From 743d8abeaffe55cefbddbd2b264be4adcac4d19c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 17 Oct 2019 00:23:46 +0200
Subject: [PATCH 0001/1292] first attempt to document and explain serialization
 tools for application developers

---
 serialize/SerialLinkedListAdapter.h | 16 +++++++++++++++-
 serialize/SerializeAdapter.h        | 14 +++++++++++++-
 serialize/SerializeIF.h             |  2 +-
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 29952c4a..44d9e15b 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -13,7 +13,21 @@
 #include <framework/serialize/SerializeIF.h>
 //This is where we need the SerializeAdapter!
 
-/**
+ /**
+ * An alternative to the AutoSerializeAdapter functions to implement the conversion
+ * of object data to data streams or vice-versa, using linked lists.
+ *
+ * All object members with a datatype are declared as SerializeElement<element_type> inside the class.
+ *
+ * Buffers with a size header inside that class can be declared with
+ * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
+ * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ *
+ * The serialization and deserialization process is done by instantiating the class and
+ * calling the serialize or deserialize function.
+ *
  * \ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fd9e1b6a..67c37493 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -7,7 +7,19 @@
 #include <framework/serialize/SerializeIF.h>
 #include <string.h>
 
-/**
+ /**
+ * This adapter provides an interface to use the SerializeIF functions
+ * with arbitrary template objects to facilitate and simplify the serialization of classes
+ * with different multiple different data types into buffers vice-versa.
+ *
+ * Examples:
+ * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
+ * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
+ * The getSerializedSize function is implemented by calling the
+ * AutoSerializeAdapter::getSerializedSize function repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
+ * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
  * \ingroup serialize
  */
 template<typename T, int>
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 701fbf56..50555d37 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -9,7 +9,7 @@
  */
 
 /**
- * Translation of objects into data streams.
+ * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  * \ingroup serialize
  */
 class SerializeIF {

From 5e3b7c36257314bab40b36c78c13c0525b08eb86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Oct 2019 13:37:09 +0200
Subject: [PATCH 0002/1292] explanation of cookie purpose added, device handler
 base indentation

---
 devicehandlers/Cookie.h              |  3 +++
 devicehandlers/DeviceHandlerBase.cpp | 27 +++++++++++++--------------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 495c8c40..618c901f 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,6 +1,9 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
 
+/**
+ * This datatype is used to identify different connection over a single interface (like RMAP or I2C)
+ */
 class Cookie{
 public:
 	virtual ~Cookie(){}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ae9199f2..750d4d4a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,20 +21,19 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(
-				MODE_OFF), submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(
-				maxDeviceReplyLen), wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(
-				StorageManagerIF::INVALID_ADDRESS), requestedRawTraffic(0), powerSwitcher(
-		NULL), IPCStore(NULL), deviceCommunicationId(deviceCommunication), communicationInterface(
-		NULL), cookie(
-		NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(
-				thermalRequestPoolId), healthHelper(this, setObjectId), modeHelper(
-				this), parameterHelper(this), childTransitionFailure(RETURN_OK), ignoreMissedRepliesCount(
-				0), fdirInstance(fdirInstance), hkSwitcher(this), defaultFDIRUsed(
-				fdirInstance == NULL), switchOffWasReported(false),executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(
-				ioBoardAddress), timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(
-				_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(
-				setDeviceSwitch) {
+		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
+		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
+		deviceCommunicationId(deviceCommunication), communicationInterface(NULL),
+		cookie(NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId),
+		deviceThermalRequestPoolId(thermalRequestPoolId), healthHelper(this, setObjectId),
+		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
+		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
+		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(ioBoardAddress),
+		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;

From 907664cea9958f1259ed19560839c26533481cf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 21 Oct 2019 11:38:13 +0200
Subject: [PATCH 0003/1292] added do performOperation where the comIF functions
 are called, some comments added in DeviceHandlerIF

---
 devicehandlers/DeviceHandlerBase.h | 18 +++++++++++-------
 devicehandlers/DeviceHandlerIF.h   |  7 ++++++-
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 756ad530..70fefe8a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,6 +33,7 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
+// Robin: We're not really using RMAP, right? Maybe we should adapt class description for that?
 /**
  * \brief This is the abstract base class for device handlers.
  *
@@ -81,7 +82,7 @@ public:
 
 
 	/**
-		 * This function is a core component and is called periodically.
+		 * This function is the device handler base core component and is called periodically.
 		 * General sequence:
 		 * If the State is SEND_WRITE:
 		 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
@@ -95,13 +96,16 @@ public:
 		 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
 		 *   	and performs depending on value specified
 		 *      by input value counter. The child class tells base class what to do by setting this value.
-		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite()
-		 *     	 Calls abstract funtions buildNomalDeviceCommand()
-		 *     	 or buildTransitionDeviceCommand()
-		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite().
+		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
+		 *       sendMessage function of #communicationInterface
+		 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
+		 *       getSendSuccess of #communicationInterface.
 		 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-		 *     - SEND_READ: Request reading data from device by calling doSendRead()
-		 *     - GET_READ: Access requested reading data by calling doGetRead()
+		 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
+		 *       requestReceiveMessage of #communcationInterface
+		 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
+		 *       readReceivedMessage of #communicationInterface
 		 * @param counter Specifies which Action to perform
 		 * @return RETURN_OK for successful execution
 		 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index fe0ee8e8..8fdd04fe 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -23,6 +23,11 @@ public:
 	 * @details The mode of the device handler must not be confused with the mode the device is in.
 	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
 	 */
+		// Robin: The first two modes (MODE_ON, MODE_OFF) are specified in hasModesIF.
+		// We could mention in a comment where those modes are located.
+		// The comments for _MODE_TO_ON have been taken from the comments in DeviceHandlerBase.cpp file.
+		// Is the same explanation valid for _MODE_TO_RAW and MODE_TO_NORMAL?
+
 //		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 //		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 		static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
@@ -30,7 +35,7 @@ public:
 		static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
 		static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
 		static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
 		static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
 		static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
 		static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF

From cbc8012198da6e94870f2b5fe63b799587092bc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 00:06:11 +0200
Subject: [PATCH 0004/1292] ioBoardAddress protected instead of private to
 allow custom initialize

---
 devicehandlers/DeviceHandlerBase.cpp |  4 ++--
 devicehandlers/DeviceHandlerBase.h   | 14 ++++++++++----
 devicehandlers/DeviceHandlerIF.h     |  6 ++----
 health/HealthHelper.h                |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  3 +--
 5 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 750d4d4a..bc87422d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,7 +21,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -31,7 +31,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
 		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), ioBoardAddress(ioBoardAddress),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 70fefe8a..45a87a8a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -141,6 +141,11 @@ public:
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
 protected:
+	/**
+	* cached from ctor for initialize()
+	*/
+	const uint32_t ioBoardAddress;
+
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
 	 */
@@ -163,6 +168,8 @@ protected:
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 	static const MessageQueueId_t NO_COMMANDER = 0;
 
+
+
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
@@ -833,6 +840,9 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
+
+
+
 private:
 
 	/**
@@ -865,10 +875,6 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
-	/**
-	 * cached from ctor for initialize()
-	 */
-	const uint32_t ioBoardAddress;
 
 	/**
 	 * Used for timing out mode transitions.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 8fdd04fe..bfa7c7b2 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -22,11 +22,9 @@ public:
 	 *
 	 * @details The mode of the device handler must not be confused with the mode the device is in.
 	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
-		// Robin: The first two modes (MODE_ON, MODE_OFF) are specified in hasModesIF.
-		// We could mention in a comment where those modes are located.
-		// The comments for _MODE_TO_ON have been taken from the comments in DeviceHandlerBase.cpp file.
-		// Is the same explanation valid for _MODE_TO_RAW and MODE_TO_NORMAL?
+
 
 //		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 //		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index a1ca2c52..24fd0d14 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -27,8 +27,8 @@ public:
 	/**
 	 * ctor
 	 *
+	 * @param owner
 	 * @param objectId the object Id to use when communication with the HealthTable
-	 * @param useAsFrom id to use as from id when sending replies, can be set to 0
 	 */
 	HealthHelper(HasHealthIF* owner, object_id_t objectId);
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 00fd73d3..5bf09f13 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -19,8 +19,7 @@ FixedTimeslotTask::~FixedTimeslotTask() {
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
 
 	//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place.
-	FixedTimeslotTask *originalTask(
-			reinterpret_cast<FixedTimeslotTask*>(argument));
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 	// Task should not start until explicitly requested
 	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
 	// but not if the scheduler is not running.

From 4db655e4898de934f6388365ec036d9d6e6b1bbe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 14:01:17 +0200
Subject: [PATCH 0005/1292] task priority order comment

---
 osal/FreeRTOS/TaskFactory.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 7b2f70a3..753da60f 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -15,6 +15,7 @@ TaskFactory* TaskFactory::instance() {
 }
 /***
  * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ * High taskPriority_ number means high priority.
  */
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,

From c6e34cada64f59757e420347dec8373401d73c7a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Oct 2019 17:15:29 +0200
Subject: [PATCH 0006/1292] documentation for DHB init function, ioBoard addres
 has default value 0 now, order in ctor changed (not used in source)

---
 devicehandlers/ChildHandlerBase.cpp  |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  9 ++++-----
 devicehandlers/DeviceHandlerBase.h   | 21 ++++++++++++++++++---
 3 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e..fb9238f7 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -7,8 +7,8 @@ ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
+		DeviceHandlerBase(setObjectId, maxDeviceReplyLen,
+				setDeviceSwitch, deviceCommunication,ioBoardAddress, thermalStatePoolId,
 				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
 				parent), childHandlerFdir(setObjectId) {
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index bc87422d..d0f9d8b2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,11 +16,10 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
+		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+		object_id_t deviceCommunication, uint32_t ioBoardAddress, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
 		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 45a87a8a..2278e1f5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -71,10 +71,10 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
+	DeviceHandlerBase(object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
-					PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication,uint32_t ioBoardAddress = 0,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
@@ -111,6 +111,21 @@ public:
 		 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
+	/**
+	 * Prerequisites to call initialize function without custom implementation:
+	 *   1. The three static framework IDs are set to respective objects in the Factory function
+	 *  	- First ID: Power Switcher ID. Example: PCDU Handler Object
+	 *  	- Second ID: Raw Data Receiver. Example: PUS Service 2 Object
+	 *  	- Third ID: Default FDIR parent ID. Example: ?
+	 *   2. Communication Interface Object for respective device.
+	 *      Example: UART Communication Interface which calls respective UART drivers
+	 *   3. Health table class has been instantiated in Factory
+	 *   4. deviceThermalRequestPoolId and deviceThermalStatePoolId are set to the respective data pool entries.
+	 *   	This is only required if thermal checking is needed. Otherwise, set both variables to
+	 *   	PoolVariableIF::NO_PARAMETER
+	 *
+	 * @return
+	 */
 	virtual ReturnValue_t initialize();
 
 	/**

From 07950b0c2bb9c3822729a225302cb685cb62ea7a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Oct 2019 00:31:45 +0200
Subject: [PATCH 0007/1292] documentation for object manager IF get function

---
 fdir/FailureIsolationBase.cpp   | 7 ++++---
 objectmanager/ObjectManagerIF.h | 7 +++++++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 4b7caac5..c65640c2 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -5,9 +5,10 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
-FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
-		eventQueue(NULL), ownerId(
-				owner), owner(NULL), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
+FailureIsolationBase::FailureIsolationBase(object_id_t owner,
+		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
+		eventQueue(NULL), ownerId(owner), owner(NULL),
+		faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
 	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
 }
 
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index aca24a24..9f58f600 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -78,6 +78,13 @@ public:
 	virtual void printList() = 0;
 };
 
+/**
+ * Used to retrieve Target Interface Pointers of objects.
+ * The object has to implement the SystemObject or SystemObjectIF at the very least,
+ * otherwise NULL will be returned.
+ * @param id
+ * @return NULL or pointer to target interface specified by template object
+ */
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	SystemObjectIF* temp = this->getSystemObject(id);

From 1631e739b8c0b3b7ab0af314309da898df7e2eae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Oct 2019 12:03:32 +0200
Subject: [PATCH 0008/1292] at91sam9g20 uses custom stdio.c, unsigned long cast
 in sprintf does not seem to work, casting (unsigned int) does, timestamp now
 visible in debug output

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 58065994..d5ce6056 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -5,6 +5,8 @@
 // to be implemented by bsp
 extern "C" void printChar(const char*);
 
+
+
 int ServiceInterfaceBuffer::overflow(int c) {
 	// Handle output
 	putChars(pbase(), pptr());
@@ -19,16 +21,18 @@ int ServiceInterfaceBuffer::overflow(int c) {
 	return 0;
 }
 
+// custom stdio.c library for at91sam9g20 chip which does not support unsigned long
+// So I cast (unsigned int) on loggerTimes
 int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %lu:%02lu:%02lu.%03lu | ",
-				this->log_message.c_str(), (unsigned long) loggerTime.hour,
-				(unsigned long) loggerTime.minute,
-				(unsigned long) loggerTime.second,
-				(unsigned long) loggerTime.usecond /1000);
+		sprintf(preamble, "%s: | %u:%02u:%02u.%03u | ",
+				this->log_message.c_str(), (unsigned int) loggerTime.hour,
+				(unsigned int)  loggerTime.minute,
+				(unsigned int)  loggerTime.second,
+				(unsigned int)  loggerTime.usecond /1000);
 		// Write log_message and time
 		this->putChars(preamble, preamble + sizeof(preamble));
 		// Handle output

From 8f1517d276aac56dc260b8ea4609204ab8e1036a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Oct 2019 21:12:11 +0200
Subject: [PATCH 0009/1292] additional comments on endianness (I hope this is
 correct)

---
 devicehandlers/DeviceHandlerBase.cpp | 2 --
 serialize/SerializeAdapter.h         | 7 +++++++
 serialize/SerializeIF.h              | 7 +++++++
 3 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d0f9d8b2..4eb9f504 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -53,7 +53,6 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-
 	if (counter == 0) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
@@ -670,7 +669,6 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
-
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 67c37493..6e2f3e5f 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -20,6 +20,13 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
+ *
+ * In the SOURCE mission , the target architecture is little endian,
+ * so any buffers must be deSerialized with bool bigEndian = false if
+ * the parameters are used in the FSFW.
+ * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * like seen in TmPacketStored.cpp for example.
+ *
  * \ingroup serialize
  */
 template<typename T, int>
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 50555d37..14f6995e 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -10,6 +10,13 @@
 
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
+ *
+ * In the SOURCE mission , the target architecture is little endian,
+ * so any buffers must be deSerialized with bool bigEndian = false if
+ * the parameters are used in the FSFW.
+ * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * like seen in TmPacketStored.cpp for example.
+ *
  * \ingroup serialize
  */
 class SerializeIF {

From 64f84d9d9ffbf2d4b357ac72ad24956b8540db07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Oct 2019 03:21:38 +0100
Subject: [PATCH 0010/1292] doc for dhb, serializeIF and SerializeAdapter

---
 devicehandlers/DeviceCommunicationIF.h |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 11 ++++++----
 devicehandlers/DeviceHandlerBase.h     | 11 ++++++----
 serialize/SerializeAdapter.h           | 28 ++++++++++++++++++++++----
 serialize/SerializeIF.h                | 14 +++++++++----
 tmtcservices/PusServiceBase.h          |  4 ++--
 6 files changed, 51 insertions(+), 19 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e0aca573..88f0d124 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -40,7 +40,7 @@ public:
 	virtual void close(Cookie *cookie) = 0;
 
 	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4eb9f504..2f16f846 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,6 +11,7 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
@@ -452,7 +453,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
-		//We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
+		// We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
 	} else {
 		//always generate a failure event, so that FDIR knows what's up
@@ -473,9 +474,9 @@ void DeviceHandlerBase::doSendRead() {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//We can't inform anyone, because we don't know which command was sent last.
-		//So, we need to wait for a timeout.
-		//but I think we can allow to ignore one missedReply.
+		// We can't inform anyone, because we don't know which command was sent last.
+		// So, we need to wait for a timeout.
+		// but I think we can allow to ignore one missedReply.
 		ignoreMissedRepliesCount++;
 		cookieInfo.state = COOKIE_UNUSED;
 	}
@@ -1266,3 +1267,5 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
+
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2278e1f5..6abfb675 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -167,7 +167,7 @@ protected:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
 	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6);
 //	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
 //	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
@@ -626,9 +626,9 @@ protected:
 	 * @param[out] foundLen length of the packet found
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c NO_VALID_REPLY no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c INVALID_REPLY a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c TOO_SHORT @c len is too short for any valid packet
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
 	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
@@ -954,6 +954,7 @@ private:
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
+	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1053,6 +1054,8 @@ private:
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 6e2f3e5f..04216c89 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -20,11 +20,31 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
+ * The boolean bigEndian specifies the endiness of the data to serialize or deSerialize.
  *
- * In the SOURCE mission , the target architecture is little endian,
- * so any buffers must be deSerialized with bool bigEndian = false if
- * the parameters are used in the FSFW.
- * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * If the target architecture is little endian (ARM), any data types created might
+ * have the wrong endiness if they are to be used for the FSFW.
+ * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * This can also be applied to uint32_t and uint64_t:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
+ *
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *
+ *   2. Perform a bitshift operation:
+ *
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] >> 8 | buffer[targetByte2];
+ *
+ *   3. Memcpy can be used when data is little-endian. Otherwise, endian-swapper has to be used.
+ *
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data);
+ *
+ * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
  * \ingroup serialize
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 14f6995e..d86349ab 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -11,10 +11,16 @@
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  *
- * In the SOURCE mission , the target architecture is little endian,
- * so any buffers must be deSerialized with bool bigEndian = false if
- * the parameters are used in the FSFW.
- * When serializing for downlink, the packets are generally serialized into big endian for the network when using a TC/UDP client
+ * If the target architecture is little endian (ARM), any data types created might
+ * have the wrong endiness if they are to be used for the FSFW.
+ * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * This can also be applied to uint32_t and uint64_t:
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
+ *   2. Perform a bitshift operation
+ *   3. @c memcpy can be used when data is little-endian. Otherwise, @c EndianSwapper has to be used.
+ *
+ * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
  * \ingroup serialize
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 782d375f..4fe13ca9 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -68,8 +68,8 @@ public:
 	 * It checks for new requests, and, if found, calls handleRequest, sends completion verification messages and deletes
 	 * the TC requests afterwards.
 	 * performService is always executed afterwards.
-	 * @return	- \c RETURN_OK if the periodic performService was successful.
-	 * 			- \c RETURN_FAILED else.
+	 * @return	\c RETURN_OK if the periodic performService was successful.
+	 * 			\c RETURN_FAILED else.
 	 */
 	ReturnValue_t performOperation(uint8_t opCode);
 	virtual uint16_t getIdentifier();

From d79f072851264ec3f9e369f2b2ccbfa7fddd3145 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Oct 2019 13:38:08 +0100
Subject: [PATCH 0011/1292] Additional documentation for DHB and CSB

---
 devicehandlers/DeviceHandlerBase.h   | 19 ++++++----
 tmtcservices/CommandingServiceBase.h | 54 +++++++++++++++++++++++++---
 2 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6abfb675..be488d35 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,24 +33,29 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-// Robin: We're not really using RMAP, right? Maybe we should adapt class description for that?
+
 /**
  * \brief This is the abstract base class for device handlers.
  *
  * Documentation: Dissertation Baetz p.138,139, p.141-149
- * SpaceWire Remote Memory Access Protocol (RMAP)
  *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, the RMAP communication and the
- * communication with commanding objects.
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
+ * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
+ *
+ * NOTE: RMAP is a legacy standard which is used for FLP.
+ * RMAP communication is not mandatory for projects implementing the FSFW.
+ * However, the communication principles are similar to RMAP as there are two write and two send calls involved.
+ *
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed. If data has been received (eg in case of an RMAP Read), the data will be interpreted.
- * The action for each step can be defined by the child class but as most device handlers share a 4-call (Read-getRead-write-getWrite) structure,
- * a default implementation is provided.
+ * For each step an RMAP action is selected and executed. If data has been received (GET_READ), the data will be interpreted.
+ * The action for each step can be defined by the child class but as most device handlers share a 4-call
+ * (sendRead-getRead-sendWrite-getWrite) structure, a default implementation is provided.
  *
  * Device handler instances should extend this class and implement the abstract functions.
  * Components and drivers can send so called cookies which are used for communication
+ * and contain information about the communcation (e.g. slave address for I2C or RMAP structs).
  *
  * \ingroup devices
  */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index ee59ffe4..f662072f 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -180,20 +180,65 @@ protected:
 	 */
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = NULL);
+
+	/**
+	 * Check the target subservice
+	 * @param subservice
+	 * @return
+	 */
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
+	 * The target message queue ID can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED
+	 *         - @c CSB or implementation specific return codes
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined,
+	 * the command is prepared by using an implementation specific CommandMessage type which is sent to
+	 * the target device. It contains all necessary information for the device to
+	 * execute telecommands.
+	 * @param message
+	 * @param subservice
+	 * @param tcData
+	 * @param tcDataLen
+	 * @param state
+	 * @param objectId
+	 * @return
+	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
 			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
+	/**
+	 * This function is responsible for the communication between the Command Service Base
+	 * and the respective PUS Commanding Service once the execution has started.
+	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
+	 * There are different translations of these replies to specify how the Command Service proceeds.
+	 * @param reply Command Message which determines how CommandServiceBase proceeds
+	 * @param previousCommand
+	 * @param state
+	 * @param optionalNextCommand
+	 * @param objectId
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 
@@ -209,7 +254,8 @@ private:
 	 * It handles replies generated by the devices and relayed by the specific service implementation.
 	 * This means that it determines further course of action depending on the return values specified
 	 * in the service implementation.
-	 * This includes the generation of TC verification messages:
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver needs to be set.
 	 *   - TM[1,5] Step Successs
 	 *   - TM[1,6] Step Failure
 	 *   - TM[1,7] Completion Success

From b51536c772c9d058b7c7a4449f8cf8ca107773ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Oct 2019 12:48:41 +0100
Subject: [PATCH 0012/1292] CSB doc correction

---
 fdir/FailureIsolationBase.h          | 4 ++++
 tmtcservices/CommandingServiceBase.h | 8 +++++---
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index cd582e39..894f6356 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -21,6 +21,10 @@ public:
 			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
 	virtual ~FailureIsolationBase();
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * This is called by the DHB in performOperation()
+	 */
 	void checkForFailures();
 	MessageQueueId_t getEventReceptionQueue();
 	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index f662072f..8ce25f00 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -64,7 +64,7 @@ public:
 	virtual ~CommandingServiceBase();
 
 	/***
-	 * This is the periodic called function
+	 * This is the periodically called function.
 	 * Handle request queue for external commands.
 	 * Handle command Queue for internal commands.
 	 * @param opCode is unused here at the moment
@@ -226,13 +226,15 @@ protected:
 	 * and the respective PUS Commanding Service once the execution has started.
 	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
 	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply Command Message which determines how CommandServiceBase proceeds
+	 * @param reply Command Message which contains information about the command
 	 * @param previousCommand
 	 * @param state
 	 * @param optionalNextCommand
 	 * @param objectId
 	 * @param isStep Flag value to mark steps of command execution
-	 * @return
+	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
+	 *         - @c INVALID_REPLY can handle unrequested replies
+	 *         - Anything else triggers a TC verification failure
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,

From 1ee445ce245b0383a3d770b44f971693ff37542f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 11:17:07 +0100
Subject: [PATCH 0013/1292] fifo typo

---
 container/FIFO.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 670a50d7..134da9b8 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -21,7 +21,7 @@ public:
 			readIndex(0), writeIndex(0), currentSize(0) {
 	}
 
-	bool emtpy() {
+	bool empty() {
 		return (currentSize == 0);
 	}
 
@@ -45,7 +45,7 @@ public:
 	}
 
 	ReturnValue_t retrieve(T *value) {
-		if (emtpy()) {
+		if (empty()) {
 			return EMPTY;
 		} else {
 			*value = data[readIndex];

From e8a16ac59cf87d27d1e79a6571a6ee11f0edc3c2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 18:21:01 +0100
Subject: [PATCH 0014/1292] dummy com if sendMessage data const

---
 devicehandlers/DeviceCommunicationIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e0aca573..88f0d124 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -40,7 +40,7 @@ public:
 	virtual void close(Cookie *cookie) = 0;
 
 	//SHOULDDO can data be const?
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;

From 3887cb8ca14f4a12a2fd446e1779b66c76096962 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 18:22:34 +0100
Subject: [PATCH 0015/1292] removed wrong include in dhb

---
 devicehandlers/DeviceHandlerBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2f16f846..1bb411b7 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,7 +11,6 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;

From 16af33a7bb52e3d9363e1e6f61e16a67783f74df Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Oct 2019 19:31:18 +0100
Subject: [PATCH 0016/1292] doc for fifo, device com if..

---
 container/FIFO.h                       |  4 +--
 container/SimpleRingBuffer.h           | 28 +++++++++++++++++++++
 devicehandlers/DeviceCommunicationIF.h | 35 +++++++++++++++++++++++++-
 serialize/SerializeAdapter.h           |  2 ++
 4 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 670a50d7..134da9b8 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -21,7 +21,7 @@ public:
 			readIndex(0), writeIndex(0), currentSize(0) {
 	}
 
-	bool emtpy() {
+	bool empty() {
 		return (currentSize == 0);
 	}
 
@@ -45,7 +45,7 @@ public:
 	}
 
 	ReturnValue_t retrieve(T *value) {
-		if (emtpy()) {
+		if (empty()) {
 			return EMPTY;
 		} else {
 			*value = data[readIndex];
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 6d7d67e1..45cb0927 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -4,12 +4,40 @@
 #include <framework/container/RingBufferBase.h>
 #include <stddef.h>
 
+/**
+ * Circular buffer implementation, useful for buffering into data streams.
+ * Note that the deleteData() has to be called to increment the read pointer
+ */
 class SimpleRingBuffer: public RingBufferBase<> {
 public:
 	SimpleRingBuffer(uint32_t size, bool overwriteOld);
 	virtual ~SimpleRingBuffer();
+
+	/**
+	 * Write to circular buffer and increment write pointer by amount
+	 * @param data
+	 * @param amount
+	 * @return
+	 */
 	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
+
+	/**
+	 * Read from circular buffer at read pointer
+	 * @param data
+	 * @param amount
+	 * @param readRemaining
+	 * @param trueAmount
+	 * @return
+	 */
 	ReturnValue_t readData(uint8_t* data, uint32_t amount, bool readRemaining = false, uint32_t* trueAmount = NULL);
+
+	/**
+	 * Delete data starting by incrementing read pointer
+	 * @param amount
+	 * @param deleteRemaining
+	 * @param trueAmount
+	 * @return
+	 */
 	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false, uint32_t* trueAmount = NULL);
 private:
 //	static const uint8_t TEMP_READ_PTR = 1;
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 88f0d124..59420861 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -4,6 +4,22 @@
 #include <framework/devicehandlers/Cookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * Documentation: Dissertation Baetz p.138
+ *
+ * This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * It works with the assumption that received data
+ * is polled by a component. There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return so-called cookies to components.
+ *
+ */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
@@ -39,7 +55,15 @@ public:
 
 	virtual void close(Cookie *cookie) = 0;
 
-	//SHOULDDO can data be const?
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return
+	 */
 	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
 
@@ -47,6 +71,15 @@ public:
 
 	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
 
+	/**
+	 * Called by DHB in the GET_WIRTE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return
+	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 04216c89..a0aab9e9 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -28,6 +28,8 @@
  * This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
+ *		The pointer *buffer will be incremented automatically by the typeSize of data,
+ *		so this function can be called on &buffer without adjusting pointer position
  *
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);

From 46986f69e4a17923717464c120f4d227df561618 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Nov 2019 23:30:12 +0100
Subject: [PATCH 0017/1292] serialize tools more documentation

---
 serialize/SerialBufferAdapter.cpp       |  8 ++++----
 serialize/SerialBufferAdapter.h         |  8 ++++++++
 serialize/SerialFixedArrayListAdapter.h | 11 +++++++++++
 serialize/SerialLinkedListAdapter.h     | 10 +++++++++-
 serialize/SerializeIF.h                 |  6 +++---
 5 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3ed083bf..c5fcfb57 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -5,15 +5,15 @@
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(buffer), buffer(NULL), bufferLength(
+		T bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(NULL), bufferLength(
 				bufferLength) {
 }
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
-		bool serializeLenght) :
-		serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
+		bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(NULL), buffer(buffer), bufferLength(
 				bufferLength) {
 }
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7cd75d55..7d192bb4 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -5,6 +5,14 @@
 #include <framework/serialize/SerializeAdapter.h>
 
 /**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<T(will be uint8_t mostly)>> serialBufferElement
+ *
  * \ingroup serialize
  */
 template<typename T>
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 16919b62..821e8710 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,6 +5,17 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
+ * This adapter provides an interface for SerializeIF to serialize and deserialize
+ * buffers with a header containing the buffer length.
+ *
+ * Can be used by SerialLinkedListAdapter.
+ *
+ * Buffers with a size header inside that class can be declared with
+ * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
+ * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ *
  * \ingroup serialize
  */
 template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 44d9e15b..08d385ee 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -17,12 +17,20 @@
  * An alternative to the AutoSerializeAdapter functions to implement the conversion
  * of object data to data streams or vice-versa, using linked lists.
  *
- * All object members with a datatype are declared as SerializeElement<element_type> inside the class.
+ * All object members with a datatype are declared as SerializeElement<element_type> inside the class
+ * implementing this adapter.
  *
  * Buffers with a size header inside that class can be declared with
  * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
  * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * Please note that a direct link from a linked element to a SerialFixedArrayListAdapter element is not possible and a
+ * helper needs to be used by calling <LinkedElement>.setNext(&linkHelper)
+ * and initialising the link helper as linkHelper(&SerialFixedArrayListAdapterElement).
+ *
+ * For buffers with no size header, declare
+ * SerializeElement<SerializeBufferAdapter<T>> and initialise the buffer adapter in the constructor.
+ *
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
  * The serialization and deserialization process is done by instantiating the class and
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d86349ab..cada1e72 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -11,14 +11,14 @@
 /**
  * An interface for alle classes which require translation of objects data into data streams and vice-versa.
  *
- * If the target architecture is little endian (ARM), any data types created might
+ * If the target architecture is little endian (e.g. ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
  * This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
  *   2. Perform a bitshift operation
- *   3. @c memcpy can be used when data is little-endian. Otherwise, @c EndianSwapper has to be used.
+ *   3. @c memcpy can be used when data is in little-endian format. Otherwise, @c EndianSwapper has to be used in conjuction.
  *
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.

From 8eb1a5b13e2fccf21176aed9a6a27287196fd236 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 00:47:46 +0100
Subject: [PATCH 0018/1292] proposal 1: expectedReplies parameter is set in
 insertInCommandAndReplyMap, default value stays one. overriding
 enableReplyInReplyMap is not necessary anymore.second proposal: the commander
 id is supplied in the interpretDeviceReply function, so we don't have to look
 for it in the DeviceCommandMap. was it removed at some point because it is
 listed in the documentation?

---
 action/ActionHelper.h                  |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 32 +++++++++++++++++---------
 devicehandlers/DeviceHandlerBase.h     | 16 ++++++++-----
 modes/ModeHelper.h                     | 13 ++++++++++-
 tmtcservices/CommandingServiceBase.cpp | 11 ++++-----
 5 files changed, 49 insertions(+), 25 deletions(-)

diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 6ba6dd89..a72e3654 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -74,7 +74,7 @@ public:
 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
+	MessageQueueIF* queueToUse;//!< Queue to be used as response sender, has to be set with @c setQueueToUse
 	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)
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1bb411b7..c92cac33 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -255,9 +255,9 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-//No need to check, as we may try to insert multiple times.
-	insertInCommandMap(deviceCommand);
+		uint8_t periodic, uint8_t expectedReplies, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+	//No need to check, as we may try to insert multiple times.
+	insertInCommandMap(deviceCommand,expectedReplies);
 	if (hasDifferentReplyId) {
 		return insertInReplyMap(replyId, maxDelayCycles, periodic);
 	} else {
@@ -283,9 +283,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
+		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
 	DeviceCommandInfo info;
-	info.expectedReplies = 0;
+	info.expectedReplies = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -712,6 +712,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		DeviceCommandId_t foundId, uint32_t foundLen) {
 	ReturnValue_t result;
 	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
+	MessageQueueId_t commander;
 
 	if (iter == deviceReplyMap.end()) {
 		replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -728,7 +729,17 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		} else {
 			info->delayCycles = 0;
 		}
-		result = interpretDeviceReply(foundId, receivedData);
+
+		DeviceCommandMap::iterator commandIter = deviceCommandMap.find(foundId);
+		// could be a reply only packet
+		if(commandIter == deviceCommandMap.end()) {
+			commander = 0;
+		}
+		else {
+			commander = commandIter->second.sendReplyTo;
+		}
+
+		result = interpretDeviceReply(foundId, receivedData,commander);
 		if (result != RETURN_OK) {
 			//Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -798,7 +809,7 @@ void DeviceHandlerBase::modeChanged(void) {
 }
 
 ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command, uint8_t expectedReplies,
+		DeviceCommandMap::iterator command,/* uint8_t expectedReplies, */
 		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
 	DeviceReplyMap::iterator iter;
 	if (useAlternativeId) {
@@ -810,7 +821,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		command->second.expectedReplies = expectedReplies;
+		// command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
@@ -1108,8 +1119,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
 			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-			true);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1122,7 +1132,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-//Try to cast to DataSet and commit data.
+	//Try to cast to DataSet and commit data.
 	if (!neverInDataPool) {
 		DataSet* dataSet = dynamic_cast<DataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index be488d35..89f96503 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -576,8 +576,9 @@ protected:
 	 *		 			Default is aperiodic (0)
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
+	// Proposal: Set expected replies for a command in insertInCommandAndReplyMap so we don't have to overwrite enableReplyInReplyMap
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, uint8_t periodic = 0, uint8_t expectedReplies = 1,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -594,7 +595,7 @@ protected:
 	 * @param deviceCommand The command to add
 	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
 	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand, uint8_t expectedReplies = 1);
 	/**
 	 * This is a helper method to facilitate updating entries in the reply map.
 	 * @param deviceCommand		Identifier of the reply to update.
@@ -644,18 +645,19 @@ protected:
 	 *
 	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
 	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
+	 * a TM packet or stores the data in the DataPool depending on whether it was an external command.
 	 * No packet length is given, as it should be defined implicitly by the id.
 	 *
 	 * @param id the id found by scanForReply()
 	 * @param packet
-	 * @param commander the one who initiated the command, is 0 if not external commanded
+	 * @param commander the one who initiated the command, is 0 if not external commanded.
+	 *        UPDATE: This parameter does not exist anymore. Why?
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
 	 */
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+			const uint8_t *packet, MessageQueueId_t commander = 0) = 0;
 
 	/**
 	 * Construct a command reply containing a raw reply.
@@ -723,13 +725,15 @@ protected:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
+	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
 	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
 	 * 				do not expect a reply.
 	 */
+	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			uint8_t expectedReplies = 1, bool useAlternateId = false,
+			/* uint8_t expectedReplies = 0 */ bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 87f6d411..b23eb69e 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -16,11 +16,17 @@ public:
 	ModeHelper(HasModesIF *owner);
 	virtual ~ModeHelper();
 
+	/**
+	 * This is used by DHB to handle all mode messages issued by a service
+	 * @param message
+	 * @return
+	 */
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object (assembly or subsystem object).
+	 *        Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
@@ -28,6 +34,11 @@ public:
 
 	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
 
+	/**
+	 * Used to notify
+	 * @param mode
+	 * @param submode
+	 */
 	void modeChanged(Mode_t mode, Submode_t submode);
 
 	void startTimer(uint32_t timeoutMs);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b9042..ec65492d 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -11,12 +11,11 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
 		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
-				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
-		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
-				numberOfParallelCommands), failureParameter1(0), failureParameter2(
-				0), packetSource(setPacketSource), packetDestination(
-				setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeout_seconds(commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL),
+		TCStore(NULL), commandQueue(NULL), requestQueue(NULL), commandMap(numberOfParallelCommands),
+		failureParameter1(0), failureParameter2(0), packetSource(setPacketSource),
+		packetDestination(setPacketDestination),executingTask(NULL) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }

From 12f51575eb42bffc9e2cf5a72a5678975f87db34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 00:53:05 +0100
Subject: [PATCH 0019/1292] removed a flag by accident, fixed now

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c92cac33..3018a076 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1119,7 +1119,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
 			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
 
 		}
 	} else { //unrequested/aperiodic replies

From cb919ada2a99b818624d05a4e4fdfeb85e9b8174 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 01:55:40 +0100
Subject: [PATCH 0020/1292] assuming that a default value of 0 for
 expectedReplies is needed, I introduced a new variable into
 DeviceCommandInfo, which stores another number of replies expected. this
 value is assigned in enableReplyInReplyMap. That way, the initial value of 0
 remains the same (if it was needed), and is only set to another desired value
 if a write was sent

---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++--
 devicehandlers/DeviceHandlerBase.h   | 9 +++++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 3018a076..491d792b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -285,7 +285,8 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
 	DeviceCommandInfo info;
-	info.expectedReplies = expectedReplies;
+	info.expectedReplies = 0;
+	info.expectedRepliesWhenEnablingReplyMap = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -821,7 +822,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		// command->second.expectedReplies = expectedReplies;
+		command->second.expectedReplies = command->second.expectedRepliesWhenEnablingReplyMap;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 89f96503..ad4a2203 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -704,7 +704,8 @@ protected:
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.
-		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected.
+		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
+		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 
@@ -732,8 +733,12 @@ protected:
 	 * 				do not expect a reply.
 	 */
 	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
+	// Replies are only checked when a write was issued and the default value here was one, so
+	// it should be possible to set this in the DeviceCommandMap with default value one.
+	// UPDATE: The default value of 0 when inserting into command and reply map is retained now by introducing a new
+	// variable in the DeviceCommandInfo which specifies expected replies if this function is called.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			/* uint8_t expectedReplies = 0 */ bool useAlternateId = false,
+			/* uint8_t expectedReplies = 1, */ bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**

From e7f7625adf27263aec16580fa70ca137e412aef6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 4 Nov 2019 11:06:59 +0100
Subject: [PATCH 0021/1292] removed wrong include

---
 devicehandlers/DeviceHandlerBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2f16f846..1bb411b7 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -11,7 +11,6 @@
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <mission/test/DummyCookie.h>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;

From b594bc2a9719b6ffb99cb3fdaf4813c688576158 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Nov 2019 19:25:00 +0100
Subject: [PATCH 0022/1292] removed obsolete comment

---
 action/ActionHelper.h                  |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 28 ++++++++------------------
 devicehandlers/DeviceHandlerBase.h     | 19 +++++------------
 modes/ModeHelper.h                     | 13 +-----------
 tmtcservices/CommandingServiceBase.cpp | 11 +++++-----
 5 files changed, 21 insertions(+), 52 deletions(-)

diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a72e3654..6ba6dd89 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -74,7 +74,7 @@ public:
 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 @c setQueueToUse
+	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)
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 491d792b..6150954d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -255,9 +255,9 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, uint8_t expectedReplies, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-	//No need to check, as we may try to insert multiple times.
-	insertInCommandMap(deviceCommand,expectedReplies);
+		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+//No need to check, as we may try to insert multiple times.
+	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
 		return insertInReplyMap(replyId, maxDelayCycles, periodic);
 	} else {
@@ -283,10 +283,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand, uint8_t expectedReplies) {
+		DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
-	info.expectedRepliesWhenEnablingReplyMap = expectedReplies;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
 	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
@@ -713,7 +712,6 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		DeviceCommandId_t foundId, uint32_t foundLen) {
 	ReturnValue_t result;
 	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
-	MessageQueueId_t commander;
 
 	if (iter == deviceReplyMap.end()) {
 		replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -730,17 +728,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 		} else {
 			info->delayCycles = 0;
 		}
-
-		DeviceCommandMap::iterator commandIter = deviceCommandMap.find(foundId);
-		// could be a reply only packet
-		if(commandIter == deviceCommandMap.end()) {
-			commander = 0;
-		}
-		else {
-			commander = commandIter->second.sendReplyTo;
-		}
-
-		result = interpretDeviceReply(foundId, receivedData,commander);
+		result = interpretDeviceReply(foundId, receivedData);
 		if (result != RETURN_OK) {
 			//Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
@@ -810,7 +798,7 @@ void DeviceHandlerBase::modeChanged(void) {
 }
 
 ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command,/* uint8_t expectedReplies, */
+		DeviceCommandMap::iterator command, uint8_t expectedReplies,
 		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
 	DeviceReplyMap::iterator iter;
 	if (useAlternativeId) {
@@ -822,7 +810,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
-		command->second.expectedReplies = command->second.expectedRepliesWhenEnablingReplyMap;
+		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
 		return NO_REPLY_EXPECTED;
@@ -1133,7 +1121,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-	//Try to cast to DataSet and commit data.
+//Try to cast to DataSet and commit data.
 	if (!neverInDataPool) {
 		DataSet* dataSet = dynamic_cast<DataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ad4a2203..040c2190 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -576,9 +576,8 @@ protected:
 	 *		 			Default is aperiodic (0)
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
-	// Proposal: Set expected replies for a command in insertInCommandAndReplyMap so we don't have to overwrite enableReplyInReplyMap
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0, uint8_t expectedReplies = 1,
+			uint16_t maxDelayCycles, uint8_t periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -595,7 +594,7 @@ protected:
 	 * @param deviceCommand The command to add
 	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
 	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand, uint8_t expectedReplies = 1);
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
 	/**
 	 * This is a helper method to facilitate updating entries in the reply map.
 	 * @param deviceCommand		Identifier of the reply to update.
@@ -645,19 +644,17 @@ protected:
 	 *
 	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
 	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether it was an external command.
+	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
 	 * No packet length is given, as it should be defined implicitly by the id.
 	 *
 	 * @param id the id found by scanForReply()
 	 * @param packet
-	 * @param commander the one who initiated the command, is 0 if not external commanded.
-	 *        UPDATE: This parameter does not exist anymore. Why?
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
 	 */
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet, MessageQueueId_t commander = 0) = 0;
+			const uint8_t *packet) = 0;
 
 	/**
 	 * Construct a command reply containing a raw reply.
@@ -726,19 +723,13 @@ protected:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
-	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
 	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
 	 * 				do not expect a reply.
 	 */
-	// Proposal: Set expected replies in insertInCommandAndReplyMap so we don't have to overwrite that function anymore.
-	// Replies are only checked when a write was issued and the default value here was one, so
-	// it should be possible to set this in the DeviceCommandMap with default value one.
-	// UPDATE: The default value of 0 when inserting into command and reply map is retained now by introducing a new
-	// variable in the DeviceCommandInfo which specifies expected replies if this function is called.
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			/* uint8_t expectedReplies = 1, */ bool useAlternateId = false,
+			uint8_t expectedReplies = 1, bool useAlternateId = false,
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index b23eb69e..87f6d411 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -16,17 +16,11 @@ public:
 	ModeHelper(HasModesIF *owner);
 	virtual ~ModeHelper();
 
-	/**
-	 * This is used by DHB to handle all mode messages issued by a service
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object (assembly or subsystem object).
-	 *        Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
@@ -34,11 +28,6 @@ public:
 
 	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
 
-	/**
-	 * Used to notify
-	 * @param mode
-	 * @param submode
-	 */
 	void modeChanged(Mode_t mode, Submode_t submode);
 
 	void startTimer(uint32_t timeoutMs);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index ec65492d..d70b9042 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -11,11 +11,12 @@ CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
 		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeout_seconds(commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL),
-		TCStore(NULL), commandQueue(NULL), requestQueue(NULL), commandMap(numberOfParallelCommands),
-		failureParameter1(0), failureParameter2(0), packetSource(setPacketSource),
-		packetDestination(setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
+				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
+		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
+				numberOfParallelCommands), failureParameter1(0), failureParameter2(
+				0), packetSource(setPacketSource), packetDestination(
+				setPacketDestination),executingTask(NULL) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }

From bf7bc342ff2bb816d910bd2c142661fecd25c867 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Nov 2019 19:30:02 +0100
Subject: [PATCH 0023/1292] Revert "documentation for DHB init function,
 ioBoard addres has default value 0 now, order in ctor changed (not used in
 source)"

This reverts commit c6e34cada64f59757e420347dec8373401d73c7a.
---
 devicehandlers/ChildHandlerBase.cpp  |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  9 +++++----
 devicehandlers/DeviceHandlerBase.h   | 21 +++------------------
 3 files changed, 10 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index fb9238f7..50a5c07e 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -7,8 +7,8 @@ ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication,ioBoardAddress, thermalStatePoolId,
+		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
+				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
 				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
 				parent), childHandlerFdir(setObjectId) {
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6150954d..def9a724 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,10 +16,11 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		object_id_t deviceCommunication, uint32_t ioBoardAddress, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
+DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
+		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
+		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
 		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 040c2190..03e35727 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -76,10 +76,10 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(object_id_t setObjectId,
+	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication,uint32_t ioBoardAddress = 0,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
+					PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
@@ -116,21 +116,6 @@ public:
 		 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
-	/**
-	 * Prerequisites to call initialize function without custom implementation:
-	 *   1. The three static framework IDs are set to respective objects in the Factory function
-	 *  	- First ID: Power Switcher ID. Example: PCDU Handler Object
-	 *  	- Second ID: Raw Data Receiver. Example: PUS Service 2 Object
-	 *  	- Third ID: Default FDIR parent ID. Example: ?
-	 *   2. Communication Interface Object for respective device.
-	 *      Example: UART Communication Interface which calls respective UART drivers
-	 *   3. Health table class has been instantiated in Factory
-	 *   4. deviceThermalRequestPoolId and deviceThermalStatePoolId are set to the respective data pool entries.
-	 *   	This is only required if thermal checking is needed. Otherwise, set both variables to
-	 *   	PoolVariableIF::NO_PARAMETER
-	 *
-	 * @return
-	 */
 	virtual ReturnValue_t initialize();
 
 	/**

From 801bd4d7ebce3ce32eab46e561dec5bc95401c4a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:07:26 +0100
Subject: [PATCH 0024/1292] debug interface for dhb created. This is useful to
 track states or values in child handler. some documentation added. New
 doxygen group for interfaced added.

---
 action/HasActionsIF.h                |  6 +++++-
 devicehandlers/DeviceHandlerBase.cpp |  8 ++++++--
 devicehandlers/DeviceHandlerBase.h   | 12 ++++++++++++
 events/EventManager.cpp              |  7 ++++---
 modes/ModeHelper.cpp                 |  2 +-
 power/PowerSwitchIF.h                |  9 +++++++--
 6 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index f30fcb45..4d66ad1f 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -7,8 +7,10 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 /**
- * \brief Interface for component which uses actions
+ * @brief
+ * Interface for component which uses actions
  *
+ * @details
  * This interface is used to execute actions in the component. Actions, in the sense of this interface, are activities with a well-defined beginning and
  * end in time. They may adjust sub-states of components, but are not supposed to change
  * the main mode of operation, which is handled with the HasModesIF described below.
@@ -23,6 +25,8 @@
  * parameters and immediately start execution of the action. It is, however, not required to
  * immediately finish execution. Instead, this may be deferred to a later point in time, at
  * which the component needs to inform the caller about finished or failed execution.
+ *
+ * \ingroup interfaces
  */
 class HasActionsIF {
 public:
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index def9a724..35a987f3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -834,8 +834,9 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
-					== PowerSwitchIF::SWITCH_OFF) {
+			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
+				== PowerSwitchIF::SWITCH_OFF)
+			{
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -1267,4 +1268,7 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
+}
+
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 03e35727..4938e019 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -553,6 +553,18 @@ protected:
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
 
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode. An optional position tracker can be supplied
+	 *          to provide the child handler a way to know where the debugInterface was called
+	 *
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0);
+
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 01334bac..46c53752 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -137,9 +137,10 @@ void EventManager::printEvent(EventMessage* message) {
 			error << "0x" << std::hex << message->getReporter() << std::dec;
 		}
 		error << " reported " << translateEvents(message->getEvent()) << " ("
-				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-				<< message->getParameter1() << " P2: 0x"
-				<< message->getParameter2() << std::dec << std::endl;
+				<< std::dec << message->getEventId() << ") " << std::endl;
+
+		error << std::hex << "P1 Hex: 0x" << message->getParameter1() << ", P1 Dec: " << std::dec << message->getParameter1() << std::endl;
+		error << std::hex << "P2 Hex: 0x" << message->getParameter2() << ", P2 Dec: " <<  std::dec << message->getParameter2() << std::endl;
 		break;
 	}
 
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 7b98bdc6..d9266c35 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,6 +1,7 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/modes/ModeHelper.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
 		theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode(
@@ -42,7 +43,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		}
 
 		countdown.setTimeout(timeout);
-
 		owner->startTransition(mode, submode);
 	}
 		break;
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 1c4c06f7..f25589c4 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -11,8 +11,13 @@
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
- * This interface defines a connection to a device that is capable of turning on and off
- * switches of devices identified by a switch ID.
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
  */
 class PowerSwitchIF : public HasReturnvaluesIF {
 public:

From ee765eafc766d9a4a1053d3d685d7d63e6f9f95f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:17:54 +0100
Subject: [PATCH 0025/1292] ioBoardAddress renamed to logicalAddress

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++----
 devicehandlers/DeviceHandlerBase.h   | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 35a987f3..fd8d6141 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,12 +16,12 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t ioBoardAddress,
+DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId),ioBoardAddress(ioBoardAddress), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId),logicalAddress(logicalAddress_), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -589,7 +589,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	result = communicationInterface->open(&cookie, ioBoardAddress,
+	result = communicationInterface->open(&cookie, logicalAddress,
 			maxDeviceReplyLen);
 	if (result != RETURN_OK) {
 		return result;
@@ -750,7 +750,7 @@ ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
 			DeviceCommunicationIF>(newChannelId);
 
 	if (newCommunication != NULL) {
-		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
 				maxDeviceReplyLen);
 		if (result != RETURN_OK) {
 			return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4938e019..8f7f065a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -76,7 +76,7 @@ public:
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 */
-	DeviceHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
+	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
 					PoolVariableIF::NO_PARAMETER,
@@ -149,7 +149,7 @@ protected:
 	/**
 	* cached from ctor for initialize()
 	*/
-	const uint32_t ioBoardAddress;
+	const uint32_t logicalAddress;
 
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF

From 537e2ceb18ddd360176fddec37331bb952f8c674 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 13:29:12 +0100
Subject: [PATCH 0026/1292] Getter method for logicalAddress

---
 devicehandlers/DeviceHandlerBase.cpp |  9 ++++++---
 devicehandlers/DeviceHandlerBase.h   | 17 +++++++++++------
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index fd8d6141..09c27c87 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -21,7 +21,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId),logicalAddress(logicalAddress_), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
+		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
 		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
 		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
@@ -31,7 +31,7 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(),
+		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
@@ -1018,6 +1018,7 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 	}
 }
 
+
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
 	ReturnValue_t result;
@@ -1271,4 +1272,6 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
 }
 
-
+uint32_t DeviceHandlerBase::getLogicalAddress() {
+	return logicalAddress;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8f7f065a..4c83b230 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -146,11 +146,6 @@ public:
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
 protected:
-	/**
-	* cached from ctor for initialize()
-	*/
-	const uint32_t logicalAddress;
-
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
 	 */
@@ -763,6 +758,11 @@ protected:
 	 */
 	virtual bool dontCheckQueue();
 
+	/**
+	 * Used to retrieve logical address
+	 * @return
+	 */
+	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
 
 	bool isAwaitingReply();
@@ -775,7 +775,6 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
-
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -862,6 +861,8 @@ protected:
 
 private:
 
+
+
 	/**
 	 * State a cookie is in.
 	 *
@@ -892,6 +893,10 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
+	/**
+	* cached from ctor for initialize()
+	*/
+	const uint32_t logicalAddress;
 
 	/**
 	 * Used for timing out mode transitions.

From b8af3b5e3df66e67c8fa7e0e99b6d5b2554deef4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Nov 2019 18:15:45 +0100
Subject: [PATCH 0027/1292] debugInterface extended

---
 devicehandlers/DeviceHandlerBase.cpp | 14 +++++++-------
 devicehandlers/DeviceHandlerBase.h   |  9 +++++----
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 09c27c87..92232e3d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -33,14 +33,15 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
 		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
-			CommandMessage::MAX_MESSAGE_SIZE);
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+{
+	commandQueue = QueueFactory::instance()->
+			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == NULL) {
-		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFDIRParentId);
+		this->fdirInstance =
+				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
 	}
 }
 
@@ -468,7 +469,6 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-
 	result = communicationInterface->requestReceiveMessage(cookie);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
@@ -1269,7 +1269,7 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker) {
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
 }
 
 uint32_t DeviceHandlerBase::getLogicalAddress() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c83b230..c50823d9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -553,12 +553,13 @@ protected:
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
-	 *          to track values like mode. An optional position tracker can be supplied
-	 *          to provide the child handler a way to know where the debugInterface was called
-	 *
+	 *          to track values like mode.
+	 * @param positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.

From 2b44e1c9c4aa5e516114a6adb922e860c5044417 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 Nov 2019 13:08:02 +0100
Subject: [PATCH 0028/1292] CCSDS sscanf function adapted for atmel stdio.c
 (see comments)

---
 timemanager/CCSDSTime.cpp | 43 +++++++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 32032716..2eb6c4b5 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -154,32 +154,41 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
-			&month, &day, &hour, &minute, &second);
-	if (count == 6) {
+	// In the size optimized nano library used by ATMEL, floating point conversion
+	// is not allowed. There is a linker flag to allow it apparently, but I
+	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
+	// but we propably should include this). Using floats with sscanf is also expensive.
+	// Furthermore, the stdio.c library by ATMEL can't resolve the %hhi specifiers
+	// Therefore, I adapted this function.
+	int year;
+	int month;
+	int day;
+	int hour;
+	int minute;
+	int second;
+	int usecond;
+	// try Code A (yyyy-mm-dd)
+	//int count = sscanf((char *) from, "%4hi-%2hi-%2hiT%2hi:%2hi:%fZ", &year,
+	//		&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
+				&month, &day, &hour, &minute, &second, &usecond);
+	if (count == 7) {
 		to->year = year;
 		to->month = month;
 		to->day = day;
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
+		to->usecond = usecond;//(second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 
-	//try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4i-%3iT%2i:%2i:%2i.%iZ", &year, &day,
+			&hour, &minute, &second, &usecond);
+	if (count == 6) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear((uint16_t)day,(uint16_t) year,(uint8_t *) &month,
 				&tempDay);
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
@@ -190,7 +199,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
+		to->usecond = usecond;
 		return RETURN_OK;
 	}
 

From 2f14fd5d4d67d2b8223b115d2c5d421cccecffb5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Nov 2019 22:45:53 +0100
Subject: [PATCH 0029/1292] Cant reach mode reason getter function added

---
 modes/ModeMessage.cpp | 4 ++++
 modes/ModeMessage.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 62fea7e4..1d3baad5 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -16,6 +16,10 @@ ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t com
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
 void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index fad34726..0a72aee0 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -24,6 +24,7 @@ public:
 	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
 	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
 	//SHOULDDO is there a way we can transmit a returnvalue when responding that the mode is wrong, so we can give a nice failure code when commanded by PUS?
+	// shouldn't that possible with parameter 2 when submode only takes 1 byte?
 	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
 	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
 	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
@@ -34,6 +35,7 @@ public:
 	static ReturnValue_t setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
 	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
 	static void clear(CommandMessage* message);
 };
 

From 2039aa56658923cb4127fddb409c251fdb8d55af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 Nov 2019 00:14:39 +0100
Subject: [PATCH 0030/1292] Service Interface Stream buffer size higher to
 print long buffers (like nav data)

---
 serviceinterface/ServiceInterfaceBuffer.h |  2 +-
 tmtcservices/PusServiceBase.cpp           | 10 +++++-----
 tmtcservices/PusServiceBase.h             |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b42c8a19..9a5f4ef8 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = 255;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index c8f6accf..6e105325 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -23,14 +23,14 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	TmTcMessage message;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId() << std::dec << " returned: " << status << std::endl;
+		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId()
+		// << std::dec << " returned: " << status << std::endl;
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
-//			info << "Service " << (uint16_t) this->serviceId << ": new packet!"
-//					<< std::endl;
+			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
 
 			ReturnValue_t return_code = this->handleRequest();
-			//		debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
+			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
 			if (return_code == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
 						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
@@ -44,7 +44,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 			errorParameter2 = 0;
 		} else if (status == MessageQueueIF::EMPTY) {
 			status = RETURN_OK;
-			//		debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
+			// debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
 			break;
 		} else {
 
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 4fe13ca9..2b5e8b67 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -52,7 +52,7 @@ public:
 	 * Success or Failure Reports are generated automatically after execution of this method.
 	 * If a Telecommand can not be executed within one call cycle, this Base class is not the right parent.
 	 * The child class may add additional error information in #errorParameters which are attached to the generated
-	 * verification message.
+	 * verification message. Subservice checking should be implemented in this method.
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */

From 10c24e39a31293ba54ee8bfdbb2f3835b91dad9e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 Nov 2019 19:56:05 +0100
Subject: [PATCH 0031/1292] new returnvalue for scanForReply to ignore full
 packet

---
 devicehandlers/DeviceCommunicationIF.h |  6 ++++--
 devicehandlers/DeviceHandlerBase.cpp   |  2 ++
 devicehandlers/DeviceHandlerBase.h     | 14 +++++++++-----
 3 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 59420861..10ad2776 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -62,7 +62,8 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return
+	 * @return @c RETURN_OK for successfull send
+	 *         Everything else triggers sending failed event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
 			uint32_t len) = 0;
@@ -78,7 +79,8 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return
+	 * @return @c RETURN_OK for successfull receive
+	 *         Everything else triggers receiving failed with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 92232e3d..0b35effd 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -537,6 +537,8 @@ void DeviceHandlerBase::doGetRead() {
 				break;
 			case IGNORE_REPLY_DATA:
 				break;
+			case IGNORE_FULL_PACKET:
+				return;
 			default:
 				//We need to wait for timeout.. don't know what command failed and who sent it.
 				replyRawReplyIfnotWiretapped(receivedData, foundLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c50823d9..b5ffa2ee 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -153,7 +153,8 @@ protected:
 
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
 	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
 //	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
 //	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
@@ -607,6 +608,7 @@ protected:
 	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Scans a buffer for a valid reply.
 	 *
@@ -618,15 +620,17 @@ protected:
 	 * Errors should be reported directly, the base class does NOT report any errors based on the return
 	 * value of this function.
 	 *
-	 * @param start start of data
-	 * @param len length of data
-	 * @param[out] foundId the id of the packet starting at @c start
-	 * @param[out] foundLen length of the packet found
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
 	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
 	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
 	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
+	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
 	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,

From 37a70df24496dd0924969c4f52c960ed80d5a1d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 1 Dec 2019 17:48:05 +0100
Subject: [PATCH 0032/1292] SerialBufferAdapter can process uint32_t * buffers
 now

---
 datapool/DataPool.h                     |  2 +-
 internalError/InternalErrorReporter.cpp |  7 +++---
 serialize/SerialBufferAdapter.cpp       | 13 ++++++++--
 serialize/SerialBufferAdapter.h         | 33 ++++++++++++++++++++++---
 4 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/datapool/DataPool.h b/datapool/DataPool.h
index 6e38dc1b..a9af8af0 100644
--- a/datapool/DataPool.h
+++ b/datapool/DataPool.h
@@ -29,7 +29,7 @@
  *	\brief		This class represents the OBSW global data-pool.
  *
  *	\details	All variables are registered and space is allocated in an initialization
- *				function, which is passed do the constructor.
+ *				function, which is passed to the constructor.
  *				Space for the variables is allocated on the heap (with a new call).
  *				The data is found by a data pool id, which uniquely represents a variable.
  *				Data pool variables should be used with a blackboard logic in mind,
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 9a8ede00..81c4a0e5 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -8,10 +8,9 @@
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
 		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId), tmPoolId(
-				tmPoolId), storePoolId(
-				storePoolId), queueHits(0), tmHits(0), storeHits(
-				0) {
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index c5fcfb57..9a8e6f06 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,8 +1,6 @@
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <cstring>
 
-
-
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
 		T bufferLength, bool serializeLength) :
@@ -17,6 +15,13 @@ SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
 				bufferLength) {
 }
 
+template<typename T>
+SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
+		T bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
+		bufferLength(bufferLength*4) {
+}
+
 template<typename T>
 SerialBufferAdapter<T>::~SerialBufferAdapter() {
 }
@@ -86,6 +91,10 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	}
 }
 
+template<typename T>
+uint8_t * SerialBufferAdapter<T>::getBuffer() {
+	return buffer;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7d192bb4..7496c137 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -11,16 +11,39 @@
  * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
  *
  * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<T(will be uint8_t mostly)>> serialBufferElement
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement
  *
  * \ingroup serialize
  */
 template<typename T>
 class SerialBufferAdapter: public SerializeIF {
 public:
-	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLenght = false);
-	SerialBufferAdapter(uint8_t* buffer, T bufferLength,
-			bool serializeLenght = false);
+	/**
+	 * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+	 * Type of length can be supplied as template type.
+	 * @param buffer
+	 * @param bufferLength
+	 * @param serializeLength
+	 */
+	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
+
+	/**
+	 * Constructoor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * Type of length can be supplied as template type.
+	 * @param buffer
+	 * @param bufferLength
+	 * @param serializeLength
+	 */
+	SerialBufferAdapter(uint8_t* buffer, T bufferLength, bool serializeLength = false);
+
+	/**
+	 * Constructoor for non-constant uint32_t buffer. Length field can be serialized optionally.
+	 * Type of length can be supplied as template type.
+	 * @param buffer
+	 * @param bufferLength
+	 * @param serializeLength
+	 */
+	SerialBufferAdapter(uint32_t* buffer,T bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -31,6 +54,8 @@ public:
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
+
+	uint8_t * getBuffer();
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;

From 9c3a9323b7ee50685fd23b57c9d1b39445c43a18 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 3 Dec 2019 19:30:37 +0100
Subject: [PATCH 0033/1292] some doc change proposals while writing hk service.
 Added Type.h in PoolRawAccess.h, compiler error when not doing that

---
 datapool/PoolRawAccess.h             |  6 +--
 datapool/PoolVariable.h              |  3 +-
 devicehandlers/DeviceHandlerBase.h   | 63 ++++++++++++++--------------
 objectmanager/ObjectManagerIF.h      |  6 +--
 tmtcservices/AcceptsTelecommandsIF.h |  2 +-
 5 files changed, 38 insertions(+), 42 deletions(-)

diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3e2bd7ae..9a3000c0 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -3,6 +3,7 @@
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/globalfunctions/Type.h>
 
 /**
  * This class allows accessing Data Pool variables as raw bytes.
@@ -79,9 +80,8 @@ public:
 	~PoolRawAccess();
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
-	 * 			array entry "index". Example: If the original data pool array consists of an double
-	 * 			array of size four, getEntry(1) returns &(this->value[8]).
+	 * \details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
 	 */
 	uint8_t* getEntry();
 	/**
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 25345c0a..2c48ca3e 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -112,8 +112,7 @@ public:
 	 * 					corresponds to.
 	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
 	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
+	 * \param setReadWriteMode
 	 */
 	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
 			ReadWriteMode_t setReadWriteMode) :
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b5ffa2ee..d489ada1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -35,14 +35,14 @@ class StorageManagerIF;
 
 
 /**
- * \brief This is the abstract base class for device handlers.
- *
+ * @brief This is the abstract base class for device handlers.
+ * @details
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
  * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
  *
- * NOTE: RMAP is a legacy standard which is used for FLP.
+ * NOTE: RMAP is a standard which is used for FLP.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are two write and two send calls involved.
  *
@@ -57,7 +57,7 @@ class StorageManagerIF;
  * Components and drivers can send so called cookies which are used for communication
  * and contain information about the communcation (e.g. slave address for I2C or RMAP structs).
  *
- * \ingroup devices
+ * @ingroup devices
  */
 class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasReturnvaluesIF,
@@ -87,33 +87,34 @@ public:
 
 
 	/**
-		 * This function is the device handler base core component and is called periodically.
-		 * General sequence:
-		 * If the State is SEND_WRITE:
-		 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
-		 *   2. Handles Device State Modes by calling doStateMachine().
-		 *      This function calls callChildStatemachine() which calls the abstract functions
-		 *      doStartUp() and doShutDown()
-		 *   3. Check switch states by calling checkSwitchStates()
-		 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
-		 *   5. Performs FDIR check for failures
-		 *   6. Calls hkSwitcher.performOperation()
-		 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
-		 *   	and performs depending on value specified
-		 *      by input value counter. The child class tells base class what to do by setting this value.
-		 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
-		 *       sendMessage function of #communicationInterface
-		 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-		 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
-		 *       getSendSuccess of #communicationInterface.
-		 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-		 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
-		 *       requestReceiveMessage of #communcationInterface
-		 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
-		 *       readReceivedMessage of #communicationInterface
-		 * @param counter Specifies which Action to perform
-		 * @return RETURN_OK for successful execution
-		 */
+	 * @brief This function is the device handler base core component and is called periodically.
+	 * @details
+	 * General sequence, showing where abstract virtual functions are called:
+	 * If the State is SEND_WRITE:
+	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
+	 *   2. Handles Device State Modes by calling doStateMachine().
+	 *      This function calls callChildStatemachine() which calls the abstract functions
+	 *      doStartUp() and doShutDown()
+	 *   3. Check switch states by calling checkSwitchStates()
+	 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
+	 *   5. Performs FDIR check for failures
+	 *   6. Calls hkSwitcher.performOperation()
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
+	 *   	and performs depending on value specified
+	 *      by input value counter. The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
+	 *       sendMessage function of #communicationInterface
+	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
+	 *       getSendSuccess of #communicationInterface.
+	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
+	 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
+	 *       requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
+	 *       readReceivedMessage of #communicationInterface
+	 * @param counter Specifies which Action to perform
+	 * @return RETURN_OK for successful execution
+	 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
 	virtual ReturnValue_t initialize();
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 9f58f600..5fbce282 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -79,11 +79,7 @@ public:
 };
 
 /**
- * Used to retrieve Target Interface Pointers of objects.
- * The object has to implement the SystemObject or SystemObjectIF at the very least,
- * otherwise NULL will be returned.
- * @param id
- * @return NULL or pointer to target interface specified by template object
+ * @brief Documentation can be found in the class method declration.
  */
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 03a57aae..0952d3a6 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);

From 950a48078c6464decada0262f5590c75c5d35a6f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 5 Dec 2019 12:21:06 +0100
Subject: [PATCH 0034/1292] some documentation, question about HasParametersIF,
 variable in ParameterHelper intialized (compiler warning)

---
 devicehandlers/DeviceCommunicationIF.h |  6 ++---
 devicehandlers/DeviceHandlerBase.h     | 36 ++++++++++++--------------
 parameters/HasParametersIF.h           |  1 +
 parameters/ParameterHelper.cpp         |  2 +-
 4 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 10ad2776..ca0e9fe2 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -5,10 +5,10 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 /**
- * Documentation: Dissertation Baetz p.138
- *
- * This is an interface to decouple device communication from
+ * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138
  * It works with the assumption that received data
  * is polled by a component. There are four generic steps of device communication:
  *
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index d489ada1..e7ac3aa6 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -331,9 +331,10 @@ protected:
 			uint32_t parameter = 0);
 
 	/**
-	 *
-
-	 * @param parameter2 additional parameter
+	 * Send reply to a command, differentiate between raw command
+	 * and normal command.
+	 * @param status
+	 * @param parameter
 	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
@@ -532,10 +533,9 @@ protected:
 			size_t commandDataLen) = 0;
 
 	/**
-	 * fill the #deviceCommandMap
-	 *
-	 * called by the initialize() of the base class
-	 *
+	 * @brief fill the #deviceCommandMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
 	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
@@ -556,9 +556,9 @@ protected:
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param parameter Supply a parameter of interest
+	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param 	parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
 	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
@@ -766,7 +766,7 @@ protected:
 
 	/**
 	 * Used to retrieve logical address
-	 * @return
+	 * @return logicalAddress
 	 */
 	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
@@ -863,12 +863,8 @@ protected:
 
 	ActionHelper actionHelper;
 
-
-
 private:
 
-
-
 	/**
 	 * State a cookie is in.
 	 *
@@ -957,11 +953,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1066,6 +1057,11 @@ private:
 	 */
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
+	/**
+	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
+	 * @param message
+	 * @return
+	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
 
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index fbb69445..cd053fee 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -46,6 +46,7 @@ public:
 	 * @param startAtIndex
 	 * @return
 	 */
+	// shouldnt startAtIndex be uint8?
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 75b71a7e..6ebc9e62 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -3,7 +3,7 @@
 #include <framework/parameters/ParameterMessage.h>
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner), storage(NULL) {
+		owner(owner), ownerQueueId(0), storage(NULL){
 
 }
 

From d99ed4715017fddab2c1f80610c9c72d3b428315 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 19:04:53 +0100
Subject: [PATCH 0035/1292] fixed map bugfix (fist instead of first), new
 access functions for fixed maP (first(), second()), some documentation, raw
 pool access read() call public because call is necessary before using public
 serialize function. maybe integrate read() call into serialize function?

---
 container/FixedMap.h                    | 13 +++++++++++--
 datapool/PoolRawAccess.h                | 22 ++++++++++++----------
 parameters/HasParametersIF.h            |  1 -
 serialize/SerialArrayListAdapter.h      |  1 +
 serialize/SerialFixedArrayListAdapter.h |  2 ++
 storagemanager/LocalPool.h              | 25 +++++++++++++++++++++++++
 6 files changed, 51 insertions(+), 13 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 0b84bf4e..4e1dc629 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -6,7 +6,9 @@
 #include <utility>
 
 /**
- * \ingroup container
+ * @brief 	Implementation of a fixed map using an array list
+ * @details Initialize with desired fixed size
+ * @ingroup container
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
@@ -56,6 +58,13 @@ public:
 			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		key_t first() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->first;
+		}
+
+		T second() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
 	};
 
 	Iterator begin() const {
@@ -87,7 +96,7 @@ public:
 	}
 
 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.fist, pair.second);
+		return insert(pair.first, pair.second);
 	}
 
 	ReturnValue_t exists(key_t key) const {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 9a3000c0..8b81894a 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -31,7 +31,7 @@ private:
 	 */
 	Type type;
 	/**
-	 * \brief	This value contains the size of the data pool entry in bytes.
+	 * \brief	This value contains the size of the data pool entry type in bytes.
 	 */
 	uint8_t typeSize;
 	/**
@@ -48,15 +48,7 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
+
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -66,6 +58,7 @@ protected:
 	 */
 	ReturnValue_t commit();
 public:
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
@@ -78,6 +71,15 @@ public:
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index cd053fee..fbb69445 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -46,7 +46,6 @@ public:
 	 * @param startAtIndex
 	 * @return
 	 */
-	// shouldnt startAtIndex be uint8?
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5ffbc375..7e2e527b 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -27,6 +27,7 @@ public:
 
 	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) {
+		// Serialize length field first
 		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
 		count_t i = 0;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 821e8710..18093e45 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -24,10 +24,12 @@ public:
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
+
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
+
 	uint32_t getSerializedSize() const {
 		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 08cb017f..425ba005 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -159,6 +159,15 @@ public:
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
 	virtual ~LocalPool(void);
+
+	/**
+	 * Add data to local data pool, performs range check
+	 * @param storageId [out] Store ID in which the data will be stored
+	 * @param data
+	 * @param size
+	 * @param ignoreFault
+	 * @return @c RETURN_OK if write was successful
+	 */
 	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
 			uint32_t size, bool ignoreFault = false);
 
@@ -171,8 +180,24 @@ public:
 	 */
 	ReturnValue_t getFreeElement(store_address_t* storageId,
 			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
+
+	/**
+	 * Retrieve data from local pool
+	 * @param packet_id
+	 * @param packet_ptr
+	 * @param size [out] Size of retrieved data
+	 * @return @c RETURN_OK if data retrieval was successfull
+	 */
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
 			uint32_t* size);
+
+	/**
+	 * Modify data by supplying a previously obtaind packet pointer
+	 * @param packet_id Store ID of data to modify
+	 * @param packet_ptr
+	 * @param size [out] size of changed data
+	 * @return
+	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
 			uint32_t* size);
 	virtual ReturnValue_t deleteData(store_address_t);

From 3159ccbc4017f7a9662b82054ac3adbce3aa6261 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 22:26:42 +0100
Subject: [PATCH 0036/1292] fixed map and local pool doc

---
 container/FixedMap.h       | 11 +++++++++--
 storagemanager/LocalPool.h |  2 ++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 4e1dc629..5e8ca9c3 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -6,8 +6,10 @@
 #include <utility>
 
 /**
- * @brief 	Implementation of a fixed map using an array list
- * @details Initialize with desired fixed size
+ * @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.
  * @ingroup container
  */
 template<typename key_t, typename T>
@@ -54,19 +56,24 @@ public:
 			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		// -> operator overloaded, can be used to access value
 		T *operator->() {
 			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 
+		// 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;
 		}
 
+		// Alternative to access value, similar to std::map implementation
 		T second() {
 			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
 		}
 	};
 
+
+
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 425ba005..57c80c2e 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -149,6 +149,8 @@ public:
 	 * 						The position of these values correspond to those in
 	 * 						element_sizes.
 	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
+	 * @param spillsToHigherPools
+	 * 						A variable to determine whether higher n pools are used if the store is full.
 	 */
 	LocalPool(object_id_t setObjectId,
 			const uint16_t element_sizes[NUMBER_OF_POOLS],

From 8168885dd905992920029c38444b9abf27541d52 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 8 Dec 2019 22:57:03 +0100
Subject: [PATCH 0037/1292] Serialization documentation update

---
 serialize/EndianSwapper.h               |  4 ++
 serialize/SerialFixedArrayListAdapter.h | 14 +++----
 serialize/SerialLinkedListAdapter.h     | 56 ++++++++++++++++---------
 serialize/SerializeAdapter.h            | 12 +++---
 serialize/SerializeElement.h            | 10 ++++-
 serialize/SerializeIF.h                 | 13 +++---
 6 files changed, 70 insertions(+), 39 deletions(-)

diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6ff54444..dfd93484 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -5,6 +5,10 @@
 #include <cstring>
 #include <iostream>
 
+/**
+ * @brief Can be used to swap endianness of data
+ *        into big endian
+ */
 class EndianSwapper {
 private:
 	EndianSwapper() {
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 18093e45..593a0ec1 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,18 +5,18 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
- * This adapter provides an interface for SerializeIF to serialize and deserialize
- * buffers with a header containing the buffer length.
- *
- * Can be used by SerialLinkedListAdapter.
- *
+ * @brief This adapter provides an interface for SerializeIF to serialize and deserialize
+ *        buffers with a header containing the buffer length.
+ * @details
+ * Can be used by SerialLinkedListAdapter by using this type in
+ * SerializeElement<>
  * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
+ * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
  * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
 class SerialFixedArrayListAdapter : public FixedArrayList<T, MAX_SIZE, count_t>, public SerializeIF {
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 08d385ee..c135a2d3 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -14,29 +14,30 @@
 //This is where we need the SerializeAdapter!
 
  /**
- * An alternative to the AutoSerializeAdapter functions to implement the conversion
- * of object data to data streams or vice-versa, using linked lists.
+ * @brief  	Implement the conversion of object data to data streams
+ * 		   	or vice-versa, using linked lists.
+ * @details
+ * An alternative to the AutoSerializeAdapter functions
+ *   - All object members with a datatype are declared as SerializeElement<element_type>
+ * 	   inside the class implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
+ *     with a known size, where the size can also be serialized
+ *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
+ *     with a size header, which is scanned automatically
  *
- * All object members with a datatype are declared as SerializeElement<element_type> inside the class
- * implementing this adapter.
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
  *
- * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<uint8_t,MAX_BUFFER_LENGTH,typeOfMaxData>.
- * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
- * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
- * Please note that a direct link from a linked element to a SerialFixedArrayListAdapter element is not possible and a
- * helper needs to be used by calling <LinkedElement>.setNext(&linkHelper)
- * and initialising the link helper as linkHelper(&SerialFixedArrayListAdapterElement).
+ * - The serialization process is done by instantiating the class and
+ *   calling the serialize after all SerializeElement entries have been set by
+ *   using a constructor or setter functions. An additional size variable can be supplied
+ *   which is calculated/incremented automatically
+ * - The deserialization process is done by instantiating the class and supplying
+ *   a buffer with the data which is converted into an object. The size of
+ *   data to serialize can be supplied and is decremented in the function
  *
- * For buffers with no size header, declare
- * SerializeElement<SerializeBufferAdapter<T>> and initialise the buffer adapter in the constructor.
  *
- * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
- *
- * The serialization and deserialization process is done by instantiating the class and
- * calling the serialize or deserialize function.
- *
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
@@ -53,6 +54,16 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
+	/**
+	 * Serialize object implementing this adapter into the supplied buffer
+	 * and calculate the serialized size
+	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
+	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
+	 * @param max_size
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		if (printCount) {
@@ -95,6 +106,13 @@ public:
 		return size;
 	}
 
+	/**
+	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * @param buffer
+	 * @param size Decremented in respective deSerialize functions automatically
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index a0aab9e9..385f40d3 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -8,10 +8,10 @@
 #include <string.h>
 
  /**
- * This adapter provides an interface to use the SerializeIF functions
- * with arbitrary template objects to facilitate and simplify the serialization of classes
- * with different multiple different data types into buffers vice-versa.
- *
+ * @brief This adapter provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the serialization of classes
+ * 		  with different multiple different data types into buffers vice-versa.
+ * @details
  * Examples:
  * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
  * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
@@ -49,7 +49,7 @@
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, int>
 class SerializeAdapter_ {
@@ -141,7 +141,7 @@ public:
 	}
 };
 
-
+// No type specification necessary here.
 class AutoSerializeAdapter {
 public:
 	template<typename T>
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index db7db20a..4f5a22b6 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -6,7 +6,15 @@
 #include <utility>
 
 /**
- * \ingroup serialize
+ * @brief This class is used to mark datatypes for serialization with the
+ *        SerialLinkedListAdapter
+ * @details
+ * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
+ * inside a SerialLinkedListAdapter implementation and setting the sequence
+ * of objects with setNext() and setStart().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
  */
 template<typename T>
 class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index cada1e72..fb750a08 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -4,17 +4,18 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 /**
- * \defgroup serialize Serialization
+ * @defgroup serialize Serialization
  * Contains serialisation services.
  */
 
 /**
- * An interface for alle classes which require translation of objects data into data streams and vice-versa.
- *
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
  * If the target architecture is little endian (e.g. ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * There are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
- * This can also be applied to uint32_t and uint64_t:
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW to use
+ * regular aligned (big endian) data. This can also be applied to uint32_t and uint64_t:
  *
  *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
  *   2. Perform a bitshift operation
@@ -23,7 +24,7 @@
  * When serializing for downlink, the packets are generally serialized assuming big endian data format
  * like seen in TmPacketStored.cpp for example.
  *
- * \ingroup serialize
+ * @ingroup serialize
  */
 class SerializeIF {
 public:

From e765f8c99bbe6827b44a8ea21a9808ca51471cf1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 9 Dec 2019 12:27:14 +0100
Subject: [PATCH 0038/1292] pool raw access modified so vectors are properly
 serialized now Endian swapper can swap the entries of a uint16,uint32 buffers
 now. Some documentation for functions added. setter function for serial
 buffer adapter written but does not appear to compile, commented out

---
 datapool/PoolRawAccess.cpp        | 20 +++++++++++++-------
 datapool/PoolRawAccess.h          | 18 ++++++++++++++----
 serialize/EndianSwapper.h         | 21 +++++++++++++++++++++
 serialize/SerialBufferAdapter.cpp |  5 +++++
 serialize/SerialBufferAdapter.h   |  1 +
 serialize/SerializeAdapter.h      |  8 ++++++++
 6 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 555896bb..6e9b3d08 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -31,7 +31,10 @@ ReturnValue_t PoolRawAccess::read() {
 				sizeTillEnd = read_out->getByteSize() - arrayPosition;
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
+				for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+					memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
+				}
+
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
 				//Error value type too large.
@@ -152,17 +155,20 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
+			for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+				for (uint8_t count = 0; count < typeSize; count++) {
+					(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
+							value[typeSize * arrayCount + count];
+				}
 			}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
+			memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
-			memcpy(*buffer, value, typeSize);
+			memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize;
-		(*buffer) += typeSize;
+		*size += typeSize * arraySize;
+		(*buffer) += typeSize * arraySize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 8b81894a..2a634fa8 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -48,7 +48,6 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
-
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -80,6 +79,20 @@ public:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read();
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @details Should be called after read() call. Endianness can be specified too
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
@@ -142,9 +155,6 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-
 	uint32_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index dfd93484..db170c0b 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -44,6 +44,27 @@ public:
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size);
 		return;
+#endif
+	}
+
+	template<typename T>
+	static void swap(T * out, const T * in, uint32_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
+		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
+		for (uint8_t count = 0; count < size; count++) {
+			for(uint8_t i = 0; i < sizeof(T);i++) {
+				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+			}
+
+		}
+
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size*sizeof(T));
+		return;
 #endif
 	}
 };
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 9a8e6f06..d7ab0d88 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -96,6 +96,11 @@ uint8_t * SerialBufferAdapter<T>::getBuffer() {
 	return buffer;
 }
 
+//template<typename T>
+//void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+//	buffer = buffer_;
+//}
+
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7496c137..0438f884 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -56,6 +56,7 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
+	//void setBuffer(uint8_t * buffer_);
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 385f40d3..933d933d 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -76,6 +76,14 @@ public:
 		}
 	}
 
+	/**
+	 * Deserialize buffer into object
+	 * @param object [out] Object to be deserialized with buffer data
+	 * @param buffer buffer containing the data
+	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
 	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		T tmp;

From 356d1d35dc97232e92778a4d0602947db812dc59 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 13:29:16 +0100
Subject: [PATCH 0039/1292] experimenting with recursive constructor to enable
 automatic vector registering

---
 datapool/PoolRawAccess.cpp | 46 +++++++++++++++++++++++++++-----------
 datapool/PoolRawAccess.h   | 44 +++++++++++++++++++++++++-----------
 2 files changed, 64 insertions(+), 26 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 6e9b3d08..41efdd7a 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -5,13 +5,27 @@
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
+		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
+		bool registerVectors) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
 				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
+	if(registerVectors == true) {
+		this->read();
+		if(arraySize > 1) {
+			for(uint16_t vectorCount = typeSize;vectorCount < arraySize;vectorCount += typeSize)
+			{
+				PoolRawAccess * newPoolRawAccess =
+						new PoolRawAccess(set_id, setArrayEntry + typeSize,
+								          data_set,setReadWriteMode,true);
+				if(newPoolRawAccess) {};
+			}
+		}
+	}
+
 }
 
 PoolRawAccess::~PoolRawAccess() {
@@ -31,9 +45,10 @@ ReturnValue_t PoolRawAccess::read() {
 				sizeTillEnd = read_out->getByteSize() - arrayPosition;
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-					memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
-				}
+				memcpy(value, ptr, typeSize);
+				//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+				//	memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
+				//}
 
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
@@ -155,20 +170,25 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-				for (uint8_t count = 0; count < typeSize; count++) {
-					(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
-							value[typeSize * arrayCount + count];
-				}
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
 			}
+			//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
+			//	for (uint8_t count = 0; count < typeSize; count++) {
+			//		(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
+			//				value[typeSize * arrayCount + count];
+			//	}
+			//}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize * arraySize);
+			memcpy(*buffer, value, typeSize);
+			//memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
-			memcpy(*buffer, value, typeSize * arraySize);
+			memcpy(*buffer, value, typeSize);
+			//memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize * arraySize;
-		(*buffer) += typeSize * arraySize;
+		*size += typeSize;// * arraySize;
+		(*buffer) += typeSize;// * arraySize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 2a634fa8..e85bef24 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -6,10 +6,14 @@
 #include <framework/globalfunctions/Type.h>
 
 /**
- * This class allows accessing Data Pool variables as raw bytes.
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
  * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information.
- *	\ingroup data_pool
+ * provide a type information. Please note that the the raw pool access read() and commit()
+ * calls are not thread-safe and therefore private.
+ * Please supply a data set and use the data set read(), commit() calls for thread-safe
+ * data pool access.
+ * @ingroup data_pool
  */
 class PoolRawAccess: public PoolVariableIF {
 private:
@@ -48,6 +52,18 @@ private:
 	ReadWriteMode_t readWriteMode;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 */
+	ReturnValue_t read();
 	/**
 	 * \brief	The commit call writes back the variable's value to the data pool.
 	 * \details	It checks type and size, as well as if the variable is writable. If so,
@@ -62,23 +78,25 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
+	//uint8_t value[RAW_MAX_SIZE*3];
+
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
+			PoolVariableIF::VAR_READ,bool registerVectors = false);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly

From f33949ba4b2e7ef3784d712af06e94a04c45ebac Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 14:54:17 +0100
Subject: [PATCH 0040/1292] doc adapted, merging

---
 datapool/PoolRawAccess.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 2a634fa8..3b9144a2 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -82,7 +82,6 @@ public:
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @details Should be called after read() call. Endianness can be specified too
 	 * @param buffer Provided buffer. Raw pool data will be copied here
 	 * @param size [out] Increment provided size value by serialized size
 	 * @param max_size Maximum allowed serialization size

From f7d8f0c1617295aae5ed652ee99566f98d84111c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Dec 2019 23:26:48 +0100
Subject: [PATCH 0041/1292] Reverted changed  pool raw access commit

---
 datapool/PoolRawAccess.cpp | 31 ++++++++-----------------------
 datapool/PoolRawAccess.h   |  9 +++++++--
 2 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 41efdd7a..0c31565a 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -15,17 +15,14 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 	if(registerVectors == true) {
 		this->read();
-		if(arraySize > 1) {
-			for(uint16_t vectorCount = typeSize;vectorCount < arraySize;vectorCount += typeSize)
-			{
-				PoolRawAccess * newPoolRawAccess =
-						new PoolRawAccess(set_id, setArrayEntry + typeSize,
-								          data_set,setReadWriteMode,true);
-				if(newPoolRawAccess) {};
-			}
+		if(arrayEntry < arraySize - 1) {
+			uint8_t nextArrayEntry = arrayEntry + 1;
+			PoolRawAccess * newPoolRawAccess =
+				new PoolRawAccess(set_id, nextArrayEntry,
+								  data_set,setReadWriteMode,true);
+			if(newPoolRawAccess) {};
 		}
 	}
-
 }
 
 PoolRawAccess::~PoolRawAccess() {
@@ -46,10 +43,6 @@ ReturnValue_t PoolRawAccess::read() {
 				uint8_t* ptr =
 						&((uint8_t*) read_out->getRawData())[arrayPosition];
 				memcpy(value, ptr, typeSize);
-				//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-				//	memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize);
-				//}
-
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
 				//Error value type too large.
@@ -173,22 +166,14 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 			for (uint8_t count = 0; count < typeSize; count++) {
 				(*buffer)[count] = value[typeSize - count - 1];
 			}
-			//for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) {
-			//	for (uint8_t count = 0; count < typeSize; count++) {
-			//		(*buffer)[typeSize * (arrayCount + 1) - count - 1] =
-			//				value[typeSize * arrayCount + count];
-			//	}
-			//}
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(*buffer, value, typeSize);
-			//memcpy(*buffer, value, typeSize * arraySize);
 #endif
 		} else {
 			memcpy(*buffer, value, typeSize);
-			//memcpy(*buffer, value, typeSize * arraySize);
 		}
-		*size += typeSize;// * arraySize;
-		(*buffer) += typeSize;// * arraySize;
+		*size += typeSize;
+		(*buffer) += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SerializeIF::BUFFER_TOO_SHORT;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index cdead93a..9bf09d0a 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -78,16 +78,21 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
-	//uint8_t value[RAW_MAX_SIZE*3];
 
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
 	 * @param data_pool_id Target data pool entry ID
 	 * @param arrayEntry
 	 * @param data_set Dataset to register data pool entry to
 	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
 	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =

From 138cac98d100affabc0916e27f8189c42af3f3b9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 01:57:36 +0100
Subject: [PATCH 0042/1292] experimenting with recursive constructor and
 dataset call

---
 datapool/PoolRawAccess.cpp | 9 +++++----
 datapool/PoolRawAccess.h   | 1 +
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 0c31565a..6be4b783 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -3,6 +3,7 @@
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
+#include "DataSet.h"
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
@@ -15,12 +16,12 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 	if(registerVectors == true) {
 		this->read();
+//		DataSet * myDataSetTest = (DataSet *) data_set;
+//		myDataSetTest->read();
 		if(arrayEntry < arraySize - 1) {
 			uint8_t nextArrayEntry = arrayEntry + 1;
-			PoolRawAccess * newPoolRawAccess =
-				new PoolRawAccess(set_id, nextArrayEntry,
-								  data_set,setReadWriteMode,true);
-			if(newPoolRawAccess) {};
+			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
+					data_set,setReadWriteMode,true);
 		}
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 9bf09d0a..ac7d6702 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,6 +50,7 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
+	PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**

From 29a15e8154d5de81d5dff878f6e54f413f5fe12d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 13:03:51 +0100
Subject: [PATCH 0043/1292] commented out functions which will propably not be
 needed and removed

---
 datapool/PoolRawAccess.cpp | 22 +++++++++++-----------
 datapool/PoolRawAccess.h   |  4 ++--
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 6be4b783..c99d8069 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -3,7 +3,9 @@
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
-#include "DataSet.h"
+
+//PoolRawAccess::PoolRawAccess() {
+//}
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
@@ -14,16 +16,14 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
-	if(registerVectors == true) {
-		this->read();
-//		DataSet * myDataSetTest = (DataSet *) data_set;
-//		myDataSetTest->read();
-		if(arrayEntry < arraySize - 1) {
-			uint8_t nextArrayEntry = arrayEntry + 1;
-			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
-					data_set,setReadWriteMode,true);
-		}
-	}
+//	if(registerVectors == true) {
+//		this->read();
+//		if(arrayEntry < arraySize - 1) {
+//			uint8_t nextArrayEntry = arrayEntry + 1;
+//			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
+//					data_set,setReadWriteMode,true);
+//		}
+//	}
 }
 
 PoolRawAccess::~PoolRawAccess() {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index ac7d6702..7207518c 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,7 +50,7 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	PoolRawAccess * nextPoolRawAccess;
+	//PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**
@@ -79,7 +79,7 @@ public:
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
-
+	//PoolRawAccess();
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied

From 9382eb03e6cfb0985d78587df3f4696e52ead038 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 22:50:08 +0100
Subject: [PATCH 0044/1292] function to serialize pool ID buffers into dataset
 created

---
 datapool/DataSet.cpp     |  6 ++++++
 datapool/DataSet.h       | 11 +++++++++++
 datapool/PoolRawAccess.h |  2 +-
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c73..55d8d670 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -148,3 +148,9 @@ ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
 	}
 	return result;
 }
+
+ReturnValue_t DataSet::serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
+		const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
+		uint32_t poolIdSize) {
+	return RETURN_OK;
+}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 982be692..deee8ca6 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -146,6 +146,14 @@ public:
 	 */
 	void setValid(uint8_t valid);
 
+	/**
+	 * Serialize all registered pool variables into the provided buffer
+	 * @param buffer
+	 * @param size Is incremented by serialized size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const;
 
@@ -154,6 +162,9 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
 
+	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
+			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
+			uint32_t poolIdSize);
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 7207518c..3735868f 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -10,7 +10,7 @@
  * @details
  * This is necessary to have an access method for HK data, as the PID's alone do not
  * provide a type information. Please note that the the raw pool access read() and commit()
- * calls are not thread-safe and therefore private.
+ * calls are not thread-safe.
  * Please supply a data set and use the data set read(), commit() calls for thread-safe
  * data pool access.
  * @ingroup data_pool

From 625f3dc79c33794c041bf91af87bd0a2d271e67b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 23:15:34 +0100
Subject: [PATCH 0045/1292] local pool modify data doc modifided

---
 storagemanager/LocalPool.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 57c80c2e..80e6a495 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -194,10 +194,11 @@ public:
 			uint32_t* size);
 
 	/**
-	 * Modify data by supplying a previously obtaind packet pointer
+	 * Modify data by supplying a packet pointer and using that packet pointer
+	 * to access and modify the pool entry (via *pointer call)
 	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr
-	 * @param size [out] size of changed data
+	 * @param packet_ptr [out] pointer to the pool entry to modify
+	 * @param size [out] size of pool entry
 	 * @return
 	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,

From fa6cbe7e0c8862f903e7c78bdf938c8caff93863 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 11 Dec 2019 23:18:28 +0100
Subject: [PATCH 0046/1292] pool raw access changed reverted

---
 datapool/PoolRawAccess.cpp | 11 -----------
 datapool/PoolRawAccess.h   |  1 -
 2 files changed, 12 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c99d8069..7cc61852 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -4,9 +4,6 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
-//PoolRawAccess::PoolRawAccess() {
-//}
-
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
 		bool registerVectors) :
@@ -16,14 +13,6 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	if (data_set != NULL) {
 		data_set->registerVariable(this);
 	}
-//	if(registerVectors == true) {
-//		this->read();
-//		if(arrayEntry < arraySize - 1) {
-//			uint8_t nextArrayEntry = arrayEntry + 1;
-//			nextPoolRawAccess = new PoolRawAccess(set_id, nextArrayEntry,
-//					data_set,setReadWriteMode,true);
-//		}
-//	}
 }
 
 PoolRawAccess::~PoolRawAccess() {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3735868f..603bae23 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -50,7 +50,6 @@ private:
 	 * \brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	//PoolRawAccess * nextPoolRawAccess;
 	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 protected:
 	/**

From d17146d847610b403118c7992908a94deb361e1c Mon Sep 17 00:00:00 2001
From: Maximilian Luz <luzmaximilian@gmail.com>
Date: Thu, 19 Dec 2019 16:09:50 +0100
Subject: [PATCH 0047/1292] Check object existence before adding it to the PST

Currently, adding new objects/components to the FixedSlotSequence PST is
not being checked, meaning that it is possible to add NULL objects here
without any warning. This causes NULL-pointer errors when non-existent
components are added, which can be hard to debug.

To solve this, add a check for the object existence before adding it to
PST and emit an error message.

Signed-off-by: Maximilian Luz <luzmaximilian@gmail.com>
---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++++
 osal/linux/FixedTimeslotTask.cpp    | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 5bf09f13..4a30774a 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -57,6 +57,11 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
+	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
+		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	pst.addSlot(componentId, slotTimeMs, executionStep, this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 99cbf818..21040e6e 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -40,6 +40,11 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
+	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
+		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	pst.addSlot(componentId, slotTimeMs, executionStep, this);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From 89f490ac36dd3178616cbdfa712adea389ab15ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 20 Dec 2019 23:09:35 +0100
Subject: [PATCH 0048/1292] assembly constructor formatting

---
 devicehandlers/AssemblyBase.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index c250cf73..bd85d1de 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -2,10 +2,10 @@
 
 AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
 		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth), internalState(
-				STATE_NONE), recoveryState(RECOVERY_IDLE), recoveringDevice(
-				childrenMap.end()), targetMode(MODE_OFF), targetSubmode(
-				SUBMODE_NONE) {
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
 	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
 }
 

From f6b9b232877d29d6a68640967f131d6091c7f2de Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 24 Dec 2019 01:41:04 +0100
Subject: [PATCH 0049/1292] pool raw access init

---
 datapool/PoolRawAccessHelper.cpp | 68 ++++++++++++++++++++++++++++++
 datapool/PoolRawAccessHelper.h   | 71 ++++++++++++++++++++++++++++++++
 2 files changed, 139 insertions(+)
 create mode 100644 datapool/PoolRawAccessHelper.cpp
 create mode 100644 datapool/PoolRawAccessHelper.h

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
new file mode 100644
index 00000000..24bcc1d4
--- /dev/null
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -0,0 +1,68 @@
+/**
+ * @file PoolRawAccessHelper.cpp
+ *
+ * @date 22.12.2019
+ */
+
+#include <framework/datapool/PoolRawAccessHelper.h>
+
+PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
+		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
+		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
+		numberOfParameters(numberOfParameters_){
+}
+
+PoolRawAccessHelper::~PoolRawAccessHelper() {
+}
+
+ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
+		const uint32_t max_size, bool bigEndian) {
+	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
+	int32_t remainingParametersSize = numberOfParameters * 4;
+	for(uint8_t count=0; count < numberOfParameters; count++) {
+		serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+				&remainingParametersSize,size,max_size, bigEndian, false);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
+		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+	return RETURN_OK;
+}
+
+void PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
+		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
+		const uint32_t max_size, bool bigEndian, bool withValidMask) {
+	uint32_t currentPoolId;
+	// Deserialize current pool ID from pool ID buffer
+	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
+			pPoolIdBuffer,remainingParameters,true);
+	if(result != RETURN_OK) {
+		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
+		return;
+	}
+	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
+	result = dataSet->read();
+
+	if (result != RETURN_OK) {
+		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
+		return;
+	}
+	result = dataSet->serialize(buffer, hkDataSize,
+			max_size, bigEndian);
+	if (result != RETURN_OK) {
+		debug << "Service 3: Error serializing pool data into send buffer" << std::endl;
+		return;
+	}
+}
+
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
+	if(position < 1 or position > 8) {
+		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+		return byte;
+	}
+	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
+	byte = (byte | value) <<  shiftNumber;
+	return byte;
+}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
new file mode 100644
index 00000000..bb19a3ce
--- /dev/null
+++ b/datapool/PoolRawAccessHelper.h
@@ -0,0 +1,71 @@
+/**
+ * @file PoolRawAccessHelper.h
+ *
+ * @date 22.12.2019
+ */
+
+#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/datapool/DataSet.h>
+
+/**
+ * @brief 	This helper function simplifies accessing data pool entries
+ *  	  	via PoolRawAccess
+ * @details Can be used for a Housekeeping Service
+ * 			like PUS Service 3 if the type of the datapool entries is unknown.
+ * 			The provided dataset is serialized into a provided buffer automatically.
+ */
+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(DataSet * dataSet_, const uint8_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, uint32_t * size,
+			const uint32_t max_size, bool bigEndian);
+
+	/**
+	 * 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, uint32_t * size,
+			const uint32_t max_size, bool bigEndian);
+
+
+private:
+	DataSet * dataSet;
+	const uint8_t * poolIdBuffer;
+	uint8_t numberOfParameters;
+
+	void serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
+				bool bigEndian, bool withValidMask);
+	uint8_t bitSetter(uint8_t byte, uint8_t position, bool value);
+};
+
+#endif /* FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_ */

From 1f1831c4a14ddf806a6a360e1f60b1c46e90d968 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 24 Dec 2019 22:15:39 +0100
Subject: [PATCH 0050/1292] pool raw access init

---
 datapool/PoolRawAccessHelper.cpp | 53 ++++++++++++++++++++++++++------
 datapool/PoolRawAccessHelper.h   | 33 +++++++++++++++++---
 2 files changed, 73 insertions(+), 13 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 24bcc1d4..5a43e43c 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -2,6 +2,7 @@
  * @file PoolRawAccessHelper.cpp
  *
  * @date 22.12.2019
+ * @author R. Mueller
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
@@ -9,7 +10,7 @@
 PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
 		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
 		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
-		numberOfParameters(numberOfParameters_){
+		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
 PoolRawAccessHelper::~PoolRawAccessHelper() {
@@ -17,44 +18,78 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
+	ReturnValue_t result;
 	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
 				&remainingParametersSize,size,max_size, bigEndian, false);
+		if(result != RETURN_OK) {
+			return result;
+		}
 	}
 	return RETURN_OK;
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+	ReturnValue_t result;
+	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
+	int32_t remainingParametersSize = numberOfParameters * 4;
+	uint8_t validityMaskSize = numberOfParameters/8;
+	uint8_t validityMask[validityMaskSize];
+	memset(validityMask,0, validityMaskSize);
+	for(uint8_t count=0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	memcpy(*buffer + *size, validityMask, validityMaskSize);
+	*size += validityMaskSize;
+	validBufferIndex = 1;
+	validBufferIndexBit = 0;
 	return RETURN_OK;
 }
 
-void PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
 		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
-		const uint32_t max_size, bool bigEndian, bool withValidMask) {
+		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			pPoolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
-		return;
+		return result;
 	}
 	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
-	result = dataSet->read();
 
+	// set valid mask bit if necessary
+	if(withValidMask) {
+		if(currentPoolRawAccess.isValid()) {
+			validityMask[validBufferIndex] =
+					bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
+			validBufferIndexBit ++;
+			if(validBufferIndexBit == 8) {
+				validBufferIndex ++;
+				validBufferIndexBit = 1;
+			}
+		}
+	}
+
+	result = dataSet->read();
 	if (result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
-		return;
+		return result;
 	}
 	result = dataSet->serialize(buffer, hkDataSize,
 			max_size, bigEndian);
 	if (result != RETURN_OK) {
-		debug << "Service 3: Error serializing pool data into send buffer" << std::endl;
-		return;
+		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
 	}
+	return result;
 }
 
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index bb19a3ce..36f42f83 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -14,8 +14,10 @@
  * @brief 	This helper function simplifies accessing data pool entries
  *  	  	via PoolRawAccess
  * @details Can be used for a Housekeeping Service
- * 			like PUS Service 3 if the type of the datapool entries is unknown.
- * 			The provided dataset is serialized into a provided buffer automatically.
+ * 			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:
@@ -62,9 +64,32 @@ private:
 	const uint8_t * poolIdBuffer;
 	uint8_t numberOfParameters;
 
-	void serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+	uint8_t validBufferIndex;
+	uint8_t validBufferIndexBit;
+
+	/**
+	 * 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(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
 				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
-				bool bigEndian, bool withValidMask);
+				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
+
+	/**
+	 * 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);
 };
 

From e24f9b89e4c1965387de84520c80d2439337a9e3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 16:44:50 +0100
Subject: [PATCH 0051/1292] Pool Raw Access Helper tested, appesrs to work.
 SerializeAdapter doc changes, tm packet stored debug output if not enough
 storage available

---
 datapool/PoolRawAccessHelper.cpp  | 42 +++++++++++++++++++------------
 datapool/PoolRawAccessHelper.h    |  7 +++---
 osal/FreeRTOS/MessageQueue.cpp    | 21 ++++++++--------
 serialize/SerializeAdapter.h      | 24 ++++++++++--------
 tmtcpacket/pus/TmPacketStored.cpp |  1 +
 5 files changed, 55 insertions(+), 40 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 5a43e43c..bacf8ea5 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,10 +6,11 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+#include <framework/datapool/DataSet.h>
 
-PoolRawAccessHelper::PoolRawAccessHelper(DataSet *dataSet_,
-		const uint8_t * poolIdBuffer_, uint8_t  numberOfParameters_):
-		dataSet(dataSet_), poolIdBuffer(poolIdBuffer_),
+PoolRawAccessHelper::PoolRawAccessHelper(uint8_t * poolIdBuffer_,
+		uint8_t  numberOfParameters_):
+		poolIdBuffer(poolIdBuffer_),
 		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
@@ -19,52 +20,61 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
-	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+		result = serializeCurrentPoolEntryIntoBuffer(buffer,
 				&remainingParametersSize,size,max_size, bigEndian, false);
 		if(result != RETURN_OK) {
 			return result;
 		}
 	}
-	return RETURN_OK;
+	if(remainingParametersSize != 0) {
+		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
+	return result;
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 		uint32_t *size, const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
-	const uint8_t ** pPoolIdBuffer = &poolIdBuffer;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = numberOfParameters/8;
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
-	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(pPoolIdBuffer,buffer,
+	for(uint8_t count = 0; count < numberOfParameters; count++) {
+		result = serializeCurrentPoolEntryIntoBuffer(buffer,
 				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
 		if (result != RETURN_OK) {
 			return result;
 		}
 	}
+	if(remainingParametersSize != 0) {
+		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		result = RETURN_FAILED;
+	}
 	memcpy(*buffer + *size, validityMask, validityMaskSize);
 	*size += validityMaskSize;
 	validBufferIndex = 1;
 	validBufferIndexBit = 0;
-	return RETURN_OK;
+	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,
-		uint8_t ** buffer, int32_t * remainingParameters, uint32_t * hkDataSize,
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
+		int32_t * remainingParameters, uint32_t * hkDataSize,
 		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
+	DataSet currentDataSet = DataSet();
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			pPoolIdBuffer,remainingParameters,true);
+			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
 		return result;
 	}
-	PoolRawAccess currentPoolRawAccess(currentPoolId,0,dataSet,PoolVariableIF::VAR_READ);
+
+	// info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	PoolRawAccess currentPoolRawAccess(currentPoolId,0,&currentDataSet,PoolVariableIF::VAR_READ);
 
 	// set valid mask bit if necessary
 	if(withValidMask) {
@@ -79,12 +89,12 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(const uin
 		}
 	}
 
-	result = dataSet->read();
+	result = currentDataSet.read();
 	if (result != RETURN_OK) {
 		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
 		return result;
 	}
-	result = dataSet->serialize(buffer, hkDataSize,
+	result = currentDataSet.serialize(buffer, hkDataSize,
 			max_size, bigEndian);
 	if (result != RETURN_OK) {
 		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 36f42f83..756ae286 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -28,8 +28,7 @@ public:
 	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
 	 * @param numberOfParameters_ The number of parameters / pool IDs
 	 */
-	PoolRawAccessHelper(DataSet * dataSet_, const uint8_t * poolIdBuffer_,
-			uint8_t numberOfParameters_);
+	PoolRawAccessHelper(uint8_t * poolIdBuffer_, uint8_t numberOfParameters_);
 	virtual ~PoolRawAccessHelper();
 
 	/**
@@ -60,7 +59,7 @@ public:
 
 
 private:
-	DataSet * dataSet;
+	// DataSet * dataSet;
 	const uint8_t * poolIdBuffer;
 	uint8_t numberOfParameters;
 
@@ -79,7 +78,7 @@ private:
 	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(const uint8_t ** pPoolIdBuffer,uint8_t ** buffer,
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
 				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
 				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index f3aebcd1..1f514cf3 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -89,23 +89,24 @@ MessageQueueId_t MessageQueue::getDefaultDestination() const {
 bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
+
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessage *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 
-		BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-		if (result != pdPASS) {
-			if (!ignoreFault) {
-				InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-							objects::INTERNAL_ERROR_REPORTER);
-				if (internalErrorReporter != NULL) {
-					internalErrorReporter->queueMessageNotSent();
-				}
+	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
 			}
-			return MessageQueueIF::FULL;
 		}
-		return HasReturnvaluesIF::RETURN_OK;
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 
 }
 
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 933d933d..18240a95 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -10,7 +10,7 @@
  /**
  * @brief This adapter provides an interface to use the SerializeIF functions
  * 		  with arbitrary template objects to facilitate and simplify the serialization of classes
- * 		  with different multiple different data types into buffers vice-versa.
+ * 		  with different multiple different data types into buffers and vice-versa.
  * @details
  * Examples:
  * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
@@ -20,27 +20,31 @@
  *
  * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
  * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
- * The boolean bigEndian specifies the endiness of the data to serialize or deSerialize.
+ * The boolean bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
  *
  * If the target architecture is little endian (ARM), any data types created might
  * have the wrong endiness if they are to be used for the FSFW.
- * there are three ways to retrieve data out of a buffer to be used in the FSFW to use regular aligned (big endian) data.
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data.
  * This can also be applied to uint32_t and uint64_t:
  *
- *   1. Use the AutoSerializeAdapter::deSerialize function with bool bigEndian = true:
- *		The pointer *buffer will be incremented automatically by the typeSize of data,
- *		so this function can be called on &buffer without adjusting pointer position
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize of the object,
+ *		so this function can be called on &buffer repeatedly without adjusting pointer position.
+ *		Set bigEndian parameter to true to perform endian swapping.
  *
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);
  *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
  *
- *   2. Perform a bitshift operation:
+ *   2. Perform a bitshift operation. Perform endian swapping if necessary:
  *
  *   	uint16_t data;
- *   	data = buffer[targetByte1] >> 8 | buffer[targetByte2];
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data);
  *
- *   3. Memcpy can be used when data is little-endian. Otherwise, endian-swapper has to be used.
+ *   3. Memcpy can be used when data is little-endian. Perform endian-swapping if necessary.
  *
  *   	uint16_t data;
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
@@ -79,7 +83,7 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const pointer to const buffer.
 	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
 	 * @param bigEndian Specify endianness
 	 * @return
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index f2c1eb28..b1c1ec62 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -22,6 +22,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
 	if (returnValue != store->RETURN_OK) {
+		debug << "TM Packet Stored: Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From 29b4480fc4f6d752e1236e6b9172dc622ea640ba Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 18:55:31 +0100
Subject: [PATCH 0052/1292] include adapted

---
 osal/FreeRTOS/QueueFactory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 5c7087de..eaf245d3 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,6 +1,6 @@
 #include <framework/ipc/QueueFactory.h>
 
-#include "../FreeRTOS/MessageQueue.h"
+#include <framework/osal/FreeRTOS/MessageQueue.h>
 
 
 QueueFactory* QueueFactory::factoryInstance = NULL;

From 0066a6b78819777a62f8f1b0ec8512f56b4a49d4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 19:47:46 +0100
Subject: [PATCH 0053/1292] Generic TMTC Bridge added

---
 tmtcservices/TmTcBridge.cpp | 173 ++++++++++++++++++++++++++++++++++++
 tmtcservices/TmTcBridge.h   | 121 +++++++++++++++++++++++++
 2 files changed, 294 insertions(+)
 create mode 100644 tmtcservices/TmTcBridge.cpp
 create mode 100644 tmtcservices/TmTcBridge.h

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
new file mode 100644
index 00000000..e7928317
--- /dev/null
+++ b/tmtcservices/TmTcBridge.cpp
@@ -0,0 +1,173 @@
+/**
+ * @file TmTcBridge.cpp
+ *
+ * @date 26.12.2019
+ */
+
+#include <framework/tmtcservices/TmTcBridge.h>
+
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
+	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
+	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
+	tmStored(false) {
+	TmTcReceptionQueue = QueueFactory::instance()->
+			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+
+}
+
+TmTcBridge::~TmTcBridge() {
+}
+
+ReturnValue_t TmTcBridge::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == NULL) {
+		return RETURN_FAILED;
+	}
+	tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+	if (tmStore == NULL) {
+		return RETURN_FAILED;
+	}
+	AcceptsTelecommandsIF* tcDistributor =
+			objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor);
+	if (tcDistributor == NULL) {
+		return RETURN_FAILED;
+	}
+	TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
+	ReturnValue_t result;
+	result = handleTc();
+	if(result != RETURN_OK) {
+		error << "TMTC Bridge: Error handling TCs" << std::endl;
+	}
+	result = handleTm();
+	if (result != RETURN_OK) {
+		error << "TMTC Bridge: Error handling TMs" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTc() {
+	ReturnValue_t result = receiveTc();
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTm() {
+	ReturnValue_t result = readTmQueue();
+	if(result != RETURN_OK) {
+		error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		return RETURN_FAILED;
+	}
+
+	if(tmStored && communicationLinkUp) {
+		result = sendStoredTm();
+	}
+	return result;
+
+}
+
+ReturnValue_t TmTcBridge::readTmQueue() {
+	TmTcMessage message;
+	const uint8_t* data = NULL;
+	uint32_t size = 0;
+	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
+		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
+	{
+		if(not communicationLinkUp) {
+			result = storeDownlinkData(&message);
+			return result;
+		}
+
+		result = tmStore->getData(message.getStorageId(), &data, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+
+		result = sendTm(data, size);
+		if (result != RETURN_OK) {
+			error << "UDP Server: Could not send TM packet"<< std::endl;
+			tmStore->deleteData(message.getStorageId());
+			return result;
+
+		}
+		tmStore->deleteData(message.getStorageId());
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
+	info << "UDP Server: Client address not bound yet. Packet can not be sent. "
+			"Saving packet to be sent later " << std::endl;
+	store_address_t storeId;
+
+	if(fifo.full()) {
+		info << "UDP Server: TM downlink store is full. Overwriting old data" << std::endl;
+		fifo.retrieve(&storeId);
+	}
+	storeId = message->getStorageId();
+	fifo.insert(storeId);
+	//storageIdBufferCounter ++;
+	tmStored = true;
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::sendStoredTm() {
+	uint8_t counter = 0;
+	ReturnValue_t result = RETURN_OK;
+	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
+		info << "UDP Server: Sending stored TM data. There are "
+				<< (int) fifo.size() << " left to send" << std::endl;
+		store_address_t storeId;
+		const uint8_t* data = NULL;
+		uint32_t size = 0;
+		fifo.retrieve(&storeId);
+		result = tmStore->getData(storeId, &data, &size);
+		sendTm(data,size);
+		if(result != RETURN_OK) {
+			error << "UDP Server: Could not send stored downlink data" << std::endl;
+			result = RETURN_FAILED;
+		}
+		counter ++;
+
+		if(fifo.empty()) {
+			tmStored = false;
+		}
+		tmStore->deleteData(storeId);
+	}
+	return result;
+}
+
+void TmTcBridge::registerCommConnect() {
+	info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+	if(not communicationLinkUp) {
+		communicationLinkUp = true;
+	}
+}
+
+void TmTcBridge::registerCommDisconnect() {
+	info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	if(communicationLinkUp) {
+		communicationLinkUp = false;
+	}
+}
+
+MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
+	return TmTcReceptionQueue->getId();
+}
+
+void TmTcBridge::printData(uint8_t * data, uint32_t dataLen) {
+	info << "TMTC Bridge: Printing data: [";
+	for(uint32_t i=0;i<dataLen;i++) {
+		info << std::hex << (int)data[i];
+		if(i < dataLen-1){
+			info << " , ";
+		}
+	}
+	info << " ] " << std::endl;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
new file mode 100644
index 00000000..ad09bf7c
--- /dev/null
+++ b/tmtcservices/TmTcBridge.h
@@ -0,0 +1,121 @@
+/**
+ * @file TmTcBridge.h
+ *
+ * @date 26.12.2019
+ */
+
+#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
+
+#include <framework/tmtcservices/TmTcMessage.h>
+#include <framework/container/FIFO.h>
+
+class TmTcBridge : public AcceptsTelemetryIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF,
+		public SystemObject {
+public:
+	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
+	virtual ~TmTcBridge();
+
+	/**
+	 * Initializes basic FSFW components for TMTC Bridge
+	 * @return
+	 */
+	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
+
+	/**
+	 * Return TMTC Reception Queue
+	 * @param virtualChannel
+	 * @return
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0);
+
+protected:
+	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
+	StorageManagerIF* tcStore;
+	StorageManagerIF* tmStore;
+	object_id_t ccsdsPacketDistributor;
+	bool communicationLinkUp; //!< Used to specify whether communication link is up
+	bool tmStored;
+
+	/**
+	 * Handle TC reception. Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t handleTc();
+
+	/**
+	 * Implemented by child class. Perform receiving of Telecommand
+	 * @return
+	 */
+	virtual ReturnValue_t receiveTc() = 0;
+
+	/**
+	 * Handle Telemetry. Default implementation provided.
+	 * Calls sendTm()
+	 * @return
+	 */
+	virtual ReturnValue_t handleTm();
+
+	/**
+	 * Read the TM Queue and send TM if necessary. Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t readTmQueue();
+
+	/**
+	 * Implemented by child class. Perform sending of Telemetry
+	 * @param data
+	 * @param dataLen
+	 * @return
+	 */
+	virtual ReturnValue_t sendTm(const uint8_t * data, uint32_t dataLen) = 0;
+
+	/**
+	 * Store data to be sent later if communication link is not up.
+	 * @param message
+	 * @return
+	 */
+	ReturnValue_t storeDownlinkData(TmTcMessage * message);
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	ReturnValue_t sendStoredTm();
+
+	/**
+	 * Print data as hexidecimal array
+	 * @param data
+	 * @param dataLen
+	 */
+	void printData(uint8_t * data, uint32_t dataLen);
+
+	void registerCommConnect();
+	void registerCommDisconnect();
+
+private:
+	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
+	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
+
+	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */

From 8397f5b2b1961bc875282829fa687adb6cdb6d97 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:17:21 +0100
Subject: [PATCH 0054/1292] tmtc bridge bugfix

---
 tmtcservices/TmTcBridge.cpp | 5 +++--
 tmtcservices/TmTcBridge.h   | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index e7928317..9e863ffd 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -2,6 +2,7 @@
  * @file TmTcBridge.cpp
  *
  * @date 26.12.2019
+ * @author R. Mueller
  */
 
 #include <framework/tmtcservices/TmTcBridge.h>
@@ -144,8 +145,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 }
 
 void TmTcBridge::registerCommConnect() {
-	info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
-	if(not communicationLinkUp) {
+	if(!communicationLinkUp) {
+		info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index ad09bf7c..0f045e47 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -25,7 +25,7 @@ public:
 	virtual ~TmTcBridge();
 
 	/**
-	 * Initializes basic FSFW components for TMTC Bridge
+	 * Initializes basic FSFW components for the TMTC Bridge
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();

From 19e257a90aa57622732177166a9b1ff547da9456 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:35:11 +0100
Subject: [PATCH 0055/1292] tmtc bridge debug output corrected

---
 tmtcservices/TmTcBridge.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 9e863ffd..6415cb35 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -103,12 +103,13 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 }
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	info << "UDP Server: Client address not bound yet. Packet can not be sent. "
-			"Saving packet to be sent later " << std::endl;
+	info << "TMTC Bridge: Comm Link down. "
+			"Saving packet ID to be sent later " << std::endl;
 	store_address_t storeId;
 
 	if(fifo.full()) {
-		info << "UDP Server: TM downlink store is full. Overwriting old data" << std::endl;
+		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
+				" Overwriting old data" << std::endl;
 		fifo.retrieve(&storeId);
 	}
 	storeId = message->getStorageId();

From 33a7c033a27dd741ebbec31f5d517b6acabd342a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 20:38:15 +0100
Subject: [PATCH 0056/1292] doc extended, instructions for sendTm and receiveTc

---
 tmtcservices/TmTcBridge.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 0f045e47..216dae8b 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -60,7 +60,8 @@ protected:
 	virtual ReturnValue_t handleTc();
 
 	/**
-	 * Implemented by child class. Perform receiving of Telecommand
+	 * Implemented by child class. Perform receiving of Telecommand, for example by implementing
+	 * specific drivers or wrappers, e.g. UART Communication or lwIP stack
 	 * @return
 	 */
 	virtual ReturnValue_t receiveTc() = 0;
@@ -79,7 +80,8 @@ protected:
 	virtual ReturnValue_t readTmQueue();
 
 	/**
-	 * Implemented by child class. Perform sending of Telemetry
+	 * Implemented by child class. Perform sending of Telemetry by implementing
+	 * communication drivers or wrappers, e.g. UART communication or lwIP stack.
 	 * @param data
 	 * @param dataLen
 	 * @return

From a38a2f4b3a4e07b77e4989300871c91705496718 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 22:07:17 +0100
Subject: [PATCH 0057/1292] tmtc bridge bugfix: tm data deleted when
 overwriting old data

---
 tmtcservices/TmTcBridge.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6415cb35..860589c5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -111,6 +111,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
 				" Overwriting old data" << std::endl;
 		fifo.retrieve(&storeId);
+		tmStore->deleteData(storeId);
 	}
 	storeId = message->getStorageId();
 	fifo.insert(storeId);

From 79e7fee8072abbf40d65d2114157f35d856bbb5d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 26 Dec 2019 22:15:19 +0100
Subject: [PATCH 0058/1292] comment deleted

---
 tmtcservices/TmTcBridge.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 860589c5..6af6d524 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -115,7 +115,6 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	}
 	storeId = message->getStorageId();
 	fifo.insert(storeId);
-	//storageIdBufferCounter ++;
 	tmStored = true;
 	return RETURN_OK;
 }

From 666341d03ddbe1394e452b0f15af2a4457a0f148 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 27 Dec 2019 22:43:09 +0100
Subject: [PATCH 0059/1292] new bool datatype for possible pool entries

---
 datapool/DataPool.cpp  | 1 +
 datapool/PoolEntry.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 89543d77..1d3af742 100644
--- a/datapool/DataPool.cpp
+++ b/datapool/DataPool.cpp
@@ -79,6 +79,7 @@ void DataPool::print() {
 	}
 }
 
+template PoolEntry<bool>* DataPool::getData<bool>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint8_t>* DataPool::getData<uint8_t>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint16_t>* DataPool::getData<uint16_t>( uint32_t data_pool_id,  uint8_t size );
 template PoolEntry<uint32_t>* DataPool::getData<uint32_t>( uint32_t data_pool_id,  uint8_t size );
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index c303e56b..f2968c32 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -56,6 +56,7 @@ Type PoolEntry<T>::getType() {
 	return PodTypeConversion<T>::type;
 }
 
+template class PoolEntry<bool>;
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;

From 2425685e446ec9a0dae320ea6f0cf0ca95e0cd33 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Dec 2019 01:59:02 +0100
Subject: [PATCH 0060/1292] Pool Raw Access Helper serialization of vectors
 implemented

---
 datapool/PoolRawAccessHelper.cpp        | 91 ++++++++++++++++---------
 datapool/PoolRawAccessHelper.h          | 15 +++-
 serialize/SerialFixedArrayListAdapter.h |  2 +-
 3 files changed, 71 insertions(+), 37 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index bacf8ea5..b1766671 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -19,11 +19,12 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 		const uint32_t max_size, bool bigEndian) {
+	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(buffer,
-				&remainingParametersSize,size,max_size, bigEndian, false);
+		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
+				&remainingParametersSize, false);
 		if(result != RETURN_OK) {
 			return result;
 		}
@@ -35,16 +36,17 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
-		uint32_t *size, const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
+		const uint32_t max_size, bool bigEndian) {
 	ReturnValue_t result;
+	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = numberOfParameters/8;
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
 	for(uint8_t count = 0; count < numberOfParameters; count++) {
-		result = serializeCurrentPoolEntryIntoBuffer(buffer,
-				&remainingParametersSize,size,max_size, bigEndian,true,validityMask);
+		result = serializeCurrentPoolEntryIntoBuffer(argStruct,
+				&remainingParametersSize,true,validityMask);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -60,11 +62,9 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t **buffer,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
-		int32_t * remainingParameters, uint32_t * hkDataSize,
-		const uint32_t max_size, bool bigEndian, bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
+		int32_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
-	DataSet currentDataSet = DataSet();
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
@@ -72,36 +72,61 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(uint8_t *
 		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
 		return result;
 	}
+	result = handlePoolEntrySerialization(currentPoolId, argStruct, withValidMask, validityMask);
+	return result;
+}
 
-	// info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
-	PoolRawAccess currentPoolRawAccess(currentPoolId,0,&currentDataSet,PoolVariableIF::VAR_READ);
-
-	// set valid mask bit if necessary
-	if(withValidMask) {
-		if(currentPoolRawAccess.isValid()) {
-			validityMask[validBufferIndex] =
-					bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-			validBufferIndexBit ++;
-			if(validBufferIndexBit == 8) {
-				validBufferIndex ++;
-				validBufferIndexBit = 1;
+ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
+		bool withValidMask, uint8_t * validityMask) {
+	ReturnValue_t result;
+	uint8_t arrayPosition = 0;
+	bool poolEntrySerialized = false;
+	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	while(not poolEntrySerialized) {
+		DataSet currentDataSet = DataSet();
+		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+		result = currentDataSet.read();
+		if (result != RETURN_OK) {
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset" << std::dec << std::endl;
+			return result;
+		}
+		uint8_t remainingSize = currentPoolRawAccess.getSizeTillEnd() - currentPoolRawAccess.getSizeOfType();
+		if(remainingSize == 0) {
+			poolEntrySerialized = true;
+		}
+		else if(remainingSize > 0) {
+			arrayPosition += currentPoolRawAccess.getSizeOfType() / 8;
+		}
+		else {
+			error << "Pool Raw Access Helper: Configuration Error. Size till end smaller than 0" << std::endl;
+			return result;
+		}
+		// set valid mask bit if necessary
+		if(withValidMask) {
+			if(currentPoolRawAccess.isValid()) {
+				handleMaskModification(validityMask);
 			}
 		}
-	}
-
-	result = currentDataSet.read();
-	if (result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error read raw dataset" << std::dec << std::endl;
-		return result;
-	}
-	result = currentDataSet.serialize(buffer, hkDataSize,
-			max_size, bigEndian);
-	if (result != RETURN_OK) {
-		debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
+				argStruct.max_size, argStruct.bigEndian);
+		if (result != RETURN_OK) {
+			debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+			return result;
+		}
 	}
 	return result;
 }
 
+void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
+	validityMask[validBufferIndex] =
+			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
+	validBufferIndexBit ++;
+	if(validBufferIndexBit == 8) {
+		validBufferIndex ++;
+		validBufferIndexBit = 1;
+	}
+}
+
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
 	if(position < 1 or position > 8) {
 		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 756ae286..25d8b163 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -66,6 +66,12 @@ private:
 	uint8_t validBufferIndex;
 	uint8_t validBufferIndexBit;
 
+	struct SerializationArgs {
+		uint8_t ** buffer;
+		uint32_t * size;
+		const uint32_t max_size;
+		bool bigEndian;
+	};
 	/**
 	 * Helper function to serialize single pool entries
 	 * @param pPoolIdBuffer
@@ -78,10 +84,13 @@ private:
 	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(uint8_t ** buffer,
-				int32_t * remainingParameters, uint32_t * hkDataSize,const uint32_t max_size,
-				bool bigEndian, bool withValidMask = false, uint8_t * validityMask = NULL);
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
+				int32_t * remainingParameters, bool withValidMask = false, uint8_t * validityMask = NULL);
 
+	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
+				bool withValidMask = false, uint8_t * validityMask = NULL);
+
+	void handleMaskModification(uint8_t * validityMask);
 	/**
 	 * Sets specific bit of a byte
 	 * @param byte
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 593a0ec1..c8424f05 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -9,7 +9,7 @@
  *        buffers with a header containing the buffer length.
  * @details
  * Can be used by SerialLinkedListAdapter by using this type in
- * SerializeElement<>
+ * SerializeElement<>.
  * Buffers with a size header inside that class can be declared with
  * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
  * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows

From a762c159fe334f1e1be6f448dd9ed6ea2519246b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Dec 2019 01:13:33 +0100
Subject: [PATCH 0061/1292] pool raw access helper info output commented out

---
 datapool/PoolRawAccessHelper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index b1766671..fae45b53 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -81,7 +81,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	ReturnValue_t result;
 	uint8_t arrayPosition = 0;
 	bool poolEntrySerialized = false;
-	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 		DataSet currentDataSet = DataSet();
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);

From c73cb90c3645f50794cd2919ef73fc755cc93948 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jan 2020 16:54:05 +0100
Subject: [PATCH 0062/1292] receiveTc function adapted

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 tmtcservices/TmTcBridge.h   | 6 +++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6af6d524..ddd63d47 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -14,7 +14,7 @@
 TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
 	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
 	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false) {
+	tmStored(false), size(0) {
 	TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 
@@ -55,7 +55,7 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t TmTcBridge::handleTc() {
-	ReturnValue_t result = receiveTc();
+	ReturnValue_t result = receiveTc(&recvBuffer, &size);
 	return result;
 }
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 216dae8b..8edf3f37 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -62,9 +62,11 @@ protected:
 	/**
 	 * Implemented by child class. Perform receiving of Telecommand, for example by implementing
 	 * specific drivers or wrappers, e.g. UART Communication or lwIP stack
+	 * @param recvBuffer [out] Received data
+	 * @param size [out] Size of received data
 	 * @return
 	 */
-	virtual ReturnValue_t receiveTc() = 0;
+	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, uint32_t * size) = 0;
 
 	/**
 	 * Handle Telemetry. Default implementation provided.
@@ -117,6 +119,8 @@ private:
 	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
+	uint8_t * recvBuffer;
+	uint32_t size;
 };
 
 

From 831a01e79ef7d5c5fd6885486f9a9fc7333d504e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jan 2020 17:31:17 +0100
Subject: [PATCH 0063/1292] recvBuffer and recvSize initialized

---
 tmtcservices/TmTcBridge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index ddd63d47..7cc97d0d 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -14,7 +14,7 @@
 TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
 	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
 	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false), size(0) {
+	tmStored(false),recvBuffer(NULL), size(0) {
 	TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 

From e2f07cbcd1436176c45ad8c846657436b0aed832 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jan 2020 14:01:21 +0100
Subject: [PATCH 0064/1292] connect and disconnect functions public

---
 tmtcservices/TmTcBridge.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 8edf3f37..7870e79b 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -45,6 +45,8 @@ public:
 	 */
 	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0);
 
+	void registerCommConnect();
+	void registerCommDisconnect();
 protected:
 	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
 	StorageManagerIF* tcStore;
@@ -110,9 +112,6 @@ protected:
 	 */
 	void printData(uint8_t * data, uint32_t dataLen);
 
-	void registerCommConnect();
-	void registerCommDisconnect();
-
 private:
 	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
 	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;

From f6e88e83db014f529151126d7ba5fe681604981c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jan 2020 21:12:21 +0100
Subject: [PATCH 0065/1292] debug output change

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 7cc97d0d..e402d79e 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -80,7 +80,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
-		if(not communicationLinkUp) {
+		if(communicationLinkUp == false) {
 			result = storeDownlinkData(&message);
 			return result;
 		}
@@ -92,7 +92,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			error << "UDP Server: Could not send TM packet"<< std::endl;
+			error << "TMTC Bridge: Could not send TM packet"<< std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 

From a7450144de20cb086ba5a9602bd5a7ad44fb83af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 3 Jan 2020 15:39:32 +0100
Subject: [PATCH 0066/1292] doxygen group definitions moved to framework

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++++
 subsystem/SubsystemBase.h              | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index ca0e9fe2..06c228f7 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -3,6 +3,10 @@
 
 #include <framework/devicehandlers/Cookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Communication interfaces for flight software objects
+ */
 
 /**
  * @brief This is an interface to decouple device communication from
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 3294c46d..1a050a9a 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -12,6 +12,10 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <map>
 
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
 class SubsystemBase: public SystemObject,
 		public HasModesIF,
 		public HasHealthIF,

From 827f185e20788b0b72eaf4cd5d322e78fb7cadd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jan 2020 16:37:08 +0100
Subject: [PATCH 0067/1292] Some bugfixes(?) for PusServiceBase. Getter
 Function for Serial Buffer Adapter.

---
 container/FixedMap.h              |  8 ++++----
 container/FixedOrderedMultimap.h  |  2 +-
 returnvalues/FwClassIds.h         |  1 +
 serialize/SerialBufferAdapter.cpp |  8 ++++----
 serialize/SerialBufferAdapter.h   |  2 +-
 tmtcservices/PusServiceBase.h     | 18 +++++++++++++-----
 6 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 5e8ca9c3..d664a086 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -16,8 +16,8 @@ template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
 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_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01); //!< P1: SID for HK packets
+	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02); //!< P1: SID for HK packets
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
@@ -88,10 +88,10 @@ public:
 
 	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
+			return FixedMap::KEY_ALREADY_EXISTS;
 		}
 		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
+			return FixedMap::MAP_FULL;
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 21629664..3dd20a74 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -10,7 +10,7 @@
 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_MAP;
+	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);
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index d21861c0..beef0475 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -24,6 +24,7 @@ enum {
 	MEMORY_HELPER, //MH
 	SERIALIZE_IF, //SE
 	FIXED_MAP, //FM
+	FIXED_MULTIMAP, //FMM
 	HAS_HEALTH_IF, //HHI
 	FIFO_CLASS, //FF
 	MESSAGE_PROXY, //MQP
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index d7ab0d88..a365cc99 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -96,10 +96,10 @@ uint8_t * SerialBufferAdapter<T>::getBuffer() {
 	return buffer;
 }
 
-//template<typename T>
-//void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
-//	buffer = buffer_;
-//}
+template<typename T>
+void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+	buffer = buffer_;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 0438f884..cee2cb26 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -56,7 +56,7 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
-	//void setBuffer(uint8_t * buffer_);
+	void setBuffer(uint8_t * buffer_);
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 2b5e8b67..6c8c5f61 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -46,13 +46,20 @@ public:
 	 */
 	virtual ~PusServiceBase();
 	/**
-	 * The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @brief The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @details
 	 * Implemetations can take the Telecommand in currentPacket and perform any kind of operation.
 	 * They may send additional "Start Success (1,3)" messages with the verifyReporter, but Completion
 	 * Success or Failure Reports are generated automatically after execution of this method.
-	 * If a Telecommand can not be executed within one call cycle, this Base class is not the right parent.
-	 * The child class may add additional error information in #errorParameters which are attached to the generated
-	 * verification message. Subservice checking should be implemented in this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting #errorParameters which are
+	 * attached to the generated verification message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
@@ -91,7 +98,8 @@ protected:
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint8_t errorParameter2;
+	// shouldn't this be uint32_t ? The PUS Verification Message structure param2 has the size 4
+	uint32_t errorParameter2;
 	/**
 	 * This is a complete instance of the Telecommand reception queue of the class.
 	 * It is initialized on construction of the class.

From 2ec486a8806f9c0bdf287ef81b04c6b494c592ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jan 2020 18:20:57 +0100
Subject: [PATCH 0068/1292] max number of stored packets lowered

---
 tmtcservices/TmTcBridge.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 7870e79b..8e4124e0 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -115,7 +115,7 @@ protected:
 private:
 	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
 	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 20;
+	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
 	uint8_t * recvBuffer;

From 59b25bee863987dd8a38517f95ac3dc2b780be1a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 9 Jan 2020 19:04:33 +0100
Subject: [PATCH 0069/1292] pool raw helper input buffer type changed to
 uint32_t

---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 datapool/PoolRawAccessHelper.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index fae45b53..e1ae56bf 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -8,9 +8,9 @@
 #include <framework/datapool/PoolRawAccessHelper.h>
 #include <framework/datapool/DataSet.h>
 
-PoolRawAccessHelper::PoolRawAccessHelper(uint8_t * poolIdBuffer_,
+PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
-		poolIdBuffer(poolIdBuffer_),
+		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
 		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
 }
 
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 25d8b163..e9e9c8ec 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -28,7 +28,7 @@ public:
 	 * @param poolIdBuffer_ A buffer of uint32_t pool IDs
 	 * @param numberOfParameters_ The number of parameters / pool IDs
 	 */
-	PoolRawAccessHelper(uint8_t * poolIdBuffer_, uint8_t numberOfParameters_);
+	PoolRawAccessHelper(uint32_t * poolIdBuffer_, uint8_t numberOfParameters_);
 	virtual ~PoolRawAccessHelper();
 
 	/**

From 0ce67de8c8eb8f4eb532e4445e3a1e3765ff07f2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jan 2020 00:57:09 +0100
Subject: [PATCH 0070/1292] Changes to pool access classes

1. PoolRawAccessHelper is more robust now and has better error handling
2. PoolRawAccess: Removed an unneeded constructor value, moved serialize
further to the top. Added new returnvalues and more precise error
handling for read() call
3. DataSet: Made MAX Number of data pool entries public so it can be
used by pool raw access error handling
---
 datapool/DataSet.h               |  71 +++++++-------
 datapool/PoolRawAccess.cpp       |  72 +++++++++------
 datapool/PoolRawAccess.h         | 153 ++++++++++++++++---------------
 datapool/PoolRawAccessHelper.cpp |  51 ++++++++---
 datapool/PoolRawAccessHelper.h   |   2 +
 5 files changed, 199 insertions(+), 150 deletions(-)

diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index deee8ca6..e8e1a597 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -37,44 +37,11 @@
  *	\ingroup data_pool
  */
 class DataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
-private:
+
+public:
 	//SHOULDDO we could use a linked list of datapool variables
 	static const uint8_t DATA_SET_MAX_SIZE = 63; //!< This definition sets the maximum number of variables to register in one DataSet.
 
-	/**
-	 * \brief	This array represents all pool variables registered in this set.
-	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \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 fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum 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;
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	uint8_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	uint8_t freeDataPoolLock();
-
-public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
 	static const ReturnValue_t INVALID_PARAMETER_DEFINITION =
 			MAKE_RETURN_CODE( 0x01 );
@@ -165,6 +132,40 @@ public:
 	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
 			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
 			uint32_t poolIdSize);
+private:
+	/**
+	 * \brief	This array represents all pool variables registered in this set.
+	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * \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 fill_count;
+	/**
+	 * States of the seet.
+	 */
+	enum 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;
+	/**
+	 * \brief	This is a small helper function to facilitate locking the global data pool.
+	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	uint8_t lockDataPool();
+	/**
+	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	uint8_t freeDataPoolLock();
+
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 7cc61852..c4e327b1 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -5,8 +5,7 @@
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode,
-		bool registerVectors) :
+		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
 				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
@@ -20,6 +19,7 @@ PoolRawAccess::~PoolRawAccess() {
 }
 
 ReturnValue_t PoolRawAccess::read() {
+	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		valid = read_out->getValid();
@@ -35,21 +35,30 @@ ReturnValue_t PoolRawAccess::read() {
 				memcpy(value, ptr, typeSize);
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
-				//Error value type too large.
+				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
-			//Error index requested too large
+			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
-		//Error entry does not exist.
+		result = READ_ENTRY_NON_EXISTENT;
 	}
 	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed." << std::endl;
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		error << "index too large." << std::endl;
+	}
+	else {
+		error << "entry does not exist." << std::endl;
+	}
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
-	return HasReturnvaluesIF::RETURN_FAILED;
+	return result;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -90,6 +99,32 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
+		const uint32_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
+
+
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -146,29 +181,6 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
 
 uint32_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 603bae23..432d9ad9 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -15,70 +15,17 @@
  * data pool access.
  * @ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 *  \brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * \brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	uint8_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	uint8_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	uint16_t sizeTillEnd;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
 public:
-
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 	uint8_t value[RAW_MAX_SIZE];
-	//PoolRawAccess();
+
 	/**
 	 * This constructor is used to access a data pool entry with a
 	 * given ID if the target type is not known. A DataSet object is supplied
@@ -96,25 +43,13 @@ public:
 	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-			PoolVariableIF::VAR_READ,bool registerVectors = false);
+			PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
 
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
 	 * \details	Return pointer to the buffer containing the raw data
@@ -136,6 +71,19 @@ public:
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
 			uint32_t max_size);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const;
+
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
@@ -181,6 +129,67 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
+
+protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read();
+	/**
+	 * \brief	The commit call writes back the variable's value to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
+
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 *  \brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * \brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	uint8_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	uint8_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	uint16_t sizeTillEnd;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index e1ae56bf..8c750270 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -78,45 +78,70 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(Serializa
 
 ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
 		bool withValidMask, uint8_t * validityMask) {
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_FAILED;
 	uint8_t arrayPosition = 0;
+	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	//info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
+
+		if(counter > DataSet::DATA_SET_MAX_SIZE) {
+			error << "Pool Raw Access Helper: Config error, max. number of possible data set variables exceeded" << std::endl;
+			return result;
+		}
+		counter ++;
+
 		DataSet currentDataSet = DataSet();
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset" << std::dec << std::endl;
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode "
+				  << result << std::dec << std::endl;
 			return result;
 		}
-		uint8_t remainingSize = currentPoolRawAccess.getSizeTillEnd() - currentPoolRawAccess.getSizeOfType();
-		if(remainingSize == 0) {
-			poolEntrySerialized = true;
-		}
-		else if(remainingSize > 0) {
-			arrayPosition += currentPoolRawAccess.getSizeOfType() / 8;
-		}
-		else {
-			error << "Pool Raw Access Helper: Configuration Error. Size till end smaller than 0" << std::endl;
+
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized, &arrayPosition);
+		if(result != RETURN_OK) {
+			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);
 			}
 		}
+
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data into send buffer" << std::endl;
+			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 += currentPoolRawAccess->getSizeOfType();
+	}
+	else {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
 void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	validityMask[validBufferIndex] =
 			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index e9e9c8ec..72f2324c 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -90,6 +90,8 @@ private:
 	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
 				bool withValidMask = false, uint8_t * validityMask = NULL);
 
+	ReturnValue_t checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
+			bool * isSerialized, uint8_t * arrayPosition);
 	void handleMaskModification(uint8_t * validityMask);
 	/**
 	 * Sets specific bit of a byte

From a8247eb2f0406ea78259f9a5c3f70f7b02cef15a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jan 2020 14:18:12 +0100
Subject: [PATCH 0071/1292] Some more debugging output switched on

---
 container/SimpleRingBuffer.h      | 5 +++--
 storagemanager/LocalPool.h        | 4 ++--
 tcdistribution/PUSDistributor.cpp | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 45cb0927..4552a1c0 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,8 +5,9 @@
 #include <stddef.h>
 
 /**
- * Circular buffer implementation, useful for buffering into data streams.
- * Note that the deleteData() has to be called to increment the read pointer
+ * @brief 	Circular buffer implementation, useful for buffering into data streams.
+ * @details Note that the deleteData() has to be called to increment the read pointer
+ * @ingroup containers
  */
 class SimpleRingBuffer: public RingBufferBase<> {
 public:
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 80e6a495..f8b2b730 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -294,8 +294,8 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 		if (!ignoreFault) {
 			internalErrorReporter->storeFull();
 		}
-//		error << "LocalPool( " << std::hex << getObjectId() << std::dec
-//				<< " )::reserveSpace: Packet store is full." << std::endl;
+		error << "LocalPool( " << std::hex << getObjectId() << std::dec
+				<< " )::reserveSpace: Packet store is full." << std::endl;
 	}
 	return status;
 }
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index a209620f..0f1aa7f0 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -31,7 +31,7 @@ iterator_t PUSDistributor::selectDestination() {
 	}
 
 	if (tcStatus != RETURN_OK) {
-		debug << "PUSDistributor::handlePacket: error with " << (int) tcStatus
+		debug << "PUSDistributor::handlePacket: error with 0x" << std::hex << (int) tcStatus
 				<< std::endl;
 		return this->queueMap.end();
 	} else {

From d2325e60b69650b5dde10f28dc88a929decf6527 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jan 2020 15:51:59 +0100
Subject: [PATCH 0072/1292] Import bugfix in MessageQueue.cpp

lastPartner is only assigned if receiveMessage is successful
---
 osal/FreeRTOS/MessageQueue.cpp    | 4 +++-
 tcdistribution/PUSDistributor.cpp | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 1f514cf3..887df392 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -38,7 +38,9 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
 	return status;
 }
 
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 0f1aa7f0..7b413eab 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -48,6 +48,7 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	ReturnValue_t returnValue = RETURN_OK;
 	bool errorCode = true;
 	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
 	errorCode = this->queueMap.insert(
 			std::pair<uint32_t, MessageQueueId_t>(serviceId, queue)).second;

From 1369e792b4c1f3327923c1e7418641c687bb512e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jan 2020 00:14:14 +0100
Subject: [PATCH 0073/1292] CommandingServiceBase documentation

---
 tmtcservices/CommandingServiceBase.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8ce25f00..279f9ab4 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -195,7 +195,7 @@ protected:
 	 * @param tcData Application Data of TC Packet
 	 * @param tcDataLen
 	 * @param id MessageQueue ID is stored here
-	 * @param objectId
+	 * @param objectId Object ID is extracted and stored here
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED
 	 *         - @c CSB or implementation specific return codes
@@ -206,15 +206,15 @@ protected:
 
 	/**
 	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type which is sent to
-	 * the target device. It contains all necessary information for the device to
-	 * execute telecommands.
+	 * the command is prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object.
+	 * It contains all necessary information for the device to execute telecommands.
 	 * @param message
 	 * @param subservice
 	 * @param tcData
 	 * @param tcDataLen
 	 * @param state
-	 * @param objectId
+	 * @param objectId Target object ID
 	 * @return
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
@@ -226,11 +226,11 @@ protected:
 	 * and the respective PUS Commanding Service once the execution has started.
 	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
 	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply Command Message which contains information about the command
-	 * @param previousCommand
+	 * @param reply[out] Command Message which contains information about the command
+	 * @param previousCommand [out]
 	 * @param state
 	 * @param optionalNextCommand
-	 * @param objectId
+	 * @param objectId Source object ID
 	 * @param isStep Flag value to mark steps of command execution
 	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
 	 *         - @c INVALID_REPLY can handle unrequested replies

From 01551b8fa5bf642bac0ec124eef94f192087188a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jan 2020 01:21:53 +0100
Subject: [PATCH 0074/1292] Getter function in SerialBufferAdapter

For const uint8_t *
---
 serialize/SerialBufferAdapter.cpp | 27 ++++++++++++++++++++++-----
 serialize/SerialBufferAdapter.h   | 10 +++++++++-
 2 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a365cc99..a045d37a 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,24 +1,27 @@
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <cstring>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
 		T bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(NULL), bufferLength(
-				bufferLength) {
+		currentBufferType(bufferType::CONST), serializeLength(serializeLength),
+		constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
+
 }
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
 		bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(NULL), buffer(buffer), bufferLength(
-				bufferLength) {
+		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength), constBuffer(NULL), buffer(buffer),
+		bufferLength(bufferLength) {
 }
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
 		T bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
+		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength),
+		constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
 		bufferLength(bufferLength*4) {
 }
 
@@ -93,14 +96,28 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 
 template<typename T>
 uint8_t * SerialBufferAdapter<T>::getBuffer() {
+	if(currentBufferType != NORMAL) {
+		warning << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		return 0;
+	}
 	return buffer;
 }
 
+template<typename T>
+const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
+	if(currentBufferType != CONST) {
+		warning << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		return 0;
+	}
+	return constBuffer;
+}
+
 template<typename T>
 void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
 	buffer = buffer_;
 }
 
+
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cee2cb26..6623beb3 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -28,7 +28,7 @@ public:
 	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
 
 	/**
-	 * Constructoor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
 	 * Type of length can be supplied as template type.
 	 * @param buffer
 	 * @param bufferLength
@@ -56,8 +56,16 @@ public:
 			bool bigEndian);
 
 	uint8_t * getBuffer();
+	const uint8_t * getConstBuffer();
 	void setBuffer(uint8_t * buffer_);
 private:
+
+	enum bufferType {
+		NORMAL,
+		CONST
+	};
+	bufferType currentBufferType;
+
 	bool serializeLength;
 	const uint8_t *constBuffer;
 	uint8_t *buffer;

From c7479523363c83db5e1c3c9a207a5eeee5cf5a65 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jan 2020 00:49:09 +0100
Subject: [PATCH 0075/1292] fixed map full() function added.

Pool raw access debugging
---
 container/FixedMap.h             | 9 +++++++++
 datapool/PoolRawAccess.cpp       | 1 +
 datapool/PoolRawAccessHelper.cpp | 5 +++--
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index d664a086..55a43533 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -164,6 +164,15 @@ public:
 		return theMap.maxSize();
 	}
 
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c4e327b1..66ba6218 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -38,6 +38,7 @@ ReturnValue_t PoolRawAccess::read() {
 				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
+			info << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
 			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 8c750270..de6e4802 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -92,11 +92,12 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
+		info << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode "
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
 		}
@@ -134,7 +135,7 @@ ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoo
 		*isSerialized = true;
 	}
 	else if(remainingSize > 0) {
-		*arrayPosition += currentPoolRawAccess->getSizeOfType();
+		*arrayPosition += 1;
 	}
 	else {
 		return RETURN_FAILED;

From b0d88129db48db94d4d8ed4526408c62c962e2f0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jan 2020 01:39:47 +0100
Subject: [PATCH 0076/1292] Pool Raw Access Helper bugfix

debug output commented
---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index de6e4802..646ffbb1 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -82,7 +82,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	uint8_t arrayPosition = 0;
 	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	info << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
@@ -92,7 +92,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
-		info << "Current array position: " << (int)arrayPosition << std::endl;
+		//debug << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();

From f16cce8be11be06f704fd0f141cb28dea233d802 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 13:32:21 +0100
Subject: [PATCH 0077/1292] Basic doc for thermal modules started

---
 thermal/ThermalComponent.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 93243868..7482bd9b 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -14,6 +14,9 @@ public:
 		float hysteresis;
 		float heaterSwitchoff;
 	};
+
+	// TODO: Documentaiton ,what is NOP?
+	// propably Non-operational?
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;

From 9aa57f29b81d066429f77cd163043f661062d7ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 13:52:18 +0100
Subject: [PATCH 0078/1292] basic documentation thermal

---
 thermal/AbstractTemperatureSensor.h | 9 +++++++++
 thermal/CoreComponent.h             | 1 +
 thermal/TemperatureSensor.h         | 8 ++++++++
 thermal/ThermalModule.h             | 3 +++
 4 files changed, 21 insertions(+)

diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 75437dca..3bebbe73 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -10,6 +10,15 @@
 #include "ThermalModuleIF.h"
 #include "tcsDefinitions.h"
 
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces
+ * @ingroup thermal
+ */
 class AbstractTemperatureSensor: public HasHealthIF,
 		public SystemObject,
 		public ExecutableObjectIF,
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index f7e7aff8..e21ee113 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -8,6 +8,7 @@
 #include <framework/thermal/ThermalModule.h>
 #include <framework/thermal/ThermalMonitor.h>
 
+// TODO: Documentaiton, how to use this? only use Thermal COmponent, which inherits core component?
 class CoreComponent: public ThermalComponentIF {
 public:
 	struct Parameters {
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index de280d87..cbf8ea30 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -5,6 +5,14 @@
 #include "AbstractTemperatureSensor.h"
 #include <framework/monitoring/LimitMonitor.h>
 
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details
+ *
+ *
+ */
+
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index d8ac7d73..e65560cd 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -11,6 +11,9 @@
 #include "RedundantHeater.h"
 class PowerSwitchIF;
 
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
 class ThermalModule: public ThermalModuleIF {
 	friend class ThermalController;
 public:

From 1437f33027cf60c8561eb3517418df2b16194016 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 15 Jan 2020 17:30:23 +0100
Subject: [PATCH 0079/1292] Serial Fixed Array List template type
 clarifications

---
 serialize/SerialArrayListAdapter.h      |  1 +
 serialize/SerialBufferAdapter.h         |  3 ++-
 serialize/SerialFixedArrayListAdapter.h | 22 +++++++++++++---------
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 7e2e527b..72b8d97f 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -12,6 +12,7 @@
 #include <utility>
 
 /**
+ * Also serializes length field !
  * \ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 6623beb3..b7729e31 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -11,7 +11,8 @@
  * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
  *
  * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
+ * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
  *
  * \ingroup serialize
  */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index c8424f05..4c4ec56f 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -8,34 +8,38 @@
  * @brief This adapter provides an interface for SerializeIF to serialize and deserialize
  *        buffers with a header containing the buffer length.
  * @details
+ *
  * Can be used by SerialLinkedListAdapter by using this type in
  * SerializeElement<>.
+ *
  * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<bufferType,MAX_BUFFER_LENGTH,typeOfMaxData>.
- * typeOfMaxData specifies the data type of the buffer header containing the buffer size that follows
- * and MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ * SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
+ * LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
+ * (defaults to 1 byte length field) that follows and MAX_BUFFER_LENGTH specifies
+ * the maximum allowed value for the buffer size.
+ *
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
  * @ingroup serialize
  */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter : public FixedArrayList<T, MAX_SIZE, count_t>, public SerializeIF {
+template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class SerialFixedArrayListAdapter : public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>, public SerializeIF {
 public:
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
+	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
 	uint32_t getSerializedSize() const {
-		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
 	}
 };
 

From 9bdbc2c380780ae7f523c4367560a13f1c64ca66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 16 Jan 2020 18:46:29 +0100
Subject: [PATCH 0080/1292] Endian swapper changes, Serial buffer adapter

New Serial Buffer Adapter with complete template class for buffer type.
Endian Swapper input now standard uint8_t * pointers instead of template
type. Fixed Array List new ctor, but commented out for now
---
 container/FixedArrayList.h       |   8 ++
 serialize/EndianSwapper.h        |   7 +-
 serialize/SerialBufferAdapter2.h | 139 +++++++++++++++++++++++++++++++
 3 files changed, 149 insertions(+), 5 deletions(-)
 create mode 100644 serialize/SerialBufferAdapter2.h

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index eeffcc87..ef2a82f5 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -14,6 +14,14 @@ public:
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
+	//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?
+//	FixedArrayList(T * data_, count_t count):
+//		ArrayList<T, count_t>(data, MAX_SIZE) {
+//		memcpy(data, data_, count);
+//	}
+
 	FixedArrayList(const FixedArrayList& other) :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, other.data, sizeof(this->data));
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index db170c0b..6c391316 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -48,17 +48,14 @@ public:
 	}
 
 	template<typename T>
-	static void swap(T * out, const T * in, uint32_t size) {
+	static void swap(uint8_t * out, const uint8_t * in, uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
-		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
 		for (uint8_t count = 0; count < size; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+				out[sizeof(T)* (count + 1) - i - 1] = in[count * sizeof(T) + i];
 			}
-
 		}
 
 		return;
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
new file mode 100644
index 00000000..a9613d94
--- /dev/null
+++ b/serialize/SerialBufferAdapter2.h
@@ -0,0 +1,139 @@
+#ifndef SERIALBUFFERADAPTER2_H_
+#define SERIALBUFFERADAPTER2_H_
+
+#include <framework/serialize/SerializeIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+#include <cstring>
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
+ * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename BUFFER_TYPE = uint8_t, typename count_t = uint8_t>
+class SerialBufferAdapter2: public SerializeIF {
+public:
+	/**
+	 * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+	 * Type of length can be supplied as template type.
+	 * @param buffer
+	 * @param bufferLength
+	 * @param serializeLength
+	 */
+	SerialBufferAdapter2(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+				buffer(buffer_),bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthMultiplier(sizeof(count_t));
+		if(std::is_const<BUFFER_TYPE>::value) {
+			isConst = true;
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		uint32_t serializedLength = bufferLength;
+		if (serializeLength) {
+			serializedLength += AutoSerializeAdapter::getSerializedSize(
+					&bufferLength);
+		}
+		if (*size + serializedLength > max_size) {
+			return BUFFER_TOO_SHORT;
+		} else {
+			if (serializeLength) {
+				AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+						max_size, bigEndian);
+			}
+			memcpy(*buffer, this->buffer, bufferLength);
+			*size += bufferLength;
+			(*buffer) += bufferLength;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	uint32_t getSerializedSize() const {
+		if (serializeLength) {
+			return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		} else {
+			return bufferLength;
+		}
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer,
+			int32_t* size, bool bigEndian) {
+		//TODO Ignores Endian flag!
+		//UPDATE: Endian swapper introduced. Must be tested..
+		if (buffer != NULL) {
+			if(serializeLength){
+				count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
+						&bufferLength);
+				if((*size - bufferLength - serializedSize) >= 0){
+					*buffer +=  serializedSize;
+					*size -= serializedSize;
+				}else{
+					return STREAM_TOO_SHORT;
+				}
+			}
+			//No Else If, go on with buffer
+			if (*size - bufferLength >= 0) {
+				uint8_t tmp [bufferLength];
+				uint8_t * pTmp = tmp;
+				if (bigEndian) {
+					EndianSwapper::swap<BUFFER_TYPE>(pTmp,*buffer, bufferLength);
+				} else {
+					pTmp = const_cast<uint8_t *>(*buffer);
+				}
+				*size -= bufferLength;
+				memcpy(const_cast<void *>(reinterpret_cast<const void*>(this->buffer)), pTmp, bufferLength);
+				(*buffer) += bufferLength;
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return STREAM_TOO_SHORT;
+			}
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+
+
+	uint8_t * getBuffer() {
+		return reinterpret_cast<uint8_t *>(buffer);
+	}
+
+	void setBuffer(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+		buffer = buffer_;
+		bufferLength = bufferLength_;
+		serializeLength = serializeLength_;
+		determineLengthMultiplier(sizeof(count_t));
+	}
+private:
+	BUFFER_TYPE * buffer;
+	count_t bufferLength;
+	bool serializeLength;
+
+	bool isConst = false;
+
+	void determineLengthMultiplier(uint8_t typeSize) {
+		switch(typeSize) {
+		case(2):
+			bufferLength *= 2; break;
+		case(4):
+			bufferLength *= 4; break;
+		case(8):
+			bufferLength *= 8; break;
+		default:
+			warning << "Invalid type size, assuming regular uint8_t." << std::endl;
+		}
+	}
+};
+
+
+
+#endif /* SERIALBUFFERADAPTER2_H_ */

From 1d1bb88a6f173ba3426a176fb6609e27740928cd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 16 Jan 2020 19:07:53 +0100
Subject: [PATCH 0081/1292] Merge request check

---
 container/FixedMap.h                    |   4 +-
 datapool/DataSet.cpp                    |   6 --
 datapool/DataSet.h                      |   3 -
 datapool/PoolRawAccess.cpp              |   2 +-
 devicehandlers/DeviceHandlerBase.h      |   2 -
 devicehandlers/DeviceHandlerIF.h        | 133 ++++++++++++------------
 objectmanager/ObjectManagerIF.h         |   5 +-
 serialize/SerialBufferAdapter.cpp       |   2 +-
 serialize/SerialFixedArrayListAdapter.h |  17 ++-
 serialize/SerialLinkedListAdapter.h     |   7 +-
 10 files changed, 83 insertions(+), 98 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 55a43533..39e9106d 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -16,8 +16,8 @@ template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01); //!< P1: SID for HK packets
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02); //!< P1: SID for HK packets
+	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:
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index 55d8d670..b4725c73 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -148,9 +148,3 @@ ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
 	}
 	return result;
 }
-
-ReturnValue_t DataSet::serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
-		const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
-		uint32_t poolIdSize) {
-	return RETURN_OK;
-}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index e8e1a597..8e013223 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -129,9 +129,6 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
 
-	ReturnValue_t serializeRawFromIdBuffer(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian, uint32_t * poolIdBuffer,
-			uint32_t poolIdSize);
 private:
 	/**
 	 * \brief	This array represents all pool variables registered in this set.
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 66ba6218..4eeba4f5 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -38,7 +38,7 @@ ReturnValue_t PoolRawAccess::read() {
 				result = READ_TYPE_TOO_LARGE;
 			}
 		} else {
-			info << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+			//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
 			result = READ_INDEX_TOO_LARGE;
 		}
 	} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e7ac3aa6..95e972b6 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -170,8 +170,6 @@ protected:
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 	static const MessageQueueId_t NO_COMMANDER = 0;
 
-
-
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index bfa7c7b2..ed0260d6 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -25,80 +25,79 @@ public:
 	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
 
+	//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
+	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
+	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
 
-//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-		static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-		static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-		static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-		static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-		static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
-		static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-		static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-		static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-		static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-		static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-		static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-		static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
 
-		static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-		static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-		static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-		static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-		static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-		static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-		static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-		static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-		static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-		static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-		static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-		static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-		static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-		static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
-		static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
-		static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
-		static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-		static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
-		static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-		static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-		static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-		static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-		static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-		static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-		//standard codes used in scan for reply
+	//standard codes used in scan for reply
 	//	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
-		static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
-		static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
-		static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
-		static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
 
-		//standard codes used in  interpret device reply
-		static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
-		static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
-		static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
-		static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
+	//standard codes used in  interpret device reply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
-		//Standard codes used in buildCommandFromCommand
-		static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
-				0xD0);
-		static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
-				MAKE_RETURN_CODE(0xD1);
+	//Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
+			0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
+			MAKE_RETURN_CODE(0xD1);
 
-		/**
-		 * RMAP Action that will be executed.
-		 *
-		 * This is used by the child class to tell the base class what to do.
-		 */
-		enum RmapAction_t {
-			SEND_WRITE,//!< RMAP send write
-			GET_WRITE, //!< RMAP get write
-			SEND_READ, //!< RMAP send read
-			GET_READ,  //!< RMAP get read
-			NOTHING    //!< Do nothing.
-		};
+	/**
+	 * RMAP Action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum RmapAction_t {
+		SEND_WRITE,//!< RMAP send write
+		GET_WRITE, //!< RMAP get write
+		SEND_READ, //!< RMAP send read
+		GET_READ,  //!< RMAP get read
+		NOTHING    //!< Do nothing.
+	};
 	/**
 	 * Default Destructor
 	 */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 5fbce282..1d7674c6 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -78,9 +78,8 @@ public:
 	virtual void printList() = 0;
 };
 
-/**
- * @brief Documentation can be found in the class method declration.
- */
+
+/*Documentation can be found in the class method declaration above.*/
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	SystemObjectIF* temp = this->getSystemObject(id);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a045d37a..895e9461 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,6 +1,6 @@
 #include <framework/serialize/SerialBufferAdapter.h>
-#include <cstring>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstring>
 
 template<typename T>
 SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 4c4ec56f..e6db56e1 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -9,17 +9,16 @@
  *        buffers with a header containing the buffer length.
  * @details
  *
- * Can be used by SerialLinkedListAdapter by using this type in
- * SerializeElement<>.
- *
- * Buffers with a size header inside that class can be declared with
- * SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- * LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
- * (defaults to 1 byte length field) that follows and MAX_BUFFER_LENGTH specifies
- * the maximum allowed value for the buffer size.
- *
+ * Can be used by SerialLinkedListAdapter by declaring
+ * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
  * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
  *
+ *  1. Buffers with a size header inside that class can be declared with
+ *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
+ *     (defaults to 1 byte length field) that follows
+ *
  * @ingroup serialize
  */
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index c135a2d3..ef1fa200 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -19,7 +19,7 @@
  * @details
  * An alternative to the AutoSerializeAdapter functions
  *   - All object members with a datatype are declared as SerializeElement<element_type>
- * 	   inside the class implementing this adapter.
+ * 	   members inside the class implementing this adapter.
  *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
  *     with a known size, where the size can also be serialized
  *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
@@ -29,14 +29,13 @@
  * the setStart and setNext functions.
  *
  * - The serialization process is done by instantiating the class and
- *   calling the serialize after all SerializeElement entries have been set by
- *   using a constructor or setter functions. An additional size variable can be supplied
+ *   calling serializ after all SerializeElement entries have been set by
+ *   using the constructor or setter functions. An additional size variable can be supplied
  *   which is calculated/incremented automatically
  * - The deserialization process is done by instantiating the class and supplying
  *   a buffer with the data which is converted into an object. The size of
  *   data to serialize can be supplied and is decremented in the function
  *
- *
  * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>

From 1f4391f56e5f95a44529bf89661c69c821fbb5c4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 17 Jan 2020 21:11:39 +0100
Subject: [PATCH 0082/1292] Endian Swapper buffer swapper changes reverted

---
 serialize/EndianSwapper.h | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6c391316..25fb681e 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -47,17 +47,25 @@ public:
 #endif
 	}
 
+	/**
+	 * Swap endianness of buffer entries
+	 * Template argument specifies buffer type
+	 * @param out
+	 * @param in
+	 * @param size
+	 */
 	template<typename T>
-	static void swap(uint8_t * out, const uint8_t * in, uint32_t size) {
+	static void swap(T * out, const T * in, uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
+		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
 		for (uint8_t count = 0; count < size; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out[sizeof(T)* (count + 1) - i - 1] = in[count * sizeof(T) + i];
+				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
 			}
 		}
-
 		return;
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size*sizeof(T));

From c9e4c73bd251b15c05c7d3140413ca39a2617919 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 15:03:22 +0100
Subject: [PATCH 0083/1292] Local pool public members/functions moved to top

---
 container/FixedArrayList.h        |   9 +-
 serialize/SerialBufferAdapter.cpp |   8 +-
 serialize/SerialBufferAdapter.h   |   2 +-
 serialize/SerialBufferAdapter2.h  |  57 +++++-----
 storagemanager/LocalPool.h        | 179 +++++++++++++++---------------
 5 files changed, 135 insertions(+), 120 deletions(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index ef2a82f5..b9394cfe 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -17,10 +17,11 @@ public:
 	//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?
-//	FixedArrayList(T * data_, count_t count):
-//		ArrayList<T, count_t>(data, MAX_SIZE) {
-//		memcpy(data, data_, count);
-//	}
+	FixedArrayList(T * data_, count_t count):
+		ArrayList<T, count_t>(data, MAX_SIZE) {
+		memcpy(this->data, data_, count);
+		this->size = count;
+	}
 
 	FixedArrayList(const FixedArrayList& other) :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 895e9461..ab9dae07 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -71,6 +71,11 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
+			// Suggestion (would require removing rest of the block inside this if clause !):
+			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
+			//if (result != HasReturnvaluesIF::RETURN_OK) {
+			//	return result;
+			//}
 			T serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
@@ -113,8 +118,9 @@ const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
 }
 
 template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_) {
+void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
 	buffer = buffer_;
+	bufferLength = bufferLength_;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index b7729e31..53c5dc72 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -58,7 +58,7 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t * buffer_);
+	void setBuffer(uint8_t * buffer_, T bufferLength_);
 private:
 
 	enum bufferType {
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
index a9613d94..59c79dc2 100644
--- a/serialize/SerialBufferAdapter2.h
+++ b/serialize/SerialBufferAdapter2.h
@@ -29,12 +29,18 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter2(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-				buffer(buffer_),bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthMultiplier(sizeof(count_t));
-		if(std::is_const<BUFFER_TYPE>::value) {
-			isConst = true;
-		}
+	SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+				bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+		buffer = reinterpret_cast<const uint8_t *>(buffer_);
+		constBuffer = NULL;
+	}
+
+	SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
+					bufferLength(bufferLength_), serializeLength(serializeLength_) {
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+		constBuffer = reinterpret_cast<const uint8_t *>(buffer_);
+		buffer = NULL;
 	}
 
 	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
@@ -69,9 +75,13 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer,
 			int32_t* size, bool bigEndian) {
 		//TODO Ignores Endian flag!
-		//UPDATE: Endian swapper introduced. Must be tested..
 		if (buffer != NULL) {
 			if(serializeLength){
+				// Suggestion (would require removing rest of the block inside this if clause !):
+				//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
+				//if (result != HasReturnvaluesIF::RETURN_OK) {
+				//	return result;
+				//}
 				count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 						&bufferLength);
 				if((*size - bufferLength - serializedSize) >= 0){
@@ -83,15 +93,8 @@ public:
 			}
 			//No Else If, go on with buffer
 			if (*size - bufferLength >= 0) {
-				uint8_t tmp [bufferLength];
-				uint8_t * pTmp = tmp;
-				if (bigEndian) {
-					EndianSwapper::swap<BUFFER_TYPE>(pTmp,*buffer, bufferLength);
-				} else {
-					pTmp = const_cast<uint8_t *>(*buffer);
-				}
 				*size -= bufferLength;
-				memcpy(const_cast<void *>(reinterpret_cast<const void*>(this->buffer)), pTmp, bufferLength);
+				memcpy(this->buffer, *buffer, bufferLength);
 				(*buffer) += bufferLength;
 				return HasReturnvaluesIF::RETURN_OK;
 			} else {
@@ -103,24 +106,30 @@ public:
 	}
 
 
-	uint8_t * getBuffer() {
-		return reinterpret_cast<uint8_t *>(buffer);
+	BUFFER_TYPE * getBuffer() {
+		return reinterpret_cast<BUFFER_TYPE *>(buffer);
 	}
 
-	void setBuffer(BUFFER_TYPE * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+	void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
 		buffer = buffer_;
 		bufferLength = bufferLength_;
 		serializeLength = serializeLength_;
-		determineLengthMultiplier(sizeof(count_t));
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
+	}
+
+	void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
+		constBuffer = buffer_;
+		bufferLength = bufferLength_;
+		serializeLength = serializeLength_;
+		determineLengthInBytes(sizeof(BUFFER_TYPE));
 	}
 private:
-	BUFFER_TYPE * buffer;
+	uint8_t * buffer;
+	const uint8_t * constBuffer;
 	count_t bufferLength;
 	bool serializeLength;
 
-	bool isConst = false;
-
-	void determineLengthMultiplier(uint8_t typeSize) {
+	void determineLengthInBytes(uint8_t typeSize) {
 		switch(typeSize) {
 		case(2):
 			bufferLength *= 2; break;
@@ -134,6 +143,4 @@ private:
 	}
 };
 
-
-
 #endif /* SERIALBUFFERADAPTER2_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f8b2b730..f6d5ba8a 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -39,7 +39,95 @@ public:
 	 * @brief	This definition generally sets the number of different sized pools.
 	 * @details This must be less than the maximum number of pools (currently 0xff).
 	 */
-//	static const uint32_t NUMBER_OF_POOLS;
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with \c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
+	 * @param spillsToHigherPools
+	 * 						A variable to determine whether higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Add data to local data pool, performs range check
+	 * @param storageId [out] Store ID in which the data will be stored
+	 * @param data
+	 * @param size
+	 * @param ignoreFault
+	 * @return @c RETURN_OK if write was successful
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			uint32_t size, bool ignoreFault = false);
+
+	/**
+	 * With this helper method, a free element of \c size is reserved.
+	 * @param storageId [out] storeID of the free element
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param p_data [out] pointer to the pointer of free element
+	 * @param ignoreFault
+	 * @return	Returns the storage identifier within the storage or
+	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
+	 */
+	ReturnValue_t getFreeElement(store_address_t* storageId,
+			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
+
+	/**
+	 * Retrieve data from local pool
+	 * @param packet_id
+	 * @param packet_ptr
+	 * @param size [out] Size of retrieved data
+	 * @return @c RETURN_OK if data retrieval was successfull
+	 */
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			uint32_t* size);
+
+	/**
+	 * Modify data by supplying a packet pointer and using that packet pointer
+	 * to access and modify the pool entry (via *pointer call)
+	 * @param packet_id Store ID of data to modify
+	 * @param packet_ptr [out] pointer to the pool entry to modify
+	 * @param size [out] size of pool entry
+	 * @return
+	 */
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			uint32_t* size);
+	virtual ReturnValue_t deleteData(store_address_t);
+	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
+			store_address_t* storeId = NULL);
+	void clearStore();
+	ReturnValue_t initialize();
+protected:
+	/**
+	 * With this helper method, a free element of \c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
 private:
 	/**
 	 * Indicates that this element is free.
@@ -121,93 +209,6 @@ private:
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-protected:
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-public:
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with \c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
-	 * @param spillsToHigherPools
-	 * 						A variable to determine whether higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Add data to local data pool, performs range check
-	 * @param storageId [out] Store ID in which the data will be stored
-	 * @param data
-	 * @param size
-	 * @param ignoreFault
-	 * @return @c RETURN_OK if write was successful
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			uint32_t size, bool ignoreFault = false);
-
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 *
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @return	Returns the storage identifier within the storage or
-	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
-	 */
-	ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
-
-	/**
-	 * Retrieve data from local pool
-	 * @param packet_id
-	 * @param packet_ptr
-	 * @param size [out] Size of retrieved data
-	 * @return @c RETURN_OK if data retrieval was successfull
-	 */
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
-
-	/**
-	 * Modify data by supplying a packet pointer and using that packet pointer
-	 * to access and modify the pool entry (via *pointer call)
-	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr [out] pointer to the pool entry to modify
-	 * @param size [out] size of pool entry
-	 * @return
-	 */
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
-			store_address_t* storeId = NULL);
-	void clearStore();
-	ReturnValue_t initialize();
 };
 
 template<uint8_t NUMBER_OF_POOLS>
@@ -304,7 +305,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
 		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered), spillsToHigherPools(spillsToHigherPools), internalErrorReporter(NULL) {
+		SystemObject(setObjectId, registered), internalErrorReporter(NULL), spillsToHigherPools(spillsToHigherPools){
 	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
 		this->element_sizes[n] = element_sizes[n];
 		this->n_elements[n] = n_elements[n];

From 6fe0f45c278e51b4a54a7f3a105edcafaad9f89a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 16:48:33 +0100
Subject: [PATCH 0084/1292] SerialBufferAdapter new setBuffer function

Serial Fixed Array List Adapter documentation adapted
SinglyLinkedList setEnd() function added
---
 container/SinglyLinkedList.h            | 5 +++++
 serialize/SerialBufferAdapter.cpp       | 5 +++++
 serialize/SerialBufferAdapter.h         | 1 +
 serialize/SerialFixedArrayListAdapter.h | 2 +-
 4 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 0a2e0531..5c9de6cf 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -58,6 +58,11 @@ public:
 	virtual void setNext(LinkedElement* next) {
 		this->next = next;
 	}
+
+	void setEnd() {
+		this->next = NULL;
+	}
+
 	LinkedElement* begin() {
 		return this;
 	}
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ab9dae07..6ac2894f 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -123,6 +123,11 @@ void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
 	bufferLength = bufferLength_;
 }
 
+template<typename T>
+void SerialBufferAdapter<T>::setBuffer(uint32_t * buffer_, T bufferLength_) {
+	buffer = reinterpret_cast<uint8_t *>(buffer_);
+	bufferLength = 4 * bufferLength_;
+}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 53c5dc72..600bd692 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -59,6 +59,7 @@ public:
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
 	void setBuffer(uint8_t * buffer_, T bufferLength_);
+	void setBuffer(uint32_t * buffer_, T bufferLength_);
 private:
 
 	enum bufferType {
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index e6db56e1..18a970b8 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -15,7 +15,7 @@
  *
  *  1. Buffers with a size header inside that class can be declared with
  *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed value for the buffer size.
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements in FixedArrayList
  *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
  *     (defaults to 1 byte length field) that follows
  *

From 5cb591a063cb9df22954a26e490806b5648d4061 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 18:01:37 +0100
Subject: [PATCH 0085/1292] Array List swapper for SerialFixedArrayList

---
 serialize/SerialArrayListAdapter.h      | 16 ++++++++++++++++
 serialize/SerialFixedArrayListAdapter.h |  4 ++++
 2 files changed, 20 insertions(+)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 72b8d97f..21cbbc4d 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -78,6 +78,22 @@ public:
 		}
 		return result;
 	}
+
+	/**
+	 * Swap the endianness of the Array list (not the length field !)
+	 * Useful if the case the buffer type is large than uint8_t and the endianness
+	 * is inconsistent with other SerializeElements.
+	 * @param list
+	 */
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			T newEntry = EndianSwapper::swap(list->entries[i]);
+			list->entries[i] = newEntry;
+			++i;
+		}
+	}
 private:
 	ArrayList<T, count_t> *adaptee;
 };
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 18a970b8..9613f6c1 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -40,6 +40,10 @@ public:
 			bool bigEndian) {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
 	}
+
+	void swapArrayListEndianness() {
+		SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
+	}
 };
 
 

From 424c82ce165e1da122729ce058be19a32ade7dfa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Jan 2020 23:07:43 +0100
Subject: [PATCH 0086/1292] Extracted one logic block

To increase readability
---
 datapool/PoolRawAccess.cpp | 47 ++++++++++++++++++++------------------
 datapool/PoolRawAccess.h   |  1 +
 2 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 4eeba4f5..899eedd6 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -14,33 +14,13 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {
-
-}
+PoolRawAccess::~PoolRawAccess() {}
 
 ReturnValue_t PoolRawAccess::read() {
 	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
-		valid = read_out->getValid();
-		if (read_out->getSize() > arrayEntry) {
-			arraySize = read_out->getSize();
-			typeSize = read_out->getByteSize() / read_out->getSize();
-			type = read_out->getType();
-			if (typeSize <= sizeof(value)) {
-				uint16_t arrayPosition = arrayEntry * typeSize;
-				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t* ptr =
-						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				result = READ_TYPE_TOO_LARGE;
-			}
-		} else {
-			//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-			result = READ_INDEX_TOO_LARGE;
-		}
+		result = handleReadOut(read_out);
 	} else {
 		result = READ_ENTRY_NON_EXISTENT;
 	}
@@ -62,6 +42,29 @@ ReturnValue_t PoolRawAccess::read() {
 	return result;
 }
 
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = read_out->getValid();
+	if (read_out->getSize() > arrayEntry) {
+		arraySize = read_out->getSize();
+		typeSize = read_out->getByteSize() / read_out->getSize();
+		type = read_out->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = read_out->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) read_out->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
 ReturnValue_t PoolRawAccess::commit() {
 	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 432d9ad9..5fb482f0 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -156,6 +156,7 @@ protected:
 	 */
 	ReturnValue_t commit();
 
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
 private:
 	/**
 	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id

From dba26baee6b4df5c0379f6886c7eaf12a387683d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 20 Jan 2020 23:00:23 +0100
Subject: [PATCH 0087/1292] Restructured header file

Abstract functions are closer to the top
because they must be implemented and documentation
should be near the top.
Important virtual functions moved up too.
Additional documentation added
---
 devicehandlers/DeviceHandlerBase.cpp | 167 +++++------
 devicehandlers/DeviceHandlerBase.h   | 425 ++++++++++++++-------------
 2 files changed, 306 insertions(+), 286 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0b35effd..c4f7465d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -90,6 +90,85 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	return RETURN_OK;
 }
 
+ReturnValue_t DeviceHandlerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	communicationInterface = objectManager->get<DeviceCommunicationIF>(
+			deviceCommunicationId);
+	if (communicationInterface == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = communicationInterface->open(&cookie, logicalAddress,
+			maxDeviceReplyLen);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+			AcceptsDeviceResponsesIF>(rawDataReceiverId);
+
+	if (rawReceiver == NULL) {
+		return RETURN_FAILED;
+	}
+
+	defaultRawReceiver = rawReceiver->getDeviceQueue();
+
+	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+	if (powerSwitcher == NULL) {
+		return RETURN_FAILED;
+	}
+
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = actionHelper.initialize(commandQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = fdirInstance->initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	fillCommandAndReplyMap();
+
+	//Set temperature target state to NON_OP.
+	DataSet mySet;
+	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+			PoolVariableIF::VAR_WRITE);
+	mySet.read();
+	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	mySet.commit(PoolVariableIF::VALID);
+
+	return RETURN_OK;
+
+}
+
 void DeviceHandlerBase::decrementDeviceReplyMap() {
 	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
@@ -454,7 +533,8 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
-		// We need to distinguish here, because a raw command never expects a reply. (Could be done in eRIRM, but then child implementations need to be careful.
+		//We need to distinguish here, because a raw command never expects a reply.
+		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
 	} else {
 		//always generate a failure event, so that FDIR knows what's up
@@ -474,9 +554,9 @@ void DeviceHandlerBase::doSendRead() {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		// We can't inform anyone, because we don't know which command was sent last.
-		// So, we need to wait for a timeout.
-		// but I think we can allow to ignore one missedReply.
+		//We can't inform anyone, because we don't know which command was sent last.
+		//So, we need to wait for a timeout.
+		//but I think we can allow to ignore one missedReply.
 		ignoreMissedRepliesCount++;
 		cookieInfo.state = COOKIE_UNUSED;
 	}
@@ -579,84 +659,6 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 
 }
 
-ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	if (communicationInterface == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-			AcceptsDeviceResponsesIF>(rawDataReceiverId);
-
-	if (rawReceiver == NULL) {
-		return RETURN_FAILED;
-	}
-
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
-	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-	if (powerSwitcher == NULL) {
-		return RETURN_FAILED;
-	}
-
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	fillCommandAndReplyMap();
-
-	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
-
-	return RETURN_OK;
-
-}
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
@@ -1020,7 +1022,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 	}
 }
 
-
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
 	ReturnValue_t result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 95e972b6..7503faf9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,7 +33,6 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
@@ -56,6 +55,17 @@ class StorageManagerIF;
  * Device handler instances should extend this class and implement the abstract functions.
  * Components and drivers can send so called cookies which are used for communication
  * and contain information about the communcation (e.g. slave address for I2C or RMAP structs).
+ * The following abstract methods must be implemented by a device handler:
+ *  1. doStartUp()
+ *  2. doShutDown()
+ *  3. buildTransitionDeviceCommand()
+ *  4. buildNormalDeviceCommand()
+ *  5. buildCommandFromCommand()
+ *  6. fillCommandAndReplyMap()
+ *  7. scanForReply()
+ *  8. interpretDeviceReply()
+ * Other important virtual methods with a default implementation
+ * are the getTransitionDelay() function and the getSwitches() function
  *
  * @ingroup devices
  */
@@ -75,17 +85,19 @@ public:
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
 	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 * @param fdirInstance
+	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication, uint32_t thermalStatePoolId =
-					PoolVariableIF::NO_PARAMETER,
+			object_id_t deviceCommunication,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
 
-	virtual MessageQueueId_t getCommandQueue(void) const;
-
-
 	/**
 	 * @brief This function is the device handler base core component and is called periodically.
 	 * @details
@@ -117,17 +129,214 @@ public:
 	 */
 	virtual ReturnValue_t performOperation(uint8_t counter);
 
+	/**
+	 * @brief  Initializes the device handler
+	 * @details
+	 * Initialize Device Handler as system object and
+	 * initializes all important helper classes.
+	 * Calls fillCommandAndReplyMap().
+	 * @return
+	 */
 	virtual ReturnValue_t initialize();
 
-	/**
-	 *
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 	/**
 	 * Destructor.
 	 */
 	virtual ~DeviceHandlerBase();
+protected:
+	/**
+	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
+	 *
+	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 * use the to on transition if available.
+	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
+	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 */
+	virtual void doStartUp() = 0;
+
+	/**
+	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 *
+	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
+	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
+	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 */
+	virtual void doShutDown() = 0;
+
+	/**
+	 * Build the device command to send for normal mode.
+	 *
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
+	 * different commands can built returned depending on the submode.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id that has been built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c RETURN_OK when no command is to be sent
+	 */
+	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * Build the device command to send for a transitional mode.
+	 *
+	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
+	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp() and doShutDown() as well as doTransition()
+	 *
+	 * A good idea is to implement a flag indicating a command has to be built and a variable containing the command number to be built
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c RETURN_OK when no command is to be sent
+	 */
+	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * Build a device command packet from data supplied by a direct command.
+	 *
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 *
+	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param commandData pointer to the data from the direct command
+	 * @param commandDataLen length of commandData
+	 * @return
+	 *     - @c RETURN_OK when #rawPacket is valid
+	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
+	 */
+	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t * commandData, size_t commandDataLen) = 0;
+
+	/**
+	 * @brief fill the #deviceCommandMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
+	 * This is used to let the base class know which replies are expected.
+	 * There are different scenarios regarding this:
+	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
+	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
+	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
+	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
+	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
+	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
+	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
+	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
+	 *
+	 */
+	virtual void fillCommandAndReplyMap() = 0;
+
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data.
+	 * No information check is done, e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any errors based on the return
+	 * value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
+	 * @return
+	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
+	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
+			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
+	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 */
+	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+			const uint8_t *packet) = 0;
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode.
+	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
+	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
+	 * @param 	parameter Supply a parameter of interest
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+
+	/**
+	 * Get the time needed to transit from modeFrom to modeTo.
+	 *
+	 * Used for the following transitions:
+	 * modeFrom -> modeTo:
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 *
+	 * The default implementation returns 0 !
+	 * @param modeFrom
+	 * @param modeTo
+	 * @return time in ms
+	 */
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+
+	/**
+	 * Return the switches connected to the device.
+	 *
+	 * The default implementation returns one switch set in the ctor.
+	 *
+	 * @param[out] switches pointer to an array of switches
+	 * @param[out] numberOfSwitches length of returned array
+	 * @return
+	 *      - @c RETURN_OK if the parameters were set
+	 *      - @c RETURN_FAILED if no switches exist
+	 */
+	virtual ReturnValue_t getSwitches(const uint8_t **switches,
+			uint8_t *numberOfSwitches);
+
+public:
+	/**
+	 * @param parentQueueId
+	 */
+	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
@@ -146,6 +355,8 @@ public:
 	 * @param task_ Pointer to the taskIF of this task
 	 */
 	virtual  void setTaskIF(PeriodicTaskIF* task_);
+	virtual MessageQueueId_t getCommandQueue(void) const;
+
 protected:
 	/**
 	 * The Returnvalues id of this class, required by HasReturnvaluesIF
@@ -357,41 +568,6 @@ protected:
 	 */
 	void setMode(Mode_t newMode, Submode_t submode);
 
-	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 * use the to on transition if available.
-	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
-	 */
-	virtual void doStartUp() = 0;
-
-	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
-	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
-	 */
-	virtual void doShutDown() = 0;
-
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -421,24 +597,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * Get the time needed to transit from modeFrom to modeTo.
-	 *
-	 * Used for the following transitions:
-	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
-	 *
-	 * The default implementation returns 0;
-	 *
-	 * @param modeFrom
-	 * @param modeTo
-	 * @return time in ms
-	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -460,40 +618,6 @@ protected:
 	 */
 	virtual RmapAction_t getRmapAction();
 
-	/**
-	 * Build the device command to send for normal mode.
-	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id that has been built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
-	 */
-	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * Build the device command to send for a transitional mode.
-	 *
-	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp() and doShutDown() as well as doTransition()
-	 *
-	 * A good idea is to implement a flag indicating a command has to be built and a variable containing the command number to be built
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
-	 */
-	virtual ReturnValue_t buildTransitionDeviceCommand(
-			DeviceCommandId_t * id) = 0;
-
 	/**
 	 * Build the device command to send for raw mode.
 	 *
@@ -514,52 +638,6 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
-	/**
-	 * Build a device command packet from data supplied by a direct command.
-	 *
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
-	 * @param commandData pointer to the data from the direct command
-	 * @param commandDataLen length of commandData
-	 * @return
-	 *     - @c RETURN_OK when #rawPacket is valid
-	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
-	 */
-	virtual ReturnValue_t buildCommandFromCommand(
-			DeviceCommandId_t deviceCommand, const uint8_t * commandData,
-			size_t commandDataLen) = 0;
-
-	/**
-	 * @brief fill the #deviceCommandMap
-	 *	 	  called by the initialize() of the base class
-	 * @details
-	 * This is used to let the base class know which replies are expected.
-	 * There are different scenarios regarding this:
-	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
-	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
-	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
-	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
-	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
-	 *
-	 */
-	virtual void fillCommandAndReplyMap() = 0;
-
-
-	/**
-	 * @brief   Can be implemented by child handler to
-	 *          perform debugging
-	 * @details Example: Calling this in performOperation
-	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
-	 * Please delete all debugInterface calls in DHB after debugging is finished !
-	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
@@ -608,50 +686,6 @@ protected:
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
-	/**
-	 * Scans a buffer for a valid reply.
-	 *
-	 * This is used by the base class to check the data received from the RMAP stack for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data. No
-	 * information check is done, eg range checks etc.
-	 *
-	 * Errors should be reported directly, the base class does NOT report any errors based on the return
-	 * value of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
-	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
-			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
-
-	/**
-	 * Interpret a reply from the device.
-	 *
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
-	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
-
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -675,21 +709,6 @@ protected:
 	 */
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
-	/**
-	 * Return the switches connected to the device.
-	 *
-	 * The default implementation returns one switch set in the ctor.
-	 *
-	 *
-	 * @param[out] switches pointer to an array of switches
-	 * @param[out] numberOfSwitches length of returned array
-	 * @return
-	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
-	 */
-	virtual ReturnValue_t getSwitches(const uint8_t **switches,
-			uint8_t *numberOfSwitches);
-
 	/**
 	 * notify child about mode change
 	 */

From 3d2bdae14df5427251b59bd81dc44a82f7667a34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 20 Jan 2020 23:29:36 +0100
Subject: [PATCH 0088/1292] CSB abstract functions moved to top

So documentation of functions to implement is closer to the top
---
 devicehandlers/DeviceHandlerBase.h   |  52 +++++++-----
 tmtcservices/CommandingServiceBase.h | 121 +++++++++++++--------------
 2 files changed, 92 insertions(+), 81 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 7503faf9..f16a4ff9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -39,18 +39,17 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
- * physical devices, using the @link DeviceCommunicationIF, and communication with commanding objects.
- *
- * NOTE: RMAP is a standard which is used for FLP.
- * RMAP communication is not mandatory for projects implementing the FSFW.
- * However, the communication principles are similar to RMAP as there are two write and two send calls involved.
- *
+ * physical devices, using the @link DeviceCommunicationIF @endlink, and communication with commanding objects.
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed. If data has been received (GET_READ), the data will be interpreted.
+ * For each step an RMAP action is selected and executed.
+ * If data has been received (GET_READ), the data will be interpreted.
  * The action for each step can be defined by the child class but as most device handlers share a 4-call
  * (sendRead-getRead-sendWrite-getWrite) structure, a default implementation is provided.
+ * NOTE: RMAP is a standard which is used for FLP.
+ * RMAP communication is not mandatory for projects implementing the FSFW.
+ * However, the communication principles are similar to RMAP as there are two write and two send calls involved.
  *
  * Device handler instances should extend this class and implement the abstract functions.
  * Components and drivers can send so called cookies which are used for communication
@@ -64,8 +63,9 @@ class StorageManagerIF;
  *  6. fillCommandAndReplyMap()
  *  7. scanForReply()
  *  8. interpretDeviceReply()
+ *
  * Other important virtual methods with a default implementation
- * are the getTransitionDelay() function and the getSwitches() function
+ * are the getTransitionDelayMs() function and the getSwitches() function.
  *
  * @ingroup devices
  */
@@ -233,14 +233,26 @@ protected:
 	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
-	 * - "Normal" commands. These are commands, that trigger a direct reply from the device. In this case, the id of the command should be added to the command map
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles the reply will take. Then, scanForReply returns the id of the command and the base class can handle time-out and missing replies.
-	 * - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device on its own in a defined interval. In this case, the id of the reply or a placeholder id should be added to the deviceCommandMap
-	 * with a commandData_t where maxDelayCycles is set to the maximum expected number of PST cycles between two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 * As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1, DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles. From then on, the base class handles the reception.
-	 * Then, scanForReply returns the id of the reply or the placeholder id and the base class will take care of checking that all replies are received and the interval is correct.
-	 * When the replies are disabled, DeviceCommandInfo.periodic must be set to 0, DeviceCommandInfo.delayCycles to 0;
-	 * - Aperiodic, unrequested replies. These are replies that are sent by the device without any preceding command and not in a defined interval. These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
+	 *  - "Normal" commands. These are commands, that trigger a direct reply from the device.
+	 *    In this case, the id of the command should be added to the command map
+	 *    with a commandData_t where maxDelayCycles is set to the maximum expected
+	 *    number of PST cycles the reply will take. Then, scanForReply returns
+	 *    the id of the command and the base class can handle time-out and missing replies.
+	 *  - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device
+	 *    on its own in a defined interval. In this case, the id of the reply
+	 *    or a placeholder id should be added to the deviceCommandMap with a commandData_t
+	 *    where maxDelayCycles is set to the maximum expected number of PST cycles between
+	 *    two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1,
+	 *    DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id and the base class will
+	 *    take care of checking that all replies are received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set to 0,
+	 *    DeviceCommandInfo.delayCycles to 0;
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined interval.
+	 *    These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
 	 *
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
@@ -306,10 +318,10 @@ protected:
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 279f9ab4..a62b7397 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -104,6 +104,66 @@ public:
 	};
 
 protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice
+	 * @return
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
+	 * The target message queue ID can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED
+	 *         - @c CSB or implementation specific return codes
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined,
+	 * the command is prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object.
+	 * It contains all necessary information for the device to execute telecommands.
+	 * @param message
+	 * @param subservice
+	 * @param tcData
+	 * @param tcDataLen
+	 * @param state
+	 * @param objectId Target object ID
+	 * @return
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage *message,
+			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is responsible for the communication between the Command Service Base
+	 * and the respective PUS Commanding Service once the execution has started.
+	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
+	 * There are different translations of these replies to specify how the Command Service proceeds.
+	 * @param reply[out] Command Message which contains information about the command
+	 * @param previousCommand [out]
+	 * @param state
+	 * @param optionalNextCommand
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
+	 *         - @c INVALID_REPLY can handle unrequested replies
+	 *         - Anything else triggers a TC verification failure
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage *reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage *optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
 	struct CommandInfo {
 		struct tcInfo {
 			uint8_t ackFlags;
@@ -181,67 +241,6 @@ protected:
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = NULL);
 
-	/**
-	 * Check the target subservice
-	 * @param subservice
-	 * @return
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
-	 * The target message queue ID can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED
-	 *         - @c CSB or implementation specific return codes
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object.
-	 * It contains all necessary information for the device to execute telecommands.
-	 * @param message
-	 * @param subservice
-	 * @param tcData
-	 * @param tcDataLen
-	 * @param state
-	 * @param objectId Target object ID
-	 * @return
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage *message,
-			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is responsible for the communication between the Command Service Base
-	 * and the respective PUS Commanding Service once the execution has started.
-	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
-	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply[out] Command Message which contains information about the command
-	 * @param previousCommand [out]
-	 * @param state
-	 * @param optionalNextCommand
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
-	 *         - @c INVALID_REPLY can handle unrequested replies
-	 *         - Anything else triggers a TC verification failure
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage *reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage *optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 
 	virtual void doPeriodicOperation();

From 1977942c4b2a785e503c21f5cd5cc235ee69e9ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 22 Jan 2020 14:24:48 +0100
Subject: [PATCH 0089/1292] Array List Entry swapper function

And respective SerialAdapter functions to use it
---
 container/ArrayList.h                   | 19 +++++++++++++++++++
 container/FixedArrayList.h              |  9 +++++++--
 serialize/SerialArrayListAdapter.h      | 15 ++-------------
 serialize/SerialFixedArrayListAdapter.h |  4 ++++
 serialize/SerializeElement.h            |  4 ++++
 5 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 9c4c4ceb..0a2c2ff7 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -223,6 +223,25 @@ public:
 	count_t remaining() {
 		return (maxSize_ - size);
 	}
+
+	/**
+	 * Swap the endianness of the Array list (not the length field !)
+	 * Useful if the case the buffer type is larger than uint8_t
+	 * @param list
+	 */
+	void swapArrayListEndianness() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		count_t i = 0;
+		// uint8_t buffer does not require swapping of entries.
+		if(sizeof(T) == 1) {
+			return;
+		}
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < size)) {
+			T newEntry = EndianSwapper::swap(entries[i]);
+			entries[i] = newEntry;
+			++i;
+		}
+	}
 private:
 	/**
 	 * This is the copy constructor
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index b9394cfe..36d37979 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -2,8 +2,10 @@
 #define FIXEDARRAYLIST_H_
 
 #include <framework/container/ArrayList.h>
+
 /**
- * \ingroup container
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
  */
 template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
@@ -17,10 +19,13 @@ public:
 	//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?
-	FixedArrayList(T * data_, count_t count):
+	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count);
 		this->size = count;
+		if(swapArrayListEndianess) {
+			ArrayList<T, count_t>::swapArrayListEndianness();
+		}
 	}
 
 	FixedArrayList(const FixedArrayList& other) :
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 21cbbc4d..3f80e97b 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -79,20 +79,9 @@ public:
 		return result;
 	}
 
-	/**
-	 * Swap the endianness of the Array list (not the length field !)
-	 * Useful if the case the buffer type is large than uint8_t and the endianness
-	 * is inconsistent with other SerializeElements.
-	 * @param list
-	 */
+
 	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			T newEntry = EndianSwapper::swap(list->entries[i]);
-			list->entries[i] = newEntry;
-			++i;
-		}
+		list->swapArrayListEndianness();
 	}
 private:
 	ArrayList<T, count_t> *adaptee;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 9613f6c1..67954d68 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -24,6 +24,10 @@
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
 class SerialFixedArrayListAdapter : public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>, public SerializeIF {
 public:
+	/**
+	 * Constructor Arguments are forwarded to FixedArrayList constructor
+	 * @param args
+	 */
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 4f5a22b6..cd040c0f 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -19,6 +19,10 @@
 template<typename T>
 class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
 public:
+	/**
+	 * Arguments are forwarded to the element datatype constructor
+	 * @param args
+	 */
 	template<typename... Args>
 	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
 

From d330958abb5813261936198700a2fac535aa1884 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 22 Jan 2020 14:27:11 +0100
Subject: [PATCH 0090/1292] Array List endian swapper protected now

---
 container/ArrayList.h | 55 ++++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 0a2c2ff7..59e5eef4 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -224,6 +224,34 @@ public:
 		return (maxSize_ - size);
 	}
 
+
+private:
+	/**
+	 * This is the copy constructor
+	 *
+	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
+	 * What to do in an modifying call?)
+	 *
+	 * @param other
+	 */
+	ArrayList(const ArrayList& other) :
+			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
+			allocated(false) {}
+protected:
+	/**
+	 * pointer to the array in which the entries are stored
+	 */
+	T *entries;
+	/**
+	 * remembering the maximum size
+	 */
+	uint32_t maxSize_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+
 	/**
 	 * Swap the endianness of the Array list (not the length field !)
 	 * Useful if the case the buffer type is larger than uint8_t
@@ -242,33 +270,6 @@ public:
 			++i;
 		}
 	}
-private:
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_), allocated(
-					false) {
-	}
-protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	uint32_t maxSize_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
 
 };
 #endif /* ARRAYLIST_H_ */

From 6eedb3f09748ed698ece38cb9fc5be6ebe1d3c66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 23 Jan 2020 15:45:21 +0100
Subject: [PATCH 0091/1292] New Pool List Initializer.

Needs testing !!!
---
 datapool/PoolEntry.cpp | 11 ++++++-----
 datapool/PoolEntry.h   |  3 ++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index f2968c32..af5584d8 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -2,12 +2,13 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
-	if (initValue != NULL) {
-		memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		memset(this->address, 0, this->getByteSize() );
+	if(initValue.size() == 0) {
+		memset(this->address, 0, this->getByteSize());
+	}
+	else {
+		memcpy(this->address, initValue.begin(), this->getByteSize());
 	}
 }
 
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index ce41a991..97364bf0 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -5,6 +5,7 @@
 #include <framework/datapool/PoolEntryIF.h>
 #include <stddef.h>
 #include <cstring>
+#include <initializer_list>
 /**
  * \brief		This is a small helper class that defines a single data pool entry.
  *
@@ -31,7 +32,7 @@ public:
 	 * \param set_length	Defines the array length of this entry.
 	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
-	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.

From d9fa13b6ebd597b6c23f5768405dc757b467028e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 26 Jan 2020 18:31:17 +0100
Subject: [PATCH 0092/1292] ADDED old pool entry constructor

---
 datapool/PoolEntry.cpp | 11 +++++++++++
 datapool/PoolEntry.h   |  1 +
 2 files changed, 12 insertions(+)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index af5584d8..898d226e 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -12,6 +12,17 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
 	}
 }
 
+template <typename T>
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+	this->address = new T[this->length];
+	if (initValue != NULL) {
+		memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+
 //As the data pool is global, this dtor is only be called on program exit.
 //Warning! Never copy pool entries!
 template <typename T>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 97364bf0..a02c6c60 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -33,6 +33,7 @@ public:
 	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
 	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.

From 85048cc9ee180ce6ba14485d18d85bf694e1e51f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 26 Jan 2020 22:13:56 +0100
Subject: [PATCH 0093/1292] Pool Raw Access change bugfix

---
 datapool/PoolRawAccess.cpp | 37 ++++++++++++++++++++++---------------
 datapool/PoolRawAccess.h   |  1 +
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 899eedd6..ff8fb956 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -21,24 +21,13 @@ ReturnValue_t PoolRawAccess::read() {
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		result = handleReadOut(read_out);
+		if(result == RETURN_OK) {
+			return result;
+		}
 	} else {
 		result = READ_ENTRY_NON_EXISTENT;
 	}
-	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		error << "index too large." << std::endl;
-	}
-	else {
-		error << "entry does not exist." << std::endl;
-	}
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
+	handleReadError(result);
 	return result;
 }
 
@@ -65,6 +54,24 @@ ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
 	return result;
 }
 
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		error << "entry does not exist." << std::endl;
+	}
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
 ReturnValue_t PoolRawAccess::commit() {
 	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 5fb482f0..52ba8b21 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -157,6 +157,7 @@ protected:
 	ReturnValue_t commit();
 
 	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
 private:
 	/**
 	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id

From 8f17d5147e7b13179c32fa47f2c2bdc7408e4ef5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 27 Jan 2020 00:43:01 +0100
Subject: [PATCH 0094/1292] SerialFixedArrayList constructor bugfix

---
 container/FixedArrayList.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 36d37979..12e292b4 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -21,7 +21,7 @@ public:
 	//is this feasible?
 	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, data_, count);
+		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
 		if(swapArrayListEndianess) {
 			ArrayList<T, count_t>::swapArrayListEndianness();

From 7dd4694d9d9e25114c6b52f7539ced43b8bdca3f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jan 2020 23:19:19 +0100
Subject: [PATCH 0095/1292] CCSDS time extra defined for avr lib

---
 timemanager/CCSDSTime.cpp        | 47 +++++++++++++++++++++++++++++---
 timemanager/ReceivesTimeInfoIF.h |  1 +
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 2eb6c4b5..c3a28df7 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -154,6 +154,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
+#ifdef AVR_STDIO
 	// In the size optimized nano library used by ATMEL, floating point conversion
 	// is not allowed. There is a linker flag to allow it apparently, but I
 	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
@@ -167,11 +168,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	int minute;
 	int second;
 	int usecond;
-	// try Code A (yyyy-mm-dd)
-	//int count = sscanf((char *) from, "%4hi-%2hi-%2hiT%2hi:%2hi:%fZ", &year,
-	//		&month, &day, &hour, &minute, &second);
 	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
-				&month, &day, &hour, &minute, &second, &usecond);
+			&month, &day, &hour, &minute, &second, &usecond);
 	if (count == 7) {
 		to->year = year;
 		to->month = month;
@@ -202,6 +200,47 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = usecond;
 		return RETURN_OK;
 	}
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+	//try Code A (yyyy-mm-dd)
+	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+			&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	//try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
 
 	return UNSUPPORTED_TIME_FORMAT;
 }
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 14a750c5..f65f9dad 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -7,6 +7,7 @@
 
 #ifndef RECEIVESTIMEINFOIF_H_
 #define RECEIVESTIMEINFOIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
  * This is a Interface for classes that receive timing information

From 09144b18c4fad1c9c92510f3c99ad377ddbbac58 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jan 2020 01:03:20 +0100
Subject: [PATCH 0096/1292] ccsds time changes changed

---
 timemanager/CCSDSTime.cpp | 43 +++++++++++++++++----------------------
 1 file changed, 19 insertions(+), 24 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index c3a28df7..a81f5596 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,5 +1,6 @@
 #include <framework/timemanager/CCSDSTime.h>
 #include <stdio.h>
+#include <inttypes.h>
 #include <math.h>
 
 CCSDSTime::CCSDSTime() {
@@ -154,39 +155,33 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-#ifdef AVR_STDIO
-	// In the size optimized nano library used by ATMEL, floating point conversion
-	// is not allowed. There is a linker flag to allow it apparently, but I
-	// could not manage to make it run (removing -specs=nano.specs in linker flags works though,
-	// but we propably should include this). Using floats with sscanf is also expensive.
-	// Furthermore, the stdio.c library by ATMEL can't resolve the %hhi specifiers
-	// Therefore, I adapted this function.
-	int year;
-	int month;
-	int day;
-	int hour;
-	int minute;
-	int second;
-	int usecond;
-	int count = sscanf((char *) from, "%4d-%2d-%2dT%2d:%2d:%2d.%dZ", &year,
-			&month, &day, &hour, &minute, &second, &usecond);
-	if (count == 7) {
+// Newlib can't parse uint8 (there is a configure option but I still need to figure out how to make it work..)
+#ifdef NEWLIB_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
 		to->year = year;
 		to->month = month;
 		to->day = day;
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = usecond;//(second - floor(second)) * 1000000;
+		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 
 	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4i-%3iT%2i:%2i:%2i.%iZ", &year, &day,
-			&hour, &minute, &second, &usecond);
-	if (count == 6) {
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear((uint16_t)day,(uint16_t) year,(uint8_t *) &month,
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,(uint8_t *) &month,
 				&tempDay);
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
@@ -197,7 +192,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->hour = hour;
 		to->minute = minute;
 		to->second = second;
-		to->usecond = usecond;
+		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
 #else
@@ -208,7 +203,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t minute;
 	float second;
 	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16 "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year,
 			&month, &day, &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;

From 5190e4c16e0f6618cd1c6b3a3b8f8ad7683172f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 31 Jan 2020 00:54:34 +0100
Subject: [PATCH 0097/1292] Serial Buffer dapter changes reverted

CCSDS time bugfixes in separate section (for C98)
Serial buffer adapter 2 bugfixes
---
 serialize/SerialBufferAdapter2.h            |  4 +++-
 serviceinterface/ServiceInterfaceBuffer.cpp | 14 +++++++-------
 timemanager/CCSDSTime.cpp                   | 10 ++++++----
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
index 59c79dc2..98e2d187 100644
--- a/serialize/SerialBufferAdapter2.h
+++ b/serialize/SerialBufferAdapter2.h
@@ -131,6 +131,7 @@ private:
 
 	void determineLengthInBytes(uint8_t typeSize) {
 		switch(typeSize) {
+		case(1): break;
 		case(2):
 			bufferLength *= 2; break;
 		case(4):
@@ -138,7 +139,8 @@ private:
 		case(8):
 			bufferLength *= 8; break;
 		default:
-			warning << "Invalid type size, assuming regular uint8_t." << std::endl;
+			error << "Serial Buffer Adapter 2: Invalid type size, assuming regular uint8_t." << std::endl;
+			error << "Detected type size: " << (int) typeSize << std::endl;
 		}
 	}
 };
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index d5ce6056..6798b776 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,7 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
+#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*);
@@ -21,18 +22,17 @@ int ServiceInterfaceBuffer::overflow(int c) {
 	return 0;
 }
 
-// custom stdio.c library for at91sam9g20 chip which does not support unsigned long
-// So I cast (unsigned int) on loggerTimes
 int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %u:%02u:%02u.%03u | ",
-				this->log_message.c_str(), (unsigned int) loggerTime.hour,
-				(unsigned int)  loggerTime.minute,
-				(unsigned int)  loggerTime.second,
-				(unsigned int)  loggerTime.usecond /1000);
+		sprintf(preamble, "%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%03" PRIu32 " | ",
+				this->log_message.c_str(),
+				loggerTime.hour,
+				loggerTime.minute,
+				loggerTime.second,
+				loggerTime.usecond /1000);
 		// Write log_message and time
 		this->putChars(preamble, preamble + sizeof(preamble));
 		// Handle output
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index a81f5596..8a123f85 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -155,8 +155,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
-// Newlib can't parse uint8 (there is a configure option but I still need to figure out how to make it work..)
-#ifdef NEWLIB_NO_C99_IO
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;
@@ -181,8 +182,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 			&hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,(uint8_t *) &month,
-				&tempDay);
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
 		}
@@ -195,6 +196,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement C99 I/O
 #else
 	uint16_t year;
 	uint8_t month;

From b3faf1e4adee4097b9bcc15ad61c299adacc33a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 31 Jan 2020 23:42:11 +0100
Subject: [PATCH 0098/1292] old timestring used

---
 timemanager/CCSDSTime.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8a123f85..29aafb68 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -205,8 +205,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t minute;
 	float second;
 	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16 "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year,
-			&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
+				&month, &day, &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;

From e15839b3a6cdccf3f437991262c0c2eddb6b4ba6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 15 Feb 2020 18:26:25 +0100
Subject: [PATCH 0099/1292] Thermal: Some formatting stuff, doc to do

Need to find out how to use the thermal components
---
 thermal/AbstractTemperatureSensor.h |  3 +-
 thermal/CoreComponent.h             |  2 +-
 thermal/RedundantHeater.h           | 11 +++---
 thermal/TemperatureSensor.h         | 56 +++++++++++++++++------------
 thermal/ThermalComponent.cpp        | 10 +++---
 thermal/ThermalComponent.h          | 25 +++++++++++--
 thermal/ThermalMonitor.h            |  3 ++
 7 files changed, 72 insertions(+), 38 deletions(-)

diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 3bebbe73..4b869365 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -16,7 +16,8 @@
  */
 
 /**
- * @brief Base class for Temperature Sensor, implements all important interfaces
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
  * @ingroup thermal
  */
 class AbstractTemperatureSensor: public HasHealthIF,
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index e21ee113..da77c65b 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -8,7 +8,7 @@
 #include <framework/thermal/ThermalModule.h>
 #include <framework/thermal/ThermalMonitor.h>
 
-// TODO: Documentaiton, how to use this? only use Thermal COmponent, which inherits core component?
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
 class CoreComponent: public ThermalComponentIF {
 public:
 	struct Parameters {
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 29791a9a..55d402d7 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -10,15 +10,14 @@ public:
 		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
 				uint8_t switch0Heater0, uint8_t switch1Heater0,
 				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(
-						objectIdHeater1), switch0Heater0(switch0Heater0), switch1Heater0(
-						switch1Heater0), switch0Heater1(switch0Heater1), switch1Heater1(
-						switch1Heater1) {
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
 		}
 
 		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0), switch1Heater0(
-						0), switch0Heater1(0), switch1Heater1(0) {
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
 		}
 
 		uint32_t objectIdHeater0;
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cbf8ea30..2f64f772 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -8,14 +8,17 @@
 /**
  * @brief 	This building block handles non-linear value conversion and
  * 			range checks for analog temperature sensors.
- * @details
- *
+ * @details HOW TO USE
  *
  */
 
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
+
+	/**
+	 * What are a,b and c?
+	 */
 	struct Parameters {
 		float a;
 		float b;
@@ -24,11 +27,37 @@ public:
 		T upperLimit;
 		float gradient;
 	};
+
+	/**
+	 * How to use me.
+	 * @param setObjectid
+	 * @param inputTemperature
+	 * @param poolVariable
+	 * @param vectorIndex
+	 * @param parameters
+	 * @param datapoolId
+	 * @param outputSet
+	 * @param thermalModule
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+		T *inputTemperature, PoolVariableIF *poolVariable,
+		uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
+		DataSet *outputSet, ThermalModuleIF *thermalModule) :
+
+		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+		inputTemperature(inputTemperature), poolVariable(poolVariable),
+		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+		sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+			DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+			DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,parameters.upperLimit,
+			TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
-				a(parameters.a), b(parameters.b), c(parameters.c), gradient(
-						parameters.gradient) {
-		}
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.gradient) {}
 		float a;
 		float b;
 		float c;
@@ -118,23 +147,6 @@ protected:
 	}
 
 public:
-	TemperatureSensor(object_id_t setObjectid,
-			T *inputTemperature, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
-			DataSet *outputSet, ThermalModuleIF *thermalModule) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(
-					parameters), inputTemperature(inputTemperature), poolVariable(
-					poolVariable), outputTemperature(datapoolId, outputSet,
-					PoolVariableIF::VAR_WRITE), sensorMonitor(setObjectid,
-							DOMAIN_ID_SENSOR,
-					DataPool::poolIdAndPositionToPid(
-							poolVariable->getDataPoolId(), vectorIndex),
-					DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,
-					parameters.upperLimit, TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH), oldTemperature(
-					20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-
-	}
-
 	float getTemperature() {
 		return outputTemperature;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index bf6f7398..15a2bbc9 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -12,12 +12,10 @@ ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
 				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,
-				{ parameters.lowerOpLimit, parameters.upperOpLimit,
-						parameters.heaterOn, parameters.hysteresis,
-						parameters.heaterSwitchoff }, priority,
-				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL), nopParameters(
-				{ parameters.lowerNopLimit, parameters.upperNopLimit }) {
+				thermalModule,{ parameters.lowerOpLimit, parameters.upperOpLimit,
+				parameters.heaterOn, parameters.hysteresis, parameters.heaterSwitchoff },
+				priority, ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
 ThermalComponent::~ThermalComponent() {
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 7482bd9b..4e32e97c 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -3,6 +3,9 @@
 
 #include "CoreComponent.h"
 
+/**
+ * What is it. How to use
+ */
 class ThermalComponent: public CoreComponent {
 public:
 	struct Parameters {
@@ -15,12 +18,30 @@ public:
 		float heaterSwitchoff;
 	};
 
-	// TODO: Documentaiton ,what is NOP?
-	// propably Non-operational?
+	/**
+	 * Non-Operational Temperatures
+	 */
 	struct NopParameters {
 		float lowerNopLimit;
 		float upperNopLimit;
 	};
+
+	/**
+	 * How to use.
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param sensor
+	 * @param firstRedundantSensor
+	 * @param secondRedundantSensor
+	 * @param thermalModule
+	 * @param parameters
+	 * @param priority
+	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
 			DataSet *dataSet, AbstractTemperatureSensor *sensor,
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index 6aca55ab..a38889d0 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -4,6 +4,9 @@
 #include <framework/monitoring/MonitorReporter.h>
 #include <framework/thermal/ThermalComponentIF.h>
 
+/**
+ * What does it do. How to use it.
+ */
 class ThermalMonitor: public MonitorReporter<float> {
 public:
 	template<typename ... Args>

From d8ed5bb1c15587ef853432a84a3c0334350f9ebd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 15 Feb 2020 18:55:22 +0100
Subject: [PATCH 0100/1292] some comments for missing doc

---
 tmstorage/TmStoreBackendIF.h  | 19 +++++++++++++++++++
 tmstorage/TmStoreFrontendIF.h |  8 ++++++++
 2 files changed, 27 insertions(+)

diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 162bd766..9b913b35 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -49,14 +49,33 @@ public:
 	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
 	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
 	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
 	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
 	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
 	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
 				uint32_t* deletedPackets) = 0;
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 787c3597..7d38cfc6 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -11,6 +11,14 @@ class TmStoreBackendIF;
 class TmStoreFrontendIF {
 public:
 	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	/**
 	 * Callback from the back-end to indicate a certain packet was received.

From ddae9ee80f2c74383fa4efa91082c3871b60f6d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 14:59:45 +0100
Subject: [PATCH 0101/1292] =?UTF-8?q?adapted=20temp=20sensor=20to=20use=20?=
 =?UTF-8?q?=C2=B0C=20limits,=20doc=20added?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 monitoring/LimitMonitor.h   |  11 +--
 thermal/TemperatureSensor.h | 152 +++++++++++++++++++++++-------------
 2 files changed, 105 insertions(+), 58 deletions(-)

diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 45abe48b..c24629a3 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -16,12 +16,13 @@ public:
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
-					lowerLimit), upperLimit(upperLimit), belowLowEvent(
-					belowLowEvent), aboveHighEvent(aboveHighEvent) {
-	}
-	virtual ~LimitMonitor() {
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
 	}
+
+	virtual ~LimitMonitor() {}
+
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
 		*crossedLimit = 0.0;
 		if (sample > upperLimit) {
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 2f64f772..ca0dbce6 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,105 +1,142 @@
 #ifndef TEMPERATURESENSOR_H_
 #define TEMPERATURESENSOR_H_
 
+#include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/datapool/DataSet.h>
-#include "AbstractTemperatureSensor.h"
 #include <framework/monitoring/LimitMonitor.h>
 
 /**
  * @brief 	This building block handles non-linear value conversion and
  * 			range checks for analog temperature sensors.
- * @details HOW TO USE
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
  *
+ * @ingroup thermal
  */
 
 template<typename T>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
-
 	/**
-	 * What are a,b and c?
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, for example parameters for the
+	 * Callendar-Van-Dusen equation(see datasheet of used sensor / ADC)
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in °C or in the input value
+	 * format
 	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
-		T lowerLimit;
-		T upperLimit;
-		float gradient;
+		float maxGradient;
 	};
 
 	/**
-	 * How to use me.
-	 * @param setObjectid
-	 * @param inputTemperature
-	 * @param poolVariable
-	 * @param vectorIndex
-	 * @param parameters
-	 * @param datapoolId
-	 * @param outputSet
-	 * @param thermalModule
+	 * Forward declaration for explicit instantiation of used parameters.
 	 */
-	TemperatureSensor(object_id_t setObjectid,
-		T *inputTemperature, PoolVariableIF *poolVariable,
-		uint8_t vectorIndex, Parameters parameters, uint32_t datapoolId,
-		DataSet *outputSet, ThermalModuleIF *thermalModule) :
-
-		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-		inputTemperature(inputTemperature), poolVariable(poolVariable),
-		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-		sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-			DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-			DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit,parameters.upperLimit,
-			TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
 	struct UsedParameters {
 		UsedParameters(Parameters parameters) :
 			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.gradient) {}
+			gradient(parameters.maxGradient) {}
 		float a;
 		float b;
 		float c;
 		float gradient;
 	};
 
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
+	/**
+	 * Constructor to check against raw input values
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			T *inputValue, T lowerLimit, T upperLimit, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
+	{
+		sensorMonitorRaw = new LimitMonitor<T>(setObjectid, DOMAIN_ID_SENSOR,
+				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
+		delete sensorMonitor;
+	}
+
+	/**
+	 * Constructor do check against °C values
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+		T *inputValue, float lowerLimit, float upperLimit, PoolVariableIF *poolVariable,
+		uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+		DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+		inputValue(inputValue), poolVariable(poolVariable),
+		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
+	{
+		sensorMonitor = new LimitMonitor<float>(setObjectid, DOMAIN_ID_SENSOR,
+				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
+		delete sensorMonitorRaw;
+	}
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(T inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
 
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
 
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
 private:
 	void setInvalid() {
 		outputTemperature = INVALID_TEMPERATURE;
 		outputTemperature.setValid(false);
 		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
+		sensorMonitor->setToInvalid();
 	}
 protected:
 	static const int32_t INVALID_UPTIME = 0;
 
 	UsedParameters parameters;
 
-	T *inputTemperature;
+	T * inputValue;
 
 	PoolVariableIF *poolVariable;
 
 	PoolVariable<float> outputTemperature;
 
-	LimitMonitor<T> sensorMonitor;
+	LimitMonitor<T> * sensorMonitorRaw;
+	LimitMonitor<float> * sensorMonitor;
 
 	float oldTemperature;
 	timeval uptimeOfOldTemperature;
 
-	virtual float calculateOutputTemperature(T inputTemperature) {
-		return parameters.a * inputTemperature * inputTemperature
-				+ parameters.b * inputTemperature + parameters.c;
-	}
-
 	void doChildOperation() {
 		if (!poolVariable->isValid()
 				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
@@ -107,7 +144,7 @@ protected:
 			return;
 		}
 
-		outputTemperature = calculateOutputTemperature(*inputTemperature);
+		outputTemperature = calculateOutputTemperature(*inputValue);
 		outputTemperature.setValid(PoolVariableIF::VALID);
 
 		timeval uptime;
@@ -115,7 +152,7 @@ protected:
 
 		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
 			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the gradient in DP and quite some overhead.
+			//But this would require storing the maxGradient in DP and quite some overhead.
 			//The concept of delta limits is a bit strange anyway.
 			float deltaTime;
 			float deltaTemp;
@@ -133,10 +170,10 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
-		sensorMonitor.doCheck(*inputTemperature);
+		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
+		sensorMonitor->doCheck(outputTemperature.value);
 
-		if (sensorMonitor.isOutOfLimits()) {
+		if (sensorMonitor->isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 			outputTemperature.setValid(PoolVariableIF::INVALID);
 			outputTemperature = INVALID_TEMPERATURE;
@@ -155,10 +192,19 @@ public:
 		return outputTemperature.isValid();
 	}
 
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+		ReturnValue_t result = sensorMonitor->getParameter(domainId, parameterId,
 				parameterWrapper, newValues, startAtIndex);
 		if (result != INVALID_DOMAIN_ID) {
 			return result;
@@ -186,7 +232,7 @@ public:
 	}
 
 	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
+		sensorMonitor->setToUnchecked();
 	}
 
 };

From 99b90e625d916dafe30cda283c7d75ec772376a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 16:14:29 +0100
Subject: [PATCH 0102/1292] refactored: limit type specified separately

---
 thermal/TemperatureSensor.h | 60 +++++++++++++------------------------
 1 file changed, 21 insertions(+), 39 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index ca0dbce6..00f77b24 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -13,11 +13,12 @@
  *          The temperature is calculated from an input value with
  *			the calculateOutputTemperature() function. Range checking and
  *			limit monitoring is performed automatically.
- *
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
  * @ingroup thermal
  */
 
-template<typename T>
+template<typename inputType, typename limitType = inputType>
 class TemperatureSensor: public AbstractTemperatureSensor {
 public:
 	/**
@@ -29,13 +30,15 @@ public:
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
-	 * The lower and upper limits can be specified in °C or in the input value
-	 * format
+	 * The lower and upper limits can be specified in any type, for example float for C° values
+	 * or any other type for raw values.
 	 */
 	struct Parameters {
 		float a;
 		float b;
 		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
 		float maxGradient;
 	};
 
@@ -64,39 +67,19 @@ public:
 	 * @param thermalModule respective thermal module, if it has one
 	 */
 	TemperatureSensor(object_id_t setObjectid,
-			T *inputValue, T lowerLimit, T upperLimit, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
 			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputValue(inputValue), poolVariable(poolVariable),
 			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
-	{
-		sensorMonitorRaw = new LimitMonitor<T>(setObjectid, DOMAIN_ID_SENSOR,
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
 				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
-		delete sensorMonitor;
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
 	}
 
-	/**
-	 * Constructor do check against °C values
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-		T *inputValue, float lowerLimit, float upperLimit, PoolVariableIF *poolVariable,
-		uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0},
-		DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-		AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-		inputValue(inputValue), poolVariable(poolVariable),
-		outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-		oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 })
-	{
-		sensorMonitor = new LimitMonitor<float>(setObjectid, DOMAIN_ID_SENSOR,
-				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, lowerLimit, upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH);
-		delete sensorMonitorRaw;
-	}
 
 protected:
 	/**
@@ -107,7 +90,7 @@ protected:
 	 * @param inputTemperature
 	 * @return
 	 */
-	virtual float calculateOutputTemperature(T inputValue) {
+	virtual float calculateOutputTemperature(inputType inputValue) {
 		return parameters.a * inputValue * inputValue
 				+ parameters.b * inputValue + parameters.c;
 	}
@@ -118,21 +101,20 @@ private:
 		outputTemperature = INVALID_TEMPERATURE;
 		outputTemperature.setValid(false);
 		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor->setToInvalid();
+		sensorMonitor.setToInvalid();
 	}
 protected:
 	static const int32_t INVALID_UPTIME = 0;
 
 	UsedParameters parameters;
 
-	T * inputValue;
+	inputType * inputValue;
 
 	PoolVariableIF *poolVariable;
 
 	PoolVariable<float> outputTemperature;
 
-	LimitMonitor<T> * sensorMonitorRaw;
-	LimitMonitor<float> * sensorMonitor;
+	LimitMonitor<limitType> sensorMonitor;
 
 	float oldTemperature;
 	timeval uptimeOfOldTemperature;
@@ -171,9 +153,9 @@ protected:
 		}
 
 		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
-		sensorMonitor->doCheck(outputTemperature.value);
+		sensorMonitor.doCheck(outputTemperature.value);
 
-		if (sensorMonitor->isOutOfLimits()) {
+		if (sensorMonitor.isOutOfLimits()) {
 			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
 			outputTemperature.setValid(PoolVariableIF::INVALID);
 			outputTemperature = INVALID_TEMPERATURE;
@@ -204,7 +186,7 @@ public:
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor->getParameter(domainId, parameterId,
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
 				parameterWrapper, newValues, startAtIndex);
 		if (result != INVALID_DOMAIN_ID) {
 			return result;
@@ -232,7 +214,7 @@ public:
 	}
 
 	virtual void resetOldState() {
-		sensorMonitor->setToUnchecked();
+		sensorMonitor.setToUnchecked();
 	}
 
 };

From 1001c1d48bc7aff5a88bcd58028e6f6d58777265 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 17:21:06 +0100
Subject: [PATCH 0103/1292] added new IF for thermal messages

---
 thermal/AcceptsThermalMessagesIF.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 thermal/AcceptsThermalMessagesIF.h

diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
new file mode 100644
index 00000000..e95faaaf
--- /dev/null
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -0,0 +1,18 @@
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
+
+class AcceptsThermalMessagesIF {
+public:
+	virtual ~AcceptsThermalMessagesIF();
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */

From 6ab07aeb1978d7a630944a698abebca1097b1d71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 16 Feb 2020 21:04:17 +0100
Subject: [PATCH 0104/1292] valid mask bugfixes

---
 datapool/PoolRawAccessHelper.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 646ffbb1..07ea4465 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,6 +6,9 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+
+#include <cmath>
+
 #include <framework/datapool/DataSet.h>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
@@ -41,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
-	uint8_t validityMaskSize = numberOfParameters/8;
+	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
 	for(uint8_t count = 0; count < numberOfParameters; count++) {
@@ -55,7 +58,8 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
-	memcpy(*buffer + *size, validityMask, validityMaskSize);
+
+	memcpy(*argStruct.buffer, validityMask, validityMaskSize);
 	*size += validityMaskSize;
 	validBufferIndex = 1;
 	validBufferIndexBit = 0;
@@ -114,6 +118,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 			if(currentPoolRawAccess.isValid()) {
 				handleMaskModification(validityMask);
 			}
+			validBufferIndexBit ++;
 		}
 
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
@@ -146,7 +151,6 @@ ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoo
 void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	validityMask[validBufferIndex] =
 			bitSetter(validityMask[validBufferIndex], validBufferIndexBit, true);
-	validBufferIndexBit ++;
 	if(validBufferIndexBit == 8) {
 		validBufferIndex ++;
 		validBufferIndexBit = 1;
@@ -159,6 +163,6 @@ uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool valu
 		return byte;
 	}
 	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
-	byte = (byte | value) <<  shiftNumber;
+	byte |= 1UL << shiftNumber;
 	return byte;
 }

From 54eeb71f02d1c4c4e49f25e25ed0821a7325b093 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 17 Feb 2020 21:20:51 +0100
Subject: [PATCH 0105/1292] bugfix: added implementation

---
 thermal/AcceptsThermalMessagesIF.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index e95faaaf..28c62af6 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -10,7 +10,11 @@
 
 class AcceptsThermalMessagesIF {
 public:
-	virtual ~AcceptsThermalMessagesIF();
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
 
 	virtual MessageQueueId_t getReceptionQueue() const = 0;
 };

From 7a426acece7e6fb6135f48b62f1431c894c8e711 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 21 Feb 2020 16:08:43 +0100
Subject: [PATCH 0106/1292] therm sensor doc correction

---
 thermal/TemperatureSensor.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 00f77b24..b4172670 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -25,8 +25,7 @@ public:
 	 * This structure contains parameters required for range checking
 	 * and the conversion from the input value to the output temperature.
 	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, for example parameters for the
-	 * Callendar-Van-Dusen equation(see datasheet of used sensor / ADC)
+	 * temperature from the input value, depending on the formula used.
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
@@ -56,7 +55,7 @@ public:
 	};
 
 	/**
-	 * Constructor to check against raw input values
+	 * Instantiate Temperature Sensor Object.
 	 * @param setObjectid objectId of the sensor object
 	 * @param inputValue Input value which is converted to a temperature
 	 * @param poolVariable Pool Variable to store the temperature value

From bfc7a768ce73b1db2a535d7919f24cc1b3244736 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Feb 2020 12:54:28 +0100
Subject: [PATCH 0107/1292] message queue adaptions for calls from ISR

functions moved to top
binary sempahore file init
mutex return values
---
 ipc/MessageQueueIF.h                      |  6 +-
 ipc/MessageQueueSenderIF.h                |  4 +-
 osal/Endiness.h                           |  4 +
 osal/FreeRTOS/BinarySemaphore.cpp         |  9 +++
 osal/FreeRTOS/BinarySempahore.h           | 14 ++++
 osal/FreeRTOS/MessageQueue.cpp            | 90 +++++++++++++++--------
 osal/FreeRTOS/MessageQueue.h              | 90 +++++++++++++++++------
 osal/FreeRTOS/Mutex.cpp                   | 13 ++--
 osal/FreeRTOS/Mutex.h                     |  6 +-
 serviceinterface/ServiceInterfaceBuffer.h |  2 +-
 10 files changed, 171 insertions(+), 67 deletions(-)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.cpp
 create mode 100644 osal/FreeRTOS/BinarySempahore.h

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 18e2d99a..ee2479bf 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -3,12 +3,16 @@
 
 // COULDDO: We could support blocking calls
 
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 class MessageQueueIF {
 public:
-
 	static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 9e7e11c0..6eb7733d 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -26,8 +26,8 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom =
-					MessageQueueSenderIF::NO_QUEUE, bool ignoreFault=false);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = MessageQueueSenderIF::NO_QUEUE,
+			bool ignoreFault=false);
 private:
 	MessageQueueSenderIF() {}
 };
diff --git a/osal/Endiness.h b/osal/Endiness.h
index 65cc0a10..55d0aeb3 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_OSAL_ENDINESS_H_
 #define FRAMEWORK_OSAL_ENDINESS_H_
 
+/**
+ * @defgroup osal Operating System Abstraction Layer
+ * @brief Provides clean interfaces to use OS functionalities
+ */
 
 /*
  * BSD-style endian declaration
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
new file mode 100644
index 00000000..0422f105
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -0,0 +1,9 @@
+/**
+ * @file BinarySemaphore.cpp
+ *
+ * @date 25.02.2020
+ */
+
+
+
+
diff --git a/osal/FreeRTOS/BinarySempahore.h b/osal/FreeRTOS/BinarySempahore.h
new file mode 100644
index 00000000..ab32d7b7
--- /dev/null
+++ b/osal/FreeRTOS/BinarySempahore.h
@@ -0,0 +1,14 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+
+
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 887df392..883cf261 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,11 +1,13 @@
 #include "MessageQueue.h"
+#include "task.h"
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 // TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-
+// As a first step towards this, introduces system context variable which needs to be switched manually
+// Haven't found function to find system context.
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0)  {
+defaultDestination(0),lastPartner(0), callContext(SystemContext::task_context)  {
 	handle = xQueueCreate(message_depth, max_message_size);
 	if (handle == NULL) {
 		error << "MessageQueue creation failed" << std::endl;
@@ -18,6 +20,10 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+void MessageQueue::switchSystemContext(SystemContext callContext) {
+	this->callContext = callContext;
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -27,6 +33,11 @@ ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
 ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
@@ -35,6 +46,52 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+}
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+		bool ignoreFault, SystemContext callContext) {
+	message->setSender(sentFrom);
+	BaseType_t result;
+	if(callContext == SystemContext::task_context) {
+		result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
+				reinterpret_cast<const void*>(message->getBuffer()), 0);
+	}
+	else {
+		BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+		result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
+				reinterpret_cast<const void*>(message->getBuffer()), &xHigherPriorityTaskWoken);
+		if(xHigherPriorityTaskWoken == pdTRUE) {
+			requestContextSwitch(callContext);
+		}
+	}
+	return handleSendResult(result, ignoreFault);
+}
+
+void MessageQueue::requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		portYIELD_FROM_ISR();
+	}
+}
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
@@ -73,17 +130,6 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return defaultDestination;
 }
@@ -92,23 +138,5 @@ bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
 
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	message->setSender(sentFrom);
 
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-	if (result != pdPASS) {
-		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
 
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 32f41b44..9e2d7790 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,7 +6,8 @@
 #include <framework/ipc/MessageQueueMessage.h>
 
 #include <FreeRTOS.h>
-#include <queue.h>
+#include "queue.h"
+#include "portmacro.h"
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -21,11 +22,17 @@
  *				methods to send a message to a user-defined or a default destination. In addition
  *				it also provides a reply method to answer to the queue it received its last message
  *				from.
+ *
  *				The MessageQueue should be used as "post box" for a single owning object. So all
  *				message queue communication is "n-to-one".
  *				For creating the queue, as well as sending and receiving messages, the class makes
  *				use of the operating system calls provided.
- *	\ingroup message_queue
+ *
+ *				Please keep in mind that FreeRTOS offers
+ *				different calls for message queue operations if called from an ISR.
+ *				For now, the system context needs to be switched manually.
+ *	@ingroup osal
+ *	@ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
@@ -43,11 +50,30 @@ public:
 	 * 							This should be left default.
 	 */
 	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
 	 * @details	This is accomplished by using the delete call provided by the operating system.
 	 */
 	virtual ~MessageQueue();
+
+	/*!
+	 * Used by calling function to tell the callbacks if they are being called from
+	 * within an ISR or from a regular task. This is required because FreeRTOS
+	 * has different functions for handling semaphores from within an ISR and task.
+	 */
+	typedef enum _SystemContext {
+		task_context = 0x00,//!< task_context
+		isr_context = 0xFF  //!< isr_context
+	} SystemContext;
+
+	/**
+	 * This function is used to specify whether a message queue operation is called
+	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
+	 * @param callContext
+	 */
+	void switchSystemContext(SystemContext callContext);
+
 	/**
 	 * @brief	This operation sends a message to the given destination.
 	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
@@ -74,6 +100,29 @@ public:
 	 */
 	ReturnValue_t reply( MessageQueueMessage* message );
 
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
 	 * @details	It works identically to the other receiveMessage call, but in addition returns the
@@ -107,26 +156,7 @@ public:
 	 * @brief	This method returns the message queue id of this class's message queue.
 	 */
 	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -148,12 +178,26 @@ protected:
 	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 * \param context
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, SystemContext callContex = SystemContext::task_context);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+	/**
+	 * In this function, a function dependant on the portmacro.h header function calls
+	 * to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task to unblock
+	 * and a context switch is required.
+	 */
+	static void requestContextSwitch(SystemContext callContext);
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
+	SystemContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 7c511091..456506ea 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -6,7 +6,9 @@ const uint32_t MutexIF::NO_TIMEOUT = 0;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	//TODO print error
+	if(handle == NULL) {
+		error << "Mutex creation failure" << std::endl;
+	}
 }
 
 Mutex::~Mutex() {
@@ -18,8 +20,7 @@ Mutex::~Mutex() {
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	TickType_t timeout = portMAX_DELAY;
 	if (timeoutMs != NO_TIMEOUT) {
@@ -30,8 +31,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO could not be acquired/timeout
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_TIMEOUT;
 	}
 }
 
@@ -44,7 +44,6 @@ ReturnValue_t Mutex::unlockMutex() {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO is not owner
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
 	}
 }
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 91f29585..471b1113 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -7,8 +7,10 @@
 #include <FreeRTOS.h>
 #include "semphr.h"
 
-
-
+/**
+ *
+ * @ingroup osal
+ */
 class Mutex : public MutexIF {
 public:
 	Mutex();
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 9a5f4ef8..b42c8a19 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 255;
+	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.

From 083cc7c50ac017a12061e66d6d937a82b2908c92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Feb 2020 17:04:21 +0100
Subject: [PATCH 0108/1292] sempahore wrapper extended

---
 ipc/MutexIF.h                     |  7 +++
 osal/FreeRTOS/BinarySemaphore.cpp | 86 ++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 94 +++++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySempahore.h   | 14 -----
 osal/FreeRTOS/MessageQueue.cpp    | 13 +++--
 osal/FreeRTOS/MessageQueue.h      |  1 +
 osal/FreeRTOS/Mutex.cpp           |  3 +-
 osal/FreeRTOS/Mutex.h             | 10 +++-
 returnvalues/FwClassIds.h         |  1 +
 9 files changed, 204 insertions(+), 25 deletions(-)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.h
 delete mode 100644 osal/FreeRTOS/BinarySempahore.h

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 35786d6a..a4aff1cd 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -3,6 +3,13 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ *
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
 class MutexIF {
 public:
 	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 0422f105..dd73c5b0 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,7 +3,93 @@
  *
  * @date 25.02.2020
  */
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "portmacro.h"
+#include "task.h"
 
+BinarySemaphore::BinarySemaphore() {
+	vSemaphoreCreateBinary(handle);
+	if(handle == NULL) {
+		error << "Binary semaphore creation failure" << std::endl;
+	}
+}
 
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
 
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	if(handle == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TickType_t timeout = portMAX_DELAY;
+	if(timeoutMs != 0) {
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
 
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_FOUND;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
+	if(handle == NULL) {
+		return SEMAPHORE_NOT_FOUND;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+	if (semaphore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+		BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		if(*higherPriorityTaskWoken == pdPASS) {
+			// Request context switch
+			portYIELD_FROM_ISR();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
new file mode 100644
index 00000000..afc01adf
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -0,0 +1,94 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <FreeRTOS.h>
+#include "semphr.h"
+
+/**
+ * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ * @ingroup osal
+ */
+class BinarySemaphore: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	/** Semaphore object not found */
+	static const ReturnValue_t SEMAPHORE_NOT_FOUND = MAKE_RETURN_CODE(1);
+	/** Semaphore timeout */
+	static const ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(2);
+	/** The current semaphore can not be given, because it is not owned */
+	static const ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Create a binary semaphore
+	 */
+	BinarySemaphore();
+
+	/**
+	 * Delete the binary semaphore to prevent a memory leak
+	 */
+	~BinarySemaphore();
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked for a maximum
+	 * of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+private:
+	SemaphoreHandle_t handle;
+};
+
+/**
+ * Wrapper function to give back semaphore from handle
+ * @param semaphore
+ * @return -@c RETURN_OK on success
+ *         -@c RETURN_FAILED on failure
+ */
+ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
+
+/**
+ * Wrapper function to give back semaphore from handle when called from an ISR
+ * @param semaphore
+ * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
+ *        was unblocked
+ * @return -@c RETURN_OK on success
+ *         -@c RETURN_FAILED on failure
+ */
+ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+			BaseType_t * higherPriorityTaskWoken);
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/BinarySempahore.h b/osal/FreeRTOS/BinarySempahore.h
deleted file mode 100644
index ab32d7b7..00000000
--- a/osal/FreeRTOS/BinarySempahore.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * @file BinarySempahore.h
- *
- * @date 25.02.2020
- */
-
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-
-
-
-
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 883cf261..fdca80c7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,5 +1,4 @@
 #include "MessageQueue.h"
-#include "task.h"
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -24,6 +23,12 @@ void MessageQueue::switchSystemContext(SystemContext callContext) {
 	this->callContext = callContext;
 }
 
+void MessageQueue::requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		portYIELD_FROM_ISR();
+	}
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -72,11 +77,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	return handleSendResult(result, ignoreFault);
 }
 
-void MessageQueue::requestContextSwitch(SystemContext callContext) {
-	if(callContext == SystemContext::isr_context) {
-		portYIELD_FROM_ISR();
-	}
-}
+
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 9e2d7790..cdb2a798 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -8,6 +8,7 @@
 #include <FreeRTOS.h>
 #include "queue.h"
 #include "portmacro.h"
+#include "task.h"
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 456506ea..616ef7b8 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -37,8 +37,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 
 ReturnValue_t Mutex::unlockMutex() {
 	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 471b1113..2703df4e 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
 
@@ -8,7 +8,11 @@
 #include "semphr.h"
 
 /**
+ * @brief OS component to implement MUTual EXclusion
  *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
  * @ingroup osal
  */
 class Mutex : public MutexIF {
@@ -21,4 +25,4 @@ private:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index beef0475..120d8b8c 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -60,6 +60,7 @@ enum {
 	SGP4PROPAGATOR_CLASS, //SGP4 53
 	MUTEX_IF, //MUX 54
 	MESSAGE_QUEUE_IF,//MQI 55
+	SEMAPHORE_IF, //SPH 56
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From abccd81fdfddb1fc065af32bf6c603c4c3722430 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 26 Feb 2020 16:55:35 +0100
Subject: [PATCH 0109/1292] new file for freeRTOS task management functions

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  1 -
 osal/FreeRTOS/FixedTimeslotTask.h   |  1 +
 osal/FreeRTOS/MessageQueue.cpp      |  6 -----
 osal/FreeRTOS/MessageQueue.h        | 22 +++---------------
 osal/FreeRTOS/PeriodicTask.h        |  6 ++---
 osal/FreeRTOS/TaskManagement.cpp    | 24 ++++++++++++++++++++
 osal/FreeRTOS/TaskManagement.h      | 35 +++++++++++++++++++++++++++++
 7 files changed, 66 insertions(+), 29 deletions(-)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 413d7596..a2c2e5c6 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,4 +114,3 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
-
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index bed13051..1ab8724f 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -51,6 +51,7 @@ public:
 	ReturnValue_t checkSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
+
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index fdca80c7..92c691ea 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -23,12 +23,6 @@ void MessageQueue::switchSystemContext(SystemContext callContext) {
 	this->callContext = callContext;
 }
 
-void MessageQueue::requestContextSwitch(SystemContext callContext) {
-	if(callContext == SystemContext::isr_context) {
-		portYIELD_FROM_ISR();
-	}
-}
-
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index cdb2a798..9406fdef 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -4,11 +4,11 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <FreeRTOS.h>
 #include "queue.h"
-#include "portmacro.h"
-#include "task.h"
+
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -58,16 +58,6 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	/*!
-	 * Used by calling function to tell the callbacks if they are being called from
-	 * within an ISR or from a regular task. This is required because FreeRTOS
-	 * has different functions for handling semaphores from within an ISR and task.
-	 */
-	typedef enum _SystemContext {
-		task_context = 0x00,//!< task_context
-		isr_context = 0xFF  //!< isr_context
-	} SystemContext;
-
 	/**
 	 * This function is used to specify whether a message queue operation is called
 	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
@@ -187,13 +177,7 @@ protected:
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
-	/**
-	 * In this function, a function dependant on the portmacro.h header function calls
-	 * to request a context switch can be specified.
-	 * This can be used if sending to the queue from an ISR caused a task to unblock
-	 * and a context switch is required.
-	 */
-	static void requestContextSwitch(SystemContext callContext);
+
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index e7ba8dd2..4cbffd5a 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,5 +1,5 @@
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
+#ifndef PERIODICTASK_H_
+#define PERIODICTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -107,4 +107,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* MULTIOBJECTTASK_H_ */
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 00000000..e9781769
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,24 @@
+/**
+ * @file TaskManagement.cpp
+ *
+ * @date 26.02.2020
+ *
+ */
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <FreeRTOS.h>
+#include "portmacro.h"
+#include "task.h"
+
+void requestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void requestContextSwitch(SystemContext callContext) {
+	if(callContext == SystemContext::isr_context) {
+		// This function depends on the partmacro.h definition for the specific device
+		portYIELD_FROM_ISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 00000000..74e2316f
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,35 @@
+/**
+ * @file TaskManagement.h
+ *
+ * @date 26.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+/*!
+ * Used by functions to tell if they are being called from
+ * within an ISR or from a regular task. This is required because FreeRTOS
+ * has different functions for handling semaphores and messages from within an ISR and task.
+ */
+typedef enum _SystemContext {
+	task_context = 0x00,//!< task_context
+	isr_context = 0xFF  //!< isr_context
+} SystemContext;
+
+/**
+ * In this function, a function dependant on the portmacro.h header function calls
+ * to request a context switch can be specified.
+ * This can be used if sending to the queue from an ISR caused a task to unblock
+ * and a context switch is required.
+ */
+void requestContextSwitch(SystemContext callContext);
+
+/**
+ * If task preemption in FreeRTOS is disabled, a context switch
+ * can be requested manually by calling this function.
+ */
+void requestContextSwitch(void);
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From c93ee5c6cdc0098dbcf41ff3fe4c5511534e6c69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 27 Feb 2020 19:00:51 +0100
Subject: [PATCH 0110/1292] message queue IF return values

---
 devicehandlers/DeviceCommunicationIF.h | 16 ++++++++--
 ipc/CommandMessage.h                   |  3 ++
 ipc/MessageQueueIF.h                   | 43 ++++++++++++++++----------
 osal/FreeRTOS/MutexFactory.cpp         |  3 +-
 4 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 06c228f7..546081ba 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -36,9 +36,7 @@ public:
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
 	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
 
-	virtual ~DeviceCommunicationIF() {
-
-	}
+	virtual ~DeviceCommunicationIF() {}
 
 	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
 			uint32_t maxReplyLen) = 0;
@@ -93,8 +91,20 @@ public:
 
 	virtual uint32_t getAddress(Cookie *cookie) = 0;
 
+	/**
+	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
+	 * @param cookie
+	 * @param parameter
+	 * @return
+	 */
 	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
 
+	/**
+	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
+	 * @param cookie
+	 * @param parameter
+	 * @return
+	 */
 	virtual uint32_t getParameter(Cookie *cookie) = 0;
 
 };
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 2d966063..21c393e5 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -17,6 +17,9 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef ReturnValue_t Command_t;
 
+/**
+ * @brief Used to pass command messages between tasks
+ */
 class CommandMessage : public MessageQueueMessage {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index ee2479bf..47da694c 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -58,6 +58,8 @@ public:
 	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
 	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0;
 	/**
@@ -76,33 +78,38 @@ public:
 	virtual MessageQueueId_t getId() const = 0;
 
 	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * @details	This method takes the message provided, adds the sentFrom information and passes
 	 * 			it on to the destination provided with an operating system call. The OS's return
 	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @param sendTo	This parameter specifies the message queue id to send the message to.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+
 	/**
-		 * @brief	This operation sends a message to the given destination.
-		 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-		 * 			queue id as "sentFrom" parameter.
-		 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-		 * @param message	A pointer to a previously created message, which is sent.
-		 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-		 */
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessage* message, bool ignoreFault = false ) = 0;
 
 	/**
-	 * \brief	The sendToDefaultFrom method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
+	 * @details	In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
@@ -110,6 +117,8 @@ public:
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			Implementation class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message )  = 0;
 	/**
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index cadb54fb..b3e3f02c 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,6 +1,5 @@
 #include <framework/ipc/MutexFactory.h>
-
-#include "../FreeRTOS/Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why? -> one is on heap the other on bss/data
 //MutexFactory* MutexFactory::factoryInstance = new MutexFactory();

From fa38a3760448e28109b6a73bb46e3ee50bb583a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Feb 2020 22:55:25 +0100
Subject: [PATCH 0111/1292] all context switches calls to TaskManagement.h now

---
 osal/FreeRTOS/BinarySemaphore.cpp |  8 ++++---
 osal/FreeRTOS/BinarySemaphore.h   | 38 +++++++++++++++++--------------
 osal/FreeRTOS/MessageQueue.cpp    |  2 +-
 osal/FreeRTOS/MessageQueue.h      |  5 ----
 osal/FreeRTOS/TaskManagement.cpp  |  6 +++--
 osal/FreeRTOS/TaskManagement.h    | 32 ++++++++++++++------------
 6 files changed, 48 insertions(+), 43 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index dd73c5b0..09e71f6d 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -4,6 +4,8 @@
  * @date 25.02.2020
  */
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include "portmacro.h"
 #include "task.h"
@@ -65,7 +67,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -77,7 +79,7 @@ ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	}
 }
 
-ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -86,7 +88,7 @@ ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
-			portYIELD_FROM_ISR();
+			TaskManagement::requestContextSwitch(SystemContext::isr_context);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index afc01adf..7ead0d2f 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -68,27 +68,31 @@ public:
 	 * @return
 	 */
 	SemaphoreHandle_t getSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
+	 *        was unblocked
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
 private:
 	SemaphoreHandle_t handle;
 };
 
-/**
- * Wrapper function to give back semaphore from handle
- * @param semaphore
- * @return -@c RETURN_OK on success
- *         -@c RETURN_FAILED on failure
- */
-ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
 
-/**
- * Wrapper function to give back semaphore from handle when called from an ISR
- * @param semaphore
- * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
- *        was unblocked
- * @return -@c RETURN_OK on success
- *         -@c RETURN_FAILED on failure
- */
-ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
-			BaseType_t * higherPriorityTaskWoken);
+
+
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 92c691ea..f23d9d9d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -65,7 +65,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
 				reinterpret_cast<const void*>(message->getBuffer()), &xHigherPriorityTaskWoken);
 		if(xHigherPriorityTaskWoken == pdTRUE) {
-			requestContextSwitch(callContext);
+			TaskManagement::requestContextSwitch(callContext);
 		}
 	}
 	return handleSendResult(result, ignoreFault);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 9406fdef..d8e14961 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -58,11 +58,6 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	/**
-	 * This function is used to specify whether a message queue operation is called
-	 * from within an ISR or a task. FreeRTOS offers different functions for this task.
-	 * @param callContext
-	 */
 	void switchSystemContext(SystemContext callContext);
 
 	/**
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index e9781769..573a7d7d 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -9,11 +9,11 @@
 #include "portmacro.h"
 #include "task.h"
 
-void requestContextSwitchFromTask() {
+void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
-void requestContextSwitch(SystemContext callContext) {
+void TaskManagement::requestContextSwitch(SystemContext callContext = SystemContext::task_context) {
 	if(callContext == SystemContext::isr_context) {
 		// This function depends on the partmacro.h definition for the specific device
 		portYIELD_FROM_ISR();
@@ -22,3 +22,5 @@ void requestContextSwitch(SystemContext callContext) {
 	}
 }
 
+
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 74e2316f..381e06f9 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -12,24 +12,26 @@
  * within an ISR or from a regular task. This is required because FreeRTOS
  * has different functions for handling semaphores and messages from within an ISR and task.
  */
-typedef enum _SystemContext {
+enum SystemContext {
 	task_context = 0x00,//!< task_context
 	isr_context = 0xFF  //!< isr_context
-} SystemContext;
+};
 
-/**
- * In this function, a function dependant on the portmacro.h header function calls
- * to request a context switch can be specified.
- * This can be used if sending to the queue from an ISR caused a task to unblock
- * and a context switch is required.
- */
-void requestContextSwitch(SystemContext callContext);
-
-/**
- * If task preemption in FreeRTOS is disabled, a context switch
- * can be requested manually by calling this function.
- */
-void requestContextSwitch(void);
+class TaskManagement {
+public:
+	/**
+	 * In this function, a function dependant on the portmacro.h header function calls
+	 * to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task to unblock
+	 * and a context switch is required.
+	 */
+	static void requestContextSwitch(SystemContext callContext);
 
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void requestContextSwitchFromTask(void);
+};
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 6d6c78b255407dc08979dbfbf927b9e4dd54db44 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 29 Feb 2020 01:21:36 +0100
Subject: [PATCH 0112/1292] task management doc

---
 osal/FreeRTOS/TaskManagement.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index e9781769..f94c0fde 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -9,6 +9,12 @@
 #include "portmacro.h"
 #include "task.h"
 
+/**
+ * TODO: This stuff is hardware and architecture and mission dependant...
+ * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
+ * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
+ * 	     not be necessary anyway. Maybe there is a better solution?
+ */
 void requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }

From d0e8eb386ce45b3aa99f8d1413b2c05b1db079d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Mar 2020 01:00:17 +0100
Subject: [PATCH 0113/1292] renamed system context to call context

to avoid conflicts with ISIS library, I don't want to fiddle with
it if we don't have source code
---
 devicehandlers/CommunicationMessage.cpp |  9 +++
 devicehandlers/CommunicationMessage.h   | 82 +++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.cpp       |  2 +-
 osal/FreeRTOS/MessageQueue.cpp          |  8 +--
 osal/FreeRTOS/MessageQueue.h            |  6 +-
 osal/FreeRTOS/TaskManagement.cpp        |  4 +-
 osal/FreeRTOS/TaskManagement.h          |  9 +--
 7 files changed, 106 insertions(+), 14 deletions(-)
 create mode 100644 devicehandlers/CommunicationMessage.cpp
 create mode 100644 devicehandlers/CommunicationMessage.h

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
new file mode 100644
index 00000000..6dddc5be
--- /dev/null
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -0,0 +1,9 @@
+/**
+ * @file CommunicationMessage.cpp
+ *
+ * @date 28.02.2020
+ */
+
+
+
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
new file mode 100644
index 00000000..70c1052a
--- /dev/null
+++ b/devicehandlers/CommunicationMessage.h
@@ -0,0 +1,82 @@
+/**
+ * @file CommunicationMessage.h
+ *
+ * @date 28.02.2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+/**
+ * @brief Used to pass communication information between tasks
+ *
+ * @details
+ * Can be used to pass information like data pointers and
+ * data sizes between communication tasks
+ * like the Device Handler Comm Interfaces and Polling Tasks.
+ *
+ * Can also be used to exchange actual data if its not too large
+ * (e.g. Sensor values).
+ *
+ */
+class CommunicationMessage: public MessageQueueMessage {
+public:
+	enum communicationStatus {
+		SEND_DATA,
+		PROCESS_DATA,
+		FAULTY,
+	};
+
+	//Add other messageIDs here if necessary.
+	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
+
+	CommunicationMessage();
+
+	/**
+	 * Send requests with pointer to the data to be sent and send data length
+	 * @param address Target Address
+	 * @param sendData
+	 * @param length
+	 */
+	void setSendRequest(uint32_t address, const uint8_t * sendData, uint32_t length);
+
+	/**
+	 * Data message with data stored in IPC store
+	 * @param address
+	 * @param length
+	 * @param storeId
+	 */
+	void setDataMessage(uint32_t address, uint32_t length, store_address_t * storeId);
+
+	/**
+	 * Data message with data stored in actual message.
+	 * 4 byte datafield is intialized with 0.
+	 * Set data with specific setter functions.
+	 */
+	void setDataMessage(uint32_t address, uint32_t length);
+
+private:
+	void setCommunicationStatus(communicationStatus status);
+	void setAddress(uint32_t address);
+	void setSendData(const uint8_t * sendData);
+	void setDataLen(uint32_t length);
+
+	/** For low size data, maximum of 4 bytes can be sent */
+	void setDataByte1(uint8_t byte1);
+	void setDataByte2(uint8_t byte2);
+	void setDataByte3(uint8_t byte3);
+	void setDataByte4(uint8_t byte4);
+
+	void setDataUINT16_1(uint16_t data1);
+	void setDataUINT16_2(uint16_t data2);
+
+	void setData(uint32_t data);
+
+	virtual ~CommunicationMessage();
+};
+
+
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 09e71f6d..c3d57387 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -88,7 +88,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
-			TaskManagement::requestContextSwitch(SystemContext::isr_context);
+			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index f23d9d9d..cc38e77d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -6,7 +6,7 @@
 // As a first step towards this, introduces system context variable which needs to be switched manually
 // Haven't found function to find system context.
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0), callContext(SystemContext::task_context)  {
+defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
 	handle = xQueueCreate(message_depth, max_message_size);
 	if (handle == NULL) {
 		error << "MessageQueue creation failed" << std::endl;
@@ -19,7 +19,7 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
-void MessageQueue::switchSystemContext(SystemContext callContext) {
+void MessageQueue::switchSystemContext(CallContext callContext) {
 	this->callContext = callContext;
 }
 
@@ -53,10 +53,10 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault, SystemContext callContext) {
+		bool ignoreFault, CallContext callContext) {
 	message->setSender(sentFrom);
 	BaseType_t result;
-	if(callContext == SystemContext::task_context) {
+	if(callContext == CallContext::task) {
 		result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
 				reinterpret_cast<const void*>(message->getBuffer()), 0);
 	}
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index d8e14961..8edfed10 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -58,7 +58,7 @@ public:
 	 */
 	virtual ~MessageQueue();
 
-	void switchSystemContext(SystemContext callContext);
+	void switchSystemContext(CallContext callContext);
 
 	/**
 	 * @brief	This operation sends a message to the given destination.
@@ -168,7 +168,7 @@ protected:
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, SystemContext callContex = SystemContext::task_context);
+			bool ignoreFault=false, CallContext callContex = CallContext::task);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
@@ -177,7 +177,7 @@ private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
-	SystemContext callContext; //!< Stores the current system context
+	CallContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 573a7d7d..40a0f395 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -13,8 +13,8 @@ void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
-void TaskManagement::requestContextSwitch(SystemContext callContext = SystemContext::task_context) {
-	if(callContext == SystemContext::isr_context) {
+void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
+	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
 		portYIELD_FROM_ISR();
 	} else {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 381e06f9..fd2bfc0b 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -12,9 +12,10 @@
  * within an ISR or from a regular task. This is required because FreeRTOS
  * has different functions for handling semaphores and messages from within an ISR and task.
  */
-enum SystemContext {
-	task_context = 0x00,//!< task_context
-	isr_context = 0xFF  //!< isr_context
+
+enum CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
 };
 
 class TaskManagement {
@@ -25,7 +26,7 @@ public:
 	 * This can be used if sending to the queue from an ISR caused a task to unblock
 	 * and a context switch is required.
 	 */
-	static void requestContextSwitch(SystemContext callContext);
+	static void requestContextSwitch(CallContext callContext);
 
 	/**
 	 * If task preemption in FreeRTOS is disabled, a context switch

From dd4a5a45e3a25ce5bbbedfdd37a407273b62ac54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 3 Mar 2020 21:20:08 +0100
Subject: [PATCH 0114/1292] communication message extended

---
 devicehandlers/CommunicationMessage.cpp |  95 +++++++++++++++++++++
 devicehandlers/CommunicationMessage.h   | 105 +++++++++++++++++++-----
 devicehandlers/DeviceCommunicationIF.h  |   3 +-
 devicehandlers/FixedSequenceSlot.h      |   2 +-
 4 files changed, 183 insertions(+), 22 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 6dddc5be..8f9d1eb6 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -4,6 +4,101 @@
  * @date 28.02.2020
  */
 
+#include <framework/devicehandlers/CommunicationMessage.h>
+#include <cstring>
+
+CommunicationMessage::CommunicationMessage(): uninitialized(true) {
+}
+
+void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
+		uint32_t dataLen, const uint8_t * data) {
+	setMessageType(SEND_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(SEND_DATA_FROM_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId);
+}
+
+void CommunicationMessage::setSendRequestRaw(uint32_t address) {
+}
+
+void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(REPLY_DATA_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId);
+}
+void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
+		uint32_t dataLen, uint8_t *data) {
+}
+
+void CommunicationMessage::setDataReplyRaw(uint32_t address,
+		uint32_t length, uint16_t receiveBufferPosition) {
+	setMessageType(REPLY_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(receiveBufferPosition != 0) {
+		setReceiveBufferPosition(receiveBufferPosition);
+	}
+}
+
+
+
+void CommunicationMessage::setMessageType(messageType status) {
+	uint8_t status_uint8 = status;
+	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
+}
+
+void CommunicationMessage::setAddress(uint32_t address) {
+	memcpy(getData(),&address,sizeof(address));
+}
+
+void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t),
+			&bufferPosition, sizeof(bufferPosition));
+}
+
+void CommunicationMessage::setDataPointer(const uint8_t *sendData) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &sendData, sizeof(uint32_t));
+}
+
+void CommunicationMessage::setStoreId(store_address_t storeId) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId, sizeof(store_address_t));
+}
+
+void CommunicationMessage::setDataLen(uint32_t length) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
+}
+
+void CommunicationMessage::setDataByte1(uint8_t byte1) {
+}
+
+void CommunicationMessage::setDataByte2(uint8_t byte2) {
+}
+
+void CommunicationMessage::setDataByte3(uint8_t byte3) {
+}
+
+void CommunicationMessage::setDataByte4(uint8_t byte4) {
+}
+
+void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
+}
+
+void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
+}
+
+void CommunicationMessage::setData(uint32_t data) {
+}
+
+CommunicationMessage::~CommunicationMessage() {
+}
+
+
 
 
 
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 70c1052a..fe744fd6 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -6,6 +6,8 @@
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
 #define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include <framework/devicehandlers/CommunicationMessage.h>
+
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 
@@ -23,9 +25,13 @@
  */
 class CommunicationMessage: public MessageQueueMessage {
 public:
-	enum communicationStatus {
-		SEND_DATA,
-		PROCESS_DATA,
+	enum messageType {
+		SEND_DATA_FROM_POINTER,
+		SEND_DATA_FROM_IPC_STORE,
+		SEND_DATA_RAW,
+		REPLY_DATA_FROM_POINTER,
+		REPLY_DATA_IPC_STORE,
+		REPLY_DATA_RAW,
 		FAULTY,
 	};
 
@@ -36,34 +42,60 @@ public:
 
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address
-	 * @param sendData
-	 * @param length
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
 	 */
-	void setSendRequest(uint32_t address, const uint8_t * sendData, uint32_t length);
+	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
+
+	/**
+	 * Send requests with a store ID, using the IPC store
+	 * @param address Target Address, first four bytes
+	 * @param storeId Store ID in the IPC store
+	 *
+	 */
+	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Send requests with data length and data in message (max. 4 bytes)
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestRaw(uint32_t address);
 
 	/**
 	 * Data message with data stored in IPC store
-	 * @param address
+	 * @param address Target Address, first four bytes
 	 * @param length
 	 * @param storeId
 	 */
-	void setDataMessage(uint32_t address, uint32_t length, store_address_t * storeId);
+	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Data reply with data stored in buffer, passing the pointer to
+	 * the buffer and the data size
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to the data
+	 */
+	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
 
 	/**
 	 * Data message with data stored in actual message.
 	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions.
+	 * Set data with specific setter functions below.
+	 * Can also be used to supply information at which position the raw data should be stored
+	 * in a receive buffer.
 	 */
-	void setDataMessage(uint32_t address, uint32_t length);
+	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
 
-private:
-	void setCommunicationStatus(communicationStatus status);
-	void setAddress(uint32_t address);
-	void setSendData(const uint8_t * sendData);
-	void setDataLen(uint32_t length);
-
-	/** For low size data, maximum of 4 bytes can be sent */
+	/*
+	 * The following functions can be used to
+	 * set the data field (4 bytes possible);
+	 */
 	void setDataByte1(uint8_t byte1);
 	void setDataByte2(uint8_t byte2);
 	void setDataByte3(uint8_t byte3);
@@ -74,9 +106,42 @@ private:
 
 	void setData(uint32_t data);
 
+private:
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(uint32_t address);
+
+	/**
+	 * Stored in Bytes 13-16 of message data
+	 * @param length
+	 */
+	void setDataLen(uint32_t length);
+
+	/**
+	 * Stored in last four bytes (Bytes 17-20) of message data
+	 * @param sendData
+	 */
+	void setDataPointer(const uint8_t * sendData);
+
+	/**
+	 * Buffer Position is stored as the seventh and eigth byte of
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now
+	 * @param bufferPosition
+	 */
+	void setReceiveBufferPosition(uint16_t bufferPosition);
+	void setStoreId(store_address_t storeId);
+
 	virtual ~CommunicationMessage();
+
+	bool uninitialized;
 };
 
-
-
 #endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 546081ba..e03db26b 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -22,7 +22,8 @@
  *   4. Read received data
  *
  *  To identify different connection over a single interface can return so-called cookies to components.
- *
+ *  The CommunicationMessage message type can be used to extend the functionality of the
+ *  ComIF if a separate polling task is required.
  */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h
index 5aff0f4f..0ed285b3 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/devicehandlers/FixedSequenceSlot.h
@@ -31,7 +31,7 @@ public:
 	 * \brief	This attribute defines when a device handler object is executed.
 	 *
 	 * \details	The pollingTime attribute identifies the time the handler is executed in ms. It must be
-	 * 			smaller than the period length of the polling sequence, what is ensured by automated calculation
+	 * 			smaller than the period length of the polling sequence, which is ensured by automated calculation
 	 * 			from a database.
 	 */
 	uint32_t	pollingTimeMs;

From fb6172fdc51a6e76513437ec74ed733da3847e1f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 4 Mar 2020 00:37:58 +0100
Subject: [PATCH 0115/1292] communication message continued.

Some fixed timeslot task improvements
---
 devicehandlers/CommunicationMessage.cpp | 40 +++++++++++++++-------
 devicehandlers/CommunicationMessage.h   | 44 +++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h      |  7 +++-
 devicehandlers/FixedSlotSequence.h      |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp     |  4 +++
 5 files changed, 65 insertions(+), 32 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 8f9d1eb6..5c042487 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -10,6 +10,8 @@
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
 }
 
+CommunicationMessage::~CommunicationMessage() {}
+
 void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
 		uint32_t dataLen, const uint8_t * data) {
 	setMessageType(SEND_DATA_FROM_POINTER);
@@ -24,7 +26,10 @@ void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_ad
 	setStoreId(storeId);
 }
 
-void CommunicationMessage::setSendRequestRaw(uint32_t address) {
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length) {
+	setMessageType(SEND_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
 }
 
 void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
@@ -34,6 +39,10 @@ void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_addr
 }
 void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
 		uint32_t dataLen, uint8_t *data) {
+	setMessageType(REPLY_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
 }
 
 void CommunicationMessage::setDataReplyRaw(uint32_t address,
@@ -46,8 +55,6 @@ void CommunicationMessage::setDataReplyRaw(uint32_t address,
 	}
 }
 
-
-
 void CommunicationMessage::setMessageType(messageType status) {
 	uint8_t status_uint8 = status;
 	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
@@ -62,8 +69,8 @@ void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
 			&bufferPosition, sizeof(bufferPosition));
 }
 
-void CommunicationMessage::setDataPointer(const uint8_t *sendData) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &sendData, sizeof(uint32_t));
+void CommunicationMessage::setDataPointer(const void * data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
 }
 
 void CommunicationMessage::setStoreId(store_address_t storeId) {
@@ -74,31 +81,40 @@ void CommunicationMessage::setDataLen(uint32_t length) {
 	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
 }
 
+void CommunicationMessage::setData(uint32_t data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
+}
+
 void CommunicationMessage::setDataByte1(uint8_t byte1) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &byte1, sizeof(byte1));
 }
 
 void CommunicationMessage::setDataByte2(uint8_t byte2) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint8_t), &byte2, sizeof(byte2));
 }
 
 void CommunicationMessage::setDataByte3(uint8_t byte3) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + 2* sizeof(uint8_t), &byte3, sizeof(byte3));
 }
 
 void CommunicationMessage::setDataByte4(uint8_t byte4) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + 3* sizeof(uint8_t), &byte4, sizeof(byte4));
 }
 
 void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data1, sizeof(data1));
 }
 
 void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
+	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint16_t), &data2, sizeof(data2));
 }
 
-void CommunicationMessage::setData(uint32_t data) {
+CommunicationMessage::messageType CommunicationMessage::getMessageType() {
+	messageType messageType;
+	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
+	return messageType;
 }
 
-CommunicationMessage::~CommunicationMessage() {
+void CommunicationMessage::clearCommunicationMessage() {
+	messageType messageType = getMessageType();
 }
-
-
-
-
-
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index fe744fd6..805dd9a8 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -39,6 +39,7 @@ public:
 	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
 
 	CommunicationMessage();
+	virtual ~CommunicationMessage();
 
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
@@ -64,7 +65,7 @@ public:
 	 * @param data Pointer to data to send
 	 *
 	 */
-	void setSendRequestRaw(uint32_t address);
+	void setSendRequestRaw(uint32_t address, uint32_t length);
 
 	/**
 	 * Data message with data stored in IPC store
@@ -92,6 +93,22 @@ public:
 	 */
 	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
 
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(uint32_t address);
+
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType();
+
+	void setMessageId(uint8_t messageId);
+	messageType getMessageId();
+
 	/*
 	 * The following functions can be used to
 	 * set the data field (4 bytes possible);
@@ -106,19 +123,6 @@ public:
 
 	void setData(uint32_t data);
 
-private:
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(uint32_t address);
-
 	/**
 	 * Stored in Bytes 13-16 of message data
 	 * @param length
@@ -129,19 +133,23 @@ private:
 	 * Stored in last four bytes (Bytes 17-20) of message data
 	 * @param sendData
 	 */
-	void setDataPointer(const uint8_t * sendData);
+	void setDataPointer(const void * data);
 
 	/**
 	 * Buffer Position is stored as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
 	 * @param bufferPosition
 	 */
 	void setReceiveBufferPosition(uint16_t bufferPosition);
 	void setStoreId(store_address_t storeId);
 
-	virtual ~CommunicationMessage();
+	/**
+	 * Clear the message
+	 */
+	void clearCommunicationMessage();
+private:
 
-	bool uninitialized;
+	bool uninitialized; //!< Could be used to warn if data has not been set.
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f16a4ff9..98808d87 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,6 +33,11 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
@@ -91,7 +96,7 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(uint32_t logicalAddress, object_id_t setObjectId,
+	DeviceHandlerBase(address_t logicalAddress, object_id_t setObjectId,
 			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			object_id_t deviceCommunication,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index f8fd9a36..d72de913 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -104,7 +104,7 @@ protected:
 	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
 	 * 			device handler objects.
 	 *
-	 * \details	The slot list is a std:list object that contains all created OPUSPollingSlot instances.
+	 * @details	The slot list is a std:list object that contains all created PollingSlot instances.
 	 * 			They are NOT ordered automatically, so by adding entries, the correct order needs to be ensured.
 	 * 			By iterating through this list the polling sequence is executed. Two entries with identical
 	 * 			polling times are executed immediately one after another.
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index a2c2e5c6..604a10b8 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,6 +58,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
+		if(slotTimeMs == 0) {
+			// FreeRTOS throws errors for zero values
+			slotTimeMs = 1;
+		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 43ac0ec04bbaffc1f7a23b478fd747396a3a4ad4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 4 Mar 2020 23:07:54 +0100
Subject: [PATCH 0116/1292] Communication Message continued

---
 devicehandlers/CommunicationMessage.cpp | 129 +++++++++++++++++++-----
 devicehandlers/CommunicationMessage.h   |  76 +++++++++-----
 devicehandlers/DeviceCommunicationIF.h  |   7 +-
 3 files changed, 160 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 5c042487..028e8a2e 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <framework/devicehandlers/CommunicationMessage.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
@@ -23,19 +24,23 @@ void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
 void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
 	setMessageType(SEND_DATA_FROM_IPC_STORE);
 	setAddress(address);
-	setStoreId(storeId);
+	setStoreId(storeId.raw);
 }
 
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length) {
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
+		uint16_t sendBufferPosition) {
 	setMessageType(SEND_DATA_RAW);
 	setAddress(address);
 	setDataLen(length);
+	if(sendBufferPosition != 0) {
+		setBufferPosition(sendBufferPosition);
+	}
 }
 
 void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
 	setMessageType(REPLY_DATA_IPC_STORE);
 	setAddress(address);
-	setStoreId(storeId);
+	setStoreId(storeId.raw);
 }
 void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
 		uint32_t dataLen, uint8_t *data) {
@@ -51,7 +56,7 @@ void CommunicationMessage::setDataReplyRaw(uint32_t address,
 	setAddress(address);
 	setDataLen(length);
 	if(receiveBufferPosition != 0) {
-		setReceiveBufferPosition(receiveBufferPosition);
+		setBufferPosition(receiveBufferPosition);
 	}
 }
 
@@ -60,61 +65,137 @@ void CommunicationMessage::setMessageType(messageType status) {
 	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
 }
 
-void CommunicationMessage::setAddress(uint32_t address) {
+void CommunicationMessage::setAddress(address_t address) {
 	memcpy(getData(),&address,sizeof(address));
 }
 
-void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t),
+address_t CommunicationMessage::getAddress() const {
+	address_t address;
+	memcpy(&address,getData(),sizeof(address));
+	return address;
+}
+
+void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
 			&bufferPosition, sizeof(bufferPosition));
 }
 
+uint16_t CommunicationMessage::getBufferPosition() const {
+	uint16_t bufferPosition;
+	memcpy(&bufferPosition,
+			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
+	return bufferPosition;
+}
+
 void CommunicationMessage::setDataPointer(const void * data) {
 	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
 }
 
 void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId, sizeof(store_address_t));
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
+}
+
+store_address_t CommunicationMessage::getStoreId() const{
+	store_address_t temp;
+	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
+	return temp;
 }
 
 void CommunicationMessage::setDataLen(uint32_t length) {
 	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
 }
 
-void CommunicationMessage::setData(uint32_t data) {
+uint32_t CommunicationMessage::getDataLen() const {
+	uint32_t len;
+	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
+	return len;
+}
+
+void CommunicationMessage::setUint32Data(uint32_t data) {
 	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
 }
 
-void CommunicationMessage::setDataByte1(uint8_t byte1) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &byte1, sizeof(byte1));
+uint32_t CommunicationMessage::getUint32Data() const{
+	uint32_t data;
+	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
+	return data;
 }
 
-void CommunicationMessage::setDataByte2(uint8_t byte2) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint8_t), &byte2, sizeof(byte2));
+void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
+	if(0 <= position && position <= 3) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
+	}
+	else {
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataByte3(uint8_t byte3) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + 2* sizeof(uint8_t), &byte3, sizeof(byte3));
+uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
+	if(0 <= position && position <= 3) {
+		uint8_t byte;
+		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
+		return byte;
+	}
+	else {
+		return 0;
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataByte4(uint8_t byte4) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + 3* sizeof(uint8_t), &byte4, sizeof(byte4));
+void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
+	if(position == 0 || position == 1) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
+	}
+	else {
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
+
 }
 
-void CommunicationMessage::setDataUINT16_1(uint16_t data1) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data1, sizeof(data1));
+uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
+	if(position == 0 || position == 1) {
+		uint16_t data;
+		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
+		return data;
+	}
+	else {
+		return 0;
+		error << "Comm Message: Invalid byte position" << std::endl;
+	}
 }
 
-void CommunicationMessage::setDataUINT16_2(uint16_t data2) {
-	memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint16_t), &data2, sizeof(data2));
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() {
+CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
 	messageType messageType;
 	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
 	return messageType;
 }
 
+void CommunicationMessage::setMessageId(uint8_t messageId) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
+}
+
+uint8_t CommunicationMessage::getMessageId() const {
+	uint8_t messageId;
+	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
+	return messageId;
+}
+
 void CommunicationMessage::clearCommunicationMessage() {
 	messageType messageType = getMessageType();
+	switch(messageType) {
+	case(messageType::REPLY_DATA_IPC_STORE):
+	case(messageType::SEND_DATA_FROM_IPC_STORE): {
+		store_address_t storeId = getStoreId();
+		StorageManagerIF *ipcStore = objectManager->
+				get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(storeId);
+		}
+	}
+	/* NO BREAK falls through*/
+	default:
+		memset(getData(),0,4*sizeof(uint32_t));
+		break;
+	}
 }
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 805dd9a8..a92c4b5c 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -10,6 +10,7 @@
 
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/devicehandlers/DeviceHandlerBase.h>
 
 /**
  * @brief Used to pass communication information between tasks
@@ -26,6 +27,7 @@
 class CommunicationMessage: public MessageQueueMessage {
 public:
 	enum messageType {
+		NONE,
 		SEND_DATA_FROM_POINTER,
 		SEND_DATA_FROM_IPC_STORE,
 		SEND_DATA_RAW,
@@ -41,6 +43,24 @@ public:
 	CommunicationMessage();
 	virtual ~CommunicationMessage();
 
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType() const;
+
+	/**
+	 * This is a unique ID which can be used to handle different kinds of messages.
+	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
+	 * (e.g. sensor values) and data stored in the IPC store.
+	 * The ID can be used to distinguish the messages in child implementations.
+	 * The message ID is stored as the sixth byte of the message data.
+	 * @param messageId
+	 */
+	void setMessageId(uint8_t messageId);
+	uint8_t getMessageId() const;
+
 	/**
 	 * Send requests with pointer to the data to be sent and send data length
 	 * @param address Target Address, first four bytes
@@ -65,7 +85,8 @@ public:
 	 * @param data Pointer to data to send
 	 *
 	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length);
+	void setSendRequestRaw(uint32_t address, uint32_t length,
+			uint16_t sendBufferPosition = 0);
 
 	/**
 	 * Data message with data stored in IPC store
@@ -97,31 +118,27 @@ public:
 	 * First four bytes of message data
 	 * @param address
 	 */
-	void setAddress(uint32_t address);
+	void setAddress(address_t address);
+
+	address_t getAddress() const;
+	/**
+	 * Set byte as position of 4 byte data field
+	 * @param byte
+	 * @param position Position, 0 to 3 possible
+	 */
+	void setDataByte(uint8_t byte, uint8_t position);
+	uint8_t getDataByte(uint8_t position) const;
 
 	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
+	 * Set 2 byte value at position 1 or 2 of data field
+	 * @param data
+	 * @param position 0 or 1 possible
 	 */
-	void setMessageType(messageType status);
-	messageType getMessageType();
+	void setDataUint16(uint16_t data, uint8_t position);
+	uint16_t getDataUint16(uint8_t position) const;
 
-	void setMessageId(uint8_t messageId);
-	messageType getMessageId();
-
-	/*
-	 * The following functions can be used to
-	 * set the data field (4 bytes possible);
-	 */
-	void setDataByte1(uint8_t byte1);
-	void setDataByte2(uint8_t byte2);
-	void setDataByte3(uint8_t byte3);
-	void setDataByte4(uint8_t byte4);
-
-	void setDataUINT16_1(uint16_t data1);
-	void setDataUINT16_2(uint16_t data2);
-
-	void setData(uint32_t data);
+	void setUint32Data(uint32_t data);
+	uint32_t getUint32Data() const;
 
 	/**
 	 * Stored in Bytes 13-16 of message data
@@ -129,6 +146,8 @@ public:
 	 */
 	void setDataLen(uint32_t length);
 
+	uint32_t getDataLen() const;
+
 	/**
 	 * Stored in last four bytes (Bytes 17-20) of message data
 	 * @param sendData
@@ -136,19 +155,22 @@ public:
 	void setDataPointer(const void * data);
 
 	/**
-	 * Buffer Position is stored as the seventh and eigth byte of
+	 * In case the send request data or reply data is to be stored in a buffer,
+	 * a buffer Position can be stored here as the seventh and eigth byte of
 	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition
+	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
 	 */
-	void setReceiveBufferPosition(uint16_t bufferPosition);
+	void setBufferPosition(uint16_t bufferPosition);
+	uint16_t getBufferPosition() const;
 	void setStoreId(store_address_t storeId);
+	store_address_t getStoreId() const;
 
 	/**
-	 * Clear the message
+	 * Clear the message. Deletes IPC Store data
+	 * and sets all data to 0. Also sets message type to NONE
 	 */
 	void clearCommunicationMessage();
 private:
-
 	bool uninitialized; //!< Could be used to warn if data has not been set.
 };
 
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index e03db26b..99904510 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -73,10 +73,15 @@ public:
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * @param cookie
+	 * @return
+	 */
 	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
 
 	/**
-	 * Called by DHB in the GET_WIRTE doGetRead().
+	 * Called by DHB in the GET_WRITE doGetRead().
 	 * This function is used to receive data from the physical device
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie

From 22e4dabd1bf778c1a4c32aa76d8bf72b99936576 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 15:39:42 +0100
Subject: [PATCH 0117/1292] BinSemaphore reset function added

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 +++++
 osal/FreeRTOS/BinarySemaphore.h   | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c3d57387..d429f1a0 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -79,6 +79,11 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	}
 }
 
+void BinarySemaphore::resetSemaphore() {
+	vSemaphoreDelete(handle);
+	vSemaphoreCreateBinary(handle);
+}
+
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == NULL) {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 7ead0d2f..a809f0bb 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -69,6 +69,11 @@ public:
 	 */
 	SemaphoreHandle_t getSemaphore();
 
+	/**
+	 * Reset the semaphore.
+	 */
+	void resetSemaphore();
+
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore

From 68cda479d699ef0f5c73b9ee95c352e178171896 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 18:48:48 +0100
Subject: [PATCH 0118/1292] DHB: performOperation Hook + polling counter

polling counter to specify how often communication opertions are
performed, however this still needs to be changed..
---
 container/FixedMap.h                 |  2 +-
 container/group.h                    |  8 +++-----
 devicehandlers/DeviceHandlerBase.cpp | 20 +++++++++++++++++---
 devicehandlers/DeviceHandlerBase.h   | 25 +++++++++++++++++++++++--
 4 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 39e9106d..f5ee4244 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -9,7 +9,7 @@
  * @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.
+ * 	        iterate through map entries. Complexity O(n).
  * @ingroup container
  */
 template<typename key_t, typename T>
diff --git a/container/group.h b/container/group.h
index 5a39d34e..9c70d523 100644
--- a/container/group.h
+++ b/container/group.h
@@ -4,11 +4,9 @@
 /**
  * @defgroup container Container
  *
- * 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.
+ * General Purpose Containers to store various elements.
+ * As opposed to the STL library implementation, these implementations
+ * don't  allocate memory dynamically.
  */
 
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c4f7465d..1252d61f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,8 +32,9 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+		pollingFrequency(1), pollingCounter(1), timeoutStart(0), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
+		deviceSwitch(setDeviceSwitch)
 {
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
@@ -63,10 +64,20 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
+
+	if (pollingCounter != pollingFrequency) {
+		pollingCounter ++;
+		return RETURN_OK;
+	}
+	else {
+		pollingCounter = 1;
+	}
+
 	switch (getRmapAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,6 +98,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
+
 	return RETURN_OK;
 }
 
@@ -166,7 +178,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -1278,3 +1289,6 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t obje
 uint32_t DeviceHandlerBase::getLogicalAddress() {
 	return logicalAddress;
 }
+
+void DeviceHandlerBase::performOperationHook() {
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 98808d87..130aedb9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -18,9 +18,9 @@
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapool/HkSwitchHelper.h>
 #include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <map>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
+#include <map>
 
 namespace Factory{
 void setStaticFrameworkObjectIds();
@@ -88,7 +88,7 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
+	 * @param maxDeviceReplyLen the largest allowed reply size
 	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
 	 * @param thermalStatePoolId
@@ -349,6 +349,12 @@ protected:
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
+	/**
+	 * Can be used to perform device specific periodic operations.
+	 * This is called on the SEND_READ step of the performOperation() call
+	 */
+	virtual void performOperationHook();
+
 public:
 	/**
 	 * @param parentQueueId
@@ -934,6 +940,19 @@ private:
 	*/
 	const uint32_t logicalAddress;
 
+	/**
+	 * Polling Frequency which specifies how often the communication functions
+	 * and functionalities are called.
+	 *
+	 * This is not a time value. The time value depends on the
+	 * respective period time of the polling sequence table.
+	 * The actual time frequency can be calculated by multiplying that period
+	 * with the polling frequency value. Defaults to 1 (communication operations called
+	 * in each performOperation()).
+	 */
+	uint32_t pollingFrequency;
+	uint32_t pollingCounter;
+
 	/**
 	 * Used for timing out mode transitions.
 	 *
@@ -981,6 +1000,8 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 * - Maybe export this into own class to increase modularity of software
+	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 

From 6579200f5551f93349ce018127b249ab7cdb3739 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 6 Mar 2020 19:01:31 +0100
Subject: [PATCH 0119/1292] removed counter, will be implemented in childclass

---
 devicehandlers/DeviceHandlerBase.cpp | 13 ++-----------
 devicehandlers/DeviceHandlerBase.h   | 15 ++-------------
 2 files changed, 4 insertions(+), 24 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1252d61f..e7b4c684 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,9 +32,8 @@ DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
 		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
 		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		pollingFrequency(1), pollingCounter(1), timeoutStart(0), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
-		deviceSwitch(setDeviceSwitch)
+		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
@@ -70,14 +69,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 
-	if (pollingCounter != pollingFrequency) {
-		pollingCounter ++;
-		return RETURN_OK;
-	}
-	else {
-		pollingCounter = 1;
-	}
-
 	switch (getRmapAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 130aedb9..7586cc0f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -668,6 +668,8 @@ protected:
 	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
 	 *		 			Default is aperiodic (0)
+	 * @param hasDifferentReplyId
+	 * @param replyId
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
@@ -940,19 +942,6 @@ private:
 	*/
 	const uint32_t logicalAddress;
 
-	/**
-	 * Polling Frequency which specifies how often the communication functions
-	 * and functionalities are called.
-	 *
-	 * This is not a time value. The time value depends on the
-	 * respective period time of the polling sequence table.
-	 * The actual time frequency can be calculated by multiplying that period
-	 * with the polling frequency value. Defaults to 1 (communication operations called
-	 * in each performOperation()).
-	 */
-	uint32_t pollingFrequency;
-	uint32_t pollingCounter;
-
 	/**
 	 * Used for timing out mode transitions.
 	 *

From b5fe1fa530ed9fd91b5936b0cb617a9774861a6a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 9 Mar 2020 22:15:52 +0100
Subject: [PATCH 0120/1292] dhb virtual function moved to top

---
 devicehandlers/DeviceHandlerBase.h | 18 +++++++++---------
 devicehandlers/DeviceHandlerIF.h   |  8 ++++----
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 7586cc0f..53eaa7dd 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -306,6 +306,14 @@ protected:
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
 			const uint8_t *packet) = 0;
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -666,7 +674,7 @@ protected:
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
+	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
 	 *		 			Default is aperiodic (0)
 	 * @param hasDifferentReplyId
 	 * @param replyId
@@ -782,14 +790,6 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
-	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index ed0260d6..cce40349 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -67,20 +67,20 @@ public:
 	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
 	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-	//standard codes used in scan for reply
-	//	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
+	// Standard codes used in scan for reply
+	//static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
 	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
 	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
 	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
 
-	//standard codes used in  interpret device reply
+	// Standard codes used in  interpret device reply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
 	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
-	//Standard codes used in buildCommandFromCommand
+	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
 			0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =

From a3903f80fb915a046eb69e1492254ef4e69b5987 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 00:49:47 +0100
Subject: [PATCH 0121/1292] typedef address_t moved to deviceComIF

---
 devicehandlers/Cookie.h                |  8 ++++-
 devicehandlers/DeviceCommunicationIF.h | 41 +++++++++++++++++++-------
 devicehandlers/DeviceHandlerBase.h     | 24 +++++++--------
 rmap/RmapDeviceCommunicationIF.h       |  6 ++--
 4 files changed, 52 insertions(+), 27 deletions(-)

diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 618c901f..ec22ec3a 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -2,7 +2,13 @@
 #define COOKIE_H_
 
 /**
- * This datatype is used to identify different connection over a single interface (like RMAP or I2C)
+ * @brief This datatype is used to identify different connection over a single interface
+ *        (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie. This cookie
+ * can be used in the device communication interface by performing
+ * a C++ dynamic cast. The cookie can be used to store all kinds of information
+ * about the communication between read and send calls.
  */
 class Cookie{
 public:
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 99904510..9b0e0a3a 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -8,6 +8,11 @@
  * @brief Communication interfaces for flight software objects
  */
 
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
 /**
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
@@ -39,23 +44,36 @@ public:
 
 	virtual ~DeviceCommunicationIF() {}
 
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
+	/**
+	 * Open a connection. Define a communication specific cookie which can
+	 * be used to store information about the communication.
+	 *
+	 * @param cookie [in/out] This data class stores information about the communication.
+	 * @param address Logical device address
+	 * @param maxReplyLen Maximum length of expected reply
+	 * @return
+	 */
+	virtual ReturnValue_t open(Cookie **cookie, address_t address,
 			uint32_t maxReplyLen) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
 	 * The previous connection must not be closed.
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
-	 * can be used with the previous connection.
 	 *
 	 * @param cookie
 	 * @param address
 	 * @param maxReplyLen
-	 * @return
+	 * @return -@c RETURN_OK New communication set up successfully
+	 *         - Everything else: Cookie is unchanged and can be used with
+	 *           previous connection
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
+	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
 			uint32_t maxReplyLen) = 0;
 
+	/**
+	 * Closing call of connection. Don't forget to free memory of cookie.
+	 * @param cookie
+	 */
 	virtual void close(Cookie *cookie) = 0;
 
 	/**
@@ -65,16 +83,18 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return @c RETURN_OK for successfull send
-	 *         Everything else triggers sending failed event with returnvalue as parameter 1
+	 * @return -@c RETURN_OK for successfull send
+	 *         -Everything else triggers sending failed event with
+	 *          returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie,const uint8_t *data,
+	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t *data,
 			uint32_t len) = 0;
 
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * Instructs the Communication Interface to prepare
 	 * @param cookie
 	 * @return
 	 */
@@ -93,9 +113,9 @@ public:
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
 			uint32_t *size) = 0;
 
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address) = 0;
+	virtual ReturnValue_t setAddress(Cookie *cookie, address_t address) = 0;
 
-	virtual uint32_t getAddress(Cookie *cookie) = 0;
+	virtual address_t getAddress(Cookie *cookie) = 0;
 
 	/**
 	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
@@ -112,7 +132,6 @@ public:
 	 * @return
 	 */
 	virtual uint32_t getParameter(Cookie *cookie) = 0;
-
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 53eaa7dd..60e8888e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -33,28 +33,25 @@ class StorageManagerIF;
  * Contains all devices and the DeviceHandlerBase class.
  */
 
-/**
- * Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief This is the abstract base class for device handlers.
  * @details
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink, communication with
- * physical devices, using the @link DeviceCommunicationIF @endlink, and communication with commanding objects.
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
+ * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
+ * and communication with commanding objects.
  * It inherits SystemObject and thus can be created by the ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
  * For each step an RMAP action is selected and executed.
  * If data has been received (GET_READ), the data will be interpreted.
- * The action for each step can be defined by the child class but as most device handlers share a 4-call
- * (sendRead-getRead-sendWrite-getWrite) structure, a default implementation is provided.
- * NOTE: RMAP is a standard which is used for FLP.
+ * The action for each step can be defined by the child class but as most
+ * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
+ * a default implementation is provided. NOTE: RMAP is a standard which is used for FLP.
  * RMAP communication is not mandatory for projects implementing the FSFW.
- * However, the communication principles are similar to RMAP as there are two write and two send calls involved.
+ * However, the communication principles are similar to RMAP as there are
+ * two write and two send calls involved.
  *
  * Device handler instances should extend this class and implement the abstract functions.
  * Components and drivers can send so called cookies which are used for communication
@@ -495,7 +492,8 @@ protected:
 	DeviceCommunicationIF *communicationInterface;
 
 	/**
-	 * Cookie used for communication
+	 * Cookie used for communication. This is passed to the communication
+	 * interface.
 	 */
 	Cookie *cookie;
 
@@ -910,7 +908,7 @@ private:
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the RMAP communication.
+	 * Used to keep track of the state of the communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 12ae67e4..45963d86 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -4,7 +4,8 @@
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
 
 /**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls. It expects RMAPCookies or a derived class of RMAPCookies
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
  *
  * @details	The open, close and reOpen calls are mission specific
  * 			The open call might return any child of RMAPCookies
@@ -44,7 +45,8 @@ public:
 
 
 	/**
-	 * Closing call of connection and memory free of cookie. Mission dependent call
+	 * Closing call of connection and free memory of cookie.
+	 * Mission dependent call
 	 * @param cookie
 	 */
 	virtual void close(Cookie *cookie) = 0;

From b7e3449b04c48ff65e6e21767667c328938701dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 12:38:11 +0100
Subject: [PATCH 0122/1292] some more doc for containers

---
 container/ArrayList.h              |  7 ++-
 container/FIFO.h                   |  5 ++
 container/HybridIterator.h         |  2 +-
 container/IndexedRingMemoryArray.h | 87 ++++++++++++++++++------------
 container/SinglyLinkedList.h       |  4 +-
 5 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 59e5eef4..57b2f94d 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -6,10 +6,9 @@
 #include <framework/serialize/SerializeIF.h>
 
 /**
- * A List that stores its values in an array.
- *
- * The backend is an array that can be allocated by the class itself or supplied via ctor.
- *
+ * @brief 	A List that stores its values in an array.
+ * @details The backend is an array that can be allocated
+ * 			by the class itself or supplied via ctor.
  *
  * @ingroup container
  */
diff --git a/container/FIFO.h b/container/FIFO.h
index 134da9b8..00f56993 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -3,6 +3,11 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
+/**
+ * @brief Simple First-In-First-Out data structure
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
 template<typename T, uint8_t capacity>
 class FIFO {
 private:
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index b34fdfd0..1c56aa13 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -67,7 +67,7 @@ public:
 	}
 
 	bool operator==(HybridIterator other) {
-		return value == other->value;
+		return value == other.value;
 	}
 
 	bool operator!=(HybridIterator other) {
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index eacfe3e5..4ab174f4 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -8,20 +8,27 @@
 #include <framework/globalfunctions/crc_ccitt.h>
 #include <cmath>
 
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
 template<typename T>
 class Index: public SerializeIF{
 	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+	 *
 	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
 public:
 	Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
-
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
 	}
 
-	void setBlockStartAddress(uint32_t newAddress){
+	void setBlockStartAddress(uint32_t newAddress) {
 		this->blockStartAddress = newAddress;
 	}
 
@@ -33,7 +40,7 @@ public:
 		return &indexType;
 	}
 
-	T* modifyIndexType(){
+	T* modifyIndexType() {
 		return &indexType;
 	}
 	/**
@@ -128,26 +135,35 @@ private:
 };
 
 
-
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
 	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
+	 *
 	 */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
-
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
 		//Calculate the maximum number of indices needed for this blocksize
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
 		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
+		if(additionalInfo!=NULL) {
 			serializedSize += additionalInfo->getSerializedSize();
 		}
+
 		//Size of current iterator type
 		Index<T> tempIndex;
 		serializedSize += tempIndex.getSerializedSize();
@@ -162,6 +178,7 @@ public:
 			error << "IndexedRingMemory: Store is too small for index" << std::endl;
 		}
 		uint32_t useableSize = totalSize - serializedSize;
+
 		//Update the totalSize for calculations
 		totalSize = useableSize;
 
@@ -178,12 +195,10 @@ public:
 		this->allocated = true;
 
 		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
+		if(trueNumberOfBlocks<1) {
 			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
 		}
 
-
-
 		//Fill address into index
 		uint32_t address = trueStartAddress;
 		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
@@ -193,7 +208,6 @@ public:
 			address += bytesPerBlock;
 		}
 
-
 		//Initialize iterators
 		currentWriteBlock = this->begin();
 		currentReadBlock = this->begin();
@@ -232,10 +246,10 @@ public:
 		(*typeResetFnc)(it->modifyIndexType());
 	}
 
-	/*
+	/**
 	 * Reading
+	 * @param it
 	 */
-
 	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
 		currentReadBlock = it;
 		currentReadBlockSizeCached = it->getSize();
@@ -248,6 +262,7 @@ public:
 		lastBlockToRead = currentWriteBlock;
 		lastBlockToReadSize = currentWriteBlock->getSize();
 	}
+
 	/**
 	 * Sets the last block to read to this iterator.
 	 * Can be used to dump until block x
@@ -292,33 +307,39 @@ public:
 	uint32_t getCurrentReadAddress() const {
 		return getAddressOfCurrentReadBlock() + currentReadSize;
 	}
+
 	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
 	 * @param readSize The size that was read
 	 * @return Returns true if the read can go on
 	 */
 	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
+		if(currentReadBlock == lastBlockToRead) {
 			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
 				//the block has more data -> return true
 				currentReadSize += readSize;
 				return true;
-			}else{
+			}
+			else {
 				//Reached end of read -> return false
 				currentReadSize = lastBlockToReadSize;
 				return false;
 			}
-		}else{
+		}
+		else {
 			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
 				//The current Block has more data
 				currentReadSize += readSize;
 				return true;
-			}else{
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
 				//The current block is written completely
 				readNext();
-				if(currentReadBlockSizeCached==0){
+				if(currentReadBlockSizeCached==0) {
 					//Next block is empty
 					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
 					//Search if any block between this and the last block is not empty
@@ -421,13 +442,13 @@ public:
 	T* modifyCurrentWriteBlockIndexType(){
 		return currentWriteBlock->modifyIndexType();
 	}
+
 	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
 		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
 		it->addSize(size);
 		it->addStoredPackets(storedPackets);
 	}
 
-
 	/**
 	 * Checks if the block has enough space for sizeToWrite
 	 * @param sizeToWrite The data to be written in the Block
@@ -436,7 +457,10 @@ public:
 	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
 		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
 		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
 		return (sizeToWrite < availableSize);
 	}
 
@@ -694,7 +718,4 @@ private:
 
 };
 
-
-
-
 #endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 5c9de6cf..b926bd00 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -4,7 +4,9 @@
 #include <stddef.h>
 #include <stdint.h>
 /**
- * \ingroup container
+ * @brief	Linked list data structure,
+ * 			each entry has a pointer to the next entry (singly)
+ * @ingroup container
  */
 template<typename T>
 class LinkedElement {

From 52c05e2f3da8043336f77deba36e1fefa53e61fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 19 Mar 2020 12:44:24 +0100
Subject: [PATCH 0123/1292] minor formatting for pull request

---
 container/ArrayList.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 57b2f94d..f978c984 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -223,7 +223,6 @@ public:
 		return (maxSize_ - size);
 	}
 
-
 private:
 	/**
 	 * This is the copy constructor
@@ -236,6 +235,7 @@ private:
 	ArrayList(const ArrayList& other) :
 			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
 			allocated(false) {}
+
 protected:
 	/**
 	 * pointer to the array in which the entries are stored
@@ -269,6 +269,6 @@ protected:
 			++i;
 		}
 	}
-
 };
+
 #endif /* ARRAYLIST_H_ */

From af6d18d60b323ea2759e1ca5af5980bd25673015 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 20 Mar 2020 22:47:07 +0100
Subject: [PATCH 0124/1292] added additional parameter form open/reopen call

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 9b0e0a3a..4f98dd6d 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -54,7 +54,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
@@ -68,7 +68,7 @@ public:
 	 *           previous connection
 	 */
 	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
 
 	/**
 	 * Closing call of connection. Don't forget to free memory of cookie.

From c50d9d90d61a727ddc90e64d75ee98a4d3679bd0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 13:14:23 +0100
Subject: [PATCH 0125/1292] replaced std::variant by two uint32 parameters

---
 devicehandlers/DeviceCommunicationIF.h | 18 ++++----
 devicehandlers/DeviceHandlerBase.cpp   |  6 +--
 devicehandlers/DeviceHandlerBase.h     | 61 ++++++++++++++++----------
 devicehandlers/DeviceHandlerIF.h       | 32 +++++++++++++-
 4 files changed, 82 insertions(+), 35 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 4f98dd6d..1e307b6c 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -2,17 +2,13 @@
 #define DEVICECOMMUNICATIONIF_H_
 
 #include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
  * @defgroup interfaces Interfaces
  * @brief Communication interfaces for flight software objects
  */
 
-/**
- * Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
@@ -47,14 +43,20 @@ public:
 	/**
 	 * Open a connection. Define a communication specific cookie which can
 	 * be used to store information about the communication.
+	 * The two optional parameter provide additional flexibility to
+	 * set up the communication interface as desired. If there are a lot of
+	 * variables to set, a store ID to the parameters stored in the IPC store
+	 * can also be passed.
 	 *
-	 * @param cookie [in/out] This data class stores information about the communication.
+	 * @param cookie [out] This data class stores information about the communication.
 	 * @param address Logical device address
 	 * @param maxReplyLen Maximum length of expected reply
+	 * @param comParameter1 Arbitrary parameter which can be used to set up the cookie or comIF.
+	 * @param comParameter2 Arbitrary parameter which can be used to set up the cookie or comIF.
 	 * @return
 	 */
 	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
 
 	/**
 	 * Use an existing cookie to open a connection to a new DeviceCommunication.
@@ -68,7 +70,7 @@ public:
 	 *           previous connection
 	 */
 	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter = 0) = 0;
+			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
 
 	/**
 	 * Closing call of connection. Don't forget to free memory of cookie.
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index e7b4c684..ca883e83 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -106,7 +106,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen);
+			maxDeviceReplyLen, comParameter1, comParameter2);
 	if (result != RETURN_OK) {
 		return result;
 	}
@@ -691,7 +691,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 //Default child implementations
 
-DeviceHandlerBase::RmapAction_t DeviceHandlerBase::getRmapAction() {
+DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getRmapAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -757,7 +757,7 @@ ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
 
 	if (newCommunication != NULL) {
 		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-				maxDeviceReplyLen);
+				maxDeviceReplyLen, comParameter1, comParameter2);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 60e8888e..868412ed 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -418,6 +418,22 @@ protected:
 	 */
 	uint32_t rawPacketLen;
 
+//	/**
+//	 * This union (or std::variant) type can be used to set comParameters which
+//	 * are passed in the open() and reOpen() calls to the communication
+//	 * interface
+//	 * TODO: I don't know if we should use C++17 features but if we do we propably
+//	 *		 should also write a function to get either a storeId handle
+//	 *		 or an array handle so these values can be set conveniently.
+//	 * The good think is that if there are many parameters, they can
+//	 * be stored in the IPC pool. But maybe two uint32_t parameters are enough.
+//	 * Simple = Good. It is downwards compatible and one can still store
+//	 * 4 bytes of parameters AND a store ID.
+//	 */
+//	comParameters_t comParameters;
+	uint32_t comParameter1 = 0;
+	uint32_t comParameter2 = 0;
+
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -548,6 +564,28 @@ protected:
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
 	static object_id_t defaultFDIRParentId; //!< Object which may be the root cause of an identified fault.
+
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -576,27 +614,6 @@ protected:
 	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -645,7 +662,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
-	virtual RmapAction_t getRmapAction();
+	virtual CommunicationAction_t getRmapAction();
 
 	/**
 	 * Build the device command to send for raw mode.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index cce40349..c453e7e8 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,6 +7,33 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+#if __cplusplus >= 201703L
+#include <array>
+#include <variant>
+#endif
+
+/**
+ * Physical address type
+ */
+typedef uint32_t address_t;
+
+///**
+// * This type safe union cold be used if C++17 or newer is used to transfer
+// * comIF settings to the communication interface object.
+// */
+//
+//#if __cplusplus >= 201703L
+//using comParameterArray_t = std::array<uint8_t, 4>;
+//using comParameters_t = std::variant<store_address_t, comParameterArray_t>;
+//#else
+//using comParameters_t = union comParameters {
+//		comParameters() = default;
+//		comParameters(uint32_t initValue): storeIdRaw(initValue) {}
+//		uint32_t storeIdRaw;
+//		uint8_t comParameter[4];
+//	};
+//#endif
+
 /**
  * This is the Interface used to communicate with a device handler.
  *
@@ -87,17 +114,18 @@ public:
 			MAKE_RETURN_CODE(0xD1);
 
 	/**
-	 * RMAP Action that will be executed.
+	 * Communication action that will be executed.
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-	enum RmapAction_t {
+	enum CommunicationAction_t: uint8_t {
 		SEND_WRITE,//!< RMAP send write
 		GET_WRITE, //!< RMAP get write
 		SEND_READ, //!< RMAP send read
 		GET_READ,  //!< RMAP get read
 		NOTHING    //!< Do nothing.
 	};
+
 	/**
 	 * Default Destructor
 	 */

From d3e2652078913332c407845920b14cd0c5e459a6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 17:58:23 +0100
Subject: [PATCH 0126/1292] replaced DHB sizes by size_t, rework

Cookie now passed to DHB, rework in progress
---
 action/ActionHelper.cpp                 |   2 +-
 action/CommandActionHelper.cpp          |   2 +-
 action/SimpleActionHelper.cpp           |   2 +-
 datapool/DataPoolAdmin.cpp              |   2 +-
 devicehandlers/ChildHandlerBase.cpp     |  15 ++--
 devicehandlers/ChildHandlerBase.h       |  12 +--
 devicehandlers/Cookie.cpp               |  24 ++++++
 devicehandlers/Cookie.h                 |  21 ++++-
 devicehandlers/DeviceCommunicationIF.h  | 103 +++++++-----------------
 devicehandlers/DeviceHandlerBase.cpp    |  92 +++++++++++----------
 devicehandlers/DeviceHandlerBase.h      |  56 +++++++------
 devicehandlers/DeviceHandlerMessage.cpp |   4 +-
 devicehandlers/DeviceHandlerMessage.h   |   2 +-
 memory/MemoryHelper.cpp                 |   2 +-
 osal/FreeRTOS/BinarySemaphore.cpp       |   4 +-
 parameters/ParameterHelper.cpp          |   2 +-
 storagemanager/LocalPool.h              |   8 +-
 storagemanager/StorageManagerIF.h       |   4 +-
 subsystem/Subsystem.cpp                 |   4 +-
 tcdistribution/CCSDSDistributor.cpp     |   2 +-
 tmtcpacket/pus/TcPacketStored.cpp       |   4 +-
 tmtcpacket/pus/TmPacketStored.cpp       |   2 +-
 tmtcservices/TmTcBridge.cpp             |   4 +-
 23 files changed, 186 insertions(+), 187 deletions(-)
 create mode 100644 devicehandlers/Cookie.cpp

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9c1475f1..18e46fba 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -49,7 +49,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
 		store_address_t dataAddress) {
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 05eb9346..ceb97d3b 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -113,7 +113,7 @@ uint8_t CommandActionHelper::getCommandCount() const {
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
 	const uint8_t * data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6de372fb..6861fc28 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -44,7 +44,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		queueToUse->sendMessage(commandedBy, &reply);
 	}
 	const uint8_t* dataPtr = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index fe6b9215..99d2b51b 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -215,7 +215,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(ParameterMessage::getStoreId(command),
 				&storedStream, &storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e..a0630fc6 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -2,15 +2,16 @@
 #include <framework/devicehandlers/ChildHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
-ChildHandlerBase::ChildHandlerBase(uint32_t ioBoardAddress,
-		object_id_t setObjectId, object_id_t deviceCommunication,
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, address_t logicalAddress,
+		object_id_t deviceCommunication, Cookie * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, uint32_t cmdQueueSize) :
-		DeviceHandlerBase(ioBoardAddress, setObjectId, maxDeviceReplyLen,
-				setDeviceSwitch, deviceCommunication, thermalStatePoolId,
-				thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir), cmdQueueSize), parentId(
-				parent), childHandlerFdir(setObjectId) {
+		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, logicalAddress, deviceCommunication, cookie,
+			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
+			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 3879f66f..4e9eee49 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -6,12 +6,12 @@
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(uint32_t ioBoardAddress, object_id_t setObjectId,
-			object_id_t deviceCommunication, uint32_t maxDeviceReplyLen,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, uint32_t parent,
-			FailureIsolationBase* customFdir = NULL,
-			uint32_t cmdQueueSize = 20);
+	ChildHandlerBase(object_id_t setObjectId, uint32_t logicalAddress,
+			object_id_t deviceCommunication, Cookie * cookie,
+			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
new file mode 100644
index 00000000..f0748b5d
--- /dev/null
+++ b/devicehandlers/Cookie.cpp
@@ -0,0 +1,24 @@
+/**
+ * @file Cookie.cpp
+ *
+ * @date 23.03.2020
+ */
+#include <framework/devicehandlers/Cookie.h>
+
+//Cookie::Cookie(address_t logicalAddress_, size_t maxReplyLen_):
+//	logicalAddress(logicalAddress_), maxReplyLen(maxReplyLen_){}
+
+Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
+}
+
+void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
+	maxReplyLen = maxReplyLen_;
+}
+
+address_t Cookie::getAddress() const {
+	return logicalAddress;
+}
+
+size_t Cookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index ec22ec3a..60f20ff1 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,5 +1,6 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
+#include <framework/devicehandlers/DeviceHandlerIF.h>
 
 /**
  * @brief This datatype is used to identify different connection over a single interface
@@ -7,13 +8,27 @@
  * @details
  * To use this class, implement a communication specific child cookie. This cookie
  * can be used in the device communication interface by performing
- * a C++ dynamic cast. The cookie can be used to store all kinds of information
- * about the communication between read and send calls.
+ * a C++ dynamic cast and passing it to a child device handler, which stores
+ * it and passes the Cookie to the communication interface where it can be used
+ * by again performing a dynamic cast.
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ * @ingroup comm
  */
 class Cookie{
 public:
+	Cookie() = default;
+	Cookie(address_t logicalAddress_);
 	virtual ~Cookie(){}
+
+	void setMaxReplyLen(size_t maxReplyLen_);
+
+	address_t getAddress() const;
+	size_t getMaxReplyLen() const;
+private:
+	address_t logicalAddress = 0;
+	size_t maxReplyLen = 0;
 };
 
-
 #endif /* COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 1e307b6c..43aa7965 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -6,7 +6,12 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
  * @defgroup interfaces Interfaces
- * @brief Communication interfaces for flight software objects
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup communication comm
+ * @brief Communication software components.
  */
 
 /**
@@ -22,9 +27,12 @@
  *   3. Request reading data from a device
  *   4. Read received data
  *
- *  To identify different connection over a single interface can return so-called cookies to components.
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
  *  The CommunicationMessage message type can be used to extend the functionality of the
  *  ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
  */
 class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
@@ -32,52 +40,12 @@ public:
 
 	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t CANT_CHANGE_REPLY_LEN = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x05);
 
 	virtual ~DeviceCommunicationIF() {}
 
-	/**
-	 * Open a connection. Define a communication specific cookie which can
-	 * be used to store information about the communication.
-	 * The two optional parameter provide additional flexibility to
-	 * set up the communication interface as desired. If there are a lot of
-	 * variables to set, a store ID to the parameters stored in the IPC store
-	 * can also be passed.
-	 *
-	 * @param cookie [out] This data class stores information about the communication.
-	 * @param address Logical device address
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @param comParameter1 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @param comParameter2 Arbitrary parameter which can be used to set up the cookie or comIF.
-	 * @return
-	 */
-	virtual ReturnValue_t open(Cookie **cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 *
-	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return -@c RETURN_OK New communication set up successfully
-	 *         - Everything else: Cookie is unchanged and can be used with
-	 *           previous connection
-	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, address_t address,
-			uint32_t maxReplyLen, uint32_t comParameter1, uint32_t comParameter2) = 0;
-
-	/**
-	 * Closing call of connection. Don't forget to free memory of cookie.
-	 * @param cookie
-	 */
-	virtual void close(Cookie *cookie) = 0;
-
 	/**
 	 * Called by DHB in the SEND_WRITE doSendWrite().
 	 * This function is used to send data to the physical device
@@ -86,21 +54,29 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         -Everything else triggers sending failed event with
-	 *          returnvalue as parameter 1
+	 *         - Everything else triggers sending failed event with
+	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t *data,
-			uint32_t len) = 0;
+	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t * sendData,
+			size_t sendLen) = 0;
 
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers sending failed event with
+	 *           returnvalue as parameter 1
+	 */
 	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * Instructs the Communication Interface to prepare
+	 * Request a reply.
 	 * @param cookie
 	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0;
+	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie, size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -110,30 +86,11 @@ public:
 	 * @param data
 	 * @param len
 	 * @return @c RETURN_OK for successfull receive
-	 *         Everything else triggers receiving failed with returnvalue as parameter 1
+	 *         - Everything else triggers receiving failed with
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size) = 0;
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, address_t address) = 0;
-
-	virtual address_t getAddress(Cookie *cookie) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter) = 0;
-
-	/**
-	 * Can be used by DeviceHandlerBase getParameter() call to set DeviceComIF parameters
-	 * @param cookie
-	 * @param parameter
-	 * @return
-	 */
-	virtual uint32_t getParameter(Cookie *cookie) = 0;
+			size_t *size) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ca883e83..5834db2f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,37 +16,34 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(uint32_t logicalAddress_,
-		object_id_t setObjectId, uint32_t maxDeviceReplyLen,
-		uint8_t setDeviceSwitch, object_id_t deviceCommunication,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, uint32_t cmdQueueSize) :
-		SystemObject(setObjectId), rawPacket(0), rawPacketLen(0), mode(MODE_OFF),
-		submode(SUBMODE_NONE), pstStep(0), maxDeviceReplyLen(maxDeviceReplyLen),
-		wiretappingMode(OFF), defaultRawReceiver(0), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		requestedRawTraffic(0), powerSwitcher(NULL), IPCStore(NULL),
-		deviceCommunicationId(deviceCommunication), communicationInterface(NULL),
-		cookie(NULL), commandQueue(NULL), deviceThermalStatePoolId(thermalStatePoolId),
-		deviceThermalRequestPoolId(thermalRequestPoolId), healthHelper(this, setObjectId),
-		modeHelper(this), parameterHelper(this), childTransitionFailure(RETURN_OK),
-		ignoreMissedRepliesCount(0), fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == NULL), switchOffWasReported(false),
-		executingTask(NULL), actionHelper(this, NULL), cookieInfo(), logicalAddress(logicalAddress_),
-		timeoutStart(0), childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
+		object_id_t deviceCommunication, Cookie * cookie_, size_t maxReplyLen,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+	    deviceCommunicationId(deviceCommunication), cookie(cookie_),
+		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
+		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
+		fdirInstance(fdirInstance), hkSwitcher(this),
+		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
+		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
+		logicalAddress(logicalAddress_), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
+		deviceSwitch(setDeviceSwitch)
 {
+	this->cookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
-	if (this->fdirInstance == NULL) {
+	if (this->fdirInstance == nullptr) {
 		this->fdirInstance =
 				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	communicationInterface->close(cookie);
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -105,11 +102,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	result = communicationInterface->open(&cookie, logicalAddress,
-			maxDeviceReplyLen, comParameter1, comParameter2);
-	if (result != RETURN_OK) {
-		return result;
-	}
+//	result = communicationInterface->open(&cookie, logicalAddress,
+//			maxDeviceReplyLen, comParameter1, comParameter2);
+//	if (result != RETURN_OK) {
+//		return result;
+//	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
@@ -551,7 +548,7 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-	result = communicationInterface->requestReceiveMessage(cookie);
+	result = communicationInterface->requestReceiveMessage(cookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -565,10 +562,10 @@ void DeviceHandlerBase::doSendRead() {
 }
 
 void DeviceHandlerBase::doGetRead() {
-	uint32_t receivedDataLen;
+	size_t receivedDataLen;
 	uint8_t *receivedData;
 	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	uint32_t foundLen = 0;
+	size_t foundLen = 0;
 	ReturnValue_t result;
 
 	if (cookieInfo.state != COOKIE_READ_SENT) {
@@ -639,8 +636,8 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t * *data, uint32_t * len) {
-	uint32_t lenTmp;
+		uint8_t ** data, size_t * len) {
+	size_t lenTmp;
 
 	if (IPCStore == NULL) {
 		*data = NULL;
@@ -751,20 +748,20 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
-	DeviceCommunicationIF *newCommunication = objectManager->get<
-			DeviceCommunicationIF>(newChannelId);
-
-	if (newCommunication != NULL) {
-		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-				maxDeviceReplyLen, comParameter1, comParameter2);
-		if (result != RETURN_OK) {
-			return result;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
+//ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
+//	DeviceCommunicationIF *newCommunication = objectManager->get<
+//			DeviceCommunicationIF>(newChannelId);
+//
+//	if (newCommunication != NULL) {
+//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
+//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		if (result != RETURN_OK) {
+//			return result;
+//		}
+//		return RETURN_OK;
+//	}
+//	return RETURN_FAILED;
+//}
 
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
@@ -1048,12 +1045,13 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
 		if (mode != MODE_OFF) {
 			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
 		} else {
-			result = switchCookieChannel(
-					DeviceHandlerMessage::getIoBoardObjectId(message));
+			// rework in progress
+			//result = switchCookieChannel(
+			//		DeviceHandlerMessage::getIoBoardObjectId(message));
 			if (result == RETURN_OK) {
 				replyReturnvalueToCommand(RETURN_OK);
 			} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 868412ed..e9288921 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -29,7 +29,7 @@ void setStaticFrameworkObjectIds();
 class StorageManagerIF;
 
 /**
- * \defgroup devices Devices
+ * @defgroup devices Devices
  * Contains all devices and the DeviceHandlerBase class.
  */
 
@@ -93,12 +93,11 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(address_t logicalAddress, object_id_t setObjectId,
-			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			object_id_t deviceCommunication,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+	DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
+			object_id_t deviceCommunication, Cookie* cookie_, size_t maxReplyLen,
+			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = NULL, uint32_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief This function is the device handler base core component and is called periodically.
@@ -283,8 +282,8 @@ protected:
 	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
 	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, uint32_t len,
-			DeviceCommandId_t *foundId, uint32_t *foundLen) = 0;
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
 
 	/**
 	 * @brief Interpret a reply from the device.
@@ -412,11 +411,16 @@ protected:
 	/**
 	 * Pointer to the raw packet that will be sent.
 	 */
-	uint8_t *rawPacket;
+	uint8_t *rawPacket = nullptr;
 	/**
 	 * Size of the #rawPacket.
 	 */
-	uint32_t rawPacketLen;
+	size_t rawPacketLen = 0;
+
+	/**
+	 * Size of data to request.
+	 */
+	size_t requestLen = 0;
 
 //	/**
 //	 * This union (or std::variant) type can be used to set comParameters which
@@ -431,8 +435,8 @@ protected:
 //	 * 4 bytes of parameters AND a store ID.
 //	 */
 //	comParameters_t comParameters;
-	uint32_t comParameter1 = 0;
-	uint32_t comParameter2 = 0;
+	// uint32_t comParameter1 = 0;
+	// uint32_t comParameter2 = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -451,12 +455,12 @@ protected:
 	/**
 	 * This is the counter value from performOperation().
 	 */
-	uint8_t pstStep;
+	uint8_t pstStep = 0;
 
 	/**
 	 * This will be used in the RMAP getRead command as expected length, is set by the constructor, can be modiefied at will.
 	 */
-	const uint32_t maxDeviceReplyLen;
+	const uint32_t maxDeviceReplyLen = 0;
 
 	/**
 	 * wiretapping flag:
@@ -474,7 +478,7 @@ protected:
 	 * Statically initialized in initialize() to a configurable object. Used when there is no method
 	 * of finding a recipient, ie raw mode and reporting erreonous replies
 	 */
-	MessageQueueId_t defaultRawReceiver;
+	MessageQueueId_t defaultRawReceiver = 0;
 
 	store_address_t storedRawData;
 
@@ -483,19 +487,19 @@ protected:
 	 *
 	 * if #isWiretappingActive all raw communication from and to the device will be sent to this queue
 	 */
-	MessageQueueId_t requestedRawTraffic;
+	MessageQueueId_t requestedRawTraffic = 0;
 
 	/**
 	 * the object used to set power switches
 	 */
-	PowerSwitchIF *powerSwitcher;
+	PowerSwitchIF *powerSwitcher = nullptr;
 
 	/**
 	 * Pointer to the IPCStore.
 	 *
 	 * This caches the pointer received from the objectManager in the constructor.
 	 */
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 	/**
 	 * cached for init
@@ -505,7 +509,7 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface;
+	DeviceCommunicationIF *communicationInterface = nullptr;
 
 	/**
 	 * Cookie used for communication. This is passed to the communication
@@ -516,7 +520,7 @@ protected:
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
 	 */
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	/**
 	 * this is the datapool variable with the thermal state of the device
@@ -545,9 +549,9 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure;
+	ReturnValue_t childTransitionFailure = RETURN_OK;
 
-	uint32_t ignoreMissedRepliesCount; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
 	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
 
@@ -962,7 +966,7 @@ private:
 	 *
 	 * Set when setMode() is called.
 	 */
-	uint32_t timeoutStart;
+	uint32_t timeoutStart = 0;
 
 	/**
 	 * Delay for the current mode transition, used for time out
@@ -1084,8 +1088,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
-			uint32_t *len);
+	ReturnValue_t getStorageData(store_address_t storageAddress,
+			uint8_t ** data, size_t * len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1114,7 +1118,7 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	/**
 	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 58a6d312..97abcac5 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -47,7 +47,7 @@ void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
 
 void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
 		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_IOBOARD);
+	message->setCommand(CMD_SWITCH_ADDRESS);
 	message->setParameter(ioBoardIdentifier);
 }
 
@@ -90,7 +90,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
 		}
 	}
 		/* NO BREAK falls through*/
-	case CMD_SWITCH_IOBOARD:
+	case CMD_SWITCH_ADDRESS:
 	case CMD_WIRETAPPING:
 		message->setCommand(CommandMessage::CMD_NONE);
 		message->setParameter(0);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index fad0f1b1..c91bb0a4 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -28,7 +28,7 @@ public:
 	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::DEVICE_HANDLER_COMMAND;
 	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
 //	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_IOBOARD = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
 	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
 
 	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 4905875e..9bebb597 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -152,7 +152,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 	ipcAddress = MemoryMessage::getStoreID(message);
 	const uint8_t* p_data = NULL;
 	uint8_t* dataPointer = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
 	if (returnCode == RETURN_OK) {
 		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index d429f1a0..4ec61ff7 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,7 +11,7 @@
 #include "task.h"
 
 BinarySemaphore::BinarySemaphore() {
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle); // @suppress("Function cannot be resolved")
 	if(handle == NULL) {
 		error << "Binary semaphore creation failure" << std::endl;
 	}
@@ -81,7 +81,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 
 void BinarySemaphore::resetSemaphore() {
 	vSemaphoreDelete(handle);
-	vSemaphoreCreateBinary(handle);
+	xSemaphoreCreateBinary(handle);
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 6ebc9e62..e260465a 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -37,7 +37,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 				ParameterMessage::getParameterId(message));
 
 		const uint8_t *storedStream;
-		uint32_t storedStreamSize;
+		size_t storedStreamSize;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f6d5ba8a..c2fab82b 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -100,7 +100,7 @@ public:
 	 * @return @c RETURN_OK if data retrieval was successfull
 	 */
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 
 	/**
 	 * Modify data by supplying a packet pointer and using that packet pointer
@@ -111,7 +111,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			uint32_t* size);
+			size_t * size);
 	virtual ReturnValue_t deleteData(store_address_t);
 	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
 			store_address_t* storeId = NULL);
@@ -348,7 +348,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, uint32_t* size) {
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t * size) {
 	uint8_t* tempData = NULL;
 	ReturnValue_t status = modifyData(packet_id, &tempData, size);
 	*packet_ptr = tempData;
@@ -357,7 +357,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, uint32_t* size) {
+		uint8_t** packet_ptr, size_t * size) {
 	ReturnValue_t status = RETURN_FAILED;
 	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
 		return ILLEGAL_STORAGE_ID;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 575e9caa..e8d8b413 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -125,12 +125,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, uint32_t* size) = 0;
+			const uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, uint32_t* size) = 0;
+			uint8_t** packet_ptr, size_t * size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e1ec544b..2d7d9c44 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -162,7 +162,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_SEQUENCE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
@@ -188,7 +188,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 	case ModeSequenceMessage::ADD_TABLE: {
 		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
 		const uint8_t *pointer;
-		uint32_t sizeRead;
+		size_t sizeRead;
 		result = IPCStore->getData(
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index ecd7702e..878b8f7d 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -13,7 +13,7 @@ CCSDSDistributor::~CCSDSDistributor() {
 iterator_t CCSDSDistributor::selectDestination() {
 //	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
 	const uint8_t* p_packet = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	//TODO check returncode?
 	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
 	SpacePacketBase current_packet( p_packet );
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 1f31a763..4bfd0e37 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -59,7 +59,7 @@ bool TcPacketStored::checkAndSetStore() {
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
 		status = this->store->getData(this->storeAddress, &temp_data,
@@ -79,7 +79,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 
 bool TcPacketStored::isSizeCorrect() {
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
 	if (status == StorageManagerIF::RETURN_OK) {
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index b1c1ec62..bb932641 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -82,7 +82,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t* temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index e402d79e..6b563f98 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -76,7 +76,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = NULL;
-	uint32_t size = 0;
+	size_t size = 0;
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -127,7 +127,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 				<< (int) fifo.size() << " left to send" << std::endl;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
-		uint32_t size = 0;
+		size_t size = 0;
 		fifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 		sendTm(data,size);

From fa058ee6025cfe03e0a60f62ebb744d80b676637 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 18:05:39 +0100
Subject: [PATCH 0127/1292] renamed rmap to com (more generic)

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 devicehandlers/DeviceHandlerBase.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5834db2f..4c2ae568 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -688,7 +688,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 //Default child implementations
 
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getRmapAction() {
+DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e9288921..3e588115 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -666,7 +666,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
-	virtual CommunicationAction_t getRmapAction();
+	virtual CommunicationAction_t getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.

From f7bd661e6923713740c77e91c2602caa74e6abe5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 18:08:24 +0100
Subject: [PATCH 0128/1292] small fixes

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4c2ae568..4b88355a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -66,7 +66,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 
-	switch (getRmapAction()) {
+	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
 			buildInternalCommand();
@@ -1050,6 +1050,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
 		} else {
 			// rework in progress
+			result = RETURN_OK;
 			//result = switchCookieChannel(
 			//		DeviceHandlerMessage::getIoBoardObjectId(message));
 			if (result == RETURN_OK) {

From b6bf9d71477b3695b1a3dfe7253137c5936c7ebc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 19:09:42 +0100
Subject: [PATCH 0129/1292] to avoid dynamic casting, introuced CookieIF

---
 devicehandlers/AcceptsDeviceResponsesIF.h |  5 ++--
 devicehandlers/ChildHandlerBase.cpp       |  6 ++---
 devicehandlers/ChildHandlerBase.h         |  5 ++--
 devicehandlers/Cookie.cpp                 |  8 ++++---
 devicehandlers/Cookie.h                   | 28 +++++++++++++----------
 devicehandlers/CookieIF.h                 | 25 ++++++++++++++++++++
 devicehandlers/DeviceCommunicationIF.h    |  8 +++----
 devicehandlers/DeviceHandlerBase.cpp      | 26 ++++++++++-----------
 devicehandlers/DeviceHandlerBase.h        | 27 +++++-----------------
 rmap/RMAPCookie.cpp                       |  8 +++----
 rmap/RMAPCookie.h                         |  4 ++--
 11 files changed, 82 insertions(+), 68 deletions(-)
 create mode 100644 devicehandlers/CookieIF.h

diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index 0eedae88..c811158f 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -15,9 +15,8 @@ public:
 	/**
 	 * Default empty virtual destructor.
 	 */
-	virtual ~AcceptsDeviceResponsesIF() {
-}
-virtual MessageQueueId_t getDeviceQueue() = 0;
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
 #endif /* ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index a0630fc6..ac0b2438 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -2,12 +2,12 @@
 #include <framework/devicehandlers/ChildHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, address_t logicalAddress,
-		object_id_t deviceCommunication, Cookie * cookie,
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, logicalAddress, deviceCommunication, cookie,
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
 			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 4e9eee49..493b22ee 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -6,9 +6,8 @@
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
-	ChildHandlerBase(object_id_t setObjectId, uint32_t logicalAddress,
-			object_id_t deviceCommunication, Cookie * cookie,
-			uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
 			size_t cmdQueueSize = 20);
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
index f0748b5d..05b9425c 100644
--- a/devicehandlers/Cookie.cpp
+++ b/devicehandlers/Cookie.cpp
@@ -5,12 +5,12 @@
  */
 #include <framework/devicehandlers/Cookie.h>
 
-//Cookie::Cookie(address_t logicalAddress_, size_t maxReplyLen_):
-//	logicalAddress(logicalAddress_), maxReplyLen(maxReplyLen_){}
-
 Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
 }
 
+void Cookie::setAddress(address_t logicalAddress_) {
+	logicalAddress = logicalAddress_;
+}
 void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
 	maxReplyLen = maxReplyLen_;
 }
@@ -22,3 +22,5 @@ address_t Cookie::getAddress() const {
 size_t Cookie::getMaxReplyLen() const {
 	return maxReplyLen;
 }
+
+
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
index 60f20ff1..d76facc0 100644
--- a/devicehandlers/Cookie.h
+++ b/devicehandlers/Cookie.h
@@ -1,31 +1,35 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
-#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/devicehandlers/CookieIF.h>
 
 /**
  * @brief This datatype is used to identify different connection over a single interface
  *        (like RMAP or I2C)
  * @details
- * To use this class, implement a communication specific child cookie. This cookie
- * can be used in the device communication interface by performing
- * a C++ dynamic cast and passing it to a child device handler, which stores
- * it and passes the Cookie to the communication interface where it can be used
- * by again performing a dynamic cast.
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
+ * CookieIF* childCookie = new ChildCookie(...).´
+ *
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
  * The cookie can be used to store all kinds of information
  * about the communication, like slave addresses, communication status,
  * communication parameters etc.
+ *
  * @ingroup comm
  */
-class Cookie{
+class Cookie: public CookieIF {
 public:
-	Cookie() = default;
+	Cookie();
 	Cookie(address_t logicalAddress_);
-	virtual ~Cookie(){}
+	virtual ~Cookie() {};
 
-	void setMaxReplyLen(size_t maxReplyLen_);
+	virtual void setAddress(address_t logicalAddres_);
+	virtual void setMaxReplyLen(size_t maxReplyLen_);
 
-	address_t getAddress() const;
-	size_t getMaxReplyLen() const;
+	virtual address_t getAddress() const;
+	virtual size_t getMaxReplyLen() const;
 private:
 	address_t logicalAddress = 0;
 	size_t maxReplyLen = 0;
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
new file mode 100644
index 00000000..3e08709b
--- /dev/null
+++ b/devicehandlers/CookieIF.h
@@ -0,0 +1,25 @@
+/**
+ * @file CookieIF.h
+ *
+ * @date 23 Mar 2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+
+class CookieIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~CookieIF() {};
+
+	virtual void setAddress(address_t logicalAddress_) = 0;
+	virtual address_t getAddress() const = 0;
+
+	virtual void setMaxReplyLen(size_t maxReplyLen_) = 0;
+	virtual size_t getMaxReplyLen() const = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 43aa7965..6f271504 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -57,7 +57,7 @@ public:
 	 *         - Everything else triggers sending failed event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, const uint8_t * sendData,
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
 
 	/**
@@ -68,7 +68,7 @@ public:
 	 * 		   - Everything else triggers sending failed event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0;
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
@@ -76,7 +76,7 @@ public:
 	 * @param cookie
 	 * @return
 	 */
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie, size_t requestLen) = 0;
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -89,7 +89,7 @@ public:
 	 *         - Everything else triggers receiving failed with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
 };
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4b88355a..33e44146 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,23 +16,22 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-		object_id_t deviceCommunication, Cookie * cookie_, size_t maxReplyLen,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+		CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-	    deviceCommunicationId(deviceCommunication), cookie(cookie_),
+	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
 		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
 		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
 		fdirInstance(fdirInstance), hkSwitcher(this),
 		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
 		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		logicalAddress(logicalAddress_), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(SUBMODE_NONE),
-		deviceSwitch(setDeviceSwitch)
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
-	this->cookie->setMaxReplyLen(maxReplyLen);
+	this->comCookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
@@ -44,6 +43,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, address_t logicalA
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -506,7 +506,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 void DeviceHandlerBase::doSendWrite() {
 	if (cookieInfo.state == COOKIE_WRITE_READY) {
 
-		ReturnValue_t result = communicationInterface->sendMessage(cookie,
+		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
 				rawPacket, rawPacketLen);
 
 		if (result == RETURN_OK) {
@@ -527,7 +527,7 @@ void DeviceHandlerBase::doGetWrite() {
 		return;
 	}
 	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(cookie);
+	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
 	if (result == RETURN_OK) {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
@@ -548,7 +548,7 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
-	result = communicationInterface->requestReceiveMessage(cookie, requestLen);
+	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	} else {
@@ -575,7 +575,7 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(cookie, &receivedData,
+	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
 			&receivedDataLen);
 
 	if (result != RETURN_OK) {
@@ -1277,7 +1277,7 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t obje
 }
 
 uint32_t DeviceHandlerBase::getLogicalAddress() {
-	return logicalAddress;
+	return this->comCookie->getAddress();
 }
 
 void DeviceHandlerBase::performOperationHook() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3e588115..05be2d45 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -17,6 +17,7 @@
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -93,9 +94,9 @@ public:
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
-	DeviceHandlerBase(object_id_t setObjectId, address_t logicalAddress_,
-			object_id_t deviceCommunication, Cookie* cookie_, size_t maxReplyLen,
-			uint8_t setDeviceSwitch, uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
+	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
@@ -422,22 +423,6 @@ protected:
 	 */
 	size_t requestLen = 0;
 
-//	/**
-//	 * This union (or std::variant) type can be used to set comParameters which
-//	 * are passed in the open() and reOpen() calls to the communication
-//	 * interface
-//	 * TODO: I don't know if we should use C++17 features but if we do we propably
-//	 *		 should also write a function to get either a storeId handle
-//	 *		 or an array handle so these values can be set conveniently.
-//	 * The good think is that if there are many parameters, they can
-//	 * be stored in the IPC pool. But maybe two uint32_t parameters are enough.
-//	 * Simple = Good. It is downwards compatible and one can still store
-//	 * 4 bytes of parameters AND a store ID.
-//	 */
-//	comParameters_t comParameters;
-	// uint32_t comParameter1 = 0;
-	// uint32_t comParameter2 = 0;
-
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -515,7 +500,7 @@ protected:
 	 * Cookie used for communication. This is passed to the communication
 	 * interface.
 	 */
-	Cookie *cookie;
+	CookieIF *comCookie;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -959,7 +944,7 @@ private:
 	/**
 	* cached from ctor for initialize()
 	*/
-	const uint32_t logicalAddress;
+	//const uint32_t logicalAddress = 0;
 
 	/**
 	 * Used for timing out mode transitions.
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 5bf2ba9f..84e407ba 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -93,10 +93,10 @@ RMAPCookie::~RMAPCookie() {
 
 }
 
-uint32_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
+//uint32_t RMAPCookie::getMaxReplyLen() const {
+//	return maxReplyLen;
+//}
+//
 void RMAPCookie::setMaxReplyLen(uint32_t maxReplyLen) {
 	this->maxReplyLen = maxReplyLen;
 }
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index c091ba18..cf033bae 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -6,7 +6,7 @@
 
 class RMAPChannelIF;
 
-class RMAPCookie : public Cookie{
+class RMAPCookie : public Cookie {
 public:
 	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
 	RMAPCookie();
@@ -28,7 +28,7 @@ public:
 	void setCommandMask(uint8_t commandMask);
 	uint8_t getCommandMask();
 
-	uint32_t getMaxReplyLen() const;
+	//size_t getMaxReplyLen() const;
 	void setMaxReplyLen(uint32_t maxReplyLen);
 
 	uint16_t getTransactionIdentifier() const;

From f7b7e10d05224dcd6ab5e2c0c4e778ce5585c544 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 23 Mar 2020 19:14:36 +0100
Subject: [PATCH 0130/1292] date format changed

---
 devicehandlers/CookieIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 3e08709b..d8781cd7 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,7 +1,7 @@
 /**
  * @file CookieIF.h
  *
- * @date 23 Mar 2020
+ * @date 23.03.2020
  */
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_

From 7e8d92f956220734c4d65dc026550595cfbf577f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 00:22:17 +0100
Subject: [PATCH 0131/1292] replaced std::list by std::set for fixedSlotSequen

---
 devicehandlers/DeviceHandlerBase.h   |  8 ++-
 devicehandlers/DeviceHandlerIF.h     | 22 --------
 devicehandlers/FixedSequenceSlot.h   | 19 ++++---
 devicehandlers/FixedSlotSequence.cpp | 84 ++++++++++++++--------------
 devicehandlers/FixedSlotSequence.h   | 48 ++++++++++------
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  4 +-
 tasks/FixedTimeslotTaskIF.h          |  4 +-
 7 files changed, 95 insertions(+), 94 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 05be2d45..3bfb07ae 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -69,6 +69,12 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
+ * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
+ * power switches are not implemented yet. Otherwise, the device handler will
+ * not transition to MODE_ON, even if setMode(MODE_ON) is called.
+ * If a transition to MODE_ON is desired without commanding, override the
+ * intialize() function and call setMode(_MODE_START_UP) before calling
+ * DeviceHandlerBase::initialize().
  *
  * @ingroup devices
  */
@@ -349,7 +355,7 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
+	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index c453e7e8..f0f7adfd 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,33 +7,11 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
-#if __cplusplus >= 201703L
-#include <array>
-#include <variant>
-#endif
-
 /**
  * Physical address type
  */
 typedef uint32_t address_t;
 
-///**
-// * This type safe union cold be used if C++17 or newer is used to transfer
-// * comIF settings to the communication interface object.
-// */
-//
-//#if __cplusplus >= 201703L
-//using comParameterArray_t = std::array<uint8_t, 4>;
-//using comParameters_t = std::variant<store_address_t, comParameterArray_t>;
-//#else
-//using comParameters_t = union comParameters {
-//		comParameters() = default;
-//		comParameters(uint32_t initValue): storeIdRaw(initValue) {}
-//		uint32_t storeIdRaw;
-//		uint8_t comParameter[4];
-//	};
-//#endif
-
 /**
  * This is the Interface used to communicate with a device handler.
  *
diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h
index 0ed285b3..b3bac08f 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/devicehandlers/FixedSequenceSlot.h
@@ -19,29 +19,34 @@ class PeriodicTaskIF;
  */
 class FixedSequenceSlot {
 public:
-			FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs, int8_t setSequenceId, PeriodicTaskIF* executingTask );
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, PeriodicTaskIF* executingTask );
 	virtual ~FixedSequenceSlot();
 
 	/**
-	 * \brief	\c handler identifies which device handler object is executed in this slot.
+	 * @brief	Handler identifies which device handler object is executed in this slot.
 	 */
 	ExecutableObjectIF*	handler;
 
 	/**
-	 * \brief	This attribute defines when a device handler object is executed.
+	 * @brief	This attribute defines when a device handler object is executed.
 	 *
-	 * \details	The pollingTime attribute identifies the time the handler is executed in ms. It must be
-	 * 			smaller than the period length of the polling sequence, which is ensured by automated calculation
-	 * 			from a database.
+	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
+	 * 			It must be smaller than the period length of the polling sequence.
 	 */
 	uint32_t	pollingTimeMs;
 
 	/**
 	 * \brief	This value defines the type of device communication.
 	 *
-	 * \details	The state of this value decides what communication routine is called in the PST executable or the device handler object.
+	 * \details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
 	 */
 	uint8_t			opcode;
+
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
 };
 
 
diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index a65dd929..f01b1399 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -2,22 +2,23 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
+		slotLengthMs(setLengthMs) {
 	current = slotList.begin();
 }
 
 FixedSlotSequence::~FixedSlotSequence() {
-	std::list<FixedSequenceSlot*>::iterator slotIt;
-	//Iterate through slotList and delete all entries.
-	slotIt = this->slotList.begin();
-	while (slotIt != this->slotList.end()) {
-		delete (*slotIt);
-		slotIt++;
-	}
+	// This should call the destructor on each list entry.
+	slotList.clear();
+//	SlotListIter slotListIter = this->slotList.begin();
+//	//Iterate through slotList and delete all entries.
+//	while (slotListIter != this->slotList.end()) {
+//		delete (*slotIt);
+//		slotIt++;
+//	}
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	(*this->current)->handler->performOperation((*this->current)->opcode);
+	current->handler->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -31,53 +32,50 @@ void FixedSlotSequence::executeAndAdvance() {
 
 uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	uint32_t oldTime;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = current;
+	SlotListIter slotListIter = current;
 	// Get the pollingTimeMs of the current slot object.
-	oldTime = (*it)->pollingTimeMs;
+	oldTime = slotListIter->pollingTimeMs;
 	// Advance to the next object.
-	it++;
+	slotListIter++;
 	// Find the next interval which is not 0.
-	while (it != slotList.end()) {
-		if (oldTime != (*it)->pollingTimeMs) {
-			return (*it)->pollingTimeMs - oldTime;
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
 		} else {
-			it++;
+			slotListIter++;
 		}
 	}
 	// If the list end is reached (this is definitely an interval != 0),
 	// the interval is calculated by subtracting the remaining time of the PST
 	// and adding the start time of the first handler in the list.
-	it = slotList.begin();
-	return lengthMs - oldTime + (*it)->pollingTimeMs;
+	slotListIter = slotList.begin();
+	return slotLengthMs - oldTime + slotListIter->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 	uint32_t currentTime;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = current;
+	SlotListIter slotListIter = current;
 	// Get the pollingTimeMs of the current slot object.
-	currentTime = (*it)->pollingTimeMs;
+	currentTime = slotListIter->pollingTimeMs;
 
 	//if it is the first slot, calculate difference to last slot
-	if (it == slotList.begin()){
-		return lengthMs - (*(--slotList.end()))->pollingTimeMs + currentTime;
+	if (slotListIter == slotList.begin()){
+		return slotLengthMs - (--slotList.end())->pollingTimeMs + currentTime;
 	}
 	// get previous slot
-	it--;
+	slotListIter--;
 
-	return currentTime - (*it)->pollingTimeMs;
+	return currentTime - slotListIter->pollingTimeMs;
 }
 
 bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = (*current)->pollingTimeMs;
-	std::list<FixedSequenceSlot*>::iterator it;
-	it = this->current;
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
 	// Get the pollingTimeMs of the current slot object.
-	if (it == slotList.begin())
+	if (fixedSequenceIter == slotList.begin())
 		return false;
-	it--;
-	if ((*it)->pollingTimeMs == currentTime) {
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
 		return true;
 	} else {
 		return false;
@@ -85,29 +83,30 @@ bool FixedSlotSequence::slotFollowsImmediately() {
 }
 
 uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
+	return this->slotLengthMs;
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
-	//Iterate through slotList and check successful creation. Checks if timing is ok (must be ascending) and if all handlers were found.
+	// Iterate through slotList and check successful creation.
+	// Checks if timing is ok (must be ascending) and if all handlers were found.
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;
 	while (slotIt != slotList.end()) {
-		if ((*slotIt)->handler == NULL) {
+		if (slotIt->handler == NULL) {
 			error << "FixedSlotSequene::initialize: ObjectId does not exist!"
 					<< std::endl;
 			count++;
-		} else if ((*slotIt)->pollingTimeMs < time) {
+		} else if (slotIt->pollingTimeMs < time) {
 			error << "FixedSlotSequence::initialize: Time: "
-					<< (*slotIt)->pollingTimeMs
+					<< slotIt->pollingTimeMs
 					<< " is smaller than previous with " << time << std::endl;
 			count++;
 		} else {
-			//All ok, print slot.
-//			(*slotIt)->print();
+			// All ok, print slot.
+			// (*slotIt)->print();
 		}
-		time = (*slotIt)->pollingTimeMs;
+		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
 	if (count > 0) {
@@ -118,8 +117,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 
 void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.push_back(
-			new FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-					executingTask));
+	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
+			executingTask));
 	this->current = slotList.begin();
 }
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index d72de913..974dbb2b 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -4,11 +4,15 @@
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <list>
+#include <set>
+
+using SlotList = std::set<FixedSequenceSlot>;
+using SlotListIter = std::set<FixedSequenceSlot>::iterator;
 
 /**
- * \brief	This class is the representation of a Polling Sequence Table in software.
+ * @brief	This class is the representation of a Polling Sequence Table in software.
  *
- * \details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
+ * @details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
  * 			The main idea is to create a list of device handlers, to announce all handlers to the
  * 			polling sequence and to maintain a list of polling slot objects. This slot list represents the
  * 			Polling Sequence Table in software. Each polling slot contains information to indicate when and
@@ -19,29 +23,37 @@
 class FixedSlotSequence {
 public:
 
+
 	/**
-	 * \brief	The constructor of the FixedSlotSequence object.
+	 * @brief	The constructor of the FixedSlotSequence object.
 	 *
-	 * \details	The constructor takes two arguments, the period length and the init function.
+	 * @details	The constructor takes two arguments, the period length and the init function.
 	 *
-	 * \param	setLength	The period length, expressed in ms.
+	 * @param	setLength	The period length, expressed in ms.
 	 */
 	FixedSlotSequence(uint32_t setLengthMs);
 
 	/**
-	 * \brief	The destructor of the FixedSlotSequence object.
+	 * @brief	The destructor of the FixedSlotSequence object.
 	 *
-	 * \details	The destructor frees all allocated memory by iterating through the slotList
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
 	 *  		and deleting all allocated resources.
 	 */
 	virtual ~FixedSlotSequence();
 
 	/**
-	 * \brief	This is a method to add an PollingSlot object to slotList.
+	 * @brief	This is a method to add an PollingSlot object to slotList.
 	 *
-	 * \details	Here, a polling slot object is added to the slot list. It is appended
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
 	 * 			to the end of the list. The list is currently NOT reordered.
 	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
 			PeriodicTaskIF* executingTask);
@@ -75,12 +87,12 @@ public:
 	uint32_t getIntervalToPreviousSlotMs();
 
 	/**
-	 * \brief	This method returns the length of this FixedSlotSequence instance.
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
 	 */
 	uint32_t getLengthMs() const;
 
 	/**
-	 * \brief	The method to execute the device handler entered in the current OPUSPollingSlot object.
+	 * \brief	The method to execute the device handler entered in the current PollingSlot object.
 	 *
 	 * \details	Within this method the device handler object to be executed is chosen by looking up the
 	 * 			handler address of the current slot in the handlerMap. Either the device handler's
@@ -91,17 +103,17 @@ public:
 	void executeAndAdvance();
 
 	/**
-	 * \brief	An iterator that indicates the current polling slot to execute.
+	 * @brief	An iterator that indicates the current polling slot to execute.
 	 *
-	 * \details	This is an iterator for slotList and always points to the polling slot which is executed next.
+	 * @details	This is an iterator for slotList and always points to the polling slot which is executed next.
 	 */
-	std::list<FixedSequenceSlot*>::iterator current;
+	SlotListIter current;
 
-	ReturnValue_t checkSequence() const;
+	virtual ReturnValue_t checkSequence() const;
 protected:
 
 	/**
-	 * \brief	This list contains all OPUSPollingSlot objects, defining order and execution time of the
+	 * @brief	This list contains all PollingSlot objects, defining order and execution time of the
 	 * 			device handler objects.
 	 *
 	 * @details	The slot list is a std:list object that contains all created PollingSlot instances.
@@ -109,9 +121,9 @@ protected:
 	 * 			By iterating through this list the polling sequence is executed. Two entries with identical
 	 * 			polling times are executed immediately one after another.
 	 */
-	std::list<FixedSequenceSlot*> slotList;
+	SlotList slotList;
 
-	uint32_t lengthMs;
+	uint32_t slotLengthMs;
 };
 
 #endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 604a10b8..71e166a5 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -80,10 +80,10 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = (*it)->pollingTimeMs;
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 3a3582fb..d2980184 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -5,11 +5,13 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 
 /**
- * Following the same principle as the base class IF. This is the interface for a Fixed timeslot task
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
  */
 class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
+
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep) = 0;
 	virtual ReturnValue_t checkSequence() const = 0;
 };

From ea49d88c4be5929208192fd86d9f2ccf99889cb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 14:21:57 +0100
Subject: [PATCH 0132/1292] moved all return values to DH IF

---
 action/HasActionsIF.h                |  7 +--
 datapool/DataPoolAdmin.cpp           |  2 +-
 datapool/DataPoolAdmin.h             |  4 +-
 devicehandlers/DeviceHandlerBase.cpp | 22 ++++++---
 devicehandlers/DeviceHandlerBase.h   | 49 ++++++++++---------
 devicehandlers/DeviceHandlerIF.h     | 73 ++++++++++++++++------------
 returnvalues/HasReturnvaluesIF.h     |  8 +--
 7 files changed, 92 insertions(+), 73 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 4d66ad1f..12ecb89a 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -44,10 +44,11 @@ public:
 	/**
 	 * 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!
+	 * 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, uint32_t size) = 0;
+	virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) = 0;
 };
 
 
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index 99d2b51b..e66a44e9 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
diff --git a/datapool/DataPoolAdmin.h b/datapool/DataPoolAdmin.h
index 448d78fb..dffcd462 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapool/DataPoolAdmin.h
@@ -33,8 +33,8 @@ public:
 	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 33e44146..ebb361d9 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -811,9 +811,9 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo *info = &(iter->second);
-		info->delayCycles = info->maxDelayCycles;
-		info->command = command;
+		DeviceReplyInfo & info = iter->second;
+		info.delayCycles = info.maxDelayCycles;
+		info.command = command;
 		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
@@ -1056,7 +1056,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 			if (result == RETURN_OK) {
 				replyReturnvalueToCommand(RETURN_OK);
 			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_IOBOARD);
+				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
 			}
 		}
 		return RETURN_OK;
@@ -1138,11 +1138,15 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
+	if(size == 0) {
+		return NO_COMMAND_DATA;
+	}
+
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1161,7 +1165,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-//Neither Raw nor Direct could build a command
+	// Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1179,12 +1183,13 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
+
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter = deviceCommandMap.find(
-				deviceCommandId);
+		DeviceCommandMap::iterator iter =
+				deviceCommandMap.find(deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1199,6 +1204,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
+
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3bfb07ae..5faaa8e0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -197,8 +197,9 @@ protected:
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
+	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
+	 *    - @c NOTHING_TO_SEND when no command is to be sent.
+	 *    - Anything else triggers an even with the returnvalue as a parameter.
 	 */
 	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
 
@@ -216,21 +217,25 @@ protected:
 	 * @param[out] id the device command id built
 	 * @return
 	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c RETURN_OK when no command is to be sent
+	 *    - @c NOTHING_TO_SEND when no command is to be sent
+	 *    - Anything else triggers an even with the returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * Build a device command packet from data supplied by a direct command.
+	 * @brief Build a device command packet from data supplied by a direct command.
 	 *
+	 * @details
 	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 * The existence of the command in the command map and the command size check
+	 * against 0 are done by the base class.
 	 *
 	 * @param deviceCommand the command to build, already checked against deviceCommandMap
 	 * @param commandData pointer to the data from the direct command
 	 * @param commandDataLen length of commandData
 	 * @return
-	 *     - @c RETURN_OK when #rawPacket is valid
-	 *     - @c RETURN_FAILED when #rawPacket is invalid and no data should be sent
+	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
+	 *     - Anything else triggers an event with the returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -366,14 +371,29 @@ protected:
 	 */
 	virtual void performOperationHook();
 
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
+	/**
+	 * This function call handles the execution of external commands as required
+	 * by the HasActionIF.
+	 * @param actionId
+	 * @param commandedBy
+	 * @param data
+	 * @param size
+	 * @return
+	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -392,21 +412,6 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
-//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
-
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f0f7adfd..5ea527e9 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -8,12 +8,13 @@
 #include <framework/ipc/MessageQueueSenderIF.h>
 
 /**
- * Physical address type
+ * @brief Physical address type
  */
 typedef uint32_t address_t;
 
 /**
- * This is the Interface used to communicate with a device handler.
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
  *
  */
 class DeviceHandlerIF {
@@ -30,8 +31,8 @@ public:
 	 * MODE_ON and MODE_OFF are included in hasModesIF.h
 	 */
 
-	//		MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	//		MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
 	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
 	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
@@ -60,36 +61,48 @@ public:
 	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_IOBOARD = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
-	// Standard codes used in scan for reply
-	//static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB3);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB4);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB5);
+	// Standard codes used when building commands.
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xA0); //!< Return this if no command sending in required
+	// Mostly used for internal handling.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA2); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA3); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA4); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA5); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xAA);
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xAB);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAC);
 
-	// Standard codes used in  interpret device reply
+	// Standard codes used in scanForReply
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB1); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB3); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB4); //!< Ignore full received packet
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB5);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB6);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB7);
+
+	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
 	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(
-			0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS =
-			MAKE_RETURN_CODE(0xD1);
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	// Standard codes used in getSwitches
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
+
+	//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+	//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	// where is this used?
+	// static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
 
 	/**
 	 * Communication action that will be executed.
@@ -97,10 +110,10 @@ public:
 	 * This is used by the child class to tell the base class what to do.
 	 */
 	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< RMAP send write
-		GET_WRITE, //!< RMAP get write
-		SEND_READ, //!< RMAP send read
-		GET_READ,  //!< RMAP get read
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
 		NOTHING    //!< Do nothing.
 	};
 
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 5adbca3f..b8b72a9f 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -9,19 +9,13 @@
 typedef uint16_t ReturnValue_t;
 
 
-
-
-
-
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
+	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
 	virtual ~HasReturnvaluesIF() {
 	}
 
 };
 
-
-
 #endif /* HASRETURNVALUESIF_H_ */

From b2b6b8ee23bc1ed05a4b1e1fc583a9c3f1f71cef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 24 Mar 2020 15:33:18 +0100
Subject: [PATCH 0133/1292] added initializeInterface for comIF/cookie

---
 devicehandlers/DeviceCommunicationIF.h | 12 ++++++++++++
 devicehandlers/DeviceHandlerBase.cpp   |  9 ++++-----
 devicehandlers/DeviceHandlerBase.h     |  2 +-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 6f271504..931fc8b5 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -46,6 +46,18 @@ public:
 
 	virtual ~DeviceCommunicationIF() {}
 
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
 	/**
 	 * Called by DHB in the SEND_WRITE doSendWrite().
 	 * This function is used to send data to the physical device
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ebb361d9..ad699508 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -102,11 +102,10 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-//	result = communicationInterface->open(&cookie, logicalAddress,
-//			maxDeviceReplyLen, comParameter1, comParameter2);
-//	if (result != RETURN_OK) {
-//		return result;
-//	}
+	result = communicationInterface->initializeInterface(comCookie);
+	if (result != RETURN_OK) {
+		return result;
+	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5faaa8e0..dcca2cc4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -464,7 +464,7 @@ protected:
 	 * indicates either that all raw messages to and from the device should be sent to #theOneWhoWantsToReadRawTraffic
 	 * or that all device TM should be downlinked to #theOneWhoWantsToReadRawTraffic
 	 */
-	enum WiretappingMode {
+	enum WiretappingMode: uint8_t {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 

From 163779622fd9b7d367a0fe05d236928e2727d06e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 25 Mar 2020 02:08:35 +0100
Subject: [PATCH 0134/1292] DHB: replyLen in replyMap now

---
 devicehandlers/DeviceHandlerBase.cpp | 38 +++++++------
 devicehandlers/DeviceHandlerBase.h   | 83 +++++++++++++++-------------
 2 files changed, 67 insertions(+), 54 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ad699508..068a62de 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -332,37 +332,35 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
-		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		uint8_t periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId) {
-//No need to check, as we may try to insert multiple times.
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic,
+		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
-		return insertInReplyMap(replyId, maxDelayCycles, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, uint8_t periodic) {
+		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
+	info.replyLen = replyLen;
 	info.command = deviceCommandMap.end();
-	std::pair<std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator, bool> returnValue;
-	returnValue = deviceReplyMap.insert(
-			std::pair<DeviceCommandId_t, DeviceReplyInfo>(replyId, info));
-	if (returnValue.second) {
+	std::pair<DeviceReplyIter, bool> result = deviceReplyMap.emplace(replyId, info);
+	if (result.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
 	info.isExecuting = false;
@@ -378,9 +376,8 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(
-		DeviceCommandId_t deviceReply, uint16_t delayCycles,
-		uint16_t maxDelayCycles, uint8_t periodic) {
+ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
+		uint16_t delayCycles, uint16_t maxDelayCycles, uint8_t periodic) {
 	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.find(deviceReply);
 	if (iter == deviceReplyMap.end()) {
@@ -547,6 +544,15 @@ void DeviceHandlerBase::doGetWrite() {
 
 void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
+
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
+	}
+
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index dcca2cc4..b4882b9d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -275,26 +275,33 @@ protected:
 	 * @details
 	 * This is used by the base class to check the data received for valid packets.
 	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet, eg checksums lengths and protocol data.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data.
 	 * No information check is done, e.g. range checks etc.
 	 *
-	 * Errors should be reported directly, the base class does NOT report any errors based on the return
-	 * value of this function.
+	 * Errors should be reported directly,  the base class does NOT report
+	 * any errors based on the returnvalue of this function.
 	 *
 	 * @param start start of remaining buffer to be scanned
 	 * @param len length of remaining buffer to be scanned
 	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function, buffer is scanned at previous position + foundLen.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 * 						buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start, implies @c foundLen is not valid, base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid, eg checksum error, implies @c foundLen is valid, can be used to skip some bytes
+	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *             implies @c foundLen is not valid,
+	 *             base class will call scanForReply() again with ++start
+	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
 	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
 	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
 	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been requested by a command, but should be handled anyway (@see also fillCommandAndCookieMap() )
+	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *             requested by a command, but should be handled anyway
+	 *             (@see also fillCommandAndCookieMap() )
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
 			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
 
 	/**
@@ -513,6 +520,30 @@ protected:
 	 */
 	CookieIF *comCookie;
 
+	struct DeviceCommandInfo {
+		bool isExecuting; //!< Indicates if the command is already executing.
+		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
+		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
+		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
+	};
+	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
+
+	/**
+	 * @brief Information about expected replies
+	 *
+	 * This is used to keep track of pending replies
+	 */
+	struct DeviceReplyInfo {
+		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
+		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
+		size_t replyLen = 0; //!< Expected size of the reply.
+		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
+		DeviceCommandMap::iterator command; //!< The command that expects this reply.
+	};
+
+	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
+	typedef DeviceReplyMap::iterator DeviceReplyIter;
+
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
 	 */
@@ -696,7 +727,7 @@ protected:
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 	/**
 	 * This is a helper method to insert replies in the reply map.
@@ -707,7 +738,7 @@ protected:
 	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, uint8_t periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 	/**
 	 * A simple command to add a command to the commandList.
 	 * @param deviceCommand The command to add
@@ -762,14 +793,6 @@ protected:
 	 */
 	virtual void modeChanged(void);
 
-	struct DeviceCommandInfo {
-		bool isExecuting; //!< Indicates if the command is already executing.
-		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
-		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
-		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
-	};
-
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
 	/**
 	 * Enable the reply checking for a command
 	 *
@@ -780,16 +803,16 @@ protected:
 	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
 	 * expect one reply.
 	 *
-	 * Can be overwritten by the child, if a command activates multiple replies or replyId differs from
-	 * commandId.
+	 * Can be overwritten by the child, if a command activates multiple replies
+	 * or replyId differs from commandId.
 	 * Notes for child implementations:
 	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
 	 * @param deviceCommand
 	 * @return 	- RETURN_OK if a reply was activated.
-	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an error case as many commands
-	 * 				do not expect a reply.
+	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
+	 * 			  error case as many commands do not expect a reply.
 	 */
 	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
 			uint8_t expectedReplies = 1, bool useAlternateId = false,
@@ -884,22 +907,6 @@ protected:
 
 	bool commandIsExecuting(DeviceCommandId_t commandId);
 
-	/**
-	 * Information about expected replies
-	 *
-	 * This is used to keep track of pending replies
-	 */
-	struct DeviceReplyInfo {
-		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
-		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
-		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
-		DeviceCommandMap::iterator command; //!< The command that expects this reply.
-	};
-
-	/**
-	 * Definition for the important reply Map.
-	 */
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
 	/**
 	 * This map is used to check and track correct reception of all replies.
 	 *

From 093fef5d6f2aea6589abe45077037057bfb879ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 26 Mar 2020 15:20:17 +0100
Subject: [PATCH 0135/1292] moved address_t typedef to cookieImoved address_t
 typedef to cookieIFF

---
 devicehandlers/CookieIF.h            |  5 ++
 devicehandlers/DeviceHandlerBase.cpp | 23 ++++----
 devicehandlers/DeviceHandlerBase.h   | 87 ++++++++++++++--------------
 devicehandlers/DeviceHandlerIF.h     |  7 +--
 4 files changed, 64 insertions(+), 58 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index d8781cd7..fc89c1af 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -8,6 +8,11 @@
 #define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
 #include <framework/devicehandlers/DeviceHandlerIF.h>
 
+/**
+ * @brief Physical address type
+ */
+typedef uint32_t address_t;
+
 class CookieIF {
 public:
 	/**
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 068a62de..b1af2689 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -365,11 +365,8 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
-	returnValue = deviceCommandMap.insert(
-			std::pair<DeviceCommandId_t, DeviceCommandInfo>(deviceCommand,
-					info));
-	if (returnValue.second) {
+	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
+	if (result.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
@@ -489,7 +486,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo* info = &(iter->second.command->second);
+	DeviceCommandInfo * info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -550,13 +547,17 @@ void DeviceHandlerBase::doSendRead() {
 		requestLen = iter->second.replyLen;
 	}
 	else {
-		requestLen = 0;
+		requestLen = comCookie->getMaxReplyLen();
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	} else {
+	}
+	else if(result == NO_READ_REQUEST) {
+		return;
+	}
+	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -816,9 +817,9 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo & info = iter->second;
-		info.delayCycles = info.maxDelayCycles;
-		info.command = command;
+		DeviceReplyInfo * info = &(iter->second);
+		info->delayCycles = info->maxDelayCycles;
+		info->command = command;
 		command->second.expectedReplies = expectedReplies;
 		return RETURN_OK;
 	} else {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b4882b9d..129fb288 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -194,6 +194,9 @@ protected:
 	 * different commands can built returned depending on the submode.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * If variable command frequence is required, a counter can be used and
+	 * the frequency in the reply map has to be set manually
+	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
@@ -527,6 +530,7 @@ protected:
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
+	typedef DeviceCommandMap::iterator DeviceCommandIter;
 
 	/**
 	 * @brief Information about expected replies
@@ -674,48 +678,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * Is the combination of mode and submode valid?
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if valid
-	 *    - @c RETURN_FAILED if invalid
-	 */
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode);
-
-	/**
-	 * Get the Rmap action for the current step.
-	 *
-	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
-	 */
-	virtual CommunicationAction_t getComAction();
-
-	/**
-	 * Build the device command to send for raw mode.
-	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
-	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c NOTHING_TO_SEND when no command is to be sent
-	 */
-	virtual ReturnValue_t buildChildRawCommand();
-
-
 	/**
 	 * This is a helper method to facilitate inserting entries in the command map.
 	 * @param deviceCommand	Identifier of the command to add.
@@ -765,6 +727,47 @@ protected:
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
+	/**
+	 * Is the combination of mode and submode valid?
+	 *
+	 * @param mode
+	 * @param submode
+	 * @return
+	 *    - @c RETURN_OK if valid
+	 *    - @c RETURN_FAILED if invalid
+	 */
+	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+			Submode_t submode);
+
+	/**
+	 * Get the Rmap action for the current step.
+	 *
+	 * The step number can be read from #pstStep.
+	 *
+	 * @return The Rmap action to execute in this step
+	 */
+	virtual CommunicationAction_t getComAction();
+
+	/**
+	 * Build the device command to send for raw mode.
+	 *
+	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
+	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
+	 * Its only current use is in the STR handler which gets its raw packets from a different
+	 * source.
+	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 *
+	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c NOTHING_TO_SEND when no command is to be sent
+	 */
+	virtual ReturnValue_t buildChildRawCommand();
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 5ea527e9..c6baf7af 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -7,11 +7,6 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
-/**
- * @brief Physical address type
- */
-typedef uint32_t address_t;
-
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -95,6 +90,8 @@ public:
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+	// Standard codes used in buildNomalDeviceCommand
+	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0xD2);
 
 	// Standard codes used in getSwitches
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches

From e252a5b795147d11371514b9defad39d91a596ed Mon Sep 17 00:00:00 2001
From: "jakob.meier" <jakob.meier@outlook.de>
Date: Thu, 26 Mar 2020 19:20:16 +0100
Subject: [PATCH 0136/1292] file system support

---
 memory/FileSystemMessage.cpp | 28 ++++++++++++++++++++++++++++
 memory/FileSystemMessage.h   | 30 ++++++++++++++++++++++++++++++
 memory/HasFileSystemIF.h     | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+)
 create mode 100644 memory/FileSystemMessage.cpp
 create mode 100644 memory/FileSystemMessage.h
 create mode 100644 memory/HasFileSystemIF.h

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
new file mode 100644
index 00000000..efbc8009
--- /dev/null
+++ b/memory/FileSystemMessage.cpp
@@ -0,0 +1,28 @@
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include <framework/objectmanager/ObjectManagerIF.h>
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
new file mode 100644
index 00000000..b6fd7309
--- /dev/null
+++ b/memory/FileSystemMessage.h
@@ -0,0 +1,30 @@
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
new file mode 100644
index 00000000..8b66f88b
--- /dev/null
+++ b/memory/HasFileSystemIF.h
@@ -0,0 +1,36 @@
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */

From 0e56a094d305a35b80bdb20cc0c3cdcd533bd888 Mon Sep 17 00:00:00 2001
From: "jakob.meier" <jakob.meier@outlook.de>
Date: Thu, 26 Mar 2020 19:43:38 +0100
Subject: [PATCH 0137/1292] merged FwMessageTypes

---
 ipc/FwMessageTypes.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index ec1c9aa2..07e3d245 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -14,7 +14,8 @@ enum FW_MESSAGE_TYPE {
 	MONITORING,
 	MEMORY,
 	PARAMETER,
-	FW_MESSAGES_COUNT
+	FW_MESSAGES_COUNT,
+	FILE_SYSTEM_MESSAGE
 };
 }
 

From 5d071a1cf1e4160386566cd1bcd1eeb70e65e5f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 26 Mar 2020 19:53:05 +0100
Subject: [PATCH 0138/1292] new device comIF return value in DHB

request receive message
---
 devicehandlers/DeviceCommunicationIF.h | 32 +++++++++++++++-----------
 devicehandlers/DeviceHandlerBase.cpp   |  6 ++---
 devicehandlers/DeviceHandlerIF.h       |  2 --
 osal/FreeRTOS/BinarySemaphore.cpp      | 20 ++++++++--------
 4 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 931fc8b5..ddd27d10 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -38,11 +38,16 @@ class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x05);
+	//!< This is used if no read request is to be made by the device handler.
+	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0x01);
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
 
 	virtual ~DeviceCommunicationIF() {}
 
@@ -54,7 +59,8 @@ public:
 	 * this can be performed in this function, which is called on device handler
 	 * initialization.
 	 * @param cookie
-	 * @return
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -66,8 +72,7 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers sending failed event with
-	 *           returnvalue as parameter 1
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -77,8 +82,7 @@ public:
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
 	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers sending failed event with
-	 *           returnvalue as parameter 1
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -86,7 +90,10 @@ public:
 	 * Called by DHB in the SEND_WRITE doSendRead().
 	 * Request a reply.
 	 * @param cookie
-	 * @return
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -98,8 +105,7 @@ public:
 	 * @param data
 	 * @param len
 	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers receiving failed with
-	 *           returnvalue as parameter 1
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b1af2689..8187ffde 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -554,7 +554,7 @@ void DeviceHandlerBase::doSendRead() {
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-	else if(result == NO_READ_REQUEST) {
+	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
 		return;
 	}
 	else {
@@ -777,8 +777,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.find(
-				(DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.
+				find((DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index c6baf7af..34aa4114 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -90,8 +90,6 @@ public:
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-	// Standard codes used in buildNomalDeviceCommand
-	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0xD2);
 
 	// Standard codes used in getSwitches
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 4ec61ff7..631e4742 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,8 +11,8 @@
 #include "task.h"
 
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle); // @suppress("Function cannot be resolved")
-	if(handle == NULL) {
+	xSemaphoreCreateBinary(handle);
+	if(handle == nullptr) {
 		error << "Binary semaphore creation failure" << std::endl;
 	}
 }
@@ -22,7 +22,7 @@ BinarySemaphore::~BinarySemaphore() {
 }
 
 ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
-	if(handle == NULL) {
+	if(handle == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TickType_t timeout = portMAX_DELAY;
@@ -39,7 +39,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 }
 
 ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
-	if(handle == NULL) {
+	if(handle == nullptr) {
 		return SEMAPHORE_NOT_FOUND;
 	}
 
@@ -52,7 +52,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeout
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	if (handle == NULL) {
+	if (handle == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
@@ -68,7 +68,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
-	if (semaphore == NULL) {
+	if (semaphore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
@@ -80,13 +80,15 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 }
 
 void BinarySemaphore::resetSemaphore() {
-	vSemaphoreDelete(handle);
-	xSemaphoreCreateBinary(handle);
+	if(handle != nullptr) {
+		vSemaphoreDelete(handle);
+		xSemaphoreCreateBinary(handle);
+	}
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
-	if (semaphore == NULL) {
+	if (semaphore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);

From 93678adc5a8570f444e82259c991f8b5e378cae8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 28 Mar 2020 00:09:15 +0100
Subject: [PATCH 0139/1292] replace std::set by std::multiset

so there can be multiple entries with same pollignTime
---
 devicehandlers/FixedSlotSequence.cpp |  5 ++++-
 devicehandlers/FixedSlotSequence.h   | 17 ++++++++++-------
 tasks/FixedTimeslotTaskIF.h          |  3 ++-
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index f01b1399..23bb0e78 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -104,11 +104,14 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			count++;
 		} else {
 			// All ok, print slot.
-			// (*slotIt)->print();
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
 		time = slotIt->pollingTimeMs;
 		slotIt++;
 	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 974dbb2b..813d2fce 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -6,8 +6,8 @@
 #include <list>
 #include <set>
 
-using SlotList = std::set<FixedSequenceSlot>;
-using SlotListIter = std::set<FixedSequenceSlot>::iterator;
+using SlotList = std::multiset<FixedSequenceSlot>;
+using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
@@ -69,11 +69,14 @@ public:
 	/**
 	 * \brief	This method returns the time until the next software component is invoked.
 	 *
-	 * \details	This method is vitally important for the operation of the PST. By fetching the polling time
-	 * 			of the current slot and that of the next one (or the first one, if the list end is reached)
-	 * 			it calculates and returns the interval in milliseconds within which the handler execution
-	 * 			shall take place. If the next slot has the same time as the current one, it is ignored until
-	 * 			a slot with different time or the end of the PST is found.
+	 * \details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
 	 */
 	uint32_t getIntervalToNextSlotMs();
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index d2980184..7edd6751 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -12,7 +12,8 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
 
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep) = 0;
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 

From 5218a0d84f987272ac2281c6a09ac4ef431dceb6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 28 Mar 2020 19:42:24 +0100
Subject: [PATCH 0140/1292] doc fix

---
 devicehandlers/DeviceCommunicationIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index ddd27d10..68db82e6 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -10,7 +10,7 @@
  */
 
 /**
- * @defgroup communication comm
+ * @defgroup comm Communication
  * @brief Communication software components.
  */
 
@@ -18,7 +18,7 @@
  * @brief This is an interface to decouple device communication from
  * the device handler to allow reuse of these components.
  * @details
- * Documentation: Dissertation Baetz p.138
+ * Documentation: Dissertation Baetz p.138.
  * It works with the assumption that received data
  * is polled by a component. There are four generic steps of device communication:
  *

From 996dbc9e4b952fa208b1e4b12d1ee291701ddf57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 12:41:54 +0200
Subject: [PATCH 0141/1292] DHB/Cookie refactoring

---
 devicehandlers/ChildHandlerBase.cpp    |   2 +-
 devicehandlers/Cookie.cpp              |  26 -------
 devicehandlers/Cookie.h                |  38 ---------
 devicehandlers/CookieIF.h              |  63 ++++++++-------
 devicehandlers/DeviceCommunicationIF.h |  11 ++-
 devicehandlers/DeviceHandlerBase.cpp   |  31 ++++----
 devicehandlers/DeviceHandlerBase.h     |  23 +-----
 rmap/RMAP.cpp                          |   6 +-
 rmap/RMAP.h                            |   6 +-
 rmap/RMAPChannelIF.h                   |   5 +-
 rmap/RMAPCookie.cpp                    |  10 +--
 rmap/RMAPCookie.h                      |   9 ++-
 rmap/RmapDeviceCommunicationIF.cpp     |  22 +++---
 rmap/RmapDeviceCommunicationIF.h       | 103 +++++++++++++------------
 14 files changed, 142 insertions(+), 213 deletions(-)
 delete mode 100644 devicehandlers/Cookie.cpp
 delete mode 100644 devicehandlers/Cookie.h

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index ac0b2438..c3484676 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -8,7 +8,7 @@ ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			maxDeviceReplyLen, setDeviceSwitch,  thermalStatePoolId,
+			setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
diff --git a/devicehandlers/Cookie.cpp b/devicehandlers/Cookie.cpp
deleted file mode 100644
index 05b9425c..00000000
--- a/devicehandlers/Cookie.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * @file Cookie.cpp
- *
- * @date 23.03.2020
- */
-#include <framework/devicehandlers/Cookie.h>
-
-Cookie::Cookie(address_t logicalAddress_): logicalAddress(logicalAddress_) {
-}
-
-void Cookie::setAddress(address_t logicalAddress_) {
-	logicalAddress = logicalAddress_;
-}
-void Cookie::setMaxReplyLen(size_t maxReplyLen_) {
-	maxReplyLen = maxReplyLen_;
-}
-
-address_t Cookie::getAddress() const {
-	return logicalAddress;
-}
-
-size_t Cookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-
diff --git a/devicehandlers/Cookie.h b/devicehandlers/Cookie.h
deleted file mode 100644
index d76facc0..00000000
--- a/devicehandlers/Cookie.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
-#include <framework/devicehandlers/CookieIF.h>
-
-/**
- * @brief This datatype is used to identify different connection over a single interface
- *        (like RMAP or I2C)
- * @details
- * To use this class, implement a communication specific child cookie which
- * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
- * CookieIF* childCookie = new ChildCookie(...).´
- *
- * This cookie is then passed to the child device handlers, which stores the
- * pointer and passes it to the communication interface functions.
- *
- * The cookie can be used to store all kinds of information
- * about the communication, like slave addresses, communication status,
- * communication parameters etc.
- *
- * @ingroup comm
- */
-class Cookie: public CookieIF {
-public:
-	Cookie();
-	Cookie(address_t logicalAddress_);
-	virtual ~Cookie() {};
-
-	virtual void setAddress(address_t logicalAddres_);
-	virtual void setMaxReplyLen(size_t maxReplyLen_);
-
-	virtual address_t getAddress() const;
-	virtual size_t getMaxReplyLen() const;
-private:
-	address_t logicalAddress = 0;
-	size_t maxReplyLen = 0;
-};
-
-#endif /* COOKIE_H_ */
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index fc89c1af..55fdb44b 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,30 +1,33 @@
-/**
- * @file CookieIF.h
- *
- * @date 23.03.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-
-/**
- * @brief Physical address type
- */
-typedef uint32_t address_t;
-
-class CookieIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~CookieIF() {};
-
-	virtual void setAddress(address_t logicalAddress_) = 0;
-	virtual address_t getAddress() const = 0;
-
-	virtual void setMaxReplyLen(size_t maxReplyLen_) = 0;
-	virtual size_t getMaxReplyLen() const = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COOKIEIF_H_ */
+#ifndef COOKIE_H_
+#define COOKIE_H_
+#include <framework/devicehandlers/CookieIF.h>
+#include <stdint.h>
+
+/**
+ * @brief Physical address type
+ */
+typedef uint32_t address_t;
+
+/**
+ * @brief This datatype is used to identify different connection over a single interface
+ *        (like RMAP or I2C)
+ * @details
+ * To use this class, implement a communication specific child cookie which
+ * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
+ * CookieIF* childCookie = new ChildCookie(...).
+ *
+ * This cookie is then passed to the child device handlers, which stores the
+ * pointer and passes it to the communication interface functions.
+ *
+ * The cookie can be used to store all kinds of information
+ * about the communication, like slave addresses, communication status,
+ * communication parameters etc.
+ *
+ * @ingroup comm
+ */
+class CookieIF {
+public:
+	virtual ~CookieIF() {};
+};
+
+#endif /* COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 68db82e6..657f7232 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,7 +1,7 @@
 #ifndef DEVICECOMMUNICATIONIF_H_
 #define DEVICECOMMUNICATIONIF_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 /**
@@ -88,11 +88,14 @@ public:
 
 	/**
 	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * Request a reply.
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
 	 * @param cookie
+	 * @param requestLen Size of data to read
 	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
 	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8187ffde..9691ac2f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -17,7 +17,7 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-		CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+		CookieIF * comCookie_, uint8_t setDeviceSwitch,
 		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
@@ -31,7 +31,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
 		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
 {
-	this->comCookie->setMaxReplyLen(maxReplyLen);
 	commandQueue = QueueFactory::instance()->
 			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
@@ -540,23 +539,27 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result;
-
-	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
-	if(iter != deviceReplyMap.end()) {
-		requestLen = iter->second.replyLen;
-	}
-	else {
-		requestLen = comCookie->getMaxReplyLen();
+	ReturnValue_t result = RETURN_FAILED;
+	size_t requestLen = 0;
+	// If the device handler can only request replies after a command
+	// has been sent, there should be only one reply enabled and the
+	// correct reply length will be mapped.
+	for(DeviceReplyIter iter = deviceReplyMap.begin();
+			iter != deviceReplyMap.end();iter++)
+	{
+		if(iter->second.delayCycles != 0) {
+			requestLen = iter->second.replyLen;
+			break;
+		}
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
+/*	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
 		return;
-	}
+	}*/
 	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
@@ -1288,9 +1291,5 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
 }
 
-uint32_t DeviceHandlerBase::getLogicalAddress() {
-	return this->comCookie->getAddress();
-}
-
 void DeviceHandlerBase::performOperationHook() {
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 129fb288..c162210c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -101,7 +101,7 @@ public:
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, size_t maxReplyLen, uint8_t setDeviceSwitch,
+			CookieIF * comCookie_, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
@@ -439,11 +439,6 @@ protected:
 	 */
 	size_t rawPacketLen = 0;
 
-	/**
-	 * Size of data to request.
-	 */
-	size_t requestLen = 0;
-
 	/**
 	 * The mode the device handler is currently in.
 	 *
@@ -463,11 +458,6 @@ protected:
 	 */
 	uint8_t pstStep = 0;
 
-	/**
-	 * This will be used in the RMAP getRead command as expected length, is set by the constructor, can be modiefied at will.
-	 */
-	const uint32_t maxDeviceReplyLen = 0;
-
 	/**
 	 * wiretapping flag:
 	 *
@@ -526,7 +516,6 @@ protected:
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.
 		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
-		uint8_t expectedRepliesWhenEnablingReplyMap; //!< Constant value which specifies expected replies when enabling reply map. Inititated in insertInCommandAndReplyMap()
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
 	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
@@ -847,11 +836,6 @@ protected:
 	 */
 	virtual bool dontCheckQueue();
 
-	/**
-	 * Used to retrieve logical address
-	 * @return logicalAddress
-	 */
-	virtual uint32_t getLogicalAddress();
 	Mode_t getBaseMode(Mode_t transitionMode);
 
 	bool isAwaitingReply();
@@ -962,11 +946,6 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
-	/**
-	* cached from ctor for initialize()
-	*/
-	//const uint32_t logicalAddress = 0;
-
 	/**
 	 * Used for timing out mode transitions.
 	 *
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 4c95f6c9..927fe746 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -12,8 +12,8 @@ RMAP::RMAP(){
 
 }
 
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length) {
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
 	uint8_t instruction;
 
 	if ((buffer == NULL) && (length != 0)) {
@@ -61,7 +61,7 @@ ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
 }
 
 ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		uint32_t *size) {
+		size_t *size) {
 	if (cookie->getChannel() == NULL) {
 		return COMMAND_NO_CHANNEL;
 	}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 195574f8..91aa123e 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -153,8 +153,8 @@ public:
 	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
 	 *      - return codes of RMAPChannelIF::sendCommand()
 	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length);
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
 
 	/**
 	 * get the reply to a write command
@@ -204,7 +204,7 @@ public:
 	 *      - return codes of RMAPChannelIF::getReply()
 	 */
 	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			uint32_t *size);
+			size_t *size);
 
 	/**
 	 * @see sendReadCommand()
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 6549c8ef..34623bb3 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -3,6 +3,7 @@
 
 #include <framework/rmap/RMAPCookie.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 class RMAPChannelIF {
 public:
@@ -73,7 +74,7 @@ public:
 	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
 	 */
 	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			uint8_t *data, uint32_t datalen)=0;
+			const uint8_t *data, size_t datalen)=0;
 
 	/**
 	 * get the reply to an rmap command
@@ -92,7 +93,7 @@ public:
 	 *      - all RMAP standard replies
 	 */
 	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			uint32_t *len)=0;
+			size_t *len)=0;
 
 	/**
 	 *
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 84e407ba..223b5165 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -93,11 +93,11 @@ RMAPCookie::~RMAPCookie() {
 
 }
 
-//uint32_t RMAPCookie::getMaxReplyLen() const {
-//	return maxReplyLen;
-//}
-//
-void RMAPCookie::setMaxReplyLen(uint32_t maxReplyLen) {
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
 	this->maxReplyLen = maxReplyLen;
 }
 
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index cf033bae..99ebd6a2 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,12 +1,13 @@
 #ifndef RMAPCOOKIE_H_
 #define RMAPCOOKIE_H_
 
-#include <framework/devicehandlers/Cookie.h>
+#include <framework/devicehandlers/CookieIF.h>
 #include <framework/rmap/rmapStructs.h>
+#include <cstddef>
 
 class RMAPChannelIF;
 
-class RMAPCookie : public Cookie {
+class RMAPCookie : public CookieIF {
 public:
 	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
 	RMAPCookie();
@@ -28,8 +29,8 @@ public:
 	void setCommandMask(uint8_t commandMask);
 	uint8_t getCommandMask();
 
-	//size_t getMaxReplyLen() const;
-	void setMaxReplyLen(uint32_t maxReplyLen);
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
 
 	uint16_t getTransactionIdentifier() const;
 	void setTransactionIdentifier(uint16_t id_);
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 4958b3ed..6dc91339 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -5,43 +5,43 @@
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(Cookie* cookie,
-		uint8_t* data, uint32_t len) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, data, len);
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(Cookie* cookie) {
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
 	return RMAP::getWriteReply((RMAPCookie *) cookie);
 }
 
 ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		Cookie* cookie) {
+		CookieIF *cookie, size_t requestLen) {
 	return RMAP::sendReadCommand((RMAPCookie *) cookie,
 				((RMAPCookie *) cookie)->getMaxReplyLen());
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(Cookie* cookie,
-		uint8_t** buffer, uint32_t* size) {
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
 	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
 		uint32_t address) {
 
 	((RMAPCookie *) cookie)->setAddress(address);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t RmapDeviceCommunicationIF::getAddress(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
 	return ((RMAPCookie *) cookie)->getAddress();
 }
 
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(Cookie* cookie,
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
 		uint32_t parameter) {
 	//TODO Empty?
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-uint32_t RmapDeviceCommunicationIF::getParameter(Cookie* cookie) {
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
 	return 0;
 }
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 45963d86..12bac57a 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -17,66 +17,73 @@ class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
 public:
 	virtual ~RmapDeviceCommunicationIF();
 
-
 	/**
-	 * This method is mission specific as the open call will return a mission specific cookie
-	 *
-	 * @param cookie A cookie, can be mission specific subclass of RMAP Cookie
-	 * @param address The address of the RMAP Cookie
-	 * @param maxReplyLen Maximum length of expected reply
-	 * @return
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
 	/**
-	 * Use an existing cookie to open a connection to a new DeviceCommunication.
-	 * The previous connection must not be closed.
-	 * If the returnvalue is not RETURN_OK, the cookie is unchanged and
-	 * can be used with the previous connection.
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
 	 *
 	 * @param cookie
-	 * @param address
-	 * @param maxReplyLen
-	 * @return
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
-			uint32_t maxReplyLen) = 0;
-
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
 
 	/**
-	 * Closing call of connection and free memory of cookie.
-	 * Mission dependent call
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual void close(Cookie *cookie) = 0;
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
 
-	//SHOULDDO can data be const?
-	/**
-	 *
-	 *
-	 * @param cookie Expects an RMAPCookie or derived from RMAPCookie Class
-	 * @param data Data to be send
-	 * @param len Length of the data to be send
-	 * @return - Return codes of RMAP::sendWriteCommand()
-	 */
-	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
-			uint32_t len);
-
-	virtual ReturnValue_t getSendSuccess(Cookie *cookie);
-
-	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie);
-
-	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-			uint32_t *size);
-
-	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address);
-
-	virtual uint32_t getAddress(Cookie *cookie);
-
-	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter);
-
-	virtual uint32_t getParameter(Cookie *cookie);
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
 };
 
 #endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */

From 8f39820ace6ecd146b5ac8e0ce10797c79159801 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:05:55 +0200
Subject: [PATCH 0142/1292] doc formatting

---
 devicehandlers/CookieIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 55fdb44b..ca171ff4 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -9,8 +9,8 @@
 typedef uint32_t address_t;
 
 /**
- * @brief This datatype is used to identify different connection over a single interface
- *        (like RMAP or I2C)
+ * @brief 	This datatype is used to identify different connection over a
+ * 			single interface (like RMAP or I2C)
  * @details
  * To use this class, implement a communication specific child cookie which
  * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling

From 335df7787ab118078b1a22a26cdd1259d46240ed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:15:27 +0200
Subject: [PATCH 0143/1292] testing timeslot task 0

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 71e166a5..c33c4ef0 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,10 +58,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
-		if(slotTimeMs == 0) {
-			// FreeRTOS throws errors for zero values
-			slotTimeMs = 1;
-		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From bd468a1b7498d217ca681e25c1932a39639f155f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Apr 2020 17:19:03 +0200
Subject: [PATCH 0144/1292] timeslot time 0 definitely leads to error

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index c33c4ef0..7bfee7e6 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -58,6 +58,11 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != NULL) {
+		if(slotTimeMs == 0) {
+			// TODO: FreeRTOS throws errors for zero values.
+			// maybe there is a better solution than this.
+			slotTimeMs = 1;
+		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 80b1d28bc84ed4d9e86791b6e1c3e74abae3a4d4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 00:23:29 +0200
Subject: [PATCH 0145/1292] new dvice com IF return value

---
 devicehandlers/DeviceCommunicationIF.h | 33 ++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.cpp   |  5 +---
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 657f7232..39cfadd7 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -29,8 +29,8 @@
  *
  *  To identify different connection over a single interface can return
  *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the functionality of the
- *  ComIF if a separate polling task is required.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
  *  @ingroup interfaces
  *  @ingroup comm
  */
@@ -38,8 +38,9 @@ class DeviceCommunicationIF: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
 
-	//!< This is used if no read request is to be made by the device handler.
-	static const ReturnValue_t NO_READ_REQUEST = MAKE_RETURN_CODE(0x01);
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
 	//! General protocol error. Define more concrete errors in child handler
 	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
 	//! If cookie is a null pointer
@@ -60,7 +61,8 @@ public:
 	 * initialization.
 	 * @param cookie
 	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 * 		   - Everything else triggers failure event with
+	 * 		   returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -72,7 +74,8 @@ public:
 	 * @param data
 	 * @param len
 	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 *         - Everything else triggers failure event with
+	 *         returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -82,7 +85,8 @@ public:
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
 	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 * 		   - Everything else triggers falure event with
+	 * 		   returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -96,7 +100,8 @@ public:
 	 * @param cookie
 	 * @param requestLen Size of data to read
 	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 *         - Everything else triggers failure event with
+	 *         returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -105,10 +110,14 @@ public:
 	 * This function is used to receive data from the physical device
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return -@c RETURN_OK for successfull receive
+	 * 		   -@c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
 			size_t *size) = 0;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9691ac2f..9f23dd7f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -557,9 +557,6 @@ void DeviceHandlerBase::doSendRead() {
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
 	}
-/*	else if(result == DeviceCommunicationIF::NO_READ_REQUEST) {
-		return;
-	}*/
 	else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
@@ -594,7 +591,7 @@ void DeviceHandlerBase::doGetRead() {
 		return;
 	}
 
-	if (receivedDataLen == 0)
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
 		return;
 
 	if (wiretappingMode == RAW) {

From 4a35035b2890f3491d096afb22ad3421bc4d1e60 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:30:31 +0200
Subject: [PATCH 0146/1292] serial buffer adapted improvements

---
 serialize/SerialBufferAdapter.cpp | 127 ++++++++++++++----------------
 serialize/SerialBufferAdapter.h   |  34 +++-----
 2 files changed, 68 insertions(+), 93 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 6ac2894f..978d8029 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -2,83 +2,79 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::CONST), serializeLength(serializeLength),
-		constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
+		count_t bufferLength, bool serializeLength) :
+		m_serialize_length(serializeLength),
+		m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
+		m_buffer_length(bufferLength) {
 
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
 		bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength), constBuffer(NULL), buffer(buffer),
-		bufferLength(bufferLength) {
+		m_serialize_length(serializeLength), m_buffer_length(bufferLength) {
+	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer = member_buffer;
+	m_const_buffer = member_buffer;
 }
 
-template<typename T>
-SerialBufferAdapter<T>::SerialBufferAdapter(uint32_t* buffer,
-		T bufferLength, bool serializeLength) :
-		currentBufferType(bufferType::NORMAL),serializeLength(serializeLength),
-		constBuffer(NULL), buffer(reinterpret_cast<uint8_t *>(buffer)),
-		bufferLength(bufferLength*4) {
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename T>
-SerialBufferAdapter<T>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	uint32_t serializedLength = bufferLength;
-	if (serializeLength) {
+	uint32_t serializedLength = m_buffer_length;
+	if (m_serialize_length) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
-				&bufferLength);
+				&m_buffer_length);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
-		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+		if (m_serialize_length) {
+			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
 					max_size, bigEndian);
 		}
-		if (this->constBuffer != NULL) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		} else if (this->buffer != NULL) {
-			memcpy(*buffer, this->buffer, bufferLength);
+		if (this->m_const_buffer != nullptr) {
+			memcpy(*buffer, m_const_buffer, m_buffer_length);
+		} else if (this->m_buffer != nullptr) {
+			memcpy(*buffer, m_buffer, m_buffer_length);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size += m_buffer_length;
+		(*buffer) += m_buffer_length;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
-template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+template<typename count_t>
+uint32_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (m_serialize_length) {
+		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
 	} else {
-		return bufferLength;
+		return m_buffer_length;
 	}
 }
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
-		if(serializeLength){
+		if(m_serialize_length){
 			// Suggestion (would require removing rest of the block inside this if clause !):
 			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
 			//if (result != HasReturnvaluesIF::RETURN_OK) {
 			//	return result;
 			//}
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
+					&m_buffer_length);
+			if((*size - m_buffer_length - serializedSize) >= 0){
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}else{
@@ -86,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
+		if (*size - m_buffer_length >= 0) {
+			*size -= m_buffer_length;
+			memcpy(m_buffer, *buffer, m_buffer_length);
+			(*buffer) += m_buffer_length;
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return STREAM_TOO_SHORT;
@@ -99,35 +95,30 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	}
 }
 
-template<typename T>
-uint8_t * SerialBufferAdapter<T>::getBuffer() {
-	if(currentBufferType != NORMAL) {
-		warning << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(m_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		return nullptr;
 	}
-	return buffer;
+	return m_buffer;
 }
 
-template<typename T>
-const uint8_t * SerialBufferAdapter<T>::getConstBuffer() {
-	if(currentBufferType != CONST) {
-		warning << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
-		return 0;
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(m_const_buffer == nullptr) {
+		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		return nullptr;
 	}
-	return constBuffer;
+	return m_const_buffer;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint8_t * buffer_, T bufferLength_) {
-	buffer = buffer_;
-	bufferLength = bufferLength_;
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+	m_buffer = static_cast<uint8_t *>(buffer);
+	m_buffer_length = buffer_length;
 }
 
-template<typename T>
-void SerialBufferAdapter<T>::setBuffer(uint32_t * buffer_, T bufferLength_) {
-	buffer = reinterpret_cast<uint8_t *>(buffer_);
-	bufferLength = 4 * bufferLength_;
-}
 
 //forward Template declaration for linker
 template class SerialBufferAdapter<uint8_t>;
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 600bd692..4ee4ca0b 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -16,9 +16,10 @@
  *
  * \ingroup serialize
  */
-template<typename T>
+template<typename count_t>
 class SerialBufferAdapter: public SerializeIF {
 public:
+
 	/**
 	 * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
 	 * Type of length can be supplied as template type.
@@ -26,7 +27,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	/**
 	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
@@ -35,16 +36,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(uint8_t* buffer, T bufferLength, bool serializeLength = false);
-
-	/**
-	 * Constructoor for non-constant uint32_t buffer. Length field can be serialized optionally.
-	 * Type of length can be supplied as template type.
-	 * @param buffer
-	 * @param bufferLength
-	 * @param serializeLength
-	 */
-	SerialBufferAdapter(uint32_t* buffer,T bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -58,20 +50,12 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t * buffer_, T bufferLength_);
-	void setBuffer(uint32_t * buffer_, T bufferLength_);
+	void setBuffer(void* buffer_, count_t bufferLength_);
 private:
-
-	enum bufferType {
-		NORMAL,
-		CONST
-	};
-	bufferType currentBufferType;
-
-	bool serializeLength;
-	const uint8_t *constBuffer;
-	uint8_t *buffer;
-	T bufferLength;
+	bool m_serialize_length = false;
+	const uint8_t *m_const_buffer = nullptr;
+	uint8_t *m_buffer = nullptr;
+	count_t m_buffer_length = 0;
 };
 
 

From a65a19f583b4f71b4c13e3d553fc6e990fd49ba9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:33:24 +0200
Subject: [PATCH 0147/1292] deletd serial buffer adapter2

---
 serialize/SerialBufferAdapter.cpp |   4 +-
 serialize/SerialBufferAdapter2.h  | 148 ------------------------------
 2 files changed, 2 insertions(+), 150 deletions(-)
 delete mode 100644 serialize/SerialBufferAdapter2.h

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 978d8029..859e7edf 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -40,9 +40,9 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t
 			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
 					max_size, bigEndian);
 		}
-		if (this->m_const_buffer != nullptr) {
+		if (m_const_buffer != nullptr) {
 			memcpy(*buffer, m_const_buffer, m_buffer_length);
-		} else if (this->m_buffer != nullptr) {
+		} else if (m_buffer != nullptr) {
 			memcpy(*buffer, m_buffer, m_buffer_length);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/serialize/SerialBufferAdapter2.h b/serialize/SerialBufferAdapter2.h
deleted file mode 100644
index 98e2d187..00000000
--- a/serialize/SerialBufferAdapter2.h
+++ /dev/null
@@ -1,148 +0,0 @@
-#ifndef SERIALBUFFERADAPTER2_H_
-#define SERIALBUFFERADAPTER2_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <cstring>
-
-/**
- * This adapter provides an interface for SerializeIF to serialize or deserialize
- * buffers with no length header but a known size.
- *
- * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
- *
- * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
- * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename BUFFER_TYPE = uint8_t, typename count_t = uint8_t>
-class SerialBufferAdapter2: public SerializeIF {
-public:
-	/**
-	 * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
-	 * Type of length can be supplied as template type.
-	 * @param buffer
-	 * @param bufferLength
-	 * @param serializeLength
-	 */
-	SerialBufferAdapter2(void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-				bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-		buffer = reinterpret_cast<const uint8_t *>(buffer_);
-		constBuffer = NULL;
-	}
-
-	SerialBufferAdapter2(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false):
-					bufferLength(bufferLength_), serializeLength(serializeLength_) {
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-		constBuffer = reinterpret_cast<const uint8_t *>(buffer_);
-		buffer = NULL;
-	}
-
-	ReturnValue_t serialize(uint8_t ** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t serializedLength = bufferLength;
-		if (serializeLength) {
-			serializedLength += AutoSerializeAdapter::getSerializedSize(
-					&bufferLength);
-		}
-		if (*size + serializedLength > max_size) {
-			return BUFFER_TOO_SHORT;
-		} else {
-			if (serializeLength) {
-				AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
-						max_size, bigEndian);
-			}
-			memcpy(*buffer, this->buffer, bufferLength);
-			*size += bufferLength;
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	uint32_t getSerializedSize() const {
-		if (serializeLength) {
-			return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
-		} else {
-			return bufferLength;
-		}
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		//TODO Ignores Endian flag!
-		if (buffer != NULL) {
-			if(serializeLength){
-				// Suggestion (would require removing rest of the block inside this if clause !):
-				//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
-				//if (result != HasReturnvaluesIF::RETURN_OK) {
-				//	return result;
-				//}
-				count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
-						&bufferLength);
-				if((*size - bufferLength - serializedSize) >= 0){
-					*buffer +=  serializedSize;
-					*size -= serializedSize;
-				}else{
-					return STREAM_TOO_SHORT;
-				}
-			}
-			//No Else If, go on with buffer
-			if (*size - bufferLength >= 0) {
-				*size -= bufferLength;
-				memcpy(this->buffer, *buffer, bufferLength);
-				(*buffer) += bufferLength;
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return STREAM_TOO_SHORT;
-			}
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-
-	BUFFER_TYPE * getBuffer() {
-		return reinterpret_cast<BUFFER_TYPE *>(buffer);
-	}
-
-	void setBuffer(void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
-		buffer = buffer_;
-		bufferLength = bufferLength_;
-		serializeLength = serializeLength_;
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-	}
-
-	void setConstBuffer(const void * buffer_, count_t bufferLength_, bool serializeLength_ = false) {
-		constBuffer = buffer_;
-		bufferLength = bufferLength_;
-		serializeLength = serializeLength_;
-		determineLengthInBytes(sizeof(BUFFER_TYPE));
-	}
-private:
-	uint8_t * buffer;
-	const uint8_t * constBuffer;
-	count_t bufferLength;
-	bool serializeLength;
-
-	void determineLengthInBytes(uint8_t typeSize) {
-		switch(typeSize) {
-		case(1): break;
-		case(2):
-			bufferLength *= 2; break;
-		case(4):
-			bufferLength *= 4; break;
-		case(8):
-			bufferLength *= 8; break;
-		default:
-			error << "Serial Buffer Adapter 2: Invalid type size, assuming regular uint8_t." << std::endl;
-			error << "Detected type size: " << (int) typeSize << std::endl;
-		}
-	}
-};
-
-#endif /* SERIALBUFFERADAPTER2_H_ */

From 06ae64d59c7de1bfaa63c63249cc56c53c47d829 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 15:46:10 +0200
Subject: [PATCH 0148/1292] CSB: replaced some uint32 with size_t

---
 tmtcservices/CommandingServiceBase.cpp |  6 +++---
 tmtcservices/CommandingServiceBase.h   | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b9042..8d207d9c 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -219,8 +219,8 @@ void CommandingServiceBase::handleRequestQueue() {
 
 
 void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, uint32_t dataLen, const uint8_t* headerData,
-		uint32_t headerSize) {
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, headerData, headerSize);
 	ReturnValue_t result = tmPacketStored.sendPacket(
@@ -232,7 +232,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 
 
 void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
+		object_id_t objectId, const uint8_t *data, size_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
 	uint32_t size = 0;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index a62b7397..56e9b87d 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -124,7 +124,7 @@ protected:
 	 *         - @c CSB or implementation specific return codes
 	 */
 	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
 			object_id_t *objectId) = 0;
 
 	/**
@@ -141,7 +141,7 @@ protected:
 	 * @return
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage *message,
-			uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
 	/**
@@ -219,8 +219,8 @@ protected:
 	 * @param headerData HeaderData will be placed before data
 	 * @param headerSize Size of HeaderData
 	 */
-	void sendTmPacket(uint8_t subservice, const uint8_t *data, uint32_t dataLen,
-			const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	void sendTmPacket(uint8_t subservice, const uint8_t *data, size_t dataLen,
+			const uint8_t* headerData = nullptr,size_t headerSize = 0);
 
 	/**
 	 * To send TM packets of objects that still need to be serialized and consist of an object ID with appended data
@@ -230,7 +230,7 @@ protected:
 	 * @param dataLen Length of Data
 	 */
 	void sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, uint32_t dataLen);
+			const uint8_t *data, size_t dataLen);
 
 	/**
 	 * To send packets has data which is in form of a SerializeIF or Adapters implementing it
@@ -239,7 +239,7 @@ protected:
 	 * @param header Serialize IF header which will be placed before content
 	 */
 	void sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = NULL);
+			SerializeIF* header = nullptr);
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);
 

From 7079c9c56dc03bc1eb89311b831ff9f622257f81 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 17:58:39 +0200
Subject: [PATCH 0149/1292] replaced serializeIF serialize sizes with size_t

---
 action/ActionHelper.cpp                      |  5 +++--
 action/CommandActionHelper.cpp               |  2 +-
 container/FixedMap.h                         |  4 ++--
 datapool/DataPoolAdmin.cpp                   |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  4 ++--
 datapool/DataSet.cpp                         |  4 ++--
 datapool/DataSet.h                           |  4 ++--
 datapool/PIDReader.h                         |  4 ++--
 datapool/PoolRawAccess.cpp                   |  4 ++--
 datapool/PoolRawAccess.h                     |  4 ++--
 datapool/PoolRawAccessHelper.cpp             | 11 ++++++-----
 datapool/PoolRawAccessHelper.h               | 10 +++++-----
 datapool/PoolVariable.h                      |  4 ++--
 datapool/PoolVector.h                        |  4 ++--
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  4 ++--
 events/eventmatching/EventRangeMatcherBase.h |  4 ++--
 globalfunctions/Type.cpp                     |  4 ++--
 globalfunctions/Type.h                       |  4 ++--
 globalfunctions/matching/MatchTree.h         |  4 ++--
 globalfunctions/matching/RangeMatcher.h      |  4 ++--
 health/HealthTable.cpp                       |  2 +-
 monitoring/LimitViolationReporter.cpp        |  2 +-
 parameters/ParameterHelper.cpp               |  2 +-
 parameters/ParameterWrapper.cpp              |  8 ++++----
 parameters/ParameterWrapper.h                |  8 ++++----
 power/Fuse.cpp                               |  4 ++--
 power/Fuse.h                                 |  4 ++--
 power/PowerComponent.cpp                     |  4 ++--
 power/PowerComponent.h                       |  4 ++--
 serialize/SerialArrayListAdapter.h           |  9 +++++----
 serialize/SerialBufferAdapter.cpp            |  4 ++--
 serialize/SerialBufferAdapter.h              |  4 ++--
 serialize/SerialFixedArrayListAdapter.h      |  4 ++--
 serialize/SerialLinkedListAdapter.h          |  6 +++---
 serialize/SerializeAdapter.h                 | 14 +++++++-------
 serialize/SerializeElement.h                 |  6 ++++--
 serialize/SerializeIF.h                      |  5 +++--
 subsystem/Subsystem.cpp                      |  2 +-
 subsystem/modes/ModeDefinitions.h            |  4 ++--
 tmstorage/TmStorePackets.h                   |  8 ++++----
 tmtcpacket/packetmatcher/ApidMatcher.h       |  7 ++++---
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  7 ++++---
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  7 ++++---
 tmtcpacket/pus/TmPacketStored.cpp            |  2 +-
 tmtcservices/CommandingServiceBase.cpp       |  2 +-
 tmtcservices/PusVerificationReport.h         |  4 ++--
 48 files changed, 118 insertions(+), 109 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 18e46fba..96a4824c 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -67,7 +67,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	}
 }
 
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t replyId, SerializeIF* data, bool hideSender) {
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+		ActionId_t replyId, SerializeIF* data, bool hideSender) {
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
@@ -76,7 +77,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
 			&dataPtr);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index ceb97d3b..e670121f 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -26,7 +26,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	result = data->serialize(&storePointer, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/container/FixedMap.h b/container/FixedMap.h
index f5ee4244..314fb45a 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -173,8 +173,8 @@ public:
 		}
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
 				buffer, size, max_size, bigEndian);
 		uint32_t i = 0;
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index e66a44e9..25013726 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -272,7 +272,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
 			serializedSize, true);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 0ff2121d..88ac51a6 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -36,7 +36,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
 	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index faadf659..32ba6509 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -11,8 +11,8 @@ public:
 
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c73..ccd9fd3c 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -106,8 +106,8 @@ uint8_t DataSet::lockDataPool() {
 	return ::dataPool.lockDataPool();
 }
 
-ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		result = registeredVariables[count]->serialize(buffer, size, max_size,
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 8e013223..0732feb3 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -121,8 +121,8 @@ public:
 	 * @param bigEndian
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	uint32_t getSerializedSize() const;
 
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 299cc2fe..68e70e86 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -126,8 +126,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
 				bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index ff8fb956..63dc5b49 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -111,8 +111,8 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 }
 
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	if (typeSize + *size <= max_size) {
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 52ba8b21..1599a40e 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -81,8 +81,8 @@ public:
 	 * @return - @c RETURN_OK if serialization was successfull
 	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 07ea4465..7ea3576f 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -14,14 +14,15 @@
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
 		poolIdBuffer(reinterpret_cast<uint8_t * >(poolIdBuffer_)),
-		numberOfParameters(numberOfParameters_), validBufferIndex(0), validBufferIndexBit(1){
+		numberOfParameters(numberOfParameters_), validBufferIndex(0),
+		validBufferIndexBit(1) {
 }
 
 PoolRawAccessHelper::~PoolRawAccessHelper() {
 }
 
-ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
-		const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
+		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
 	int32_t remainingParametersSize = numberOfParameters * 4;
@@ -39,8 +40,8 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, uint32_t *size,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
-		const uint32_t max_size, bool bigEndian) {
+ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
+		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	int32_t remainingParametersSize = numberOfParameters * 4;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 72f2324c..4a4a1fab 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -41,8 +41,8 @@ public:
 	 * @return 	@c RETURN_OK On success
 	 * 			@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t serialize(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian);
+	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
+			const size_t max_size, bool bigEndian);
 
 	/**
 	 * Serializes data pool entries into provided buffer with the validity mask buffer
@@ -54,8 +54,8 @@ public:
 	 * @return 	@c RETURN_OK On success
 	 * 			@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, uint32_t * size,
-			const uint32_t max_size, bool bigEndian);
+	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
+			const size_t max_size, bool bigEndian);
 
 
 private:
@@ -68,7 +68,7 @@ private:
 
 	struct SerializationArgs {
 		uint8_t ** buffer;
-		uint32_t * size;
+		size_t * size;
 		const uint32_t max_size;
 		bool bigEndian;
 	};
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 2c48ca3e..76418ab8 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -193,8 +193,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
 				bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index d3617d17..154cb18a 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -197,8 +197,8 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2c9e820f..2be37dd4 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -12,7 +12,7 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1cd9470d..ecdeca49 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -11,8 +11,8 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 921a5d6a..3906b627 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -11,8 +11,8 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
 public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 814d26f4..e9bbab52 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
 	}
 }
 
-ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 88df07b6..8d595daf 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -39,8 +39,8 @@ public:
 
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 398cf3f0..ccf464f0 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -45,8 +45,8 @@ public:
 		return matchSubtree(iter, number);
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
 		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 10e07173..8e0ae850 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -27,8 +27,8 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index a575b282..94b7cf0b 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -65,7 +65,7 @@ bool HealthTable::hasHealth(object_id_t object) {
 
 void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	uint32_t size = 0;
+	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
 			&pointer, &size, maxSize, true);
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 760e8b93..77c3dad1 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -26,7 +26,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
+	size_t size = 0;
 	result = data->serialize(&dataTarget, &size, maxSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e260465a..4ba2a1d9 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -94,7 +94,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
 			serializedSize, true);
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8f661bb3..501c7c4d 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -20,8 +20,8 @@ ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 ParameterWrapper::~ParameterWrapper() {
 }
 
-ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
 	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
@@ -88,8 +88,8 @@ uint32_t ParameterWrapper::getSerializedSize() const {
 }
 
 template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f61786b8..a78e586d 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -25,8 +25,8 @@ public:
 			const void *data);
 	virtual ~ParameterWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
@@ -128,8 +128,8 @@ private:
 	const void *readonlyData;
 
 	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index dd5d3e3f..93e98290 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -86,8 +86,8 @@ ReturnValue_t Fuse::check() {
 	return result;
 }
 
-ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
diff --git a/power/Fuse.h b/power/Fuse.h
index 6da24178..a9542167 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -49,8 +49,8 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 6a87d88b..83ed0e68 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -17,8 +17,8 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 				twoSwitches), min(min), max(max), moduleId(moduleId) {
 }
 
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index a82fe1d7..de08e5ec 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -19,8 +19,8 @@ public:
 	float getMin();
 	float getMax();
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	uint32_t getSerializedSize() const;
 
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 3f80e97b..0bc0a97b 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -21,13 +21,14 @@ public:
 	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return serialize(adaptee, buffer, size, max_size, bigEndian);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+			uint8_t** buffer, size_t* size, const size_t max_size,
+			bool bigEndian) {
 		// Serialize length field first
 		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 859e7edf..a125ef44 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -26,8 +26,8 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = m_buffer_length;
 	if (m_serialize_length) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4ee4ca0b..f8ff122e 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -40,8 +40,8 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
 
 	virtual uint32_t getSerializedSize() const;
 
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 67954d68..e10322f9 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -32,8 +32,8 @@ public:
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index ef1fa200..196432af 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -63,8 +63,8 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -78,7 +78,7 @@ public:
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, uint32_t* size, const uint32_t max_size,
+			uint8_t** buffer, size_t* size, const size_t max_size,
 			bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 18240a95..7654eb0d 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -59,8 +59,8 @@ template<typename T, int>
 class SerializeAdapter_ {
 public:
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		uint32_t ignoredSize = 0;
+			size_t* size, const size_t max_size, bool bigEndian) {
+		size_t ignoredSize = 0;
 		if (size == NULL) {
 			size = &ignoredSize;
 		}
@@ -115,9 +115,9 @@ public:
 template<typename T>
 class SerializeAdapter_<T, 1> {
 public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t ignoredSize = 0;
+	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		size_t ignoredSize = 0;
 		if (size == NULL) {
 			size = &ignoredSize;
 		}
@@ -137,7 +137,7 @@ template<typename T>
 class SerializeAdapter {
 public:
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
+			size_t* size, const size_t max_size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
@@ -158,7 +158,7 @@ class AutoSerializeAdapter {
 public:
 	template<typename T>
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
+			size_t* size, const size_t max_size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index cd040c0f..81f557a5 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -29,9 +29,11 @@ public:
 	}
 	SerializeElement() : LinkedElement<SerializeIF>(this) {
 	}
+
 	T entry;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index fb750a08..d9d361c1 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,6 +2,7 @@
 #define SERIALIZEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 /**
  * @defgroup serialize Serialization
@@ -36,8 +37,8 @@ public:
 	virtual ~SerializeIF() {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const = 0;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const = 0;
 
 	virtual uint32_t getSerializedSize() const = 0;
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 2d7d9c44..8b7f3851 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -607,7 +607,7 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	}
 	uint8_t *storeBuffer;
 	store_address_t address;
-	uint32_t size = 0;
+	size_t size = 0;
 
 	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8e7531f3..8a88eb92 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -18,8 +18,8 @@ public:
 	uint8_t value3;
 	uint8_t value4;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 
 		ReturnValue_t result;
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 6eea6f58..b31b37cb 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -32,8 +32,8 @@ public:
 	}
 	uint16_t apid;
 	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -218,8 +218,8 @@ public:
 	}
 
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
 		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1f194968..0140340b 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -22,9 +22,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
+				size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 1a6781b4..be2dd2f5 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -22,9 +22,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&service, buffer,
+				size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b589b20..de62e183 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -20,9 +20,10 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size,
+				max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index bb932641..c66e3324 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -58,7 +58,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
 	uint8_t* putDataHere = getSourceData();
-	uint32_t size = 0;
+	size_t size = 0;
 	if (header != NULL) {
 		header->serialize(&putDataHere, &size, sourceDataSize, true);
 	}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 8d207d9c..5b397756 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -235,7 +235,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		object_id_t objectId, const uint8_t *data, size_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
-	uint32_t size = 0;
+	size_t size = 0;
 	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
 			sizeof(object_id_t), true);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 7a173be9..f8913627 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -49,7 +49,7 @@ class PusSuccessReport {
 private:
 	static const uint16_t MAX_SIZE = 7;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@@ -63,7 +63,7 @@ class PusFailureReport {
 private:
 	static const uint16_t MAX_SIZE = 16;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,

From 87852e5f2a3983e21c99a18f8503a511a158cecd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 21:54:11 +0200
Subject: [PATCH 0150/1292] replaced getSerializedSize returnvalue with size_t

---
 action/ActionHelper.cpp                      | 2 +-
 action/CommandActionHelper.cpp               | 2 +-
 container/FixedMap.h                         | 2 +-
 container/IndexedRingMemoryArray.h           | 6 +++---
 datapool/DataPoolParameterWrapper.cpp        | 2 +-
 datapool/DataPoolParameterWrapper.h          | 2 +-
 datapool/DataSet.cpp                         | 4 ++--
 datapool/DataSet.h                           | 2 +-
 datapool/PIDReader.h                         | 2 +-
 datapool/PoolRawAccess.cpp                   | 2 +-
 datapool/PoolRawAccess.h                     | 2 +-
 datapool/PoolVariable.h                      | 2 +-
 datapool/PoolVector.h                        | 2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  | 2 +-
 devicehandlers/DeviceTmReportingWrapper.h    | 2 +-
 events/eventmatching/EventRangeMatcherBase.h | 2 +-
 globalfunctions/Type.cpp                     | 2 +-
 globalfunctions/Type.h                       | 2 +-
 globalfunctions/matching/MatchTree.h         | 2 +-
 globalfunctions/matching/RangeMatcher.h      | 2 +-
 monitoring/LimitViolationReporter.cpp        | 2 +-
 parameters/ParameterWrapper.cpp              | 2 +-
 parameters/ParameterWrapper.h                | 2 +-
 power/Fuse.cpp                               | 2 +-
 power/PowerComponent.cpp                     | 2 +-
 power/PowerComponent.h                       | 2 +-
 serialize/SerialArrayListAdapter.h           | 2 +-
 serialize/SerialBufferAdapter.cpp            | 2 +-
 serialize/SerialBufferAdapter.h              | 2 +-
 serialize/SerialFixedArrayListAdapter.h      | 2 +-
 serialize/SerialLinkedListAdapter.h          | 2 +-
 serialize/SerializeElement.h                 | 2 +-
 serialize/SerializeIF.h                      | 2 +-
 subsystem/Subsystem.cpp                      | 2 +-
 subsystem/modes/ModeDefinitions.h            | 2 +-
 tmstorage/TmStorePackets.h                   | 4 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       | 2 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    | 2 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h | 2 +-
 tmtcpacket/pus/TmPacketStored.cpp            | 2 +-
 40 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 96a4824c..ef9f06a9 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -72,7 +72,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index e670121f..77295401 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -20,7 +20,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 	}
 	store_address_t storeId;
 	uint8_t* storePointer;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
 			&storePointer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 314fb45a..23a79aef 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -188,7 +188,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 4ab174f4..8682780a 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -159,7 +159,7 @@ public:
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
+		size_t serializedSize = 0;
 		if(additionalInfo!=NULL) {
 			serializedSize += additionalInfo->getSerializedSize();
 		}
@@ -548,9 +548,9 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 
-		uint32_t size = 0;
+		size_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 88ac51a6..aa194b61 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -69,7 +69,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-uint32_t DataPoolParameterWrapper::getSerializedSize() const {
+size_t DataPoolParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index 32ba6509..c9631b9c 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -14,7 +14,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index ccd9fd3c..90baf063 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-uint32_t DataSet::getSerializedSize() const {
-	uint32_t size = 0;
+size_t DataSet::getSerializedSize() const {
+	size_t size = 0;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 0732feb3..9bcdb892 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -124,7 +124,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 68e70e86..d6b10b65 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -132,7 +132,7 @@ public:
 				bigEndian);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 63dc5b49..16d6562e 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -193,7 +193,7 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 }
 
 
-uint32_t PoolRawAccess::getSerializedSize() const {
+size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 1599a40e..73a609ff 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -125,7 +125,7 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 76418ab8..351ffec3 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -199,7 +199,7 @@ public:
 				bigEndian);
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 154cb18a..a21f31d2 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -211,7 +211,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2be37dd4..344a1dc1 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -26,7 +26,7 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
 	return data->serialize(buffer, size, max_size, bigEndian);
 }
 
-uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
 	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index ecdeca49..1582ff48 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -14,7 +14,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 3906b627..0f096b9c 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -15,7 +15,7 @@ public:
 			const size_t max_size, bool bigEndian) const {
 		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index e9bbab52..0d6d7c1d 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -81,7 +81,7 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
 
 }
 
-uint32_t Type::getSerializedSize() const {
+size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d595daf..e6413d2d 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -42,7 +42,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index ccf464f0..3b8e1942 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 8e0ae850..c93e7919 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -40,7 +40,7 @@ public:
 		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 77c3dad1..234a0bff 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	}
 	store_address_t storeId;
 	uint8_t* dataTarget = NULL;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
 	}
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 501c7c4d..f359a745 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -77,7 +77,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-uint32_t ParameterWrapper::getSerializedSize() const {
+size_t ParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index a78e586d..6681f7c4 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -28,7 +28,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 93e98290..04adac80 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -100,7 +100,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
 }
 
 uint32_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
+	size_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
 		size += (*iter)->getSerializedSize();
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 83ed0e68..b7158e62 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -28,7 +28,7 @@ ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
 			bigEndian);
 }
 
-uint32_t PowerComponent::getSerializedSize() const {
+size_t PowerComponent::getSerializedSize() const {
 	return sizeof(min) + sizeof(max);
 }
 
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index de08e5ec..97341667 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -22,7 +22,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 0bc0a97b..5274c488 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -41,7 +41,7 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index a125ef44..83fda418 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -54,7 +54,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t*
 }
 
 template<typename count_t>
-uint32_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 	if (m_serialize_length) {
 		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
 	} else {
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index f8ff122e..0c3d4dd6 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -43,7 +43,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian);
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index e10322f9..573d3314 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -37,7 +37,7 @@ public:
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 196432af..0865faa5 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -88,7 +88,7 @@ public:
 		}
 		return result;
 	}
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 81f557a5..fe9d5d71 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -37,7 +37,7 @@ public:
 		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d9d361c1..a9f40a08 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -40,7 +40,7 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const = 0;
 
-	virtual uint32_t getSerializedSize() const = 0;
+	virtual size_t getSerializedSize() const = 0;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) = 0;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 8b7f3851..1c4bee33 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -601,7 +601,7 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		SerializeIF** elements, uint8_t count) {
 	ReturnValue_t result;
-	uint32_t maxSize = 0;
+	size_t maxSize = 0;
 	for (uint8_t i = 0; i < count; i++) {
 		maxSize += elements[i]->getSerializedSize();
 	}
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8a88eb92..406f9583 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -49,7 +49,7 @@ public:
 
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b31b37cb..b6c63b91 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -44,7 +44,7 @@ public:
 
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(apid) + sizeof(ssc);
 	}
 
@@ -244,7 +244,7 @@ public:
 		return adapter.serialize(buffer,size,max_size,bigEndian);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = 0;
 		size += AutoSerializeAdapter::getSerializedSize(&apid);
 		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 0140340b..37b91bd3 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -27,7 +27,7 @@ public:
 		return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
 				size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index be2dd2f5..31502053 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -27,7 +27,7 @@ public:
 		return SerializeAdapter<uint8_t>::serialize(&service, buffer,
 				size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index de62e183..8b872876 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -25,7 +25,7 @@ public:
 		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size,
 				max_size, bigEndian);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index c66e3324..b60f6c7e 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -42,7 +42,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}

From 42838272a522b76c9e055f93bdf7af6d00b84b01 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 22:42:48 +0200
Subject: [PATCH 0151/1292] replaced int32_t size by ssize_t (type trait trick)

---
 container/FixedMap.h                         |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  2 +-
 datapool/DataSet.cpp                         |  2 +-
 datapool/DataSet.h                           |  2 +-
 datapool/PIDReader.h                         |  2 +-
 datapool/PoolRawAccess.cpp                   |  2 +-
 datapool/PoolRawAccess.h                     |  2 +-
 datapool/PoolRawAccessHelper.cpp             |  6 +++---
 datapool/PoolRawAccessHelper.h               |  8 +++++---
 datapool/PoolVariable.h                      |  2 +-
 datapool/PoolVector.h                        |  2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  2 +-
 events/eventmatching/EventRangeMatcherBase.h |  2 +-
 globalfunctions/Type.cpp                     |  3 +--
 globalfunctions/Type.h                       |  2 +-
 globalfunctions/matching/MatchTree.h         |  2 +-
 globalfunctions/matching/RangeMatcher.h      |  2 +-
 parameters/ParameterWrapper.cpp              | 10 +++++-----
 parameters/ParameterWrapper.h                |  8 ++++----
 power/Fuse.cpp                               |  2 +-
 power/Fuse.h                                 |  4 ++--
 power/PowerComponent.cpp                     |  4 ++--
 power/PowerComponent.h                       |  2 +-
 serialize/SerialArrayListAdapter.h           |  6 +++---
 serialize/SerialBufferAdapter.cpp            |  2 +-
 serialize/SerialBufferAdapter.h              |  2 +-
 serialize/SerialFixedArrayListAdapter.h      |  5 +++--
 serialize/SerialLinkedListAdapter.h          |  4 ++--
 serialize/SerializeAdapter.h                 |  8 ++++----
 serialize/SerializeElement.h                 |  3 ++-
 serialize/SerializeIF.h                      |  4 +++-
 subsystem/Subsystem.cpp                      |  4 ++--
 subsystem/modes/ModeDefinitions.h            |  2 +-
 thermal/ThermalComponent.cpp                 |  4 ++--
 thermal/ThermalComponent.h                   |  2 +-
 tmstorage/TmStorePackets.h                   |  4 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       |  2 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  2 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  2 +-
 41 files changed, 70 insertions(+), 65 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 23a79aef..7f3d28f7 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -201,7 +201,7 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
 				buffer, size, bigEndian);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index aa194b61..7139a0d8 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -80,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index c9631b9c..45d3de53 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index 90baf063..eabb4b8c 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -136,7 +136,7 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 9bcdb892..888d45e6 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -126,7 +126,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 private:
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index d6b10b65..26a9e2a8 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -136,7 +136,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 16d6562e..b5f94c8c 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -197,7 +197,7 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	*size -= typeSize;
 	if (*size >= 0) {
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 73a609ff..955c640b 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -127,7 +127,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 protected:
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 7ea3576f..cac6e506 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
-	int32_t remainingParametersSize = numberOfParameters * 4;
+	ssize_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
 				&remainingParametersSize, false);
@@ -44,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
-	int32_t remainingParametersSize = numberOfParameters * 4;
+	ssize_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
@@ -68,7 +68,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-		int32_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
+		ssize_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 4a4a1fab..89974ea4 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -85,10 +85,12 @@ private:
 	 * @return
 	 */
 	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-				int32_t * remainingParameters, bool withValidMask = false, uint8_t * validityMask = NULL);
+				ssize_t * remainingParameters, bool withValidMask = false,
+				uint8_t * validityMask = nullptr);
 
-	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
-				bool withValidMask = false, uint8_t * validityMask = NULL);
+	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);
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 351ffec3..d32cdf22 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -203,7 +203,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index a21f31d2..3e82a721 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -215,7 +215,7 @@ public:
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		uint16_t i;
 		ReturnValue_t result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 344a1dc1..4987c7fb 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -31,7 +31,7 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1582ff48..fce74814 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 private:
 	object_id_t objectId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 0f096b9c..8dea3e10 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -18,7 +18,7 @@ public:
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 0d6d7c1d..ea2ad896 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,4 +1,3 @@
-#include <framework/serialize/SerializeAdapter.h>
 #include <framework/globalfunctions/Type.h>
 #include <framework/serialize/SerializeAdapter.h>
 
@@ -86,7 +85,7 @@ size_t Type::getSerializedSize() const {
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, ssize_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index e6413d2d..244091f7 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -44,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 private:
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 3b8e1942..498fe860 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -115,7 +115,7 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c93e7919..c0980255 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -44,7 +44,7 @@ public:
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index f359a745..1420c076 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t *) from;
-	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+	ssize_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -137,12 +137,12 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	return deSerialize(buffer, size, bigEndian, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		ssize_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,8 +153,8 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
-		const uint8_t **remainingStream, int32_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
+		const uint8_t **remainingStream, ssize_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 6681f7c4..6f8f6fc9 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -30,10 +30,10 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
@@ -111,8 +111,8 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
-	ReturnValue_t set(const uint8_t *stream, int32_t streamSize,
-			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, ssize_t streamSize,
+			const uint8_t **remainingStream = NULL, ssize_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 04adac80..6a4e6caf 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, ssize_t* size,
 bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
diff --git a/power/Fuse.h b/power/Fuse.h
index a9542167..b3c9547a 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -52,8 +52,8 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+				bool bigEndian);
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index b7158e62..77e60d0e 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -56,8 +56,8 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 97341667..1410e69d 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -24,7 +24,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5274c488..21a669c2 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -56,13 +56,13 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
 				buffer, size, bigEndian);
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 83fda418..618e8a15 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -63,7 +63,7 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 }
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		ssize_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(m_serialize_length){
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 0c3d4dd6..ff2083de 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian);
 
 	uint8_t * getBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 573d3314..8bcbf09e 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -40,9 +40,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this, buffer, size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+				buffer, size, bigEndian);
 	}
 
 	void swapArrayListEndianness() {
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 0865faa5..80dbcaf1 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -112,13 +112,13 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, int32_t* size, bool bigEndian) {
+			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
 			result = element->value->deSerialize(buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 7654eb0d..81a3730f 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -88,7 +88,7 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		T tmp;
 		*size -= sizeof(T);
@@ -127,7 +127,7 @@ public:
 		return object->getSerializedSize();
 	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return object->deSerialize(buffer, size, bigEndian);
 	}
@@ -147,7 +147,7 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
+			ssize_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
@@ -169,7 +169,7 @@ public:
 	}
 	template<typename T>
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
+			ssize_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index fe9d5d71..e2da5c14 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -41,10 +41,11 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
+
 	operator T() {
 		return entry;
 	}
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index a9f40a08..d547daac 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -3,7 +3,9 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <type_traits>
 
+typedef std::make_signed<std::size_t>::type ssize_t;
 /**
  * @defgroup serialize Serialization
  * Contains serialisation services.
@@ -42,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) = 0;
 
 };
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 1c4bee33..e4a682ba 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -168,7 +168,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			int32_t size = sizeRead;
+			ssize_t size = sizeRead;
 			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
@@ -193,7 +193,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			int32_t size = sizeRead;
+			ssize_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 406f9583..4c0c4a26 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -53,7 +53,7 @@ public:
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 15a2bbc9..737ffd2e 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -40,11 +40,11 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, ssize_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	int32_t readSize = size;
+	ssize_t readSize = size;
 	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
 	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 4e32e97c..37ed01c0 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -53,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, ssize_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b6c63b91..4e7bc94b 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -48,7 +48,7 @@ public:
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
 				buffer, size, bigEndian);
@@ -257,7 +257,7 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 37b91bd3..1ee44476 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -30,7 +30,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
 	}
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 31502053..b69ac7a5 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -30,7 +30,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
 	}
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 8b872876..9c93af64 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -28,7 +28,7 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
 	}

From e791f44c41525bc742c9027bbeb08a530cd5a424 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 5 Apr 2020 23:03:32 +0200
Subject: [PATCH 0152/1292] copy ctor and assgnment op forbidden

for serial linked lists
---
 returnvalues/HasReturnvaluesIF.h    |  2 +-
 serialize/SerialLinkedListAdapter.h | 10 ++++++++++
 serialize/SerializeIF.h             |  3 +++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index b8b72a9f..d84fc757 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,9 +1,9 @@
 #ifndef HASRETURNVALUESIF_H_
 #define HASRETURNVALUESIF_H_
 
-#include <stdint.h>
 #include <framework/returnvalues/FwClassIds.h>
 #include <config/returnvalues/classIds.h>
+#include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
 typedef uint16_t ReturnValue_t;
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 80dbcaf1..b5c06a16 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -41,6 +41,16 @@
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
 public:
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
+
 	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index d547daac..da401b2f 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -5,7 +5,10 @@
 #include <cstddef>
 #include <type_traits>
 
+#ifndef ssize_t
 typedef std::make_signed<std::size_t>::type ssize_t;
+#endif
+
 /**
  * @defgroup serialize Serialization
  * Contains serialisation services.

From 3654c7bf8162cd176509db6d83241f077bdfb929 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 11:15:44 +0200
Subject: [PATCH 0153/1292] some form stuff

---
 datapool/PoolEntry.cpp              | 6 ++++--
 osal/FreeRTOS/FixedTimeslotTask.cpp | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 898d226e..e5d4ffde 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -2,7 +2,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
+		uint8_t set_valid ) : length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		memset(this->address, 0, this->getByteSize());
@@ -13,7 +14,8 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) :
+		length(set_length), valid(set_valid) {
 	this->address = new T[this->length];
 	if (initValue != NULL) {
 		memcpy(this->address, initValue, this->getByteSize() );
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 7bfee7e6..b1c97420 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -67,7 +67,8 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+	error << "Component " << std::hex << componentId
+		  << " not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

From 78aad91aab99ff6123d8575300613dd14a79b81e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 12:38:39 +0200
Subject: [PATCH 0154/1292] PSB subservice passed to handleRequest

---
 tmtcservices/PusServiceBase.cpp | 2 +-
 tmtcservices/PusServiceBase.h   | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 6e105325..a0ab1768 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
 			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
 
-			ReturnValue_t return_code = this->handleRequest();
+			ReturnValue_t return_code = this->handleRequest(currentPacket.getSubService());
 			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
 			if (return_code == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 6c8c5f61..de16ebe2 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -30,7 +30,10 @@ void setStaticFrameworkObjectIds();
  * All PUS Services are System Objects, so an Object ID needs to be specified on construction.
  * \ingroup pus_services
  */
-class PusServiceBase : public ExecutableObjectIF, public AcceptsTelecommandsIF, public SystemObject, public HasReturnvaluesIF {
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -63,7 +66,7 @@ public:
 	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
-	virtual ReturnValue_t handleRequest() = 0;
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
 	/**
 	 * In performService, implementations can handle periodic, non-TC-triggered activities.
 	 * The performService method is always called.

From aaabbe8aef2a759d1928b22c6b3acfca2fd9980d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 13:59:57 +0200
Subject: [PATCH 0155/1292] DHB fix

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9f23dd7f..5fb5a9e5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1149,9 +1149,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if(size == 0) {
-		return NO_COMMAND_DATA;
-	}
 
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {

From c88c6c2a45482d19f51ec0548ffe50e5b1203a82 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Apr 2020 19:51:45 +0200
Subject: [PATCH 0156/1292] binary semaphore info printout added

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 631e4742..546c5a46 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -86,6 +86,7 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+// Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
@@ -95,6 +96,10 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch
+		    // TODO: I don't know if this will ever happen but if it does,
+		    // I want to to know in case this causes issues. If it doesn't
+		    // we should remove this.
+		    TRACE_INFO("Binary Semaphore: Higher priority task unblocked!");
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;

From 30ed08005fd07cd894a49dee5123e028d1fbeed6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Apr 2020 22:16:43 +0200
Subject: [PATCH 0157/1292] reverted some naming changes

---
 datapool/DataPool.h               |  3 +-
 serialize/SerialBufferAdapter.cpp | 56 +++++++++++++++----------------
 serialize/SerialBufferAdapter.h   |  6 ++--
 3 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/datapool/DataPool.h b/datapool/DataPool.h
index a9af8af0..857bc3b2 100644
--- a/datapool/DataPool.h
+++ b/datapool/DataPool.h
@@ -42,7 +42,8 @@ private:
 	/**
 	 * \brief	This is the actual data pool itself.
 	 * \details	It is represented by a map
-	 * 			with the data pool id as index and a pointer to a single PoolEntry as value.
+	 * 			with the data pool id as index and a pointer to a single
+	 * 			PoolEntry as value.
 	 */
 	std::map<uint32_t, PoolEntryIF*> data_pool;
 public:
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 618e8a15..f97d0d58 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -5,19 +5,19 @@
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
 		count_t bufferLength, bool serializeLength) :
-		m_serialize_length(serializeLength),
-		m_const_buffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
-		m_buffer_length(bufferLength) {
+		serializeLength(serializeLength),
+		constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
+		bufferLength(bufferLength) {
 
 }
 
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
 		bool serializeLength) :
-		m_serialize_length(serializeLength), m_buffer_length(bufferLength) {
+		serializeLength(serializeLength), bufferLength(bufferLength) {
 	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
 	m_buffer = member_buffer;
-	m_const_buffer = member_buffer;
+	constBuffer = member_buffer;
 }
 
 
@@ -28,37 +28,37 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
-	uint32_t serializedLength = m_buffer_length;
-	if (m_serialize_length) {
+	uint32_t serializedLength = bufferLength;
+	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
-				&m_buffer_length);
+				&bufferLength);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
-		if (m_serialize_length) {
-			AutoSerializeAdapter::serialize(&m_buffer_length, buffer, size,
+		if (serializeLength) {
+			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
 					max_size, bigEndian);
 		}
-		if (m_const_buffer != nullptr) {
-			memcpy(*buffer, m_const_buffer, m_buffer_length);
+		if (constBuffer != nullptr) {
+			memcpy(*buffer, constBuffer, bufferLength);
 		} else if (m_buffer != nullptr) {
-			memcpy(*buffer, m_buffer, m_buffer_length);
+			memcpy(*buffer, m_buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += m_buffer_length;
-		(*buffer) += m_buffer_length;
+		*size += bufferLength;
+		(*buffer) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
 
 template<typename count_t>
 size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (m_serialize_length) {
-		return m_buffer_length + AutoSerializeAdapter::getSerializedSize(&m_buffer_length);
+	if (serializeLength) {
+		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
-		return m_buffer_length;
+		return bufferLength;
 	}
 }
 template<typename count_t>
@@ -66,15 +66,15 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		ssize_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
-		if(m_serialize_length){
+		if(serializeLength){
 			// Suggestion (would require removing rest of the block inside this if clause !):
 			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
 			//if (result != HasReturnvaluesIF::RETURN_OK) {
 			//	return result;
 			//}
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
-					&m_buffer_length);
-			if((*size - m_buffer_length - serializedSize) >= 0){
+					&bufferLength);
+			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}else{
@@ -82,10 +82,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - m_buffer_length >= 0) {
-			*size -= m_buffer_length;
-			memcpy(m_buffer, *buffer, m_buffer_length);
-			(*buffer) += m_buffer_length;
+		if (*size - bufferLength >= 0) {
+			*size -= bufferLength;
+			memcpy(m_buffer, *buffer, bufferLength);
+			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
 			return STREAM_TOO_SHORT;
@@ -106,17 +106,17 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(m_const_buffer == nullptr) {
+	if(constBuffer == nullptr) {
 		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
 		return nullptr;
 	}
-	return m_const_buffer;
+	return constBuffer;
 }
 
 template<typename count_t>
 void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
 	m_buffer = static_cast<uint8_t *>(buffer);
-	m_buffer_length = buffer_length;
+	bufferLength = buffer_length;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index ff2083de..cf3ae07e 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -52,10 +52,10 @@ public:
 	const uint8_t * getConstBuffer();
 	void setBuffer(void* buffer_, count_t bufferLength_);
 private:
-	bool m_serialize_length = false;
-	const uint8_t *m_const_buffer = nullptr;
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
 	uint8_t *m_buffer = nullptr;
-	count_t m_buffer_length = 0;
+	count_t bufferLength = 0;
 };
 
 

From e0e1e64a092b9a06570149c2c694102230af182c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:08:14 +0200
Subject: [PATCH 0158/1292] various changes, stopwatch

Semaphore: Some bugfixes, some constructors added
Stopwatch: First implementation, can measure in ms(double) and
ms(normal)
---
 datalinklayer/Clcw.cpp                    |  3 +-
 datapool/PoolEntry.cpp                    |  3 +-
 health/HealthHelper.cpp                   |  5 +-
 osal/FreeRTOS/BinarySemaphore.cpp         | 68 ++++++++++++++++++-----
 osal/FreeRTOS/BinarySemaphore.h           | 51 +++++++++++++----
 osal/FreeRTOS/Clock.cpp                   |  4 +-
 osal/FreeRTOS/Timekeeper.cpp              | 26 +++++----
 osal/FreeRTOS/Timekeeper.h                |  9 ++-
 serviceinterface/ServiceInterfaceStream.h |  3 +-
 timemanager/CCSDSTime.cpp                 |  3 +-
 timemanager/Clock.h                       |  3 +-
 timemanager/Stopwatch.cpp                 | 62 +++++++++++++++++++++
 timemanager/Stopwatch.h                   | 52 +++++++++++++++++
 13 files changed, 247 insertions(+), 45 deletions(-)
 create mode 100644 timemanager/Stopwatch.cpp
 create mode 100644 timemanager/Stopwatch.h

diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 448d4d7b..0ffa7abf 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,8 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
-	debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+	debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole()
+	        << std::dec << std::endl;
 }
 
 void Clcw::setWhole(uint32_t rawClcw) {
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index e5d4ffde..655b467a 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -60,7 +60,8 @@ uint8_t PoolEntry<T>::getValid() {
 template <typename T>
 void PoolEntry<T>::print() {
 	for (uint8_t size = 0; size < this->length; size++ ) {
-		debug << "| " << std::hex << (double)this->address[size] << (this->valid? " (valid) " : " (invalid) ");
+		debug << "| " << std::hex << (double)this->address[size]
+		      << (this->valid? " (valid) " : " (invalid) ");
 	}
 	debug << std::dec << std::endl;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 8fc413ed..931645d1 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -89,8 +89,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
 	}
 	if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
 			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		debug
-				<< "HealthHelper::handleHealthCommand: sending health reply failed."
-				<< std::endl;
+		debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
 	}
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 546c5a46..05c97ae2 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -21,26 +21,68 @@ BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
+// This copy ctor is important as it prevents the assignment to a ressource
+// (other.handle) variable which is later deleted!
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+    if(this != &s) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
 ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if(timeoutMs != 0) {
-		timeout = pdMS_TO_TICKS(timeoutMs);
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeout);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_FOUND;
+	}
+	else {
+	    return SEMAPHORE_TIMEOUT;
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NOT_FOUND;
+		return SEMAPHORE_NULLPOINTER;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
@@ -53,7 +95,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(TickType_t timeout
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
@@ -69,7 +111,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
@@ -86,11 +128,12 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
@@ -99,11 +142,10 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		    // TODO: I don't know if this will ever happen but if it does,
 		    // I want to to know in case this causes issues. If it doesn't
 		    // we should remove this.
-		    TRACE_INFO("Binary Semaphore: Higher priority task unblocked!");
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SEMAPHORE_NOT_OWNED;
 	}
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index a809f0bb..54126692 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -20,22 +20,51 @@ class BinarySemaphore: public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
-	/** Semaphore object not found */
-	static const ReturnValue_t SEMAPHORE_NOT_FOUND = MAKE_RETURN_CODE(1);
-	/** Semaphore timeout */
-	static const ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(2);
+	//! No block time, poll the semaphore. Can also be used as tick type.
+	//! Can be passed as tick type and ms value.
+	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
+	static constexpr TickType_t NO_BLOCK_TICKS = 0;
+	//! No block time, poll the semaphore.
+	//! Can be passed as tick type and ms value.
+	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
+	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
+
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	/** The current semaphore can not be given, because it is not owned */
-	static const ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(3);
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
 	/**
 	 * Create a binary semaphore
 	 */
 	BinarySemaphore();
 
+	/**
+	 * Copy ctor
+	 * @param
+	 */
+	BinarySemaphore(const BinarySemaphore&);
+
+	/**
+	 * Copy assignment
+	 */
+	BinarySemaphore& operator=(const BinarySemaphore&);
+
+	/**
+	 * Move constructor
+	 */
+	BinarySemaphore (BinarySemaphore &&);
+
+	/**
+	 * Move assignment
+	 */
+	BinarySemaphore & operator=(BinarySemaphore &&);
+
 	/**
 	 * Delete the binary semaphore to prevent a memory leak
 	 */
-	~BinarySemaphore();
+	virtual ~BinarySemaphore();
 
 	/**
 	 * Take the binary semaphore.
@@ -46,7 +75,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs);
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -54,7 +84,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks);
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
@@ -96,8 +127,4 @@ private:
 	SemaphoreHandle_t handle;
 };
 
-
-
-
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index cffc2125..5e597f25 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -3,8 +3,11 @@
 #include <stdlib.h>
 #include "Timekeeper.h"
 
+extern "C" {
 #include <FreeRTOS.h>
 #include <task.h>
+}
+
 
 //TODO sanitize input?
 //TODO much of this code can be reused for tick-only systems
@@ -56,7 +59,6 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 
 timeval Clock::getUptime() {
 	TickType_t ticksSinceStart = xTaskGetTickCount();
-
 	return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 81f7f997..949e1df3 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,20 +1,24 @@
-#include "Timekeeper.h"
-#include <FreeRTOSConfig.h>
+/**
+ * @file Timekeeper.cpp
+ * @date
+ */
 
-Timekeeper::Timekeeper() :
-		offset( { 0, 0 }) {
-	// TODO Auto-generated constructor stub
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
+extern "C" {
+#include <task.h>
 }
 
-Timekeeper * Timekeeper::myinstance = NULL;
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 }) {}
 
 const timeval& Timekeeper::getOffset() const {
 	return offset;
 }
 
 Timekeeper* Timekeeper::instance() {
-	if (myinstance == NULL) {
+	if (myinstance == nullptr) {
 		myinstance = new Timekeeper();
 	}
 	return myinstance;
@@ -24,9 +28,7 @@ void Timekeeper::setOffset(const timeval& offset) {
 	this->offset = offset;
 }
 
-Timekeeper::~Timekeeper() {
-	// TODO Auto-generated destructor stub
-}
+Timekeeper::~Timekeeper() {}
 
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 	timeval uptime;
@@ -40,3 +42,7 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 
 	return uptime;
 }
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 2ba3e4a9..05f0f701 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -2,8 +2,10 @@
 #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 
 #include <framework/timemanager/Clock.h>
-
+extern "C" {
 #include <FreeRTOS.h>
+}
+
 
 /**
  * A Class to basically store the time difference between uptime and UTC
@@ -25,6 +27,11 @@ public:
 	virtual ~Timekeeper();
 
 	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
 
 	const timeval& getOffset() const;
 	void setOffset(const timeval& offset);
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 32bc263e..44cf1168 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,7 +7,8 @@
 #include <sstream>
 #include <cstdio>
 
-//Unfortunately, there must be a forward declaration of log_fe (MUST be defined in main), to let the system know where to write to.
+//Unfortunately, there must be a forward declaration of log_fe
+// (MUST be defined in main), to let the system know where to write to.
 extern std::ostream debug;
 extern std::ostream info;
 extern std::ostream warning;
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 29aafb68..47cab911 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -196,7 +196,8 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		to->usecond = (second - floor(second)) * 1000000;
 		return RETURN_OK;
 	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement C99 I/O
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
 #else
 	uint16_t year;
 	uint8_t month;
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index af657247..afa9963c 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,7 +7,8 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
-
+typedef uint32_t ms_normal_t;
+typedef double ms_double_t;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
new file mode 100644
index 00000000..37133def
--- /dev/null
+++ b/timemanager/Stopwatch.cpp
@@ -0,0 +1,62 @@
+/**
+ * @file Stopwatch.cpp
+ *
+ * @date 08.04.2020
+ */
+
+#include <framework/timemanager/Stopwatch.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
+        displayOnDestruction(displayOnDestruction) {
+    Clock::getUptime(&startTime);
+    stopwatchState = StopwatchState::STARTED;
+}
+
+void Stopwatch::start() {
+    startTime = Clock::getUptime();
+}
+
+ms_normal_t Stopwatch::stop() {
+    elapsedTime = Clock::getUptime() - startTime;
+    int32_t elapsedTimeMs = elapsedTime.tv_sec * 1000 +
+            elapsedTime.tv_usec/1000;
+    if(elapsedTimeMs < 0) {
+        error << "Stopwatch: Measured time negative!";
+        return INVALID_TIME;
+    }
+    else {
+        return static_cast<ms_normal_t>(elapsedTimeMs);
+    }
+}
+
+ms_double_t Stopwatch::stopPrecise() {
+    elapsedTime = Clock::getUptime() - startTime;
+    return timevalOperations::toDouble(elapsedTime) * 1000.0;
+}
+
+
+void Stopwatch::display() {
+    if(displayMode == DisplayMode::MS_FLOAT) {
+        info << "Stopwatch: Operation took " <<
+                elapsedTimeMs << " milliseconds" << std::endl;
+    }
+    else {
+        timeval elapsedTime = stopTime - startTime;
+        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec * 1000 << " milliseconds";
+    }
+}
+
+
+Stopwatch::~Stopwatch() {
+    if(displayOnDestruction) {
+        stopInternal();
+        display();
+    }
+}
+
+void Stopwatch::stopInternal() {
+    elapsedTime = Clock::getUptime() - startTime;
+    elapsedTimeMs = timevalOperations::toDouble(elapsedTime) * 1000.0;
+}
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
new file mode 100644
index 00000000..6f58553f
--- /dev/null
+++ b/timemanager/Stopwatch.h
@@ -0,0 +1,52 @@
+/**
+ * @file Stopwatch.h
+ *
+ * @date 08.04.2020
+ */
+
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include <framework/timemanager/Clock.h>
+
+class Stopwatch {
+    enum class DisplayMode {
+        MS_FLOAT,
+        MS
+    };
+
+    Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
+            DisplayMode::MS_FLOAT);
+    virtual~ Stopwatch();
+
+    void start();
+
+    ms_normal_t stop();
+    ms_double_t stopPrecise();
+
+    void display();
+private:
+    static const ms_normal_t INVALID_TIME = 0xFFFFFFFF;
+
+    timeval startTime {0, 0};
+    timeval stopTime {0, 0};
+    timeval elapsedTime {0, 0};
+    double elapsedTimeMs = 0;
+    //ms_normal_t elapsedTimeMs {0};
+
+    bool displayOnDestruction = true;
+
+    enum class StopwatchState {
+        IDLE,
+        STARTED,
+    };
+
+    StopwatchState stopwatchState = StopwatchState::IDLE;
+    DisplayMode displayMode = DisplayMode::MS_FLOAT;
+
+    void stopInternal();
+};
+
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */

From 3af241b9c48f1c0f5685435f198d27e4333caa99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:27:18 +0200
Subject: [PATCH 0159/1292] stopwatch more lightweight now

---
 timemanager/Stopwatch.cpp | 25 ++++++++-----------------
 timemanager/Stopwatch.h   | 27 +++++++++++++--------------
 2 files changed, 21 insertions(+), 31 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 37133def..fde77540 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -10,7 +10,6 @@
 Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
         displayOnDestruction(displayOnDestruction) {
     Clock::getUptime(&startTime);
-    stopwatchState = StopwatchState::STARTED;
 }
 
 void Stopwatch::start() {
@@ -18,31 +17,22 @@ void Stopwatch::start() {
 }
 
 ms_normal_t Stopwatch::stop() {
-    elapsedTime = Clock::getUptime() - startTime;
-    int32_t elapsedTimeMs = elapsedTime.tv_sec * 1000 +
-            elapsedTime.tv_usec/1000;
-    if(elapsedTimeMs < 0) {
-        error << "Stopwatch: Measured time negative!";
-        return INVALID_TIME;
-    }
-    else {
-        return static_cast<ms_normal_t>(elapsedTimeMs);
-    }
+    stopInternal();
+    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
 ms_double_t Stopwatch::stopPrecise() {
-    elapsedTime = Clock::getUptime() - startTime;
-    return timevalOperations::toDouble(elapsedTime) * 1000.0;
+    stopInternal();
+    return elapsedTimeMsDouble;
 }
 
 
 void Stopwatch::display() {
-    if(displayMode == DisplayMode::MS_FLOAT) {
+    if(displayMode == DisplayMode::MS_DOUBLE) {
         info << "Stopwatch: Operation took " <<
-                elapsedTimeMs << " milliseconds" << std::endl;
+                elapsedTimeMsDouble << " milliseconds" << std::endl;
     }
     else {
-        timeval elapsedTime = stopTime - startTime;
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds";
     }
@@ -56,7 +46,8 @@ Stopwatch::~Stopwatch() {
     }
 }
 
+
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
-    elapsedTimeMs = timevalOperations::toDouble(elapsedTime) * 1000.0;
+    elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 6f58553f..7760fda9 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -8,14 +8,23 @@
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
 
+/**
+ * @brief Simple Stopwatch implementation to measure elapsed time
+ * @details
+ * This class can be used to measure elapsed times. It also displays elapsed
+ * times automatically on destruction if not explicitely deactivated in the
+ * constructor. The default time format is the elapsed time in miliseconds
+ * as a float.
+ * This class caches the value
+ */
 class Stopwatch {
     enum class DisplayMode {
-        MS_FLOAT,
+        MS_DOUBLE,
         MS
     };
 
     Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
-            DisplayMode::MS_FLOAT);
+            DisplayMode::MS_DOUBLE);
     virtual~ Stopwatch();
 
     void start();
@@ -25,23 +34,13 @@ class Stopwatch {
 
     void display();
 private:
-    static const ms_normal_t INVALID_TIME = 0xFFFFFFFF;
 
     timeval startTime {0, 0};
-    timeval stopTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMs = 0;
-    //ms_normal_t elapsedTimeMs {0};
+    double elapsedTimeMsDouble = 0;
 
     bool displayOnDestruction = true;
-
-    enum class StopwatchState {
-        IDLE,
-        STARTED,
-    };
-
-    StopwatchState stopwatchState = StopwatchState::IDLE;
-    DisplayMode displayMode = DisplayMode::MS_FLOAT;
+    DisplayMode displayMode = DisplayMode::MS_DOUBLE;
 
     void stopInternal();
 };

From 3dbf35338561897c356a1f949ed2a74ec7e9f311 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 18:33:38 +0200
Subject: [PATCH 0160/1292] some more refactoring for stopwatch

---
 timemanager/Stopwatch.cpp | 13 +++++++++++--
 timemanager/Stopwatch.h   | 35 +++++++++++++++++++++++++++--------
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index fde77540..7b08c120 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -7,8 +7,10 @@
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-Stopwatch::Stopwatch(bool displayOnDestruction, DisplayMode displayMode):
+Stopwatch::Stopwatch(bool displayOnDestruction,
+        StopwatchDisplayMode displayMode):
         displayOnDestruction(displayOnDestruction) {
+    // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
 
@@ -28,7 +30,7 @@ ms_double_t Stopwatch::stopPrecise() {
 
 
 void Stopwatch::display() {
-    if(displayMode == DisplayMode::MS_DOUBLE) {
+    if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
         info << "Stopwatch: Operation took " <<
                 elapsedTimeMsDouble << " milliseconds" << std::endl;
     }
@@ -46,6 +48,13 @@ Stopwatch::~Stopwatch() {
     }
 }
 
+void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
+    this->displayMode = displayMode;
+}
+
+StopwatchDisplayMode Stopwatch::getDisplayMode() const {
+    return displayMode;
+}
 
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 7760fda9..b136019f 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -8,6 +8,11 @@
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
 
+enum class StopwatchDisplayMode {
+    MS_DOUBLE,
+    MS
+};
+
 /**
  * @brief Simple Stopwatch implementation to measure elapsed time
  * @details
@@ -15,24 +20,38 @@
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
  * as a float.
- * This class caches the value
  */
 class Stopwatch {
-    enum class DisplayMode {
-        MS_DOUBLE,
-        MS
-    };
 
-    Stopwatch(bool displayOnDestruction = true, DisplayMode displayMode =
-            DisplayMode::MS_DOUBLE);
+    Stopwatch(bool displayOnDestruction = true,
+            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE);
     virtual~ Stopwatch();
 
+    /**
+     * Caches the start time
+     */
     void start();
 
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (rounded)
+     */
     ms_normal_t stop();
+
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (doulbe precision)
+     */
     ms_double_t stopPrecise();
 
+    /**
+     * Displays the elapsed times on the osstream, depending on internal display
+     * mode.
+     */
     void display();
+
+    StopwatchDisplayMode getDisplayMode() const;
+    void setDisplayMode(StopwatchDisplayMode displayMode);
 private:
 
     timeval startTime {0, 0};
@@ -40,7 +59,7 @@ private:
     double elapsedTimeMsDouble = 0;
 
     bool displayOnDestruction = true;
-    DisplayMode displayMode = DisplayMode::MS_DOUBLE;
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
 
     void stopInternal();
 };

From da9bb97b23f2519137674a8b352e7b93592f4ef4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:05:21 +0200
Subject: [PATCH 0161/1292] added precision for double output

---
 timemanager/Stopwatch.cpp | 12 ++++++++----
 timemanager/Stopwatch.h   | 18 ++++++++++++++----
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 7b08c120..1ccebc57 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -6,10 +6,11 @@
 
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode):
-        displayOnDestruction(displayOnDestruction) {
+        StopwatchDisplayMode displayMode, uint8_t precision):
+        displayOnDestruction(displayOnDestruction), outputPrecision(precision) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
@@ -31,8 +32,9 @@ ms_double_t Stopwatch::stopPrecise() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
-        info << "Stopwatch: Operation took " <<
-                elapsedTimeMsDouble << " milliseconds" << std::endl;
+        info << "Stopwatch: Operation took "
+             << std::setprecision(outputPrecision) << elapsedTimeMsDouble
+             << " milliseconds" << std::endl;
     }
     else {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
@@ -56,6 +58,8 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
     return displayMode;
 }
 
+
+
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
     elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index b136019f..1e438272 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -22,9 +22,19 @@ enum class StopwatchDisplayMode {
  * as a float.
  */
 class Stopwatch {
-
+public:
+    /**
+     * Default constructor. Call "Stopwatch stopwatch" without brackets if
+     * no parameters are required!
+     * @param displayOnDestruction If set to true, displays measured time on
+     *        object destruction
+     * @param displayMode Display format is either MS rounded or MS as double
+     *        format
+     * @param outputPrecision If using double format, specify precision here.
+     */
     Stopwatch(bool displayOnDestruction = true,
-            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE);
+            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE,
+            uint8_t outputPrecision = 4);
     virtual~ Stopwatch();
 
     /**
@@ -53,12 +63,12 @@ class Stopwatch {
     StopwatchDisplayMode getDisplayMode() const;
     void setDisplayMode(StopwatchDisplayMode displayMode);
 private:
-
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMsDouble = 0;
+    double elapsedTimeMsDouble {0.0};
 
     bool displayOnDestruction = true;
+    uint8_t outputPrecision = 4;
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
 
     void stopInternal();

From 5b0f80509f7f8dec258d333c26766dfdf8336ccc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:24:24 +0200
Subject: [PATCH 0162/1292] usec replaced by seconds

---
 timemanager/Clock.h       |  4 ++--
 timemanager/Stopwatch.cpp | 27 +++++++++++----------------
 timemanager/Stopwatch.h   | 22 +++++++---------------
 3 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index afa9963c..5f18de3e 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,8 +7,8 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
-typedef uint32_t ms_normal_t;
-typedef double ms_double_t;
+typedef uint32_t millis_t;
+typedef float seconds_t;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 1ccebc57..40b711d9 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,8 +9,8 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode, uint8_t precision):
-        displayOnDestruction(displayOnDestruction), outputPrecision(precision) {
+        StopwatchDisplayMode displayMode):
+        displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
 }
@@ -19,30 +19,28 @@ void Stopwatch::start() {
     startTime = Clock::getUptime();
 }
 
-ms_normal_t Stopwatch::stop() {
+millis_t Stopwatch::stop() {
     stopInternal();
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-ms_double_t Stopwatch::stopPrecise() {
+seconds_t Stopwatch::stopSeconds() {
     stopInternal();
-    return elapsedTimeMsDouble;
+    return timevalOperations::toDouble(elapsedTime);
 }
 
-
 void Stopwatch::display() {
-    if(displayMode == StopwatchDisplayMode::MS_DOUBLE) {
-        info << "Stopwatch: Operation took "
-             << std::setprecision(outputPrecision) << elapsedTimeMsDouble
-             << " milliseconds" << std::endl;
-    }
-    else {
+    if(displayMode == StopwatchDisplayMode::MILLIS) {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds";
     }
+    else if(displayMode == StopwatchDisplayMode::SECONDS) {
+        info <<"Stopwatch: Operation took "  << std::setprecision(4)
+             << std::fixed << timevalOperations::toDouble(elapsedTime)
+             << " seconds";
+    }
 }
 
-
 Stopwatch::~Stopwatch() {
     if(displayOnDestruction) {
         stopInternal();
@@ -58,9 +56,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
     return displayMode;
 }
 
-
-
 void Stopwatch::stopInternal() {
     elapsedTime = Clock::getUptime() - startTime;
-    elapsedTimeMsDouble = timevalOperations::toDouble(elapsedTime) * 1000.0;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 1e438272..aeb61265 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -9,8 +9,8 @@
 #include <framework/timemanager/Clock.h>
 
 enum class StopwatchDisplayMode {
-    MS_DOUBLE,
-    MS
+    MILLIS,
+    SECONDS
 };
 
 /**
@@ -32,9 +32,8 @@ public:
      *        format
      * @param outputPrecision If using double format, specify precision here.
      */
-    Stopwatch(bool displayOnDestruction = true,
-            StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE,
-            uint8_t outputPrecision = 4);
+    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
+              = StopwatchDisplayMode::MILLIS);
     virtual~ Stopwatch();
 
     /**
@@ -46,13 +45,8 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    ms_normal_t stop();
-
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in milliseconds (doulbe precision)
-     */
-    ms_double_t stopPrecise();
+    millis_t stop();
+    seconds_t stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display
@@ -65,11 +59,9 @@ public:
 private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
-    double elapsedTimeMsDouble {0.0};
 
     bool displayOnDestruction = true;
-    uint8_t outputPrecision = 4;
-    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MS_DOUBLE;
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
 
     void stopInternal();
 };

From 640cc1ddec6fa6e53c8dca212b06b61604e5a6da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Apr 2020 19:30:39 +0200
Subject: [PATCH 0163/1292] some more bugfixes

---
 timemanager/Stopwatch.cpp | 8 ++++----
 timemanager/Stopwatch.h   | 3 +--
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 40b711d9..6c50f0de 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,7 +9,7 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode):
+        StopwatchDisplayMode displayMode): displayMode(displayMode),
         displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
     Clock::getUptime(&startTime);
@@ -32,12 +32,12 @@ seconds_t Stopwatch::stopSeconds() {
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
         info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec * 1000 << " milliseconds";
+                elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        info <<"Stopwatch: Operation took "  << std::setprecision(4)
+        info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
-             << " seconds";
+             << " seconds" << std::endl;
     }
 }
 
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index aeb61265..786a9d57 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -60,9 +60,8 @@ private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
 
-    bool displayOnDestruction = true;
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-
+    bool displayOnDestruction = true;
     void stopInternal();
 };
 

From 8a8761ea88e361ff610dd18ba22e59f3f5a9140b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Apr 2020 17:56:48 +0200
Subject: [PATCH 0164/1292] stopwatch bugfix

---
 devicehandlers/CookieIF.h              |  5 +++--
 devicehandlers/DeviceCommunicationIF.h | 24 ++++++++++++------------
 osal/FreeRTOS/BinarySemaphore.h        | 26 +++++++++++---------------
 serialize/SerializeDoc.h               | 16 ++++++++++++++++
 timemanager/Stopwatch.cpp              |  2 +-
 5 files changed, 43 insertions(+), 30 deletions(-)
 create mode 100644 serialize/SerializeDoc.h

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index ca171ff4..6b2bb559 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -13,8 +13,9 @@ typedef uint32_t address_t;
  * 			single interface (like RMAP or I2C)
  * @details
  * To use this class, implement a communication specific child cookie which
- * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
- * CookieIF* childCookie = new ChildCookie(...).
+ * inherits Cookie. Cookie instances are created in config/Factory.cpp by
+ * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
+ * @endcode .
  *
  * This cookie is then passed to the child device handlers, which stores the
  * pointer and passes it to the communication interface functions.
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 39cfadd7..bb095116 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -60,9 +60,9 @@ public:
 	 * this can be performed in this function, which is called on device handler
 	 * initialization.
 	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with
-	 * 		   returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -73,9 +73,9 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -84,9 +84,9 @@ public:
 	 * Called by DHB in the GET_WRITE doGetWrite().
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
+	 * @return - @c RETURN_OK if data was sent successfull
 	 * 		   - Everything else triggers falure event with
-	 * 		   returnvalue as parameter 1
+	 * 		     returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -99,9 +99,9 @@ public:
 	 *
 	 * @param cookie
 	 * @param requestLen Size of data to read
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
 	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -113,8 +113,8 @@ public:
 	 * @param buffer [out] Set reply here (by using *buffer = ...)
 	 * @param size [out] size pointer to set (by using *size = ...).
 	 * 	           Set to 0 if no reply was received
-	 * @return -@c RETURN_OK for successfull receive
-	 * 		   -@c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
 	 * 		   	   0 has the same effect
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 54126692..373e26bf 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -35,24 +35,20 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	/**
-	 * Create a binary semaphore
-	 */
 	BinarySemaphore();
 
 	/**
-	 * Copy ctor
-	 * @param
+	 * @brief Copy ctor
 	 */
 	BinarySemaphore(const BinarySemaphore&);
 
 	/**
-	 * Copy assignment
+	 * @brief Copy assignment
 	 */
 	BinarySemaphore& operator=(const BinarySemaphore&);
 
 	/**
-	 * Move constructor
+	 * @brief Move constructor
 	 */
 	BinarySemaphore (BinarySemaphore &&);
 
@@ -81,16 +77,16 @@ public:
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t giveBinarySemaphore();
 
@@ -108,8 +104,8 @@ public:
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
 
@@ -118,8 +114,8 @@ public:
 	 * @param semaphore
 	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
 	 *        was unblocked
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
diff --git a/serialize/SerializeDoc.h b/serialize/SerializeDoc.h
new file mode 100644
index 00000000..6186b77b
--- /dev/null
+++ b/serialize/SerializeDoc.h
@@ -0,0 +1,16 @@
+/**
+ * @page    serialPage Serialization Tools
+ * This page refers to the serialization tools included in framework/serialize.
+ * The serialization tools are a useful tool to convert object data into raw
+ * buffers and vice-versa. Here is a rough overview which tool to use for
+ * which purpose.
+ *
+ * @section endSwapper  Endian Swapper
+ * This header file includes tools to do simple serial order swapping
+ *
+ * @section serialiezIF SerializeIF
+ *
+ * @section serElement  SerializeElement
+ *
+ */
+
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 6c50f0de..a7cbfa7c 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -31,7 +31,7 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
+        info << "Stopwatch: Operation took " << elapsedTime.tv_sec / 1000 +
                 elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {

From 841b28b65d3c46a175d283d01e92729495f218d9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Apr 2020 18:02:10 +0200
Subject: [PATCH 0165/1292] stopwatch ms now working

---
 timemanager/Stopwatch.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index a7cbfa7c..3f0755fd 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -12,7 +12,7 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayMode(displayMode),
         displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
-    Clock::getUptime(&startTime);
+    startTime = Clock::getUptime();
 }
 
 void Stopwatch::start() {
@@ -31,8 +31,8 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << elapsedTime.tv_sec / 1000 +
-                elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
+        info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
         info <<"Stopwatch: Operation took "  << std::setprecision(3)

From 69e9710bf17013f974188ee420279107b472e822 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Apr 2020 17:06:06 +0200
Subject: [PATCH 0166/1292] added intial carriage return im preamble

---
 osal/FreeRTOS/BinarySemaphore.cpp           |  6 ++----
 serviceinterface/ServiceInterfaceBuffer.cpp |  9 +++++----
 serviceinterface/ServiceInterfaceBuffer.h   | 10 +++++-----
 serviceinterface/ServiceInterfaceStream.cpp |  4 ++--
 serviceinterface/ServiceInterfaceStream.h   |  4 ++--
 tmtcservices/TmTcBridge.cpp                 |  4 ++--
 6 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 05c97ae2..e2cddacc 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -138,10 +138,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
-			// Request context switch
-		    // TODO: I don't know if this will ever happen but if it does,
-		    // I want to to know in case this causes issues. If it doesn't
-		    // we should remove this.
+			// Request context switch because unblocking the semaphore
+		    // caused a high priority task unblock.
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 6798b776..527db07b 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -27,8 +27,8 @@ int ServiceInterfaceBuffer::sync(void) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
 		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%03" PRIu32 " | ",
-				this->log_message.c_str(),
+		sprintf(preamble, "\r%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32
+		        ".%03" PRIu32 " | ", this->log_message.c_str(),
 				loggerTime.hour,
 				loggerTime.minute,
 				loggerTime.second,
@@ -45,7 +45,8 @@ int ServiceInterfaceBuffer::sync(void) {
 
 #ifndef UT699
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+        uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -59,7 +60,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	}
 	memcpy(array, begin, length);
 
-	for( ; begin != end; begin++){
+	for(; begin != end; begin++){
 		printChar(begin);
 	}
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b42c8a19..b4756d41 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -7,8 +7,8 @@
 #include <cstdio>
 
 #ifndef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
+class ServiceInterfaceBuffer:
+        public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
 	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
@@ -17,11 +17,11 @@ protected:
 	// This is called when buffer becomes full. If
 	// buffer is not used, then this is called every
 	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
+	int overflow(int c = Traits::eof()) override;
 
 	// This function is called when stream is flushed,
 	// for example when std::endl is put to stream.
-	virtual int sync(void);
+	int sync(void) override;
 
 private:
 	// For additional message information
@@ -30,7 +30,7 @@ private:
 	typedef std::char_traits<char> Traits;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = 150;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c2979f36..f52413a4 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -6,6 +6,6 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
 		uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char> >(&buf), buf(
-				set_message, port) {
+		std::basic_ostream<char, std::char_traits<char>>(&buf),
+		buf(set_message, port) {
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 44cf1168..4a5b709f 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -14,7 +14,8 @@ extern std::ostream info;
 extern std::ostream warning;
 extern std::ostream error;
 
-class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
+class ServiceInterfaceStream :
+        public std::basic_ostream<char, std::char_traits<char>> {
 protected:
     ServiceInterfaceBuffer buf;
 public:
@@ -23,5 +24,4 @@ public:
 };
 
 
-
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 6b563f98..8450494a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -104,7 +104,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	info << "TMTC Bridge: Comm Link down. "
-			"Saving packet ID to be sent later " << std::endl;
+			"Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId;
 
 	if(fifo.full()) {
@@ -124,7 +124,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
 		info << "UDP Server: Sending stored TM data. There are "
-				<< (int) fifo.size() << " left to send" << std::endl;
+				<< (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;

From eb2df3d88cc3bc2c70bda89208bf4e392bbef860 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Apr 2020 23:06:57 +0200
Subject: [PATCH 0167/1292] Using C++ to implement preamble. adding optional
 flag for carriage return

---
 datapool/PoolRawAccessHelper.h              |  2 +-
 osal/linux/FixedTimeslotTask.cpp            |  4 ++-
 serviceinterface/ServiceInterfaceBuffer.cpp | 32 ++++++++++++---------
 serviceinterface/ServiceInterfaceBuffer.h   | 22 ++++++++++++--
 serviceinterface/ServiceInterfaceStream.cpp |  4 +--
 serviceinterface/ServiceInterfaceStream.h   |  5 ++--
 6 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 89974ea4..7d9b9b48 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -69,7 +69,7 @@ private:
 	struct SerializationArgs {
 		uint8_t ** buffer;
 		size_t * size;
-		const uint32_t max_size;
+		const size_t max_size;
 		bool bigEndian;
 	};
 	/**
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 21040e6e..7f117301 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -9,7 +9,9 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_):PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
 }
 
 FixedTimeslotTask::~FixedTimeslotTask() {
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 527db07b..a2365d00 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,13 +1,10 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
-#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*);
 
-
-
 int ServiceInterfaceBuffer::overflow(int c) {
 	// Handle output
 	putChars(pbase(), pptr());
@@ -26,15 +23,16 @@ int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
-		char preamble[96] = { 0 };
-		sprintf(preamble, "\r%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32
-		        ".%03" PRIu32 " | ", this->log_message.c_str(),
-				loggerTime.hour,
-				loggerTime.minute,
-				loggerTime.second,
-				loggerTime.usecond /1000);
+		std::string preamble;
+		if(addCrToPreamble) {
+			preamble += "\r";
+		}
+		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
+				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+				+ zero_padded(loggerTime.second, 2) + "."
+				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 		// Write log_message and time
-		this->putChars(preamble, preamble + sizeof(preamble));
+		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
 	}
@@ -43,10 +41,13 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+
+
 #ifndef UT699
 
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-        uint16_t port) {
+        uint16_t port, bool addCrToPreamble) {
+	this->addCrToPreamble = addCrToPreamble;
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -67,10 +68,15 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 }
 #endif
 
+/**
+ * TODO: This is architecture specific. Maybe there is a better solution
+ * to move this into the Bsp folder..
+ */
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b4756d41..a2bc4f4b 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -2,16 +2,17 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include <iostream>
-#include <iosfwd>
 #include <sstream>
 #include <cstdio>
+#include <iomanip>
 
 #ifndef UT699
 class ServiceInterfaceBuffer:
         public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
+			bool addCrToPreamble);
 protected:
 	bool isActive;
 	// This is called when buffer becomes full. If
@@ -28,13 +29,28 @@ private:
 	std::string log_message;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+	// This is useful for some terminal programs which do not have
+	// implicit carriage return with newline characters.
+	bool addCrToPreamble;
 
 	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 150;
+	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
 	// In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
+
+	template<typename T>
+	std::string zero_padded(const T& num, uint8_t width) {
+	    std::ostringstream string_to_pad;
+	    string_to_pad << std::setw(width) << std::setfill('0') << num;
+	    std::string result = string_to_pad.str();
+	    if (result.length() > width)
+	    {
+	        result.erase(0, result.length() - width);
+	    }
+	    return result;
+	}
 };
 #endif
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index f52413a4..40f52f1f 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -5,7 +5,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 }
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		uint16_t port) :
+		bool addCrToPreamble, uint16_t port) :
 		std::basic_ostream<char, std::char_traits<char>>(&buf),
-		buf(set_message, port) {
+		buf(set_message, port, addCrToPreamble) {
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 4a5b709f..5e223f0e 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,7 +7,7 @@
 #include <sstream>
 #include <cstdio>
 
-//Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of log_fe
 // (MUST be defined in main), to let the system know where to write to.
 extern std::ostream debug;
 extern std::ostream info;
@@ -19,7 +19,8 @@ class ServiceInterfaceStream :
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message, uint16_t port = 1234 );
+    ServiceInterfaceStream( std::string set_message,
+    		bool addCrToPreamble = false, uint16_t port = 1234);
 	void setActive( bool );
 };
 

From a0ee010926eb3870c61c8eaa8cd39f9601b1fa86 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 16:27:05 +0200
Subject: [PATCH 0168/1292] Added test folder.

---
 framework.mk                      |   1 +
 serialize/EndianSwapper.h         |   4 +-
 serialize/SerialBufferAdapter.cpp |  17 ++-
 serialize/SerialBufferAdapter.h   |  18 +--
 serialize/SerializeAdapter.h      |  37 ++---
 test/UnitTestClass.cpp            | 217 ++++++++++++++++++++++++++++++
 test/UnitTestClass.h              |  78 +++++++++++
 7 files changed, 338 insertions(+), 34 deletions(-)
 create mode 100644 test/UnitTestClass.cpp
 create mode 100644 test/UnitTestClass.h

diff --git a/framework.mk b/framework.mk
index a5a65364..2e7e57e9 100644
--- a/framework.mk
+++ b/framework.mk
@@ -54,3 +54,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 25fb681e..9f621902 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -11,9 +11,7 @@
  */
 class EndianSwapper {
 private:
-	EndianSwapper() {
-	}
-	;
+	EndianSwapper() {};
 public:
 	template<typename T>
 	static T swap(T in) {
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index f97d0d58..42ea3dad 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -12,8 +12,8 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
 }
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
-		bool serializeLength) :
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
+		count_t bufferLength, bool serializeLength) :
 		serializeLength(serializeLength), bufferLength(bufferLength) {
 	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
 	m_buffer = member_buffer;
@@ -26,8 +26,8 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
@@ -98,7 +98,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(m_buffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
 	return m_buffer;
@@ -107,14 +108,16 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getBuffer()" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;
 }
 
 template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
+		count_t buffer_length) {
 	m_buffer = static_cast<uint8_t *>(buffer);
 	bufferLength = buffer_length;
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cf3ae07e..4a886cba 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -8,11 +8,13 @@
  * This adapter provides an interface for SerializeIF to serialize or deserialize
  * buffers with no length header but a known size.
  *
- * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
  *
  * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
- * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
  *
  * \ingroup serialize
  */
@@ -27,14 +29,16 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength,
+			bool serializeLength = false);
 
 	/**
-	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * Constructor for non-constant uint8_t buffer.
+	 * Length field can be serialized optionally.
 	 * Type of length can be supplied as template type.
 	 * @param buffer
 	 * @param bufferLength
-	 * @param serializeLength
+	 * @param serializeLength Length field will be serialized with size count_t
 	 */
 	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
@@ -58,6 +62,4 @@ private:
 	count_t bufferLength = 0;
 };
 
-
-
 #endif /* SERIALBUFFERADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 81a3730f..fce8651b 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -9,18 +9,21 @@
 
  /**
  * @brief This adapter provides an interface to use the SerializeIF functions
- * 		  with arbitrary template objects to facilitate and simplify the serialization of classes
- * 		  with different multiple different data types into buffers and vice-versa.
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
  * @details
  * Examples:
- * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
- * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
- * The getSerializedSize function is implemented by calling the
- * AutoSerializeAdapter::getSerializedSize function repeatedly on all data fields.
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
  *
- * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
- * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
- * The boolean bigEndian specifies whether an endian swap is performed on the data before
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
  * serialization or deserialization.
  *
  * If the target architecture is little endian (ARM), any data types created might
@@ -50,8 +53,8 @@
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
  *   	data = EndianSwapper::swap(data);
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
@@ -83,8 +86,10 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const
+	 * 						pointer to const buffer.
+	 * @param size int32_t type to allow value to be values smaller than 0,
+	 * 						needed for range/size checking
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
@@ -106,7 +111,7 @@ public:
 		}
 	}
 
-	uint32_t getSerializedSize(const T * object) {
+	size_t getSerializedSize(const T * object) {
 		return sizeof(T);
 	}
 
@@ -123,7 +128,7 @@ public:
 		}
 		return object->serialize(buffer, size, max_size, bigEndian);
 	}
-	uint32_t getSerializedSize(const T* object) const {
+	size_t getSerializedSize(const T* object) const {
 		return object->getSerializedSize();
 	}
 
@@ -163,7 +168,7 @@ public:
 		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
 	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
+	static size_t getSerializedSize(const T* object) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.getSerializedSize(object);
 	}
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
new file mode 100644
index 00000000..7050dece
--- /dev/null
+++ b/test/UnitTestClass.cpp
@@ -0,0 +1,217 @@
+/**
+ * @file 	UnitTestClass.cpp
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+#include <framework/test/UnitTestClass.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/serialize/SerializeElement.h>
+#include <framework/serialize/SerialBufferAdapter.h>
+
+#include <cstdlib>
+
+UnitTestClass::UnitTestClass() {
+}
+
+UnitTestClass::~UnitTestClass() {
+}
+
+ReturnValue_t UnitTestClass::performTests() {
+	ReturnValue_t result = test_serialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_serialization() {
+	// Here, we test all serialization tools. First test basic cases.
+	ReturnValue_t result = test_autoserialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_serial_buffer_adapter();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_autoserialization() {
+	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
+	// Unit Test getSerializedSize
+	if(AutoSerializeAdapter::
+			getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int8) != sizeof(tv_int8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_double) != sizeof(tv_double) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int16) != sizeof(tv_int16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int32) != sizeof(tv_int32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_float) != sizeof(tv_float))
+	{
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter deserialize
+	current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_float, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_double, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
+			&serialized_size, test_array.size(), false);
+	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
+	if(serialized_size != 47) {
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter serialize
+	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
+	p_array = test_array.data();
+	ssize_t remaining_size = serialized_size;
+	AutoSerializeAdapter::deSerialize(&test_value_bool,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint64,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_float,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_double,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sfloat,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sdouble,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+
+	//	uint16_t tv_uint16 {283};
+	//	uint32_t tv_uint32 {929221};
+	//	uint64_t tv_uint64 {2929329429};
+	//	int8_t tv_int8 {-16};
+	//	int16_t tv_int16 {-829};
+	//	int32_t tv_int32 {-2312};
+	//	float tv_float {8.2149214};
+	//	float tv_sfloat = {-922.2321321};
+	//	double tv_double {9.2132142141e8};
+	//	double tv_sdouble {-2.2421e19};
+	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
+			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
+			tv_int16 != -829 or tv_int32 != -2312 or tv_float != 8.214921 or
+			tv_double != 9.2132142141e8 or tv_sfloat != -922.2321321 or
+			tv_sdouble != -2.2421e19)
+	{
+		return put_error(current_id);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
+	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
+
+	// I will skip endian swapper testing, its going to be changed anyway..
+	// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
+
+	size_t serialized_size = 0;
+	test_value_bool = true;
+	uint8_t * p_array = test_array.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	tv_uint16 = 16;
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), true);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
+			or test_array[5] != 2 or test_array[6] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
+	error << "Unit Tester failed at test ID "
+			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
+	return RETURN_FAILED;
+}
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
new file mode 100644
index 00000000..c93ea0bc
--- /dev/null
+++ b/test/UnitTestClass.h
@@ -0,0 +1,78 @@
+/**
+ * @file 	UnitTestClass.h
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <map>
+#include <vector>
+
+/**
+ * We could start doing basic forms of Unit Testing (without a framework, first)
+ * for framework components. This could include:
+ *
+ *  1. TMTC Services
+ *  2. Serialization tools
+ *  3. Framework internal algorithms
+ */
+
+class UnitTestClass: public HasReturnvaluesIF {
+public:
+	UnitTestClass();
+	virtual~ UnitTestClass();
+
+	enum class TestIds {
+		AUTO_SERIALIZATION_SIZE = 0,
+		AUTO_SERIALIZATION_SERIALIZE = 1,
+		AUTO_SERIALIZATION_DESERIALIZE = 2,
+		SERIALIZATION_BUFFER_ADAPTER = 3,
+		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER = 4,
+		SERIALIZATION_COMBINATION = 5,
+		TMTC_SERVICES ,
+		MISC
+	};
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	ReturnValue_t performTests();
+
+	ReturnValue_t test_serialization();
+	ReturnValue_t test_autoserialization();
+	ReturnValue_t test_serial_buffer_adapter();
+private:
+	uint32_t errorCounter = 0;
+	TestIds current_id = TestIds::MISC;
+	std::array<uint8_t, 512> test_array;
+
+	using TestResultMap = std::map<uint32_t, ReturnValue_t>;
+	using TestBuffer = std::vector<uint8_t>;
+	TestResultMap testResultMap;
+
+	// POD test values
+	bool test_value_bool = true;
+	uint8_t tv_uint8   {5};
+	uint16_t tv_uint16 {283};
+	uint32_t tv_uint32 {929221};
+	uint64_t tv_uint64 {2929329429};
+
+	int8_t tv_int8 {-16};
+	int16_t tv_int16 {-829};
+	int32_t tv_int32 {-2312};
+
+	float tv_float {8.2149214};
+	float tv_sfloat = {-922.2321321};
+	double tv_double {9.2132142141e8};
+	double tv_sdouble {-2.2421e19};
+
+	ReturnValue_t put_error(TestIds currentId);
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */

From 0d016e5a2b2e5b566c7c7f2a11e64c1c93dcc4d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 16:37:25 +0200
Subject: [PATCH 0169/1292] slight formatting

---
 osal/linux/PeriodicPosixTask.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index e3fa5722..43647eda 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -9,7 +9,8 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(*deadlineMissedFunc_)());
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
 	/**
 	 * @brief	The method to start the task.

From b48a0a4a4ce5ea9b4e85b76223e357fe49ce6907 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Apr 2020 22:45:23 +0200
Subject: [PATCH 0170/1292] unit test class continued. serialize adapter

functions which are internal, extracted to separate class
---
 container/IsDerivedFrom.h            |   9 ++
 serialize/SerializeAdapter.h         | 162 +++++++--------------------
 serialize/SerializeAdapterInternal.h | 114 +++++++++++++++++++
 test/UnitTestClass.cpp               |  87 +++++++++++++-
 test/UnitTestClass.h                 |  18 +--
 5 files changed, 259 insertions(+), 131 deletions(-)
 create mode 100644 serialize/SerializeAdapterInternal.h

diff --git a/container/IsDerivedFrom.h b/container/IsDerivedFrom.h
index 520033db..8142a378 100644
--- a/container/IsDerivedFrom.h
+++ b/container/IsDerivedFrom.h
@@ -1,6 +1,13 @@
 #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 {
@@ -9,7 +16,9 @@ class IsDerivedFrom {
 		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:
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fce8651b..d926bfce 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,19 +1,18 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
-#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
 #include <framework/serialize/SerializeIF.h>
-#include <string.h>
+#include <framework/serialize/SerializeAdapterInternal.h>
+#include <type_traits>
 
  /**
- * @brief This adapter provides an interface to use the SerializeIF functions
+ * @brief These adapters provides an interface to use the SerializeIF functions
  * 		  with arbitrary template objects to facilitate and simplify the
  * 		  serialization of classes with different multiple different data types
  * 		  into buffers and vice-versa.
  * @details
- * Examples:
+ *
  * A report class is converted into a TM buffer. The report class implements a
  * serialize functions and calls the AutoSerializeAdapter::serialize function
  * repeatedly on all object data fields. The getSerializedSize function is
@@ -26,137 +25,42 @@
  * bigEndian specifies whether an endian swap is performed on the data before
  * serialization or deserialization.
  *
- * If the target architecture is little endian (ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
  * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data.
- * This can also be applied to uint32_t and uint64_t:
+ * to use regular aligned (big endian) data. Examples:
  *
  *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize of the object,
- *		so this function can be called on &buffer repeatedly without adjusting pointer position.
- *		Set bigEndian parameter to true to perform endian swapping.
- *
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *
- *   2. Perform a bitshift operation. Perform endian swapping if necessary:
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
  *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
  *   	uint16_t data;
  *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data);
- *
- *   3. Memcpy can be used when data is little-endian. Perform endian-swapping if necessary.
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
  *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
  *   	uint16_t data;
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data);
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
  *
  * When serializing for downlink, the packets are generally serialized assuming
  * big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const
-	 * 						pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0,
-	 * 						needed for range/size checking
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	size_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-
-};
-
-template<typename T>
-class SerializeAdapter_<T, 1> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-	size_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-template<typename T>
-class SerializeAdapter {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
 
 // No type specification necessary here.
 class AutoSerializeAdapter {
@@ -180,4 +84,24 @@ public:
 	}
 };
 
+template<typename T>
+class SerializeAdapter {
+public:
+	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+			size_t* size, const size_t max_size, bool bigEndian) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+	}
+	static uint32_t getSerializedSize(const T* object) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+
+	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
+			ssize_t* size, bool bigEndian) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, bigEndian);
+	}
+};
+
 #endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
new file mode 100644
index 00000000..46dbdf19
--- /dev/null
+++ b/serialize/SerializeAdapterInternal.h
@@ -0,0 +1,114 @@
+/**
+ * @file 	SerializeAdapterInternal.h
+ *
+ * @date	13.04.2020
+ * @author	R. Mueller
+ */
+
+#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/IsDerivedFrom.h>
+#include <framework/serialize/EndianSwapper.h>
+
+/**
+ * This template specialization will be chosen for fundamental types.
+ * @tparam T
+ * @tparam
+ */
+template<typename T, int>
+class SerializeAdapter_ {
+public:
+	/**
+	 *
+	 * @param object
+	 * @param buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+			size_t* size, const size_t max_size, bool bigEndian) {
+		size_t ignoredSize = 0;
+		if (size == nullptr) {
+			size = &ignoredSize;
+		}
+		if (sizeof(T) + *size <= max_size) {
+			T tmp;
+			if (bigEndian) {
+				tmp = EndianSwapper::swap<T>(*object);
+			} else {
+				tmp = *object;
+			}
+			memcpy(*buffer, &tmp, sizeof(T));
+			*size += sizeof(T);
+			(*buffer) += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::BUFFER_TOO_SHORT;
+		}
+	}
+
+	/**
+	 * Deserialize buffer into object
+	 * @param object [out] Object to be deserialized with buffer data
+	 * @param buffer buffer containing the data. Non-Const pointer to non-const
+	 * 						pointer to const buffer.
+	 * @param size int32_t type to allow value to be values smaller than 0,
+	 * 						needed for range/size checking
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
+		T tmp;
+		*size -= sizeof(T);
+		if (*size >= 0) {
+			memcpy(&tmp, *buffer, sizeof(T));
+			if (bigEndian) {
+				*object = EndianSwapper::swap<T>(tmp);
+			} else {
+				*object = tmp;
+			}
+			*buffer += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::STREAM_TOO_SHORT;
+		}
+	}
+
+	size_t getSerializedSize(const T * object) {
+		return sizeof(T);
+	}
+};
+
+/**
+ * This template specialization will be chosen for class derived from
+ * SerializeIF.
+ * @tparam T
+ * @tparam
+ */
+template<typename T>
+class SerializeAdapter_<T, true> {
+public:
+	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		size_t ignoredSize = 0;
+		if (size == NULL) {
+			size = &ignoredSize;
+		}
+		return object->serialize(buffer, size, max_size, bigEndian);
+	}
+
+	size_t getSerializedSize(const T* object) const {
+		return object->getSerializedSize();
+	}
+
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+			bool bigEndian) {
+		return object->deSerialize(buffer, size, bigEndian);
+	}
+};
+
+#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 7050dece..ac570b21 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -17,7 +17,7 @@ UnitTestClass::UnitTestClass() {
 UnitTestClass::~UnitTestClass() {
 }
 
-ReturnValue_t UnitTestClass::performTests() {
+ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
 	if(result != RETURN_OK) {
 		return result;
@@ -28,7 +28,11 @@ ReturnValue_t UnitTestClass::performTests() {
 
 ReturnValue_t UnitTestClass::test_serialization() {
 	// Here, we test all serialization tools. First test basic cases.
-	ReturnValue_t result = test_autoserialization();
+	ReturnValue_t result = test_endianness_tools();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_autoserialization();
 	if(result != RETURN_OK) {
 		return result;
 	}
@@ -39,6 +43,47 @@ ReturnValue_t UnitTestClass::test_serialization() {
 	return RETURN_OK;
 }
 
+ReturnValue_t UnitTestClass::test_endianness_tools() {
+	test_array[0] = 0;
+	test_array[1] = 0;
+	uint16_t two_byte_value = 1;
+	size_t size = 0;
+	uint8_t* p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
+	// Little endian: Value one on first byte
+	if(test_array[0] != 1 and test_array[1] != 0) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+
+	}
+	p_array = test_array.data();
+	size = 0;
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
+	// Big endian: Value one on second byte
+	if(test_array[0] != 0 and test_array[1] != 1) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+	}
+
+	// Endianness paameter will be changed later.
+//	p_array = test_array.data();
+//	ssize_t ssize = size;
+//	// Resulting parameter should be big endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, true);
+//	if(two_byte_value != 1) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+//
+//	ssize = size;
+//	p_array = test_array.data();
+//	// Resulting parameter should be little endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, false);
+//	if(two_byte_value != 256) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+	return RETURN_OK;
+}
+
 ReturnValue_t UnitTestClass::test_autoserialization() {
 	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
 	// Unit Test getSerializedSize
@@ -142,15 +187,21 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	//	double tv_sdouble {-2.2421e19};
 	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
 			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
-			tv_int16 != -829 or tv_int32 != -2312 or tv_float != 8.214921 or
-			tv_double != 9.2132142141e8 or tv_sfloat != -922.2321321 or
-			tv_sdouble != -2.2421e19)
+			tv_int16 != -829 or tv_int32 != -2312)
 	{
 		return put_error(current_id);
 	}
+
+	if(abs(tv_float - 8.214921) > 0.0001 or
+			abs(tv_double - 9.2132142141e8) > 0.01 or
+			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
+			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
+		return put_error(current_id);
+	}
 	return RETURN_OK;
 }
 
+// TODO: Also test for constant buffers.
 ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
 
@@ -203,6 +254,31 @@ ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	{
 		return put_error(current_id);
 	}
+	memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
+			SerialBufferAdapter<uint8_t>(
+			const_cast<const uint8_t*>(test_serial_buffer.data()),
+			test_serial_buffer.size(), false);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
 	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
 	if(tv_uint16 != 16) {
 		return put_error(current_id);
@@ -215,3 +291,4 @@ ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
 			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
 	return RETURN_FAILED;
 }
+
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index c93ea0bc..078cf3c9 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -19,6 +19,8 @@
  *  1. TMTC Services
  *  2. Serialization tools
  *  3. Framework internal algorithms
+ *
+ *  TODO: Maybe use specialized framework.
  */
 
 class UnitTestClass: public HasReturnvaluesIF {
@@ -27,12 +29,13 @@ public:
 	virtual~ UnitTestClass();
 
 	enum class TestIds {
-		AUTO_SERIALIZATION_SIZE = 0,
-		AUTO_SERIALIZATION_SERIALIZE = 1,
-		AUTO_SERIALIZATION_DESERIALIZE = 2,
-		SERIALIZATION_BUFFER_ADAPTER = 3,
-		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER = 4,
-		SERIALIZATION_COMBINATION = 5,
+		ENDIANNESS_TOOLS,
+		AUTO_SERIALIZATION_SIZE,
+		AUTO_SERIALIZATION_SERIALIZE,
+		AUTO_SERIALIZATION_DESERIALIZE ,
+		SERIALIZATION_BUFFER_ADAPTER,
+		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
+		SERIALIZATION_COMBINATION,
 		TMTC_SERVICES ,
 		MISC
 	};
@@ -41,11 +44,12 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	ReturnValue_t perform_tests();
 
 	ReturnValue_t test_serialization();
 	ReturnValue_t test_autoserialization();
 	ReturnValue_t test_serial_buffer_adapter();
+	ReturnValue_t test_endianness_tools();
 private:
 	uint32_t errorCounter = 0;
 	TestIds current_id = TestIds::MISC;

From 03b0ae7b68541f8d6268c0dcc8b763e04870d185 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 11:16:51 +0200
Subject: [PATCH 0171/1292] unit test fixes

---
 test/UnitTestClass.cpp | 2 +-
 test/UnitTestClass.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 7050dece..f2925a24 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -17,7 +17,7 @@ UnitTestClass::UnitTestClass() {
 UnitTestClass::~UnitTestClass() {
 }
 
-ReturnValue_t UnitTestClass::performTests() {
+ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
 	if(result != RETURN_OK) {
 		return result;
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index c93ea0bc..f1184269 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -41,7 +41,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	ReturnValue_t perform_tests();
 
 	ReturnValue_t test_serialization();
 	ReturnValue_t test_autoserialization();

From c5e5de1530acb3f3212514c254dea65635ece647 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 12:24:26 +0200
Subject: [PATCH 0172/1292] deleted example values

---
 test/UnitTestClass.cpp | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index ac570b21..89d4001d 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -11,11 +11,9 @@
 
 #include <cstdlib>
 
-UnitTestClass::UnitTestClass() {
-}
+UnitTestClass::UnitTestClass() {}
 
-UnitTestClass::~UnitTestClass() {
-}
+UnitTestClass::~UnitTestClass() {}
 
 ReturnValue_t UnitTestClass::perform_tests() {
 	ReturnValue_t result = test_serialization();
@@ -175,16 +173,6 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	AutoSerializeAdapter::deSerialize(&tv_sdouble,
 			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
 
-	//	uint16_t tv_uint16 {283};
-	//	uint32_t tv_uint32 {929221};
-	//	uint64_t tv_uint64 {2929329429};
-	//	int8_t tv_int8 {-16};
-	//	int16_t tv_int16 {-829};
-	//	int32_t tv_int32 {-2312};
-	//	float tv_float {8.2149214};
-	//	float tv_sfloat = {-922.2321321};
-	//	double tv_double {9.2132142141e8};
-	//	double tv_sdouble {-2.2421e19};
 	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
 			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
 			tv_int16 != -829 or tv_int32 != -2312)

From af27a2441affb1923a4a2ff33c044ce825549094 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Apr 2020 16:19:13 +0200
Subject: [PATCH 0173/1292] added catch framework for basic testing

---
 framework.mk                             |     2 +-
 serialize/SerializeAdapterInternal.h     |     8 +-
 test/CatchExample.cpp                    |    49 +
 test/UnitTestClass.cpp                   |    11 +
 test/UnitTestClass.h                     |     1 +
 test/catch2/catch.hpp                    | 17618 +++++++++++++++++++++
 test/catch2/catch_reporter_automake.hpp  |    62 +
 test/catch2/catch_reporter_sonarqube.hpp |   181 +
 test/catch2/catch_reporter_tap.hpp       |   253 +
 test/catch2/catch_reporter_teamcity.hpp  |   219 +
 10 files changed, 18401 insertions(+), 3 deletions(-)
 create mode 100644 test/CatchExample.cpp
 create mode 100644 test/catch2/catch.hpp
 create mode 100644 test/catch2/catch_reporter_automake.hpp
 create mode 100644 test/catch2/catch_reporter_sonarqube.hpp
 create mode 100644 test/catch2/catch_reporter_tap.hpp
 create mode 100644 test/catch2/catch_reporter_teamcity.hpp

diff --git a/framework.mk b/framework.mk
index 2e7e57e9..6f64b720 100644
--- a/framework.mk
+++ b/framework.mk
@@ -54,4 +54,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
\ No newline at end of file
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index 46dbdf19..ed0f6c3b 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -12,7 +12,8 @@
 #include <framework/serialize/EndianSwapper.h>
 
 /**
- * This template specialization will be chosen for fundamental types.
+ * This template specialization will be chosen for fundamental types,
+ * based on partial template specialization
  * @tparam T
  * @tparam
  */
@@ -30,6 +31,9 @@ public:
 	 */
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
 			size_t* size, const size_t max_size, bool bigEndian) {
+	    // function eventuelly serializes structs here.
+	    // does this work on every architecture?
+	    //static_assert(std::is_fundamental<T>::value);
 		size_t ignoredSize = 0;
 		if (size == nullptr) {
 			size = &ignoredSize;
@@ -85,7 +89,7 @@ public:
 
 /**
  * This template specialization will be chosen for class derived from
- * SerializeIF.
+ * SerializeIF, based on partial template specialization.
  * @tparam T
  * @tparam
  */
diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
new file mode 100644
index 00000000..4db6a5c2
--- /dev/null
+++ b/test/CatchExample.cpp
@@ -0,0 +1,49 @@
+// Catch Example.
+// Does not work yet. Problems with linker without main and config folder.
+// Let Catch provide main():
+
+#if defined(UNIT_TEST)
+#define CATCH_CONFIG_MAIN
+
+#include <framework/test/catch2/catch.hpp>
+#include <framework/test/UnitTestClass.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+int Factorial( int number ) {
+   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
+// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
+}
+
+
+
+TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
+    REQUIRE( Factorial(0) == 1 );
+}
+
+TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
+    REQUIRE( Factorial(1) == 1 );
+    REQUIRE( Factorial(2) == 2 );
+    REQUIRE( Factorial(3) == 6 );
+    REQUIRE( Factorial(10) == 3628800 );
+}
+
+TEST_CASE( "Custom test", "[single-file]" ) {
+    UnitTestClass unitTestClass;
+    REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
+}
+
+// Compile & run:
+// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
+// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
+
+// Expected compact output (all assertions):
+//
+// prompt> 010-TestCase --reporter compact --success
+// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
+// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
+// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
+// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
+// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
+// Failed 1 test case, failed 1 assertion.
+
+#endif
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index 89d4001d..d20dfb0a 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -11,6 +11,15 @@
 
 #include <cstdlib>
 
+#if defined(UNIT_TEST)
+#include "catch.hpp"
+#define CATCH_CONFIG_MAIN
+
+TEST_CASE( "Serialization Size tests", "[single-file]") {
+   //REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
+}
+#endif
+
 UnitTestClass::UnitTestClass() {}
 
 UnitTestClass::~UnitTestClass() {}
@@ -53,6 +62,7 @@ ReturnValue_t UnitTestClass::test_endianness_tools() {
 		return put_error(TestIds::ENDIANNESS_TOOLS);
 
 	}
+
 	p_array = test_array.data();
 	size = 0;
 	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
@@ -180,6 +190,7 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 		return put_error(current_id);
 	}
 
+	// These epsilon values were just guessed.. It appears to work though.
 	if(abs(tv_float - 8.214921) > 0.0001 or
 			abs(tv_double - 9.2132142141e8) > 0.01 or
 			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index 078cf3c9..d9ba9d1c 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -9,6 +9,7 @@
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+
 #include <map>
 #include <vector>
 
diff --git a/test/catch2/catch.hpp b/test/catch2/catch.hpp
new file mode 100644
index 00000000..51618b38
--- /dev/null
+++ b/test/catch2/catch.hpp
@@ -0,0 +1,17618 @@
+/*
+ *  Catch v2.11.3
+ *  Generated: 2020-03-19 13:44:21.042491
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+// start catch.hpp
+
+
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 11
+#define CATCH_VERSION_PATCH 3
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// start catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+// end catch_suppress_warnings.h
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+// start catch_platform.h
+
+#ifdef __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_OSX == 1
+#  define CATCH_PLATFORM_MAC
+# elif TARGET_OS_IPHONE == 1
+#  define CATCH_PLATFORM_IPHONE
+# endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+#endif
+
+// end catch_platform.h
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// start catch_user_interfaces.h
+
+namespace Catch {
+    unsigned int rngSeed();
+}
+
+// end catch_user_interfaces.h
+// start catch_tag_alias_autoregistrar.h
+
+// start catch_common.h
+
+// start catch_compiler_capabilities.h
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+#ifdef __cplusplus
+
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#endif
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+// We have to avoid both ICC and Clang, because they try to mask themselves
+// as gcc, and we want only GCC in this block
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use of __COUNTER__ is suppressed during code analysis in
+// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
+// handled by it.
+// Otherwise all supported compilers support COUNTER macro,
+// but user still might want to turn it off
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+// end catch_compiler_capabilities.h
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <cstdint>
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+
+    protected:
+        NonCopyable();
+        virtual ~NonCopyable();
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
+            line( _line )
+        {}
+
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
+
+        bool empty() const noexcept { return file[0] == '\0'; }
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() const;
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+// end catch_common.h
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_tag_alias_autoregistrar.h
+// start catch_test_registry.h
+
+// start catch_interfaces_testcase.h
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestInvoker {
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+// end catch_interfaces_testcase.h
+// start catch_stringref.h
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
+        auto c_str() const -> char const*;
+
+    public: // substrings and searches
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
+
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
+
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
+
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
+
+    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+// end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
+public:
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+    void invoke() const override {
+        C obj;
+        (obj.*m_testAsMethod)();
+    }
+};
+
+auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+
+template<typename C>
+auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+}
+
+struct NameAndTags {
+    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : NonCopyable {
+    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+    ~AutoReg();
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+
+// end catch_test_registry.h
+// start catch_capture.hpp
+
+// start catch_assertionhandler.h
+
+// start catch_assertioninfo.h
+
+// start catch_result_type.h
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+// end catch_result_type.h
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+
+        // We want to delete this constructor but a compiler bug in 4.8 means
+        // the struct is then treated as non-aggregate
+        //AssertionInfo() = delete;
+    };
+
+} // end namespace Catch
+
+// end catch_assertioninfo.h
+// start catch_decomposer.h
+
+// start catch_tostring.h
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+// start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    class StringRef;
+
+    struct IStream {
+        virtual ~IStream();
+        virtual std::ostream& stream() const = 0;
+    };
+
+    auto makeStream( StringRef const &filename ) -> IStream const*;
+
+    class ReusableStringStream : NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        auto str() const -> std::string;
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+// end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef __OBJC__
+// start catch_objc_arc.hpp
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+// end catch_objc_arc.hpp
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+namespace Catch {
+    namespace Detail {
+
+        extern const std::string unprintableString;
+
+        std::string rawMemoryToString( const void *object, std::size_t size );
+
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
+
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string>::type convertUnstreamable( T const& ) {
+            return Detail::unprintableString;
+        }
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string>::type convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+        template<typename T>
+        typename std::enable_if<
+            std::is_enum<T>::value
+        , std::string>::type convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
+#endif
+
+    } // namespace Detail
+
+    // If we decide for C++14, change these to enable_if_ts
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
+
+        template <typename Fake = T>
+        static
+        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
+#else
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+        }
+    };
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
+        }
+#endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif
+
+    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+    //      while keeping string semantics?
+    template<int SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return ::Catch::Detail::stringify(std::string{ str });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
+    };
+
+    template<>
+    struct StringMaker<bool> {
+        static std::string convert(bool b);
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char c);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char c);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t);
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
+
+    namespace Detail {
+        template<typename InputIterator>
+        std::string rangeToString(InputIterator first, InputIterator last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
+        }
+    }
+
+#ifdef __OBJC__
+    template<>
+    struct StringMaker<NSString*> {
+        static std::string convert(NSString * nsstring) {
+            if (!nsstring)
+                return "nil";
+            return std::string("@") + [nsstring UTF8String];
+        }
+    };
+    template<>
+    struct StringMaker<NSObject*> {
+        static std::string convert(NSObject* nsObject) {
+            return ::Catch::Detail::stringify([nsObject description]);
+        }
+
+    };
+    namespace Detail {
+        inline std::string stringify( NSString* nsstring ) {
+            return StringMaker<NSString*>::convert( nsstring );
+        }
+
+    } // namespace Detail
+#endif // __OBJC__
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+
+    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
+    using std::begin;
+    using std::end;
+
+    not_this_one begin( ... );
+    not_this_one end( ... );
+
+    template <typename T>
+    struct is_range {
+        static const bool value =
+            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+    };
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, int SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol();
+};
+
+template <class Ratio>
+std::string ratio_string<Ratio>::symbol() {
+    Catch::ReusableStringStream rss;
+    rss << '[' << Ratio::num << '/'
+        << Ratio::den << ']';
+    return rss.str();
+}
+template <>
+struct ratio_string<std::atto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::femto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::pico> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::nano> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::micro> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::milli> {
+    static std::string symbol();
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_tostring.h
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+namespace Catch {
+
+    struct ITransientExpression {
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+        ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression();
+
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+    template<typename LhsT, typename RhsT>
+    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+    template<typename T>
+    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+    template<typename LhsT, typename RhsT>
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+    template<typename T>
+    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+        template<typename RhsT>
+        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+        }
+        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs == rhs, m_lhs, "==", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+        }
+        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs != rhs, m_lhs, "!=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+        }
+        template<typename RhsT>
+        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+        }
+        template<typename RhsT>
+        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+        }
+        template<typename RhsT>
+        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    void handleExpression( ITransientExpression const& expr );
+
+    template<typename T>
+    void handleExpression( ExprLhs<T> const& expr ) {
+        handleExpression( expr.makeUnaryExpr() );
+    }
+
+    struct Decomposer {
+        template<typename T>
+        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<T const&>{ lhs };
+        }
+
+        auto operator <=( bool value ) -> ExprLhs<bool> {
+            return ExprLhs<bool>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_decomposer.h
+// start catch_interfaces_capture.h
+
+#include <string>
+#include <chrono>
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// end catch_interfaces_capture.h
+namespace Catch {
+
+    struct TestFailureException{};
+    struct AssertionResultData;
+    struct IResultCapture;
+    class RunContext;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated );
+        LazyExpression( LazyExpression const& other );
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const;
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef const& macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+        template<typename T>
+        void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+        void setCompleted();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+
+} // namespace Catch
+
+// end catch_assertionhandler.h
+// start catch_message.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const;
+        bool operator < ( MessageInfo const& other ) const;
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type );
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
+    };
+
+} // end namespace Catch
+
+// end catch_message.h
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+
+#endif
+
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            static_cast<void>(__VA_ARGS__); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_capture.hpp
+// start catch_section.h
+
+// start catch_section_info.h
+
+// start catch_totals.h
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::size_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::size_t passed = 0;
+        std::size_t failed = 0;
+        std::size_t failedButOk = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        int error = 0;
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// end catch_totals.h
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
+
+        std::string name;
+        std::string description; // !Deprecated: this will always be empty
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// end catch_section_info.h
+// start catch_timer.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+    auto getEstimatedClockResolution() -> uint64_t;
+
+    class Timer {
+        uint64_t m_nanoseconds = 0;
+    public:
+        void start();
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
+    };
+
+} // namespace Catch
+
+// end catch_timer.h
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_section.h
+// start catch_interfaces_exception.h
+
+// start catch_interfaces_registry_hub.h
+
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
+    class StartupExceptionRegistry;
+
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+// end catch_interfaces_registry_hub.h
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
+
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    struct IExceptionTranslator;
+    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// end catch_interfaces_exception.h
+// start catch_approx.h
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T const& value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T const& newEpsilon ) {
+            double epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T const& newMargin ) {
+            double marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
+            return *this;
+        }
+
+        std::string toString() const;
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Detail::Approx> {
+    static std::string convert(Catch::Detail::Approx const& value);
+};
+
+} // end namespace Catch
+
+// end catch_approx.h
+// start catch_string_manip.h
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+}
+
+// end catch_string_manip.h
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+// start catch_capture_matchers.h
+
+// start catch_matchers.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            MatcherUntypedBase() = default;
+            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+            std::string toString() const;
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        };
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
+        };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<T> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename T>
+        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<T>() && *this && other;
+        }
+        template<typename T>
+        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<T>() || *this || other;
+        }
+        template<typename T>
+        MatchNotOf<T> MatcherBase<T>::operator ! () const {
+            return MatchNotOf<T>( *this );
+        }
+
+    } // namespace Impl
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+// end catch_matchers.h
+// start catch_matchers_exception.hpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Floating {
+
+        enum class FloatingPointKind : uint8_t;
+
+        struct WithinAbsMatcher : MatcherBase<double> {
+            WithinAbsMatcher(double target, double margin);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_margin;
+        };
+
+        struct WithinUlpsMatcher : MatcherBase<double> {
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            uint64_t m_ulps;
+            FloatingPointKind m_type;
+        };
+
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
+    } // namespace Floating
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.h
+// start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+namespace Generic {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+}
+
+template <typename T>
+class PredicateMatcher : public MatcherBase<T> {
+    std::function<bool(T const&)> m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+        :m_predicate(std::move(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+} // namespace Generic
+
+    // The following functions create the actual matcher objects.
+    // The user has to explicitly specify type to the function, because
+    // inferring std::function<bool(T const&)> is hard (but possible) and
+    // requires a lot of TMP.
+    template<typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+        return Generic::PredicateMatcher<T>(predicate, description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_generic.hpp
+// start catch_matchers_string.h
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            std::string describe() const override;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+
+        struct RegexMatcher : MatcherBase<std::string> {
+            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+            bool match( std::string const& matchee ) const override;
+            std::string describe() const override;
+
+        private:
+            std::string m_regex;
+            CaseSensitive::Choice m_caseSensitivity;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_string.h
+// start catch_matchers_vector.h
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const override {
+                for (auto const& el : v) {
+                    if (el == m_comparator) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (auto const& comparator : m_comparator) {
+                    auto present = false;
+                    for (const auto& el : v) {
+                        if (el == comparator) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>> {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+
+            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+            bool match(std::vector<T> const& vec) const override {
+                // Note: This is a reimplementation of std::is_permutation,
+                //       because I don't want to include <algorithm> inside the common path
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
+
+            std::string describe() const override {
+                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+            }
+        private:
+            std::vector<T> const& m_target;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
+        return Vector::ApproxMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
+        return Vector::UnorderedEqualsMatcher<T>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_vector.h
+namespace Catch {
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT const& m_arg;
+        MatcherT m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) },
+            m_arg( arg ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            auto matcherAsString = m_matcher.toString();
+            os << Catch::Detail::stringify( m_arg ) << ' ';
+            if( matcherAsString == Detail::unprintableString )
+                os << m_matcherString;
+            else
+                os << matcherAsString;
+        }
+    };
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    }
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__ ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+// end catch_capture_matchers.h
+#endif
+// start catch_generators.hpp
+
+// start catch_interfaces_generatortracker.h
+
+
+#include <memory>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
+        };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+#include <exception>
+
+namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
+namespace Generators {
+
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
+
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
+    public:
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
+
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
+
+// start catch_context.h
+
+#include <memory>
+
+namespace Catch {
+
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
+
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
+
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
+
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : NonCopyable {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestInvoker;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
+    };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
+
+#ifdef __OBJC__
+// start catch_objc.hpp
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    struct IConfig;
+
+    class TestSpec {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidArgs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void reportInvalidArguments(std::string const&) {}
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved = false;
+    };
+
+    std::ostream& operator << ( std::ostream& os, Colour const& );
+
+} // end namespace Catch
+
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
+
+
+namespace Catch {
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
+
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
+
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
+    };
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
+
+// start catch_xmlwriter.h
+
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        void writeStylesheetRef( std::string const& url );
+
+        XmlWriter& writeBlankLine();
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+// end catch_xmlwriter.h
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
+
+        ~JunitReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& /*spec*/) override;
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEndedCumulative() override;
+
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void noMatchingTestCases(std::string const& s) override;
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_xml.h
+
+// end catch_external_interfaces.h
+#endif
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
+
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
+
+// start catch_benchmark.hpp
+
+ // Benchmark
+
+// start catch_chronometer.hpp
+
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
+
+// Invoke with a special case for void
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+            template <typename Sig>
+            using ResultOf_t = typename std::result_of<Sig>::type;
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
+
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return k; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
+
+ // Execution plan
+
+
+// start catch_benchmark_function.hpp
+
+ // Dumb std::function implementation for consistent call overhead
+
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
+
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
+
+// Run a function for a minimum amount of time
+
+
+// start catch_measure.hpp
+
+// Measure
+
+
+// start catch_timing.hpp
+
+// Timing
+
+
+#include <tuple>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), std::move(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_run_for_at_least.hpp
+#include <algorithm>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
+
+// Statistical analysis tools
+
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
+
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
+
+ // Run and analyse one benchmark
+
+
+// start catch_sample_analysis.hpp
+
+// Benchmark results
+
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
+
+// Constructor and destructor helpers
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+
+                ObjectStorage() : data() {}
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                TStorage data;
+            };
+        }
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
+
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+// start catch_impl.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// Keep these here for external reporters
+// start catch_test_case_tracker.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+    };
+
+    struct ITracker;
+
+    using ITrackerPtr = std::shared_ptr<ITracker>;
+
+    struct ITracker {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( ITrackerPtr const& child ) = 0;
+        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+        void endRun();
+
+        void startCycle();
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        using Children = std::vector<ITrackerPtr>;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        NameAndLocation const& nameAndLocation() const override;
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
+
+        void addChild( ITrackerPtr const& child ) override;
+
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
+
+        void openChild() override;
+
+        bool isSectionTracker() const override;
+        bool isGeneratorTracker() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<std::string> const& filters );
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+// end catch_test_case_tracker.h
+
+// start catch_leak_detector.h
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+namespace Detail {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
+// start catch_debugger.h
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+// end catch_debugger.h
+// start catch_run_context.h
+
+// start catch_fatal_condition.h
+
+// start catch_windows_h_proxy.h
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#  define CATCH_DEFINED_NOMINMAX
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINED_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+// end catch_windows_h_proxy.h
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+        FatalConditionHandler();
+        static void reset();
+        ~FatalConditionHandler();
+
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+} // namespace Catch
+
+#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions[];
+        static stack_t oldSigStack;
+        static char altStackMem[];
+
+        static void handleSignal( int sig );
+
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+        static void reset();
+    };
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset();
+    };
+}
+
+#endif
+
+// end catch_fatal_condition.h
+#include <string>
+
+namespace Catch {
+
+    struct IMutableContext;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
+
+        ~RunContext() override;
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
+
+        Totals runTest(TestCase const& testCase);
+
+        IConfigPtr config() const;
+        IStreamingReporter& reporter() const;
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const final;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Option<AssertionResult> m_lastResult;
+
+        IConfigPtr m_config;
+        Totals m_totals;
+        IStreamingReporterPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+// end catch_run_context.h
+namespace Catch {
+
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
+    }
+
+    LazyExpression::LazyExpression( bool isNegated )
+    :   m_isNegated( isNegated )
+    {}
+
+    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+
+    LazyExpression::operator bool() const {
+        return m_transientExpression != nullptr;
+    }
+
+    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+        if( lazyExpr.m_isNegated )
+            os << "!";
+
+        if( lazyExpr ) {
+            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+                os << "(" << *lazyExpr.m_transientExpression << ")";
+            else
+                os << *lazyExpr.m_transientExpression;
+        }
+        else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+    AssertionHandler::AssertionHandler
+        (   StringRef const& macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {}
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+            throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
+    }
+    void AssertionHandler::setCompleted() {
+        m_completed = true;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+    }
+
+} // namespace Catch
+// end catch_assertionhandler.cpp
+// start catch_assertionresult.cpp
+
+namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
+        else {
+            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+            expr += m_info.macroName;
+            expr += "( ";
+            expr += m_info.capturedExpression;
+            expr += " )";
+        }
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+// end catch_assertionresult.cpp
+// start catch_capture_matchers.cpp
+
+namespace Catch {
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+// end catch_capture_matchers.cpp
+// start catch_commandline.cpp
+
+// start catch_commandline.h
+
+// start catch_clara.h
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
+
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.5
+
+
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+namespace clara {
+namespace TextFlow {
+
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
+
+class Columns;
+
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
+
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
+
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto operator + (Column const& other)->Columns;
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+class Spacer : public Column {
+
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
+
+class Columns {
+	std::vector<Column> m_columns;
+
+public:
+
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
+
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
+
+}
+}
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+#include <cctype>
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+namespace Catch { namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char const* const* argv )
+            : m_exeName(argv[0]),
+              m_args(argv + 1, argv + argc) {}
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+
+            // Errors shouldn't reach this point, but if they do
+            // the actual error message will be in m_errorMessage
+            assert( m_type != ResultBase::LogicError );
+            assert( m_type != ResultBase::RuntimeError );
+            if( m_type != ResultBase::Ok )
+                std::abort();
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+    template<typename T>
+    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+        T temp;
+        auto result = convertInto( source, temp );
+        if( result )
+            target = std::move(temp);
+        return result;
+    }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+}} // namespace Catch::clara
+
+// end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// end catch_clara.h
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+// end catch_commandline.h
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+                auto warningSet = [&]() {
+                    if( warning == "NoAssertions" )
+                        return WarnAbout::NoAssertions;
+
+                    if ( warning == "NoTests" )
+                        return WarnAbout::NoTests;
+
+                    return WarnAbout::Nothing;
+                }();
+
+                if (warningSet == WarnAbout::Nothing)
+                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + line + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = RunTests::InDeclarationOrder;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = RunTests::InLexicographicalOrder;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = RunTests::InRandomOrder;
+                else
+                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed != "time" )
+                    return clara::detail::convertInto( seed, config.rngSeed );
+                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setColourUsage = [&]( std::string const& useColour ) {
+                    auto mode = toLower( useColour );
+
+                    if( mode == "yes" )
+                        config.useColour = UseColour::Yes;
+                    else if( mode == "no" )
+                        config.useColour = UseColour::No;
+                    else if( mode == "auto" )
+                        config.useColour = UseColour::Auto;
+                    else
+                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.listTests )
+                ["-l"]["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["-t"]["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.outputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "output filename" )
+            | Opt( setReporter, "name" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTestNamesOnly )
+                ["--list-test-names-only"]
+                ( "list all/matching test cases names only" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all reporters" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setColourUsage, "yes|no" )
+                ["--use-colour"]
+                ( "should output be colourised" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+// end catch_commandline.cpp
+// start catch_common.cpp
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    std::string StreamEndStop::operator+() const {
+        return std::string();
+    }
+
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}
+// end catch_common.cpp
+// start catch_config.cpp
+
+namespace Catch {
+
+    Config::Config( ConfigData const& data )
+    :   m_data( data ),
+        m_stream( openStream() )
+    {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+    }
+
+    std::string const& Config::getFilename() const {
+        return m_data.outputFilename ;
+    }
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+
+    std::string Config::getProcessName() const { return m_data.processName; }
+    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    std::ostream& Config::stream() const               { return m_stream->stream(); }
+    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    IStream const* Config::openStream() {
+        return Catch::makeStream(m_data.outputFilename);
+    }
+
+} // end namespace Catch
+// end catch_config.cpp
+// start catch_console_colour.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+// start catch_errno_guard.h
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+// end catch_errno_guard.h
+#include <sstream>
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() = default;
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) override {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = UseColour::Yes;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
+        }
+    };
+
+    bool useColourOnPlatform() {
+        return
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+            !isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+            isatty(STDOUT_FILENO)
+#else
+            false
+#endif
+            ;
+    }
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = useColourOnPlatform()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
+    }
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
+        return *this;
+    }
+
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, Colour const& ) {
+        return os;
+    }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_console_colour.cpp
+// start catch_context.cpp
+
+namespace Catch {
+
+    class Context : public IMutableContext, NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+        IRunner* getRunner() override {
+            return m_runner;
+        }
+
+        IConfigPtr const& getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setRunner( IRunner* runner ) override {
+            m_runner = runner;
+        }
+        void setConfig( IConfigPtr const& config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfigPtr m_config;
+        IRunner* m_runner = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
+
+// start catch_debug_console.h
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+// end catch_debug_console.h
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+
+#else
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <assert.h>
+#  include <stdbool.h>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
+
+namespace Catch {
+
+    ITransientExpression::~ITransientExpression() = default;
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << " " << op << " " << rhs;
+        else
+            os << lhs << "\n" << op << "\n" << rhs;
+    }
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
+
+#include <stdexcept>
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
+// start catch_errno_guard.cpp
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
+
+// start catch_exception_translator_registry.h
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry();
+        virtual void registerTranslator( const IExceptionTranslator* translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+    };
+}
+
+// end catch_exception_translator_registry.h
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+    }
+
+    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                return tryTranslators();
+            }
+            @catch (NSException *exception) {
+                return Catch::Detail::stringify( [exception description] );
+            }
+#else
+            // Compiling a mixed mode project with MSVC means that CLR
+            // exceptions will be caught in (...) as well. However, these
+            // do not fill-in std::current_exception and thus lead to crash
+            // when attempting rethrow.
+            // /EHa switch also causes structured exceptions to be caught
+            // here, but they fill-in current_exception properly, so
+            // at worst the output should be a little weird, instead of
+            // causing a crash.
+            if (std::current_exception() == nullptr) {
+                return "Non C++ exception. Possibly a CLR exception.";
+            }
+            return tryTranslators();
+#endif
+        }
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+}
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    // Report the error condition
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+}
+
+#endif // signals/SEH handling
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
+    };
+
+    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        // 32k seems enough for Catch to handle stack overflow,
+        // but the value was found experimentally, so there is no strong guarantee
+        guaranteeSize = 32 * 1024;
+        exceptionHandlerHandle = nullptr;
+        // Register as first handler in current chain
+        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+        // Pass in guarantee size to be filled
+        SetThreadStackGuarantee(&guaranteeSize);
+    }
+
+    void FatalConditionHandler::reset() {
+        if (isSet) {
+            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+            SetThreadStackGuarantee(&guaranteeSize);
+            exceptionHandlerHandle = nullptr;
+            isSet = false;
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+bool FatalConditionHandler::isSet = false;
+ULONG FatalConditionHandler::guaranteeSize = 0;
+PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+
+} // namespace Catch
+
+#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    // 32kb for the alternate stack seems to be sufficient. However, this value
+    // is experimentally determined, so that's not guaranteed.
+    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    void FatalConditionHandler::handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        reset();
+        reportFatal(name);
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = sigStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+    void FatalConditionHandler::reset() {
+        if( isSet ) {
+            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+            }
+            // Return the old stack
+            sigaltstack(&oldSigStack, nullptr);
+            isSet = false;
+        }
+    }
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[sigStackSize] = {};
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    void FatalConditionHandler::reset() {}
+}
+
+#endif // signals/SEH handling
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
+// start catch_interfaces_capture.cpp
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
+
+// start catch_reporter_listening.h
+
+namespace Catch {
+
+    class ListeningReporter : public IStreamingReporter {
+        using Reporters = std::vector<IStreamingReporterPtr>;
+        Reporters m_listeners;
+        IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
+
+    public:
+        ListeningReporter();
+
+        void addListener( IStreamingReporterPtr&& listener );
+        void addReporter( IStreamingReporterPtr&& reporter );
+
+    public: // IStreamingReporter
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases( std::string const& spec ) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        // The return value indicates if the messages buffer should be cleared:
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_listening.h
+namespace Catch {
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+    std::ostream& ReporterConfig::stream() const { return *m_stream; }
+    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+
+    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+
+    GroupInfo::GroupInfo(  std::string const& _name,
+                           std::size_t _groupIndex,
+                           std::size_t _groupsCount )
+    :   name( _name ),
+        groupIndex( _groupIndex ),
+        groupsCounts( _groupsCount )
+    {}
+
+     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                     std::vector<MessageInfo> const& _infoMessages,
+                                     Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
+    {
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
+
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder << assertionResult.getMessage();
+            builder.m_info.message = builder.m_stream.str();
+
+            infoMessages.push_back( builder.m_info );
+        }
+    }
+
+     AssertionStats::~AssertionStats() = default;
+
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+    SectionStats::~SectionStats() = default;
+
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string const& _stdOut,
+                                   std::string const& _stdErr,
+                                   bool _aborting )
+    : testInfo( _testInfo ),
+        totals( _totals ),
+        stdOut( _stdOut ),
+        stdErr( _stdErr ),
+        aborting( _aborting )
+    {}
+
+    TestCaseStats::~TestCaseStats() = default;
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+                                    Totals const& _totals,
+                                    bool _aborting )
+    :   groupInfo( _groupInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+    :   groupInfo( _groupInfo ),
+        aborting( false )
+    {}
+
+    TestGroupStats::~TestGroupStats() = default;
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestRunStats::~TestRunStats() = default;
+
+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+    bool IStreamingReporter::isMulti() const { return false; }
+
+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
+
+} // end namespace Catch
+// end catch_interfaces_reporter.cpp
+// start catch_interfaces_runner.cpp
+
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+}
+
+#else
+
+    Catch::LeakDetector::LeakDetector() {}
+
+#endif
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
+
+// start catch_list.h
+
+#include <set>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config );
+
+    std::size_t listTestsNamesOnly( Config const& config );
+
+    struct TagInfo {
+        void add( std::string const& spelling );
+        std::string all() const;
+
+        std::set<std::string> spellings;
+        std::size_t count = 0;
+    };
+
+    std::size_t listTags( Config const& config );
+
+    std::size_t listReporters();
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
+
+} // end namespace Catch
+
+// end catch_list.h
+// start catch_text.h
+
+namespace Catch {
+    using namespace clara::TextFlow;
+}
+
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+        }
+
+        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+            if( config.verbosity() >= Verbosity::High ) {
+                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Column( description ).indent(4) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+        }
+
+        if( !config.hasTestFilters() )
+            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+        return matchedTestCases.size();
+    }
+
+    std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            matchedTests++;
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.verbosity() >= Verbosity::High )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    void TagInfo::add( std::string const& spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    std::size_t listTags( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCase : matchedTestCases ) {
+            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+                std::string lcaseTagName = toLower( tagName );
+                auto countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( auto const& tagCount : tagCounts ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+            auto str = rss.str();
+            auto wrapper = Column( tagCount.second.all() )
+                                                    .initialIndent( 0 )
+                                                    .indent( str.size() )
+                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+            Catch::cout() << str << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    std::size_t listReporters() {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        std::size_t maxNameLen = 0;
+        for( auto const& factoryKvp : factories )
+            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+        for( auto const& factoryKvp : factories ) {
+            Catch::cout()
+                    << Column( factoryKvp.first + ":" )
+                            .indent(2)
+                            .width( 5+maxNameLen )
+                    +  Column( factoryKvp.second->getDescription() )
+                            .initialIndent(0)
+                            .indent(2)
+                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+                    << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
+        Option<std::size_t> listedCount;
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
+        return listedCount;
+    }
+
+} // end namespace Catch
+// end catch_list.cpp
+// start catch_matchers.cpp
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        std::string MatcherUntypedBase::toString() const {
+            if( m_cachedToString.empty() )
+                m_cachedToString = describe();
+            return m_cachedToString;
+        }
+
+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+    } // namespace Impl
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+// end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
+// start catch_matchers_floating.cpp
+
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+// end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
+
+namespace Catch {
+namespace {
+
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
+        std::memcpy(&i, &f, sizeof(f));
+        return i;
+    }
+
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
+        std::memcpy(&i, &d, sizeof(d));
+        return i;
+    }
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+}// namespace Floating
+
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+}
+
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+}
+
+Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+    return Floating::WithinAbsMatcher(target, margin);
+}
+
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.cpp
+// start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+        bool RegexMatcher::match(std::string const& matchee) const {
+            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+            if (m_caseSensitivity == CaseSensitive::Choice::No) {
+                flags |= std::regex::icase;
+            }
+            auto reg = std::regex(m_regex, flags);
+            return std::regex_match(matchee, reg);
+        }
+
+        std::string RegexMatcher::describe() const {
+            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+        return StdString::RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_string.cpp
+// start catch_message.cpp
+
+// start catch_uncaught_exceptions.h
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+// end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    bool MessageInfo::operator==( MessageInfo const& other ) const {
+        return sequence == other.sequence;
+    }
+
+    bool MessageInfo::operator<( MessageInfo const& other ) const {
+        return sequence < other.sequence;
+    }
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+                                           SourceLineInfo const& lineInfo,
+                                           ResultWas::OfType type )
+        :m_info(macroName, lineInfo, type) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info ), m_moved()
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(names[start])) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(names[end])) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+// end catch_message.cpp
+// start catch_output_redirect.cpp
+
+// start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+    class RedirectedStream {
+        std::ostream& m_originalStream;
+        std::ostream& m_redirectionStream;
+        std::streambuf* m_prevBuf;
+
+    public:
+        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+        ~RedirectedStream();
+    };
+
+    class RedirectedStdOut {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cout;
+    public:
+        RedirectedStdOut();
+        auto str() const -> std::string;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes
+    class RedirectedStdErr {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cerr;
+        RedirectedStream m_clog;
+    public:
+        RedirectedStdErr();
+        auto str() const -> std::string;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+    // Windows's implementation of std::tmpfile is terrible (it tries
+    // to create a file inside system folder, thus requiring elevated
+    // privileges for the binary), so we have to use tmpnam(_s) and
+    // create the file ourselves there.
+    class TempFile {
+    public:
+        TempFile(TempFile const&) = delete;
+        TempFile& operator=(TempFile const&) = delete;
+        TempFile(TempFile&&) = delete;
+        TempFile& operator=(TempFile&&) = delete;
+
+        TempFile();
+        ~TempFile();
+
+        std::FILE* getFile();
+        std::string getContents();
+
+    private:
+        std::FILE* m_file = nullptr;
+    #if defined(_MSC_VER)
+        char m_buffer[L_tmpnam] = { 0 };
+    #endif
+    };
+
+    class OutputRedirect {
+    public:
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+        ~OutputRedirect();
+
+    private:
+        int m_originalStdout = -1;
+        int m_originalStderr = -1;
+        TempFile m_stdoutFile;
+        TempFile m_stderrFile;
+        std::string& m_stdoutDest;
+        std::string& m_stderrDest;
+    };
+
+#endif
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+// end catch_output_redirect.h
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
+#endif
+
+namespace Catch {
+
+    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }
+
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }
+
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStdErr::RedirectedStdErr()
+    :   m_cerr( Catch::cerr(), m_rss.get() ),
+        m_clog( Catch::clog(), m_rss.get() )
+    {}
+    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+    TempFile::TempFile() {
+        if (tmpnam_s(m_buffer)) {
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+        }
+        if (fopen_s(&m_file, m_buffer, "w")) {
+            char buffer[100];
+            if (strerror_s(buffer, errno)) {
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            }
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+        }
+    }
+#else
+    TempFile::TempFile() {
+        m_file = std::tmpfile();
+        if (!m_file) {
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+        }
+    }
+
+#endif
+
+    TempFile::~TempFile() {
+         // TBD: What to do about errors here?
+         std::fclose(m_file);
+         // We manually create the file on Windows only, on Linux
+         // it will be autodeleted
+#if defined(_MSC_VER)
+         std::remove(m_buffer);
+#endif
+    }
+
+    FILE* TempFile::getFile() {
+        return m_file;
+    }
+
+    std::string TempFile::getContents() {
+        std::stringstream sstr;
+        char buffer[100] = {};
+        std::rewind(m_file);
+        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            sstr << buffer;
+        }
+        return sstr.str();
+    }
+
+    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+        m_originalStdout(dup(1)),
+        m_originalStderr(dup(2)),
+        m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest) {
+        dup2(fileno(m_stdoutFile.getFile()), 1);
+        dup2(fileno(m_stderrFile.getFile()), 2);
+    }
+
+    OutputRedirect::~OutputRedirect() {
+        Catch::cout() << std::flush;
+        fflush(stdout);
+        // Since we support overriding these streams, we flush cerr
+        // even though std::cerr is unbuffered
+        Catch::cerr() << std::flush;
+        Catch::clog() << std::flush;
+        fflush(stderr);
+
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);
+
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
+#endif
+// end catch_output_redirect.cpp
+// start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+    class TestCase;
+    struct IConfig;
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        virtual ~TestRegistry() = default;
+
+        virtual void registerTest( TestCase const& testCase );
+
+        std::vector<TestCase> const& getAllTests() const override;
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        std::size_t m_unnamedCount = 0;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction : public ITestInvoker {
+        void(*m_testAsFunction)();
+    public:
+        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+        void invoke() const override;
+    };
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+// end catch_test_case_registry_impl.h
+// start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias_registry.h
+// start catch_startup_exception_registry.h
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+    };
+
+} // end namespace Catch
+
+// end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+                            private NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            IReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            void registerListener( IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerListener( factory );
+            }
+            void registerTest( TestCase const& testInfo ) override {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            void registerTranslator( const IExceptionTranslator* translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+                m_exceptionRegistry.add(std::current_exception());
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+// end catch_registry_hub.cpp
+// start catch_reporter_registry.cpp
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+// end catch_result_type.cpp
+// start catch_run_context.cpp
+
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                }
+                else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // Generator interface only finds out if it has another item on atual move
+                if (m_runState == CompletedSuccessfully && m_generator->next()) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
+    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(std::move(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setRunner(this);
+        m_context.setConfig(m_config);
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+    }
+
+    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCase const& testCase) {
+        Totals prevTotals = m_totals;
+
+        std::string redirectedCout;
+        std::string redirectedCerr;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+
+        m_reporter->testCaseStarting(testInfo);
+
+        m_activeTestCase = &testCase;
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+            runCurrentTest(redirectedCout, redirectedCerr);
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  redirectedCout,
+                                  redirectedCerr,
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+    IConfigPtr RunContext::config() const {
+        return m_config;
+    }
+
+    IStreamingReporter& RunContext::reporter() const {
+        return *m_reporter;
+    }
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.isOk()) {
+            m_lastAssertionPassed = false;
+            if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+        // and should be let to clear themselves out.
+        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // Reset working state
+        resetAssertionInfo();
+        m_lastResult = result;
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+    }
+
+    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        m_reporter->sectionStarting(sectionInfo);
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
+        assert( tracker.isOpen() );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+        if (m_unfinishedSections.empty())
+            m_activeSections.back()->fail();
+        else
+            m_activeSections.back()->close();
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(endInfo);
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+		m_reporter->benchmarkPreparing(name);
+	}
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+	void RunContext::benchmarkFailed(std::string const & error) {
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered(message);
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, tempResult);
+
+        assertionEnded(result);
+
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+        m_reporter->sectionEnded(testCaseSectionStats);
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        testGroupEnded(std::string(), m_totals, 1, 1);
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        seedRng(*m_config);
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#else
+                OutputRedirect r(redirectedCout, redirectedCerr);
+                timer.start();
+                invokeActiveTestCase();
+#endif
+            } else {
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        FatalConditionHandler fatalConditionHandler; // Handle signals
+        m_activeTestCase->invoke();
+        fatalConditionHandler.reset();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for (auto it = m_unfinishedSections.rbegin(),
+             itEnd = m_unfinishedSections.rend();
+             it != itEnd;
+             ++it)
+            sectionEnded(*it);
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, data };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( assertionResult );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            StringRef const& message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(message);
+        AssertionResult assertionResult{ m_lastAssertionInfo, data };
+        assertionEnded( assertionResult );
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string const& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = message;
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+        populateReaction( reaction );
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+            if( uncaught_exceptions() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+// end catch_section.cpp
+// start catch_section_info.cpp
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name )
+    :   name( _name ),
+        lineInfo( _lineInfo )
+    {}
+
+} // end namespace Catch
+// end catch_section_info.cpp
+// start catch_session.cpp
+
+// start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+// end catch_session.h
+// start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+#include <set>
+#include <iterator>
+
+namespace Catch {
+
+    namespace {
+        const int MaxExitCode = 255;
+
+        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+            return reporter;
+        }
+
+        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+                return createReporter(config->getReporterName(), config);
+            }
+
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
+            }
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
+                }
+            }
+
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
+                }
+
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
+            }
+
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
+
+        void applyFilenamesAsTags(Catch::IConfig const& config) {
+            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+            for (auto& testCase : tests) {
+                auto tags = testCase.tags;
+
+                std::string filename = testCase.lineInfo.file;
+                auto lastSlash = filename.find_last_of("\\/");
+                if (lastSlash != std::string::npos) {
+                    filename.erase(0, lastSlash);
+                    filename[0] = '#';
+                }
+
+                auto lastDot = filename.find_last_of('.');
+                if (lastDot != std::string::npos) {
+                    filename.erase(lastDot);
+                }
+
+                tags.push_back(std::move(filename));
+                setTags(testCase, tags);
+            }
+        }
+
+    } // anon namespace
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        }
+
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
+            m_startupExceptions = true;
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
+
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if( m_startupExceptions )
+            return 1;
+
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( m_config ) )
+                return static_cast<int>( *listed );
+
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+// end catch_session.cpp
+// start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
+// start catch_startup_exception_registry.cpp
+
+namespace Catch {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+
+} // end namespace Catch
+// end catch_startup_exception_registry.cpp
+// start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+    namespace Detail { namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
+            }
+
+            ~StreamBufImpl() noexcept {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        struct OutputDebugWriter {
+
+            void operator()( std::string const&str ) {
+                writeToDebugConsole( str );
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream : public IStream {
+            mutable std::ofstream m_ofs;
+        public:
+            FileStream( StringRef filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
+            }
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() const override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream : public IStream {
+            mutable std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+            ~CoutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            mutable std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+    }} // namespace anon::detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( StringRef const &filename ) -> IStream const* {
+        if( filename.empty() )
+            return new Detail::CoutStream();
+        else if( filename[0] == '%' ) {
+            if( filename == "%debug" )
+                return new Detail::DebugOutStream();
+            else
+                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+        }
+        else
+            return new Detail::FileStream( filename );
+    }
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
+        }
+    };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    auto ReusableStringStream::str() const -> std::string {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+}
+// end catch_stream.cpp
+// start catch_string_manip.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+    {}
+
+    auto StringRef::c_str() const -> char const* {
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
+        return m_start;
+    }
+    auto StringRef::data() const noexcept -> char const* {
+        return m_start;
+    }
+
+    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
+            return StringRef();
+        }
+    }
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+        return os.write(str.data(), str.size());
+    }
+
+    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+// end catch_stringref.cpp
+// start catch_tag_alias.cpp
+
+namespace Catch {
+    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+// end catch_tag_alias_registry.cpp
+// start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+    }
+
+    TestCase makeTestCase(  ITestInvoker* _testCase,
+                            std::string const& _className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden = false;
+
+        // Parse out tags
+        std::vector<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for (char c : nameAndTags.tags) {
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
+                    tags.push_back( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
+        }
+
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, std::move(info) );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+        testCaseInfo.lcaseTags.clear();
+
+        for( auto const& tag : tags ) {
+            std::string lcaseTag = toLower( tag );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.push_back( lcaseTag );
+        }
+        testCaseInfo.tags = std::move(tags);
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::vector<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret.append(tag);
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+// end catch_test_case_info.cpp
+// start catch_test_case_registry_impl.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                seedRng( config );
+                std::shuffle( sorted.begin(), sorted.end(), rng() );
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( auto const& function : functions ) {
+            auto prev = seenFunctions.insert( function );
+            CATCH_ENFORCE( prev.second,
+                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest( TestCase const& testCase ) {
+        std::string name = testCase.getTestCaseInfo().name;
+        if( name.empty() ) {
+            ReusableStringStream rss;
+            rss << "Anonymous test case " << ++m_unnamedCount;
+            return registerTest( testCase.withName( rss.str() ) );
+        }
+        m_functions.push_back( testCase );
+    }
+
+    std::vector<TestCase> const& TestRegistry::getAllTests() const {
+        return m_functions;
+    }
+    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_functions );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_functions );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+        std::string className(classOrQualifiedMethodName);
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+} // end namespace Catch
+// end catch_test_case_registry_impl.cpp
+// start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+    :   name( _name ),
+        location( _location )
+    {}
+
+    ITracker::~ITracker() = default;
+
+    ITracker& TrackerContext::startRun() {
+        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::endRun() {
+        m_rootTracker.reset();
+        m_currentTracker = nullptr;
+        m_runState = NotStarted;
+    }
+
+    void TrackerContext::startCycle() {
+        m_currentTracker = m_rootTracker.get();
+        m_runState = Executing;
+    }
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    ITracker& TrackerContext::currentTracker() {
+        return *m_currentTracker;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   m_nameAndLocation( nameAndLocation ),
+        m_ctx( ctx ),
+        m_parent( parent )
+    {}
+
+    NameAndLocation const& TrackerBase::nameAndLocation() const {
+        return m_nameAndLocation;
+    }
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+    bool TrackerBase::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+    bool TrackerBase::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+    bool TrackerBase::hasChildren() const {
+        return !m_children.empty();
+    }
+
+    void TrackerBase::addChild( ITrackerPtr const& child ) {
+        m_children.push_back( child );
+    }
+
+    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
+        return( it != m_children.end() )
+            ? *it
+            : nullptr;
+    }
+    ITracker& TrackerBase::parent() {
+        assert( m_parent ); // Should always be non-null except for root
+        return *m_parent;
+    }
+
+    void TrackerBase::openChild() {
+        if( m_runState != ExecutingChildren ) {
+            m_runState = ExecutingChildren;
+            if( m_parent )
+                m_parent->openChild();
+        }
+    }
+
+    bool TrackerBase::isSectionTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = &parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if ((m_filters.empty() || m_filters[0] == "")
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        std::shared_ptr<SectionTracker> section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = std::static_pointer_cast<SectionTracker>( childTracker );
+        }
+        else {
+            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+            currentTracker.addChild( section );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+// end catch_test_case_tracker.cpp
+// start catch_test_registry.cpp
+
+namespace Catch {
+
+    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+    }
+
+    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCase(
+                            invoker,
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo));
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+    AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find(begin(testCase.lcaseTags),
+                         end(testCase.lcaseTags),
+                         m_tag) != end(testCase.lcaseTags);
+    }
+
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
+    }
+
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return m_testSpec;
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_patterns.empty() ) {
+            m_testSpec.m_filters.push_back( m_currentFilter );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+// end catch_test_spec_parser.cpp
+// start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+    }
+
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
+
+            auto startTime = getCurrentNanosecondsSinceEpoch();
+
+            for( std::size_t i = 0; i < iterations; ++i ) {
+
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
+
+                auto delta = ticks - baseTicks;
+                sum += delta;
+
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
+            }
+
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
+    }
+    auto getEstimatedClockResolution() -> uint64_t {
+        static auto s_resolution = estimateClockResolution();
+        return s_resolution;
+    }
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+// end catch_timer.cpp
+// start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+// Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    if (Catch::isnan(value)) {
+        return "nan";
+    }
+
+    ReusableStringStream rss;
+    rss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = rss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    if (!getCurrentContext().getConfig()->showInvisibles()) {
+        return '"' + str + '"';
+    }
+
+    std::string s("\"");
+    for (char c : str) {
+        switch (c) {
+        case '\n':
+            s.append("\\n");
+            break;
+        case '\t':
+            s.append("\\t");
+            break;
+        default:
+            s.push_back(c);
+            break;
+        }
+    }
+    s.append("\"");
+    return s;
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<bool>::convert(bool b) {
+    return b ? "true" : "false";
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
+}
+
+std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+    return "nullptr";
+}
+
+int StringMaker<float>::precision = 5;
+
+std::string StringMaker<float>::convert(float value) {
+    return fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = 10;
+
+std::string StringMaker<double>::convert(double value) {
+    return fpToString(value, precision);
+}
+
+std::string ratio_string<std::atto>::symbol() { return "a"; }
+std::string ratio_string<std::femto>::symbol() { return "f"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::micro>::symbol() { return "u"; }
+std::string ratio_string<std::milli>::symbol() { return "m"; }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_tostring.cpp
+// start catch_totals.cpp
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        return *this;
+    }
+
+    std::size_t Counts::total() const {
+        return passed + failed + failedButOk;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+// end catch_uncaught_exceptions.cpp
+// start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 2, 11, 3, "", 0 );
+        return version;
+    }
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive::Choice caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = m_str[idx];
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = m_str[idx + n];
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( std::string const& url ) {
+        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+    }
+
+    XmlWriter& XmlWriter::writeBlankLine() {
+        ensureTagClosed();
+        m_os << '\n';
+        return *this;
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << std::endl;
+            m_needsNewline = false;
+        }
+    }
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result) {
+        result.getExpandedExpression();
+    }
+
+    // Because formatting using c++ streams is stateful, drop down to C is required
+    // Alternatively we could use stringstream, but its performance is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
+
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        sprintf_s(buffer, "%.3f", duration);
+#else
+        std::sprintf(buffer, "%.3f", duration);
+#endif
+        return std::string(buffer);
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
+    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+        :StreamingReporterBase(_config) {}
+
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
+
+    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+
+    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+        return false;
+    }
+
+} // end namespace Catch
+// end catch_reporter_bases.cpp
+// start catch_reporter_compact.cpp
+
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+    const char* failedString() { return "FAILED"; }
+    const char* passedString() { return "PASSED"; }
+#else
+    const char* failedString() { return "failed"; }
+    const char* passedString() { return "passed"; }
+#endif
+
+    // Colour::LightGrey
+    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+
+    std::string bothOrAll( std::size_t count ) {
+        return count == 1 ? std::string() :
+               count == 2 ? "both " : "all " ;
+    }
+
+} // anon namespace
+
+namespace Catch {
+namespace {
+// Colour, message variants:
+// - white: No tests ran.
+// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+// - white: Passed [both/all] N test cases (no assertions).
+// -   red: Failed N tests cases, failed M assertions.
+// - green: Passed [both/all] N tests cases with M assertions.
+void printTotals(std::ostream& out, const Totals& totals) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour colour(Colour::ResultError);
+        const std::string qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : std::string();
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion") << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case")
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        Colour colour(Colour::ResultError);
+        out <<
+            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+    } else {
+        Colour colour(Colour::ResultSuccess);
+        out <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") <<
+            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+    }
+}
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages) {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, passedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+            else
+                printResultType(Colour::Error, failedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, failedString());
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, failedString());
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, failedString());
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, failedString());
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+        if (!passOrFail.empty()) {
+            {
+                Colour colourGuard(colour);
+                stream << ' ' << passOrFail;
+            }
+            stream << ':';
+        }
+    }
+
+    void printIssue(std::string const& issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                Colour colour(dimColour());
+                stream << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            {
+                Colour colour(dimColour());
+                stream << " for: ";
+            }
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = dimColour()) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        {
+            Colour colourGuard(colour);
+            stream << " with " << pluralise(N, "message") << ':';
+        }
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    Colour colourGuard(dimColour());
+                    stream << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        ReporterPreferences CompactReporter::getPreferences() const {
+            return m_reporterPrefs;
+        }
+
+        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
+
+        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( stream, _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() {}
+
+    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+// end catch_reporter_compact.cpp
+// start catch_reporter_console.cpp
+
+#include <cfloat>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED";
+            //if( result.hasMessage() )
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok";
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED";
+            }
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to unexpected exception with ";
+            if (_stats.infoMessages.size() == 1)
+                messageLabel += "message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel += "messages";
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "because no exception was thrown where one was expected";
+            break;
+        case ResultWas::Info:
+            messageLabel = "info";
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning";
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED";
+            colour = Colour::Error;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "explicitly with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "explicitly with messages";
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **";
+            colour = Colour::Error;
+            break;
+        }
+    }
+
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
+        }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            Colour colourGuard(colour);
+            stream << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            Colour colourGuard(Colour::OriginalExpression);
+            stream << "  ";
+            stream << result.getExpressionInMacro();
+            stream << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            Colour colourGuard(Colour::ReconstructedExpression);
+            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    std::string passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio(std::size_t number, std::size_t total) {
+    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : ratio;
+}
+
+std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+    if (i > j && i > k)
+        return i;
+    else if (j > k)
+        return j;
+    else
+        return k;
+}
+
+struct ColumnInfo {
+    enum Justification { Left, Right };
+    std::string name;
+    int width;
+    Justification justification;
+};
+struct ColumnBreak {};
+struct RowBreak {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
+    };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    auto unitsAsString() const -> std::string {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns";
+        case Unit::Microseconds:
+            return "us";
+        case Unit::Milliseconds:
+            return "ms";
+        case Unit::Seconds:
+            return "s";
+        case Unit::Minutes:
+            return "m";
+        default:
+            return "** internal error **";
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    std::ostringstream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( std::move( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << std::endl;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == ColumnInfo::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+    : StreamingReporterBase(config),
+    m_tablePrinter(new TablePrinter(config.stream(),
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+}
+
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+        return false;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+    printer.print();
+    stream << std::endl;
+    return true;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        Colour colour(Colour::ResultError);
+        if (m_sectionStack.size() > 1)
+            stream << "\nNo assertions in section";
+        else
+            stream << "\nNo assertions in test case";
+        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+    }
+    if (m_config->showDurations() == ShowDurations::Always) {
+        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+    if (currentGroupInfo.used) {
+        printSummaryDivider();
+        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+        printTotals(_testGroupStats.totals);
+        stream << '\n' << std::endl;
+    }
+    StreamingReporterBase::testGroupEnded(_testGroupStats);
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    stream << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if (!currentTestRunInfo.used)
+        lazyPrintRunInfo();
+    if (!currentGroupInfo.used)
+        lazyPrintGroupInfo();
+
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    stream << '\n' << getLineOfChars<'~'>() << '\n';
+    Colour colour(Colour::SecondaryText);
+    stream << currentTestRunInfo->name
+        << " is a Catch v" << libraryVersion() << " host application.\n"
+        << "Run with -? for options\n\n";
+
+    if (m_config->rngSeed() != 0)
+        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+    currentTestRunInfo.used = true;
+}
+void ConsoleReporter::lazyPrintGroupInfo() {
+    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+        printClosedHeader("Group: " + currentGroupInfo->name);
+        currentGroupInfo.used = true;
+    }
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        Colour colourGuard(Colour::Headers);
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
+    stream << getLineOfChars<'.'>() << '\n' << std::endl;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    stream << getLineOfChars<'.'>() << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    stream << getLineOfChars<'-'>() << '\n';
+    {
+        Colour colourGuard(Colour::Headers);
+        printHeaderString(_name);
+    }
+}
+
+// if string has a : in first line will set indent to follow it on
+// subsequent lines
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    std::size_t i = _string.find(": ");
+    if (i != std::string::npos)
+        i += 2;
+    else
+        i = 0;
+    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( std::move( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::size_t count ) {
+        ReusableStringStream rss;
+        rss << count;
+        std::string row = rss.str();
+        for (auto& oldRow : rows) {
+            while (oldRow.size() < row.size())
+                oldRow = ' ' + oldRow;
+            while (oldRow.size() > row.size())
+                row = ' ' + row;
+        }
+        rows.push_back(row);
+        return *this;
+    }
+
+    std::string label;
+    Colour::Code colour;
+    std::vector<std::string> rows;
+
+};
+
+void ConsoleReporter::printTotals( Totals const& totals ) {
+    if (totals.testCases.total() == 0) {
+        stream << Colour(Colour::Warning) << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        stream << Colour(Colour::ResultSuccess) << "All tests passed";
+        stream << " ("
+            << pluralise(totals.assertions.passed, "assertion") << " in "
+            << pluralise(totals.testCases.passed, "test case") << ')'
+            << '\n';
+    } else {
+
+        std::vector<SummaryColumn> columns;
+        columns.push_back(SummaryColumn("", Colour::None)
+                          .addRow(totals.testCases.total())
+                          .addRow(totals.assertions.total()));
+        columns.push_back(SummaryColumn("passed", Colour::Success)
+                          .addRow(totals.testCases.passed)
+                          .addRow(totals.assertions.passed));
+        columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                          .addRow(totals.testCases.failed)
+                          .addRow(totals.assertions.failed));
+        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                          .addRow(totals.testCases.failedButOk)
+                          .addRow(totals.assertions.failedButOk));
+
+        printSummaryRow("test cases", columns, 0);
+        printSummaryRow("assertions", columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string value = col.rows[row];
+        if (col.label.empty()) {
+            stream << label << ": ";
+            if (value != "0")
+                stream << value;
+            else
+                stream << Colour(Colour::Warning) << "- none -";
+        } else if (value != "0") {
+            stream << Colour(Colour::LightGrey) << " | ";
+            stream << Colour(col.colour)
+                << value << ' ' << col.label;
+        }
+    }
+    stream << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+        if (totals.testCases.allPassed())
+            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+        else
+            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    } else {
+        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+    }
+    stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    stream << getLineOfChars<'-'>() << '\n';
+}
+
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
+CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+// end catch_reporter_console.cpp
+// start catch_reporter_junit.cpp
+
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+        std::string fileNameTag(const std::vector<std::string> &tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (std::string const& tag) {return tag.front() == '#'; });
+            if (it != tags.end())
+                return it->substr(1);
+            return std::string();
+        }
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+    JunitReporter::~JunitReporter() {}
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+    }
+
+    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+        CumulativeReporterBase::testGroupStarting( groupInfo );
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        return CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        double suiteTime = suiteTimer.getElapsedSeconds();
+        CumulativeReporterBase::testGroupEnded( testGroupStats );
+        writeGroup( *m_testGroups.back(), suiteTime );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        xml.endElement();
+    }
+
+    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestGroupStats const& stats = groupNode.value;
+        xml.writeAttribute( "name", stats.groupInfo.name );
+        xml.writeAttribute( "errors", unexpectedExceptions );
+        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests", stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname", "tbd" ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time", "" );
+        else
+            xml.writeAttribute( "time", suiteTime );
+        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : groupNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className = stats.testInfo.className;
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo.tags);
+            if ( className.empty() )
+                className = "global";
+        }
+
+        if ( !m_config->name().empty() )
+            className = m_config->name() + "." + className;
+
+        writeSection( className, "", rootSection );
+    }
+
+    void JunitReporter::writeSection(  std::string const& className,
+                        std::string const& rootName,
+                        SectionNode const& sectionNode ) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( !sectionNode.assertions.empty() ||
+            !sectionNode.stdOut.empty() ||
+            !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname", name );
+                xml.writeAttribute( "name", "root" );
+            }
+            else {
+                xml.writeAttribute( "classname", className );
+                xml.writeAttribute( "name", name );
+            }
+            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+
+            writeAssertions( sectionNode );
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode );
+            else
+                writeSection( className, name, *childNode );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for( auto const& assertion : sectionNode.assertions )
+            writeAssertion( assertion );
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if( !result.isOk() ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message", result.getExpression() );
+            xml.writeAttribute( "type", result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            if( !result.getMessage().empty() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+// end catch_reporter_junit.cpp
+// start catch_reporter_listening.cpp
+
+#include <cassert>
+
+namespace Catch {
+
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+        m_listeners.push_back( std::move( listener ) );
+    }
+
+    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+        m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    }
+
+    ReporterPreferences ListeningReporter::getPreferences() const {
+        return m_preferences;
+    }
+
+    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+        return std::set<Verbosity>{ };
+    }
+
+    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->noMatchingTestCases( spec );
+        }
+        m_reporter->noMatchingTestCases( spec );
+    }
+
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
+    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkStarting( benchmarkInfo );
+        }
+        m_reporter->benchmarkStarting( benchmarkInfo );
+    }
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkEnded( benchmarkStats );
+        }
+        m_reporter->benchmarkEnded( benchmarkStats );
+    }
+
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunStarting( testRunInfo );
+        }
+        m_reporter->testRunStarting( testRunInfo );
+    }
+
+    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupStarting( groupInfo );
+        }
+        m_reporter->testGroupStarting( groupInfo );
+    }
+
+    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseStarting( testInfo );
+        }
+        m_reporter->testCaseStarting( testInfo );
+    }
+
+    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionStarting( sectionInfo );
+        }
+        m_reporter->sectionStarting( sectionInfo );
+    }
+
+    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->assertionStarting( assertionInfo );
+        }
+        m_reporter->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        for( auto const& listener : m_listeners ) {
+            static_cast<void>( listener->assertionEnded( assertionStats ) );
+        }
+        return m_reporter->assertionEnded( assertionStats );
+    }
+
+    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionEnded( sectionStats );
+        }
+        m_reporter->sectionEnded( sectionStats );
+    }
+
+    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseEnded( testCaseStats );
+        }
+        m_reporter->testCaseEnded( testCaseStats );
+    }
+
+    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupEnded( testGroupStats );
+        }
+        m_reporter->testGroupEnded( testGroupStats );
+    }
+
+    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunEnded( testRunStats );
+        }
+        m_reporter->testRunEnded( testRunStats );
+    }
+
+    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->skipTest( testInfo );
+        }
+        m_reporter->skipTest( testInfo );
+    }
+
+    bool ListeningReporter::isMulti() const {
+        return true;
+    }
+
+} // end namespace Catch
+// end catch_reporter_listening.cpp
+// start catch_reporter_xml.cpp
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig const& _config )
+    :   StreamingReporterBase( _config ),
+        m_xml(_config.stream())
+    {
+        m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename", sourceInfo.file )
+            .writeAttribute( "line", sourceInfo.line );
+    }
+
+    void XmlReporter::noMatchingTestCases( std::string const& s ) {
+        StreamingReporterBase::noMatchingTestCases( s );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement( "Catch" );
+        if( !m_config->name().empty() )
+            m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
+    }
+
+    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        StreamingReporterBase::testGroupStarting( groupInfo );
+        m_xml.startElement( "Group" )
+            .writeAttribute( "name", groupInfo.name );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name", trim( testInfo.name ) )
+            .writeAttribute( "description", testInfo.description )
+            .writeAttribute( "tags", testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name", trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    m_xml.scopedElement( "Info" )
+                            .writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    m_xml.scopedElement( "Warning" )
+                            .writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if( !includeResults && result.getResultType() != ResultWas::Warning )
+            return true;
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success", result.succeeded() )
+                .writeAttribute( "type", result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                    .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+
+        return true;
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes", sectionStats.assertions.passed );
+            e.writeAttribute( "failures", sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        StreamingReporterBase::testGroupEnded( testGroupStats );
+        // TODO: Check testGroupStats.aborting and act accordingly.
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+// end catch_reporter_xml.cpp
+
+namespace Catch {
+    LeakDetector leakDetector;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_impl.hpp
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// start catch_default_main.hpp
+
+#ifndef __OBJC__
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char**)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+// end catch_default_main.hpp
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
+
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+using Catch::Detail::Approx;
+
+#else // CATCH_CONFIG_DISABLE
+
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... )        (void)(0)
+#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CATCH_CHECK( ... )         (void)(0)
+#define CATCH_CHECK_FALSE( ... )   (void)(0)
+#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+#define CATCH_CHECK_THROWS( ... )  (void)(0)
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CHECK( ... ) (void)(0)
+#define CHECK_FALSE( ... ) (void)(0)
+#define CHECKED_IF( ... ) if (__VA_ARGS__)
+#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL( ... ) (void)(0)
+
+#define CHECK_THROWS( ... )  (void)(0)
+#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+
+#define GIVEN( desc )
+#define AND_GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+// start catch_reenable_warnings.h
+
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+// end catch_reenable_warnings.h
+// end catch.hpp
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/test/catch2/catch_reporter_automake.hpp b/test/catch2/catch_reporter_automake.hpp
new file mode 100644
index 00000000..dbebe975
--- /dev/null
+++ b/test/catch2/catch_reporter_automake.hpp
@@ -0,0 +1,62 @@
+/*
+ *  Created by Justin R. Wilson on 2/19/2017.
+ *  Copyright 2017 Justin R. Wilson. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+namespace Catch {
+
+    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
+        AutomakeReporter( ReporterConfig const& _config )
+          :   StreamingReporterBase( _config )
+        {}
+
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the format of Automake .trs files";
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+            stream << ":test-result: ";
+            if (_testCaseStats.totals.assertions.allPassed()) {
+                stream << "PASS";
+            } else if (_testCaseStats.totals.assertions.allOk()) {
+                stream << "XFAIL";
+            } else {
+                stream << "FAIL";
+            }
+            stream << ' ' << _testCaseStats.testInfo.name << '\n';
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+        }
+
+        void skipTest( TestCaseInfo const& testInfo ) override {
+            stream << ":test-result: SKIP " << testInfo.name << '\n';
+        }
+
+    };
+
+#ifdef CATCH_IMPL
+    AutomakeReporter::~AutomakeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_sonarqube.hpp b/test/catch2/catch_reporter_sonarqube.hpp
new file mode 100644
index 00000000..bf7d9299
--- /dev/null
+++ b/test/catch2/catch_reporter_sonarqube.hpp
@@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/test/catch2/catch_reporter_tap.hpp b/test/catch2/catch_reporter_tap.hpp
new file mode 100644
index 00000000..1bfe4f5e
--- /dev/null
+++ b/test/catch2/catch_reporter_tap.hpp
@@ -0,0 +1,253 @@
+/*
+ *  Created by Colton Wolkins on 2015-08-15.
+ *  Copyright 2015 Martin Moene. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct TAPReporter : StreamingReporterBase<TAPReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~TAPReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in TAP format, suitable for test harnesses";
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        void noMatchingTestCases( std::string const& spec ) override {
+            stream << "# No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
+            ++counter;
+
+            stream << "# " << currentTestCaseInfo->name << std::endl;
+            AssertionPrinter printer( stream, _assertionStats, counter );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        std::size_t counter = 0;
+        class AssertionPrinter {
+        public:
+            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
+            AssertionPrinter( AssertionPrinter const& ) = delete;
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
+            : stream( _stream )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( true )
+            , counter(_counter)
+            {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if (result.isOk()) {
+                            printResultType(passedString());
+                        } else {
+                            printResultType(failedString());
+                        }
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if (result.isOk()) {
+                            printIssue(" # TODO");
+                        }
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+            static const char* failedString() { return "not ok"; }
+            static const char* passedString() { return "ok"; }
+
+            void printSourceInfo() const {
+                Colour colourGuard( dimColour() );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    std::string expr = result.getExpandedExpression();
+                    std::replace( expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+        };
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "1..0 # Skipped: No tests ran.";
+            } else {
+                stream << "1.." << counter;
+            }
+        }
+    };
+
+#ifdef CATCH_IMPL
+    TAPReporter::~TAPReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_teamcity.hpp b/test/catch2/catch_reporter_teamcity.hpp
new file mode 100644
index 00000000..47b7e4aa
--- /dev/null
+++ b/test/catch2/catch_reporter_teamcity.hpp
@@ -0,0 +1,219 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
+        TeamCityReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape( std::string const& str ) {
+            std::string escaped = str;
+            replaceInPlace( escaped, "|", "||" );
+            replaceInPlace( escaped, "'", "|'" );
+            replaceInPlace( escaped, "\n", "|n" );
+            replaceInPlace( escaped, "\r", "|r" );
+            replaceInPlace( escaped, "[", "|[" );
+            replaceInPlace( escaped, "]", "|]" );
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        }
+
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
+
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            stream << "##teamcity[testSuiteStarted name='"
+                << escape( groupInfo.name ) << "']\n";
+        }
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            stream << "##teamcity[testSuiteFinished name='"
+                << escape( testGroupStats.groupInfo.name ) << "']\n";
+        }
+
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if( !result.isOk() ) {
+
+                ReusableStringStream msg;
+                if( !m_headerPrintedForThisSection )
+                    printSectionHeader( msg.get() );
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch( result.getResultType() ) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR( "Internal error in TeamCity reporter" );
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR( "Not implemented" );
+                }
+                if( assertionStats.infoMessages.size() == 1 )
+                    msg << " with message:";
+                if( assertionStats.infoMessages.size() > 1 )
+                    msg << " with messages:";
+                for( auto const& messageInfo : assertionStats.infoMessages )
+                    msg << "\n  \"" << messageInfo.message << "\"";
+
+
+                if( result.hasExpression() ) {
+                    msg <<
+                        "\n  " << result.getExpressionInMacro() << "\n"
+                        "with expansion:\n" <<
+                        "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting( testInfo );
+            stream << "##teamcity[testStarted name='"
+                << escape( testInfo.name ) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            if( !testCaseStats.stdOut.empty() )
+                stream << "##teamcity[testStdOut name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
+            if( !testCaseStats.stdErr.empty() )
+                stream << "##teamcity[testStdErr name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
+            stream << "##teamcity[testFinished name='"
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader( std::ostream& os ) {
+            assert( !m_sectionStack.empty() );
+
+            if( m_sectionStack.size() > 1 ) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin()+1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( os, it->name );
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            os << Column( _string )
+                           .indent( indent+i)
+                           .initialIndent( indent ) << "\n";
+        }
+    private:
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 906f941f32bc949edf899e5e8b9ededf45797793 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 15:53:46 +0200
Subject: [PATCH 0174/1292] ssize_t in deSerialize replaced by size_t

---
 container/FixedMap.h                         |  2 +-
 datapool/DataPoolParameterWrapper.cpp        |  2 +-
 datapool/DataPoolParameterWrapper.h          |  2 +-
 datapool/DataSet.cpp                         |  2 +-
 datapool/DataSet.h                           |  2 +-
 datapool/PIDReader.h                         |  2 +-
 datapool/PoolRawAccess.cpp                   | 14 ++---
 datapool/PoolRawAccess.h                     |  2 +-
 datapool/PoolRawAccessHelper.cpp             | 54 ++++++++++++--------
 datapool/PoolRawAccessHelper.h               | 12 +++--
 datapool/PoolVariable.h                      |  2 +-
 datapool/PoolVector.h                        |  2 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |  2 +-
 devicehandlers/DeviceTmReportingWrapper.h    |  2 +-
 events/eventmatching/EventRangeMatcherBase.h |  2 +-
 globalfunctions/Type.cpp                     |  2 +-
 globalfunctions/Type.h                       |  2 +-
 globalfunctions/matching/MatchTree.h         |  2 +-
 globalfunctions/matching/RangeMatcher.h      | 20 +++++---
 parameters/ParameterWrapper.cpp              | 20 ++++----
 parameters/ParameterWrapper.h                |  8 +--
 power/Fuse.cpp                               |  2 +-
 power/Fuse.h                                 |  2 +-
 power/PowerComponent.cpp                     |  2 +-
 power/PowerComponent.h                       |  2 +-
 serialize/SerialArrayListAdapter.h           |  7 ++-
 serialize/SerialBufferAdapter.cpp            | 28 +++++-----
 serialize/SerialBufferAdapter.h              | 14 ++++-
 serialize/SerialFixedArrayListAdapter.h      | 20 +++++---
 serialize/SerialLinkedListAdapter.h          |  4 +-
 serialize/SerializeAdapter.h                 |  4 +-
 serialize/SerializeAdapterInternal.h         | 17 +++---
 serialize/SerializeElement.h                 |  2 +-
 serialize/SerializeIF.h                      |  2 +-
 storagemanager/StorageManagerIF.h            |  3 +-
 subsystem/Subsystem.cpp                      |  4 +-
 subsystem/modes/ModeDefinitions.h            |  2 +-
 test/UnitTestClass.cpp                       | 15 ++++--
 test/UnitTestClass.h                         |  3 +-
 thermal/ThermalComponent.cpp                 |  4 +-
 thermal/ThermalComponent.h                   |  2 +-
 tmstorage/TmStorePackets.h                   |  4 +-
 tmtcpacket/packetmatcher/ApidMatcher.h       |  5 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  5 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  5 +-
 tmtcpacket/pus/TcPacketBase.cpp              |  2 +-
 tmtcpacket/pus/TcPacketBase.h                |  2 +-
 47 files changed, 191 insertions(+), 129 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7f3d28f7..c0eb90b2 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -201,7 +201,7 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
 				buffer, size, bigEndian);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 7139a0d8..11399fb6 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -80,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index 45d3de53..99593310 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index eabb4b8c..28cc4500 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -136,7 +136,7 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 888d45e6..1e34e07c 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -126,7 +126,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 26a9e2a8..7572cd2c 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -136,7 +136,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index b5f94c8c..a2f79343 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -197,11 +197,11 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
-	*size -= typeSize;
-	if (*size >= 0) {
-
+	// TODO: Needs to be tested!!!
+	if (*size >= typeSize) {
+		*size -= typeSize;
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -212,12 +212,14 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		} else {
+		}
+		else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 955c640b..b491d949 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -127,7 +127,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 protected:
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index cac6e506..643c7609 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
 				&remainingParametersSize, false);
@@ -44,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
@@ -67,49 +67,60 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-		ssize_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
+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 = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
+		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct, withValidMask, validityMask);
+	result = handlePoolEntrySerialization(currentPoolId, argStruct,
+			withValidMask, validityMask);
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
-		bool withValidMask, uint8_t * validityMask) {
+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;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: "
+	//      << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			error << "Pool Raw Access Helper: Config error, max. number of possible data set variables exceeded" << std::endl;
+			error << "Pool Raw Access Helper: Config error, "
+					 "max. number of possible data set variables exceeded"
+				  << std::endl;
 			return result;
 		}
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
+				&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode 0x"
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw "
+					"dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
 		}
 
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized, &arrayPosition);
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
+				&arrayPosition);
 		if(result != RETURN_OK) {
-			error << "Pool Raw Access Helper: Configuration Error at pool ID " << std::hex << currentPoolId
+			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;
 		}
@@ -125,8 +136,9 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			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;
+			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;
 		}
 
@@ -134,9 +146,10 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-		bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() - currentPoolRawAccess->getSizeOfType();
+ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
+		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
+	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
+			currentPoolRawAccess->getSizeOfType();
 	if(remainingSize == 0) {
 		*isSerialized = true;
 	}
@@ -158,7 +171,8 @@ void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	}
 }
 
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
+		bool value) {
 	if(position < 1 or position > 8) {
 		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
 		return byte;
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 7d9b9b48..61d79731 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -80,13 +80,15 @@ private:
 	 * @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
+	 * @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,
-				ssize_t * remainingParameters, bool withValidMask = false,
-				uint8_t * validityMask = nullptr);
+	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,
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index d32cdf22..e85e3b15 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -203,7 +203,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 3e82a721..3e548211 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -215,7 +215,7 @@ public:
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		uint16_t i;
 		ReturnValue_t result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 4987c7fb..adddf4f3 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -31,7 +31,7 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index fce74814..e2fa4316 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 private:
 	object_id_t objectId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 8dea3e10..328a6b69 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -18,7 +18,7 @@ public:
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index ea2ad896..11269dc2 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -85,7 +85,7 @@ size_t Type::getSerializedSize() const {
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 244091f7..f4146f4e 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -44,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 498fe860..5a897f40 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -115,7 +115,7 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c0980255..3342cc27 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -29,32 +29,38 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound,
+				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size,
+				max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter<bool>::serialize(&inverted, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound,
+				buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer,
+				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter<bool>::deSerialize(&inverted, buffer,
+				size, bigEndian);
 	}
 protected:
 	bool doMatch(T input) {
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 1420c076..475764c5 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t *) from;
-	ssize_t streamSize = fromRows * fromColumns * sizeof(T);
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -137,12 +137,12 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return deSerialize(buffer, size, bigEndian, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		size_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,8 +153,10 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
-		const uint8_t **remainingStream, ssize_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	// TODO: Replaced ssize_t for remainingSize and streamSize
+	// is the logic here correct?
 	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -172,22 +174,22 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 
-	data = NULL;
+	data = nullptr;
 	readonlyData = stream;
 	pointsToStream = true;
 
 	stream += dataSize;
-	if (remainingStream != NULL) {
+	if (remainingStream !=  nullptr) {
 		*remainingStream = stream;
 	}
 	streamSize -= dataSize;
-	if (remainingSize != NULL) {
+	if (remainingSize != nullptr) {
 		*remainingSize = streamSize;
 	}
 
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 6f8f6fc9..ef54fe6d 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -30,10 +30,10 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
@@ -111,8 +111,8 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
-	ReturnValue_t set(const uint8_t *stream, ssize_t streamSize,
-			const uint8_t **remainingStream = NULL, ssize_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 6a4e6caf..04079bb0 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
 bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
diff --git a/power/Fuse.h b/power/Fuse.h
index b3c9547a..aee03778 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -52,7 +52,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 				bool bigEndian);
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 77e60d0e..0375adf0 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -56,7 +56,7 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
 			size, bigEndian);
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 1410e69d..6ddc067f 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -24,7 +24,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 21a669c2..6a3a276d 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -56,16 +56,19 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
 				buffer, size, bigEndian);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 42ea3dad..5fb5e387 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -61,36 +61,38 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 		return bufferLength;
 	}
 }
+
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			// Suggestion (would require removing rest of the block inside this if clause !):
-			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
-			//if (result != HasReturnvaluesIF::RETURN_OK) {
-			//	return result;
-			//}
+	// (Robin) the one of the buffer? wouldn't that be an issue for serialize
+	// as well? SerialFixedArrayListAdapter implements swapping of buffer
+	// fields (if buffer type is not uint8_t)
+	if (buffer != nullptr) {
+		if(serializeLength) {
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			if(bufferLength + serializedSize >= *size) {
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
-			}else{
+			}
+			else {
 				return STREAM_TOO_SHORT;
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
+		if (bufferLength >= *size) {
 			*size -= bufferLength;
 			memcpy(m_buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
-		} else {
+		}
+		else {
 			return STREAM_TOO_SHORT;
 		}
-	} else {
+	}
+	else {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4a886cba..4421f341 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -49,7 +49,19 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	/**
+	 * @brief This function deserializes a buffer into the member buffer.
+	 * @details
+	 * If a length field is present, it is ignored, as the size should have
+	 * been set in the constructor. If the size is not known beforehand,
+	 * consider using SerialFixedArrayListAdapter instead.
+	 * @param buffer [out] Resulting buffer
+	 * @param size remaining size to deserialize, should be larger than buffer
+	 *        + size field size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	uint8_t * getBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 8bcbf09e..22c4b3a8 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -22,32 +22,38 @@
  * @ingroup serialize
  */
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter : public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>, public SerializeIF {
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
 public:
 	/**
 	 * Constructor Arguments are forwarded to FixedArrayList constructor
 	 * @param args
 	 */
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
-	}
+	SerialFixedArrayListAdapter(Args... args) :
+	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
+	{}
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+				buffer, size, max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
 				buffer, size, bigEndian);
 	}
 
 	void swapArrayListEndianness() {
-		SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
+		SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				swapArrayListEndianness(this);
 	}
 };
 
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index b5c06a16..85f239b3 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -122,13 +122,13 @@ public:
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
 			result = element->value->deSerialize(buffer, size, bigEndian);
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index d926bfce..87e4457a 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -78,7 +78,7 @@ public:
 	}
 	template<typename T>
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
+			size_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
@@ -98,7 +98,7 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
+			size_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index ed0f6c3b..0caf6786 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -33,7 +33,7 @@ public:
 			size_t* size, const size_t max_size, bool bigEndian) {
 	    // function eventuelly serializes structs here.
 	    // does this work on every architecture?
-	    //static_assert(std::is_fundamental<T>::value);
+	    // static_assert(std::is_fundamental<T>::value);
 		size_t ignoredSize = 0;
 		if (size == nullptr) {
 			size = &ignoredSize;
@@ -57,18 +57,17 @@ public:
 	/**
 	 * Deserialize buffer into object
 	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const
-	 * 						pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0,
-	 * 						needed for range/size checking
+	 * @param buffer contains the data. Non-Const pointer to non-const
+	 * 				 pointer to const data.
+	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
+		if (*size >= sizeof(T)) {
+			*size -= sizeof(T);
 			memcpy(&tmp, *buffer, sizeof(T));
 			if (bigEndian) {
 				*object = EndianSwapper::swap<T>(tmp);
@@ -109,7 +108,7 @@ public:
 		return object->getSerializedSize();
 	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return object->deSerialize(buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index e2da5c14..592968c1 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -41,7 +41,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index da401b2f..6036518a 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -47,7 +47,7 @@ public:
 
 	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) = 0;
 
 };
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index e8d8b413..bb88931b 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -144,7 +144,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e4a682ba..52f2c474 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -168,7 +168,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
@@ -193,7 +193,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 4c0c4a26..5e5631b2 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -53,7 +53,7 @@ public:
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result;
 
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
index d20dfb0a..a0f65a08 100644
--- a/test/UnitTestClass.cpp
+++ b/test/UnitTestClass.cpp
@@ -157,7 +157,7 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 	// Unit Test AutoSerializeAdapter serialize
 	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
 	p_array = test_array.data();
-	ssize_t remaining_size = serialized_size;
+	size_t remaining_size = serialized_size;
 	AutoSerializeAdapter::deSerialize(&test_value_bool,
 			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
 	AutoSerializeAdapter::deSerialize(&tv_uint8,
@@ -197,6 +197,8 @@ ReturnValue_t UnitTestClass::test_autoserialization() {
 			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
 		return put_error(current_id);
 	}
+
+	// Check overflow
 	return RETURN_OK;
 }
 
@@ -285,9 +287,16 @@ ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
 	return RETURN_OK;
 }
 
-ReturnValue_t UnitTestClass::put_error(TestIds current_id) {
+ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
+	auto errorIter = testResultMap.find(currentId);
+	if(errorIter != testResultMap.end()) {
+		testResultMap.emplace(currentId, 1);
+	}
+	else {
+		errorIter->second ++;
+	}
 	error << "Unit Tester failed at test ID "
-			<< static_cast<uint32_t>(current_id) << "\r\n" << std::flush;
+			<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
 	return RETURN_FAILED;
 }
 
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
index d9ba9d1c..ffc7a2a2 100644
--- a/test/UnitTestClass.h
+++ b/test/UnitTestClass.h
@@ -56,7 +56,8 @@ private:
 	TestIds current_id = TestIds::MISC;
 	std::array<uint8_t, 512> test_array;
 
-	using TestResultMap = std::map<uint32_t, ReturnValue_t>;
+	using error_count_t =  uint8_t;
+	using TestResultMap = std::map<TestIds, error_count_t>;
 	using TestBuffer = std::vector<uint8_t>;
 	TestResultMap testResultMap;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 737ffd2e..ffe7ba7b 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -40,11 +40,11 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, ssize_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	ssize_t readSize = size;
+	size_t readSize = size;
 	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
 	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 37ed01c0..afe9aa10 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -53,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, ssize_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4e7bc94b..2c70ca78 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -48,7 +48,7 @@ public:
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
 				buffer, size, bigEndian);
@@ -257,7 +257,7 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1ee44476..577425cc 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
+				size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index b69ac7a5..698027da 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
+				size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 9c93af64..5a8f7954 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -28,9 +28,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
+				size, bigEndian);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 630394f8..ba64689a 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -28,7 +28,7 @@ const uint8_t* TcPacketBase::getApplicationData() const {
 	return &tcData->data;
 }
 
-uint16_t TcPacketBase::getApplicationDataSize() {
+size_t TcPacketBase::getApplicationDataSize() {
 	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index e6e6bdad..d84d6c45 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -151,7 +151,7 @@ public:
 	 * @return	The size of the PUS Application Data (without Error Control
 	 * 		field)
 	 */
-	uint16_t getApplicationDataSize();
+	size_t getApplicationDataSize();
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *

From 9284fe81da14628f26001536e22a66c1873517f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 20:53:03 +0200
Subject: [PATCH 0175/1292] added override specifiers, some doc fixes

---
 container/FixedArrayList.h              | 20 ++++++++--
 serialize/EndianSwapper.h               | 27 +++++++++++---
 serialize/SerialArrayListAdapter.h      |  8 ++--
 serialize/SerialBufferAdapter.h         |  4 +-
 serialize/SerialFixedArrayListAdapter.h | 33 ++++++++++-------
 serialize/SerialLinkedListAdapter.h     | 49 +++++++++++++++----------
 serialize/SerializeAdapterInternal.h    |  5 ++-
 serialize/SerializeDoc.h                | 16 --------
 serialize/SerializeElement.h            | 17 +++++----
 serialize/SerializeIF.h                 | 27 +++++++-------
 10 files changed, 117 insertions(+), 89 deletions(-)
 delete mode 100644 serialize/SerializeDoc.h

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 12e292b4..5d93db90 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -12,14 +12,26 @@ class FixedArrayList: public ArrayList<T, count_t> {
 private:
 	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) {
 	}
 
-	//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?
-	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
+	// (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,
+			bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 9f621902..5ba6fd32 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -13,6 +13,12 @@ class EndianSwapper {
 private:
 	EndianSwapper() {};
 public:
+	/**
+	 * Swap the endianness of a variable with arbitrary type
+	 * @tparam T Type of variable
+	 * @param in variable
+	 * @return Variable with swapped endianness
+	 */
 	template<typename T>
 	static T swap(T in) {
 #ifndef BYTE_ORDER_SYSTEM
@@ -31,7 +37,14 @@ public:
 #error Unknown Byte Order
 #endif
 	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
+
+	/**
+	 * Swap the endianness of a buffer.
+	 * @param out
+	 * @param in
+	 * @param size
+	 */
+	static void swap(uint8_t* out, const uint8_t* in, size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -47,21 +60,23 @@ public:
 
 	/**
 	 * Swap endianness of buffer entries
-	 * Template argument specifies buffer type
+	 * Template argument specifies buffer type. The number of entries
+	 * (not the buffer size!) must be supplied
 	 * @param out
 	 * @param in
-	 * @param size
+	 * @param size Number of buffer entries (not size of buffer in bytes!)
 	 */
 	template<typename T>
-	static void swap(T * out, const T * in, uint32_t size) {
+	static void swap(T * out, const T * in, uint32_t entries) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
 		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
 		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
-		for (uint8_t count = 0; count < size; count++) {
+		for (uint8_t count = 0; count < entries; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+				out_buffer[sizeof(T)* (count + 1) - i - 1] =
+						in_buffer[count * sizeof(T) + i];
 			}
 		}
 		return;
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 6a3a276d..4f3b82e6 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -13,7 +13,7 @@
 
 /**
  * Also serializes length field !
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialArrayListAdapter : public SerializeIF {
@@ -22,7 +22,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const  override {
 		return serialize(adaptee, buffer, size, max_size, bigEndian);
 	}
 
@@ -41,7 +41,7 @@ public:
 		return result;
 	}
 
-	virtual size_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		return getSerializedSize(adaptee);
 	}
 
@@ -57,7 +57,7 @@ public:
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 4421f341..d414573c 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 	virtual ~SerialBufferAdapter();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;
 
@@ -62,7 +62,7 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
+			bool bigEndian) override;
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 22c4b3a8..6e13ff6f 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -5,19 +5,24 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
- * @brief This adapter provides an interface for SerializeIF to serialize and deserialize
- *        buffers with a header containing the buffer length.
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
  * @details
- *
  * Can be used by SerialLinkedListAdapter by declaring
  * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
- * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
  *
  *  1. Buffers with a size header inside that class can be declared with
- *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements in FixedArrayList
- *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
- *     (defaults to 1 byte length field) that follows
+ *     @code
+ *     SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *     		MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
+ *     @endcode
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
+ *     in FixedArrayList.
+ *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
+ *     containing the buffer size (defaults to 1 byte length field)
+ *     that follows.
  *
  * @ingroup serialize
  */
@@ -27,7 +32,8 @@ class SerialFixedArrayListAdapter :
 		public SerializeIF {
 public:
 	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor
+	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
 	 * @param args
 	 */
 	template<typename... Args>
@@ -35,8 +41,8 @@ public:
 	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
 	{}
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const  override {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
 				buffer, size, max_size, bigEndian);
 	}
@@ -45,8 +51,9 @@ public:
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
 				getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
 				buffer, size, bigEndian);
 	}
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 85f239b3..8cb9afc8 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -18,23 +18,25 @@
  * 		   	or vice-versa, using linked lists.
  * @details
  * An alternative to the AutoSerializeAdapter functions
- *   - All object members with a datatype are declared as SerializeElement<element_type>
- * 	   members inside the class implementing this adapter.
- *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
- *     with a known size, where the size can also be serialized
- *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
- *     with a size header, which is scanned automatically
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers with a known size
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
  *
  * The sequence of objects is defined in the constructor by using
  * the setStart and setNext functions.
  *
- * - The serialization process is done by instantiating the class and
- *   calling serializ after all SerializeElement entries have been set by
- *   using the constructor or setter functions. An additional size variable can be supplied
- *   which is calculated/incremented automatically
- * - The deserialization process is done by instantiating the class and supplying
- *   a buffer with the data which is converted into an object. The size of
- *   data to serialize can be supplied and is decremented in the function
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
  *
  * @ingroup serialize
  */
@@ -55,10 +57,12 @@ public:
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
 	}
+
 	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
 			SinglyLinkedList<T>(first), printCount(printCount) {
 
 	}
+
 	SerialLinkedListAdapter(bool printCount = false) :
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
@@ -66,15 +70,16 @@ public:
 	/**
 	 * Serialize object implementing this adapter into the supplied buffer
 	 * and calculate the serialized size
-	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
-	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param buffer [out] Object is serialized into this buffer.
+	 *    Note that the buffer pointer *buffer is incremented automatically
+	 *    inside the respective serialize functions
 	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
 	 * @param max_size
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const override{
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -98,7 +103,9 @@ public:
 		}
 		return result;
 	}
-	virtual size_t getSerializedSize() const {
+
+
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -106,6 +113,7 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
+
 	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
 		uint32_t size = 0;
 		while (element != NULL) {
@@ -115,15 +123,17 @@ public:
 		return size;
 	}
 
+
 	/**
-	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * Deserialize supplied buffer with supplied size into object
+	 * implementing this adapter.
 	 * @param buffer
 	 * @param size Decremented in respective deSerialize functions automatically
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
@@ -138,7 +148,6 @@ public:
 	}
 
 	bool printCount;
-
 };
 
 #endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
index 0caf6786..c57af0c9 100644
--- a/serialize/SerializeAdapterInternal.h
+++ b/serialize/SerializeAdapterInternal.h
@@ -12,8 +12,9 @@
 #include <framework/serialize/EndianSwapper.h>
 
 /**
- * This template specialization will be chosen for fundamental types,
- * based on partial template specialization
+ * This template specialization will be chosen for fundamental types or
+ * anything else not implementing SerializeIF, based on partial
+ * template specialization.
  * @tparam T
  * @tparam
  */
diff --git a/serialize/SerializeDoc.h b/serialize/SerializeDoc.h
deleted file mode 100644
index 6186b77b..00000000
--- a/serialize/SerializeDoc.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * @page    serialPage Serialization Tools
- * This page refers to the serialization tools included in framework/serialize.
- * The serialization tools are a useful tool to convert object data into raw
- * buffers and vice-versa. Here is a rough overview which tool to use for
- * which purpose.
- *
- * @section endSwapper  Endian Swapper
- * This header file includes tools to do simple serial order swapping
- *
- * @section serialiezIF SerializeIF
- *
- * @section serElement  SerializeElement
- *
- */
-
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 592968c1..4717ae17 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -24,17 +24,18 @@ public:
 	 * @param args
 	 */
 	template<typename... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	SerializeElement(Args... args):
+			LinkedElement<SerializeIF>(this),
+			entry(std::forward<Args>(args)...) {}
 
-	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
-	}
+	SerializeElement() : LinkedElement<SerializeIF>(this) {}
 
 	T entry;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter<T>::serialize(&entry, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
@@ -42,7 +43,7 @@ public:
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
+			bool bigEndian) override {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6036518a..5f8102c8 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -3,11 +3,6 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
-#include <type_traits>
-
-#ifndef ssize_t
-typedef std::make_signed<std::size_t>::type ssize_t;
-#endif
 
 /**
  * @defgroup serialize Serialization
@@ -18,17 +13,21 @@ typedef std::make_signed<std::size_t>::type ssize_t;
  * @brief An interface for alle classes which require
  *        translation of objects data into data streams and vice-versa.
  * @details
- * If the target architecture is little endian (e.g. ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
- * There are three ways to retrieve data out of a buffer to be used in the FSFW to use
- * regular aligned (big endian) data. This can also be applied to uint32_t and uint64_t:
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
  *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
- *   2. Perform a bitshift operation
- *   3. @c memcpy can be used when data is in little-endian format. Otherwise, @c EndianSwapper has to be used in conjuction.
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */

From fc08754b98698708dfd36b0f2d1f121e1755922f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 15 Apr 2020 23:28:45 +0200
Subject: [PATCH 0176/1292] some doc unclarities comment added

---
 devicehandlers/DeviceHandlerBase.cpp |  12 ++-
 devicehandlers/DeviceHandlerBase.h   | 155 +++++++++++++++++----------
 2 files changed, 105 insertions(+), 62 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5fb5a9e5..6c4be8df 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,10 +16,11 @@ object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-		CookieIF * comCookie_, uint8_t setDeviceSwitch,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * comCookie_,
+		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
+		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
@@ -37,7 +38,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId, defaultFDIRParentId);
+				new DeviceHandlerFailureIsolation(setObjectId,
+						defaultFDIRParentId);
 	}
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c162210c..729eac0b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -93,8 +93,10 @@ public:
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
 	 * @param maxDeviceReplyLen the largest allowed reply size
-	 * @param setDeviceSwitch the switch the device is connected to, for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is used to implement communication functions
+	 * @param setDeviceSwitch the switch the device is connected to,
+	 *    for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is
+	 *    used to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
@@ -107,31 +109,35 @@ public:
 			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
 	/**
-	 * @brief This function is the device handler base core component and is called periodically.
+	 * @brief 	This function is the device handler base core component and is
+	 * 			called periodically.
 	 * @details
 	 * General sequence, showing where abstract virtual functions are called:
 	 * If the State is SEND_WRITE:
 	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
 	 *   2. Handles Device State Modes by calling doStateMachine().
-	 *      This function calls callChildStatemachine() which calls the abstract functions
-	 *      doStartUp() and doShutDown()
+	 *      This function calls callChildStatemachine() which calls the
+	 *      abstract functions doStartUp() and doShutDown()
 	 *   3. Check switch states by calling checkSwitchStates()
-	 *   4. Decrements counter for timeout of replies by calling decrementDeviceReplyMap()
+	 *   4. Decrements counter for timeout of replies by calling
+	 *      decrementDeviceReplyMap()
 	 *   5. Performs FDIR check for failures
 	 *   6. Calls hkSwitcher.performOperation()
-	 *   7. If the device mode is MODE_OFF, return RETURN_OK. Otherwise, perform the Action property
-	 *   	and performs depending on value specified
-	 *      by input value counter. The child class tells base class what to do by setting this value.
-	 *     - SEND_WRITE: Send data or commands to device by calling doSendWrite() which calls
-	 *       sendMessage function of #communicationInterface
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
+     *      Otherwise, perform the Action property and performs depending
+     *      on value specified by input value counter (incremented in PST).
+     *      The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling
+	 *       doSendWrite() which calls sendMessage function
+	 *       of #communicationInterface
 	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite() which calls
-	 *       getSendSuccess of #communicationInterface.
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
+	 *       which calls getSendSuccess of #communicationInterface.
 	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-	 *     - SEND_READ: Request reading data from device by calling doSendRead() which calls
-	 *       requestReceiveMessage of #communcationInterface
-	 *     - GET_READ: Access requested reading data by calling doGetRead() which calls
-	 *       readReceivedMessage of #communicationInterface
+	 *     - SEND_READ: Request reading data from device by calling doSendRead()
+	 *       which calls requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead()
+	 *       which calls readReceivedMessage of #communicationInterface
 	 * @param counter Specifies which Action to perform
 	 * @return RETURN_OK for successful execution
 	 */
@@ -153,37 +159,54 @@ public:
 	virtual ~DeviceHandlerBase();
 protected:
 	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_START_UP to @c MODE_ON
-	 *
-	 * It is only called when the device handler is in mode @c _MODE_START_UP. That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
+	 * @brief 	This is used to let the child class handle the transition from
+	 * 			mode @c _MODE_START_UP to @c MODE_ON
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_START_UP.
+	 * That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send
 	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
+	 * the base class handles rejecting the command and sends a reply.
 	 * The replies for mode transitions are handled by the base class.
 	 *
-	 * If the device is started and ready for operation, the mode should be set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 * use the to on transition if available.
-	 * If the power-up fails, the mode should be set to _MODE_POWER_DOWN which will lead to the device being powered off.
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay()) has passed.
+	 *  - If the device is started and ready for operation, the mode should be
+	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 *    use the to on transition if available.
+	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
+	 *    which will lead to the device being powered off.
+	 *  - If the device does not change the mode, the mode will be changed
+	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
+	 *    has passed.
 	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
 	 */
 	virtual void doStartUp() = 0;
 
 	/**
-	 * This is used to let the child class handle the transition from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 *
+	 * @brief 	This is used to let the child class handle the transition
+	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 * @details
 	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class. If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE, the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send an reply
+	 * accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not
+	 * @c CMD_NONE, the base class handles rejecting the command and sends a
+	 * reply. The replies for mode transitions are handled by the base class.
 	 *
-	 * If the device ready to be switched off, the mode should be set to _MODE_POWER_DOWN.
-	 * If the device should not be switched off, the mode can be changed to _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 * If the device does not change the mode, the mode will be changed to _MODE_POWER_DOWN, when the timeout (from getTransitionDelay()) has passed.
+	 *  - If the device ready to be switched off,
+	 *    the mode should be set to _MODE_POWER_DOWN.
+	 *  - If the device should not be switched off, the mode can be changed to
+	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 *  - If the device does not change the mode, the mode will be changed to
+	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
+	 *    has passed.
 	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
 	 */
 	virtual void doShutDown() = 0;
 
@@ -249,27 +272,42 @@ protected:
 	 * @details
 	 * This is used to let the base class know which replies are expected.
 	 * There are different scenarios regarding this:
-	 *  - "Normal" commands. These are commands, that trigger a direct reply from the device.
-	 *    In this case, the id of the command should be added to the command map
-	 *    with a commandData_t where maxDelayCycles is set to the maximum expected
-	 *    number of PST cycles the reply will take. Then, scanForReply returns
-	 *    the id of the command and the base class can handle time-out and missing replies.
-	 *  - Periodic, unrequested replies. These are replies that, once enabled, are sent by the device
-	 *    on its own in a defined interval. In this case, the id of the reply
-	 *    or a placeholder id should be added to the deviceCommandMap with a commandData_t
-	 *    where maxDelayCycles is set to the maximum expected number of PST cycles between
-	 *    two replies (also a tolerance should be added, as an FDIR message will be generated if it is missed).
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must be set to 1,
-	 *    DeviceCommandInfo.delayCycles to DeviceCommandInfo.MaxDelayCycles.
-	 *    From then on, the base class handles the reception.
-	 *    Then, scanForReply returns the id of the reply or the placeholder id and the base class will
-	 *    take care of checking that all replies are received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set to 0,
-	 *    DeviceCommandInfo.delayCycles to 0;
-	 *  - Aperiodic, unrequested replies. These are replies that are sent
-	 *    by the device without any preceding command and not in a defined interval.
-	 *    These are not entered in the deviceCommandMap but handled by returning @c APERIODIC_REPLY in scanForReply().
 	 *
+	 *  - "Normal" commands. These are commands, that trigger a direct reply
+	 *    from the device. In this case, the id of the command should be added
+	 *    to the command map with a commandData_t where maxDelayCycles is set
+	 *    to the maximum expected number of PST cycles the reply will take.
+	 *    Then, scanForReply returns the id of the command and the base class
+	 *    can handle time-out and missing replies.
+	 *
+	 *  - Periodic, unrequested replies. These are replies that, once enabled,
+	 *    are sent by the device on its own in a defined interval.
+	 *    In this case, the id of the reply or a placeholder id should be added
+	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
+	 *    set to the maximum expected number of PST cycles between two replies
+	 *    (also a tolerance should be added, as an FDIR message will be
+	 *    generated if it is missed).
+	 *
+	 *    (Robin) This part confuses me. "must do as soon as" implies that
+	 *    the developer must do something somewhere else in the code. Is
+	 *    that really the case? If I understood correctly, DHB performs
+	 *    almost everything (e.g. in erirm function) as long as the commands
+	 *    are inserted correctly.
+	 *
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
+	 *    be set to true, DeviceCommandInfo.delayCycles to
+	 *    DeviceCommandInfo.maxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id
+	 *    and the base class will take care of checking that all replies are
+	 *    received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
+	 *    to 0, DeviceCommandInfo.delayCycles to 0;
+	 *
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined
+	 *    interval. These are not entered in the deviceCommandMap but
+	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
 	 */
 	virtual void fillCommandAndReplyMap() = 0;
 
@@ -530,6 +568,9 @@ protected:
 		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
 		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
 		size_t replyLen = 0; //!< Expected size of the reply.
+		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
+		// gives away the impression that this variable is more than a simple flag
+		// and true/false are also more explicit.
 		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
 		DeviceCommandMap::iterator command; //!< The command that expects this reply.
 	};

From bd0b9cb877ec6138d6d83727480748d4a676975e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 09:30:02 +0200
Subject: [PATCH 0177/1292] catch example informative comment

---
 test/CatchExample.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
index 4db6a5c2..90fd1ed5 100644
--- a/test/CatchExample.cpp
+++ b/test/CatchExample.cpp
@@ -1,5 +1,7 @@
 // Catch Example.
 // Does not work yet. Problems with linker without main and config folder.
+// propably because global object manager and some config files are not supplied
+// but mandatory for full compilation of the framework.
 // Let Catch provide main():
 
 #if defined(UNIT_TEST)

From 33b834ad910ca269c4131d8b796c2deba94a2eed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 10:43:50 +0200
Subject: [PATCH 0178/1292] null replaced by nullptr

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5fb5a9e5..374ebaf6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -114,7 +114,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == NULL) {
+	if (rawReceiver == nullptr) {
 		return RETURN_FAILED;
 	}
 

From f45a8cc17193fb3176a8410bd8b00e4ca351bad9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 13:17:26 +0200
Subject: [PATCH 0179/1292] fixed slot sequence safety check added

---
 devicehandlers/FixedSlotSequence.cpp | 11 ++++++++++-
 devicehandlers/FixedSlotSequence.h   |  4 +++-
 osal/FreeRTOS/FixedTimeslotTask.cpp  |  1 -
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 23bb0e78..f11de94b 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -1,5 +1,6 @@
 #include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
 		slotLengthMs(setLengthMs) {
@@ -87,7 +88,15 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
-	// Iterate through slotList and check successful creation.
+	if(slotList.empty()) {
+	    error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+	    // does check sequence have to be const?
+	    // if I want to check a class, I need the ability to set
+	    // internal class states.
+	    //isEmpty = true;
+	    std::exit(0);
+	}
+    // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 813d2fce..cad7ee87 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -3,6 +3,7 @@
 
 #include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <list>
 #include <set>
 
@@ -23,7 +24,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 class FixedSlotSequence {
 public:
 
-
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.
 	 *
@@ -127,6 +127,8 @@ protected:
 	SlotList slotList;
 
 	uint32_t slotLengthMs;
+
+	bool isEmpty = false;
 };
 
 #endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index b1c97420..db0247a4 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -112,7 +112,6 @@ void FixedTimeslotTask::taskFunctionality() {
 			vTaskDelayUntil(&xLastWakeTime, interval);
 			//TODO deadline missed check
 		}
-
 	}
 }
 

From eb362dcad2adb126156d19c558794892526a8791 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Apr 2020 17:02:04 +0200
Subject: [PATCH 0180/1292] some comment line break

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 6c4be8df..a371b413 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -690,7 +690,8 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	if (result != RETURN_OK) {
 		IPCStore->deleteData(address);
-		//Silently discard data, this indicates heavy TM traffic which should not be increased by additional events.
+		// Silently discard data, this indicates heavy TM traffic which should
+		// not be increased by additional events.
 	}
 }
 

From ea1d55b0336dd860c7c5ab7a2a6b62d408d3244c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:16:00 +0200
Subject: [PATCH 0181/1292] null replaced by nullptr.

storeID initialization added, all nullptr/0 initializations in header
---
 tmtcservices/TmTcBridge.cpp | 19 +++++++++----------
 tmtcservices/TmTcBridge.h   | 25 ++++++++++++++-----------
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8450494a..38d900dd 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -11,17 +11,15 @@
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_):
-	SystemObject(objectId_),tcStore(NULL), tmStore(NULL),
-	ccsdsPacketDistributor(ccsdsPacketDistributor_), communicationLinkUp(false),
-	tmStored(false),recvBuffer(NULL), size(0) {
-	TmTcReceptionQueue = QueueFactory::instance()->
+TmTcBridge::TmTcBridge(object_id_t objectId_,
+        object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
+        ccsdsPacketDistributor(ccsdsPacketDistributor_)
+{
+	    TmTcReceptionQueue = QueueFactory::instance()->
 			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
-
 }
 
-TmTcBridge::~TmTcBridge() {
-}
+TmTcBridge::~TmTcBridge() {}
 
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
@@ -75,8 +73,9 @@ ReturnValue_t TmTcBridge::handleTm() {
 
 ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
-	const uint8_t* data = NULL;
+	const uint8_t* data = nullptr;
 	size_t size = 0;
+
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -105,7 +104,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	info << "TMTC Bridge: Comm Link down. "
 			"Saving packet ID to be sent later\r\n" << std::flush;
-	store_address_t storeId;
+	store_address_t storeId = 0;
 
 	if(fifo.full()) {
 		info << "TMTC Bridge: TM downlink max. number of stored packet IDs reached."
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 8e4124e0..e0634098 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -48,12 +48,15 @@ public:
 	void registerCommConnect();
 	void registerCommDisconnect();
 protected:
-	MessageQueueIF* TmTcReceptionQueue; //!< Used to send and receive TMTC messages. TmTcMessage is used to transport messages between tasks.
-	StorageManagerIF* tcStore;
-	StorageManagerIF* tmStore;
-	object_id_t ccsdsPacketDistributor;
-	bool communicationLinkUp; //!< Used to specify whether communication link is up
-	bool tmStored;
+	//! Used to send and receive TMTC messages.
+	//! TmTcMessage is used to transport messages between tasks.
+	MessageQueueIF* TmTcReceptionQueue = nullptr;
+	StorageManagerIF* tcStore = nullptr;
+	StorageManagerIF* tmStore = nullptr;
+	object_id_t ccsdsPacketDistributor = 0;
+	//! Used to specify whether communication link is up
+	bool communicationLinkUp = false;
+	bool tmStored = false;
 
 	/**
 	 * Handle TC reception. Default implementation provided
@@ -113,13 +116,13 @@ protected:
 	void printData(uint8_t * data, uint32_t dataLen);
 
 private:
-	static const uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static const uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static const uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
+	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static constexpr uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
+	static constexpr uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
 
 	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t * recvBuffer;
-	uint32_t size;
+	uint8_t * recvBuffer = nullptr;
+	uint32_t size = 0;
 };
 
 

From 4d8aca8417f722ab6fcf15f3defd73652cc0a18a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:32:40 +0200
Subject: [PATCH 0182/1292] message queue adaptation for ISRs

---
 osal/FreeRTOS/MessageQueue.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 3546a99b..6082bb15 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -124,6 +124,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                 reinterpret_cast<const void*>(message->getBuffer()), 0);
     }
     else {
+        // If the call context is from an interrupt,
+        // request a context switch if a higher priority task
+        // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()),

From e34a438e774aee4dfe39ab881519e01e8735cb52 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 13:38:05 +0200
Subject: [PATCH 0183/1292] using size_t

---
 tmtcservices/TmTcBridge.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 38d900dd..c984a6a8 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -16,7 +16,7 @@ TmTcBridge::TmTcBridge(object_id_t objectId_,
         ccsdsPacketDistributor(ccsdsPacketDistributor_)
 {
 	    TmTcReceptionQueue = QueueFactory::instance()->
-			createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+	            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
 TmTcBridge::~TmTcBridge() {}
@@ -75,7 +75,6 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-
 	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -122,8 +121,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
-		info << "UDP Server: Sending stored TM data. There are "
-				<< (int) fifo.size() << " left to send\r\n" << std::flush;
+		info << "TMTC Bridge: Sending stored TM data. There are "
+		     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;
@@ -131,7 +130,8 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 		result = tmStore->getData(storeId, &data, &size);
 		sendTm(data,size);
 		if(result != RETURN_OK) {
-			error << "UDP Server: Could not send stored downlink data" << std::endl;
+			error << "TMTC Bridge: Could not send stored downlink data"
+			      << std::endl;
 			result = RETURN_FAILED;
 		}
 		counter ++;

From 9580f51c30590617084b2ef21b8c4fa4a23e0d92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 14:16:46 +0200
Subject: [PATCH 0184/1292] removed self-inclusion

---
 devicehandlers/CookieIF.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 6b2bb559..715a8fd4 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,7 +1,6 @@
 #ifndef COOKIE_H_
 #define COOKIE_H_
-#include <framework/devicehandlers/CookieIF.h>
-#include <stdint.h>
+#include <cstdint>
 
 /**
  * @brief Physical address type

From a7d3b4c4a03a0ec2afee9ab0ec5021750fc80dca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 15:05:51 +0200
Subject: [PATCH 0185/1292] added std:: before uint32_t typedef

---
 devicehandlers/CookieIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 715a8fd4..5fbcd198 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -5,7 +5,7 @@
 /**
  * @brief Physical address type
  */
-typedef uint32_t address_t;
+typedef std::uint32_t address_t;
 
 /**
  * @brief 	This datatype is used to identify different connection over a

From e77ca55b1d383afd0079152a4d6809d3e79a6a93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 18 Apr 2020 17:12:26 +0200
Subject: [PATCH 0186/1292] serial fixed array list adapter doc fix

---
 serialize/SerialFixedArrayListAdapter.h | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 6e13ff6f..841e9b7a 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -13,16 +13,17 @@
  * The sequence of objects is defined in the constructor by
  * using the setStart and setNext functions.
  *
- *  1. Buffers with a size header inside that class can be declared with
- *     @code
- *     SerialFixedArrayListAdapter<BUFFER_TYPE,
- *     		MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
- *     @endcode
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
- *     in FixedArrayList.
- *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
- *     containing the buffer size (defaults to 1 byte length field)
- *     that follows.
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
  *
  * @ingroup serialize
  */

From 36715e3f4cf98cb21049eaf2001129fe3acbe625 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 19 Apr 2020 12:06:28 +0200
Subject: [PATCH 0187/1292] test folder moved to separate test folder

for fsfw for now
---
 test/CatchExample.cpp                    |    51 -
 test/UnitTestClass.cpp                   |   302 -
 test/UnitTestClass.h                     |    84 -
 test/catch2/catch.hpp                    | 17618 ---------------------
 test/catch2/catch_reporter_automake.hpp  |    62 -
 test/catch2/catch_reporter_sonarqube.hpp |   181 -
 test/catch2/catch_reporter_tap.hpp       |   253 -
 test/catch2/catch_reporter_teamcity.hpp  |   219 -
 8 files changed, 18770 deletions(-)
 delete mode 100644 test/CatchExample.cpp
 delete mode 100644 test/UnitTestClass.cpp
 delete mode 100644 test/UnitTestClass.h
 delete mode 100644 test/catch2/catch.hpp
 delete mode 100644 test/catch2/catch_reporter_automake.hpp
 delete mode 100644 test/catch2/catch_reporter_sonarqube.hpp
 delete mode 100644 test/catch2/catch_reporter_tap.hpp
 delete mode 100644 test/catch2/catch_reporter_teamcity.hpp

diff --git a/test/CatchExample.cpp b/test/CatchExample.cpp
deleted file mode 100644
index 90fd1ed5..00000000
--- a/test/CatchExample.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// Catch Example.
-// Does not work yet. Problems with linker without main and config folder.
-// propably because global object manager and some config files are not supplied
-// but mandatory for full compilation of the framework.
-// Let Catch provide main():
-
-#if defined(UNIT_TEST)
-#define CATCH_CONFIG_MAIN
-
-#include <framework/test/catch2/catch.hpp>
-#include <framework/test/UnitTestClass.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-int Factorial( int number ) {
-   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
-// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
-}
-
-
-
-TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
-    REQUIRE( Factorial(0) == 1 );
-}
-
-TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
-    REQUIRE( Factorial(1) == 1 );
-    REQUIRE( Factorial(2) == 2 );
-    REQUIRE( Factorial(3) == 6 );
-    REQUIRE( Factorial(10) == 3628800 );
-}
-
-TEST_CASE( "Custom test", "[single-file]" ) {
-    UnitTestClass unitTestClass;
-    REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
-}
-
-// Compile & run:
-// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
-// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
-
-// Expected compact output (all assertions):
-//
-// prompt> 010-TestCase --reporter compact --success
-// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
-// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
-// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
-// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
-// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
-// Failed 1 test case, failed 1 assertion.
-
-#endif
diff --git a/test/UnitTestClass.cpp b/test/UnitTestClass.cpp
deleted file mode 100644
index a0f65a08..00000000
--- a/test/UnitTestClass.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-/**
- * @file 	UnitTestClass.cpp
- *
- * @date 	11.04.2020
- * @author 	R. Mueller
- */
-#include <framework/test/UnitTestClass.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-
-#include <cstdlib>
-
-#if defined(UNIT_TEST)
-#include "catch.hpp"
-#define CATCH_CONFIG_MAIN
-
-TEST_CASE( "Serialization Size tests", "[single-file]") {
-   //REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
-}
-#endif
-
-UnitTestClass::UnitTestClass() {}
-
-UnitTestClass::~UnitTestClass() {}
-
-ReturnValue_t UnitTestClass::perform_tests() {
-	ReturnValue_t result = test_serialization();
-	if(result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_serialization() {
-	// Here, we test all serialization tools. First test basic cases.
-	ReturnValue_t result = test_endianness_tools();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	result = test_autoserialization();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	result = test_serial_buffer_adapter();
-	if(result != RETURN_OK) {
-		return result;
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_endianness_tools() {
-	test_array[0] = 0;
-	test_array[1] = 0;
-	uint16_t two_byte_value = 1;
-	size_t size = 0;
-	uint8_t* p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
-	// Little endian: Value one on first byte
-	if(test_array[0] != 1 and test_array[1] != 0) {
-		return put_error(TestIds::ENDIANNESS_TOOLS);
-
-	}
-
-	p_array = test_array.data();
-	size = 0;
-	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
-	// Big endian: Value one on second byte
-	if(test_array[0] != 0 and test_array[1] != 1) {
-		return put_error(TestIds::ENDIANNESS_TOOLS);
-	}
-
-	// Endianness paameter will be changed later.
-//	p_array = test_array.data();
-//	ssize_t ssize = size;
-//	// Resulting parameter should be big endian
-//	AutoSerializeAdapter::deSerialize(&two_byte_value,
-//			const_cast<const uint8_t **>(&p_array), &ssize, true);
-//	if(two_byte_value != 1) {
-//		return put_error(TestIds::ENDIANNESS_TOOLS);
-//	}
-//
-//	ssize = size;
-//	p_array = test_array.data();
-//	// Resulting parameter should be little endian
-//	AutoSerializeAdapter::deSerialize(&two_byte_value,
-//			const_cast<const uint8_t **>(&p_array), &ssize, false);
-//	if(two_byte_value != 256) {
-//		return put_error(TestIds::ENDIANNESS_TOOLS);
-//	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::test_autoserialization() {
-	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
-	// Unit Test getSerializedSize
-	if(AutoSerializeAdapter::
-			getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int8) != sizeof(tv_int8) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_double) != sizeof(tv_double) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int16) != sizeof(tv_int16) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_int32) != sizeof(tv_int32) or
-			AutoSerializeAdapter::
-			getSerializedSize(&tv_float) != sizeof(tv_float))
-	{
-		return put_error(current_id);
-	}
-
-	// Unit Test AutoSerializeAdapter deserialize
-	current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
-
-	size_t serialized_size = 0;
-	uint8_t * p_array = test_array.data();
-
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int8, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int16, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_int32, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_float, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_double, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
-			&serialized_size, test_array.size(), false);
-	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
-	if(serialized_size != 47) {
-		return put_error(current_id);
-	}
-
-	// Unit Test AutoSerializeAdapter serialize
-	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
-	p_array = test_array.data();
-	size_t remaining_size = serialized_size;
-	AutoSerializeAdapter::deSerialize(&test_value_bool,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint8,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint16,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint32,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int8,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int16,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_int32,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_uint64,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_float,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_double,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_sfloat,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-	AutoSerializeAdapter::deSerialize(&tv_sdouble,
-			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
-
-	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
-			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
-			tv_int16 != -829 or tv_int32 != -2312)
-	{
-		return put_error(current_id);
-	}
-
-	// These epsilon values were just guessed.. It appears to work though.
-	if(abs(tv_float - 8.214921) > 0.0001 or
-			abs(tv_double - 9.2132142141e8) > 0.01 or
-			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
-			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
-		return put_error(current_id);
-	}
-
-	// Check overflow
-	return RETURN_OK;
-}
-
-// TODO: Also test for constant buffers.
-ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
-	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
-
-	// I will skip endian swapper testing, its going to be changed anyway..
-	// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
-
-	size_t serialized_size = 0;
-	test_value_bool = true;
-	uint8_t * p_array = test_array.data();
-	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
-			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
-					test_serial_buffer.size(), false);
-	tv_uint16 = 16;
-
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
-			or test_array[5] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-
-	// Serialize with size field
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
-			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
-					test_serial_buffer.size(), true);
-	serialized_size = 0;
-	p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
-			or test_array[5] != 2 or test_array[6] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-
-	// Serialize with size field
-	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
-			SerialBufferAdapter<uint8_t>(
-			const_cast<const uint8_t*>(test_serial_buffer.data()),
-			test_serial_buffer.size(), false);
-	serialized_size = 0;
-	p_array = test_array.data();
-	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
-			test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
-			&serialized_size, test_array.size(), false);
-	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
-			test_array.size(), false);
-
-	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
-			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
-			or test_array[5] != 1)
-	{
-		return put_error(current_id);
-	}
-	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
-	if(tv_uint16 != 16) {
-		return put_error(current_id);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
-	auto errorIter = testResultMap.find(currentId);
-	if(errorIter != testResultMap.end()) {
-		testResultMap.emplace(currentId, 1);
-	}
-	else {
-		errorIter->second ++;
-	}
-	error << "Unit Tester failed at test ID "
-			<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
-	return RETURN_FAILED;
-}
-
diff --git a/test/UnitTestClass.h b/test/UnitTestClass.h
deleted file mode 100644
index ffc7a2a2..00000000
--- a/test/UnitTestClass.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * @file 	UnitTestClass.h
- *
- * @date 	11.04.2020
- * @author 	R. Mueller
- */
-
-#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
-#define FRAMEWORK_TEST_UNITTESTCLASS_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include <map>
-#include <vector>
-
-/**
- * We could start doing basic forms of Unit Testing (without a framework, first)
- * for framework components. This could include:
- *
- *  1. TMTC Services
- *  2. Serialization tools
- *  3. Framework internal algorithms
- *
- *  TODO: Maybe use specialized framework.
- */
-
-class UnitTestClass: public HasReturnvaluesIF {
-public:
-	UnitTestClass();
-	virtual~ UnitTestClass();
-
-	enum class TestIds {
-		ENDIANNESS_TOOLS,
-		AUTO_SERIALIZATION_SIZE,
-		AUTO_SERIALIZATION_SERIALIZE,
-		AUTO_SERIALIZATION_DESERIALIZE ,
-		SERIALIZATION_BUFFER_ADAPTER,
-		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
-		SERIALIZATION_COMBINATION,
-		TMTC_SERVICES ,
-		MISC
-	};
-
-	/**
-	 * Some function which calls all other tests
-	 * @return
-	 */
-	ReturnValue_t perform_tests();
-
-	ReturnValue_t test_serialization();
-	ReturnValue_t test_autoserialization();
-	ReturnValue_t test_serial_buffer_adapter();
-	ReturnValue_t test_endianness_tools();
-private:
-	uint32_t errorCounter = 0;
-	TestIds current_id = TestIds::MISC;
-	std::array<uint8_t, 512> test_array;
-
-	using error_count_t =  uint8_t;
-	using TestResultMap = std::map<TestIds, error_count_t>;
-	using TestBuffer = std::vector<uint8_t>;
-	TestResultMap testResultMap;
-
-	// POD test values
-	bool test_value_bool = true;
-	uint8_t tv_uint8   {5};
-	uint16_t tv_uint16 {283};
-	uint32_t tv_uint32 {929221};
-	uint64_t tv_uint64 {2929329429};
-
-	int8_t tv_int8 {-16};
-	int16_t tv_int16 {-829};
-	int32_t tv_int32 {-2312};
-
-	float tv_float {8.2149214};
-	float tv_sfloat = {-922.2321321};
-	double tv_double {9.2132142141e8};
-	double tv_sdouble {-2.2421e19};
-
-	ReturnValue_t put_error(TestIds currentId);
-};
-
-
-#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */
diff --git a/test/catch2/catch.hpp b/test/catch2/catch.hpp
deleted file mode 100644
index 51618b38..00000000
--- a/test/catch2/catch.hpp
+++ /dev/null
@@ -1,17618 +0,0 @@
-/*
- *  Catch v2.11.3
- *  Generated: 2020-03-19 13:44:21.042491
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-// start catch.hpp
-
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 11
-#define CATCH_VERSION_PATCH 3
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// start catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-// end catch_suppress_warnings.h
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
-#endif
-
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-// start catch_platform.h
-
-#ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-#endif
-
-// end catch_platform.h
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// start catch_user_interfaces.h
-
-namespace Catch {
-    unsigned int rngSeed();
-}
-
-// end catch_user_interfaces.h
-// start catch_tag_alias_autoregistrar.h
-
-// start catch_common.h
-
-// start catch_compiler_capabilities.h
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#endif
-
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#endif
-
-#if defined(__clang__)
-
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#if defined(_MSC_VER)
-
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
-
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// DJGPP
-#ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use of __COUNTER__ is suppressed during code analysis in
-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
-// handled by it.
-// Otherwise all supported compilers support COUNTER macro,
-// but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-// end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#include <iosfwd>
-#include <string>
-#include <cstdint>
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept { return file[0] == '\0'; }
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-// end catch_common.h
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
-
-// start catch_interfaces_testcase.h
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-}
-
-// end catch_interfaces_testcase.h
-// start catch_stringref.h
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-#include <cassert>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-        using const_iterator = const char*;
-
-    private:
-        static constexpr char const* const s_empty = "";
-
-        char const* m_start = s_empty;
-        size_type m_size = 0;
-
-    public: // construction
-        constexpr StringRef() noexcept = default;
-
-        StringRef( char const* rawChars ) noexcept;
-
-        constexpr StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        explicit operator std::string() const {
-            return std::string(m_start, m_size);
-        }
-
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != (StringRef const& other) const noexcept -> bool {
-            return !(*this == other);
-        }
-
-        auto operator[] ( size_type index ) const noexcept -> char {
-            assert(index < m_size);
-            return m_start[index];
-        }
-
-    public: // named queries
-        constexpr auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        constexpr auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        // Returns the current start pointer. If the StringRef is not
-        // null-terminated, throws std::domain_exception
-        auto c_str() const -> char const*;
-
-    public: // substrings and searches
-        // Returns a substring of [start, start + length).
-        // If start + length > size(), then the substring is [start, size()).
-        // If start > size(), then the substring is empty.
-        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
-
-        // Returns the current start pointer. May not be null-terminated.
-        auto data() const noexcept -> char const*;
-
-        constexpr auto isNullTerminated() const noexcept -> bool {
-            return m_start[m_size] == '\0';
-        }
-
-    public: // iterators
-        constexpr const_iterator begin() const { return m_start; }
-        constexpr const_iterator end() const { return m_start + m_size; }
-    };
-
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
-
-    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-} // namespace Catch
-
-constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-// end catch_stringref.h
-// start catch_preprocessor.hpp
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    template<template<typename...> class...> struct TemplateTypeList{};\
-    template<template<typename...> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
-    template<typename...>\
-    struct append;\
-    template<typename...>\
-    struct rewrap;\
-    template<template<typename...> class, typename...>\
-    struct create;\
-    template<template<typename...> class, typename>\
-    struct convert;\
-    \
-    template<typename T> \
-    struct append<T> { using type = T; };\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-// end catch_preprocessor.hpp
-// start catch_meta.hpp
-
-
-#include <type_traits>
-
-namespace Catch {
-    template<typename T>
-    struct always_false : std::false_type {};
-
-    template <typename> struct true_given : std::true_type {};
-    struct is_callable_tester {
-        template <typename Fun, typename... Args>
-        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-        template <typename...>
-        std::false_type static test(...);
-    };
-
-    template <typename T>
-    struct is_callable;
-
-    template <typename Fun, typename... Args>
-    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here. Also *_t format is preferred over
-    // typename *::type format.
-    template <typename Func, typename U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
-#else
-    template <typename Func, typename U>
-    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
-#endif
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-// end catch_meta.hpp
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
-
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
-
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename convert<TestName, TmplList>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename convert<TestNameClass, TmplList>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
-
-// end catch_test_registry.h
-// start catch_capture.hpp
-
-// start catch_assertionhandler.h
-
-// start catch_assertioninfo.h
-
-// start catch_result_type.h
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-// start catch_decomposer.h
-
-// start catch_tostring.h
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-// start catch_stream.h
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    class StringRef;
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    auto makeStream( StringRef const &filename ) -> IStream const*;
-
-    class ReusableStringStream : NonCopyable {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        auto str() const -> std::string;
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-// end catch_stream.h
-// start catch_interfaces_enum_values_registry.h
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-// end catch_interfaces_enum_values_registry.h
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __OBJC__
-// start catch_objc_arc.hpp
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-// end catch_objc_arc.hpp
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-namespace Catch {
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif
-
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-#ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
-#endif // __OBJC__
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
-
-    not_this_one begin( ... );
-    not_this_one end( ... );
-
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol();
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_tostring.h
-#include <iosfwd>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-namespace Catch {
-
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        // We don't actually need a virtual destructor, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
-
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_decomposer.h
-// start catch_interfaces_capture.h
-
-#include <string>
-#include <chrono>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    struct ITransientExpression;
-    struct IGeneratorTracker;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-// end catch_message.h
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
-
-#endif
-
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_capture.hpp
-// start catch_section.h
-
-// start catch_section_info.h
-
-// start catch_totals.h
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// end catch_totals.h
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
-
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
-
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// end catch_section_info.h
-// start catch_timer.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-// end catch_timer.h
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_section.h
-// start catch_interfaces_exception.h
-
-// start catch_interfaces_registry_hub.h
-
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-// end catch_interfaces_registry_hub.h
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
-#endif
-
-#include <exception>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// end catch_interfaces_exception.h
-// start catch_approx.h
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-// end catch_approx.h
-// start catch_string_manip.h
-
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    //! Returns a new string without whitespace at the start/end
-    std::string trim( std::string const& str );
-    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
-    StringRef trim(StringRef ref);
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
-
-// end catch_string_manip.h
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-// start catch_capture_matchers.h
-
-// start catch_matchers.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-
-#if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
-#endif
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif
-
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
-
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-// end catch_matchers.h
-// start catch_matchers_exception.hpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-class ExceptionMessageMatcher : public MatcherBase<std::exception> {
-    std::string m_message;
-public:
-
-    ExceptionMessageMatcher(std::string const& message):
-        m_message(message)
-    {}
-
-    bool match(std::exception const& ex) const override;
-
-    std::string describe() const override;
-};
-
-} // namespace Exception
-
-Exception::ExceptionMessageMatcher Message(std::string const& message);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_exception.hpp
-// start catch_matchers_floating.h
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Floating {
-
-        enum class FloatingPointKind : uint8_t;
-
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
-
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            uint64_t m_ulps;
-            FloatingPointKind m_type;
-        };
-
-        // Given IEEE-754 format for floats and doubles, we can assume
-        // that float -> double promotion is lossless. Given this, we can
-        // assume that if we do the standard relative comparison of
-        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
-        // the same result if we do this for floats, as if we do this for
-        // doubles that were promoted from floats.
-        struct WithinRelMatcher : MatcherBase<double> {
-            WithinRelMatcher(double target, double epsilon);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_epsilon;
-        };
-
-    } // namespace Floating
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-    Floating::WithinRelMatcher WithinRel(double target, double eps);
-    // defaults epsilon to 100*numeric_limits<double>::epsilon()
-    Floating::WithinRelMatcher WithinRel(double target);
-    Floating::WithinRelMatcher WithinRel(float target, float eps);
-    // defaults epsilon to 100*numeric_limits<float>::epsilon()
-    Floating::WithinRelMatcher WithinRel(float target);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.h
-// start catch_matchers_generic.hpp
-
-#include <functional>
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-namespace Generic {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
-
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-} // namespace Generic
-
-    // The following functions create the actual matcher objects.
-    // The user has to explicitly specify type to the function, because
-    // inferring std::function<bool(T const&)> is hard (but possible) and
-    // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_generic.hpp
-// start catch_matchers_string.h
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
-
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
-
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
-
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
-
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-// end catch_capture_matchers.h
-#endif
-// start catch_generators.hpp
-
-// start catch_interfaces_generatortracker.h
-
-
-#include <memory>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-// end catch_interfaces_generatortracker.h
-// start catch_enforce.h
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-// end catch_enforce.h
-#include <memory>
-#include <vector>
-#include <cassert>
-
-#include <utility>
-#include <exception>
-
-namespace Catch {
-
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
-
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
-
-    const char* what() const noexcept override final;
-};
-
-namespace Generators {
-
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
-    public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::forward<T>(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::forward<U>(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
-    }
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
-
-    template<typename L>
-    // Note: The type after -> is weird, because VS2015 cannot parse
-    //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
-
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
-    }
-
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_generic.hpp
-// start catch_generators_specific.hpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
-}
-
-// end catch_context.h
-// start catch_interfaces_config.h
-
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <chrono>
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
-
-// end catch_interfaces_config.h
-// start catch_random_number_generator.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    // This is a simple implementation of C++11 Uniform Random Number
-    // Generator. It does not provide all operators, because Catch2
-    // does not use it, but it should behave as expected inside stdlib's
-    // distributions.
-    // The implementation is based on the PCG family (http://pcg-random.org)
-    class SimplePcg32 {
-        using state_type = std::uint64_t;
-    public:
-        using result_type = std::uint32_t;
-        static constexpr result_type (min)() {
-            return 0;
-        }
-        static constexpr result_type (max)() {
-            return static_cast<result_type>(-1);
-        }
-
-        // Provide some default initial state for the default constructor
-        SimplePcg32():SimplePcg32(0xed743cc4U) {}
-
-        explicit SimplePcg32(result_type seed_);
-
-        void seed(result_type seed_);
-        void discard(uint64_t skip);
-
-        result_type operator()();
-
-    private:
-        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-
-        // In theory we also need operator<< and operator>>
-        // In practice we do not use them, so we will skip them for now
-
-        std::uint64_t m_state;
-        // This part of the state determines which "stream" of the numbers
-        // is chosen -- we take it as a constant for Catch2, so we only
-        // need to deal with seeding the main state.
-        // Picked by reading 8 bytes from `/dev/random` :-)
-        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
-    };
-
-} // end namespace Catch
-
-// end catch_random_number_generator.h
-#include <random>
-
-namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
-
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container,
-          typename ResultType = typename Container::value_type>
-GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
-}
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_specific.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
-
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
-
-namespace Catch {
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                bool match( NSString* str ) const override {
-                    return false;
-                }
-
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
-
-// end catch_objc.hpp
-#endif
-
-// Benchmarking needs the externally-facing parts of reporters to work
-#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_external_interfaces.h
-
-// start catch_reporter_bases.hpp
-
-// start catch_interfaces_reporter.h
-
-// start catch_config.hpp
-
-// start catch_test_spec_parser.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_test_spec.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_wildcard_pattern.h
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string normaliseString( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-// end catch_wildcard_pattern.h
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    struct IConfig;
-
-    class TestSpec {
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            std::string const m_name;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
-        };
-
-    public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCase const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
-        using vectorStrings = std::vector<std::string>;
-
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
-        const vectorStrings & getInvalidArgs() const;
-
-    private:
-        std::vector<Filter> m_filters;
-        std::vector<std::string> m_invalidArgs;
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        Mode lastMode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::size_t m_realPatternPos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        bool visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-        void saveLastMode();
-        void revertBackToLastMode();
-        void addFilter();
-        bool separate();
-
-        // Handles common preprocessing of the pattern for name/tag patterns
-        std::string preprocessPattern();
-        // Adds the current pattern as a test name
-        void addNamePattern();
-        // Adds the current pattern as a tag
-        void addTagPattern();
-
-        inline void addCharToPattern(char c) {
-            m_substring += c;
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-
-    };
-    TestSpec parseTestSpec( std::string const& arg );
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec_parser.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
-
-    private:
-
-        IStream const* openStream();
-        ConfigData m_data;
-
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-
-} // end namespace Catch
-
-// end catch_config.hpp
-// start catch_assertionresult.h
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// end catch_assertionresult.h
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_estimate.hpp
-
- // Statistics estimates
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate.hpp
-// start catch_outlier_classification.hpp
-
-// Outlier information
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_outlier_classification.hpp
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-#include <algorithm>
-
-namespace Catch {
-
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void reportInvalidArguments(std::string const&) {}
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& container );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void reportInvalidArguments(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved = false;
-    };
-
-    std::ostream& operator << ( std::ostream& os, Colour const& );
-
-} // end namespace Catch
-
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
-
-
-namespace Catch {
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
-
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
-
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
-
-// start catch_xmlwriter.h
-
-#include <vector>
-
-namespace Catch {
-    enum class XmlFormatting {
-        None = 0x00,
-        Indent = 0x01,
-        Newline = 0x02,
-    };
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-            XmlFormatting m_fmt;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        void writeStylesheetRef( std::string const& url );
-
-        XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-    private:
-
-        void applyFormatting(XmlFormatting fmt);
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-// end catch_xmlwriter.h
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& /*spec*/) override;
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEndedCumulative() override;
-
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases(std::string const& s) override;
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_xml.h
-
-// end catch_external_interfaces.h
-#endif
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_benchmarking_all.hpp
-
-// A proxy header that includes all of the benchmarking headers to allow
-// concise include of the benchmarking features. You should prefer the
-// individual includes in standard use.
-
-// start catch_benchmark.hpp
-
- // Benchmark
-
-// start catch_chronometer.hpp
-
-// User-facing chronometer
-
-
-// start catch_clock.hpp
-
-// Clocks
-
-
-#include <chrono>
-#include <ratio>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
-
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_clock.hpp
-// start catch_optimizer.hpp
-
- // Hinting the optimizer
-
-
-#if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER)
-
-#pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#pragma optimize("", on)
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_optimizer.hpp
-// start catch_complete_invoke.hpp
-
-// Invoke with a special case for void
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
-
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                ClockDuration<Clock> elapsed() const { return finished - started; }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return k; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_chronometer.hpp
-// start catch_environment.hpp
-
-// Environment information
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_environment.hpp
-// start catch_execution_plan.hpp
-
- // Execution plan
-
-
-// start catch_benchmark_function.hpp
-
- // Dumb std::function implementation for consistent call overhead
-
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-#include <memory>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
-
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_benchmark_function.hpp
-// start catch_repeat.hpp
-
-// repeat algorithm
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_repeat.hpp
-// start catch_run_for_at_least.hpp
-
-// Run a function for a minimum amount of time
-
-
-// start catch_measure.hpp
-
-// Measure
-
-
-// start catch_timing.hpp
-
-// Timing
-
-
-#include <tuple>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_timing.hpp
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_measure.hpp
-#include <utility>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
-
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_run_for_at_least.hpp
-#include <algorithm>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_execution_plan.hpp
-// start catch_estimate_clock.hpp
-
- // Environment measurement
-
-
-// start catch_stats.hpp
-
-// Statistical analysis tools
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <iterator>
-#include <numeric>
-#include <tuple>
-#include <cmath>
-#include <utility>
-#include <cstddef>
-#include <random>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_stats.hpp
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
-
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate_clock.hpp
-// start catch_analyse.hpp
-
- // Run and analyse one benchmark
-
-
-// start catch_sample_analysis.hpp
-
-// Benchmark results
-
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <iterator>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_sample_analysis.hpp
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_analyse.hpp
-#include <algorithm>
-#include <functional>
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
-                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-// end catch_benchmark.hpp
-// start catch_constructor.hpp
-
-// Constructor and destructor helpers
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
-            {
-                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-                ObjectStorage() : data() {}
-
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
-
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(&data) T(std::move(other.stored_object()));
-                }
-
-                ~ObjectStorage() { destruct_on_exit<T>(); }
-
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (&data) T(std::forward<Args>(args)...);
-                }
-
-                template <bool AllowManualDestruction = !Destruct>
-                typename std::enable_if<AllowManualDestruction>::type destruct()
-                {
-                    stored_object().~T();
-                }
-
-            private:
-                // If this is a constructor benchmark, destruct the underlying object
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-                // Otherwise, don't
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
-
-                T& stored_object() {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                T const& stored_object() const {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                TStorage data;
-            };
-        }
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
-    }
-}
-
-// end catch_constructor.hpp
-// end catch_benchmarking_all.hpp
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
-
-    struct ITracker;
-
-    using ITrackerPtr = std::shared_ptr<ITracker>;
-
-    struct ITracker {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
-
-        virtual ITracker& parent() = 0;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-        void endRun();
-
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
-
-        void addChild( ITrackerPtr const& child ) override;
-
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
-
-        void openChild() override;
-
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-        std::string m_trimmed_name;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-// end catch_test_case_tracker.h
-
-// start catch_leak_detector.h
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_stats.cpp
-
-// Statistical analysis tools
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-
-#include <cassert>
-#include <random>
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-// end catch_stats.cpp
-// start catch_approx.cpp
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
-#endif
-
-// end catch_debugger.h
-// start catch_run_context.h
-
-// start catch_fatal_condition.h
-
-// start catch_windows_h_proxy.h
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-// end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
-
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-} // namespace Catch
-
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
-
-        static void handleSignal( int sig );
-
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
-
-#endif
-
-// end catch_fatal_condition.h
-#include <string>
-
-namespace Catch {
-
-    struct IMutableContext;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-    void seedRng(IConfig const& config);
-    unsigned int rngSeed();
-} // end namespace Catch
-
-// end catch_run_context.h
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_capture_matchers.cpp
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
-
-// start catch_commandline.h
-
-// start catch_clara.h
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.5
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-namespace clara {
-namespace TextFlow {
-
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
-
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-class Spacer : public Column {
-
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
-
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
-
-}
-}
-
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
-
-#include <cctype>
-#include <string>
-#include <memory>
-#include <set>
-#include <algorithm>
-
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
-        return result;
-    }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
-        virtual ~BoundRef() = default;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-        virtual auto isFlag() const -> bool { return true; }
-    };
-
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp{};
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundValueRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            optWidth = (std::min)(optWidth, consoleWidth/2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
-
-}} // namespace Catch::clara
-
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-// end catch_clara.h
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
-                    }
-                }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
-
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
-
-}
-// end catch_common.cpp
-// start catch_config.cpp
-
-namespace Catch {
-
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
-        }
-        m_testSpec = parser.testSpec();
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
-
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-// start catch_errno_guard.h
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-// end catch_errno_guard.h
-#include <sstream>
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) override {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-            !isDebuggerActive() &&
-#endif
-#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
-#else
-            false
-#endif
-            ;
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved  = true;
-        return *this;
-    }
-
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != nullptr) {
-            impl->use( _colourCode );
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
-
-        ~Context() override;
-
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    IMutableContext *IMutableContext::currentContext = nullptr;
-
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
-
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
-
-// start catch_debug_console.h
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-// end catch_debug_console.h
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
-
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
-
-namespace Catch {
-
-    ITransientExpression::~ITransientExpression() = default;
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_enforce.cpp
-
-#include <stdexcept>
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-} // namespace Catch;
-// end catch_enforce.cpp
-// start catch_enum_values_registry.cpp
-// start catch_enum_values_registry.h
-
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    namespace Detail {
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
-
-        std::vector<StringRef> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-// end catch_enum_values_registry.h
-
-#include <map>
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
-
-    namespace Detail {
-
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() {}
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}"_sr;
-        }
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
-
-    } // Detail
-} // Catch
-
-// end catch_enum_values_registry.cpp
-// start catch_errno_guard.cpp
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
-
-// start catch_exception_translator_registry.h
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
-
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
-
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
-
-#endif // signals/SEH handling
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
-
-} // namespace Catch
-
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
-
-#endif // signals/SEH handling
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-// end catch_fatal_condition.cpp
-// start catch_generators.cpp
-
-#include <limits>
-#include <set>
-
-namespace Catch {
-
-IGeneratorTracker::~IGeneratorTracker() {}
-
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
-
-namespace Generators {
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() {}
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
-    }
-
-} // namespace Generators
-} // namespace Catch
-// end catch_generators.cpp
-// start catch_interfaces_capture.cpp
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
-
-// start catch_reporter_listening.h
-
-namespace Catch {
-
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
-
-    public:
-        ListeningReporter();
-
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
-
-    public: // IStreamingReporter
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases( std::string const& spec ) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_listening.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
-
-namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
-
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else
-
-    Catch::LeakDetector::LeakDetector() {}
-
-#endif
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
-
-// start catch_list.h
-
-#include <set>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
-
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
-
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
-
-    std::size_t listTags( Config const& config );
-
-    std::size_t listReporters();
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
-
-} // end namespace Catch
-
-// end catch_list.h
-// start catch_text.h
-
-namespace Catch {
-    using namespace clara::TextFlow;
-}
-
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
-
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
-
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-    } // namespace Impl
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_exception.cpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-bool ExceptionMessageMatcher::match(std::exception const& ex) const {
-    return ex.what() == m_message;
-}
-
-std::string ExceptionMessageMatcher::describe() const {
-    return "exception message matches \"" + m_message + "\"";
-}
-
-}
-Exception::ExceptionMessageMatcher Message(std::string const& message) {
-    return Exception::ExceptionMessageMatcher(message);
-}
-
-// namespace Exception
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_exception.cpp
-// start catch_matchers_floating.cpp
-
-// start catch_polyfills.hpp
-
-namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
-
-// end catch_polyfills.hpp
-// start catch_to_string.hpp
-
-#include <string>
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-// end catch_to_string.hpp
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-#include <sstream>
-#include <type_traits>
-#include <iomanip>
-#include <limits>
-
-namespace Catch {
-namespace {
-
-    int32_t convert(float f) {
-        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-        int32_t i;
-        std::memcpy(&i, &f, sizeof(f));
-        return i;
-    }
-
-    int64_t convert(double d) {
-        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-        int64_t i;
-        std::memcpy(&i, &d, sizeof(d));
-        return i;
-    }
-
-    template <typename FP>
-    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-        // Comparison with NaN should always be false.
-        // This way we can rule it out before getting into the ugly details
-        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-            return false;
-        }
-
-        auto lc = convert(lhs);
-        auto rc = convert(rhs);
-
-        if ((lc < 0) != (rc < 0)) {
-            // Potentially we can have +0 and -0
-            return lhs == rhs;
-        }
-
-        auto ulpDiff = std::abs(lc - rc);
-        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
-    }
-
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-
-    float nextafter(float x, float y) {
-        return ::nextafterf(x, y);
-    }
-
-    double nextafter(double x, double y) {
-        return ::nextafter(x, y);
-    }
-
-#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
-
-template <typename FP>
-FP step(FP start, FP direction, uint64_t steps) {
-    for (uint64_t i = 0; i < steps; ++i) {
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-        start = Catch::nextafter(start, direction);
-#else
-        start = std::nextafter(start, direction);
-#endif
-    }
-    return start;
-}
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-template <typename FloatingPoint>
-void write(std::ostream& out, FloatingPoint num) {
-    out << std::scientific
-        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
-        << num;
-}
-
-} // end anonymous namespace
-
-namespace Matchers {
-namespace Floating {
-
-    enum class FloatingPointKind : uint8_t {
-        Float,
-        Double
-    };
-
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(m_type == FloatingPointKind::Double
-                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
-            "Provided ULP is impossibly large for a float comparison.");
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of ";
-
-        if (m_type == FloatingPointKind::Float) {
-            write(ret, static_cast<float>(m_target));
-            ret << 'f';
-        } else {
-            write(ret, m_target);
-        }
-
-        ret << " ([";
-        if (m_type == FloatingPointKind::Double) {
-            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
-        } else {
-            // We have to cast INFINITY to float because of MinGW, see #1782
-            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
-        }
-        ret << "])";
-
-        return ret.str();
-    }
-
-    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
-        m_target(target),
-        m_epsilon(epsilon){
-        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
-        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
-    }
-
-    bool WithinRelMatcher::match(double const& matchee) const {
-        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
-        return marginComparison(matchee, m_target,
-                                std::isinf(relMargin)? 0 : relMargin);
-    }
-
-    std::string WithinRelMatcher::describe() const {
-        Catch::ReusableStringStream sstr;
-        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
-        return sstr.str();
-    }
-
-}// namespace Floating
-
-Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
-
-Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
-
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
-
-Floating::WithinRelMatcher WithinRel(double target, double eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(double target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
-}
-
-Floating::WithinRelMatcher WithinRel(float target, float eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(float target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.cpp
-// start catch_matchers_generic.cpp
-
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-// end catch_matchers_generic.cpp
-// start catch_matchers_string.cpp
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
-
-// start catch_uncaught_exceptions.h
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-// end catch_uncaught_exceptions.h
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
-
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.empty()) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.empty() && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-// end catch_message.cpp
-// start catch_output_redirect.cpp
-
-// start catch_output_redirect.h
-#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-
-#include <cstdio>
-#include <iosfwd>
-#include <string>
-
-namespace Catch {
-
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
-
-#endif
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-// end catch_output_redirect.h
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <sstream>
-#include <stdexcept>
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
-#endif
-
-namespace Catch {
-
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
-
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
-
-#endif
-
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
-
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
-
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-} // namespace Catch
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
-#endif
-// end catch_output_redirect.cpp
-// start catch_polyfills.cpp
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-} // end namespace Catch
-// end catch_polyfills.cpp
-// start catch_random_number_generator.cpp
-
-namespace Catch {
-
-namespace {
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4146) // we negate uint32 during the rotate
-#endif
-        // Safe rotr implementation thanks to John Regehr
-        uint32_t rotate_right(uint32_t val, uint32_t count) {
-            const uint32_t mask = 31;
-            count &= mask;
-            return (val >> count) | (val << (-count & mask));
-        }
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-}
-
-    SimplePcg32::SimplePcg32(result_type seed_) {
-        seed(seed_);
-    }
-
-    void SimplePcg32::seed(result_type seed_) {
-        m_state = 0;
-        (*this)();
-        m_state += seed_;
-        (*this)();
-    }
-
-    void SimplePcg32::discard(uint64_t skip) {
-        // We could implement this to run in O(log n) steps, but this
-        // should suffice for our use case.
-        for (uint64_t s = 0; s < skip; ++s) {
-            static_cast<void>((*this)());
-        }
-    }
-
-    SimplePcg32::result_type SimplePcg32::operator()() {
-        // prepare the output value
-        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
-
-        // advance state
-        m_state = m_state * 6364136223846793005ULL + s_inc;
-
-        return output;
-    }
-
-    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state == rhs.m_state;
-    }
-
-    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state != rhs.m_state;
-    }
-}
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
-
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
-
-namespace Catch {
-
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
-
-        virtual void registerTest( TestCase const& testCase );
-
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
-
-        void invoke() const override;
-    };
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
-
-    ///////////////////////////////////////////////////////////////////////////
-
-} // end namespace Catch
-
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias.h
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
-
-// end catch_startup_exception_registry.h
-// start catch_singletons.hpp
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-// end catch_singletons.hpp
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
-
-namespace Catch {
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
-
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
-
-}
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
-
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
-
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
-
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
-
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
-
-                return *tracker;
-            }
-
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
-
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
-
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = static_cast<std::string>(message);
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        seedRng(*m_config);
-
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( assertionResult );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = static_cast<std::string>(message);
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-
-    void seedRng(IConfig const& config) {
-        if (config.rngSeed() != 0) {
-            std::srand(config.rngSeed());
-            rng().seed(config.rngSeed());
-        }
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-}
-// end catch_run_context.cpp
-// start catch_section.cpp
-
-namespace Catch {
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
-
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
-
-// start catch_session.h
-
-#include <memory>
-
-namespace Catch {
-
-    class Session : NonCopyable {
-    public:
-
-        Session();
-        ~Session() override;
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-// end catch_session.h
-// start catch_version.h
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
-#include <set>
-#include <iterator>
-
-namespace Catch {
-
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
-
-            return reporter;
-        }
-
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
-
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
-        }
-
-        class TestGroup {
-        public:
-            explicit TestGroup(std::shared_ptr<Config> const& config)
-            : m_config{config}
-            , m_context{config, makeReporter(config)}
-            {
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-
-                if (m_matches.empty() && invalidArgs.empty()) {
-                    for (auto const& test : allTestCases)
-                        if (!test.isHidden())
-                            m_tests.emplace(&test);
-                } else {
-                    for (auto const& match : m_matches)
-                        m_tests.insert(match.tests.begin(), match.tests.end());
-                }
-            }
-
-            Totals execute() {
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-                Totals totals;
-                m_context.testGroupStarting(m_config->name(), 1, 1);
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_context.reporter().skipTest(*testCase);
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_context.reporter().noMatchingTestCases(match.name);
-                        totals.error = -1;
-                    }
-                }
-
-                if (!invalidArgs.empty()) {
-                    for (auto const& invalidArg: invalidArgs)
-                         m_context.reporter().reportInvalidArguments(invalidArg);
-                }
-
-                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
-                return totals;
-            }
-
-        private:
-            using Tests = std::set<TestCase const*>;
-
-            std::shared_ptr<Config> m_config;
-            RunContext m_context;
-            Tests m_tests;
-            TestSpec::Matches m_matches;
-        };
-
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
-
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
-
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
-
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
-
-            TestGroup tests { m_config };
-            auto const totals = tests.execute();
-
-            if( m_config->warnAboutNoTests() && totals.error == -1 )
-                return 2;
-
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_singletons.cpp
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-// end catch_singletons.cpp
-// start catch_startup_exception_registry.cpp
-
-namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-
-} // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-            ~DebugOutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-    }} // namespace anon::detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
-        }
-        else
-            return new Detail::FileStream( filename );
-    }
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-}
-// end catch_stream.cpp
-// start catch_string_manip.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    StringRef trim(StringRef ref) {
-        const auto is_ws = [](char c) {
-            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-        };
-        size_t real_begin = 0;
-        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
-        size_t real_end = ref.size();
-        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
-
-        return ref.substr(real_begin, real_end - real_begin);
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    auto StringRef::c_str() const -> char const* {
-        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
-        return m_start;
-    }
-    auto StringRef::data() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if (start < m_size) {
-            return StringRef(m_start + start, (std::min)(m_size - start, size));
-        } else {
-            return StringRef();
-        }
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return m_size == other.m_size
-            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.data(), str.size());
-    }
-
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.data(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
-
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
-
-#include <cctype>
-#include <exception>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for (char c : nameAndTags.tags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            // Add all "hidden" tags to make them behave identically
-            tags.insert( tags.end(), { ".", "!hide" } );
-        }
-
-        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
-        return !testCase.throws() || config.allowThrows();
-    }
-
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className(classOrQualifiedMethodName);
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
-
-#include <algorithm>
-#include <cassert>
-#include <stdexcept>
-#include <memory>
-#include <sstream>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isGeneratorTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_trimmed_name(trim(nameAndLocation.name))
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "")
-            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
-            complete = TrackerBase::isComplete();
-        }
-        return complete;
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.emplace_back(""); // Root - should never be consulted
-            m_filters.emplace_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
-
-namespace Catch {
-
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
-
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
-
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
-
-    TestSpec::Pattern::~Pattern() = default;
-
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
-
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( testCase.name );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( toLower( tag ) )
-    {}
-
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
-    : Pattern( underlyingPattern->name() )
-    , m_underlyingPattern( underlyingPattern )
-    {}
-
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
-        return !m_underlyingPattern->matches( testCase );
-    }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
-    }
-
-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for( auto const& p : m_patterns )
-            name += p->name();
-        return name;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
-
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
-    {
-        Matches matches( m_filters.size() );
-        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
-            std::vector<TestCase const*> currentMatches;
-            for( auto const& test : testCases )
-                if( isThrowSafe( test, config ) && filter.matches( test ) )
-                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
-        } );
-        return matches;
-    }
-
-    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
-        return  (m_invalidArgs);
-    }
-
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        m_realPatternPos = 0;
-
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){
-               m_testSpec.m_invalidArgs.push_back(arg);
-               break;
-           }
-        endMode();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-    bool TestSpecParser::visitChar( char c ) {
-        if( (m_mode != EscapedName) && (c == '\\') ) {
-            escape();
-            addCharToPattern(c);
-            return true;
-        }else if((m_mode != EscapedName) && (c == ',') )  {
-            return separate();
-        }
-
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return true;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            addCharToPattern(c);
-            return true;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return true;
-            break;
-        }
-
-        m_substring += c;
-        if( !isControlChar( c ) ) {
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-        return true;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        default:
-            startNewMode( Name );
-            return false;
-        }
-    }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
-    }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
-        endMode();
-        return true;
-    }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addNamePattern();
-        case Tag:
-            return addTagPattern();
-        case EscapedName:
-            revertBackToLastMode();
-            return;
-        case None:
-        default:
-            return startNewMode( None );
-        }
-    }
-    void TestSpecParser::escape() {
-        saveLastMode();
-        m_mode = EscapedName;
-        m_escapeChars.push_back(m_realPatternPos);
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
-    }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    void TestSpecParser::saveLastMode() {
-      lastMode = m_mode;
-    }
-
-    void TestSpecParser::revertBackToLastMode() {
-      m_mode = lastMode;
-    }
-
-    bool TestSpecParser::separate() {
-      if( (m_mode==QuotedName) || (m_mode==Tag) ){
-         //invalid argument, signal failure to previous scope.
-         m_mode = None;
-         m_pos = m_arg.size();
-         m_substring.clear();
-         m_patternName.clear();
-         return false;
-      }
-      endMode();
-      addFilter();
-      return true; //success
-    }
-
-    std::string TestSpecParser::preprocessPattern() {
-        std::string token = m_patternName;
-        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
-            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
-        m_escapeChars.clear();
-        if (startsWith(token, "exclude:")) {
-            m_exclusion = true;
-            token = token.substr(8);
-        }
-
-        m_patternName.clear();
-
-        return token;
-    }
-
-    void TestSpecParser::addNamePattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
-            if (m_exclusion)
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    void TestSpecParser::addTagPattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
-            // we have to create a separate hide tag and shorten the real one
-            if (token.size() > 1 && token[0] == '.') {
-                token.erase(token.begin());
-                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
-                if (m_exclusion) {
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-                }
-                m_currentFilter.m_patterns.push_back(pattern);
-            }
-
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
-
-            if (m_exclusion) {
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            }
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
-
-#include <chrono>
-
-static const uint64_t nanosecondsInSecond = 1000000000;
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
-
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
-
-                auto delta = ticks - baseTicks;
-                sum += delta;
-
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
-
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// Enable specific decls locally
-#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#endif
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    const std::string unprintableString = "{?}";
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                int one = 1;
-                // If the lowest byte we read is non-zero, we can assume
-                // that little endian format is used.
-                auto value = *reinterpret_cast<char*>(&one);
-                return value ? Little : Big;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    if (Catch::isnan(value)) {
-        return "nan";
-    }
-
-    ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
-    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
-
-int StringMaker<float>::precision = 5;
-
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = 10;
-
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
-
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_uncaught_exceptions.cpp
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-// end catch_uncaught_exceptions.cpp
-// start catch_version.cpp
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 11, 3, "", 0 );
-        return version;
-    }
-
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( normaliseString( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == normaliseString( str );
-            case WildcardAtStart:
-                return endsWith( normaliseString( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( normaliseString( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( normaliseString( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::normaliseString( std::string const& str ) const {
-        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
-
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-    bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
-    }
-
-    bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
-    }
-
-} // anonymous namespace
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
-    :   m_writer( writer ),
-        m_fmt(fmt)
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ),
-        m_fmt(other.m_fmt)
-    {
-        other.m_writer = nullptr;
-        other.m_fmt = XmlFormatting::None;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        m_fmt = other.m_fmt;
-        other.m_fmt = XmlFormatting::None;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if (m_writer) {
-            m_writer->endElement(m_fmt);
-        }
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
-        m_writer->writeText( text, fmt );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while (!m_tags.empty()) {
-            endElement();
-        }
-        newlineIfNecessary();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-            m_indent += "  ";
-        }
-        m_os << '<' << name;
-        m_tags.push_back( name );
-        m_tagIsOpen = true;
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
-        ScopedElement scoped( this, fmt );
-        startElement( name, fmt );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
-        m_indent = m_indent.substr(0, m_indent.size() - 2);
-
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        } else {
-            newlineIfNecessary();
-            if (shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << "</" << m_tags.back() << ">";
-        }
-        m_os << std::flush;
-        applyFormatting(fmt);
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if (tagWasOpen && shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << XmlEncode( text );
-            applyFormatting(fmt);
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
-        ensureTagClosed();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-        }
-        m_os << "<!--" << text << "-->";
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << '>' << std::flush;
-            newlineIfNecessary();
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::applyFormatting(XmlFormatting fmt) {
-        m_needsNewline = shouldNewline(fmt);
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        std::sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
-
-            oss << filter;
-        }
-        return oss.str();
-    }
-
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
-
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
-
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
-
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
-
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
-#endif
-
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
-
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-
-} // anon namespace
-
-namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
-        out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
-        const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
-        Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
-        Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
-    }
-}
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
-        if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
-        }
-    }
-
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
-        if (itMessage == messages.end())
-            return;
-
-        const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
-
-        {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
-        }
-
-        while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-                continue;
-            }
-            ++itMessage;
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
-
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
-
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
-
-#include <cfloat>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
-
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
-        return i;
-    else if (j > k)
-        return j;
-    else
-        return k;
-}
-
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    double m_inNanoseconds;
-    Unit m_units;
-
-public:
-    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return m_inNanoseconds;
-        }
-    }
-    auto unitsAsString() const -> std::string {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << ' ' << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << '\n';
-
-            m_os << Catch::getLineOfChars<'-'>() << '\n';
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        const auto strSize = colStr.size();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << '\n';
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 1), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << ' ';
-        else
-            tp.m_os << padding << colStr << ' ';
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << '\n';
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
-        [&config]() -> std::vector<ColumnInfo> {
-        if (config.fullConfig()->benchmarkNoAnalysis())
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
-                { "     samples", 14, ColumnInfo::Right },
-                { "  iterations", 14, ColumnInfo::Right },
-                { "        mean", 14, ColumnInfo::Right }
-            };
-        }
-        else
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-                { "samples      mean       std dev", 14, ColumnInfo::Right },
-                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-            };
-        }
-    }())) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
-    stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
-
-void ConsoleReporter::reportInvalidArguments(std::string const&arg){
-    stream << "Invalid Filter: " << arg << std::endl;
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
-    printer.print();
-    stream << std::endl;
-    return true;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-    }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    (*m_tablePrinter) << info.samples << ColumnBreak()
-        << info.iterations << ColumnBreak();
-    if (!m_config->benchmarkNoAnalysis())
-        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-    if (m_config->benchmarkNoAnalysis())
-    {
-        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
-    }
-    else
-    {
-        (*m_tablePrinter) << ColumnBreak()
-            << Duration(stats.mean.point.count()) << ColumnBreak()
-            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-    }
-}
-
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ')'
-        << ColumnBreak() << RowBreak();
-}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
-    if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
-    }
-    StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTotals(_testRunStats.totals);
-    stream << std::endl;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
-    StreamingReporterBase::testRunStarting(_testInfo);
-    printTestFilters();
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
-    if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
-
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    stream << '\n' << getLineOfChars<'~'>() << '\n';
-    Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
-
-    if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-    currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
-    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
-    }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-    stream << getLineOfChars<'-'>() << '\n';
-    Colour colourGuard(Colour::FileName);
-    stream << lineInfo << '\n';
-    stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    stream << getLineOfChars<'-'>() << '\n';
-    {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
-    }
-}
-
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    std::size_t i = _string.find(": ");
-    if (i != std::string::npos)
-        i += 2;
-    else
-        i = 0;
-    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
-
-struct SummaryColumn {
-
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
-    }
-
-    std::string label;
-    Colour::Code colour;
-    std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
-    if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
-    }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
-    for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
-    }
-    stream << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
-    }
-    stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
-
-void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters()) {
-        Colour guard(Colour::BrightYellow);
-        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
-    }
-}
-
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
-
-#include <cassert>
-#include <sstream>
-#include <ctime>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
-
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
-
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className = stats.testInfo.className;
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
-
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
-
-        writeSection( className, "", rootSection );
-    }
-
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message", result.getExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if (stats.totals.assertions.total() > 0) {
-                rss << "FAILED" << ":\n";
-                if (result.hasExpression()) {
-                    rss << "  ";
-                    rss << result.getExpressionInMacro();
-                    rss << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    rss << "with expansion:\n";
-                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
-                }
-            } else {
-                rss << '\n';
-            }
-
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), XmlFormatting::Newline );
-        }
-    }
-
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_listening.cpp
-
-#include <cassert>
-
-namespace Catch {
-
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
-
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
-
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
-
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
-    }
-
-    void ListeningReporter::reportInvalidArguments(std::string const&arg){
-        for ( auto const& listener : m_listeners ) {
-            listener->reportInvalidArguments( arg );
-        }
-        m_reporter->reportInvalidArguments( arg );
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
-    }
-
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
-    }
-
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
-    }
-
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
-    }
-
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
-    }
-
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
-    }
-
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
-    }
-
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
-    }
-
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
-    }
-
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
-    }
-
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
-    }
-
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
-
-} // end namespace Catch
-// end catch_reporter_listening.cpp
-// start catch_reporter_xml.cpp
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
-
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
-
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-
-        return true;
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkPreparing(std::string const& name) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", info.clockResolution)
-            .writeAttribute("estimatedDuration", info.estimatedDuration)
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", benchmarkStats.mean.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_xml.cpp
-
-namespace Catch {
-    LeakDetector leakDetector;
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_impl.hpp
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// start catch_default_main.hpp
-
-#ifndef __OBJC__
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-// end catch_default_main.hpp
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-// start catch_reenable_warnings.h
-
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-// end catch_reenable_warnings.h
-// end catch.hpp
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/test/catch2/catch_reporter_automake.hpp b/test/catch2/catch_reporter_automake.hpp
deleted file mode 100644
index dbebe975..00000000
--- a/test/catch2/catch_reporter_automake.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *  Created by Justin R. Wilson on 2/19/2017.
- *  Copyright 2017 Justin R. Wilson. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-namespace Catch {
-
-    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
-        AutomakeReporter( ReporterConfig const& _config )
-          :   StreamingReporterBase( _config )
-        {}
-
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the format of Automake .trs files";
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-            stream << ":test-result: ";
-            if (_testCaseStats.totals.assertions.allPassed()) {
-                stream << "PASS";
-            } else if (_testCaseStats.totals.assertions.allOk()) {
-                stream << "XFAIL";
-            } else {
-                stream << "FAIL";
-            }
-            stream << ' ' << _testCaseStats.testInfo.name << '\n';
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-        }
-
-        void skipTest( TestCaseInfo const& testInfo ) override {
-            stream << ":test-result: SKIP " << testInfo.name << '\n';
-        }
-
-    };
-
-#ifdef CATCH_IMPL
-    AutomakeReporter::~AutomakeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_sonarqube.hpp b/test/catch2/catch_reporter_sonarqube.hpp
deleted file mode 100644
index bf7d9299..00000000
--- a/test/catch2/catch_reporter_sonarqube.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Created by Daniel Garcia on 2018-12-04.
- *  Copyright Social Point SL. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <map>
-
-namespace Catch {
-
-    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
-
-        SonarQubeReporter(ReporterConfig const& config)
-        : CumulativeReporterBase(config)
-        , xml(config.stream()) {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-        ~SonarQubeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the Generic Test Data SonarQube XML format";
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void noMatchingTestCases(std::string const& /*spec*/) override {}
-
-        void testRunStarting(TestRunInfo const& testRunInfo) override {
-            CumulativeReporterBase::testRunStarting(testRunInfo);
-            xml.startElement("testExecutions");
-            xml.writeAttribute("version", "1");
-        }
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            CumulativeReporterBase::testGroupEnded(testGroupStats);
-            writeGroup(*m_testGroups.back());
-        }
-
-        void testRunEndedCumulative() override {
-            xml.endElement();
-        }
-
-        void writeGroup(TestGroupNode const& groupNode) {
-            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
-            for(auto const& child : groupNode.children)
-                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
-
-            for(auto const& kv : testsPerFile)
-                writeTestFile(kv.first.c_str(), kv.second);
-        }
-
-        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
-            XmlWriter::ScopedElement e = xml.scopedElement("file");
-            xml.writeAttribute("path", filename);
-
-            for(auto const& child : testCaseNodes)
-                writeTestCase(*child);
-        }
-
-        void writeTestCase(TestCaseNode const& testCaseNode) {
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert(testCaseNode.children.size() == 1);
-            SectionNode const& rootSection = *testCaseNode.children.front();
-            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
-        }
-
-        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
-            std::string name = trim(sectionNode.stats.sectionInfo.name);
-            if(!rootName.empty())
-                name = rootName + '/' + name;
-
-            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
-                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
-                xml.writeAttribute("name", name);
-                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
-
-                writeAssertions(sectionNode, okToFail);
-            }
-
-            for(auto const& childNode : sectionNode.childSections)
-                writeSection(name, *childNode, okToFail);
-        }
-
-        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
-            for(auto const& assertion : sectionNode.assertions)
-                writeAssertion( assertion, okToFail);
-        }
-
-        void writeAssertion(AssertionStats const& stats, bool okToFail) {
-            AssertionResult const& result = stats.assertionResult;
-            if(!result.isOk()) {
-                std::string elementName;
-                if(okToFail) {
-                    elementName = "skipped";
-                }
-                else {
-                    switch(result.getResultType()) {
-                        case ResultWas::ThrewException:
-                        case ResultWas::FatalErrorCondition:
-                            elementName = "error";
-                            break;
-                        case ResultWas::ExplicitFailure:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::ExpressionFailed:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::DidntThrowException:
-                            elementName = "failure";
-                            break;
-
-                            // We should never see these here:
-                        case ResultWas::Info:
-                        case ResultWas::Warning:
-                        case ResultWas::Ok:
-                        case ResultWas::Unknown:
-                        case ResultWas::FailureBit:
-                        case ResultWas::Exception:
-                            elementName = "internalError";
-                            break;
-                    }
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
-
-                ReusableStringStream messageRss;
-                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
-                xml.writeAttribute("message", messageRss.str());
-
-                ReusableStringStream textRss;
-                if (stats.totals.assertions.total() > 0) {
-                    textRss << "FAILED:\n";
-                    if (result.hasExpression()) {
-                        textRss << "\t" << result.getExpressionInMacro() << "\n";
-                    }
-                    if (result.hasExpandedExpression()) {
-                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
-                    }
-                }
-
-                if(!result.getMessage().empty())
-                    textRss << result.getMessage() << "\n";
-
-                for(auto const& msg : stats.infoMessages)
-                    if(msg.type == ResultWas::Info)
-                        textRss << msg.message << "\n";
-
-                textRss << "at " << result.getSourceInfo();
-                xml.writeText(textRss.str(), XmlFormatting::Newline);
-            }
-        }
-
-    private:
-        XmlWriter xml;
-    };
-
-#ifdef CATCH_IMPL
-    SonarQubeReporter::~SonarQubeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/test/catch2/catch_reporter_tap.hpp b/test/catch2/catch_reporter_tap.hpp
deleted file mode 100644
index 1bfe4f5e..00000000
--- a/test/catch2/catch_reporter_tap.hpp
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- *  Created by Colton Wolkins on 2015-08-15.
- *  Copyright 2015 Martin Moene. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <algorithm>
-
-namespace Catch {
-
-    struct TAPReporter : StreamingReporterBase<TAPReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~TAPReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in TAP format, suitable for test harnesses";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "# No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            ++counter;
-
-            stream << "# " << currentTestCaseInfo->name << std::endl;
-            AssertionPrinter printer( stream, _assertionStats, counter );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        std::size_t counter = 0;
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( true )
-            , counter(_counter)
-            {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if (result.isOk()) {
-                            printResultType(passedString());
-                        } else {
-                            printResultType(failedString());
-                        }
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if (result.isOk()) {
-                            printIssue(" # TODO");
-                        }
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-            static const char* failedString() { return "not ok"; }
-            static const char* passedString() { return "ok"; }
-
-            void printSourceInfo() const {
-                Colour colourGuard( dimColour() );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    std::string expr = result.getExpandedExpression();
-                    std::replace( expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-        };
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "1..0 # Skipped: No tests ran.";
-            } else {
-                stream << "1.." << counter;
-            }
-        }
-    };
-
-#ifdef CATCH_IMPL
-    TAPReporter::~TAPReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/test/catch2/catch_reporter_teamcity.hpp b/test/catch2/catch_reporter_teamcity.hpp
deleted file mode 100644
index 47b7e4aa..00000000
--- a/test/catch2/catch_reporter_teamcity.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- *  Created by Phil Nash on 19th December 2014
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
-        TeamCityReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        static std::string escape( std::string const& str ) {
-            std::string escaped = str;
-            replaceInPlace( escaped, "|", "||" );
-            replaceInPlace( escaped, "'", "|'" );
-            replaceInPlace( escaped, "\n", "|n" );
-            replaceInPlace( escaped, "\r", "|r" );
-            replaceInPlace( escaped, "[", "|[" );
-            replaceInPlace( escaped, "]", "|]" );
-            return escaped;
-        }
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as TeamCity service messages";
-        }
-
-        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
-        }
-
-        void noMatchingTestCases( std::string const& /* spec */ ) override {}
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            stream << "##teamcity[testSuiteStarted name='"
-                << escape( groupInfo.name ) << "']\n";
-        }
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            stream << "##teamcity[testSuiteFinished name='"
-                << escape( testGroupStats.groupInfo.name ) << "']\n";
-        }
-
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            AssertionResult const& result = assertionStats.assertionResult;
-            if( !result.isOk() ) {
-
-                ReusableStringStream msg;
-                if( !m_headerPrintedForThisSection )
-                    printSectionHeader( msg.get() );
-                m_headerPrintedForThisSection = true;
-
-                msg << result.getSourceInfo() << "\n";
-
-                switch( result.getResultType() ) {
-                    case ResultWas::ExpressionFailed:
-                        msg << "expression failed";
-                        break;
-                    case ResultWas::ThrewException:
-                        msg << "unexpected exception";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        msg << "fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        msg << "no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        msg << "explicit failure";
-                        break;
-
-                    // We shouldn't get here because of the isOk() test
-                    case ResultWas::Ok:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                        CATCH_ERROR( "Internal error in TeamCity reporter" );
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        CATCH_ERROR( "Not implemented" );
-                }
-                if( assertionStats.infoMessages.size() == 1 )
-                    msg << " with message:";
-                if( assertionStats.infoMessages.size() > 1 )
-                    msg << " with messages:";
-                for( auto const& messageInfo : assertionStats.infoMessages )
-                    msg << "\n  \"" << messageInfo.message << "\"";
-
-
-                if( result.hasExpression() ) {
-                    msg <<
-                        "\n  " << result.getExpressionInMacro() << "\n"
-                        "with expansion:\n" <<
-                        "  " << result.getExpandedExpression() << "\n";
-                }
-
-                if( currentTestCaseInfo->okToFail() ) {
-                    msg << "- failure ignore as test marked as 'ok to fail'\n";
-                    stream << "##teamcity[testIgnored"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-                else {
-                    stream << "##teamcity[testFailed"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-            }
-            stream.flush();
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            m_testTimer.start();
-            StreamingReporterBase::testCaseStarting( testInfo );
-            stream << "##teamcity[testStarted name='"
-                << escape( testInfo.name ) << "']\n";
-            stream.flush();
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            if( !testCaseStats.stdOut.empty() )
-                stream << "##teamcity[testStdOut name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
-            if( !testCaseStats.stdErr.empty() )
-                stream << "##teamcity[testStdErr name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
-            stream << "##teamcity[testFinished name='"
-                    << escape( testCaseStats.testInfo.name ) << "' duration='"
-                    << m_testTimer.getElapsedMilliseconds() << "']\n";
-            stream.flush();
-        }
-
-    private:
-        void printSectionHeader( std::ostream& os ) {
-            assert( !m_sectionStack.empty() );
-
-            if( m_sectionStack.size() > 1 ) {
-                os << getLineOfChars<'-'>() << "\n";
-
-                std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin()+1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( os, it->name );
-                os << getLineOfChars<'-'>() << "\n";
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            os << lineInfo << "\n";
-            os << getLineOfChars<'.'>() << "\n\n";
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            os << Column( _string )
-                           .indent( indent+i)
-                           .initialIndent( indent ) << "\n";
-        }
-    private:
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-#ifdef CATCH_IMPL
-    TeamCityReporter::~TeamCityReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 7e3af7cf839ee07cca12093812f323b7b396be04 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 19 Apr 2020 21:36:10 +0200
Subject: [PATCH 0188/1292] replaced slotLengthMs with lengthMs

---
 devicehandlers/FixedSlotSequence.cpp | 8 ++++----
 devicehandlers/FixedSlotSequence.h   | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index f11de94b..f68733b0 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -3,7 +3,7 @@
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		slotLengthMs(setLengthMs) {
+		lengthMs(setLengthMs) {
 	current = slotList.begin();
 }
 
@@ -50,7 +50,7 @@ uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
 	// the interval is calculated by subtracting the remaining time of the PST
 	// and adding the start time of the first handler in the list.
 	slotListIter = slotList.begin();
-	return slotLengthMs - oldTime + slotListIter->pollingTimeMs;
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
 }
 
 uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
@@ -61,7 +61,7 @@ uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
 
 	//if it is the first slot, calculate difference to last slot
 	if (slotListIter == slotList.begin()){
-		return slotLengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
 	}
 	// get previous slot
 	slotListIter--;
@@ -84,7 +84,7 @@ bool FixedSlotSequence::slotFollowsImmediately() {
 }
 
 uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->slotLengthMs;
+	return this->lengthMs;
 }
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index cad7ee87..1d872c84 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -126,7 +126,7 @@ protected:
 	 */
 	SlotList slotList;
 
-	uint32_t slotLengthMs;
+	uint32_t lengthMs;
 
 	bool isEmpty = false;
 };

From a42832ca01d9b5554b3e6b7c274bf16ce5d13f58 Mon Sep 17 00:00:00 2001
From: Uli <uli@vnks.de>
Date: Tue, 21 Apr 2020 21:34:03 +0200
Subject: [PATCH 0189/1292] working on updating SerializeIF, to quote Basti:
 This is going to be horrible

---
 container/FixedMap.h                         |  16 +-
 container/IndexedRingMemoryArray.h           |  32 +--
 datapool/DataPoolParameterWrapper.cpp        |   6 +-
 datapool/PIDReader.h                         |  34 ++--
 datapool/PoolRawAccess.cpp                   |  22 ++-
 datapool/PoolRawAccess.h                     |  16 +-
 datapool/PoolVariable.h                      |  30 +--
 datapool/PoolVector.h                        |   6 +-
 devicehandlers/DeviceTmReportingWrapper.cpp  |   8 +-
 globalfunctions/Type.cpp                     |  10 +-
 globalfunctions/Type.h                       |  16 +-
 globalfunctions/matching/MatchTree.h         |   2 +-
 globalfunctions/matching/RangeMatcher.h      |  29 +--
 health/HealthTable.cpp                       |   6 +-
 memory/MemoryHelper.cpp                      |   6 +-
 osal/rtems/CpuUsage.cpp                      |  16 +-
 parameters/ParameterWrapper.cpp              |  16 +-
 parameters/ParameterWrapper.h                |   2 +-
 power/PowerComponent.cpp                     |   8 +-
 serialize/EndianSwapper.h                    |  46 ++++-
 serialize/SerialArrayListAdapter.h           |  10 +-
 serialize/SerialBufferAdapter.cpp            |   8 +-
 serialize/SerialLinkedListAdapter.h          |  36 ++--
 serialize/SerializeAdapter.h                 | 198 +++++++++----------
 serialize/SerializeElement.h                 |  34 ++--
 serialize/SerializeIF.h                      |  15 +-
 subsystem/Subsystem.cpp                      |   2 +-
 subsystem/modes/ModeDefinitions.h            |  16 +-
 thermal/ThermalComponent.cpp                 |   8 +-
 tmstorage/TmStorePackets.h                   |  38 ++--
 tmtcpacket/packetmatcher/ApidMatcher.h       |   6 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h    |   6 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h |   6 +-
 tmtcservices/CommandingServiceBase.cpp       |   2 +-
 tmtcservices/PusVerificationReport.cpp       |  18 +-
 35 files changed, 389 insertions(+), 341 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 0b84bf4e..eaf8a24c 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -150,13 +150,13 @@ public:
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
 				buffer, size, max_size, bigEndian);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
 					size, max_size, bigEndian);
-			result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -168,9 +168,9 @@ public:
 		uint32_t i = 0;
 
 		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter<key_t>::getSerializedSize(
+			printSize += SerializeAdapter::getSerializedSize(
 					&theMap[i].first);
-			printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second);
+			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
 		}
 
 		return printSize;
@@ -178,16 +178,16 @@ public:
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
 				buffer, size, bigEndian);
 		if (this->_size > theMap.maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
+			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
 					size, bigEndian);
-			result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
+			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
 					bigEndian);
 			++i;
 		}
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 992b7489..32b61c2d 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -70,7 +70,7 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 				const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -78,17 +78,17 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 				bool bigEndian){
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -96,11 +96,11 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -108,10 +108,10 @@ public:
 	}
 
 	uint32_t getSerializedSize() const {
-		uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
-		size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
 		return size;
 	}
 
@@ -500,14 +500,14 @@ public:
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -515,7 +515,7 @@ public:
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
 		return result;
 	}
 
@@ -531,10 +531,10 @@ public:
 			size += additionalInfo->getSerializedSize();
 		}
 		size += currentWriteBlock->getSerializedSize();
-		size += AutoSerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->size);
 		size += (this->entries[0].getSerializedSize()) * this->size;
 		uint16_t crc = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&crc);
+		size += SerializeAdapter::getSerializedSize(&crc);
 		return size;
 	}
 	/**
@@ -563,7 +563,7 @@ public:
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -572,7 +572,7 @@ public:
 		}
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter<Index<T> >::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
 					bigEndian);
 			++i;
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 0ff2121d..10fb5392 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -39,18 +39,18 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
 			max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 299cc2fe..ac1d169e 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -17,7 +17,7 @@ protected:
 	uint8_t valid;
 	ReturnValue_t read() {
 		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(
+		PoolEntry<T> *read_out = ::dataPool.getData<T>(
 				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
@@ -43,7 +43,8 @@ protected:
 	 * Empty ctor for List initialization
 	 */
 	PIDReader() :
-		parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
 
 	}
 public:
@@ -63,9 +64,9 @@ public:
 	 * \param setWritable If this flag is set to true, changes in the value attribute can be
 	 * 					written back to the data pool, otherwise not.
 	 */
-	PIDReader(uint32_t setParameterId, DataSetIF* dataSet) :
-			parameterId(setParameterId), valid(
-					PoolVariableIF::INVALID), value(0) {
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
 		if (dataSet != NULL) {
 			dataSet->registerVariable(this);
 		}
@@ -74,7 +75,7 @@ public:
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
-	PIDReader(const PIDReader& rhs) :
+	PIDReader(const PIDReader &rhs) :
 			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
 	}
 
@@ -121,24 +122,25 @@ public:
 		return value;
 	}
 
-	PIDReader<T> &operator=(T newValue) {
+	PIDReader<T>& operator=(T newValue) {
 		value = newValue;
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
 	}
 };
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 555896bb..2053498b 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -145,10 +145,12 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	//TODO integer overflow
+	if (typeSize + *size <= maxSize) {
+#error use endian swapper
+		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -169,16 +171,16 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
 	}
 }
 
-uint32_t PoolRawAccess::getSerializedSize() const {
+size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
-	*size -= typeSize;
-	if (*size >= 0) {
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 
-		if (bigEndian) {
+	if (*size >= typeSize) {
+		*size -= typeSize;
+		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 3e2bd7ae..190c38a9 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -70,7 +70,7 @@ public:
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
 	uint8_t value[RAW_MAX_SIZE];
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+			DataSetIF *data_set, ReadWriteMode_t setReadWriteMode =
 					PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
@@ -97,7 +97,7 @@ public:
 	 * \return	- \c RETURN_OK if entry could be acquired
 	 * 			- \c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size,
 			uint32_t max_size);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
@@ -106,7 +106,7 @@ public:
 	 * @return	- \c RETURN_OK on success
 	 * 			- \c RETURN_FAILED on failure
 	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+	ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
 			uint32_t setSize);
 	/**
 	 *  \brief This operation returns the type of the entry currently stored.
@@ -140,13 +140,13 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			 Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			 Endianness streamEndianness) override;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index 25345c0a..ce073426 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -58,7 +58,7 @@ protected:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+		PoolEntry<T> *read_out = ::dataPool.getData < T > (dataPoolId, 1);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = *(read_out->address);
@@ -79,7 +79,7 @@ protected:
 	 *
 	 */
 	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+		PoolEntry<T> *write_back = ::dataPool.getData < T > (dataPoolId, 1);
 		if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 			write_back->valid = valid;
 			*(write_back->address) = value;
@@ -115,7 +115,7 @@ public:
 	 * \param setWritable If this flag is set to true, changes in the value attribute can be
 	 * 					written back to the data pool, otherwise not.
 	 */
-	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
+	PoolVariable(uint32_t set_id, DataSetIF *dataSet,
 			ReadWriteMode_t setReadWriteMode) :
 			dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
 					setReadWriteMode), value(0) {
@@ -126,7 +126,7 @@ public:
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
-	PoolVariable(const PoolVariable& rhs) :
+	PoolVariable(const PoolVariable &rhs) :
 			dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
 					rhs.readWriteMode), value(rhs.value) {
 	}
@@ -184,29 +184,29 @@ public:
 		return value;
 	}
 
-	PoolVariable<T> &operator=(T newValue) {
+	PoolVariable<T>& operator=(T newValue) {
 		value = newValue;
 		return *this;
 	}
 
-	PoolVariable<T> &operator=(PoolVariable<T> newPoolVariable) {
+	PoolVariable<T>& operator=(PoolVariable<T> newPoolVariable) {
 		value = newPoolVariable.value;
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t max_size, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize<T>(&value, buffer, size, max_size,
+				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+	virtual uint32_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index d3617d17..3809f93b 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -202,7 +202,7 @@ public:
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
 					max_size, bigEndian);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -212,7 +212,7 @@ public:
 	}
 
 	virtual uint32_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+		return vector_size * SerializeAdapter::getSerializedSize(value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
@@ -220,7 +220,7 @@ public:
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
 					bigEndian);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 2c9e820f..55861c3c 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -13,12 +13,12 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
 		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
+	result = SerializeAdapter::serialize(&actionId, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -32,12 +32,12 @@ uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 814d26f4..b7b7fd82 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -68,13 +68,13 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&ptc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&ptc, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&pfc, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&pfc, buffer, size, max_size,
 			bigEndian);
 
 	return result;
@@ -83,20 +83,20 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 
 uint32_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
 ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter<uint8_t>::deSerialize(&ptc, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 88df07b6..3ec250b0 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -22,7 +22,7 @@ public:
 
 	Type(ActualType_t actualType);
 
-	Type(const Type& type);
+	Type(const Type &type);
 
 	Type& operator=(Type rhs);
 
@@ -30,8 +30,8 @@ public:
 
 	operator ActualType_t() const;
 
-	bool operator==(const Type& rhs);
-	bool operator!=(const Type& rhs);
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
 
 	uint8_t getSize() const;
 
@@ -39,13 +39,13 @@ public:
 
 	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override;
 
 private:
 	ActualType_t actualType;
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 398cf3f0..0ee3890b 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -49,7 +49,7 @@ public:
 			const uint32_t max_size, bool bigEndian) const {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 10e07173..c30406f6 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -4,7 +4,6 @@
 #include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
 #include <framework/serialize/SerializeAdapter.h>
 
-
 template<typename T>
 class RangeMatcher: public SerializeableMatcherIF<T> {
 public:
@@ -27,34 +26,40 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&inverted, buffer, size, max_size,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	uint32_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
 	}
 protected:
 	bool doMatch(T input) {
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index a575b282..48ee6679 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -67,16 +67,16 @@ void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
 	uint32_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, true);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
-		result = SerializeAdapter<object_id_t>::serialize(&iter->first,
+		result = SerializeAdapter::serialize(&iter->first,
 				&pointer, &size, maxSize, true);
 		uint8_t health = iter->second;
-		result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
 				maxSize, true);
 	}
 	mutex->unlockMutex();
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 69830084..c89fd5a4 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -53,7 +53,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		memcpy(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianSwapper::swap(copyHere, dataToCopy, size);
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
 		break;
 	case HasMemoryIF::ACTIVITY_COMPLETED:
 	case RETURN_OK:
@@ -86,7 +86,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 	case HasMemoryIF::POINTS_TO_VARIABLE:
 		//"data" must be valid pointer!
 		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianSwapper::swap(reservedSpaceInIPC, dataToCopy, size);
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
 		} else {
 			memcpy(reservedSpaceInIPC, dataToCopy, size);
 		}
@@ -136,7 +136,7 @@ void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
 	}
 
 	while (totalSize > 0){
-		EndianSwapper::swap(out,in,datatypeSize);
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
 		out += datatypeSize;
 		in += datatypeSize;
 		totalSize -= datatypeSize;
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 9fc34ff1..903a4d0e 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -91,7 +91,7 @@ void CpuUsage::clear() {
 
 ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(
+	ReturnValue_t result = SerializeAdapter::serialize(
 			&timeSinceLastReset, buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -111,7 +111,7 @@ uint32_t CpuUsage::getSerializedSize() const {
 
 ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
 		bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(
+	ReturnValue_t result = SerializeAdapter::deSerialize(
 			&timeSinceLastReset, buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -122,7 +122,7 @@ ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
 
 ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -133,12 +133,12 @@ ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::serialize(&timeRunning,
+	result = SerializeAdapter::serialize(&timeRunning,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::serialize(&percentUsage,
+	result = SerializeAdapter::serialize(&percentUsage,
 			buffer, size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -159,7 +159,7 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 		int32_t* size, bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -169,12 +169,12 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	}
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter<float>::deSerialize(&timeRunning,
+	result = SerializeAdapter::deSerialize(&timeRunning,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<float>::deSerialize(&percentUsage,
+	result = SerializeAdapter::deSerialize(&percentUsage,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8f661bb3..9dcbc6d5 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -24,18 +24,18 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
+	result = SerializeAdapter::serialize(&columns, buffer, size,
 			max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
+	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
 			bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
@@ -94,7 +94,7 @@ ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
+		result = SerializeAdapter::serialize(element, buffer, size, max_size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -123,7 +123,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
 					true);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -155,18 +155,18 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 
 ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
 		const uint8_t **remainingStream, int32_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
+	result = SerializeAdapter::deSerialize(&columns, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
 			true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f61786b8..e6d29c59 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -54,7 +54,7 @@ public:
 			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
 			streamWithtype += (row * columns + column) * type.getSize();
 			int32_t size = type.getSize();
-			return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
+			return SerializeAdapter::deSerialize(value, &streamWithtype,
 					&size, true);
 		} else {
 			const T *dataWithType = (const T *) readonlyData;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 6a87d88b..53bb06c8 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -19,12 +19,12 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
 		const uint32_t max_size, bool bigEndian) const {
-	ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
 			size, max_size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::serialize(&max, buffer, size, max_size,
+	return SerializeAdapter::serialize(&max, buffer, size, max_size,
 			bigEndian);
 }
 
@@ -58,12 +58,12 @@ float PowerComponent::getMax() {
 
 ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
 bool bigEndian) {
-	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
 			size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter<float>::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, bigEndian);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianSwapper.h
index 6ff54444..e142c2a1 100644
--- a/serialize/EndianSwapper.h
+++ b/serialize/EndianSwapper.h
@@ -5,20 +5,20 @@
 #include <cstring>
 #include <iostream>
 
-class EndianSwapper {
+class EndianConverter {
 private:
-	EndianSwapper() {
+	EndianConverter() {
 	}
 	;
 public:
 	template<typename T>
-	static T swap(T in) {
+	static T convertBigEndian(T in) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
 		T tmp;
-		uint8_t *pointerOut = (uint8_t *) &tmp;
-		uint8_t *pointerIn = (uint8_t *) &in;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
 		for (uint8_t count = 0; count < sizeof(T); count++) {
 			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 		}
@@ -29,7 +29,8 @@ public:
 #error Unknown Byte Order
 #endif
 	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			uint32_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -40,6 +41,39 @@ public:
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 		memcpy(out, in, size);
 		return;
+#endif
+	}
+
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (uint8_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			uint32_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (uint8_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
 #endif
 	}
 };
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 5ffbc375..ab0c6c6f 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -27,11 +27,11 @@ public:
 
 	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
 				buffer, size, max_size, bigEndian);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
 					max_size, bigEndian);
 			++i;
 		}
@@ -47,7 +47,7 @@ public:
 		count_t i = 0;
 
 		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]);
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
 		}
 
 		return printSize;
@@ -61,7 +61,7 @@ public:
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
 		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
 				buffer, size, bigEndian);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
@@ -69,7 +69,7 @@ public:
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter<T>::deSerialize(
+			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
 					bigEndian);
 			++i;
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3ed083bf..f78ec8ac 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -26,14 +26,14 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 		const uint32_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += AutoSerializeAdapter::getSerializedSize(
+		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
 	if (*size + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
 					max_size, bigEndian);
 		}
 		if (this->constBuffer != NULL) {
@@ -52,7 +52,7 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 template<typename T>
 uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
-		return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
 		return bufferLength;
 	}
@@ -63,7 +63,7 @@ ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
-			T serializedSize = AutoSerializeAdapter::getSerializedSize(
+			T serializedSize = SerializeAdapter::getSerializedSize(
 					&bufferLength);
 			if((*size - bufferLength - serializedSize) >= 0){
 				*buffer +=  serializedSize;
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 29952c4a..7b10e331 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -31,32 +31,32 @@ public:
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
-					buffer, size, max_size, bigEndian);
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, max_size,
-				bigEndian);
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
 	}
 
 	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, uint32_t* size, const uint32_t max_size,
-			bool bigEndian) {
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, max_size,
-					bigEndian);
+			result = element->value->serialize(buffer, size, maxSize,
+					streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -64,8 +64,8 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
-	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
-		uint32_t size = 0;
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
 		while (element != NULL) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
@@ -73,16 +73,16 @@ public:
 		return size;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, int32_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, bigEndian);
+			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index fd9e1b6a..73323c2a 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -10,116 +10,114 @@
 /**
  * \ingroup serialize
  */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		uint32_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
 
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	uint32_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-
-};
-
-template<typename T>
-class SerializeAdapter_<T, 1> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		uint32_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-	uint32_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-template<typename T>
 class SerializeAdapter {
-public:
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
-
-
-class AutoSerializeAdapter {
 public:
 	template<typename T>
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			uint32_t* size, const uint32_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
+	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
 	}
 	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.getSerializedSize(object);
 	}
 	template<typename T>
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			int32_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
 	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) const {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
 };
 
 #endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index db7db20a..22e9838c 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -9,41 +9,43 @@
  * \ingroup serialize
  */
 template<typename T>
-class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
 public:
-	template<typename... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
 
 	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
 	}
 	T entry;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&entry);
+	uint32_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
 	}
 	operator T() {
 		return entry;
 	}
 
-	SerializeElement<T> &operator=(T newValue) {
+	SerializeElement<T>& operator=(T newValue) {
 		entry = newValue;
 		return *this;
 	}
-	T *operator->() {
+	T* operator->() {
 		return &entry;
 	}
 };
 
-
-
 #endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 701fbf56..6c875a5c 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,6 +2,7 @@
 #define SERIALIZEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <stddef.h>
 
 /**
  * \defgroup serialize Serialization
@@ -14,6 +15,10 @@
  */
 class SerializeIF {
 public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
 	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
@@ -22,13 +27,13 @@ public:
 	virtual ~SerializeIF() {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const = 0;
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t max_size, Endianness streamEndianness) const = 0;
 
-	virtual uint32_t getSerializedSize() const = 0;
+	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) = 0;
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
 
 };
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index e1ec544b..ef706dd7 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -169,7 +169,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
 			int32_t size = sizeRead;
-			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
+			result = SerializeAdapter::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 8e7531f3..3e749dd8 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -23,26 +23,26 @@ public:
 
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
+		result = SerializeAdapter::serialize(&value1, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
+		result = SerializeAdapter::serialize(&value2, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
+		result = SerializeAdapter::serialize(&value3, buffer, size,
 				max_size, bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
-		result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
+		result = SerializeAdapter::serialize(&value4, buffer, size,
 				max_size, bigEndian);
 
 		return result;
@@ -57,25 +57,25 @@ public:
 	bool bigEndian) {
 		ReturnValue_t result;
 
-		result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
 				bigEndian);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
 				bigEndian);
 
 		return result;
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index bf6f7398..93513e16 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -47,13 +47,13 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 		return MonitoringIF::INVALID_SIZE;
 	}
 	int32_t readSize = size;
-	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
+	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
 			&readSize, true);
-	SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
+	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
 			&readSize, true);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 6eea6f58..4e7160fb 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -34,12 +34,12 @@ public:
 	uint16_t ssc;
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
 				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size,
+		return SerializeAdapter::serialize(&ssc, buffer, size,
 				max_size, bigEndian);
 
 	}
@@ -50,12 +50,12 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
 				buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size,
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
 				bigEndian);
 	}
 };
@@ -220,23 +220,23 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -246,11 +246,11 @@ public:
 
 	uint32_t getSerializedSize() const {
 		uint32_t size = 0;
-		size += AutoSerializeAdapter::getSerializedSize(&apid);
-		size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceType);
-		size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += AutoSerializeAdapter::getSerializedSize(&subCounter);
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
 		size += adapter.getSerializedSize();
 		return size;
@@ -259,27 +259,27 @@ public:
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 	bool bigEndian) {
-		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
 				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
 				bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 1f194968..d5d96f2d 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -24,14 +24,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&apid, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+		return SerializeAdapter::getSerializedSize(&apid);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&apid, buffer, size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index 1a6781b4..b0623780 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -24,14 +24,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&service, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+		return SerializeAdapter::getSerializedSize(&service);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&service, buffer, size, bigEndian);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b589b20..90370af1 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -22,14 +22,14 @@ public:
 	}
 	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
 			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+		return SerializeAdapter::serialize(&subService, buffer, size, max_size, bigEndian);
 	}
 	uint32_t getSerializedSize() const {
-		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+		return SerializeAdapter::getSerializedSize(&subService);
 	}
 	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter::deSerialize(&subService, buffer, size, bigEndian);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index d70b9042..5b9e7b68 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -236,7 +236,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
 	uint32_t size = 0;
-	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+	SerializeAdapter::serialize(&objectId, &pBuffer, &size,
 			sizeof(object_id_t), true);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, buffer, size);
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 1bc53c2a..e1dad2be 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -108,12 +108,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		uint16_t setSequenceControl, uint8_t setStep) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
 				sizeof(reportBuffer), true);
 	}
 }
@@ -135,19 +135,19 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
 	if (setStep != 0) {
-		SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
 				sizeof(reportBuffer), true);
 	}
-	SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer,
 			&reportSize, sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
-	SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
 			sizeof(reportBuffer), true);
 }
 

From 6553450b4b85ea7ec53e88850195af35d76d85b2 Mon Sep 17 00:00:00 2001
From: Uli <uli@vnks.de>
Date: Tue, 21 Apr 2020 22:28:43 +0200
Subject: [PATCH 0190/1292] Actually, not that horrible, thanks to sed

---
 action/ActionHelper.cpp                      |   6 +-
 action/CommandActionHelper.cpp               |  39 ++++---
 container/FixedMap.h                         |  22 ++--
 container/IndexedRingMemoryArray.h           |  60 +++++------
 datapool/DataPool.cpp                        |   4 +-
 datapool/DataPoolAdmin.cpp                   |   6 +-
 datapool/DataPoolParameterWrapper.cpp        |  20 ++--
 datapool/DataPoolParameterWrapper.h          |  10 +-
 datapool/DataSet.cpp                         |  18 ++--
 datapool/DataSet.h                           |  10 +-
 datapool/PoolRawAccess.cpp                   |   6 +-
 datapool/PoolRawAccess.h                     |   6 +-
 datapool/PoolVariable.h                      |   6 +-
 datapool/PoolVector.h                        |  14 +--
 devicehandlers/DeviceTmReportingWrapper.cpp  |  18 ++--
 devicehandlers/DeviceTmReportingWrapper.h    |  10 +-
 events/eventmatching/EventRangeMatcherBase.h |  14 +--
 globalfunctions/Type.cpp                     |  22 ++--
 globalfunctions/conversion.cpp               | 104 -------------------
 globalfunctions/conversion.h                 |  24 -----
 globalfunctions/matching/MatchTree.h         |  20 ++--
 globalfunctions/matching/RangeMatcher.h      |  10 +-
 health/HealthTable.cpp                       |  10 +-
 health/HealthTable.h                         |   2 +-
 monitoring/LimitViolationReporter.cpp        |   6 +-
 osal/rtems/CpuUsage.cpp                      |  36 +++----
 osal/rtems/CpuUsage.h                        |  20 ++--
 parameters/ParameterHelper.cpp               |   6 +-
 parameters/ParameterWrapper.cpp              |  92 ++++++++--------
 parameters/ParameterWrapper.h                |  22 ++--
 power/Fuse.cpp                               |  14 +--
 power/Fuse.h                                 |  27 ++---
 power/PowerComponent.cpp                     |  20 ++--
 power/PowerComponent.h                       |  10 +-
 serialize/SerialArrayListAdapter.h           |  30 +++---
 serialize/SerialBufferAdapter.cpp            |  12 +--
 serialize/SerialBufferAdapter.h              |  10 +-
 serialize/SerialFixedArrayListAdapter.h      |  14 +--
 serialize/SerializeElement.h                 |   2 +-
 serialize/SerializeIF.h                      |   2 +-
 subsystem/Subsystem.cpp                      |  39 ++++---
 subsystem/modes/ModeDefinitions.h            |  26 ++---
 thermal/ThermalComponent.cpp                 |  10 +-
 tmstorage/TmStorePackets.h                   |  52 +++++-----
 tmtcpacket/packetmatcher/ApidMatcher.h       |  14 +--
 tmtcpacket/packetmatcher/ServiceMatcher.h    |  14 +--
 tmtcpacket/packetmatcher/SubserviceMatcher.h |  14 +--
 tmtcpacket/pus/TmPacketStored.cpp            |  33 +++---
 tmtcservices/CommandingServiceBase.cpp       |   4 +-
 tmtcservices/PusVerificationReport.cpp       |  28 ++---
 tmtcservices/PusVerificationReport.h         |   6 +-
 51 files changed, 458 insertions(+), 566 deletions(-)
 delete mode 100644 globalfunctions/conversion.cpp
 delete mode 100644 globalfunctions/conversion.h

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9c1475f1..f93afaa8 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -71,18 +71,18 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
 	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize == 0) {
 		//No error, there's simply nothing to report.
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	uint32_t size = 0;
+	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, true);
+	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		ipcStore->deleteData(storeAddress);
 		return result;
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 05eb9346..6a26453c 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -4,30 +4,31 @@
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
-CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
 		owner(setOwner), queueToUse(NULL), ipcStore(
-				NULL), commandCount(0), lastTarget(0) {
+		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);
+		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;
-	uint32_t maxSize = data->getSerializedSize();
+	uint8_t *storePointer;
+	size_t maxSize = data->getSerializedSize();
 	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
 			&storePointer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize, true);
+	size_t size = 0;
+	result = data->serialize(&storePointer, &size, maxSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -35,11 +36,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 }
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t* data, uint32_t size) {
+		ActionId_t actionId, const uint8_t *data, uint32_t size) {
 //	if (commandCount != 0) {
 //		return CommandsFunctionsIF::ALREADY_COMMANDING;
 //	}
-	HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
+	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
 	if (receiver == NULL) {
 		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
 	}
@@ -71,13 +72,13 @@ ReturnValue_t CommandActionHelper::initialize() {
 	}
 
 	queueToUse = owner->getCommandQueuePtr();
-	if(queueToUse == NULL){
+	if (queueToUse == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 	if (reply->getSender() != lastTarget) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::COMPLETION_FAILED:
 		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
+		owner->completionFailedReceived(ActionMessage::getActionId(reply),
+				ActionMessage::getReturnCode(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_SUCCESS:
 		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
 		return HasReturnvaluesIF::RETURN_OK;
 	case ActionMessage::STEP_FAILED:
 		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
+		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));
+		extractDataForOwner(ActionMessage::getActionId(reply),
+				ActionMessage::getStoreId(reply));
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -111,8 +115,9 @@ uint8_t CommandActionHelper::getCommandCount() const {
 	return commandCount;
 }
 
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId,
+		store_address_t storeId) {
+	const uint8_t *data = NULL;
 	uint32_t size = 0;
 	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/container/FixedMap.h b/container/FixedMap.h
index eaf8a24c..ac170bd2 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -148,22 +148,22 @@ public:
 		return theMap.maxSize();
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	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, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
 			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, max_size, bigEndian);
+					size, maxSize, streamEndianness);
 			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		uint32_t printSize = sizeof(_size);
 		uint32_t i = 0;
 
@@ -176,19 +176,19 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, bigEndian);
+				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, bigEndian);
+					size, streamEndianness);
 			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 32b61c2d..6e7f330c 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -68,46 +68,46 @@ public:
 		return this->storedPackets;
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.serialize(buffer,size,max_size,bigEndian);
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = indexType.deSerialize(buffer,size,bigEndian);
+		result = indexType.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
 		size += indexType.getSerializedSize();
 		size += SerializeAdapter::getSerializedSize(&this->size);
@@ -485,22 +485,22 @@ public:
 	 * Parameters according to HasSerializeIF
 	 * @param buffer
 	 * @param size
-	 * @param max_size
-	 * @param bigEndian
+	 * @param maxSize
+	 * @param streamEndianness
 	 * @return
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const{
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
 		uint8_t* crcBuffer = *buffer;
 		uint32_t oldSize = *size;
 		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,max_size,bigEndian);
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
 		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -508,14 +508,14 @@ public:
 		uint32_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
 			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
 		return result;
 	}
 
@@ -524,7 +524,7 @@ public:
 	 * Get the serialized Size of the index
 	 * @return The serialized size of the index
 	 */
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 
 		uint32_t size = 0;
 		if(additionalInfo!=NULL){
@@ -542,28 +542,28 @@ public:
 	 * CRC Has to be checked before!
 	 * @param buffer
 	 * @param size
-	 * @param bigEndian
+	 * @param streamEndianness
 	 * @return
 	 */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian){
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
 
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,bigEndian);
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 
 		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,bigEndian);
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
 		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
 		if(result != HasReturnvaluesIF::RETURN_OK){
 					return result;
 		}
@@ -574,7 +574,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
 			result = SerializeAdapter::deSerialize(
 					&this->entries[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		if(result != HasReturnvaluesIF::RETURN_OK){
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 89543d77..6604dc23 100644
--- a/datapool/DataPool.cpp
+++ b/datapool/DataPool.cpp
@@ -39,10 +39,10 @@ PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
 	}
 }
 
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) {
+//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
 //	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
 //	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= max_size ) {
+//		if ( it->second->getByteSize() <= maxSize ) {
 //			*size = it->second->getByteSize();
 //			memcpy( address, it->second->getRawData(), *size );
 //			return DP_SUCCESSFUL;
diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp
index fe6b9215..8bf7f6b3 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapool/DataPoolAdmin.cpp
@@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 //identical to ParameterHelper::sendParameter()
 ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		const DataPoolParameterWrapper* wrapper) {
-	uint32_t serializedSize = wrapper->getSerializedSize();
+	size_t serializedSize = wrapper->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -272,10 +272,10 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = wrapper->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp
index 10fb5392..e08eba5b 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapool/DataPoolParameterWrapper.cpp
@@ -36,22 +36,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 }
 
 ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+			maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -60,7 +60,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 		DataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
-		result = raw.serialize(buffer,size,max_size,bigEndian);
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
@@ -69,8 +69,8 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 }
 
 //same as ParameterWrapper
-uint32_t DataPoolParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
 	serializedSize += sizeof(columns);
@@ -80,7 +80,7 @@ uint32_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h
index faadf659..a3dbdc04 100644
--- a/datapool/DataPoolParameterWrapper.h
+++ b/datapool/DataPoolParameterWrapper.h
@@ -11,13 +11,13 @@ public:
 
 	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
index b4725c73..94cdcf0c 100644
--- a/datapool/DataSet.cpp
+++ b/datapool/DataSet.cpp
@@ -106,12 +106,12 @@ uint8_t DataSet::lockDataPool() {
 	return ::dataPool.lockDataPool();
 }
 
-ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t DataSet::getSerializedSize() const {
-	uint32_t size = 0;
+size_t DataSet::getSerializedSize() const {
+	size_t size = 0;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		size += registeredVariables[count]->getSerializedSize();
 	}
@@ -136,12 +136,12 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
index 982be692..3d211537 100644
--- a/datapool/DataSet.h
+++ b/datapool/DataSet.h
@@ -146,13 +146,13 @@ public:
 	 */
 	void setValid(uint8_t valid);
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 };
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 2053498b..94766d87 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -69,12 +69,12 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		uint32_t* writtenBytes, uint32_t maxSize) {
 	uint8_t* data_ptr = getEntry();
 //	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
 	if (typeSize == 0)
 		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
+	if (typeSize > maxSize)
 		return INCORRECT_SIZE;
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -149,7 +149,7 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
 		size_t maxSize, Endianness streamEndianness) const {
 	//TODO integer overflow
 	if (typeSize + *size <= maxSize) {
-#error use endian swapper
+#warning use endian swapper
 		if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index 190c38a9..8cc8f3f0 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -90,15 +90,15 @@ public:
 	 * \details	It makes use of the getEntry call of this function, but additionally flips the
 	 * 			bytes to big endian, which is the default for external communication (as House-
 	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
+	 * 			buffer, if it fits in the given maxSize.
 	 * \param buffer	A pointer to a buffer to write to
 	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param max_size	The maximum size that the function may write to buffer.
+	 * \param maxSize	The maximum size that the function may write to buffer.
 	 * \return	- \c RETURN_OK if entry could be acquired
 	 * 			- \c RETURN_FAILED else.
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, uint32_t *size,
-			uint32_t max_size);
+			uint32_t maxSize);
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
index ce073426..c1a57539 100644
--- a/datapool/PoolVariable.h
+++ b/datapool/PoolVariable.h
@@ -195,12 +195,12 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize<T>(&value, buffer, size, max_size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	virtual uint32_t getSerializedSize() const override {
+	virtual size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&value);
 	}
 
diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
index 3809f93b..50724054 100644
--- a/datapool/PoolVector.h
+++ b/datapool/PoolVector.h
@@ -197,13 +197,13 @@ public:
 		return *this;
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
 			result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -211,17 +211,17 @@ public:
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return vector_size * SerializeAdapter::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		uint16_t i;
 		ReturnValue_t result;
 		for (i = 0; i < vector_size; i++) {
 			result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
+					streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 55861c3c..ce5eb109 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -12,35 +12,35 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		uint32_t* size, const uint32_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->serialize(buffer, size, max_size, bigEndian);
+	return data->serialize(buffer, size, maxSize, streamEndianness);
 }
 
-uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
 	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return data->deSerialize(buffer, size, bigEndian);
+	return data->deSerialize(buffer, size, streamEndianness);
 }
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 1cd9470d..4432b7f1 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -11,13 +11,13 @@ public:
 			SerializeIF *data);
 	virtual ~DeviceTmReportingWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 private:
 	object_id_t objectId;
 	ActionId_t actionId;
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 921a5d6a..587669ba 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -11,16 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
 public:
 	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
 	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return rangeMatcher.deSerialize(buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
 	}
 protected:
 	RangeMatcher<T> rangeMatcher;
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index b7b7fd82..a481f768 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
 	}
 }
 
-ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@@ -68,36 +68,36 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&ptc, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&pfc, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
 
 	return result;
 
 }
 
-uint32_t Type::getSerializedSize() const {
+size_t Type::getSerializedSize() const {
 	uint8_t dontcare = 0;
 	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	uint8_t ptc;
 	uint8_t pfc;
 	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
 	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			bigEndian);
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/globalfunctions/conversion.cpp b/globalfunctions/conversion.cpp
deleted file mode 100644
index d4f542bd..00000000
--- a/globalfunctions/conversion.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include <framework/globalfunctions/conversion.h>
-#include <framework/osal/Endiness.h>
-#include <cstring>
-
-
-
-//SHOULDDO: This shall be optimized (later)!
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size +=4;
-}
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF00) >> 8;
-	buffer[1] = (value & 0x00FF);
-	*size += 2;
-}
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
-	buffer[0] = (value & 0xFF000000) >> 24;
-	buffer[1] = (value & 0x00FF0000) >> 16;
-	buffer[2] = (value & 0x0000FF00) >> 8;
-	buffer[3] = (value & 0x000000FF);
-	*size += 4;
-}
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
-//	buffer[0] = (value & 0xFF00000000000000) >> 56;
-//	buffer[1] = (value & 0x00FF000000000000) >> 48;
-//	buffer[2] = (value & 0x0000FF0000000000) >> 40;
-//	buffer[3] = (value & 0x000000FF00000000) >> 32;
-//	buffer[4] = (value & 0x00000000FF000000) >> 24;
-//	buffer[5] = (value & 0x0000000000FF0000) >> 16;
-//	buffer[6] = (value & 0x000000000000FF00) >> 8;
-//	buffer[7] = (value & 0x00000000000000FF);
-//	*size+=8;
-//}
-
-void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union float_union {
-		float value;
-		uint8_t chars[4];
-	};
-	float_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[3];
-	buffer[1] = temp.chars[2];
-	buffer[2] = temp.chars[1];
-	buffer[3] = temp.chars[0];
-	*size += 4;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
-
-void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	union double_union {
-		double value;
-		uint8_t chars[8];
-	};
-	double_union temp;
-	temp.value = in_value;
-	buffer[0] = temp.chars[7];
-	buffer[1] = temp.chars[6];
-	buffer[2] = temp.chars[5];
-	buffer[3] = temp.chars[4];
-	buffer[4] = temp.chars[3];
-	buffer[5] = temp.chars[2];
-	buffer[6] = temp.chars[1];
-	buffer[7] = temp.chars[0];
-	*size += 8;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, &in_value, sizeof(in_value));
-	*size += sizeof(in_value);
-#endif
-}
diff --git a/globalfunctions/conversion.h b/globalfunctions/conversion.h
deleted file mode 100644
index 0d1ca1a6..00000000
--- a/globalfunctions/conversion.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef CONVERSION_H_
-#define CONVERSION_H_
-
-
-#include <stdint.h>
-
-
-void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
-
-//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
-//
-//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
-
-void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
-
-#endif /* CONVERSION_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 0ee3890b..b54f5492 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -45,38 +45,38 @@ public:
 		return matchSubtree(iter, number);
 	}
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
 		iterator iter = this->begin();
 		uint8_t count = this->countRight(iter);
 		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (iter == this->end()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
-		result = iter->serialize(buffer, size, max_size, bigEndian);
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		if (maxDepth > 0) {
 			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, max_size, bigEndian);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
 		}
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		iter = iter.right();
 		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, max_size, bigEndian);
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
 			if (maxDepth > 0) {
 				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, max_size, bigEndian);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
 			}
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
@@ -86,7 +86,7 @@ public:
 		return result;
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const override {
 		//Analogous to serialize!
 		uint32_t size = 1; //One for count
 		iterator iter = this->begin();
@@ -115,8 +115,8 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index c30406f6..6fee1f52 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -26,23 +26,23 @@ public:
 		}
 	}
 
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t max_size,
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
 			SerializeIF::Endianness streamEndianness) const override {
 		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, max_size, streamEndianness);
+				size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				max_size, streamEndianness);
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, max_size,
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 48ee6679..bd6606db 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
 	return exits;
 }
 
-void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 	mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	uint32_t size = 0;
+	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, true);
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 	HealthMap::iterator iter;
 	for (iter = healthMap.begin();
 			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
 			++iter) {
 		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, true);
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
 		uint8_t health = iter->second;
 		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, true);
+				maxSize, SerializeIF::Endianness::BIG);
 	}
 	mutex->unlockMutex();
 }
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 32a7eee2..2c74bda4 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -21,7 +21,7 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t);
 
 	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize);
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
 
 protected:
 	MutexIF* mutex;
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 760e8b93..489a8f9e 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	}
 	store_address_t storeId;
 	uint8_t* dataTarget = NULL;
-	uint32_t maxSize = data->getSerializedSize();
+	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
 	}
@@ -26,8 +26,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	uint32_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, true);
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 903a4d0e..61b66c3d 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -89,15 +89,15 @@ void CpuUsage::clear() {
 	threadData.clear();
 }
 
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, max_size, bigEndian);
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 }
 
 uint32_t CpuUsage::getSerializedSize() const {
@@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
-		bool bigEndian) {
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, bigEndian);
+			&timeSinceLastReset, buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 }
 
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) {
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
 		return BUFFER_TOO_SHORT;
 	}
 	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
 	*size += MAX_LENGTH_OF_THREAD_NAME;
 	*buffer += MAX_LENGTH_OF_THREAD_NAME;
 	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, max_size, bigEndian);
+			buffer, size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		int32_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,12 +170,12 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
 	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
 	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
 	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, bigEndian);
+			buffer, size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index 3d317e4e..eb03c5e3 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -18,13 +18,13 @@ public:
 		float timeRunning;
 		float percentUsage;
 
-		virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-				const uint32_t max_size, bool bigEndian) const;
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override;
 
-		virtual uint32_t getSerializedSize() const;
+		virtual size_t getSerializedSize() const override;
 
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-				bool bigEndian);
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override;
 	};
 
 	CpuUsage();
@@ -41,13 +41,13 @@ public:
 
 	void clear();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 };
 
 #endif /* CPUUSAGE_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 75b71a7e..725fa1d7 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -83,7 +83,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		const ParameterWrapper* description) {
-	uint32_t serializedSize = description->getSerializedSize();
+	size_t serializedSize = description->getSerializedSize();
 
 	uint8_t *storeElement;
 	store_address_t address;
@@ -94,10 +94,10 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	uint32_t storeElementSize = 0;
+	size_t storeElementSize = 0;
 
 	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, true);
+			serializedSize, SerializeIF::Endianness::BIG);
 
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		storage->deleteData(address);
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 9dcbc6d5..602ec361 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -2,41 +2,41 @@
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
-				NULL), readonlyData(NULL) {
+		NULL), readonlyData(NULL) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void* data) :
+		void *data) :
 		pointsToStream(false), type(type), rows(rows), columns(columns), data(
 				data), readonlyData(data) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void* data) :
+		const void *data) :
 		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-				NULL), readonlyData(data) {
+		NULL), readonlyData(data) {
 }
 
 ParameterWrapper::~ParameterWrapper() {
 }
 
-ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result;
 
-	result = SerializeAdapter::serialize(&type, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			max_size, bigEndian);
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, max_size,
-			bigEndian);
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	}
 	switch (type) {
 	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
 		break;
 	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, max_size, bigEndian);
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
 		break;
 	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, max_size, bigEndian);
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
 		break;
 	default:
 		result = UNKNOW_DATATYPE;
@@ -77,7 +82,7 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, uint32_t* size,
 	return result;
 }
 
-uint32_t ParameterWrapper::getSerializedSize() const {
+size_t ParameterWrapper::getSerializedSize() const {
 	uint32_t serializedSize = 0;
 	serializedSize += type.getSerializedSize();
 	serializedSize += sizeof(rows);
@@ -88,14 +93,14 @@ uint32_t ParameterWrapper::getSerializedSize() const {
 }
 
 template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
 	const T *element = (const T*) readonlyData;
 	ReturnValue_t result;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, max_size,
-				bigEndian);
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -111,21 +116,21 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-	int32_t streamSize = fromRows * fromColumns * sizeof(T);
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T *) data)
+		T *dataWithDataType = ((T*) data)
 				+ (((startingRow + fromRow) * columns) + startingColumn);
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(
 					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					true);
+					SerializeIF::Endianness::BIG);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
 				return result;
 			}
@@ -136,13 +141,14 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 }
 
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
-	return deSerialize(buffer, size, bigEndian, 0);
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
 }
 
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,26 +159,26 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
-		const uint8_t **remainingStream, int32_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, true);
+			&streamSize, SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	result = SerializeAdapter::deSerialize(&columns, &stream,
-			&streamSize, true);
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			true);
+			SerializeIF::Endianness::BIG);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		return SerializeIF::STREAM_TOO_SHORT;
@@ -194,7 +200,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, int32_t streamSize,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
 	if (data == NULL) {
 		return READONLY;
@@ -261,7 +267,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
 		}
 	} else {
 		//need a type to do arithmetic
-		uint8_t *toDataWithType = (uint8_t *) data;
+		uint8_t *toDataWithType = (uint8_t*) data;
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
 			memcpy(
 					toDataWithType
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index e6d29c59..a00c997c 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -25,16 +25,16 @@ public:
 			const void *data);
 	virtual ~ParameterWrapper();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian, uint16_t startWritingAtIndex = 0);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
 	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@@ -111,8 +111,8 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
-	ReturnValue_t set(const uint8_t *stream, int32_t streamSize,
-			const uint8_t **remainingStream = NULL, int32_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
@@ -128,8 +128,8 @@ private:
 	const void *readonlyData;
 
 	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const;
 
 	template<typename T>
 	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index dd5d3e3f..db24100b 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -86,12 +86,12 @@ ReturnValue_t Fuse::check() {
 	return result;
 }
 
-ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, max_size, bigEndian);
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
@@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
 	return RETURN_OK;
 }
 
-uint32_t Fuse::getSerializedSize() const {
+size_t Fuse::getSerializedSize() const {
 	uint32_t size = 0;
 	for (DeviceList::const_iterator iter = devices.begin();
 			iter != devices.end(); iter++) {
@@ -108,12 +108,12 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
 			iter++) {
-		result = (*iter)->deSerialize(buffer, size, bigEndian);
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
 		if (result != RETURN_OK) {
 			return result;
 		}
diff --git a/power/Fuse.h b/power/Fuse.h
index 6da24178..4e22e3ed 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -11,14 +11,15 @@
 #include <framework/parameters/ParameterHelper.h>
 #include <list>
 
-namespace Factory{
+namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
 class Fuse: public SystemObject,
 		public HasHealthIF,
 		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@@ -40,7 +41,7 @@ public:
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 			float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
-	void addDevice(PowerComponentIF* set);
+	void addDevice(PowerComponentIF *set);
 	float getPower();
 
 	bool isPowerValid();
@@ -49,11 +50,11 @@ public:
 	uint8_t getFuseId() const;
 	ReturnValue_t initialize();
 	DeviceList devices;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
-	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian);
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);
 	MessageQueueId_t getCommandQueue() const;
@@ -62,13 +63,13 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
 
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF* powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
@@ -88,11 +89,11 @@ private:
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
 	db_float_t power;
-	MessageQueueIF* commandQueue;
+	MessageQueueIF *commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float* low, float* high);
+	void calculatePowerLimits(float *low, float *high);
 	void calculateFusePower();
 	void checkFuseState();
 	void reportEvents(Event event);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 53bb06c8..cd116a86 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -17,18 +17,18 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
 				twoSwitches), min(min), max(max), moduleId(moduleId) {
 }
 
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, max_size, bigEndian);
+			size, maxSize, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::serialize(&max, buffer, size, max_size,
-			bigEndian);
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
 }
 
-uint32_t PowerComponent::getSerializedSize() const {
+size_t PowerComponent::getSerializedSize() const {
 	return sizeof(min) + sizeof(max);
 }
 
@@ -56,14 +56,14 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
-bool bigEndian) {
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, bigEndian);
+			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, bigEndian);
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
 }
 
 ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index a82fe1d7..61ab3674 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -19,13 +19,13 @@ public:
 	float getMin();
 	float getMax();
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	uint32_t getSerializedSize() const;
+	size_t getSerializedSize() const override;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index ab0c6c6f..bcd99818 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -20,25 +20,25 @@ public:
 	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
 	}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return serialize(adaptee, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
 			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 			++i;
 		}
 		return result;
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return getSerializedSize(adaptee);
 	}
 
@@ -53,16 +53,16 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return deSerialize(adaptee, buffer, size, bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
@@ -71,7 +71,7 @@ public:
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
 			result = SerializeAdapter::deSerialize(
 					&list->front()[i], buffer, size,
-					bigEndian);
+					streamEndianness);
 			++i;
 		}
 		return result;
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index f78ec8ac..d4d8d1c7 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -22,19 +22,19 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
 }
 
 template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
-		const uint32_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += SerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
 			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					max_size, bigEndian);
+					maxSize, streamEndianness);
 		}
 		if (this->constBuffer != NULL) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
@@ -50,7 +50,7 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
 }
 
 template<typename T>
-uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
+size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	if (serializeLength) {
 		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
@@ -59,7 +59,7 @@ uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
 }
 template<typename T>
 ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		int32_t* size, bool bigEndian) {
+		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
 	if (buffer != NULL) {
 		if(serializeLength){
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 7cd75d55..78d42b80 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -16,13 +16,13 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const;
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
 
-	virtual uint32_t getSerializedSize() const;
+	virtual size_t getSerializedSize() const override;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian);
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
 private:
 	bool serializeLength;
 	const uint8_t *constBuffer;
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 16919b62..a2e683bf 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -13,16 +13,16 @@ public:
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 22e9838c..3941e9fb 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -26,7 +26,7 @@ public:
 				streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const override {
+	size_t getSerializedSize() const override {
 		return SerializeAdapter::getSerializedSize(&entry);
 	}
 
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6c875a5c..14244a7a 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -28,7 +28,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t max_size, Endianness streamEndianness) const = 0;
+			size_t maxSize, Endianness streamEndianness) const = 0;
 
 	virtual size_t getSerializedSize() const = 0;
 
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index ef706dd7..2e8a325a 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -13,7 +13,7 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 				false), uptimeStartTable(0), currentTargetTable(), targetMode(
 				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
 				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-				NULL)
+		NULL)
 #ifdef USE_MODESTORE
 ,modeStore(NULL)
 #endif
@@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
 	if (isInTransition) {
 		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
 			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
 					setMode(targetMode, targetSubmode);
 					isInTransition = false;
 					return;
@@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
 				}
 			}
 			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
 					transitionFailed(TABLE_CHECK_FAILED,
 							currentSequenceIterator->getTableId());
 					return;
@@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
 			childrenChangedHealth = false;
 			startTransition(mode, submode);
 		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
 				triggerEvent(CANT_KEEP_MODE, mode, submode);
 				cantKeepMode();
 			}
@@ -147,7 +150,7 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
 	}
 }
 
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
 	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case HealthMessage::HEALTH_INFO: {
@@ -168,12 +171,13 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			int32_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId,
-					&pointer, &size, true);
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size, true);
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
 				if (result == RETURN_OK) {
 					result = addSequence(&sequence,
 							ModeSequenceMessage::getSequenceId(message),
@@ -193,9 +197,9 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			int32_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, true);
+					&pointer, &size, SerializeIF::Endianness::BIG);
 			if (result == RETURN_OK) {
 				result = addTable(&table,
 						ModeSequenceMessage::getSequenceId(message));
@@ -339,7 +343,7 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
 	}
 }
 
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry>* sequence,
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
 
 	ReturnValue_t result;
@@ -507,7 +511,7 @@ MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
 }
 
 ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
+		uint32_t *msToReachTheMode) {
 	//Need to accept all submodes to be able to inherit submodes
 //	if (submode != SUBMODE_NONE) {
 //		return INVALID_SUBMODE;
@@ -599,15 +603,15 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 }
 
 void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF** elements, uint8_t count) {
+		SerializeIF **elements, uint8_t count) {
 	ReturnValue_t result;
-	uint32_t maxSize = 0;
+	size_t maxSize = 0;
 	for (uint8_t i = 0; i < count; i++) {
 		maxSize += elements[i]->getSerializedSize();
 	}
 	uint8_t *storeBuffer;
 	store_address_t address;
-	uint32_t size = 0;
+	size_t size = 0;
 
 	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 		return;
 	}
 	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
 	}
 	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 3e749dd8..153710af 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -18,65 +18,65 @@ public:
 	uint8_t value3;
 	uint8_t value4;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 
 		ReturnValue_t result;
 
 		result = SerializeAdapter::serialize(&value1, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value2, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::serialize(&value3, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 
 		result = SerializeAdapter::serialize(&value4, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 		return result;
 
 	}
 
-	virtual uint32_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const {
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result;
 
 		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				bigEndian);
+				streamEndianness);
 
 		return result;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 93513e16..5dcd0bc6 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -46,15 +46,15 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	int32_t readSize = size;
+	size_t readSize = size;
 	SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
-			&readSize, true);
+			&readSize, SerializeIF::Endianness::BIG);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4e7160fb..16768e68 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -32,31 +32,31 @@ public:
 	}
 	uint16_t apid;
 	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
 		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, max_size, bigEndian);
+				buffer, size, maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		return SerializeAdapter::serialize(&ssc, buffer, size,
-				max_size, bigEndian);
+				maxSize, streamEndianness);
 
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, bigEndian);
+				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				bigEndian);
+				streamEndianness);
 	}
 };
 
@@ -218,33 +218,33 @@ public:
 	}
 
 
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
 		if(result!=HasReturnvaluesIF::RETURN_OK){
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,max_size,bigEndian);
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
 	}
 
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		uint32_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&apid);
 		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
@@ -257,35 +257,35 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-	bool bigEndian) {
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, bigEndian);
+				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
 		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,bigEndian);
+		return adapter.deSerialize(buffer,size,streamEndianness);
 	}
 
 private:
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index d5d96f2d..3080ffef 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index b0623780..f6e9e360 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -22,16 +22,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&service, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
 	}
 };
 
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 90370af1..2e8b82b2 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -20,16 +20,16 @@ public:
 			return false;
 		}
 	}
-	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
-			const uint32_t max_size, bool bigEndian) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, max_size, bigEndian);
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
 	}
-	uint32_t getSerializedSize() const {
+	size_t getSerializedSize() const {
 		return SerializeAdapter::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
-			bool bigEndian) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, bigEndian);
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
 	}
 private:
 	uint8_t subService;
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index f2c1eb28..32f9c431 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data,
-		uint32_t size, const uint8_t* headerData, uint32_t headerSize) :
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint8_t* pData = NULL;
+	uint8_t *pData = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
@@ -34,21 +34,21 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content,
-		SerializeIF* header) :
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
 		return;
 	}
-	uint32_t sourceDataSize = 0;
+	size_t sourceDataSize = 0;
 	if (content != NULL) {
 		sourceDataSize += content->getSerializedSize();
 	}
 	if (header != NULL) {
 		sourceDataSize += header->getSerializedSize();
 	}
-	uint8_t* p_data = NULL;
+	uint8_t *p_data = NULL;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
 	if (returnValue != store->RETURN_OK) {
@@ -56,13 +56,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	}
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t* putDataHere = getSourceData();
-	uint32_t size = 0;
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
 	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize, true);
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize, true);
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
 	}
 	setPacketDataLength(
 			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@@ -80,7 +82,7 @@ void TmPacketStored::deletePacket() {
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t *temp_data = NULL;
 	uint32_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
@@ -106,8 +108,8 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF* TmPacketStored::store = NULL;
-InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL;
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
 
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
@@ -116,7 +118,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom);
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5b9e7b68..aa41f334 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -235,9 +235,9 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
 	uint8_t buffer[sizeof(object_id_t)];
 	uint8_t* pBuffer = buffer;
-	uint32_t size = 0;
+	size_t size = 0;
 	SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-			sizeof(object_id_t), true);
+			sizeof(object_id_t), SerializeIF::Endianness::BIG);
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, buffer, size);
 	ReturnValue_t result = tmPacketStored.sendPacket(
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index e1dad2be..07631801 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -33,7 +33,7 @@ PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
 		uint32_t parameter2) {
-	uint8_t* data = this->getBuffer();
+	uint8_t *data = this->getBuffer();
 	data[messageSize] = set_report_id;
 	messageSize += sizeof(set_report_id);
 	data[messageSize] = ackFlags;
@@ -109,12 +109,12 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
 }
 
@@ -136,25 +136,25 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
 		reportSize(0), pBuffer(reportBuffer) {
 	//Serialization won't fail, because we know the necessary max-size of the buffer.
 	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	if (setStep != 0) {
 		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), true);
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer,
-			&reportSize, sizeof(reportBuffer), true);
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), true);
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
 }
 
 PusFailureReport::~PusFailureReport() {
 }
 
-uint32_t PusFailureReport::getSize() {
+size_t PusFailureReport::getSize() {
 	return reportSize;
 }
 
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 7a173be9..ee84f0c1 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -49,7 +49,7 @@ class PusSuccessReport {
 private:
 	static const uint16_t MAX_SIZE = 7;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@@ -63,14 +63,14 @@ class PusFailureReport {
 private:
 	static const uint16_t MAX_SIZE = 16;
 	uint8_t reportBuffer[MAX_SIZE];
-	uint32_t reportSize;
+	size_t reportSize;
 	uint8_t * pBuffer;
 public:
 	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
 			ReturnValue_t setErrorCode, uint8_t setStep = 0,
 			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
 	~PusFailureReport();
-	uint32_t getSize();
+	size_t getSize();
 	uint8_t* getReport();
 };
 

From 326e5cf5febda0dd3ad55cd6c5b181969ebdf9ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 01:01:32 +0200
Subject: [PATCH 0191/1292] initialized uninitialized variables

---
 datapool/PoolRawAccessHelper.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 643c7609..81a9eb01 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -24,7 +24,7 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_OK;
 	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
@@ -42,7 +42,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
-	ReturnValue_t result;
+	ReturnValue_t result = RETURN_OK;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
 	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);

From 4e76b8133e905446c90b3447abfaad3744da5d87 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 01:08:36 +0200
Subject: [PATCH 0192/1292] uninitialized variable

---
 parameters/ParameterWrapper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 475764c5..e2572acb 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -91,7 +91,7 @@ template<typename T>
 ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
 	const T *element = (const T*) readonlyData;
-	ReturnValue_t result;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	uint16_t dataSize = columns * rows;
 	while (dataSize != 0) {
 		result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,

From fb9a5678fc463aba32a4bbcf01a8cf8994638a30 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 10:24:00 +0200
Subject: [PATCH 0193/1292] removed comment belonging in egit

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index a2365d00..2a97ab90 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -68,10 +68,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 }
 #endif
 
-/**
- * TODO: This is architecture specific. Maybe there is a better solution
- * to move this into the Bsp folder..
- */
+
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 

From 9f7f8073f17df0081406804bf2fc84034420da54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:42:42 +0200
Subject: [PATCH 0194/1292] freertos includes in extern "C"

---
 osal/FreeRTOS/BinarySemaphore.cpp | 3 +++
 osal/FreeRTOS/BinarySemaphore.h   | 6 +++++-
 osal/FreeRTOS/Mutex.h             | 4 ++--
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e2cddacc..b5f8e6c6 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -7,8 +7,11 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+extern "C" {
 #include "portmacro.h"
 #include "task.h"
+}
 
 BinarySemaphore::BinarySemaphore() {
 	xSemaphoreCreateBinary(handle);
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 373e26bf..2203c923 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -7,8 +7,12 @@
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <FreeRTOS.h>
+
+extern "C" {
+#include "FreeRTOS.h"
 #include "semphr.h"
+}
+
 
 /**
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 2703df4e..604511b5 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -19,8 +19,8 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;
 };

From e26f0d54b2828e786c4d91ef38345a7e68d1fbcf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:44:03 +0200
Subject: [PATCH 0195/1292] binary semaphore init

---
 osal/FreeRTOS/BinarySemaphore.cpp | 152 ++++++++++++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 130 +++++++++++++++++++++++++
 2 files changed, 282 insertions(+)
 create mode 100644 osal/FreeRTOS/BinarySemaphore.cpp
 create mode 100644 osal/FreeRTOS/BinarySemaphore.h

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
new file mode 100644
index 00000000..b5f8e6c6
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -0,0 +1,152 @@
+/**
+ * @file BinarySemaphore.cpp
+ *
+ * @date 25.02.2020
+ */
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+extern "C" {
+#include "portmacro.h"
+#include "task.h"
+}
+
+BinarySemaphore::BinarySemaphore() {
+	xSemaphoreCreateBinary(handle);
+	if(handle == nullptr) {
+		error << "Binary semaphore creation failure" << std::endl;
+	}
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
+
+// This copy ctor is important as it prevents the assignment to a ressource
+// (other.handle) variable which is later deleted!
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+    if(this != &s) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    xSemaphoreCreateBinary(handle);
+    if(handle == nullptr) {
+        error << "Binary semaphore creation failure" << std::endl;
+    }
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        xSemaphoreCreateBinary(handle);
+        if(handle == nullptr) {
+            error << "Binary semaphore creation failure" << std::endl;
+        }
+    }
+    return *this;
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	if(handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	if(handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void BinarySemaphore::resetSemaphore() {
+	if(handle != nullptr) {
+		vSemaphoreDelete(handle);
+		xSemaphoreCreateBinary(handle);
+	}
+}
+
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+		BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		if(*higherPriorityTaskWoken == pdPASS) {
+			// Request context switch because unblocking the semaphore
+		    // caused a high priority task unblock.
+			TaskManagement::requestContextSwitch(CallContext::isr);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
new file mode 100644
index 00000000..2203c923
--- /dev/null
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -0,0 +1,130 @@
+/**
+ * @file BinarySempahore.h
+ *
+ * @date 25.02.2020
+ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+extern "C" {
+#include "FreeRTOS.h"
+#include "semphr.h"
+}
+
+
+/**
+ * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ * @ingroup osal
+ */
+class BinarySemaphore: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! No block time, poll the semaphore. Can also be used as tick type.
+	//! Can be passed as tick type and ms value.
+	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
+	static constexpr TickType_t NO_BLOCK_TICKS = 0;
+	//! No block time, poll the semaphore.
+	//! Can be passed as tick type and ms value.
+	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
+	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
+
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	/** The current semaphore can not be given, because it is not owned */
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
+
+	BinarySemaphore();
+
+	/**
+	 * @brief Copy ctor
+	 */
+	BinarySemaphore(const BinarySemaphore&);
+
+	/**
+	 * @brief Copy assignment
+	 */
+	BinarySemaphore& operator=(const BinarySemaphore&);
+
+	/**
+	 * @brief Move constructor
+	 */
+	BinarySemaphore (BinarySemaphore &&);
+
+	/**
+	 * Move assignment
+	 */
+	BinarySemaphore & operator=(BinarySemaphore &&);
+
+	/**
+	 * Delete the binary semaphore to prevent a memory leak
+	 */
+	virtual ~BinarySemaphore();
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked for a maximum
+	 * of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_BLOCK_TICKS);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+
+	/**
+	 * Reset the semaphore.
+	 */
+	void resetSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
+	 *        was unblocked
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

From 6eda5a08381891907d67e3b23a93e80808585b07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:46:49 +0200
Subject: [PATCH 0196/1292] task management header added

---
 osal/FreeRTOS/TaskManagement.h | 38 ++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 00000000..fd2bfc0b
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,38 @@
+/**
+ * @file TaskManagement.h
+ *
+ * @date 26.02.2020
+ */
+
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+/*!
+ * Used by functions to tell if they are being called from
+ * within an ISR or from a regular task. This is required because FreeRTOS
+ * has different functions for handling semaphores and messages from within an ISR and task.
+ */
+
+enum CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
+};
+
+class TaskManagement {
+public:
+	/**
+	 * In this function, a function dependant on the portmacro.h header function calls
+	 * to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task to unblock
+	 * and a context switch is required.
+	 */
+	static void requestContextSwitch(CallContext callContext);
+
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void requestContextSwitchFromTask(void);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 1b5127dc85f236d7e02cdb22c722bea4976d531b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:50:07 +0200
Subject: [PATCH 0197/1292] added task management implementation

---
 osal/FreeRTOS/TaskManagement.cpp | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 00000000..9946833d
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,32 @@
+/**
+ * @file TaskManagement.cpp
+ *
+ * @date 26.02.2020
+ *
+ */
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <FreeRTOS.h>
+#include "portmacro.h"
+#include "task.h"
+
+/**
+ * TODO: This stuff is hardware and architecture and mission dependant...
+ * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
+ * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
+ * 	     not be necessary anyway. Maybe there is a better solution?
+ */
+void TaskManagement::requestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
+	if(callContext == CallContext::isr) {
+		// This function depends on the partmacro.h definition for the specific device
+		portYIELD_FROM_ISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
+
+

From 0e6f8d3f821d3fa6907de2310e9102a33d30afb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 22 Apr 2020 19:53:06 +0200
Subject: [PATCH 0198/1292] comment adapted

---
 osal/FreeRTOS/TaskManagement.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9946833d..0c96c62f 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,15 +5,17 @@
  *
  */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <FreeRTOS.h>
+
+extern "C" {
+#include "FreeRTOS.h"
 #include "portmacro.h"
 #include "task.h"
+}
 
 /**
  * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
- * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
- * 	     not be necessary anyway. Maybe there is a better solution?
+ * 	     Maybe there is a better solution? The request ContextSwitch function
+ * 	     could be declared external for example.
  */
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);

From c075e1bf2334e6984da63997589c3652d5d39b74 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:20:19 +0200
Subject: [PATCH 0199/1292] adapting tmtc bridge

---
 tmtcservices/TmTcBridge.cpp | 26 +++++++++++++++++++++-----
 tmtcservices/TmTcBridge.h   | 34 ++++++++++++++++++++++++----------
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 26131a20..646f736a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -6,8 +6,7 @@
 
 TmTcBridge::TmTcBridge(object_id_t objectId_,
         object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
-        ccsdsPacketDistributor(ccsdsPacketDistributor_),
-		sentPacketsPerCycle(5)
+        ccsdsPacketDistributor(ccsdsPacketDistributor_)
 {
     TmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
@@ -17,15 +16,30 @@ TmTcBridge::~TmTcBridge() {}
 
 ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		uint8_t sentPacketsPerCycle) {
-	if(sentPacketsPerCycle <= MAX_STORED_DATA_SENT_PER_CYCLE) {
+	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
 		this->sentPacketsPerCycle = sentPacketsPerCycle;
 		return RETURN_OK;
 	}
 	else {
+	    warning << "TmTcBridge: Number of packets sent per cycle "
+	               "exceeds limits" << std::endl;
 		return RETURN_FAILED;
 	}
 }
 
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
+        uint8_t maxNumberOfPacketsStored) {
+    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
+        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
+        return RETURN_OK;
+    }
+    else {
+        warning << "TmTcBridge: Number of packets stored "
+                   "exceeds limits" << std::endl;
+        return RETURN_FAILED;
+    }
+}
+
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == NULL) {
@@ -72,7 +86,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 	}
 
 	if(tmStored && communicationLinkUp) {
-		result = sendStoredTm();
+		result = handleStoredTm();
 	}
 	return result;
 
@@ -124,7 +138,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	return RETURN_OK;
 }
 
-ReturnValue_t TmTcBridge::sendStoredTm() {
+ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < sentPacketsPerCycle) {
@@ -171,6 +185,8 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 	return TmTcReceptionQueue->getId();
 }
 
+
+
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	info << "TMTC Bridge: Printing data: [";
 	for(uint32_t i=0;i<dataLen;i++) {
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index bae2bd69..f589a4d9 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -16,8 +16,11 @@ class TmTcBridge : public AcceptsTelemetryIF,
 		public SystemObject {
 public:
 	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static constexpr uint8_t MAX_STORED_DATA_SENT_PER_CYCLE = 10;
-	static constexpr uint8_t MAX_DOWNLINK_PACKETS_STORED = 15;
+	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
+	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
+
+	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
+	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
 	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
 	virtual ~TmTcBridge();
@@ -31,6 +34,15 @@ public:
 	 */
 	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
 
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 *         -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
+
 	void registerCommConnect();
 	void registerCommDisconnect();
 
@@ -94,7 +106,13 @@ protected:
 	 * Read the TM Queue and send TM if necessary. Default implementation provided
 	 * @return
 	 */
-	virtual ReturnValue_t readTmQueue();
+	virtual ReturnValue_t handleTmQueue();
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	virtual ReturnValue_t handleStoredTm();
 
 	/**
 	 * Implemented by child class. Perform sending of Telemetry by implementing
@@ -112,11 +130,6 @@ protected:
 	 */
 	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
 
-	/**
-	 * Send stored data if communication link is active
-	 * @return
-	 */
-	ReturnValue_t sendStoredTm();
 
 	/**
 	 * Print data as hexidecimal array
@@ -126,8 +139,9 @@ protected:
 	void printData(uint8_t * data, size_t dataLen);
 
 private:
-	FIFO<store_address_t, MAX_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t sentPacketsPerCycle = 10;
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> fifo;
+	uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+	uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 

From e40c9f42c676ef5fabe55e1392f88e3a8ba11884 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:22:25 +0200
Subject: [PATCH 0200/1292] info output commented out

---
 tmtcservices/TmTcBridge.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 646f736a..53dd422b 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -169,13 +169,13 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(!communicationLinkUp) {
-		info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
-	info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	//info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}

From 40d952a3491f549989f5bfb15da6000b8f77b3d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 10:24:34 +0200
Subject: [PATCH 0201/1292] minor form changes

---
 tmtcservices/TmTcBridge.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 53dd422b..547d3454 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -22,7 +22,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 	}
 	else {
 	    warning << "TmTcBridge: Number of packets sent per cycle "
-	               "exceeds limits" << std::endl;
+	               "exceeds limits. Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
 }
@@ -35,7 +35,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
     }
     else {
         warning << "TmTcBridge: Number of packets stored "
-                   "exceeds limits" << std::endl;
+                   "exceeds limits. Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
 }
@@ -141,7 +141,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(!fifo.empty() && counter < sentPacketsPerCycle) {
+	while(not fifo.empty() && counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
@@ -168,7 +168,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 }
 
 void TmTcBridge::registerCommConnect() {
-	if(!communicationLinkUp) {
+	if(not communicationLinkUp) {
 		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
@@ -189,7 +189,7 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	info << "TMTC Bridge: Printing data: [";
-	for(uint32_t i=0;i<dataLen;i++) {
+	for(uint32_t i = 0; i < dataLen; i++) {
 		info << std::hex << (int)data[i];
 		if(i < dataLen-1){
 			info << " , ";

From ee2ee745c7329445a408137dd95b7e243a4b5adf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 12:47:59 +0200
Subject: [PATCH 0202/1292] fifo renamed

---
 tmtcservices/TmTcBridge.cpp | 12 ++++++------
 tmtcservices/TmTcBridge.h   | 11 +++++++----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 547d3454..4e65cefa 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -126,14 +126,14 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	//		 "Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId = 0;
 
-	if(fifo.full()) {
+	if(tmFifo.full()) {
 		error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
 				 "reached! Overwriting old data" << std::endl;
-		fifo.retrieve(&storeId);
+		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
 	}
 	storeId = message->getStorageId();
-	fifo.insert(storeId);
+	tmFifo.insert(storeId);
 	tmStored = true;
 	return RETURN_OK;
 }
@@ -141,13 +141,13 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(not fifo.empty() && counter < sentPacketsPerCycle) {
+	while(not tmFifo.empty() && counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;
-		fifo.retrieve(&storeId);
+		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 
 		sendTm(data,size);
@@ -159,7 +159,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		}
 		counter ++;
 
-		if(fifo.empty()) {
+		if(tmFifo.empty()) {
 			tmStored = false;
 		}
 		tmStore->deleteData(storeId);
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index f589a4d9..0a1fcfab 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -138,10 +138,13 @@ protected:
 	 */
 	void printData(uint8_t * data, size_t dataLen);
 
-private:
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> fifo;
-	uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-	uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+	/**
+	 * This fifo can be used to store downlink data
+	 * which can not be sent at the moment.
+	 */
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };
 
 

From 44d467808939a803f837d188b006cedd332f3d0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 14:06:48 +0200
Subject: [PATCH 0203/1292] fifo features and stopwatch enhancement

---
 container/FIFO.h        | 20 ++++++++++++++++++++
 timemanager/Stopwatch.h |  3 ++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 00f56993..889d2ade 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -59,6 +59,26 @@ public:
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
+
+	ReturnValue_t peek(T * value) {
+	    if(empty()) {
+	        return EMPTY;
+	    } else {
+	       *value = data[readIndex];
+	       return HasReturnvaluesIF::RETURN_OK;
+	    }
+	}
+
+	ReturnValue_t pop() {
+	    if(empty()) {
+	        return EMPTY;
+	    } else {
+	        readIndex = next(readIndex);
+	        --currentSize;
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+	}
+
 	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);
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 786a9d57..f48c04ec 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -56,12 +56,13 @@ public:
 
     StopwatchDisplayMode getDisplayMode() const;
     void setDisplayMode(StopwatchDisplayMode displayMode);
+    bool displayOnDestruction = true;
 private:
     timeval startTime {0, 0};
     timeval elapsedTime {0, 0};
 
     StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-    bool displayOnDestruction = true;
+
     void stopInternal();
 };
 

From 1415cd2339931cec2dda229782af069459a02f3d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 17:54:41 +0200
Subject: [PATCH 0204/1292] using newer bin semaph create call.

architecture dependant function call is external now and shall
be implemented by developer
---
 osal/FreeRTOS/BinarySemaphore.cpp | 24 +++++++++++++-----------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++++--
 osal/FreeRTOS/TaskManagement.cpp  | 16 ++++++----------
 osal/FreeRTOS/TaskManagement.h    |  7 +++++++
 4 files changed, 32 insertions(+), 23 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b5f8e6c6..a6a923aa 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -8,16 +8,13 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-extern "C" {
-#include "portmacro.h"
-#include "task.h"
-}
-
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle);
+	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+
 		error << "Binary semaphore creation failure" << std::endl;
 	}
+	xSemaphoreGive(handle);
 }
 
 BinarySemaphore::~BinarySemaphore() {
@@ -27,36 +24,40 @@ BinarySemaphore::~BinarySemaphore() {
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
 
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(
         BinarySemaphore&& s) {
     if(&s != this) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
@@ -127,7 +128,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
-		xSemaphoreCreateBinary(handle);
+		handle = xSemaphoreCreateBinary();
+		xSemaphoreGive(handle);
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2203c923..0ab9cdea 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -18,6 +18,10 @@ extern "C" {
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * SHOULDDO: check freeRTOS version and use new task notifications,
+ * if non-ancient freeRTOS version is used.
+ *
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {
@@ -68,8 +72,8 @@ public:
 
 	/**
 	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked for a maximum
-	 * of #timeoutMs or until the semaphore is given back,
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
 	 * for example by an ISR or another task.
 	 * @param timeoutMs
 	 * @return -@c RETURN_OK on success
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9946833d..d7ddaf38 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,16 +5,12 @@
  *
  */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <FreeRTOS.h>
-#include "portmacro.h"
-#include "task.h"
 
-/**
- * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Some FreeRTOS implementations might be able to determine their own task context for example.
- * 	     If not ISRs are used, or task preemption is enabled, some of this stuff might
- * 	     not be necessary anyway. Maybe there is a better solution?
- */
+extern "C" {
+#include "FreeRTOS.h"
+#include "task.h"
+}
+
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -22,7 +18,7 @@ void TaskManagement::requestContextSwitchFromTask() {
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
 	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
-		portYIELD_FROM_ISR();
+		requestContextSwitchFromISR();
 	} else {
 		requestContextSwitchFromTask();
 	}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index fd2bfc0b..c122e0fb 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -7,6 +7,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern "C" void requestContextSwitchFromISR();
+
 /*!
  * Used by functions to tell if they are being called from
  * within an ISR or from a regular task. This is required because FreeRTOS
@@ -18,6 +24,7 @@ enum CallContext {
 	isr = 0xFF  //!< isr_context
 };
 
+
 class TaskManagement {
 public:
 	/**

From 328737d0ad5d6efb098963fdf0e5088776f50f64 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 18:12:02 +0200
Subject: [PATCH 0205/1292] newer non-deprecated semaphore call used

---
 osal/FreeRTOS/BinarySemaphore.cpp | 24 +++++++++++++-----------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++++--
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b5f8e6c6..a6a923aa 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -8,16 +8,13 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-extern "C" {
-#include "portmacro.h"
-#include "task.h"
-}
-
 BinarySemaphore::BinarySemaphore() {
-	xSemaphoreCreateBinary(handle);
+	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+
 		error << "Binary semaphore creation failure" << std::endl;
 	}
+	xSemaphoreGive(handle);
 }
 
 BinarySemaphore::~BinarySemaphore() {
@@ -27,36 +24,40 @@ BinarySemaphore::~BinarySemaphore() {
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
 
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-    xSemaphoreCreateBinary(handle);
+    handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         error << "Binary semaphore creation failure" << std::endl;
     }
+    xSemaphoreGive(handle);
 }
 
 BinarySemaphore& BinarySemaphore::operator =(
         BinarySemaphore&& s) {
     if(&s != this) {
-        xSemaphoreCreateBinary(handle);
+        handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
             error << "Binary semaphore creation failure" << std::endl;
         }
+        xSemaphoreGive(handle);
     }
     return *this;
 }
@@ -127,7 +128,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
-		xSemaphoreCreateBinary(handle);
+		handle = xSemaphoreCreateBinary();
+		xSemaphoreGive(handle);
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2203c923..0ab9cdea 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -18,6 +18,10 @@ extern "C" {
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * SHOULDDO: check freeRTOS version and use new task notifications,
+ * if non-ancient freeRTOS version is used.
+ *
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {
@@ -68,8 +72,8 @@ public:
 
 	/**
 	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked for a maximum
-	 * of #timeoutMs or until the semaphore is given back,
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
 	 * for example by an ISR or another task.
 	 * @param timeoutMs
 	 * @return -@c RETURN_OK on success

From fc4199c3b12dfc6f7996d75c035fb0767c21a004 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 18:13:14 +0200
Subject: [PATCH 0206/1292] architecture dependant call delcared external

---
 osal/FreeRTOS/TaskManagement.cpp | 8 +-------
 osal/FreeRTOS/TaskManagement.h   | 7 +++++++
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 0c96c62f..d7ddaf38 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -8,15 +8,9 @@
 
 extern "C" {
 #include "FreeRTOS.h"
-#include "portmacro.h"
 #include "task.h"
 }
 
-/**
- * TODO: This stuff is hardware and architecture and mission dependant...
- * 	     Maybe there is a better solution? The request ContextSwitch function
- * 	     could be declared external for example.
- */
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -24,7 +18,7 @@ void TaskManagement::requestContextSwitchFromTask() {
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
 	if(callContext == CallContext::isr) {
 		// This function depends on the partmacro.h definition for the specific device
-		portYIELD_FROM_ISR();
+		requestContextSwitchFromISR();
 	} else {
 		requestContextSwitchFromTask();
 	}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index fd2bfc0b..c122e0fb 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -7,6 +7,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern "C" void requestContextSwitchFromISR();
+
 /*!
  * Used by functions to tell if they are being called from
  * within an ISR or from a regular task. This is required because FreeRTOS
@@ -18,6 +24,7 @@ enum CallContext {
 	isr = 0xFF  //!< isr_context
 };
 
+
 class TaskManagement {
 public:
 	/**

From 0ea692a5ea8e5230ccb14ae42156ac74f05ac851 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 20:04:48 +0200
Subject: [PATCH 0207/1292] some more sif changes

---
 datapool/PoolRawAccessHelper.cpp        | 16 ++++++++--------
 devicehandlers/CommunicationMessage.cpp |  8 ++++----
 osal/FreeRTOS/BinarySemaphore.cpp       | 10 +++++-----
 tmtcpacket/pus/TmPacketStored.cpp       |  2 +-
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 81a9eb01..963835f5 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -34,7 +34,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 	return result;
@@ -56,7 +56,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 
@@ -75,7 +75,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
@@ -96,7 +96,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			error << "Pool Raw Access Helper: Config error, "
+			sif::error << "Pool Raw Access Helper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
 			return result;
@@ -110,7 +110,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw "
+			sif::debug << std::hex << "Pool Raw Access Helper: Error reading raw "
 					"dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
@@ -119,7 +119,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
 				&arrayPosition);
 		if(result != RETURN_OK) {
-			error << "Pool Raw Access Helper: Configuration Error at pool ID "
+			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;
@@ -136,7 +136,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data with "
+			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;
@@ -174,7 +174,7 @@ void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
 		bool value) {
 	if(position < 1 or position > 8) {
-		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+		sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
 		return byte;
 	}
 	uint8_t shiftNumber = position + (6 - 2 * (position - 1));
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index 028e8a2e..a80e7de1 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -126,7 +126,7 @@ void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
 	}
 	else {
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
@@ -138,7 +138,7 @@ uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
 	}
 	else {
 		return 0;
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
@@ -147,7 +147,7 @@ void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
 	}
 	else {
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 
 }
@@ -160,7 +160,7 @@ uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
 	}
 	else {
 		return 0;
-		error << "Comm Message: Invalid byte position" << std::endl;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
 	}
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index a6a923aa..6cacef65 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -12,7 +12,7 @@ BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
 
-		error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Binary semaphore creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
@@ -26,7 +26,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -35,7 +35,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
@@ -45,7 +45,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -55,7 +55,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 1ca87284..42d0d038 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -22,7 +22,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
 	if (returnValue != store->RETURN_OK) {
-		debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From a5d2cbd7db6d6f47e7a3f75cc429ac36070f806e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 21:59:24 +0200
Subject: [PATCH 0208/1292] some more sif replacements

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  2 +-
 osal/FreeRTOS/Mutex.cpp             |  2 +-
 serialize/SerialBufferAdapter.cpp   |  4 ++--
 storagemanager/LocalPool.h          |  2 +-
 timemanager/Stopwatch.cpp           |  4 ++--
 tmtcservices/TmTcBridge.cpp         | 24 ++++++++++++------------
 6 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index d6fa5936..aed66349 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -67,7 +67,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId
+	sif::error << "Component " << std::hex << componentId
 		  << " not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 616ef7b8..25513a81 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -7,7 +7,7 @@ const uint32_t MutexIF::NO_TIMEOUT = 0;
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == NULL) {
-		error << "Mutex creation failure" << std::endl;
+		sif::error << "Mutex creation failure" << std::endl;
 	}
 }
 
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 5fb5e387..3df2abe9 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -100,7 +100,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(m_buffer == nullptr) {
-		error << "Wrong access function for stored type !"
+		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
@@ -110,7 +110,7 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		error << "Wrong access function for stored type !"
+		sif::error << "Wrong access function for stored type !"
 				 " Use getBuffer()" << std::endl;
 		return nullptr;
 	}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index b541c5e1..7e934c40 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -295,7 +295,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 		if (!ignoreFault) {
 			internalErrorReporter->storeFull();
 		}
-		error << "LocalPool( " << std::hex << getObjectId() << std::dec
+		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
 				<< " )::reserveSpace: Packet store is full." << std::endl;
 	}
 	return status;
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 3f0755fd..e2018469 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -31,11 +31,11 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        info <<"Stopwatch: Operation took "  << std::setprecision(3)
+        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
     }
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 4e65cefa..c5eaf78b 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -21,7 +21,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-	    warning << "TmTcBridge: Number of packets sent per cycle "
+	    sif::warning << "TmTcBridge: Number of packets sent per cycle "
 	               "exceeds limits. Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
@@ -34,7 +34,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-        warning << "TmTcBridge: Number of packets stored "
+        sif::warning << "TmTcBridge: Number of packets stored "
                    "exceeds limits. Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
@@ -62,11 +62,11 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-		error << "TMTC Bridge: Error handling TCs" << std::endl;
+		sif::error << "TMTC Bridge: Error handling TCs" << std::endl;
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-		error << "TMTC Bridge: Error handling TMs" << std::endl;
+		sif::error << "TMTC Bridge: Error handling TMs" << std::endl;
 	}
 	return result;
 }
@@ -81,7 +81,7 @@ ReturnValue_t TmTcBridge::handleTc() {
 ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
 		return RETURN_FAILED;
 	}
 
@@ -111,7 +111,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			error << "TMTC Bridge: Could not send TM packet"<< std::endl;
+			sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 
@@ -127,7 +127,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo.full()) {
-		error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
+		sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
 				 "reached! Overwriting old data" << std::endl;
 		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
@@ -153,7 +153,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		sendTm(data,size);
 
 		if(result != RETURN_OK) {
-			error << "TMTC Bridge: Could not send stored downlink data"
+			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
 			result = RETURN_FAILED;
 		}
@@ -188,12 +188,12 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	info << "TMTC Bridge: Printing data: [";
+	sif::info << "TMTC Bridge: Printing data: [";
 	for(uint32_t i = 0; i < dataLen; i++) {
-		info << std::hex << (int)data[i];
+		sif::info << std::hex << (int)data[i];
 		if(i < dataLen-1){
-			info << " , ";
+			sif::info << " , ";
 		}
 	}
-	info << " ] " << std::endl;
+	sif::info << " ] " << std::endl;
 }

From ecf3b4b535f7becb1adbd8f0ca1619545b04f4ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 23 Apr 2020 22:05:12 +0200
Subject: [PATCH 0209/1292] stopwatch warning fix

---
 timemanager/Stopwatch.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index e2018469..1f287fb3 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -9,8 +9,8 @@
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode): displayMode(displayMode),
-        displayOnDestruction(displayOnDestruction) {
+        StopwatchDisplayMode displayMode): displayOnDestruction(
+        displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
     startTime = Clock::getUptime();
 }

From 7ec6d2ceaa74f3823db8fe49cef0ff811cbabdd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Apr 2020 18:58:55 +0200
Subject: [PATCH 0210/1292] remove dspecial character messing with decoding

---
 thermal/TemperatureSensor.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index b4172670..96dedc99 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -29,7 +29,7 @@ public:
 	 *
 	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
 	 *
-	 * The lower and upper limits can be specified in any type, for example float for C° values
+	 * The lower and upper limits can be specified in any type, for example float for C values
 	 * or any other type for raw values.
 	 */
 	struct Parameters {
@@ -151,7 +151,7 @@ protected:
 			}
 		}
 
-		//Check is done against raw limits. SHOULDDO: Why? Using °C would be more easy to handle.
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
 		sensorMonitor.doCheck(outputTemperature.value);
 
 		if (sensorMonitor.isOutOfLimits()) {

From e1aa285b6db9733c3b302a0c3c1c0231a2a5e561 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Apr 2020 13:46:30 +0200
Subject: [PATCH 0211/1292] linux osal output in namespace

---
 osal/linux/FixedTimeslotTask.cpp |  7 ++---
 osal/linux/MessageQueue.cpp      | 44 ++++++++++++++++++++------------
 osal/linux/Mutex.cpp             |  8 +++---
 osal/linux/PeriodicPosixTask.cpp |  4 +--
 osal/linux/PosixThread.cpp       | 42 +++++++++++++++++++-----------
 osal/linux/Timer.cpp             |  3 ++-
 6 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 7f117301..04ceb4e6 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -43,7 +43,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
-		error << "Component " << std::hex << componentId << " not found, not adding it to pst" << std::endl;
+		sif::error << "Component " << std::hex << componentId
+				   << " not found, not adding it to pst" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -87,7 +88,7 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
 	}
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a2e87875..edabe946 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -17,11 +17,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	attributes.mq_maxmsg = message_depth;
 	attributes.mq_msgsize = max_message_size;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-
 	//Set the name of the queue
 	sprintf(name, "/Q%u\n", queueCounter++);
 
-	//Create a nonblocking queue if the name is available (the queue is Read and writable for the owner as well as the group)
+	//Create a nonblocking queue if the name is available (the queue is Read and
+	// writable for the owner as well as the group)
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
@@ -32,8 +32,8 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 			//We unlink the other queue
 			int status = mq_unlink(name);
 			if (status != 0) {
-				error << "mq_unlink Failed with status: " << strerror(errno)
-						<< std::endl;
+				sif::error << "mq_unlink Failed with status: " << strerror(errno)
+						   << std::endl;
 			} else {
 				//Successful unlinking, try to open again
 				mqd_t tempId = mq_open(name,
@@ -47,7 +47,7 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 			}
 		}
 		//Failed either the first time or the second time
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status: "
 				<< strerror(errno) << std::endl;
 	} else {
@@ -59,11 +59,13 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
-		error << "MessageQueue::Destructor: mq_close Failed with status: " << strerror(errno) <<std::endl;
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
 	}
 	status = mq_unlink(name);
 	if(status != 0){
-		error << "MessageQueue::Destructor: mq_unlink Failed with status: " << strerror(errno) <<std::endl;
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) <<std::endl;
 	}
 }
 
@@ -93,7 +95,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),message->MAX_MESSAGE_SIZE,&messagePriority);
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->MAX_MESSAGE_SIZE,&messagePriority);
 	if (status > 0) {
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
@@ -114,7 +117,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -123,7 +127,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			 * * The number of bytes requested, msg_len is less than zero.
 			 * * msg_len is anything other than the mq_msgsize of the specified queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't been set in the queue's mq_flags.
 			 */
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
 			/*
@@ -131,7 +136,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 			 * * the QNX extended option MQ_READBUF_DYNAMIC hasn't been set, and the given msg_len is shorter than the mq_msgsize for the given queue.
 			 * * the extended option MQ_READBUF_DYNAMIC has been set, but the given msg_len is too short for the message that would have been received.
 			 */
-			error << "MessageQueue::receive: configuration error " << strerror(errno)  << std::endl;
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
 			/*NO BREAK*/
 		case EINTR:
 			//The operation was interrupted by a signal.
@@ -154,7 +160,8 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-			error << "MessageQueue::flush configuration error, called flush with an invalid queue ID" << std::endl;
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			//mq_attr is NULL
@@ -169,7 +176,8 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-			error << "MessageQueue::flush configuration error, called flush with an invalid queue ID" << std::endl;
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -237,7 +245,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			return MessageQueueIF::FULL;
 		case EBADF:
 			//mq_des doesn't represent a valid message queue descriptor, or mq_des wasn't opened for writing.
-			error << "MessageQueue::sendMessage: Configuration error " << strerror(errno) << " in mq_send mqSendTo: " << sendTo << " sent from " << sentFrom << std::endl;
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
+					   << " sent from " << sentFrom << std::endl;
 			/*NO BREAK*/
 		case EINTR:
 			//The call was interrupted by a signal.
@@ -248,9 +258,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * * msg_len is negative.
 			 * * msg_prio is greater than MQ_PRIO_MAX.
 			 * * msg_prio is less than 0.
-			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and msg_prio is greater than the priority of the calling process.
+			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des,
+			 *   and msg_prio is greater than the priority of the calling process.
 			 * */
-			error << "MessageQueue::sendMessage: Configuration error " << strerror(errno) << " in mq_send" << std::endl;
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
 			//The msg_len is greater than the msgsize associated with the specified queue.
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 055270b3..36bb3ce4 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -13,22 +13,22 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
-		error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
-		error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
-		error << "Mutex: creation with name, id " << mutex.__data.__count
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 	}
 	//After a mutex attributes object has been used to initialize one or more mutexes, any function affecting the attributes object (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
-		error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
 	}
 }
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index ee3c5c4a..b754c3f4 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -56,9 +56,9 @@ void PeriodicPosixTask::taskFunctionality(void){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status==0){
-				error << "ObjectTask: " << name << " Deadline missed." << std::endl;
+				sif::error << "ObjectTask: " << name << " Deadline missed." << std::endl;
 			}else{
-				error << "ObjectTask: X Deadline missed. " << status << std::endl;
+				sif::error << "ObjectTask: X Deadline missed. " << status << std::endl;
 			}
 			if (this->deadlineMissedFunc != NULL) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 2f0176c9..899700f0 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -22,7 +22,8 @@ ReturnValue_t PosixThread::sleep(uint64_t ns) {
 			//The nanosleep() function was interrupted by a signal.
 			return HasReturnvaluesIF::RETURN_FAILED;
 		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or greater than or equal to 1000 million.
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
 			return HasReturnvaluesIF::RETURN_FAILED;
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -40,8 +41,8 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
-		error << "FixedTimeslotTask: Unknown Signal received: " << caughtSig
-				<< std::endl;
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
 	}
 }
 
@@ -112,14 +113,15 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 	return currentTime_ms;
 }
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):thread(0),priority(priority_),stackSize(stackSize_) {
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
 	strcpy(name,name_);
 }
 
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	debug << "PosixThread::createTask" << std::endl;
+	//sif::debug << "PosixThread::createTask" << std::endl;
 	/*
 	 * The attr argument points to a pthread_attr_t structure whose contents
        are used at thread creation time to determine attributes for the new
@@ -130,35 +132,41 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
-			error << "Posix Thread attribute init failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
 	}
 	void* sp;
 	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-			error << "Posix Thread stack init failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread stack init failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_setstack(&attributes, sp, stackSize);
 	if(status != 0){
-			error << "Posix Thread attribute setStack failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute setStack failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
-			error << "Posix Thread attribute setinheritsched failed with: " << strerror(status) << std::endl;
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
 	}
 
 //TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
-		error << "Posix Thread attribute schedule policy failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	sched_param scheduleParams;
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
-			error << "Posix Thread attribute schedule params failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	//Set Signal Mask for suspend until startTask is called
@@ -167,22 +175,26 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
-			error << "Posix Thread sigmask failed failed with: " << strerror(status) << " errno: " << strerror(errno) << std::endl;
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
 	}
 
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
-		error << "Posix Thread create failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-		error << "Posix Thread setname failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread setname failed with: " <<
+				strerror(status) << std::endl;
 	}
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
-		error << "Posix Thread attribute destroy failed with: " << strerror(status) << std::endl;
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
 	}
 }
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 2347e39d..5e27c328 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -9,7 +9,8 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
-		error << "Timer creation failed with: " << status << " errno: " << errno << std::endl;
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
 	}
 }
 

From 431709a3ecefb0a358726e7f94e2f45131a7d914 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 30 Apr 2020 15:42:33 +0200
Subject: [PATCH 0212/1292] pool raw acces helper bugfix

---
 datapool/PoolRawAccessHelper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 963835f5..31c0b6f2 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -73,7 +73,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters,true);
+			&poolIdBuffer,remainingParameters, false);
 	if(result != RETURN_OK) {
 		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;

From 03333c2af0cc698646f617812fc183a2627ce974 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 30 Apr 2020 21:37:02 +0200
Subject: [PATCH 0213/1292] pool raw acces printout

---
 container/SinglyLinkedList.h     |  2 +-
 datapool/PoolRawAccessHelper.cpp | 15 ++++++++-------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index b926bd00..54e7687c 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -62,7 +62,7 @@ public:
 	}
 
 	void setEnd() {
-		this->next = NULL;
+		this->next = nullptr;
 	}
 
 	LinkedElement* begin() {
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 31c0b6f2..91d6309f 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -34,7 +34,8 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "PoolRawAccessHelper: "
+				"Remaining parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 	return result;
@@ -56,7 +57,8 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		}
 	}
 	if(remainingParametersSize != 0) {
-		sif::debug << "Pool Raw Access: Remaining parameters size not 0 !" << std::endl;
+		sif::debug << "PoolRawAccessHelper: Remaining "
+				"parameters size not 0 !" << std::endl;
 		result = RETURN_FAILED;
 	}
 
@@ -75,7 +77,7 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters, false);
 	if(result != RETURN_OK) {
-		sif::debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+		sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
 				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
@@ -96,7 +98,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			sif::error << "Pool Raw Access Helper: Config error, "
+			sif::error << "PoolRawAccessHelper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
 			return result;
@@ -110,9 +112,8 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			sif::debug << std::hex << "Pool Raw Access Helper: Error reading raw "
-					"dataset with returncode 0x"
-				  << result << std::dec << std::endl;
+			sif::debug << std::hex << "PoolRawAccessHelper: Error reading raw "
+					"dataset with returncode 0x" << result << std::dec << std::endl;
 			return result;
 		}
 

From 15c03863c008fb6d8b455bed15985ed725df3bc9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 May 2020 14:49:52 +0200
Subject: [PATCH 0214/1292] additional docmentation for freeRTOS task factory

---
 osal/FreeRTOS/TaskFactory.cpp    |  8 +++----
 osal/FreeRTOS/TaskManagement.cpp |  6 -----
 osal/FreeRTOS/TaskManagement.h   |  7 +-----
 tasks/TaskFactory.h              | 39 +++++++++++++++++++-------------
 4 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 753da60f..6b18d7a8 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -13,10 +13,7 @@ TaskFactory::~TaskFactory() {
 TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
-/***
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- * High taskPriority_ number means high priority.
- */
+
 PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
@@ -24,7 +21,8 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 	return (PeriodicTaskIF*) (new PeriodicTask(name_, taskPriority_, stackSize_,
 			period_, deadLineMissedFunction_));
 }
-/***
+
+/**
  * Keep in Mind that you need to call before this vTaskStartScheduler()!
  */
 FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index d7ddaf38..3e22021a 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,9 +1,3 @@
-/**
- * @file TaskManagement.cpp
- *
- * @date 26.02.2020
- *
- */
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index c122e0fb..4c148ca5 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,12 +1,7 @@
-/**
- * @file TaskManagement.h
- *
- * @date 26.02.2020
- */
-
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
+// maybe this can be part of the TaskFactory.cpp
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 8a59adf1..6716f7ff 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
 #define FRAMEWORK_TASKS_TASKFACTORY_H_
 
-#include <stdlib.h>
+#include <cstdlib>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
@@ -19,13 +19,16 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Creates a new periodic task and returns the interface pointer.
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack Size of the task
-	 * @param period_ Period of the task
-	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
-	 * @return PeriodicTaskIF* Pointer to the newly created Task
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param taskPriority_ Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param stackSize_ 	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param period_		Period in seconds.
+	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -33,13 +36,16 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 *
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack Size of the task
-	 * @param period_ Period of the task
-	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
-	 * @return FixedTimeslotTaskIF* Pointer to the newly created Task
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param taskPriority_ Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param stackSize_ 	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param period_		Period in seconds.
+	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -48,7 +54,8 @@ public:
 
 	/**
 	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted, NULL specifies current Task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
 	 * @return Success of deletion
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);

From 281da25bf97f344fd7b7727530208879c9c7a153 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 May 2020 16:47:53 +0200
Subject: [PATCH 0215/1292] extended task management for freeRTOS

---
 osal/FreeRTOS/PeriodicTask.cpp   |  7 ++++---
 osal/FreeRTOS/PeriodicTask.h     | 35 ++++++++++++++++----------------
 osal/FreeRTOS/TaskFactory.cpp    |  4 ----
 osal/FreeRTOS/TaskManagement.cpp | 16 ++++++++++-----
 osal/FreeRTOS/TaskManagement.h   | 32 ++++++++++++++++++++++++++++-
 tasks/TaskFactory.h              |  7 -------
 6 files changed, 63 insertions(+), 38 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index deab2dc1..3075be79 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -6,9 +6,10 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
 		void (*setDeadlineMissedFunc)()) :
 		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-
-	BaseType_t status = xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
+		setDeadlineMissedFunc)
+{
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			setStack, this, setPriority, &handle);
 	if(status != pdPASS){
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. Status: "
 		           << status << std::endl;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 4cbffd5a..02ab7148 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -13,11 +13,9 @@
 class ExecutableObjectIF;
 
 /**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
  *
  * @ingroup task_handling
  */
@@ -25,21 +23,22 @@ class PeriodicTask: public PeriodicTaskIF {
 public:
 	/**
 	 * @brief	Standard constructor of the class.
-	 * @details	The class is initialized without allocated objects. These need to be added
-	 * 			with #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be added
+	 * with #addComponent. In the underlying TaskBase class, a new operating
+	 * system task is created. In addition to the TaskBase parameters,
+	 * the period, the pointer to the aforementioned initialization function and
+	 * an optional "deadline-missed" function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values depend on
+	 * freeRTOS configuration, high number means high priority.
 	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
+	 * @param setPeriod The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall be assigned.
 	 */
-	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack, TaskPeriod setPeriod,
-			void (*setDeadlineMissedFunc)());
+	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
+			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
 	/**
 	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
 	 * 			lifetime, so the destructor is empty.
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 6b18d7a8..62015a4c 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,10 +44,6 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
 
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 3e22021a..bda43d8b 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,10 +1,5 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
-#include "FreeRTOS.h"
-#include "task.h"
-}
-
 void TaskManagement::requestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
@@ -18,5 +13,16 @@ void TaskManagement::requestContextSwitch(CallContext callContext = CallContext:
 	}
 }
 
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
 
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
+	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+}
+
+ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 4c148ca5..11c4c9dc 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,7 +1,14 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
-// maybe this can be part of the TaskFactory.cpp
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+extern "C" {
+#include "FreeRTOS.h"
+#include "task.h"
+}
+#include <cstdint>
+
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
@@ -35,6 +42,29 @@ public:
 	 * can be requested manually by calling this function.
 	 */
 	static void requestContextSwitchFromTask(void);
+
+	/**
+	 * @return The current task handle
+	 */
+	static TaskHandle_t getCurrentTaskHandle();
+
+	/**
+	 * Get returns the minimum amount of remaining stack space in words
+	 * that was a available to the task since the task started executing.
+	 * Please note that the actual value in bytes depends
+	 * on the stack depth type.
+	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
+	 * @return Smallest value of stack remaining since the task was started in
+	 * 		   words.
+	 */
+	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 6716f7ff..31b8b135 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -60,13 +60,6 @@ public:
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
 
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-
 private:
 	/**
 	 * External instantiation is not allowed.

From 35594d4b717e5296581f0227e6d952aebf506cf4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 May 2020 00:48:18 +0200
Subject: [PATCH 0216/1292] goofed up, delay function back in task factory

---
 osal/FreeRTOS/TaskFactory.cpp    | 4 ++++
 osal/FreeRTOS/TaskManagement.cpp | 4 ----
 osal/FreeRTOS/TaskManagement.h   | 7 -------
 tasks/TaskFactory.h              | 7 ++++++-
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 62015a4c..dc6b1c4e 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,6 +44,10 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
+ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
 
 TaskFactory::TaskFactory() {
 }
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index bda43d8b..52222531 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -21,8 +21,4 @@ configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
 	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
 }
 
-ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 11c4c9dc..da0cce2a 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -58,13 +58,6 @@ public:
 	 * 		   words.
 	 */
 	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 31b8b135..f7afa4a2 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -60,13 +60,18 @@ public:
 	 */
 	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
 
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
 private:
 	/**
 	 * External instantiation is not allowed.
 	 */
 	TaskFactory();
 	static TaskFactory* factoryInstance;
-
 };
 
 #endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */

From 3e4263f068aa476a608102acccad93f47b0a6d99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 May 2020 12:27:18 +0200
Subject: [PATCH 0217/1292] freeRTOS task factory fix

---
 osal/FreeRTOS/TaskFactory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index dc6b1c4e..6b18d7a8 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -44,7 +44,7 @@ ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
 	}
 }
 
-ReturnValue_t TaskManagement::delayTask(uint32_t delayMs) {
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
 	vTaskDelay(pdMS_TO_TICKS(delayMs));
 	return HasReturnvaluesIF::RETURN_OK;
 }

From 4b65d6e84739ea13e82441768917c530154d656f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 12:33:57 +0200
Subject: [PATCH 0218/1292] local pool bugfix

---
 storagemanager/LocalPool.h   | 5 +++--
 storagemanager/PoolManager.h | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 7e934c40..112f0111 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -125,7 +125,8 @@ protected:
 	 * @return	- #RETURN_OK on success,
 	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
 	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
 
 	InternalErrorReporterIF *internalErrorReporter;
 private:
@@ -292,7 +293,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
 
 		size_list[address->pool_index][address->packet_index] = size;
 	} else {
-		if (!ignoreFault) {
+		if (!ignoreFault and internalErrorReporter != nullptr) {
 			internalErrorReporter->storeFull();
 		}
 		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 68a7addc..329235d5 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -57,7 +57,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t s
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) : LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+		const uint16_t n_elements[NUMBER_OF_POOLS]) :
+		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 

From b947253ac3107e05ccb85760bb0413d28c46b5c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 16:49:15 +0200
Subject: [PATCH 0219/1292] local pool neat

---
 storagemanager/LocalPool.h        | 313 ++----------------------------
 storagemanager/LocalPool.tpp      | 260 +++++++++++++++++++++++++
 storagemanager/StorageManagerIF.h |  21 +-
 3 files changed, 287 insertions(+), 307 deletions(-)
 create mode 100644 storagemanager/LocalPool.tpp

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 112f0111..a6334458 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,15 +1,6 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
 
-/**
- *	@file	LocalPool
- *
- *  @date	02.02.2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the LocalPool class.
- */
-
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/storagemanager/StorageManagerIF.h>
@@ -70,53 +61,21 @@ public:
 	virtual ~LocalPool(void);
 
 	/**
-	 * Add data to local data pool, performs range check
-	 * @param storageId [out] Store ID in which the data will be stored
-	 * @param data
-	 * @param size
-	 * @param ignoreFault
-	 * @return @c RETURN_OK if write was successful
+	 * Documentation: See StorageManagerIF.h
 	 */
 	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			uint32_t size, bool ignoreFault = false);
-
-	/**
-	 * With this helper method, a free element of \c size is reserved.
-	 * @param storageId [out] storeID of the free element
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param p_data [out] pointer to the pointer of free element
-	 * @param ignoreFault
-	 * @return	Returns the storage identifier within the storage or
-	 * 			StorageManagerIF::INVALID_ADDRESS (in raw).
-	 */
-	ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false);
-
-	/**
-	 * Retrieve data from local pool
-	 * @param packet_id
-	 * @param packet_ptr
-	 * @param size [out] Size of retrieved data
-	 * @return @c RETURN_OK if data retrieval was successfull
-	 */
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size);
-
-	/**
-	 * Modify data by supplying a packet pointer and using that packet pointer
-	 * to access and modify the pool entry (via *pointer call)
-	 * @param packet_id Store ID of data to modify
-	 * @param packet_ptr [out] pointer to the pool entry to modify
-	 * @param size [out] size of pool entry
-	 * @return
-	 */
+			size_t * size) override;
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size);
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* ptr, uint32_t size,
-			store_address_t* storeId = NULL);
-	void clearStore();
-	ReturnValue_t initialize();
+			size_t * size) override;
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
 protected:
 	/**
 	 * With this helper method, a free element of \c size is reserved.
@@ -167,7 +126,7 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, uint32_t size);
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
@@ -190,7 +149,8 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex = 0);
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
 	 * 			of a given packet id.
@@ -212,249 +172,6 @@ private:
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
 };
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, uint32_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		uint32_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-//		debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " << n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				   << " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-//		if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-//			debug << "Reserve: Pool: " << std::dec << address->pool_index << " Index: " << address->packet_index << std::endl;
-//		}
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault and internalErrorReporter != nullptr) {
-			internalErrorReporter->storeFull();
-		}
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered, bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered), internalErrorReporter(NULL), spillsToHigherPools(spillsToHigherPools){
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list))); //TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, uint32_t size, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, size_t * size) {
-	uint8_t* tempData = NULL;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(store_address_t packet_id,
-		uint8_t** packet_ptr, size_t * size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-
-//	if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-//		debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: " << packet_id.packet_index << std::endl;
-//	}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));//TODO checkme
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		uint32_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			//Getting any data from the right "block" is ok. This is necessary, as IF's sometimes don't point to the first element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-//			if (deltaAddress % element_sizes[n] != 0) {
-//				error << "Pool::deleteData: address not aligned!" << std::endl;
-//			}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
-		return RETURN_FAILED;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error
-					<< "LocalPool::initialize: Pool is too large! Max. allowed size is: "
-					<< (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
+#include <framework/storagemanager/LocalPool.tpp>
 
 #endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
new file mode 100644
index 00000000..5cead166
--- /dev/null
+++ b/storagemanager/LocalPool.tpp
@@ -0,0 +1,260 @@
+#ifndef LOCALPOOL_TPP
+#define LOCALPOOL_TPP
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
+		bool spillsToHigherPools) :
+		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
+		spillsToHigherPools(spillsToHigherPools)
+{
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		this->element_sizes[n] = element_sizes[n];
+		this->n_elements[n] = n_elements[n];
+		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
+		size_list[n] = new uint32_t[n_elements[n]];
+		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
+		uint16_t* element) {
+	ReturnValue_t status = DATA_STORAGE_FULL;
+	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
+			foundElement++) {
+		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
+			*element = foundElement;
+			status = RETURN_OK;
+			break;
+		}
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
+		const uint8_t* data, size_t size) {
+	uint8_t* ptr;
+	uint32_t packet_position = getRawPosition(packet_id);
+
+	//check size? -> Not necessary, because size is checked before calling this function.
+	ptr = &store[packet_id.pool_index][packet_position];
+	memcpy(ptr, data, size);
+	size_list[packet_id.pool_index][packet_id.packet_index] = size;
+}
+
+//Returns page size of 0 in case store_index is illegal
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
+	if (pool_index < NUMBER_OF_POOLS) {
+		return element_sizes[pool_index];
+	} else {
+		return 0;
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
+		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
+	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
+		//		n << ", Element Size: " << element_sizes[n] << std::endl;
+		if (element_sizes[n] >= packet_size) {
+			*poolIndex = n;
+			return RETURN_OK;
+		}
+	}
+	return DATA_TOO_LARGE;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
+		store_address_t packet_id) {
+	return packet_id.packet_index * element_sizes[packet_id.pool_index];
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
+	if (status != RETURN_OK) {
+		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+				<< " )::reserveSpace: Packet too large." << std::endl;
+		return status;
+	}
+	status = findEmpty(address->pool_index, &address->packet_index);
+	while (status != RETURN_OK && spillsToHigherPools) {
+		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
+		if (status != RETURN_OK) {
+			//We don't find any fitting pool anymore.
+			break;
+		}
+		status = findEmpty(address->pool_index, &address->packet_index);
+	}
+	if (status == RETURN_OK) {
+		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
+		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
+		//				" Index: " << address->packet_index << std::endl;
+		// }
+
+		size_list[address->pool_index][address->packet_index] = size;
+	} else {
+		if (!ignoreFault and internalErrorReporter != nullptr) {
+			internalErrorReporter->storeFull();
+		}
+		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
+		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		delete[] store[n];
+		delete[] size_list[n];
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+		const uint8_t* data, size_t size, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		write(*storageId, data, size);
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
+		store_address_t* storageId, const size_t size,
+		uint8_t** p_data, bool ignoreFault) {
+	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+	if (status == RETURN_OK) {
+		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
+	} else {
+		*p_data = NULL;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
+		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
+	uint8_t* tempData = NULL;
+	ReturnValue_t status = modifyData(packet_id, &tempData, size);
+	*packet_ptr = tempData;
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	ReturnValue_t status = RETURN_FAILED;
+	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
+		return ILLEGAL_STORAGE_ID;
+	}
+	if (size_list[packet_id.pool_index][packet_id.packet_index]
+			!= STORAGE_FREE) {
+		uint32_t packet_position = getRawPosition(packet_id);
+		*packet_ptr = &store[packet_id.pool_index][packet_position];
+		*size = size_list[packet_id.pool_index][packet_id.packet_index];
+		status = RETURN_OK;
+	} else {
+		status = DATA_DOES_NOT_EXIST;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
+	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
+	//	         << packet_id.packet_index << std::endl;
+	//}
+	ReturnValue_t status = RETURN_OK;
+	uint32_t page_size = getPageSize(packet_id.pool_index);
+	if ((page_size != 0)
+			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
+		uint16_t packet_position = getRawPosition(packet_id);
+		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
+		memset(ptr, 0, page_size);
+		//Set free list
+		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
+	} else {
+		//pool_index or packet_index is too large
+		sif::error << "LocalPool:deleteData failed." << std::endl;
+		status = ILLEGAL_STORAGE_ID;
+	}
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//TODO checkme
+		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
+	}
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
+		size_t size, store_address_t* storeId) {
+	store_address_t localId;
+	ReturnValue_t result = ILLEGAL_ADDRESS;
+	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+		//Not sure if new allocates all stores in order. so better be careful.
+		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
+			localId.pool_index = n;
+			uint32_t deltaAddress = ptr - store[n];
+			// Getting any data from the right "block" is ok.
+			// This is necessary, as IF's sometimes don't point to the first
+			// element of an object.
+			localId.packet_index = deltaAddress / element_sizes[n];
+			result = deleteData(localId);
+			//if (deltaAddress % element_sizes[n] != 0) {
+			//	error << "Pool::deleteData: address not aligned!" << std::endl;
+			//}
+			break;
+		}
+	}
+	if (storeId != NULL) {
+		*storeId = localId;
+	}
+	return result;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			objects::INTERNAL_ERROR_REPORTER);
+	if (internalErrorReporter == NULL){
+		return RETURN_FAILED;
+	}
+
+	//Check if any pool size is large than the maximum allowed.
+	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+		if (element_sizes[count] >= STORAGE_FREE) {
+			sif::error << "LocalPool::initialize: Pool is too large! "
+					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+#endif
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index bb88931b..d85fe86f 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -6,9 +6,9 @@
 #include <stddef.h>
 
 /**
- * This union defines the type that identifies where a data packet is stored in the store.
- * It comprises of a raw part to read it as raw value and a structured part to use it in
- * pool-like stores.
+ * This union defines the type that identifies where a data packet is
+ * stored in the store. It comprises of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
  */
 union store_address_t {
 	/**
@@ -94,7 +94,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t addData(store_address_t* storageId, const uint8_t * data, uint32_t size, bool ignoreFault = false) = 0;
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
 	/**
 	 * @brief	With deleteData, the storageManager frees the memory region
 	 * 			identified by packet_id.
@@ -105,14 +106,16 @@ public:
 	 */
 	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
 	/**
-	 * @brief	Another deleteData which uses the pointer and size of the stored data to delete the content.
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
 	 * @param buffer	Pointer to the data.
 	 * @param size		Size of data to be stored.
 	 * @param storeId	Store id of the deleted element (optional)
 	 * @return	@li RETURN_OK on success.
 	 * 			@li	failure code if deletion did not work
 	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL) = 0;
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.
@@ -125,12 +128,12 @@ public:
 	 * 				(e.g. an illegal packet_id was passed).
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t * size) = 0;
+			const uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * Same as above, but not const and therefore modifiable.
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t * size) = 0;
+			uint8_t** packet_ptr, size_t* size) = 0;
 	/**
 	 * This method reserves an element of \c size.
 	 *
@@ -145,7 +148,7 @@ public:
 	 * 						storageId is unchanged then.
 	 */
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!

From 6817aa4d03f542939742ef9ccdadd578faaf428a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 May 2020 16:57:08 +0200
Subject: [PATCH 0220/1292] pool manager refactoring

---
 storagemanager/PoolManager.h   | 85 +++++++++-------------------------
 storagemanager/PoolManager.tpp | 50 ++++++++++++++++++++
 2 files changed, 72 insertions(+), 63 deletions(-)
 create mode 100644 storagemanager/PoolManager.tpp

diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 329235d5..6e6c7613 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,12 +1,3 @@
-/**
- *	@file	PoolManager
- *
- *  @date	02.02.2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the PoolManager class.
- */
-
 #ifndef POOLMANAGER_H_
 #define POOLMANAGER_H_
 
@@ -17,71 +8,39 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * \details	Uses local pool, but is thread-safe.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
  */
 
 template <uint8_t NUMBER_OF_POOLS = 5>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-protected:
-	/**
-	 * Overwritten for thread safety.
-	 * Locks during execution.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault);
-
-	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
-	 * \details	Locking and unlocking is done during searching for free slots and deleting existing slots.
-	 */
-	MutexIF*	mutex;
 public:
-	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS], const uint16_t n_elements[NUMBER_OF_POOLS] );
+	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS] );
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory is freed.
 	 */
-	virtual ~PoolManager( void );
+	virtual ~PoolManager();
+
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = NULL) override;
+
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+				size_t* size) override;
+protected:
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
 	/**
-	 * Overwritten for thread safety.
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
 	 */
-	virtual ReturnValue_t deleteData(store_address_t);
-	virtual ReturnValue_t deleteData(uint8_t* buffer, uint32_t size, store_address_t* storeId = NULL);
+	MutexIF* mutex;
 };
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) :
-		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//	debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store " << packet_id.pool_index << ". id is " << packet_id.packet_index << std::endl;
-		MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-		ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-		return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer, uint32_t size,
-		store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer, size, storeId);
-	return status;
-}
+#include "PoolManager.tpp"
 
 #endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
new file mode 100644
index 00000000..ed340b91
--- /dev/null
+++ b/storagemanager/PoolManager.tpp
@@ -0,0 +1,50 @@
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
+		const uint16_t element_sizes[NUMBER_OF_POOLS],
+		const uint16_t n_elements[NUMBER_OF_POOLS]) :
+		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
+		const uint32_t size, store_address_t* address, bool ignoreFault) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
+			address,ignoreFault);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
+		store_address_t packet_id) {
+	// debug << "PoolManager( " << translateObject(getObjectId()) <<
+	//       " )::deleteData from store " << packet_id.pool_index <<
+	//       ". id is "<< packet_id.packet_index << std::endl;
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
+		size_t size, store_address_t* storeId) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
+			size, storeId);
+	return status;
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
+		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
+	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
+				packet_ptr, size);
+	return status;
+}

From 1825924b7bf46d65fc163ac89921d9d70ddbe33b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 10:16:16 +0200
Subject: [PATCH 0221/1292] abbreviation for resultIF

---
 returnvalues/HasReturnvaluesIF.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index d84fc757..964d081f 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -18,4 +18,6 @@ public:
 
 };
 
+using ResultIF = HasReturnvaluesIF;
+
 #endif /* HASRETURNVALUESIF_H_ */

From c05b9cbd01b490046f6d7881bf4ff62f7e2a63c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 14:07:27 +0200
Subject: [PATCH 0222/1292] reverted ResultIF. for now, keep using
 HasReturnvaluesIF

---
 returnvalues/HasReturnvaluesIF.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 964d081f..9bbaf601 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -13,11 +13,7 @@ class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
 	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
-	virtual ~HasReturnvaluesIF() {
-	}
-
+	virtual ~HasReturnvaluesIF() {}
 };
 
-using ResultIF = HasReturnvaluesIF;
-
 #endif /* HASRETURNVALUESIF_H_ */

From bc17b5a907ca3fe2ead9829a1a582bedc84389b1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 18:43:28 +0200
Subject: [PATCH 0223/1292] resolved conflict

---
 osal/linux/FixedTimeslotTask.cpp | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 2775e4f6..098753a7 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -42,25 +42,14 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-<<<<<<< HEAD
-	if (!objectManager->get<ExecutableObjectIF>(componentId)) {
-		sif::error << "Component " << std::hex << componentId
-				   << " not found, not adding it to pst" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	pst.addSlot(componentId, slotTimeMs, executionStep, this);
-	return HasReturnvaluesIF::RETURN_OK;
-=======
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId <<
+	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
->>>>>>> luz_FixedTimeslotTask_ExistenceCheck
 }
 
 ReturnValue_t FixedTimeslotTask::checkSequence() const {

From 160a09790e112fdd6cc40cbb75b502c9ca057fd8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 18:53:25 +0200
Subject: [PATCH 0224/1292] removed c omment for now

---
 devicehandlers/FixedSlotSequence.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 466d846f..aa0df9cb 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,10 +90,6 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-	    // does check sequence have to be const?
-	    // if I want to check a class, I need the ability to set
-	    // internal class states.
-	    //isEmpty = true;
 	    std::exit(0);
 	}
     // Iterate through slotList and check successful creation.

From f09836a9eb4aeb561ae1e6fa13e20c0aa0fc01cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 19:30:03 +0200
Subject: [PATCH 0225/1292] removed exit for empty psremoved exit for empty
 pstt

---
 devicehandlers/FixedSlotSequence.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index aa0df9cb..00020d68 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,7 +90,6 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-	    std::exit(0);
 	}
     // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.

From cc0469fef6031ebde23583f958fcf1c0b1e5ef3e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 May 2020 20:09:42 +0200
Subject: [PATCH 0226/1292] return failed insteead of exiting

---
 devicehandlers/FixedSlotSequence.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 00020d68..860a643b 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -90,6 +90,7 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+	    return HasReturnvaluesIF::RETURN_FAILED;
 	}
     // Iterate through slotList and check successful creation.
 	// Checks if timing is ok (must be ascending) and if all handlers were found.

From e950051b4ab7edcc6919af226f3c7a1eae63602e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 6 May 2020 14:35:30 +0200
Subject: [PATCH 0227/1292] some object managerIF security measures

objectmanager get function checks whether global object manager was
initialized now.
New returnvalues, which are also used for local pool init
---
 devicehandlers/FixedSlotSequence.cpp |  8 --------
 devicehandlers/FixedSlotSequence.h   | 16 +--------------
 objectmanager/ObjectManagerIF.h      | 29 ++++++++++++++++++----------
 storagemanager/LocalPool.tpp         |  6 +++---
 storagemanager/StorageManagerIF.h    |  1 +
 5 files changed, 24 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp
index 6db7ee43..8974510e 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/devicehandlers/FixedSlotSequence.cpp
@@ -89,17 +89,9 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-<<<<<<< HEAD
 	    sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	}
-    // Iterate through slotList and check successful creation.
-	// Checks if timing is ok (must be ascending) and if all handlers were found.
-=======
-		error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
->>>>>>> master
 	auto slotIt = slotList.begin();
 	uint32_t count = 0;
 	uint32_t time = 0;
diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h
index 65ad3451..dd9636c1 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/devicehandlers/FixedSlotSequence.h
@@ -12,16 +12,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
- *
-<<<<<<< HEAD
- * @details	The FixedSlotSequence object maintains the dynamic execution of device handler objects.
- * 			The main idea is to create a list of device handlers, to announce all handlers to the
- * 			polling sequence and to maintain a list of polling slot objects. This slot list represents the
- * 			Polling Sequence Table in software. Each polling slot contains information to indicate when and
- * 			which device handler shall be executed within a given polling period.
- * 			The sequence is then executed by iterating through this slot list.
- * 			Handlers are invoking by calling a certain function stored in the handler list.
-=======
  * @details
  * The FixedSlotSequence object maintains the dynamic execution of
  * device handler objects.
@@ -35,7 +25,6 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
  * which device handler shall be executed within a given polling period.
  * The sequence is then executed by iterating through this slot list.
  * Handlers are invoking by calling a certain function stored in the handler list.
->>>>>>> master
  */
 class FixedSlotSequence {
 public:
@@ -128,16 +117,13 @@ public:
 	 */
 	SlotListIter current;
 
-<<<<<<< HEAD
-	virtual ReturnValue_t checkSequence() const;
-=======
 	/**
 	 * Iterate through slotList and check successful creation.
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
->>>>>>> master
+
 protected:
 
 	/**
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1d7674c6..3a23e339 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -12,6 +12,7 @@
 #include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
  * @brief	This class provides an interface to the global object manager.
@@ -24,9 +25,12 @@
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
 protected:
 	/**
 	 * @brief	This method is used to hide the template-based get call from
@@ -79,16 +83,21 @@ public:
 };
 
 
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
 extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+		std::exit(0);
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
 #endif /* OBJECTMANAGERIF_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 5cead166..c46e1a8d 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -242,8 +242,8 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 	}
 	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == NULL){
-		return RETURN_FAILED;
+	if (internalErrorReporter == nullptr){
+		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
 	}
 
 	//Check if any pool size is large than the maximum allowed.
@@ -251,7 +251,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 		if (element_sizes[count] >= STORAGE_FREE) {
 			sif::error << "LocalPool::initialize: Pool is too large! "
 					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return RETURN_FAILED;
+			return StorageManagerIF::POOL_TOO_LARGE;
 		}
 	}
 	return RETURN_OK;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d85fe86f..d1f9cde5 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -71,6 +71,7 @@ public:
 	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
 	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
 	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);

From b016f2995a00a3a5183794bb576820d17b6f078b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 6 May 2020 16:34:43 +0200
Subject: [PATCH 0228/1292] added default vlaue for init function

---
 action/ActionHelper.cpp | 10 ++++++----
 action/ActionHelper.h   |  2 +-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index ef9f06a9..19a84d82 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,9 +1,9 @@
 #include <framework/action/ActionHelper.h>
 #include <framework/action/HasActionsIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
+
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(
-				NULL) {
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -22,10 +22,12 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
+	if (ipcStore == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	setQueueToUse(queueToUse_);
+	if(queueToUse_ != nullptr) {
+		setQueueToUse(queueToUse_);
+	}
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 6ba6dd89..3d8351d6 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -38,7 +38,7 @@ public:
 	 * @param queueToUse_ Pointer to the messageQueue to be used
 	 * @return Returns RETURN_OK if successful
 	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	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.
 	 *

From fe9aa46cf8d33ccb93b570fe77631abb08555829 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 7 May 2020 12:22:17 +0200
Subject: [PATCH 0229/1292] removed system object list include.

makes it difficult for multiple configurations, because the wrong header
might be included
---
 objectmanager/ObjectManagerIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 3a23e339..3575fc16 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -9,7 +9,6 @@
 #define OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
-#include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>

From 9489b7abc1bee2a2b164e81f178222706a8c2b8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 7 May 2020 19:23:56 +0200
Subject: [PATCH 0230/1292] modifyData override deleted

is not really thread-safe anyway
---
 devicehandlers/CommunicationMessage.h | 8 ++------
 storagemanager/PoolManager.h          | 3 ---
 storagemanager/PoolManager.tpp        | 8 --------
 3 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index a92c4b5c..95266319 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -13,15 +13,11 @@
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 
 /**
- * @brief Used to pass communication information between tasks
+ * @brief Message type to send larger messages
  *
  * @details
  * Can be used to pass information like data pointers and
- * data sizes between communication tasks
- * like the Device Handler Comm Interfaces and Polling Tasks.
- *
- * Can also be used to exchange actual data if its not too large
- * (e.g. Sensor values).
+ * data sizes between communication tasks.
  *
  */
 class CommunicationMessage: public MessageQueueMessage {
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 6e6c7613..41325273 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -25,9 +25,6 @@ public:
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = NULL) override;
-
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-				size_t* size) override;
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index ed340b91..0408d55b 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -40,11 +40,3 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 	return status;
 }
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
-		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
-				packet_ptr, size);
-	return status;
-}

From 0f286461d065f25ddda7b63f4f3ae45d2e6b5db3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 May 2020 18:10:26 +0200
Subject: [PATCH 0231/1292] added new storage raw accessor

---
 storagemanager/StorageAccessor.cpp | 154 +++++++++++++++++++++++++
 storagemanager/StorageAccessor.h   | 174 +++++++++++++++++++++++++++++
 2 files changed, 328 insertions(+)
 create mode 100644 storagemanager/StorageAccessor.cpp
 create mode 100644 storagemanager/StorageAccessor.h

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
new file mode 100644
index 00000000..50e503cf
--- /dev/null
+++ b/storagemanager/StorageAccessor.cpp
@@ -0,0 +1,154 @@
+#include <test/prototypes/StorageAccessor.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteDataNonLocking(storeId);
+	}
+	if(mutexLock != nullptr) {
+		sif::debug << "unlocking mutex lock" << std::endl;
+		mutexLock.reset();
+	}
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// Transfer ownership of the lock.
+	mutexLock = std::move(other.mutexLock);
+	// This prevents double deletion of the resource. Not strictly necessary,
+	// from the testing I have conducted so far but I am not familiar enough
+	// with move semantics so I will just set the other lock to nullptr for now.
+	other.mutexLock = nullptr;
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
+	if(mutexLock == nullptr) {
+		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
+		return mutexLock.get()->getResult();
+	}
+	else {
+		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void ConstStorageAccessor::unlock() {
+	if(mutexLock != nullptr) {
+		mutexLock.reset();
+	}
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::READ;
+	this->store = store;
+}
+
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
new file mode 100644
index 00000000..f861a2cc
--- /dev/null
+++ b/storagemanager/StorageAccessor.h
@@ -0,0 +1,174 @@
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details	These helper can be used together with the
+ * 			StorageManager classes to manage access to a storage.
+ * 			It can take care of thread-safety while also providing
+ * 			mechanisms to automatically clear storage data and unlocking the
+ * 			pool.
+ */
+#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+
+#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <memory>
+
+
+/**
+ * @brief   Accessor class which can be returned by pool managers
+ *          or passed and set by pool managers to have safe access to the pool
+ *          resources.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	void getDataCopy(uint8_t *pointer);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+	/**
+	 * @brief 	Locks the supplied mutex.
+	 * @details
+	 * The mutex will be unlocked automatically
+	 * when this class is destroyed (for example when exiting the scope).
+	 * Only one mutex can be locked at a time!
+	 * @param mutex
+	 * @param mutexTimeout
+	 * @return
+	 */
+	ReturnValue_t lock(MutexIF* mutex,
+			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
+	/**
+	 * @brief	Unlocks the mutex (if one has been locked previously).
+	 *          Unless this function is called, the mutex is unlocked
+	 *          when the class exits the scope.
+	 */
+	void unlock();
+
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	//! Unique pointer to the mutex lock instance. Is initialized by
+	//! the pool manager.
+	std::unique_ptr<MutexHelper> mutexLock = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		READ
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+
+};
+
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator= (StorageAccessor&&);
+	StorageAccessor (StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset);
+	uint8_t* data();
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From 2f58c3a3052506e922ba1758e9a7fa4f1c642c9f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 00:14:00 +0200
Subject: [PATCH 0232/1292] commented out storage accessor

---
 storagemanager/StorageAccessor.cpp | 308 ++++++++++++-------------
 storagemanager/StorageAccessor.h   | 348 ++++++++++++++---------------
 2 files changed, 328 insertions(+), 328 deletions(-)

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 50e503cf..a068d169 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,154 +1,154 @@
-#include <test/prototypes/StorageAccessor.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteDataNonLocking(storeId);
-	}
-	if(mutexLock != nullptr) {
-		sif::debug << "unlocking mutex lock" << std::endl;
-		mutexLock.reset();
-	}
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// Transfer ownership of the lock.
-	mutexLock = std::move(other.mutexLock);
-	// This prevents double deletion of the resource
-	other.mutexLock = nullptr;
-	// This prevent premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// Transfer ownership of the lock.
-	mutexLock = std::move(other.mutexLock);
-	// This prevents double deletion of the resource. Not strictly necessary,
-	// from the testing I have conducted so far but I am not familiar enough
-	// with move semantics so I will just set the other lock to nullptr for now.
-	other.mutexLock = nullptr;
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
-	if(mutexLock == nullptr) {
-		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
-		return mutexLock.get()->getResult();
-	}
-	else {
-		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void ConstStorageAccessor::unlock() {
-	if(mutexLock != nullptr) {
-		mutexLock.reset();
-	}
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::READ;
-	this->store = store;
-}
-
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+//#include <framework/storagemanager/StorageAccessor.h>
+//
+//ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
+//
+//ConstStorageAccessor::~ConstStorageAccessor() {
+//	if(deleteData and store != nullptr) {
+//		sif::debug << "deleting store data" << std::endl;
+//		store->deleteDataNonLocking(storeId);
+//	}
+//	if(mutexLock != nullptr) {
+//		sif::debug << "unlocking mutex lock" << std::endl;
+//		mutexLock.reset();
+//	}
+//}
+//
+//ConstStorageAccessor& ConstStorageAccessor::operator=(
+//		ConstStorageAccessor&& other) {
+//	constDataPointer = other.constDataPointer;
+//	storeId = other.storeId;
+//	store = other.store;
+//	size_ = other.size_;
+//	deleteData = other.deleteData;
+//	this->store = other.store;
+//	// Transfer ownership of the lock.
+//	mutexLock = std::move(other.mutexLock);
+//	// This prevents double deletion of the resource
+//	other.mutexLock = nullptr;
+//	// This prevent premature deletion
+//	other.store = nullptr;
+//	return *this;
+//}
+//
+//StorageAccessor::StorageAccessor(store_address_t storeId):
+//		ConstStorageAccessor(storeId) {
+//}
+//
+//StorageAccessor& StorageAccessor::operator =(
+//		StorageAccessor&& other) {
+//	// Call the parent move assignment and also assign own member.
+//	dataPointer = other.dataPointer;
+//	StorageAccessor::operator=(std::move(other));
+//	return * this;
+//}
+//
+//// Call the parent move ctor and also transfer own member.
+//StorageAccessor::StorageAccessor(StorageAccessor&& other):
+//		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+//}
+//
+//ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+//		constDataPointer(other.constDataPointer), storeId(other.storeId),
+//		size_(other.size_), store(other.store), deleteData(other.deleteData),
+//		internalState(other.internalState) {
+//	// Transfer ownership of the lock.
+//	mutexLock = std::move(other.mutexLock);
+//	// This prevents double deletion of the resource. Not strictly necessary,
+//	// from the testing I have conducted so far but I am not familiar enough
+//	// with move semantics so I will just set the other lock to nullptr for now.
+//	other.mutexLock = nullptr;
+//	// This prevent premature deletion
+//	other.store = nullptr;
+//}
+//
+//const uint8_t* ConstStorageAccessor::data() const {
+//	return constDataPointer;
+//}
+//
+//size_t ConstStorageAccessor::size() const {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//	}
+//	return size_;
+//}
+//
+//void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return;
+//	}
+//	std::copy(constDataPointer, constDataPointer + size_, pointer);
+//}
+//
+//void ConstStorageAccessor::release() {
+//	deleteData = false;
+//}
+//
+//ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
+//	if(mutexLock == nullptr) {
+//		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
+//		return mutexLock.get()->getResult();
+//	}
+//	else {
+//		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//}
+//
+//void ConstStorageAccessor::unlock() {
+//	if(mutexLock != nullptr) {
+//		mutexLock.reset();
+//	}
+//}
+//
+//store_address_t ConstStorageAccessor::getId() const {
+//	return storeId;
+//}
+//
+//void ConstStorageAccessor::print() const {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return;
+//	}
+//	sif::info << "StorageAccessor: Printing data: [";
+//	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+//		sif::info << std::hex << (int)constDataPointer[iPool];
+//		if(iPool < size_ - 1){
+//			sif::info << " , ";
+//		}
+//	}
+//	sif::info << " ] " << std::endl;
+//}
+//
+//void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+//	internalState = AccessState::READ;
+//	this->store = store;
+//}
+//
+//
+//uint8_t* StorageAccessor::data() {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//	}
+//	return dataPointer;
+//}
+//
+//ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+//		uint16_t offset) {
+//	if(internalState == AccessState::UNINIT) {
+//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	if(offset + size > size_) {
+//		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	std::copy(data, data + size, dataPointer);
+//	return HasReturnvaluesIF::RETURN_OK;
+//}
+//
+//void StorageAccessor::assignConstPointer() {
+//	constDataPointer = dataPointer;
+//}
+//
+//
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index f861a2cc..d391c5c2 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,174 +1,174 @@
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details	These helper can be used together with the
- * 			StorageManager classes to manage access to a storage.
- * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data and unlocking the
- * 			pool.
- */
-#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
-
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <memory>
-
-
-/**
- * @brief   Accessor class which can be returned by pool managers
- *          or passed and set by pool managers to have safe access to the pool
- *          resources.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	void getDataCopy(uint8_t *pointer);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-	/**
-	 * @brief 	Locks the supplied mutex.
-	 * @details
-	 * The mutex will be unlocked automatically
-	 * when this class is destroyed (for example when exiting the scope).
-	 * Only one mutex can be locked at a time!
-	 * @param mutex
-	 * @param mutexTimeout
-	 * @return
-	 */
-	ReturnValue_t lock(MutexIF* mutex,
-			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
-	/**
-	 * @brief	Unlocks the mutex (if one has been locked previously).
-	 *          Unless this function is called, the mutex is unlocked
-	 *          when the class exits the scope.
-	 */
-	void unlock();
-
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	//! Unique pointer to the mutex lock instance. Is initialized by
-	//! the pool manager.
-	std::unique_ptr<MutexHelper> mutexLock = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		READ
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-
-};
-
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 			 move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset);
-	uint8_t* data();
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+///**
+// * @brief 	Helper classes to facilitate safe access to storages which is also
+// * 			conforming to RAII principles
+// * @details	These helper can be used together with the
+// * 			StorageManager classes to manage access to a storage.
+// * 			It can take care of thread-safety while also providing
+// * 			mechanisms to automatically clear storage data and unlocking the
+// * 			pool.
+// */
+//#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+//#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+//
+//#include <framework/ipc/MutexHelper.h>
+//#include <framework/storagemanager/StorageManagerIF.h>
+//#include <memory>
+//
+//
+///**
+// * @brief   Accessor class which can be returned by pool managers
+// *          or passed and set by pool managers to have safe access to the pool
+// *          resources.
+// */
+//class ConstStorageAccessor {
+//	//! StorageManager classes have exclusive access to private variables.
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class PoolManager;
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class LocalPool;
+//public:
+//	/**
+//	 * @brief	Simple constructor which takes the store ID of the storage
+//	 * 			entry to access.
+//	 * @param storeId
+//	 */
+//	ConstStorageAccessor(store_address_t storeId);
+//
+//	/**
+//	 * @brief	Move ctor and move assignment allow returning accessors as
+//	 * 			a returnvalue. They prevent resource being free prematurely.
+//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+//	 * move-constructors-and-move-assignment-operators-cpp.md
+//	 * @param
+//	 * @return
+//	 */
+//	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+//	ConstStorageAccessor (ConstStorageAccessor&&);
+//
+//	//! The copy ctor and copy assignemnt should be deleted implicitely
+//	//! according to https://foonathan.net/2019/02/special-member-functions/
+//	//! but I still deleted them to make it more explicit. (remember rule of 5).
+//	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+//	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+//
+//	/**
+//	 * @brief 	The destructor in default configuration takes care of
+//	 * 			deleting the accessed pool entry and unlocking the mutex
+//	 */
+//	virtual ~ConstStorageAccessor();
+//
+//	/**
+//	 * @brief	Returns a pointer to the read-only data
+//	 * @return
+//	 */
+//	const uint8_t* data() const;
+//
+//	/**
+//	 * @brief	Copies the read-only data to the supplied pointer
+//	 * @param pointer
+//	 */
+//	void getDataCopy(uint8_t *pointer);
+//
+//	/**
+//	 * @brief   Calling this will prevent the Accessor from deleting the data
+//	 *          when the destructor is called.
+//	 */
+//	void release();
+//	/**
+//	 * @brief 	Locks the supplied mutex.
+//	 * @details
+//	 * The mutex will be unlocked automatically
+//	 * when this class is destroyed (for example when exiting the scope).
+//	 * Only one mutex can be locked at a time!
+//	 * @param mutex
+//	 * @param mutexTimeout
+//	 * @return
+//	 */
+//	ReturnValue_t lock(MutexIF* mutex,
+//			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
+//	/**
+//	 * @brief	Unlocks the mutex (if one has been locked previously).
+//	 *          Unless this function is called, the mutex is unlocked
+//	 *          when the class exits the scope.
+//	 */
+//	void unlock();
+//
+//
+//	/**
+//	 * Get the size of the data
+//	 * @return
+//	 */
+//	size_t size() const;
+//
+//	/**
+//	 * Get the storage ID.
+//	 * @return
+//	 */
+//	store_address_t getId() const;
+//
+//	void print() const;
+//protected:
+//	const uint8_t* constDataPointer = nullptr;
+//	store_address_t storeId;
+//	size_t size_ = 0;
+//	//! Managing pool, has to assign itself.
+//	StorageManagerIF* store = nullptr;
+//	//! Unique pointer to the mutex lock instance. Is initialized by
+//	//! the pool manager.
+//	std::unique_ptr<MutexHelper> mutexLock = nullptr;
+//	bool deleteData = true;
+//
+//	enum class AccessState {
+//		UNINIT,
+//		READ
+//	};
+//	//! Internal state for safety reasons.
+//	AccessState internalState = AccessState::UNINIT;
+//	/**
+//	 * Used by the pool manager instances to assign themselves to the
+//	 * accessor. This is necessary to delete the data when the acessor
+//	 * exits the scope ! The internal state will be considered read
+//	 * when this function is called, so take care all data is set properly as
+//	 * well.
+//	 * @param
+//	 */
+//	void assignStore(StorageManagerIF*);
+//
+//};
+//
+//
+///**
+// * @brief   Child class for modifyable data. Also has a normal pointer member.
+// */
+//class StorageAccessor: public ConstStorageAccessor {
+//	//! StorageManager classes have exclusive access to private variables.
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class PoolManager;
+//	template<uint8_t NUMBER_OF_POOLS>
+//	friend class LocalPool;
+//public:
+//	StorageAccessor(store_address_t storeId);
+//	/**
+//	 * @brief	Move ctor and move assignment allow returning accessors as
+//	 * 			a returnvalue. They prevent resource being free prematurely.
+//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+//	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+//	 * @param
+//	 * @return
+//	 */
+//	StorageAccessor& operator= (StorageAccessor&&);
+//	StorageAccessor (StorageAccessor&&);
+//
+//	ReturnValue_t write(uint8_t *data, size_t size,
+//		uint16_t offset);
+//	uint8_t* data();
+//
+//private:
+//	//! Non-const pointer for modifyable data.
+//	uint8_t* dataPointer = nullptr;
+//	//! For modifyable data, the const pointer is assigned to the normal
+//	//! pointer by the pool manager so both access functions can be used safely
+//	void assignConstPointer();
+//};
+//
+//#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From d44a06fafc1a63ec38354438910b556e0f1c6b81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 12:48:22 +0200
Subject: [PATCH 0233/1292] removed cfg include

---
 objectmanager/ObjectManagerIF.h | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1d7674c6..3575fc16 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -9,9 +9,9 @@
 #define OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
-#include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
  * @brief	This class provides an interface to the global object manager.
@@ -24,9 +24,12 @@
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static const ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
 protected:
 	/**
 	 * @brief	This method is used to hide the template-based get call from
@@ -79,16 +82,21 @@ public:
 };
 
 
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
 extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+		std::exit(0);
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
 #endif /* OBJECTMANAGERIF_H_ */

From 43d3ca7e379cf1dd20cd0372cf4883eb468d030a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 10 May 2020 21:56:21 +0200
Subject: [PATCH 0234/1292] memory message: no retval

CSB: retval
---
 memory/MemoryMessage.cpp             | 3 +--
 memory/MemoryMessage.h               | 2 +-
 tmtcservices/CommandingServiceBase.h | 2 ++
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index c1116e08..f978ed4e 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -31,12 +31,11 @@ ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_a
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
 		uint32_t address, store_address_t storageID) {
 	message->setCommand(CMD_MEMORY_LOAD);
 	message->setParameter( address );
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index 124fad08..bcc262e9 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -24,7 +24,7 @@ public:
 	static ReturnValue_t getErrorCode( const CommandMessage* message );
 	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
 	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static ReturnValue_t setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
 	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
 	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
 	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 6b76bdab..259ed1a3 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -212,6 +212,8 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask;
 
+	// todo: why do these functions not have returnvalues? the caller should be
+	// able to check whether the send operations actually work.
 	/**
 	 * Send TM data from pointer to data. If a header is supplied it is added before data
 	 * @param subservice Number of subservice

From 1946af64af5afb479bda4604b33d712eef99e43a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 14:11:00 +0200
Subject: [PATCH 0235/1292] storage accessor mutex lock removed

---
 storagemanager/StorageAccessor.cpp | 284 ++++++++++++-------------
 storagemanager/StorageAccessor.h   | 326 ++++++++++++++---------------
 2 files changed, 282 insertions(+), 328 deletions(-)

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index a068d169..51b93f11 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,154 +1,130 @@
-//#include <framework/storagemanager/StorageAccessor.h>
-//
-//ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId): storeId(storeId) {}
-//
-//ConstStorageAccessor::~ConstStorageAccessor() {
-//	if(deleteData and store != nullptr) {
-//		sif::debug << "deleting store data" << std::endl;
-//		store->deleteDataNonLocking(storeId);
-//	}
-//	if(mutexLock != nullptr) {
-//		sif::debug << "unlocking mutex lock" << std::endl;
-//		mutexLock.reset();
-//	}
-//}
-//
-//ConstStorageAccessor& ConstStorageAccessor::operator=(
-//		ConstStorageAccessor&& other) {
-//	constDataPointer = other.constDataPointer;
-//	storeId = other.storeId;
-//	store = other.store;
-//	size_ = other.size_;
-//	deleteData = other.deleteData;
-//	this->store = other.store;
-//	// Transfer ownership of the lock.
-//	mutexLock = std::move(other.mutexLock);
-//	// This prevents double deletion of the resource
-//	other.mutexLock = nullptr;
-//	// This prevent premature deletion
-//	other.store = nullptr;
-//	return *this;
-//}
-//
-//StorageAccessor::StorageAccessor(store_address_t storeId):
-//		ConstStorageAccessor(storeId) {
-//}
-//
-//StorageAccessor& StorageAccessor::operator =(
-//		StorageAccessor&& other) {
-//	// Call the parent move assignment and also assign own member.
-//	dataPointer = other.dataPointer;
-//	StorageAccessor::operator=(std::move(other));
-//	return * this;
-//}
-//
-//// Call the parent move ctor and also transfer own member.
-//StorageAccessor::StorageAccessor(StorageAccessor&& other):
-//		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-//}
-//
-//ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-//		constDataPointer(other.constDataPointer), storeId(other.storeId),
-//		size_(other.size_), store(other.store), deleteData(other.deleteData),
-//		internalState(other.internalState) {
-//	// Transfer ownership of the lock.
-//	mutexLock = std::move(other.mutexLock);
-//	// This prevents double deletion of the resource. Not strictly necessary,
-//	// from the testing I have conducted so far but I am not familiar enough
-//	// with move semantics so I will just set the other lock to nullptr for now.
-//	other.mutexLock = nullptr;
-//	// This prevent premature deletion
-//	other.store = nullptr;
-//}
-//
-//const uint8_t* ConstStorageAccessor::data() const {
-//	return constDataPointer;
-//}
-//
-//size_t ConstStorageAccessor::size() const {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//	}
-//	return size_;
-//}
-//
-//void ConstStorageAccessor::getDataCopy(uint8_t *pointer) {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return;
-//	}
-//	std::copy(constDataPointer, constDataPointer + size_, pointer);
-//}
-//
-//void ConstStorageAccessor::release() {
-//	deleteData = false;
-//}
-//
-//ReturnValue_t ConstStorageAccessor::lock(MutexIF* mutex, uint32_t mutexTimeout) {
-//	if(mutexLock == nullptr) {
-//		mutexLock = std::unique_ptr<MutexHelper>(new MutexHelper(mutex, mutexTimeout));
-//		return mutexLock.get()->getResult();
-//	}
-//	else {
-//		sif::warning << "StorageAccessor: Attempted to lock twice. Check code!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//}
-//
-//void ConstStorageAccessor::unlock() {
-//	if(mutexLock != nullptr) {
-//		mutexLock.reset();
-//	}
-//}
-//
-//store_address_t ConstStorageAccessor::getId() const {
-//	return storeId;
-//}
-//
-//void ConstStorageAccessor::print() const {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return;
-//	}
-//	sif::info << "StorageAccessor: Printing data: [";
-//	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-//		sif::info << std::hex << (int)constDataPointer[iPool];
-//		if(iPool < size_ - 1){
-//			sif::info << " , ";
-//		}
-//	}
-//	sif::info << " ] " << std::endl;
-//}
-//
-//void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-//	internalState = AccessState::READ;
-//	this->store = store;
-//}
-//
-//
-//uint8_t* StorageAccessor::data() {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//	}
-//	return dataPointer;
-//}
-//
-//ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-//		uint16_t offset) {
-//	if(internalState == AccessState::UNINIT) {
-//		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	if(offset + size > size_) {
-//		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	std::copy(data, data + size, dataPointer);
-//	return HasReturnvaluesIF::RETURN_OK;
-//}
-//
-//void StorageAccessor::assignConstPointer() {
-//	constDataPointer = dataPointer;
-//}
-//
-//
+#include <framework/storagemanager/StorageAccessor.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::READ;
+	this->store = store;
+}
+
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index d391c5c2..2e1d44bd 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,174 +1,152 @@
-///**
-// * @brief 	Helper classes to facilitate safe access to storages which is also
-// * 			conforming to RAII principles
-// * @details	These helper can be used together with the
-// * 			StorageManager classes to manage access to a storage.
-// * 			It can take care of thread-safety while also providing
-// * 			mechanisms to automatically clear storage data and unlocking the
-// * 			pool.
-// */
-//#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-//#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
-//
-//#include <framework/ipc/MutexHelper.h>
-//#include <framework/storagemanager/StorageManagerIF.h>
-//#include <memory>
-//
-//
-///**
-// * @brief   Accessor class which can be returned by pool managers
-// *          or passed and set by pool managers to have safe access to the pool
-// *          resources.
-// */
-//class ConstStorageAccessor {
-//	//! StorageManager classes have exclusive access to private variables.
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class PoolManager;
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class LocalPool;
-//public:
-//	/**
-//	 * @brief	Simple constructor which takes the store ID of the storage
-//	 * 			entry to access.
-//	 * @param storeId
-//	 */
-//	ConstStorageAccessor(store_address_t storeId);
-//
-//	/**
-//	 * @brief	Move ctor and move assignment allow returning accessors as
-//	 * 			a returnvalue. They prevent resource being free prematurely.
-//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-//	 * move-constructors-and-move-assignment-operators-cpp.md
-//	 * @param
-//	 * @return
-//	 */
-//	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-//	ConstStorageAccessor (ConstStorageAccessor&&);
-//
-//	//! The copy ctor and copy assignemnt should be deleted implicitely
-//	//! according to https://foonathan.net/2019/02/special-member-functions/
-//	//! but I still deleted them to make it more explicit. (remember rule of 5).
-//	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-//	ConstStorageAccessor (ConstStorageAccessor&) = delete;
-//
-//	/**
-//	 * @brief 	The destructor in default configuration takes care of
-//	 * 			deleting the accessed pool entry and unlocking the mutex
-//	 */
-//	virtual ~ConstStorageAccessor();
-//
-//	/**
-//	 * @brief	Returns a pointer to the read-only data
-//	 * @return
-//	 */
-//	const uint8_t* data() const;
-//
-//	/**
-//	 * @brief	Copies the read-only data to the supplied pointer
-//	 * @param pointer
-//	 */
-//	void getDataCopy(uint8_t *pointer);
-//
-//	/**
-//	 * @brief   Calling this will prevent the Accessor from deleting the data
-//	 *          when the destructor is called.
-//	 */
-//	void release();
-//	/**
-//	 * @brief 	Locks the supplied mutex.
-//	 * @details
-//	 * The mutex will be unlocked automatically
-//	 * when this class is destroyed (for example when exiting the scope).
-//	 * Only one mutex can be locked at a time!
-//	 * @param mutex
-//	 * @param mutexTimeout
-//	 * @return
-//	 */
-//	ReturnValue_t lock(MutexIF* mutex,
-//			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
-//	/**
-//	 * @brief	Unlocks the mutex (if one has been locked previously).
-//	 *          Unless this function is called, the mutex is unlocked
-//	 *          when the class exits the scope.
-//	 */
-//	void unlock();
-//
-//
-//	/**
-//	 * Get the size of the data
-//	 * @return
-//	 */
-//	size_t size() const;
-//
-//	/**
-//	 * Get the storage ID.
-//	 * @return
-//	 */
-//	store_address_t getId() const;
-//
-//	void print() const;
-//protected:
-//	const uint8_t* constDataPointer = nullptr;
-//	store_address_t storeId;
-//	size_t size_ = 0;
-//	//! Managing pool, has to assign itself.
-//	StorageManagerIF* store = nullptr;
-//	//! Unique pointer to the mutex lock instance. Is initialized by
-//	//! the pool manager.
-//	std::unique_ptr<MutexHelper> mutexLock = nullptr;
-//	bool deleteData = true;
-//
-//	enum class AccessState {
-//		UNINIT,
-//		READ
-//	};
-//	//! Internal state for safety reasons.
-//	AccessState internalState = AccessState::UNINIT;
-//	/**
-//	 * Used by the pool manager instances to assign themselves to the
-//	 * accessor. This is necessary to delete the data when the acessor
-//	 * exits the scope ! The internal state will be considered read
-//	 * when this function is called, so take care all data is set properly as
-//	 * well.
-//	 * @param
-//	 */
-//	void assignStore(StorageManagerIF*);
-//
-//};
-//
-//
-///**
-// * @brief   Child class for modifyable data. Also has a normal pointer member.
-// */
-//class StorageAccessor: public ConstStorageAccessor {
-//	//! StorageManager classes have exclusive access to private variables.
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class PoolManager;
-//	template<uint8_t NUMBER_OF_POOLS>
-//	friend class LocalPool;
-//public:
-//	StorageAccessor(store_address_t storeId);
-//	/**
-//	 * @brief	Move ctor and move assignment allow returning accessors as
-//	 * 			a returnvalue. They prevent resource being free prematurely.
-//	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-//	 * 			 move-constructors-and-move-assignment-operators-cpp.md
-//	 * @param
-//	 * @return
-//	 */
-//	StorageAccessor& operator= (StorageAccessor&&);
-//	StorageAccessor (StorageAccessor&&);
-//
-//	ReturnValue_t write(uint8_t *data, size_t size,
-//		uint16_t offset);
-//	uint8_t* data();
-//
-//private:
-//	//! Non-const pointer for modifyable data.
-//	uint8_t* dataPointer = nullptr;
-//	//! For modifyable data, the const pointer is assigned to the normal
-//	//! pointer by the pool manager so both access functions can be used safely
-//	void assignConstPointer();
-//};
-//
-//#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details	These helper can be used together with the
+ * 			StorageManager classes to manage access to a storage.
+ * 			It can take care of thread-safety while also providing
+ * 			mechanisms to automatically clear storage data and unlocking the
+ * 			pool.
+ */
+#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+
+#include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <memory>
+
+
+/**
+ * @brief   Accessor class which can be returned by pool managers
+ *          or passed and set by pool managers to have safe access to the pool
+ *          resources.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		READ
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+
+};
+
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator= (StorageAccessor&&);
+	StorageAccessor (StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset);
+	uint8_t* data();
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */

From 5af0c15dfc6906eb16675e53416c0fe2f95b34b0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 14:12:39 +0200
Subject: [PATCH 0236/1292] simplified storage accessor

---
 ipc/MutexHelper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index f76ccec4..671cd5a6 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -10,11 +10,11 @@ public:
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
 		if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed " << status << std::endl;
+			sif::error << "MutexHelper: Lock of Mutex failed " <<
+					status << std::endl;
 		}
 	}
 
-
 	~MutexHelper() {
 		internalMutex->unlockMutex();
 	}

From 6c70abfe1621a83074f21476d680bc808a52576f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 16:32:01 +0200
Subject: [PATCH 0237/1292] moved pool accessor fuctions to local pool

---
 storagemanager/LocalPool.h        | 10 ++++++-
 storagemanager/LocalPool.tpp      | 43 +++++++++++++++++++++++++++++--
 storagemanager/PoolManager.h      | 19 +++++++-------
 storagemanager/PoolManager.tpp    |  5 ++++
 storagemanager/StorageAccessor.h  |  4 +--
 storagemanager/StorageManagerIF.h | 17 +++++++++++-
 6 files changed, 82 insertions(+), 16 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index a6334458..6892b881 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -6,7 +6,8 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/internalError/InternalErrorReporterIF.h>
-#include <string.h>
+#include <framework/storagemanager/StorageAccessor.h>
+#include <cstring>
 
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
@@ -67,10 +68,17 @@ public:
 			size_t size, bool ignoreFault = false) override;
 	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
 			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
 	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
 			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
 	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
 			size_t * size) override;
+
 	virtual ReturnValue_t deleteData(store_address_t) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
 			store_address_t* storeId = NULL) override;
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index c46e1a8d..31034974 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -121,8 +121,8 @@ inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
 	}
 }
 
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
+template<uint8_t NUMBER_OF_POOLS> inline
+ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
 		const uint8_t* data, size_t size, bool ignoreFault) {
 	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
 	if (status == RETURN_OK) {
@@ -144,6 +144,25 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
 	return status;
 }
 
+template<uint8_t NUMBER_OF_POOLS>
+inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
+		store_address_t storeId) {
+	uint8_t* tempData = nullptr;
+	ConstStorageAccessor constAccessor(storeId);
+	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
+	constAccessor.constDataPointer = tempData;
+	return ConstAccessorPair(status, std::move(constAccessor));
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId,
+		ConstStorageAccessor& storeAccessor) {
+	uint8_t* tempData = nullptr;
+	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
+	storeAccessor.constDataPointer = tempData;
+	return status;
+}
+
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
@@ -153,6 +172,26 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 	return status;
 }
 
+template<uint8_t NUMBER_OF_POOLS>
+inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t storeId) {
+	uint8_t* tempData = nullptr;
+	StorageAccessor accessor(storeId);
+	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
+	accessor.constDataPointer = tempData;
+	accessor.assignConstPointer();
+	return AccessorPair(status, std::move(accessor));
+}
+
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
+		store_address_t storeId, StorageAccessor& storeAccessor) {
+	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
+			&storeAccessor.size_);
+	storeAccessor.assignConstPointer();
+	return status;
+}
+
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 41325273..87670a82 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,9 +1,9 @@
 #ifndef POOLMANAGER_H_
 #define POOLMANAGER_H_
 
-
 #include <framework/storagemanager/LocalPool.h>
 #include <framework/ipc/MutexHelper.h>
+#include <framework/storagemanager/StorageAccessor.h>
 
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
@@ -11,20 +11,21 @@
  * @details	Uses local pool calls but is thread safe by protecting the call
  * 			with a lock.
  */
-
-template <uint8_t NUMBER_OF_POOLS = 5>
+template <uint8_t NUMBER_OF_POOLS>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
 public:
-	PoolManager( object_id_t setObjectId, const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS] );
-	/**
-	 * @brief	In the PoolManager's destructor all allocated memory is freed.
-	 */
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
 	virtual ~PoolManager();
 
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = NULL) override;
+			store_address_t* storeId = nullptr) override;
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 0408d55b..7025d795 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,3 +1,6 @@
+#ifndef POOLMANAGER_TPP_
+#define POOLMANAGER_TPP_
+
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -40,3 +43,5 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 	return status;
 }
 
+#endif
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 2e1d44bd..da319a97 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -4,8 +4,7 @@
  * @details	These helper can be used together with the
  * 			StorageManager classes to manage access to a storage.
  * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data and unlocking the
- * 			pool.
+ * 			mechanisms to automatically clear storage data.
  */
 #ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
 #define TEST_PROTOTYPES_STORAGEACCESSOR_H_
@@ -14,7 +13,6 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <memory>
 
-
 /**
  * @brief   Accessor class which can be returned by pool managers
  *          or passed and set by pool managers to have safe access to the pool
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d1f9cde5..27448ef7 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -3,7 +3,14 @@
 
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stddef.h>
+#include <cstddef>
+#include <utility>
+
+class StorageAccessor;
+class ConstStorageAccessor;
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
 /**
  * This union defines the type that identifies where a data packet is
@@ -150,6 +157,14 @@ public:
 	 */
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
 			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+			StorageAccessor&) = 0;
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor&) = 0;
+
 	/**
 	 * Clears the whole store.
 	 * Use with care!

From d873fcbf8ece518e1da89500ef8195da4384c1a3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 16:47:47 +0200
Subject: [PATCH 0238/1292] added documentation for storage manager IF

---
 storagemanager/StorageManagerIF.h | 53 +++++++++++++++++++++++++------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 27448ef7..b5508da8 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -124,6 +124,27 @@ public:
 	 */
 	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.
@@ -137,8 +158,30 @@ public:
 	 */
 	virtual ReturnValue_t getData(store_address_t packet_id,
 			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
 	/**
-	 * Same as above, but not const and therefore modifiable.
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
 	 */
 	virtual ReturnValue_t modifyData(store_address_t packet_id,
 			uint8_t** packet_ptr, size_t* size) = 0;
@@ -158,19 +201,11 @@ public:
 	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
 			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-			StorageAccessor&) = 0;
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor&) = 0;
-
 	/**
 	 * Clears the whole store.
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
-
 };
 
 #endif /* STORAGEMANAGERIF_H_ */

From 291710f257745e60e8417b2fa3648dcbfa09ed5d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 17:57:37 +0200
Subject: [PATCH 0239/1292] new ctor and bugfixes

---
 storagemanager/LocalPool.tpp       |  6 +++--
 storagemanager/StorageAccessor.cpp | 13 +++++++++-
 storagemanager/StorageAccessor.h   | 39 +++++++++++++++---------------
 storagemanager/StorageManagerIF.h  |  4 +++
 4 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 31034974..98343ea7 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -148,7 +148,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t storeId) {
 	uint8_t* tempData = nullptr;
-	ConstStorageAccessor constAccessor(storeId);
+	ConstStorageAccessor constAccessor(storeId, this);
 	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
 	constAccessor.constDataPointer = tempData;
 	return ConstAccessorPair(status, std::move(constAccessor));
@@ -159,6 +159,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId
 		ConstStorageAccessor& storeAccessor) {
 	uint8_t* tempData = nullptr;
 	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
+	storeAccessor.assignStore(this);
 	storeAccessor.constDataPointer = tempData;
 	return status;
 }
@@ -176,7 +177,7 @@ template<uint8_t NUMBER_OF_POOLS>
 inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId) {
 	uint8_t* tempData = nullptr;
-	StorageAccessor accessor(storeId);
+	StorageAccessor accessor(storeId, this);
 	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
 	accessor.constDataPointer = tempData;
 	accessor.assignConstPointer();
@@ -188,6 +189,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId, StorageAccessor& storeAccessor) {
 	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
 			&storeAccessor.size_);
+	storeAccessor.assignStore(this);
 	storeAccessor.assignConstPointer();
 	return status;
 }
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 51b93f11..67693054 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -3,6 +3,12 @@
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
 
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
 		sif::debug << "deleting store data" << std::endl;
@@ -27,6 +33,11 @@ StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
 }
 
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
 StorageAccessor& StorageAccessor::operator =(
 		StorageAccessor&& other) {
 	// Call the parent move assignment and also assign own member.
@@ -97,7 +108,7 @@ void ConstStorageAccessor::print() const {
 }
 
 void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::READ;
+	internalState = AccessState::ASSIGNED;
 	this->store = store;
 }
 
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index da319a97..2be80601 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -31,23 +31,7 @@ public:
 	 * @param storeId
 	 */
 	ConstStorageAccessor(store_address_t storeId);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
 
 	/**
 	 * @brief 	The destructor in default configuration takes care of
@@ -86,6 +70,23 @@ public:
 	store_address_t getId() const;
 
 	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;
@@ -96,7 +97,7 @@ protected:
 
 	enum class AccessState {
 		UNINIT,
-		READ
+		ASSIGNED
 	};
 	//! Internal state for safety reasons.
 	AccessState internalState = AccessState::UNINIT;
@@ -109,7 +110,6 @@ protected:
 	 * @param
 	 */
 	void assignStore(StorageManagerIF*);
-
 };
 
 
@@ -124,6 +124,7 @@ class StorageAccessor: public ConstStorageAccessor {
 	friend class LocalPool;
 public:
 	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
 	/**
 	 * @brief	Move ctor and move assignment allow returning accessors as
 	 * 			a returnvalue. They prevent resource being free prematurely.
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index b5508da8..559c4b9a 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -55,6 +55,10 @@ union store_address_t {
 	 * Alternative access to the raw value.
 	 */
 	uint32_t raw;
+
+	bool operator==(const store_address_t& other) const {
+		return raw == other.raw;
+	}
 };
 
 /**

From 3122f62b0a1e81268ad5f7ac8fa249a5458dc906 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 12 May 2020 19:02:59 +0200
Subject: [PATCH 0240/1292] bugfixes for write() call

---
 storagemanager/LocalPool.tpp       |  7 ++-
 storagemanager/StorageAccessor.cpp | 75 ++++++++++++++++++------------
 storagemanager/StorageAccessor.h   |  5 +-
 3 files changed, 50 insertions(+), 37 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 98343ea7..59d06ab8 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -176,10 +176,9 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 template<uint8_t NUMBER_OF_POOLS>
 inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId) {
-	uint8_t* tempData = nullptr;
 	StorageAccessor accessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &tempData, &accessor.size_);
-	accessor.constDataPointer = tempData;
+	ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
+			&accessor.size_);
 	accessor.assignConstPointer();
 	return AccessorPair(status, std::move(accessor));
 }
@@ -187,9 +186,9 @@ inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
 		store_address_t storeId, StorageAccessor& storeAccessor) {
+	storeAccessor.assignStore(this);
 	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
 			&storeAccessor.size_);
-	storeAccessor.assignStore(this);
 	storeAccessor.assignConstPointer();
 	return status;
 }
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 67693054..cc292d6c 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -16,6 +16,14 @@ ConstStorageAccessor::~ConstStorageAccessor() {
 	}
 }
 
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
 ConstStorageAccessor& ConstStorageAccessor::operator=(
 		ConstStorageAccessor&& other) {
 	constDataPointer = other.constDataPointer;
@@ -29,36 +37,6 @@ ConstStorageAccessor& ConstStorageAccessor::operator=(
 	return *this;
 }
 
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
 const uint8_t* ConstStorageAccessor::data() const {
 	return constDataPointer;
 }
@@ -113,6 +91,41 @@ void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
 }
 
 
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
@@ -130,7 +143,7 @@ ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	std::copy(data, data + size, dataPointer);
+	std::copy(data, data + size, dataPointer + offset);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 2be80601..8949642c 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -49,7 +49,7 @@ public:
 	 * @brief	Copies the read-only data to the supplied pointer
 	 * @param pointer
 	 */
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
 
 	/**
 	 * @brief   Calling this will prevent the Accessor from deleting the data
@@ -137,8 +137,9 @@ public:
 	StorageAccessor (StorageAccessor&&);
 
 	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset);
+		uint16_t offset = 0);
 	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
 
 private:
 	//! Non-const pointer for modifyable data.

From 50a1b5170aa472c143c8a1a349e04316fb399225 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 13 May 2020 18:03:09 +0200
Subject: [PATCH 0241/1292] formatting

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 729eac0b..25ec75b9 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -327,7 +327,7 @@ protected:
 	 * @param len length of remaining buffer to be scanned
 	 * @param[out] foundId the id of the data found in the buffer.
 	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * 						buffer is scanned at previous position + foundLen.
+	 * buffer is scanned at previous position + foundLen.
 	 * @return
 	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
 	 *     - @c RETURN_FAILED no reply could be found starting at @c start,

From 49fa2fe32c6bfc4fba6fc91e8cbf564eb7532658 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 May 2020 16:12:01 +0200
Subject: [PATCH 0242/1292] changed void* cast to QueueHandle_t cast

---
 osal/FreeRTOS/MessageQueue.cpp | 4 ++--
 osal/FreeRTOS/MessageQueue.h   | 7 +++++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e7de799c..aa4b93b7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -120,7 +120,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     message->setSender(sentFrom);
     BaseType_t result;
     if(callContext == CallContext::task) {
-        result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),
+        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()), 0);
     }
     else {
@@ -128,7 +128,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         // request a context switch if a higher priority task
         // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-        result = xQueueSendFromISR(reinterpret_cast<void*>(sendTo),
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
                 reinterpret_cast<const void*>(message->getBuffer()),
                 &xHigherPriorityTaskWoken);
         if(xHigherPriorityTaskWoken == pdTRUE) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 27076869..d8a307ea 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,8 +6,11 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-#include <FreeRTOS.h>
-#include "queue.h"
+extern "C" {
+#include "FreeRTOS.h"
+#include "freertos/queue.h"
+}
+
 
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution

From 69237bc2e87fba9d5b3c8dfc91d11e328e2bdfc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 May 2020 21:26:04 +0200
Subject: [PATCH 0243/1292] freertos includes adapted

---
 osal/FreeRTOS/MessageQueue.cpp | 4 ++--
 osal/FreeRTOS/MessageQueue.h   | 4 ++--
 osal/FreeRTOS/Mutex.h          | 6 ++++--
 osal/FreeRTOS/TaskManagement.h | 4 ++--
 4 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index aa4b93b7..aedf4831 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -121,7 +121,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     BaseType_t result;
     if(callContext == CallContext::task) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
-                reinterpret_cast<const void*>(message->getBuffer()), 0);
+                static_cast<const void*>(message->getBuffer()), 0);
     }
     else {
         // If the call context is from an interrupt,
@@ -129,7 +129,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         // was blocked by the interrupt.
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
-                reinterpret_cast<const void*>(message->getBuffer()),
+                static_cast<const void*>(message->getBuffer()),
                 &xHigherPriorityTaskWoken);
         if(xHigherPriorityTaskWoken == pdTRUE) {
             TaskManagement::requestContextSwitch(callContext);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index d8a307ea..ce6ed46b 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -7,8 +7,8 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "freertos/queue.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
 }
 
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 604511b5..ef93fd34 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,9 +3,11 @@
 
 #include <framework/ipc/MutexIF.h>
 
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+}
 
-#include <FreeRTOS.h>
-#include "semphr.h"
 
 /**
  * @brief OS component to implement MUTual EXclusion
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index da0cce2a..eaaf97e2 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -4,8 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 #include <cstdint>
 

From 684da2b8d5400ad68a59a59579bbb9244a1be5c3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 15:30:29 +0200
Subject: [PATCH 0244/1292] set application data function added

---
 tmtcpacket/SpacePacketBase.cpp  |  3 ++-
 tmtcpacket/pus/TcPacketBase.cpp | 13 ++++++++++---
 tmtcpacket/pus/TcPacketBase.h   |  9 ++++++++-
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 13c062d8..a06c3a33 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -14,7 +14,8 @@ uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
 	return (this->data->header.packet_id_h & 0b11100000) >> 5;
 }
 
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
 	//reset header to zero:
 	memset(data,0, sizeof(this->data->header) );
 	//Set TC/TM bit.
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index d7f6636d..cdeef7f8 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -46,9 +46,16 @@ void TcPacketBase::setErrorControl() {
 	(&tcData->data)[size + 1] = (crc) & 0X00FF; 		// CRCL
 }
 
-void TcPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tcData = (TcPacketPointer*) p_Data;
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setApplicationData(const uint8_t * pData, size_t dataLen) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+	SpacePacketBase::setPacketDataLength(dataLen +
+			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index d84d6c45..a7e823fc 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -2,6 +2,7 @@
 #define TCPACKETBASE_H_
 
 #include <framework/tmtcpacket/SpacePacketBase.h>
+#include <cstddef>
 
 /**
  * This struct defines a byte-wise structured PUS TC Data Field Header.
@@ -175,7 +176,13 @@ public:
 	 *
 	 * @param p_data	A pointer to another PUS Telecommand Packet.
 	 */
-	void setData( const uint8_t* p_data );
+	void setData( const uint8_t* pData );
+	/**
+	 * Set application data and corresponding length field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setApplicationData(const uint8_t * pData, size_t dataLen);
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.

From 237dd4a256598ed805442a71bef58a4ddc9aabb4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:23:57 +0200
Subject: [PATCH 0245/1292] added additonal functions for tc packet base

---
 tmtcpacket/pus/TcPacketBase.cpp | 5 +++++
 tmtcpacket/pus/TcPacketBase.h   | 9 ++++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index cdeef7f8..54ad92be 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -87,3 +87,8 @@ void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 	tcData->data_field.service_type = service;
 	tcData->data_field.service_subtype = subservice;
 }
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index a7e823fc..69c64b87 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -100,7 +100,8 @@ public:
 	 * @param service	PUS Service
 	 * @param subservice PUS Subservice
 	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack, uint8_t service, uint8_t subservice);
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
 	/**
 	 * This command returns the CCSDS Secondary Header Flag.
 	 * It shall always be zero for PUS Packets. This is the
@@ -188,6 +189,12 @@ public:
 	 * to the screen.
 	 */
 	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
 };
 
 

From 6e1bb16d4e22f5e4b0b3d9010a5662ffe7f1b16e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:46:58 +0200
Subject: [PATCH 0246/1292] printers continued,

possible  bugfix in tc packet base
---
 globalfunctions/printer.cpp     | 25 +++++++++++++++++++++++--
 globalfunctions/printer.h       | 12 +++++++++---
 tmtcpacket/pus/TcPacketBase.cpp |  2 +-
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index d6ede0a5..d7af30a5 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,13 +1,34 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size) {
+void printer::print(uint8_t *data, size_t size, OutputType type) {
 	sif::info << "StorageAccessor: Printing data: [";
+	if(type == OutputType::HEX) {
+		printer::printHex(data, size);
+	}
+	else {
+		printer::printDec(data, size);
+	}
+}
+
+void printer::printHex(uint8_t *data, size_t size) {
+	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
-		sif::info << std::hex << (int)data[i];
+		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 		}
 	}
+	sif::info << std::dec;
 	sif::info << " ] " << std::endl;
 }
+
+void printer::printDec(uint8_t *data, size_t size) {
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+		}
+	}
+}
+
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index d4a573e9..3c9d6aa0 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -4,9 +4,15 @@
 #include <cstddef>
 
 namespace printer {
-void print(uint8_t *data, size_t size);
+
+enum class OutputType {
+	DEC,
+	HEX
+};
+
+void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX);
+void printHex(uint8_t* data, size_t size);
+void printDec(uint8_t* data, size_t size);
 }
 
-
-
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 54ad92be..b98cf136 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -79,7 +79,7 @@ void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 		uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
 	memset(&tcData->data_field, 0, sizeof(tcData->data_field));
-	setPacketDataLength(sizeof(tcData->data_field) + CRC_SIZE);
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
 	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
 	tcData->data_field.version_type_ack = 0b00010000;

From 80cee2742964485910faa168cb9a1c96e2c0dec3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:53:54 +0200
Subject: [PATCH 0247/1292] printer fixes

---
 globalfunctions/printer.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index df98568e..5af4346b 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -20,15 +20,17 @@ void printer::printHex(uint8_t *data, size_t size) {
 		}
 	}
 	sif::info << std::dec;
-	sif::info << " ] " << std::endl;
+	sif::info << "]" << std::endl;
 }
 
 void printer::printDec(uint8_t *data, size_t size) {
+	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 		}
 	}
+	sif::info << "]" << std::endl;
 }
 

From 24bfbfbd33e93d35dabd716d72d67eefc9512b11 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 18:56:06 +0200
Subject: [PATCH 0248/1292] removed StorageAccessoremoved StorageAccessorr

---
 globalfunctions/printer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index 5af4346b..bf4c5848 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -2,7 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 void printer::print(uint8_t *data, size_t size, OutputType type) {
-	sif::info << "StorageAccessor: Printing data with size " << size << ": [";
+	sif::info << "Printing data with size " << size << ": [";
 	if(type == OutputType::HEX) {
 		printer::printHex(data, size);
 	}

From 3f71babfa995965ef39299f5285ad5990efe6921 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:50:51 +0200
Subject: [PATCH 0249/1292] app data len uint16_t, full length size_t

---
 tmtcpacket/SpacePacketBase.cpp  | 2 +-
 tmtcpacket/SpacePacketBase.h    | 5 +++--
 tmtcpacket/pus/TcPacketBase.cpp | 2 +-
 tmtcpacket/pus/TcPacketBase.h   | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index a06c3a33..b9ae0684 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -82,7 +82,7 @@ void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
 	this->data->header.packet_length_l = ( new_length & 0x00FF );
 }
 
-uint32_t SpacePacketBase::getFullSize() {
+size_t SpacePacketBase::getFullSize() {
 	//+1 is done because size in packet data length field is: size of data field -1
 	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
 }
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index cc68f714..57a5df9c 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -2,9 +2,10 @@
 #define SPACEPACKETBASE_H_
 
 #include <framework/tmtcpacket/ccsds_header.h>
+#include <cstddef>
 
 /**
- * \defgroup tmtcpackets Space Packets
+ * @defgroup tmtcpackets Space Packets
  * This is the group, where all classes associated with Telecommand and
  * Telemetry packets belong to.
  * The class hierarchy resembles the dependency between the different standards
@@ -167,7 +168,7 @@ public:
 	 * This method returns the full raw packet size.
 	 * @return	The full size of the packet in bytes.
 	 */
-	uint32_t getFullSize();
+	size_t getFullSize();
 
 	uint32_t getApidAndSequenceCount() const;
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index b98cf136..4ef50c0d 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -51,7 +51,7 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setApplicationData(const uint8_t * pData, size_t dataLen) {
+void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 	SpacePacketBase::setData(pData);
 	tcData = (TcPacketPointer*) pData;
 	SpacePacketBase::setPacketDataLength(dataLen +
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 69c64b87..c8342896 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -183,7 +183,7 @@ public:
 	 * @param pData
 	 * @param dataLen
 	 */
-	void setApplicationData(const uint8_t * pData, size_t dataLen);
+	void setApplicationData(const uint8_t * pData, uint16_t dataLen);
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.

From c77ec9e7fcbe038a4622b3faf3cf311d6d3cc901 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:56:54 +0200
Subject: [PATCH 0250/1292] uint16_t correction

---
 tmtcpacket/pus/TcPacketBase.cpp | 2 +-
 tmtcpacket/pus/TcPacketBase.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 4ef50c0d..f8dba79f 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -28,7 +28,7 @@ const uint8_t* TcPacketBase::getApplicationData() const {
 	return &tcData->data;
 }
 
-size_t TcPacketBase::getApplicationDataSize() {
+uint16_t TcPacketBase::getApplicationDataSize() {
 	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index c8342896..136aaa0b 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -153,7 +153,7 @@ public:
 	 * @return	The size of the PUS Application Data (without Error Control
 	 * 		field)
 	 */
-	size_t getApplicationDataSize();
+	uint16_t getApplicationDataSize();
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *

From 5b41f2a6bd4e91956874fff43774865d9887dab5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 19:58:58 +0200
Subject: [PATCH 0251/1292] optimization

---
 tmtcpacket/pus/TcPacketBase.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index f8dba79f..3e2b34c2 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -52,8 +52,7 @@ void TcPacketBase::setData(const uint8_t* pData) {
 }
 
 void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
+	setData(pData);
 	SpacePacketBase::setPacketDataLength(dataLen +
 			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
 }

From 0e2438416d0af245d086175868a5496c679b94ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 20:00:43 +0200
Subject: [PATCH 0252/1292] added comment

---
 tmtcpacket/pus/TcPacketBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 3e2b34c2..0972ffff 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -53,8 +53,9 @@ void TcPacketBase::setData(const uint8_t* pData) {
 
 void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 	setData(pData);
+	// packet data length is actual size of data field minus 1
 	SpacePacketBase::setPacketDataLength(dataLen +
-			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE-1);
+			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {

From ebcc4742a92c6aa2152aa7cc8953a587f05fec5b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 21:14:21 +0200
Subject: [PATCH 0253/1292] removed conflict markers

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 932bbe8a..18ec1092 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -57,10 +57,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-<<<<<<< HEAD
-=======
-
->>>>>>> mueller_framework
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
 		if(slotTimeMs == 0) {
 			// FreeRTOS throws a sanity error for zero values, so we set

From 20900227f8bc119befa7dcc2bd5ca3fea3d74e1b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 15 May 2020 22:53:01 +0200
Subject: [PATCH 0254/1292] periodic posix task ctor format

---
 osal/linux/PeriodicPosixTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index b754c3f4..28a0b946 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -3,9 +3,10 @@
 #include <errno.h>
 #include <framework/osal/linux/PeriodicPosixTask.h>
 
-PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):PosixThread(name_,priority_,stackSize_),objectList(),started(false),periodMs(period_),deadlineMissedFunc(
-		deadlineMissedFunc_) {
-
+PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
+		PosixThread(name_,priority_,stackSize_),objectList(),started(false),
+		periodMs(period_),deadlineMissedFunc(deadlineMissedFunc_) {
 }
 
 PeriodicPosixTask::~PeriodicPosixTask() {

From 7d579889792144e9cf45fdcc332bb3636c69f488 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 16 May 2020 13:09:50 +0200
Subject: [PATCH 0255/1292] added deadline check

---
 osal/FreeRTOS/PeriodicTask.cpp | 18 +++++++++++++++---
 osal/FreeRTOS/PeriodicTask.h   |  6 ++++--
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 3075be79..a8e40561 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,6 +1,7 @@
+#include "PeriodicTask.h"
+
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include "PeriodicTask.h"
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
@@ -31,7 +32,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
 	// if it is set, the scheduler was not running before #startTask() was called and we can continue
 
-	if (!originalTask->started) {
+	if (not originalTask->started) {
 		vTaskSuspend(NULL);
 	}
 
@@ -70,8 +71,19 @@ void PeriodicTask::taskFunctionality() {
 				it != objectList.end(); ++it) {
 			(*it)->performOperation();
 		}
-		//TODO deadline missed check
+
+		/* If all operations are finished and the difference of the
+		 * current time minus the last wake time is larger than the
+		 * wait period, a deadline was missed. */
+		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
+			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
 	}
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 02ab7148..4ece20b3 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -5,8 +5,10 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
-#include "task.h"
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
 
 #include <vector>
 

From b673e13892cf7aac425569709a140dc4b589ec70 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 16 May 2020 20:58:48 +0200
Subject: [PATCH 0256/1292] some refactoring

---
 ipc/MessageQueueIF.h           |  24 ++++---
 ipc/MessageQueueMessage.cpp    |  28 ++++----
 ipc/MessageQueueMessage.h      | 126 +++++++++++++++++++--------------
 ipc/QueueFactory.h             |   6 +-
 osal/FreeRTOS/MessageQueue.cpp |  10 +--
 osal/FreeRTOS/QueueFactory.cpp |  16 +++--
 osal/linux/MessageQueue.cpp    |  12 ++--
 osal/linux/MessageQueue.h      |  32 +++++----
 osal/linux/QueueFactory.cpp    |  16 +++--
 9 files changed, 156 insertions(+), 114 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 47da694c..c67f3870 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -36,8 +36,8 @@ public:
 	 * 			lastParnter information as destination. If there was no message received yet
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
-	 * \return RETURN_OK if ok
-	 * \return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 * @return RETURN_OK if ok
+	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
 	 */
 	virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0;
 
@@ -53,10 +53,12 @@ public:
 
 	/**
 	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in theblastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
@@ -90,7 +92,9 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	This operation sends a message to the given destination.
@@ -100,7 +104,8 @@ public:
 	 * @param message	A pointer to a previously created message, which is sent.
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessage* message, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
@@ -111,7 +116,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 30e0325c..544d18e8 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -8,6 +8,20 @@ MessageQueueMessage::MessageQueueMessage() :
 	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 }
 
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
 MessageQueueMessage::~MessageQueueMessage() {
 }
 
@@ -37,23 +51,13 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, uint32_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-	} else {
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
 size_t MessageQueueMessage::getMinimumMessageSize() {
 	return this->HEADER_SIZE;
 }
 
 void MessageQueueMessage::print() {
-	sif::debug << "MessageQueueMessage has size: " << this->messageSize << std::hex
-			<< std::endl;
+	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
+			std::hex << std::endl;
 	for (uint8_t count = 0; count < this->messageSize; count++) {
 		sif::debug << (uint32_t) this->internalBuffer[count] << ":";
 	}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 8c4ec947..4d82bd88 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -5,111 +5,129 @@
 #include <stddef.h>
 
 /**
- *	\brief		This class is the representation and data organizer for interprocess messages.
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
  *
- *	\details	To facilitate and standardize interprocess communication, this class was created
- *				to handle a lightweight "interprocess message protocol". It adds a header with the
- *				sender's queue id to every sent message and defines the maximum total message size.
- *				Specialized messages, such as device commanding messages, can be created by inheriting
- *				from this class and filling the buffer provided by getData with additional content.
- *				If larger amounts of data must be sent between processes, the data shall be stored in
- *				the IPC Store object and only the storage id is passed in a queue message.
- *				The class is used both to generate and send messages and to receive messages from
- *				other tasks.
- *	\ingroup message_queue
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
  */
 class MessageQueueMessage {
 public:
 	/**
-	 * \brief	This constant defines the maximum size of the data content, excluding the header.
-	 * \details	It may be changed if necessary, but in general should be kept as small as possible.
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details	The messageSize attribute is set to the header's size and the
+	 * 			whole content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+	/**
+	 * @brief	The size information of each message is stored in this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content, excluding the header.
+	 * @details	It may be changed if necessary, but in general should be kept as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
 	/**
-	 * \brief	This constants defines the size of the header, which is added to every message.
+	 * @brief	This constants defines the size of the header, which is added to every message.
 	 */
 	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 	/**
-	 * \brief	This constant defines the maximum total size in bytes of a sent message.
-	 * \details	It is the sum of the maximum data and the header size. Be aware that this constant
+	 * @brief	This constant defines the maximum total size in bytes of a sent message.
+	 * @details	It is the sum of the maximum data and the header size. Be aware that this constant
 	 * 			is used to define the buffer sizes for every message queue in the system. So, a change
 	 * 			here may have significant impact on the required resources.
 	 */
 	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
-	 * \brief	This is the internal buffer that contains the actual message data.
+	 * @brief	This is the internal buffer that contains the actual message data.
 	 */
 	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
 public:
 	/**
-	 * \brief	The size information of each message is stored in this attribute.
-	 * \details	It is public to simplify usage and to allow for passing the variable's address as a
-	 * 			pointer. Care must be taken when inheriting from this class, as every child class is
-	 * 			responsible for managing the size information by itself. When using the class to
-	 * 			receive a message, the size information is updated automatically.
-	 */
-	size_t messageSize;
-	/**
-	 * \brief	The class is initialized empty with this constructor.
-	 * \details	The messageSize attribute is set to the header's size and the whole content is set to
-	 * 			zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * \brief	With this constructor the class is initialized with the given content.
-	 * \details	If the passed message size fits into the buffer, the passed data is copied to the
-	 * 			internal buffer and the messageSize information is set. Otherwise, messageSize
-	 * 			is set to the header's size and the whole content is set to zero.
-	 * \param data	The data to be put in the message.
-	 * \param size	Size of the data to be copied. Must be smaller than MAX_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, uint32_t size);
-	/**
-	 * \brief	As no memory is allocated in this class, the destructor is empty.
+	 * @brief	As no memory is allocated in this class, the destructor is empty.
 	 */
 	virtual ~MessageQueueMessage();
 	/**
-	 * \brief	This method is used to get the complete data of the message.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
 	const uint8_t* getBuffer() const;
 	/**
-	 * \brief	This method is used to get the complete data of the message.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
 	uint8_t* getBuffer();
 	/**
-	 * \brief	This method is used to fetch the data content of the message.
-	 * \details It shall be used by child classes to add data at the right position.
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details It shall be used by child classes to add data at the right position.
 	 */
 	const uint8_t* getData() const;
 	/**
-	 * \brief	This method is used to fetch the data content of the message.
-	 * \details It shall be used by child classes to add data at the right position.
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details It shall be used by child classes to add data at the right position.
 	 */
 	uint8_t* getData();
 	/**
-	 * \brief	This method is used to extract the sender's message queue id information from a
+	 * @brief	This method is used to extract the sender's message queue id information from a
 	 * 			received message.
 	 */
 	MessageQueueId_t getSender() const;
 	/**
-	 * \brief	With this method, the whole content and the message size is set to zero.
+	 * @brief	With this method, the whole content and the message size is set to zero.
 	 */
 	void clear();
 	/**
-	 * \brief	This is a debug method that prints the content (till messageSize) to the debug output.
+	 * @brief	This is a debug method that prints the content (till messageSize) to the debug output.
 	 */
 	void print();
 	/**
-	 * \brief	This method is used to set the sender's message queue id information prior to
+	 * @brief	This method is used to set the sender's message queue id information prior to
 	 * 			sending the message.
-	 * \param setId	The message queue id that identifies the sending message queue.
+	 * @param setId	The message queue id that identifies the sending message queue.
 	 */
 	void setSender(MessageQueueId_t setId);
 	/**
-	 * \brief	This helper function is used by the MessageQueue class to check the size of an
+	 * @brief	This helper function is used by the MessageQueue class to check the size of an
 	 * 			incoming message.
-	 * \details	The method must be overwritten by child classes if size checks shall be more strict.
+	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
 	virtual size_t getMinimumMessageSize();
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index c385b15d..9a883fd8 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
 #include <framework/ipc/MessageQueueIF.h>
-#include <stdint.h>
+#include <cstdint>
 /**
  * Creates message queues.
  * This class is a "singleton" interface, i.e. it provides an
@@ -18,8 +18,8 @@ public:
 	 */
 	static QueueFactory* instance();
 
-	MessageQueueIF* createMessageQueue(uint32_t message_depth = 3,
-			uint32_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE);
+	MessageQueueIF* createMessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
 private:
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index aedf4831..38f425a4 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -2,12 +2,14 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-// TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-// As a first step towards this, introduces system context variable which needs to be switched manually
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
 defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
-	handle = xQueueCreate(message_depth, max_message_size);
+	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue creation failed" << std::endl;
 	}
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index eaf245d3..a4ee5cf3 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -3,16 +3,18 @@
 #include <framework/osal/FreeRTOS/MessageQueue.h>
 
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
@@ -24,9 +26,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
-	return new MessageQueue(message_depth, max_message_size);
+MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index edabe946..96d9fb4d 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,15 +7,15 @@
 #include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
 		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
 	//Set attributes
 	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = message_depth;
-	attributes.mq_msgsize = max_message_size;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
 	//Set the name of the queue
 	sprintf(name, "/Q%u\n", queueCounter++);
@@ -265,7 +265,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/
 		case EMSGSIZE:
-			//The msg_len is greater than the msgsize associated with the specified queue.
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index b8285dc5..fdc8dab1 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -5,20 +5,23 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
 /**
- *	@brief		This class manages sending and receiving of message queue messages.
+ * @brief		This class manages sending and receiving of message queue messages.
  *
- *	@details	Message queues are used to pass asynchronous messages between processes.
- *				They work like post boxes, where all incoming messages are stored in FIFO
- *				order. This class creates a new receiving queue and provides methods to fetch
- *				received messages. Being a child of MessageQueueSender, this class also provides
- *				methods to send a message to a user-defined or a default destination. In addition
- *				it also provides a reply method to answer to the queue it received its last message
- *				from.
- *				The MessageQueue should be used as "post box" for a single owning object. So all
- *				message queue communication is "n-to-one".
- *				For creating the queue, as well as sending and receiving messages, the class makes
- *				use of the operating system calls provided.
- *	\ingroup message_queue
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
@@ -35,7 +38,8 @@ public:
 	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
 	 * 							This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
 	 * @details	This is accomplished by using the delete call provided by the operating system.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index fc4c9026..2bacb815 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -5,16 +5,18 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstring>
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
@@ -26,9 +28,9 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t message_depth,
-		uint32_t max_message_size) {
-	return new MessageQueue(message_depth, max_message_size);
+MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
 }
 
 void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {

From cbfa21d45a51bbe97d6d35a6b54ab8f409a8f2d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 01:17:11 +0200
Subject: [PATCH 0257/1292] merging renaming into main branch

---
 datapool/ControllerSet.h                      |   4 +-
 datapool/DataPool.cpp                         | 132 ------
 datapool/DataPool.h                           | 136 ------
 datapool/DataSet.cpp                          | 150 ------
 datapool/DataSet.h                            | 168 -------
 datapool/DataSetIF.h                          |  39 +-
 datapool/HkSwitchHelper.cpp                   |   1 -
 datapool/PIDReader.h                          |   8 +-
 datapool/PoolEntry.cpp                        |   1 -
 datapool/PoolEntry.h                          |  46 +-
 datapool/PoolEntryIF.h                        |  61 ++-
 datapool/PoolRawAccess.cpp                    | 126 ++---
 datapool/PoolRawAccess.h                      | 172 +++----
 datapool/PoolRawAccessHelper.cpp              |   6 +-
 datapool/PoolRawAccessHelper.h                |   2 +-
 datapool/PoolVarList.h                        |   6 +-
 datapool/PoolVariableIF.h                     |  63 ++-
 {datapool => datapoolglob}/DataPoolAdmin.cpp  |  18 +-
 {datapool => datapoolglob}/DataPoolAdmin.h    |  15 +-
 .../DataPoolParameterWrapper.cpp              |  14 +-
 .../DataPoolParameterWrapper.h                |   0
 datapoolglob/GlobalDataPool.cpp               | 132 ++++++
 datapoolglob/GlobalDataPool.h                 | 146 ++++++
 datapoolglob/GlobalDataSet.cpp                | 166 +++++++
 datapoolglob/GlobalDataSet.h                  | 185 ++++++++
 datapoolglob/GlobalPoolVariable.h             | 189 ++++++++
 datapoolglob/GlobalPoolVariable.tpp           |  84 ++++
 datapoolglob/GlobalPoolVector.h               | 223 +++++++++
 datapoollocal/LocalDataSet.cpp                |  66 +++
 datapoollocal/LocalDataSet.h                  | 187 ++++++++
 datapoollocal/LocalPoolVariable.h             | 103 ++++
 datapoollocal/LocalPoolVariable.tpp           | 109 +++++
 devicehandlers/DeviceHandlerBase.cpp          | 189 ++++----
 devicehandlers/DeviceHandlerBase.h            | 439 +++++++++---------
 housekeeping/HasHkPoolParametersIF.h          |  32 ++
 housekeeping/HousekeepingManager.cpp          |  50 ++
 housekeeping/HousekeepingManager.h            |  95 ++++
 housekeeping/HousekeepingMessage.cpp          |  10 +
 housekeeping/HousekeepingMessage.h            |  87 ++++
 internalError/InternalErrorReporter.cpp       |  10 +-
 monitoring/MonitorBase.h                      |   4 +-
 power/Fuse.cpp                                |   2 +-
 power/Fuse.h                                  |   6 +-
 power/PowerSensor.h                           |   6 +-
 thermal/CoreComponent.cpp                     |  12 +-
 thermal/CoreComponent.h                       |  12 +-
 thermal/ThermalModule.h                       |   6 +-
 47 files changed, 2465 insertions(+), 1253 deletions(-)
 delete mode 100644 datapool/DataPool.cpp
 delete mode 100644 datapool/DataPool.h
 delete mode 100644 datapool/DataSet.cpp
 delete mode 100644 datapool/DataSet.h
 rename {datapool => datapoolglob}/DataPoolAdmin.cpp (96%)
 rename {datapool => datapoolglob}/DataPoolAdmin.h (90%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.cpp (96%)
 rename {datapool => datapoolglob}/DataPoolParameterWrapper.h (100%)
 create mode 100644 datapoolglob/GlobalDataPool.cpp
 create mode 100644 datapoolglob/GlobalDataPool.h
 create mode 100644 datapoolglob/GlobalDataSet.cpp
 create mode 100644 datapoolglob/GlobalDataSet.h
 create mode 100644 datapoolglob/GlobalPoolVariable.h
 create mode 100644 datapoolglob/GlobalPoolVariable.tpp
 create mode 100644 datapoolglob/GlobalPoolVector.h
 create mode 100644 datapoollocal/LocalDataSet.cpp
 create mode 100644 datapoollocal/LocalDataSet.h
 create mode 100644 datapoollocal/LocalPoolVariable.h
 create mode 100644 datapoollocal/LocalPoolVariable.tpp
 create mode 100644 housekeeping/HasHkPoolParametersIF.h
 create mode 100644 housekeeping/HousekeepingManager.cpp
 create mode 100644 housekeeping/HousekeepingManager.h
 create mode 100644 housekeeping/HousekeepingMessage.cpp
 create mode 100644 housekeeping/HousekeepingMessage.h

diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index de06bf91..7625c3d1 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,9 +1,9 @@
 #ifndef CONTROLLERSET_H_
 #define CONTROLLERSET_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
-class ControllerSet :public DataSet {
+class ControllerSet :public GlobDataSet {
 public:
 	ControllerSet();
 	virtual ~ControllerSet();
diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
deleted file mode 100644
index c6a1a74e..00000000
--- a/datapool/DataPool.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#include <framework/datapool/DataPool.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/MutexFactory.h>
-
-DataPool::DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) ) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->data_pool );
-	}
-}
-
-DataPool::~DataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for ( std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.begin(); it != this->data_pool.end(); ++it ) {
-		delete it->second;
-	}
-}
-
-//The function checks PID, type and array length before returning a copy of the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* DataPool::getData( uint32_t data_pool_id,  uint8_t sizeOrPosition ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != NULL ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return NULL;
-}
-
-PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-	if ( it != this->data_pool.end() ) {
-		return it->second;
-	} else {
-		return NULL;
-	}
-}
-
-//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) {
-//	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
-//	if ( it != this->data_pool.end() ) {
-//		if ( it->second->getByteSize() <= max_size ) {
-//			*size = it->second->getByteSize();
-//			memcpy( address, it->second->getRawData(), *size );
-//			return DP_SUCCESSFUL;
-//		}
-//	}
-//	*size = 0;
-//	return DP_FAILURE;
-//}
-
-ReturnValue_t DataPool::freeDataPoolLock() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t DataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if ( status != RETURN_OK ) {
-		sif::error << "DataPool::DataPool: lock of mutex failed with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void DataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->data_pool.begin();
-	while( dataPoolIt != this->data_pool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-template PoolEntry<bool>* DataPool::getData<bool>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint8_t>* DataPool::getData<uint8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint16_t>* DataPool::getData<uint16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint32_t>* DataPool::getData<uint32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<uint64_t>* DataPool::getData<uint64_t>(uint32_t data_pool_id,
-		uint8_t size);
-template PoolEntry<int8_t>* DataPool::getData<int8_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int16_t>* DataPool::getData<int16_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<int32_t>* DataPool::getData<int32_t>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<float>* DataPool::getData<float>( uint32_t data_pool_id,  uint8_t size );
-template PoolEntry<double>* DataPool::getData<double>(uint32_t data_pool_id,
-		uint8_t size);
-
-
-uint32_t DataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t DataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t DataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so, as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t DataPool::getType(uint32_t parameter_id, Type* type) {
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->data_pool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool DataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( poolId );
-	if (it != data_pool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
diff --git a/datapool/DataPool.h b/datapool/DataPool.h
deleted file mode 100644
index 857bc3b2..00000000
--- a/datapool/DataPool.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- *	\file	DataPool.h
- *
- *  \date	10/17/2012
- *	\author	Bastian Baetz
- *
- *	\brief	This file contains the definition of the DataPool class and (temporarily)
- *			the "extern" definition of the global dataPool instance.
- */
-
-#ifndef DATAPOOL_H_
-#define DATAPOOL_H_
-
-#include <framework/datapool/PoolEntry.h>
-#include <framework/globalfunctions/Type.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-/**
- * \defgroup data_pool Data Pool
- * This is the group, where all classes associated with Data Pool Handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-#define DP_SUCCESSFUL	0
-#define DP_FAILURE		1
-
-/**
- *	\brief		This class represents the OBSW global data-pool.
- *
- *	\details	All variables are registered and space is allocated in an initialization
- *				function, which is passed to the constructor.
- *				Space for the variables is allocated on the heap (with a new call).
- *				The data is found by a data pool id, which uniquely represents a variable.
- *				Data pool variables should be used with a blackboard logic in mind,
- *				which means read data is valid (if flagged so), but not necessarily up-to-date.
- *				Variables are either single values or arrays.
- *	\ingroup data_pool
- */
-class DataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * \brief	This is the actual data pool itself.
-	 * \details	It is represented by a map
-	 * 			with the data pool id as index and a pointer to a single
-	 * 			PoolEntry as value.
-	 */
-	std::map<uint32_t, PoolEntryIF*> data_pool;
-public:
-	/**
-	 * \brief	The mutex is created in the constructor and makes access mutual exclusive.
-	 * \details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-	/**
-	 * \brief	In the classes constructor, the passed initialization function is called.
-	 * \details	To enable filling the pool,
-	 * 			a pointer to the map is passed, allowing direct access to the pool's content.
-	 * 			On runtime, adding or removing variables is forbidden.
-	 */
-	DataPool( void ( *initFunction )( std::map<uint32_t, PoolEntryIF*>* pool_map ) );
-	/**
-	 * 	\brief	The destructor iterates through the data_pool map and calls all Entries destructors to clean up the heap.
-	 */
-	~DataPool();
-	/**
-	 * \brief	This is the default call to access the pool.
-	 * \details	A pointer to the PoolEntry object is returned.
-	 *  		The call checks data pool id, type and array size. Returns NULL in case of failure.
-	 * \param data_pool_id	The data pool id to search.
-	 * \param sizeOrPosition The array size (not byte size!) of the pool entry, or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id, uint8_t sizeOrPosition );
-	/**
-	 * \brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * \details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * \param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t freeDataPoolLock();
-	/**
-	 * \brief	The print call is a simple debug method.
-	 * \details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists.
-	 * Does not lock, as there's no possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-extern DataPool dataPool;
-#endif /* DATAPOOL_H_ */
diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp
deleted file mode 100644
index 30362118..00000000
--- a/datapool/DataSet.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataSet::DataSet() :
-		fill_count(0), state(DATA_SET_UNINITIALISED) {
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = NULL;
-	}
-}
-
-DataSet::~DataSet() {
-	//Don't do anything with your variables, they are dead already! (Destructor is already called)
-}
-
-ReturnValue_t DataSet::read() {
-	ReturnValue_t result = RETURN_OK;
-	if (state == DATA_SET_UNINITIALISED) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status != RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
-			}
-		}
-		state = DATA_SET_WAS_READ;
-		freeDataPoolLock();
-	} else {
-		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
-
-ReturnValue_t DataSet::commit(uint8_t valid) {
-	setValid(valid);
-	return commit();
-}
-
-ReturnValue_t DataSet::commit() {
-	if (state == DATA_SET_WAS_READ) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_READ
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			}
-		}
-		state = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return RETURN_OK;
-	} else {
-		ReturnValue_t result = RETURN_OK;
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					== PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				registeredVariables[count]->commit();
-			} 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 = DATA_SET_UNINITIALISED;
-		freeDataPoolLock();
-		return result;
-	}
-
-}
-
-void DataSet::registerVariable(PoolVariableIF* variable) {
-	if (state == DATA_SET_UNINITIALISED) {
-		if (variable != NULL) {
-			if (fill_count < DATA_SET_MAX_SIZE) {
-				registeredVariables[fill_count] = variable;
-				fill_count++;
-				return;
-			}
-		}
-	}
-	sif::error
-			<< "DataSet::registerVariable: failed. Either NULL, or set is full, or call made in wrong position."
-			<< std::endl;
-	return;
-}
-
-uint8_t DataSet::freeDataPoolLock() {
-	return ::dataPool.freeDataPoolLock();
-}
-
-uint8_t DataSet::lockDataPool() {
-	return ::dataPool.lockDataPool();
-}
-
-ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t DataSet::getSerializedSize() const {
-	size_t size = 0;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
-void DataSet::setValid(uint8_t valid) {
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
diff --git a/datapool/DataSet.h b/datapool/DataSet.h
deleted file mode 100644
index 1e34e07c..00000000
--- a/datapool/DataSet.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * \file	DataSet.h
- *
- * \brief	This file contains the DataSet class and a small structure called DataSetContent.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- *
- */
-
-#ifndef DATASET_H_
-#define DATASET_H_
-
-#include <framework/datapool/DataPool.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVarList.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/serialize/SerializeAdapter.h>
-/**
- * \brief	The DataSet 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.
- *
- *	\ingroup data_pool
- */
-class DataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
-
-public:
-	//SHOULDDO we could use a linked list of datapool variables
-	static const uint8_t DATA_SET_MAX_SIZE = 63; //!< This definition sets the maximum number of variables to register in one DataSet.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DATA_SET_CLASS;
-	static const ReturnValue_t INVALID_PARAMETER_DEFINITION =
-			MAKE_RETURN_CODE( 0x01 );
-	static const ReturnValue_t SET_WAS_ALREADY_READ = MAKE_RETURN_CODE( 0x02 );
-	static const ReturnValue_t COMMITING_WITHOUT_READING =
-			MAKE_RETURN_CODE(0x03);
-
-	/**
-	 * \brief	The constructor simply sets the fill_count to zero and sets the state to "uninitialized".
-	 */
-	DataSet();
-	/**
-	 * \brief	The destructor automatically manages writing the valid information of variables.
-	 * \details	In case the data set was read out, but not committed (indicated by state),
-	 * 			the destructor parses all variables that are still registered to the set.
-	 * 			For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~DataSet();
-	/**
-	 * \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
-	 */
-	ReturnValue_t read();
-	/**
-	 * \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
-	 */
-	ReturnValue_t commit(void);
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * \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
-	 */
-	ReturnValue_t commit(uint8_t valid);
-	/**
-	 * \brief	This operation is used to register the local variables in the set.
-	 * \details	It copies all required information to the currently
-	 * 			free space in the registeredVariables list.
-	 */
-	void registerVariable(PoolVariableIF* variable);
-
-	/**
-	 * Set the valid information of all variables contained in the set which are not readonly
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setValid(uint8_t valid);
-
-	/**
-	 * Serialize all registered pool variables into the provided buffer
-	 * @param buffer
-	 * @param size Is incremented by serialized size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
-	virtual size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-
-private:
-	/**
-	 * \brief	This array represents all pool variables registered in this set.
-	 * \details	It has a maximum size of DATA_SET_MAX_SIZE.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \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 fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum 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;
-	/**
-	 * \brief	This is a small helper function to facilitate locking the global data pool.
-	 * \details	It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	uint8_t lockDataPool();
-	/**
-	 * \brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * \details	It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	uint8_t freeDataPoolLock();
-
-};
-
-#endif /* DATASET_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 7741477d..4e351416 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,39 +1,36 @@
-/**
- * \file	DataSetIF.h
- *
- * \brief	This file contains the small interface to access the DataSet class.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- *
- */
-
 #ifndef DATASETIF_H_
 #define DATASETIF_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 class PoolVariableIF;
 
 /**
- * \brief	This class defines a small interface to register on a DataSet.
+ * @brief	This class defines a small interface to register on a DataSet.
  *
- * \details	Currently, the only purpose of this interface is to provide a method for locally
- * 			checked-out variables to register on a data set. Still, it may become useful for
- * 			other purposes as well.
- *
- *	\ingroup data_pool
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class DataSetIF {
 public:
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
 	virtual ~DataSetIF() {}
+
 	/**
-	 * \brief	This operation provides a method to register local data pool variables
-	 * 			to register in a data set by passing itself to this DataSet operation.
+	 * @brief	This operation provides a method to register local data pool
+	 * 			variables to register in a data set by passing itself
+	 * 			to this DataSet operation.
 	 */
-	virtual void registerVariable( PoolVariableIF* variable ) = 0;
+	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
+
+	virtual ReturnValue_t lockDataPool() = 0;
+	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
 #endif /* DATASETIF_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index caae2146..844fcd90 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,5 +1,4 @@
 #include <framework/datapool/HkSwitchHelper.h>
-//#include <mission/tmtcservices/HKService_03.h>
 #include <framework/ipc/QueueFactory.h>
 
 HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 5eb86026..3a815cee 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -1,9 +1,9 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
-#include <framework/datapool/DataPool.h>
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -16,9 +16,9 @@ protected:
 	uint32_t parameterId;
 	uint8_t valid;
 	ReturnValue_t read() {
-		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
 		PoolEntry<T>* read_out = ::dataPool.getData<T>(
-				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
@@ -88,7 +88,7 @@ public:
 	 * \brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
-		return DataPool::PIDToDataPoolId(parameterId);
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
 	}
 	uint32_t getParameterId() const {
 		return parameterId;
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index e38af775..d07c516d 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -71,7 +71,6 @@ Type PoolEntry<T>::getType() {
 	return PodTypeConversion<T>::type;
 }
 
-template class PoolEntry<bool>;
 template class PoolEntry<uint8_t>;
 template class PoolEntry<uint16_t>;
 template class PoolEntry<uint32_t>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index a02c6c60..4971ee45 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -6,34 +6,46 @@
 #include <stddef.h>
 #include <cstring>
 #include <initializer_list>
+#include <type_traits>
 /**
- * \brief		This is a small helper class that defines a single data pool entry.
- *
- * \details		The helper is used to store all information together with the data as a single data pool entry.
- * 				The content's type is defined by the template argument.
- * 				It is prepared for use with plain old data types,
- * 				but may be extended to complex types if necessary.
- * 				It can be initialized with a certain value, size and validity flag.
- * 				It holds a pointer to the real data and offers methods to access this data and to acquire
- * 				additional information (such as validity and array/byte size).
- * 				It is NOT intended to be used outside the DataPool class.
- *
- *	\ingroup data_pool
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry.The content's type is defined by the template argument.
+ * It is prepared for use with plain old data types, but may be extended to
+ * complex types if necessary. It can be initialized with a certain value,
+ * size and validity flag. It holds a pointer to the real data and offers
+ * methods to access this data and to acquire additional information
+ * (such as validity and array/byte size). It is NOT intended to be used
+ * outside the DataPool class.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
  *
  */
 template <typename T>
 class PoolEntry : public PoolEntryIF {
 public:
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"Warum? Darum :-)");
 	/**
-	 * \brief	In the classe's constructor, space is allocated on the heap and
+	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * \param initValue		A pointer to the single value or array that holds the init value.
-	 * 						With the default value (NULL), the entry is initalized with all 0.
-	 * \param set_length	Defines the array length of this entry.
-	 * \param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @param initValue	Initializer list with values to initialize with
+	 * @param set_length	Defines the array length of this entry.
+	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
 	 */
 	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue		A pointer to the single value or array that holds the init value.
+	 * 						With the default value (NULL), the entry is initalized with all 0.
+	 * @param set_length	Defines the array length of this entry.
+	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 */
 	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+
 	/**
 	 * \brief	The allocated memory for the variable is freed in the destructor.
 	 * \details	As the data pool is global, this dtor is only called on program exit.
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index 514e67ef..d24d553a 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,66 +1,63 @@
-/**
- * \file	PoolEntryIF.h
- *
- * \brief	This file holds the class that defines the Interface for Pool Entry elements.
- *
- * \date	10/18/2012
- *
- * \author	Bastian Baetz
- */
-
 #ifndef POOLENTRYIF_H_
 #define POOLENTRYIF_H_
 
 #include <framework/globalfunctions/Type.h>
-#include <stdint.h>
-
-
+#include <cstdint>
 
 /**
- * \brief	This interface defines the access possibilities to a single data pool entry.
- *
- * \details	The interface provides methods to determine the size and the validity information of a value.
- * 			It also defines a method to receive a pointer to the raw data content.
- * 			It is mainly used by DataPool itself, but also as a return pointer.
- *
- *	\ingroup data_pool
- *
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to
+ * the raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class PoolEntryIF {
 public:
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
-	virtual ~PoolEntryIF() {
-	}
+	virtual ~PoolEntryIF() {}
+
 	/**
-	 * \brief	getSize returns the array size of the entry. A single variable parameter has size 1.
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
 	 */
 	virtual uint8_t getSize() = 0;
+
 	/**
-	 * \brief	This operation returns the size in bytes, which is calculated by
+	 * @brief	This operation returns the size in bytes, which is calculated by
 	 * 			sizeof(type) * array_size.
 	 */
 	virtual uint16_t getByteSize() = 0;
+
 	/**
-	 * \brief	This operation returns a the address pointer casted to void*.
+	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	virtual void* getRawData() = 0;
+
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
 	virtual void setValid(uint8_t isValid) = 0;
+
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
 	virtual uint8_t getValid() = 0;
+
 	/**
-	 * \brief	This is a debug method that prints all values and the valid information to the screen.
-	 * 			It prints all array entries in a row.
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	virtual void print() = 0;
+
 	/**
-	 * Returns the type of the entry.
+	 * @brief 	Returns the type of the entry.
 	 */
 	virtual Type getType() = 0;
 };
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 592f663f..97bdc2b3 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,6 +1,6 @@
-#include <framework/datapool/DataPool.h>
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
@@ -14,63 +14,41 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {}
+PoolRawAccess::~PoolRawAccess() {
+
+}
 
 ReturnValue_t PoolRawAccess::read() {
-	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
-		result = handleReadOut(read_out);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* read_out) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = read_out->getValid();
-	if (read_out->getSize() > arrayEntry) {
-		arraySize = read_out->getSize();
-		typeSize = read_out->getByteSize() / read_out->getSize();
-		type = read_out->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = read_out->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) read_out->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
+		valid = read_out->getValid();
+		if (read_out->getSize() > arrayEntry) {
+			arraySize = read_out->getSize();
+			typeSize = read_out->getByteSize() / read_out->getSize();
+			type = read_out->getType();
+			if (typeSize <= sizeof(value)) {
+				uint16_t arrayPosition = arrayEntry * typeSize;
+				sizeTillEnd = read_out->getByteSize() - arrayPosition;
+				uint8_t* ptr =
+						&((uint8_t*) read_out->getRawData())[arrayPosition];
+				memcpy(value, ptr, typeSize);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				//Error value type too large.
+			}
 		} else {
-			result = READ_TYPE_TOO_LARGE;
+			//Error index requested too large
 		}
 	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
+		//Error entry does not exist.
 	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
+			<< std::dec << " failed." << std::endl;
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -111,32 +89,6 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
-
-
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -193,6 +145,29 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
 
 size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
@@ -200,9 +175,8 @@ size_t PoolRawAccess::getSerializedSize() const {
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
-	// TODO: Needs to be tested!!!
 	if (*size >= typeSize) {
-		*size -= typeSize;
+
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -213,14 +187,12 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		}
-		else {
+		} else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
+	} else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index b491d949..f32aac51 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -6,54 +6,83 @@
 #include <framework/globalfunctions/Type.h>
 
 /**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
+ * This class allows accessing Data Pool variables as raw bytes.
  * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information. Please note that the the raw pool access read() and commit()
- * calls are not thread-safe.
- * Please supply a data set and use the data set read(), commit() calls for thread-safe
- * data pool access.
- * @ingroup data_pool
+ * provide a type information.
+ *	\ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+class PoolRawAccess: public PoolVariableIF {
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 *  \brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * \brief	This value contains the size of the data pool entry in bytes.
+	 */
+	uint8_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	uint8_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	uint16_t sizeTillEnd;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+protected:
+	/**
+	 * \brief	This is a call to read the value from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
+	/**
+	 * \brief	The commit call writes back the variable's value to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
 	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
 	uint8_t value[RAW_MAX_SIZE];
-
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
 	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
 			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-			PoolVariableIF::VAR_READ);
+					PoolVariableIF::VAR_READ);
 	/**
 	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
 	~PoolRawAccess();
-
 	/**
 	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
+	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
+	 * 			array entry "index". Example: If the original data pool array consists of an double
+	 * 			array of size four, getEntry(1) returns &(this->value[8]).
 	 */
 	uint8_t* getEntry();
 	/**
@@ -71,19 +100,6 @@ public:
 	 */
 	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
 			uint32_t max_size);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
 	 * @param buffer	Pointer to the data to set
@@ -125,73 +141,13 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
+
 	size_t getSerializedSize() const;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
-
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 *  \brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * \brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	uint8_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	uint8_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	uint16_t sizeTillEnd;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
 };
 
 #endif /* POOLRAWACCESS_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 91d6309f..cf02b20a 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -9,7 +9,7 @@
 
 #include <cmath>
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
@@ -97,7 +97,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 	//      << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
-		if(counter > DataSet::DATA_SET_MAX_SIZE) {
+		if(counter > GlobDataSet::DATA_SET_MAX_SIZE) {
 			sif::error << "PoolRawAccessHelper: Config error, "
 					 "max. number of possible data set variables exceeded"
 				  << std::endl;
@@ -105,7 +105,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		}
 		counter ++;
 
-		DataSet currentDataSet = DataSet();
+		GlobDataSet currentDataSet;
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
 		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
 				&currentDataSet,PoolVariableIF::VAR_READ);
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 61d79731..ab881a5f 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -8,7 +8,7 @@
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 
 /**
  * @brief 	This helper function simplifies accessing data pool entries
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 90c9f178..9d6bc461 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,12 +1,12 @@
 #ifndef POOLVARLIST_H_
 #define POOLVARLIST_H_
 
-#include <framework/datapool/PoolVariable.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 template <class T, uint8_t n_var>
 class PoolVarList {
 private:
-	PoolVariable<T> variables[n_var];
+	GlobPoolVar<T> variables[n_var];
 public:
 	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
 		//I really should have a look at the new init list c++ syntax.
@@ -20,7 +20,7 @@ public:
 		}
 	}
 
-	PoolVariable<T> &operator [](int i) { return variables[i]; }
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
 };
 
 
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 7626c9c1..9935ef75 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,71 +1,70 @@
-/*
- * \file	PoolVariableIF.h
- *
- * \brief	This file contains the interface definition for pool variables.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
 #ifndef POOLVARIABLEIF_H_
 #define POOLVARIABLEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+
 /**
- * \brief	This interface is used to control local data pool variable representations.
- *
- * \details	To securely handle data pool variables, all pool entries are locally managed by
- * 			data pool variable access classes, which are called pool variables. To ensure a
- * 			common state of a set of variables needed in a function, these local pool variables
- * 			again are managed by other classes, e.g. the DataSet. This interface provides unified
- * 			access to local pool variables for such manager classes.
- *	\ingroup data_pool
+ * @brief	This interface is used to control data pool variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSet;
+	friend class GlobDataSet;
+	friend class LocalDataSet;
 protected:
 	/**
-	 * \brief	The commit call shall write back a newly calculated local value to the data pool.
+	 * @brief	The commit call shall write back a newly calculated local
+	 * 			value to the data pool.
 	 */
 	virtual ReturnValue_t commit() = 0;
 	/**
-	 * \brief	The read call shall read the value of this parameter from the data pool and store
-	 * 			the content locally.
+	 * @brief	The read call shall read the value of this parameter from
+	 * 			the data pool and store the content locally.
 	 */
 	virtual ReturnValue_t read() = 0;
 public:
-	static const uint8_t VALID = 1;
-	static const uint8_t INVALID = 0;
-	static const uint32_t NO_PARAMETER = 0;
+	static constexpr bool VALID = 1;
+	static constexpr bool INVALID = 0;
+	static constexpr uint32_t NO_PARAMETER = 0;
+
 	enum ReadWriteMode_t {
 		VAR_READ, VAR_WRITE, VAR_READ_WRITE
 	};
 
 	/**
-	 * \brief	This is an empty virtual destructor, as it is proposed for C++ interfaces.
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
 	 */
-	virtual ~PoolVariableIF() {
-	}
+	virtual ~PoolVariableIF() {}
 	/**
-	 * \brief	This method returns if the variable is write-only, read-write or read-only.
+	 * @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.
+	 * @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.
+	 * @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.
+	 * @brief	With this call, the valid information of the variable is set.
 	 */
+	// why not just use a boolean here?
 	virtual void setValid(uint8_t validity) = 0;
 
 };
 
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
 #endif /* POOLVARIABLEIF_H_ */
diff --git a/datapool/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
similarity index 96%
rename from datapool/DataPoolAdmin.cpp
rename to datapoolglob/DataPoolAdmin.cpp
index 25013726..59bd9f30 100644
--- a/datapool/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,5 @@
-#include <framework/datapool/DataPool.h>
-#include <framework/datapool/DataPoolAdmin.h>
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/DataPoolAdmin.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
@@ -26,7 +24,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -42,7 +40,7 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
 	ReturnValue_t status = mySet.read();
 	if (status != RETURN_OK) {
@@ -94,7 +92,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -113,7 +111,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	const uint8_t* readPosition = data;
 
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ_WRITE);
 		status = rawSet.read();
@@ -133,7 +131,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
 	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
 	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
-	DataSet testSet;
+	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
 	ReturnValue_t status = testSet.read();
@@ -146,7 +144,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 	}
 	uint8_t* ptrToCopy = copyHere;
 	for (; size > 0; size -= typeSize) {
-		DataSet rawSet;
+		GlobDataSet rawSet;
 		PoolRawAccess variable(poolId, arrayIndex, &rawSet,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
diff --git a/datapool/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
similarity index 90%
rename from datapool/DataPoolAdmin.h
rename to datapoolglob/DataPoolAdmin.h
index dffcd462..5f995893 100644
--- a/datapool/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,15 +1,16 @@
 #ifndef DATAPOOLADMIN_H_
 #define DATAPOOLADMIN_H_
 
-#include <framework/memory/MemoryHelper.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/action/SimpleActionHelper.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-#include <framework/datapool/DataPoolParameterWrapper.h>
+#include <framework/action/HasActionsIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/parameters/ReceivesParameterMessagesIF.h>
+
+#include <framework/memory/MemoryHelper.h>
+#include <framework/action/SimpleActionHelper.h>
+#include <framework/datapoolglob/DataPoolParameterWrapper.h>
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -33,8 +34,8 @@ public:
 	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
-	virtual ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
similarity index 96%
rename from datapool/DataPoolParameterWrapper.cpp
rename to datapoolglob/DataPoolParameterWrapper.cpp
index 11399fb6..d93cd88e 100644
--- a/datapool/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,10 +1,8 @@
-#include "DataPoolParameterWrapper.h"
-
-//for returncodes
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/DataPoolParameterWrapper.h>
+#include <framework/datapool/PoolRawAccess.h>
 #include <framework/parameters/HasParametersIF.h>
 
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolRawAccess.h>
 
 DataPoolParameterWrapper::DataPoolParameterWrapper() :
 		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
@@ -20,7 +18,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 		uint16_t parameterId) {
 	poolId = (domainId << 16) + parameterId;
 
-	DataSet mySet;
+	GlobDataSet mySet;
 	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
@@ -57,7 +55,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
 	}
 
 	for (uint8_t index = 0; index < rows; index++){
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
 		mySet.read();
 		result = raw.serialize(buffer,size,max_size,bigEndian);
@@ -94,7 +92,7 @@ ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
-		DataSet mySet;
+		GlobDataSet mySet;
 		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
diff --git a/datapool/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
similarity index 100%
rename from datapool/DataPoolParameterWrapper.h
rename to datapoolglob/DataPoolParameterWrapper.h
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
new file mode 100644
index 00000000..e13765ba
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -0,0 +1,132 @@
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/ipc/MutexFactory.h>
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::freeDataPoolLock() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if ( status != RETURN_OK ) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool() {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if ( status != RETURN_OK ) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
new file mode 100644
index 00000000..e0c086ad
--- /dev/null
+++ b/datapoolglob/GlobalDataPool.h
@@ -0,0 +1,146 @@
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include <framework/datapool/PoolEntry.h>
+#include <framework/globalfunctions/Type.h>
+#include <framework/ipc/MutexIF.h>
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool();
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t freeDataPoolLock();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+extern GlobalDataPool dataPool;
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
new file mode 100644
index 00000000..7409dbbd
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -0,0 +1,166 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+GlobDataSet::GlobDataSet() :
+		fill_count(0), state(DATA_SET_UNINITIALISED) {
+	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+GlobDataSet::~GlobDataSet() {
+	//Don't do anything with your variables, they are dead already!
+	// (Destructor is already called)
+}
+
+ReturnValue_t GlobDataSet::registerVariable(PoolVariableIF* variable) {
+	if (state != DATA_SET_UNINITIALISED) {
+		sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
+		return DATA_SET_UNINITIALISED;
+	}
+	if (variable == nullptr) {
+		sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
+		return POOL_VAR_NULL;
+	}
+	if (fill_count >= DATA_SET_MAX_SIZE) {
+		sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
+		return DATA_SET_FULL;
+	}
+	registeredVariables[fill_count] = variable;
+	fill_count++;
+	return RETURN_OK;
+}
+
+ReturnValue_t GlobDataSet::read() {
+	ReturnValue_t result = RETURN_OK;
+	if (state == DATA_SET_UNINITIALISED) {
+		lockDataPool();
+		for (uint16_t count = 0; count < fill_count; count++) {
+			if (registeredVariables[count]->getReadWriteMode()
+					!= PoolVariableIF::VAR_WRITE
+					&& registeredVariables[count]->getDataPoolId()
+							!= PoolVariableIF::NO_PARAMETER) {
+				ReturnValue_t status = registeredVariables[count]->read();
+				if (status != RETURN_OK) {
+					result = INVALID_PARAMETER_DEFINITION;
+					break;
+				}
+			}
+		}
+		state = DATA_SET_WAS_READ;
+		unlockDataPool();
+	} else {
+		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+ReturnValue_t GlobDataSet::commit(bool valid) {
+	setEntriesValid(valid);
+	setSetValid(valid);
+	return commit();
+}
+
+ReturnValue_t GlobDataSet::commit() {
+	if (state == DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit();
+		return RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit();
+	}
+}
+
+void GlobDataSet::handleAlreadyReadDatasetCommit() {
+	lockDataPool();
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		}
+	}
+	state = DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
+	ReturnValue_t result = RETURN_OK;
+	lockDataPool();
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		} 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 = DATA_SET_UNINITIALISED;
+	unlockDataPool();
+	return result;
+}
+
+ReturnValue_t GlobDataSet::unlockDataPool() {
+	return ::dataPool.freeDataPoolLock();
+}
+
+ReturnValue_t GlobDataSet::lockDataPool() {
+	return ::dataPool.lockDataPool();
+}
+
+ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, max_size,
+				bigEndian);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+size_t GlobDataSet::getSerializedSize() const {
+	uint32_t size = 0;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		size += registeredVariables[count]->getSerializedSize();
+	}
+	return size;
+}
+
+void GlobDataSet::setEntriesValid(bool valid) {
+	for (uint16_t count = 0; count < fill_count; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ) {
+			registeredVariables[count]->setValid(valid);
+		}
+	}
+}
+
+void GlobDataSet::setSetValid(bool valid) {
+	this->valid = valid;
+}
+
+ReturnValue_t GlobDataSet::deSerialize(const uint8_t** buffer, size_t* size,
+		bool bigEndian) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint16_t count = 0; count < fill_count; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				bigEndian);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
new file mode 100644
index 00000000..365de380
--- /dev/null
+++ b/datapoolglob/GlobalDataSet.h
@@ -0,0 +1,185 @@
+#ifndef DATASET_H_
+#define DATASET_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapool/PoolVarList.h>
+
+#include <framework/serialize/SerializeAdapter.h>
+/**
+ * @brief	The DataSet class manages a set of locally checked out variables
+ * 			for the global data pool.
+ *
+ * @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.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobDataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
+public:
+	//SHOULDDO we could use a linked list of datapool variables
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
+
+	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 DATA_SET_UNINITIALIZED = 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 );
+	/**
+	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	GlobDataSet();
+
+	/**
+	 * @brief	This operation is used to register the local variables in the set.
+	 * @details	It stores the pool variable pointer in a variable list.
+	 */
+	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~GlobDataSet();
+	/**
+	 * @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
+	 */
+	ReturnValue_t read();
+	/**
+	 * @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
+	 */
+	ReturnValue_t commit(void);
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @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
+	 */
+	ReturnValue_t commit(bool valid);
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+private:
+
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * \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 fill_count;
+	/**
+	 * States of the seet.
+	 */
+	enum 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;
+
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the underlying data data pool structure
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool() override;
+
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the underlying data data pool structure
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
new file mode 100644
index 00000000..9f80492b
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -0,0 +1,189 @@
+#ifndef POOLVARIABLE_H_
+#define POOLVARIABLE_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"Warum? Darum :-)");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+protected:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read() override;
+
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit() override;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(uint8_t valid);
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
+				bigEndian);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter<T>::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) {
+		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	}
+};
+
+#include <framework/datapoolglob/GlobalPoolVariable.tpp>
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
new file mode 100644
index 00000000..287f06dd
--- /dev/null
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -0,0 +1,84 @@
+#pragma once
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
+		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
+		readWriteMode(setReadWriteMode)
+{
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::read() {
+	PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+	if (read_out != NULL) {
+		valid = read_out->valid;
+		value = *(read_out->address);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		value = 0;
+		valid = false;
+		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
+				<< dataPoolId << std::dec << " failed." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline ReturnValue_t GlobPoolVar<T>::commit() {
+	PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->valid = valid;
+		*(write_back->address) = value;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar():
+		dataPoolId(PoolVariableIF::NO_PARAMETER),
+		valid(PoolVariableIF::INVALID),
+		readWriteMode(VAR_READ), value(0) {}
+
+template <class T>
+inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
+		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
+		rhs.readWriteMode), value(rhs.value) {}
+
+template <class T>
+inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
+	return readWriteMode;
+}
+
+template <class T>
+inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
+	return dataPoolId;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
+	dataPoolId = poolId;
+}
+
+template <class T>
+inline bool GlobPoolVar<T>::isValid() const {
+	if (valid)
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+inline uint8_t GlobPoolVar<T>::getValid() {
+	return valid;
+}
+
+template <class T>
+inline void GlobPoolVar<T>::setValid(uint8_t valid) {
+	this->valid = valid;
+}
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
new file mode 100644
index 00000000..47381aec
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.h
@@ -0,0 +1,223 @@
+#ifndef POOLVECTOR_H_
+#define POOLVECTOR_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+/**
+ * \brief	This is the access class for array-type data pool entries.
+ *
+ * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
+ * 			entries, but on local copies. This class provides simple type- and length-safe access
+ * 			to vector-style data pool entries (i.e. entries with length > 1).
+ * 			The class can be instantiated as read-write and read only.
+ * 			It provides a commit-and-roll-back semantic, which means that no array entry in
+ * 			the data pool is changed until the commit call is executed.
+ * 			There are two template parameters:
+ * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
+ * 			plain data types are supported, but in principle any type is possible.
+ * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
+ * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
+ *	\ingroup data_pool
+ */
+template<typename T, uint16_t vector_size>
+class GlobPoolVector: public PoolVariableIF {
+private:
+	/**
+	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+
+protected:
+	/**
+	 * \brief	This is a call to read the array's values from the global data pool.
+	 * \details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies all array values and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type, size or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read() {
+		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
+				vector_size);
+		if (read_out != NULL) {
+			this->valid = read_out->valid;
+			memcpy(this->value, read_out->address, read_out->getByteSize());
+
+			return HasReturnvaluesIF::RETURN_OK;
+
+		} else {
+			memset(this->value, 0, vector_size * sizeof(T));
+			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
+					<< dataPoolId << std::dec << " failed." << std::endl;
+			this->valid = INVALID;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * \brief	The commit call copies the array values back to the data pool.
+	 * \details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit() {
+		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
+				vector_size);
+		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
+			write_back->valid = valid;
+			memcpy(write_back->address, this->value, write_back->getByteSize());
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 * \detials	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vector_size];
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode) :
+			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
+		memset(this->value, 0, vector_size * sizeof(T));
+		if (set != NULL) {
+			set->registerVariable(this);
+		}
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+//	PoolVector(const PoolVector& rhs) {
+//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
+//		memcpy(value, rhs.value, sizeof(T)*vector_size);
+//	}
+	/**
+	 * \brief	The classes destructor is empty.
+	 * \details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {
+	}
+	;
+	/**
+	 * \brief	The operation returns the number of array entries in this variable.
+	 */
+	uint8_t getSize() {
+		return vector_size;
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+	;
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+
+	void setValid(uint8_t valid) {
+		this->valid = valid;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	T &operator [](int i) {
+		return value[i];
+	}
+
+	const T &operator [](int i) const {
+		return value[i];
+	}
+
+	GlobPoolVector<T, vector_size> &operator=(
+			GlobPoolVector<T, vector_size> newPoolVector) {
+
+		for (uint16_t i = 0; i < vector_size; i++) {
+			this->value[i] = newPoolVector.value[i];
+		}
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		uint16_t i;
+		ReturnValue_t result;
+		for (i = 0; i < vector_size; i++) {
+			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+					max_size, bigEndian);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
+		uint16_t i;
+		ReturnValue_t result;
+		for (i = 0; i < vector_size; i++) {
+			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+					bigEndian);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+};
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
new file mode 100644
index 00000000..07f86e18
--- /dev/null
+++ b/datapoollocal/LocalDataSet.cpp
@@ -0,0 +1,66 @@
+#include <framework/datapoollocal/LocalDataSet.h>
+
+LocalDataSet::LocalDataSet():
+		fill_count(0), state(DATA_SET_UNINITIALISED)
+{
+	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
+		registeredVariables[count] = nullptr;
+	}
+}
+
+// who has the responsibility to lock the mutex? the local pool variable
+// has access to the HK manager and could call its mutex lock function.
+ReturnValue_t LocalDataSet::registerVariable(
+		PoolVariableIF *variable) {
+	return RETURN_OK;
+}
+
+LocalDataSet::~LocalDataSet() {
+}
+
+ReturnValue_t LocalDataSet::read() {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::commit(void) {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::commit(bool valid) {
+	return RETURN_OK;
+}
+
+void LocalDataSet::setSetValid(bool valid) {
+}
+
+void LocalDataSet::setEntriesValid(bool valid) {
+}
+
+ReturnValue_t LocalDataSet::serialize(uint8_t **buffer,
+		size_t *size, const size_t max_size, bool bigEndian) const {
+	return RETURN_OK;
+}
+
+size_t LocalDataSet::getSerializedSize() const {
+	return 0;
+}
+
+ReturnValue_t LocalDataSet::deSerialize(const uint8_t **buffer,
+		size_t *size, bool bigEndian) {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::lockDataPool() {
+	return RETURN_OK;
+}
+
+ReturnValue_t LocalDataSet::unlockDataPool() {
+	return RETURN_OK;
+}
+
+void LocalDataSet::handleAlreadyReadDatasetCommit() {
+}
+
+ReturnValue_t LocalDataSet::handleUnreadDatasetCommit() {
+	return RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
new file mode 100644
index 00000000..6110175c
--- /dev/null
+++ b/datapoollocal/LocalDataSet.h
@@ -0,0 +1,187 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/serialize/SerializeIF.h>
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out variables
+ * 			for local data pools
+ * @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 local data pools,
+ * to ensure thread-safety.
+ *
+ * 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.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSet:
+		public DataSetIF,
+		public HasReturnvaluesIF,
+		public SerializeIF {
+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 DATA_SET_UNINITIALIZED = 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 );
+	/**
+	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet();
+
+	/**
+	 * @brief	This operation is used to register the local variables in the set.
+	 * @details	It stores the pool variable pointer in a variable list.
+	 */
+	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSet();
+
+	/**
+	 * @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
+	 */
+	ReturnValue_t read();
+
+	/**
+	 * @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
+	 */
+	ReturnValue_t commit(void);
+
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @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
+	 */
+	ReturnValue_t commit(bool valid);
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+private:
+	// SHOULDDO we could use a linked list of datapool variables
+	//! This definition sets the maximum number of variables
+	//! to register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+	/**
+	 * @brief	This array represents all pool variables registered in this set.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+	/**
+	 * @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 fill_count;
+
+	/**
+	 * States of the seet.
+	 */
+	enum 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;
+
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the underlying data data pool structure
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool() override;
+
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the underlying data data pool structure
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
new file mode 100644
index 00000000..44c16a7c
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapool/DataSetIF.h>
+
+#include <framework/housekeeping/HousekeepingManager.h>
+
+#include <map>
+/**
+ * @brief	This is the access class for non-array local data pool entries.
+ *
+ * @details
+ *
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details This class is not stored in the map. Instead, it is used to access
+ * 			the pool entries by using a pointer to the map storing the pool
+ * 			entries. It can also be used to organize these pool entries
+ * 			into data sets.
+ * @tparam T
+ */
+template<typename T>
+class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	static constexpr lp_id_t INVALID_POOL_ID = 0xFFFFFFFF;
+
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * @param set_id
+	 * @param setReadWriteMode
+	 * @param localPoolMap
+	 * @param dataSet
+	 */
+	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * @param poolId
+	 * @param poolOwner
+	 * @param setReadWriteMode
+	 * @param dataSet
+	 */
+	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+
+	virtual~ LocalPoolVar() {};
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	ReturnValue_t commit() override;
+	ReturnValue_t read() override;
+	pool_rwm_t getReadWriteMode() const override;
+	uint32_t getDataPoolId() const override;
+	bool isValid() const override;
+	void setValid(uint8_t validity) override;
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				bool bigEndian) override;
+private:
+	lp_id_t localPoolId = INVALID_POOL_ID;
+	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	bool valid = false;
+
+	bool objectValid = true;
+	//! Pointer to the class which manages the HK pool.
+	HousekeepingManager* hkManager;
+};
+
+#include <framework/datapoollocal/LocalPoolVariable.tpp>
+template<class T>
+using lp_variable = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<bool>;
+using lp_uint8_t = LocalPoolVar<uint8_t>;
+using lp_uint16_t = LocalPoolVar<uint16_t>;
+using lp_uint32_t = LocalPoolVar<uint32_t>;
+using lp_uint64_t = LocalPoolVar<uint64_t>;
+using lp_int8_t = LocalPoolVar<int8_t>;
+using lp_int16_t = LocalPoolVar<int16_t>;
+using lp_int32_t = LocalPoolVar<int32_t>;
+using lp_int64_t = LocalPoolVar<int64_t>;
+using lp_float_t = LocalPoolVar<float>;
+using lp_double_t = LocalPoolVar<double>;
+
+
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
new file mode 100644
index 00000000..fdd18bcd
--- /dev/null
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+
+#include <framework/serialize/SerializeAdapter.h>
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
+		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		DataSetIF* dataSet):
+		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		readWriteMode(readWriteMode) {
+	HasHkPoolParametersIF* hkOwner =
+			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
+				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		objectValid = false;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::read() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		// TODO: special return value
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	this->value = *(poolEntry->address);
+	return RETURN_OK;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commit() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				 "mode for commit() call." << std::endl;
+		// TODO: special return value
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	*(poolEntry->address) = this->value;
+	return RETURN_OK;
+}
+
+template<typename T>
+inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+template<typename T>
+inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::isValid() const {
+	return valid;
+}
+
+template<typename T>
+inline void LocalPoolVar<T>::setValid(uint8_t validity) {
+	this->valid = validity;
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	return AutoSerializeAdapter::serialize(&value,
+			buffer, size ,max_size, bigEndian);
+}
+
+template<typename T>
+inline size_t LocalPoolVar<T>::getSerializedSize() const {
+	return AutoSerializeAdapter::getSerializedSize(&value);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+		size_t* size, bool bigEndian) {
+	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
+}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 710e97d7..0549bd45 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/SubsystemBase.h>
 #include <framework/thermal/ThermalComponentIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapool/PoolVariable.h>
+#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
+#include <framework/globalfunctions/CRC.h>
+#include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -17,34 +17,33 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie_,
+		object_id_t deviceCommunication, CookieIF * comCookie,
 		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
 		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
-		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
-		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
-{
-	commandQueue = QueueFactory::instance()->
-			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
+		deviceCommunicationId(deviceCommunication), deviceThermalStatePoolId(
+		thermalStatePoolId),deviceThermalRequestPoolId(thermalRequestPoolId),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
+		switchOffWasReported(false), actionHelper(this, nullptr), cookieInfo(),
+		childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
-		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId,
-						defaultFDIRParentId);
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFDIRParentId);
 	}
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	delete comCookie;
+	//communicationInterface->close(cookie);
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -53,7 +52,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-	if (counter == 0) {
+
+	if (getComAction() == SEND_WRITE) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -66,7 +66,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-
 	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,7 +86,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
-
 	return RETURN_OK;
 }
 
@@ -116,7 +114,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == nullptr) {
+	if (rawReceiver == NULL) {
 		return RETURN_FAILED;
 	}
 
@@ -158,14 +156,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	DataSet mySet;
-	PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	mySet.read();
 	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
+
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -366,8 +365,11 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
-	if (result.second) {
+	std::pair<std::map<DeviceCommandId_t, DeviceCommandInfo>::iterator, bool> returnValue;
+	returnValue = deviceCommandMap.insert(
+			std::pair<DeviceCommandId_t, DeviceCommandInfo>(deviceCommand,
+					info));
+	if (returnValue.second) {
 		return RETURN_OK;
 	} else {
 		return RETURN_FAILED;
@@ -426,8 +428,8 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		DataSet mySet;
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		GlobDataSet mySet;
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ_WRITE);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -487,7 +489,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo * info = &(iter->second.command->second);
+	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -526,6 +528,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
+
 		//We need to distinguish here, because a raw command never expects a reply.
 		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
@@ -541,25 +544,22 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result = RETURN_FAILED;
+	ReturnValue_t result;
+
 	size_t requestLen = 0;
-	// If the device handler can only request replies after a command
-	// has been sent, there should be only one reply enabled and the
-	// correct reply length will be mapped.
-	for(DeviceReplyIter iter = deviceReplyMap.begin();
-			iter != deviceReplyMap.end();iter++)
-	{
-		if(iter->second.delayCycles != 0) {
-			requestLen = iter->second.replyLen;
-			break;
-		}
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	}
-	else {
+	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -583,8 +583,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
-			&receivedDataLen);
+	result = communicationInterface->readReceivedMessage(comCookie,
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -644,7 +644,7 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t ** data, size_t * len) {
+		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == NULL) {
@@ -663,10 +663,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		*len = 0;
 		return result;
 	}
-
 }
 
-
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
 	if (IPCStore == NULL || len == 0) {
@@ -681,6 +679,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
+
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
@@ -690,14 +689,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	if (result != RETURN_OK) {
 		IPCStore->deleteData(address);
-		// Silently discard data, this indicates heavy TM traffic which should
-		// not be increased by additional events.
+		//Silently discard data, this indicates heavy TM traffic which should not be increased by additional events.
 	}
 }
 
 //Default child implementations
-
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -762,8 +759,8 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 //			DeviceCommunicationIF>(newChannelId);
 //
 //	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+//				maxDeviceReplyLen);
 //		if (result != RETURN_OK) {
 //			return result;
 //		}
@@ -780,8 +777,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.
-				find((DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
@@ -820,7 +817,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo * info = &(iter->second);
+		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
 		command->second.expectedReplies = expectedReplies;
@@ -846,9 +843,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
-				== PowerSwitchIF::SWITCH_OFF)
-			{
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -890,10 +886,10 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
 			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		DataSet mySet;
-		PoolVariable<int8_t> thermalState(deviceThermalStatePoolId, &mySet,
+		GlobDataSet mySet;
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -920,8 +916,8 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			DataSet mySet;
-			PoolVariable<int8_t> thermalRequest(deviceThermalRequestPoolId,
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1032,7 +1028,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case DeviceHandlerMessage::CMD_WIRETAPPING:
 		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
@@ -1054,21 +1049,19 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
-		if (mode != MODE_OFF) {
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			// rework in progress
-			result = RETURN_OK;
-			//result = switchCookieChannel(
-			//		DeviceHandlerMessage::getIoBoardObjectId(message));
-			if (result == RETURN_OK) {
-				replyReturnvalueToCommand(RETURN_OK);
-			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
-			}
-		}
-		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+////			result = switchCookieChannel(
+////					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1124,7 +1117,8 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
 			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+			true);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1137,9 +1131,9 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 			true);
 		}
 	}
-//Try to cast to DataSet and commit data.
+//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
-		DataSet* dataSet = dynamic_cast<DataSet*>(data);
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
 			dataSet->commit(PoolVariableIF::VALID);
 		}
@@ -1147,12 +1141,11 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1171,7 +1164,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-	// Neither Raw nor Direct could build a command
+//Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1189,13 +1182,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
-
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter =
-				deviceCommandMap.find(deviceCommandId);
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1210,7 +1202,6 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
-
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
@@ -1285,8 +1276,8 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
-}
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {
-}
+void DeviceHandlerBase::performOperationHook() {}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 25ec75b9..379992b1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,26 +1,23 @@
 #ifndef DEVICEHANDLERBASE_H_
 #define DEVICEHANDLERBASE_H_
 
-#include <framework/action/ActionHelper.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/action/HasActionsIF.h>
-#include <framework/datapool/DataSet.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/health/HealthHelper.h>
 #include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
 #include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
+
+#include <framework/action/ActionHelper.h>
+#include <framework/health/HealthHelper.h>
+#include <framework/parameters/ParameterHelper.h>
+#include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+
 #include <map>
 
 namespace Factory{
@@ -92,21 +89,22 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the largest allowed reply size
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to,
-	 *    for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is
-	 *    used to implement communication functions
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, uint8_t setDeviceSwitch,
+			CookieIF * comCookie, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -213,12 +211,13 @@ protected:
 	/**
 	 * Build the device command to send for normal mode.
 	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 * If variable command frequence is required, a counter can be used and
-	 * the frequency in the reply map has to be set manually
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
 	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
@@ -233,10 +232,13 @@ protected:
 	 * Build the device command to send for a transitional mode.
 	 *
 	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp() and doShutDown() as well as doTransition()
+	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition()
 	 *
-	 * A good idea is to implement a flag indicating a command has to be built and a variable containing the command number to be built
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 * A good idea is to implement a flag indicating a command has to be built
+	 * and a variable containing the command number to be built
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
 	 *
@@ -266,6 +268,63 @@ protected:
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
 
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c RETURN_FAILED when the reply could not be interpreted,
+	 *     e.g. logical errors or range violations occurred
+	 */
+
+	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+			const uint8_t *packet) = 0;
+
 	/**
 	 * @brief fill the #deviceCommandMap
 	 *	 	  called by the initialize() of the base class
@@ -312,85 +371,83 @@ protected:
 	virtual void fillCommandAndReplyMap() = 0;
 
 	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data.
-	 * No information check is done, e.g. range checks etc.
-	 *
-	 * Errors should be reported directly,  the base class does NOT report
-	 * any errors based on the returnvalue of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *             implies @c foundLen is not valid,
-	 *             base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *             requested by a command, but should be handled anyway
-	 *             (@see also fillCommandAndCookieMap() )
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
 	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			uint8_t periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * Get the time needed to transit from modeFrom to modeTo.
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
@@ -408,40 +465,24 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
+	 *      - @c RETURN_FAILED if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
 	/**
-	 * Can be used to perform device specific periodic operations.
-	 * This is called on the SEND_READ step of the performOperation() call
+	 * @brief 	Hook function for child handlers which is called once per
+	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
-
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-	/**
-	 * This function call handles the execution of external commands as required
-	 * by the HasActionIF.
-	 * @param actionId
-	 * @param commandedBy
-	 * @param data
-	 * @param size
-	 * @return
-	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
+			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -460,6 +501,28 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	/**
+	 * These returnvalues can be returned from abstract functions
+	 * to alter the behaviour of DHB.For error values, refer to
+	 * DeviceHandlerIF.h returnvalues.
+	 */
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+
+//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
@@ -475,7 +538,7 @@ protected:
 	/**
 	 * Size of the #rawPacket.
 	 */
-	size_t rawPacketLen = 0;
+	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -502,7 +565,7 @@ protected:
 	 * indicates either that all raw messages to and from the device should be sent to #theOneWhoWantsToReadRawTraffic
 	 * or that all device TM should be downlinked to #theOneWhoWantsToReadRawTraffic
 	 */
-	enum WiretappingMode: uint8_t {
+	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 
@@ -546,18 +609,16 @@ protected:
 	DeviceCommunicationIF *communicationInterface = nullptr;
 
 	/**
-	 * Cookie used for communication. This is passed to the communication
-	 * interface.
+	 * Cookie used for communication
 	 */
-	CookieIF *comCookie;
+	CookieIF * comCookie = nullptr;
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.
 		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
-	typedef DeviceCommandMap::iterator DeviceCommandIter;
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
 
 	/**
 	 * @brief Information about expected replies
@@ -568,15 +629,12 @@ protected:
 		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
 		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
 		size_t replyLen = 0; //!< Expected size of the reply.
-		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
-		// gives away the impression that this variable is more than a simple flag
-		// and true/false are also more explicit.
 		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
 		DeviceCommandMap::iterator command; //!< The command that expects this reply.
 	};
 
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
-	typedef DeviceReplyMap::iterator DeviceReplyIter;
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -610,7 +668,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = RETURN_OK;
+	ReturnValue_t childTransitionFailure;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
@@ -622,35 +680,13 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
 
 	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
 
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
 	static object_id_t defaultFDIRParentId; //!< Object which may be the root cause of an identified fault.
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -671,14 +707,30 @@ protected:
 	void replyReturnvalueToCommand(ReturnValue_t status,
 			uint32_t parameter = 0);
 
-	/**
-	 * Send reply to a command, differentiate between raw command
-	 * and normal command.
-	 * @param status
-	 * @param parameter
-	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -708,55 +760,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @param hasDifferentReplyId
-	 * @param replyId
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-	/**
-	 * This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
-	/**
-	 * A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * This is a helper method to facilitate updating entries in the reply map.
-	 * @param deviceCommand		Identifier of the reply to update.
-	 * @param delayCycles		The current number of delay cycles to wait. As stated in #fillCommandAndCookieMap, to disable periodic commands, this is set to zero.
-	 * @param maxDelayCycles	The maximum number of delay cycles the reply waits until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic			Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 					Default is aperiodic (0). Warning: The setting always overrides the value that was entered in the map.
-	 * @return	RETURN_OK when the reply was successfully updated, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -776,6 +779,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
+
 	virtual CommunicationAction_t getComAction();
 
 	/**
@@ -798,6 +802,14 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -861,6 +873,14 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
@@ -889,6 +909,7 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -954,13 +975,12 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
-
 private:
 
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the communication.
+	 * Used to keep track of the state of the RMAP communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
@@ -1034,20 +1054,22 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 * - Maybe export this into own class to increase modularity of software
-	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
-	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1114,8 +1136,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress,
-			uint8_t ** data, size_t * len);
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1144,16 +1166,9 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
-	/**
-	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
new file mode 100644
index 00000000..5ec9beef
--- /dev/null
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -0,0 +1,32 @@
+#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#include <framework/datapool/PoolEntryIF.h>
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <map>
+
+class HousekeepingManager;
+/**
+ * @brief	Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
+
+/**
+ * @brief 	Interface for the local housekeeping managers used by the device
+ * 			handler.
+ */
+class HasHkPoolParametersIF {
+public:
+	virtual~ HasHkPoolParametersIF() {};
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t initializeHousekeepingPoolEntries(
+			LocalDataPoolMap& localDataPoolMap) = 0;
+	virtual float setMinimalHkSamplingFrequency() = 0;
+	virtual HousekeepingManager* getHkManagerHandle() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/housekeeping/HousekeepingManager.cpp b/housekeeping/HousekeepingManager.cpp
new file mode 100644
index 00000000..05df0ffc
--- /dev/null
+++ b/housekeeping/HousekeepingManager.cpp
@@ -0,0 +1,50 @@
+#include <framework/housekeeping/HousekeepingManager.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
+	//todo :: nullptr check owner.
+	if(owner == nullptr) {
+		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
+		std::exit(0);
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	owner->setMinimalHkSamplingFrequency();
+}
+
+HousekeepingManager::~HousekeepingManager() {}
+
+ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeHousekeepingPoolEntries(localDpMap);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+	sif::warning << "hk manager says no" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
+		CommandMessage *message) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* HousekeepingManager::getMutexHandle() {
+	return mutex;
+}
+
+void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
+	this->samplingFrequency = frequencySeconds;
+
+}
+
+void HousekeepingManager::generateHousekeepingPacket(DataSetIF *dataSet) {
+}
+
+void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
+	this->hkPacketQueue = msgQueue;
+}
diff --git a/housekeeping/HousekeepingManager.h b/housekeeping/HousekeepingManager.h
new file mode 100644
index 00000000..feec69fc
--- /dev/null
+++ b/housekeeping/HousekeepingManager.h
@@ -0,0 +1,95 @@
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/ipc/MutexIF.h>
+
+#include <framework/datapool/PoolEntry.h>
+#include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/ipc/MutexHelper.h>
+
+#include <map>
+
+
+class HousekeepingManager {
+public:
+	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
+
+	HousekeepingManager(HasHkPoolParametersIF* owner);
+	virtual~ HousekeepingManager();
+
+	MutexIF* getMutexHandle();
+
+	// propably will just call respective local data set functions.
+	void generateHousekeepingPacket(DataSetIF* dataSet);
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T>
+	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> *poolEntry);
+	void setMinimalSamplingFrequency(float frequencySeconds);
+
+	/**
+	 * This function is used to fill the local data pool map with pool
+	 * entries. The default implementation is empty.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+	void setHkPacketQueue(MessageQueueIF* msgQueue);
+private:
+	//! this depends on the PST frequency.. maybe it would be better to just
+	//! set this manually with a global configuration value which is also
+	//! passed to the PST. Or force setting this in device handler.
+	float samplingFrequency = MINIMAL_SAMPLING_FREQUENCY;
+
+	//! This is the map holding the actual data. Should only be initialized
+	//! once !
+	bool mapInitialized = false;
+	LocalDataPoolMap localDpMap;
+
+	//! Every housekeeping data manager has a mutex to protect access
+	//! to it's data pool.
+	MutexIF * mutex = nullptr;
+
+	//! The class which actually owns the manager (and its datapool).
+	HasHkPoolParametersIF* owner = nullptr;
+
+	//! Used for replies.
+	//! (maybe we dont need this, the sender can be retrieved from command
+	//! message..)
+	MessageQueueIF* hkReplyQueue = nullptr;
+	//! Used for HK packets, which are generated without requests.
+	MessageQueueIF* hkPacketQueue = nullptr;
+};
+
+template<class T> inline
+ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
+		PoolEntry<T> *poolEntry) {
+	auto poolIter = localDpMap.find(localPoolId);
+	if (poolIter == localDpMap.end()) {
+		// todo: special returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(poolEntry == nullptr) {
+		// todo: special returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
new file mode 100644
index 00000000..65d87e9e
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -0,0 +1,10 @@
+#include <framework/housekeeping/HousekeepingMessage.h>
+
+void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
+		set_t setId, store_address_t packet) {
+	message->setCommand(ADD_HK_REPORT_STRUCT);
+	message->setParameter(setId);
+	message->setParameter2(packet.raw);
+}
+
+//void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
new file mode 100644
index 00000000..80dc83a6
--- /dev/null
+++ b/housekeeping/HousekeepingMessage.h
@@ -0,0 +1,87 @@
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <limits>
+
+/**
+ * the sid consists of the target object ID and... something else I forgot.
+ * Propably a special HK id to distinguish multiple hk pool packages
+ * inside a handler or controller
+ */
+typedef uint32_t set_t;
+
+union sid_t {
+	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
+	sid_t(): raw(INVALID_ADDRESS) {}
+
+	struct {
+		object_id_t objectId ;
+		set_t hkId;
+	};
+	/**
+	 * Alternative access to the raw value.
+	 */
+	uint64_t raw;
+};
+class HousekeepingMessage {
+public:
+	/**
+	 * No instances of a message shall be created, instead
+	 * a CommandMessage instance is manipulated.
+	 */
+	HousekeepingMessage() = delete;
+	HousekeepingMessage(const HousekeepingMessage&) = delete;
+	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+
+	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
+	static constexpr Command_t ADD_HK_REPORT_STRUCT =
+			MAKE_COMMAND_ID(1);
+	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(2);
+
+	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
+	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(4);
+
+	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+			MAKE_COMMAND_ID(5);
+	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(6);
+
+	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(7);
+	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(8);
+
+	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
+	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
+			MAKE_COMMAND_ID(11);
+
+	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
+	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
+
+	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
+	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
+
+	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
+			MAKE_COMMAND_ID(27);
+	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
+			MAKE_COMMAND_ID(28);
+
+	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(29);
+	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(30);
+
+	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(31);
+	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(32);
+
+	static void setAddHkReportStructMessage(CommandMessage* message,
+			set_t setId, store_address_t packet);
+};
+
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 81c4a0e5..72ba434a 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,6 +1,6 @@
 #include "InternalErrorReporter.h"
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
@@ -20,13 +20,13 @@ InternalErrorReporter::~InternalErrorReporter() {
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 
-	DataSet mySet;
-	PoolVariable<uint32_t> queueHitsInPool(queuePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
-	PoolVariable<uint32_t> tmHitsInPool(tmPoolId, &mySet,
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 
-	PoolVariable<uint32_t> storeHitsInPool(storePoolId, &mySet,
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
 			PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 79622645..d66e956d 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,7 +1,7 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/monitoring/LimitViolationReporter.h>
 #include <framework/monitoring/MonitoringIF.h>
@@ -48,7 +48,7 @@ public:
 
 protected:
 	virtual ReturnValue_t fetchSample(T* sample) {
-		DataSet mySet;
+		GlobDataSet mySet;
 		PIDReader<T> parameter(this->parameterId, &mySet);
 		mySet.read();
 		if (!parameter.isValid()) {
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 04079bb0..eee91984 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -12,7 +12,7 @@ Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
 		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
 				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				DataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
 				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
 				ids.pidCurrent, &set), state(ids.pidState, &set), power(
 				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
diff --git a/power/Fuse.h b/power/Fuse.h
index aee03778..a826a125 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,7 +1,7 @@
 #ifndef FUSE_H_
 #define FUSE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
@@ -83,11 +83,11 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	DataSet set;
+	GlobDataSet set;
 	PIDReader<float> voltage;
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
-	db_float_t power;
+	gp_float_t power;
 	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 922560d0..566f93ca 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,7 +1,7 @@
 #ifndef POWERSENSOR_H_
 #define POWERSENSOR_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
@@ -53,12 +53,12 @@ private:
 	MessageQueueIF* commandQueue;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	DataSet set;
+	GlobDataSet set;
 	//Variables in
 	PIDReader<float> current;
 	PIDReader<float> voltage;
 	//Variables out
-	db_float_t power;
+	gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
index 304712ef..657e79cb 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/CoreComponent.cpp
@@ -2,7 +2,7 @@
 
 CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -18,14 +18,14 @@ CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
 				parameters), temperatureMonitor(reportingObjectId,
 				domainId + 1,
-				DataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
 				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
 	if (thermalModule != NULL) {
 		thermalModule->registerComponent(this, priority);
 	}
 	//Set thermal state once, then leave to operator.
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetStatePoolId, &mySet,
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
 			PoolVariableIF::VAR_WRITE);
 	writableTargetState = initialTargetState;
 	mySet.commit(PoolVariableIF::VALID);
@@ -70,8 +70,8 @@ float CoreComponent::getLowerOpLimit() {
 }
 
 ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index da77c65b..0b87d889 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,7 +1,7 @@
 #ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/thermal/AbstractTemperatureSensor.h>
@@ -23,7 +23,7 @@ public:
 
 	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, DataSet *dataSet,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
 			AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
@@ -58,10 +58,10 @@ protected:
 	AbstractTemperatureSensor *secondRedundantSensor;
 	ThermalModuleIF *thermalModule;
 
-	db_float_t temperature;
-	db_int8_t targetState;
-	db_int8_t currentState;
-	db_uint8_t heaterRequest;
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
 
 	bool isHeating;
 
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index e65560cd..65fa13a6 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,7 +1,7 @@
 #ifndef THERMALMODULE_H_
 #define THERMALMODULE_H_
 
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/events/EventReportingProxyIF.h>
@@ -23,10 +23,10 @@ public:
 	};
 
 	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, DataSet *dataSet, Parameters parameters,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
 			RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, DataSet *dataSet);
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
 
 	virtual ~ThermalModule();
 

From 5b8a6e35dcc3e36715e2eaa39345744e3b2ebaef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 13:37:50 +0200
Subject: [PATCH 0258/1292] renaming complete, pool in namespace

---
 datapool/PIDReader.h                 |  2 +-
 datapool/PoolRawAccess.cpp           |  4 ++--
 datapoolglob/DataPoolAdmin.cpp       | 10 +++++-----
 datapoolglob/GlobalDataPool.h        |  3 +++
 datapoolglob/GlobalDataSet.cpp       |  4 ++--
 datapoolglob/GlobalPoolVariable.tpp  |  4 ++--
 datapoolglob/GlobalPoolVector.h      |  4 ++--
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 devicehandlers/DeviceHandlerBase.h   |  3 ++-
 framework.mk                         |  2 ++
 thermal/TemperatureSensor.h          |  8 ++++----
 thermal/ThermalComponent.cpp         |  6 +++---
 thermal/ThermalComponent.h           |  2 +-
 thermal/ThermalModule.cpp            |  8 ++++----
 thermal/ThermalModule.h              |  6 +++---
 15 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index 3a815cee..f83fa3b9 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -17,7 +17,7 @@ protected:
 	uint8_t valid;
 	ReturnValue_t read() {
 		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(
+		PoolEntry<T>* read_out = glob::dataPool.getData<T>(
 				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index 97bdc2b3..aea84612 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -19,7 +19,7 @@ PoolRawAccess::~PoolRawAccess() {
 }
 
 ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId);
+	PoolEntryIF* read_out = glob::dataPool.getRawData(dataPoolId);
 	if (read_out != NULL) {
 		valid = read_out->getValid();
 		if (read_out->getSize() > arrayEntry) {
@@ -52,7 +52,7 @@ ReturnValue_t PoolRawAccess::read() {
 }
 
 ReturnValue_t PoolRawAccess::commit() {
-	PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId);
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->setValid(valid);
 		uint8_t array_position = arrayEntry * typeSize;
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 59bd9f30..2779ce5c 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -38,7 +38,7 @@ ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
 
 	uint8_t valid = data[4];
 
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
 
 	GlobDataSet mySet;
 	PoolRawAccess variable(poolId, 0, &mySet, PoolVariableIF::VAR_READ_WRITE);
@@ -90,8 +90,8 @@ void DataPoolAdmin::handleCommand() {
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
@@ -129,8 +129,8 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 
 ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 		uint8_t** dataPointer, uint8_t* copyHere) {
-	uint32_t poolId = ::dataPool.PIDToDataPoolId(address);
-	uint8_t arrayIndex = ::dataPool.PIDToArrayIndex(address);
+	uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
+	uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
 	GlobDataSet testSet;
 	PoolRawAccess varToGetSize(poolId, arrayIndex, &testSet,
 			PoolVariableIF::VAR_READ);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index e0c086ad..42921a77 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -142,5 +142,8 @@ public:
 };
 
 //We assume someone globally instantiates a DataPool.
+namespace glob {
 extern GlobalDataPool dataPool;
+}
+
 #endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 7409dbbd..6e09a398 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -111,11 +111,11 @@ ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
-	return ::dataPool.freeDataPoolLock();
+	return glob::dataPool.freeDataPoolLock();
 }
 
 ReturnValue_t GlobDataSet::lockDataPool() {
-	return ::dataPool.lockDataPool();
+	return glob::dataPool.lockDataPool();
 }
 
 ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index 287f06dd..21b648e6 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -13,7 +13,7 @@ inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
 
 template <class T>
 inline ReturnValue_t GlobPoolVar<T>::read() {
-	PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
 	if (read_out != NULL) {
 		valid = read_out->valid;
 		value = *(read_out->address);
@@ -29,7 +29,7 @@ inline ReturnValue_t GlobPoolVar<T>::read() {
 
 template <class T>
 inline ReturnValue_t GlobPoolVar<T>::commit() {
-	PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
+	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->valid = valid;
 		*(write_back->address) = value;
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 47381aec..8d2488ea 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -50,7 +50,7 @@ protected:
 	 * 			The operation does NOT provide any mutual exclusive protection by itself.
 	 */
 	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
+		PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
 				vector_size);
 		if (read_out != NULL) {
 			this->valid = read_out->valid;
@@ -74,7 +74,7 @@ protected:
 	 *
 	 */
 	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
+		PoolEntry<T>* write_back = glob::dataPool.getData<T>(this->dataPoolId,
 				vector_size);
 		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
 			write_back->valid = valid;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0549bd45..740bb383 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1141,7 +1141,7 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 }
 
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	ReturnValue_t result = acceptExternalDeviceCommands();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 379992b1..82cf6cab 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -482,7 +482,8 @@ public:
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
diff --git a/framework.mk b/framework.mk
index 6f64b720..cb3e4f22 100644
--- a/framework.mk
+++ b/framework.mk
@@ -8,6 +8,8 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 96dedc99..cd277784 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -2,7 +2,7 @@
 #define TEMPERATURESENSOR_H_
 
 #include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/datapool/DataSet.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/monitoring/LimitMonitor.h>
 
 /**
@@ -68,12 +68,12 @@ public:
 	TemperatureSensor(object_id_t setObjectid,
 			inputType *inputValue, PoolVariableIF *poolVariable,
 			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			DataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
 			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
 			inputValue(inputValue), poolVariable(poolVariable),
 			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
 			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				DataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
 				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
 				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
 			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
@@ -111,7 +111,7 @@ protected:
 
 	PoolVariableIF *poolVariable;
 
-	PoolVariable<float> outputTemperature;
+	gp_float_t outputTemperature;
 
 	LimitMonitor<limitType> sensorMonitor;
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index ffe7ba7b..d7024662 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -3,7 +3,7 @@
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		uint8_t domainId, uint32_t temperaturePoolId,
 		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, DataSet* dataSet,
+		uint32_t requestPoolId, GlobDataSet* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -22,8 +22,8 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
 	mySet.read();
 	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index afe9aa10..195f03b1 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -44,7 +44,7 @@ public:
 	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
 			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
-			DataSet *dataSet, AbstractTemperatureSensor *sensor,
+			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 24a4c90d..9dc1f237 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -6,7 +6,7 @@
 
 ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		DataSet *dataSet, Parameters parameters,
+		GlobDataSet *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters(parameters), moduleTemperature(
@@ -16,7 +16,7 @@ ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, DataSet* dataSet) :
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
 		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
 				false), parameters( { 0, 0 }), moduleTemperature(
 				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
@@ -250,8 +250,8 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	DataSet mySet;
-	PoolVariable<int8_t> writableTargetState(targetState.getDataPoolId(),
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_WRITE);
 	if (on) {
 		writableTargetState = STATE_REQUEST_HEATING;
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 65fa13a6..b9e8d8b8 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -70,12 +70,12 @@ protected:
 
 	Parameters parameters;
 
-	db_float_t moduleTemperature;
+	gp_float_t moduleTemperature;
 
 	RedundantHeater *heater;
 
-	db_int8_t currentState;
-	db_int8_t targetState;
+	gp_int8_t currentState;
+	gp_int8_t targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;

From 9056ad36ed69575e499376558839d0bc044ca4d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 14:13:31 +0200
Subject: [PATCH 0259/1292] object manager better output

---
 datapoolglob/GlobalPoolVector.h | 3 +++
 objectmanager/ObjectManager.cpp | 6 +++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 8d2488ea..63536934 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -220,4 +220,7 @@ public:
 	}
 };
 
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
 #endif /* POOLVECTOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 2f99e1a5..1912715d 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -67,9 +67,9 @@ void ObjectManager::initialize() {
 		return_value = it->second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it->first;
-			sif::error << "Object " << std::hex <<  (int) var
-			        << " failed to initialize with code 0x" << return_value
-			        << std::dec << std::endl;
+			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
+					std::setfill('0')<< var << " failed to initialize " <<
+					"with code 0x" << return_value << std::dec << std::endl;
 			error_count++;
 		}
 	}

From e9a4056deb17756f70973d6f383182fbabdf90b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:19:24 +0200
Subject: [PATCH 0260/1292] added DHB cookie init
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

(why was that never a problem beofre????) ¯\_(ツ)_/¯
---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 740bb383..22224c12 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -23,8 +23,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		deviceCommunicationId(deviceCommunication), deviceThermalStatePoolId(
-		thermalStatePoolId),deviceThermalRequestPoolId(thermalRequestPoolId),
+		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		deviceThermalStatePoolId(thermalStatePoolId),
+		deviceThermalRequestPoolId(thermalRequestPoolId),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),

From da972e1b5823cde5cfdf4611e42736d6e8bf7b11 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:41:42 +0200
Subject: [PATCH 0261/1292] DHB improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 173 +++++------
 devicehandlers/DeviceHandlerBase.h   | 442 ++++++++++++++-------------
 2 files changed, 310 insertions(+), 305 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 710e97d7..63c7951c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PoolVariable.h>
-#include <framework/datapool/PoolVector.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/SubsystemBase.h>
 #include <framework/thermal/ThermalComponentIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+
+#include <framework/datapool/DataSet.h>
+#include <framework/datapool/PoolVariable.h>
+#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
+#include <framework/globalfunctions/CRC.h>
+#include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -17,29 +17,29 @@ object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie_,
+		object_id_t deviceCommunication, CookieIF * comCookie,
 		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
 		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
 		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-	    deviceCommunicationId(deviceCommunication), comCookie(comCookie_),
-		deviceThermalStatePoolId(thermalStatePoolId), deviceThermalRequestPoolId(thermalRequestPoolId),
-		healthHelper(this, setObjectId), modeHelper(this), parameterHelper(this),
-		fdirInstance(fdirInstance), hkSwitcher(this),
-		defaultFDIRUsed(fdirInstance == nullptr), switchOffWasReported(false),
-		executingTask(nullptr), actionHelper(this, nullptr), cookieInfo(),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch)
-{
-	commandQueue = QueueFactory::instance()->
-			createMessageQueue(cmdQueueSize, CommandMessage::MAX_MESSAGE_SIZE);
+		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		deviceThermalStatePoolId(thermalStatePoolId),
+		deviceThermalRequestPoolId(thermalRequestPoolId),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
+		switchOffWasReported(false), actionHelper(this, nullptr), cookieInfo(),
+		childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
+		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
 	if (this->fdirInstance == nullptr) {
-		this->fdirInstance =
-				new DeviceHandlerFailureIsolation(setObjectId,
-						defaultFDIRParentId);
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFDIRParentId);
 	}
 }
 
@@ -53,7 +53,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
-	if (counter == 0) {
+
+	if (getComAction() == SEND_WRITE) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -66,7 +67,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
-
 	switch (getComAction()) {
 	case SEND_WRITE:
 		if ((cookieInfo.state == COOKIE_UNUSED)) {
@@ -87,7 +87,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	default:
 		break;
 	}
-
 	return RETURN_OK;
 }
 
@@ -116,7 +115,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == nullptr) {
+	if (rawReceiver == NULL) {
 		return RETURN_FAILED;
 	}
 
@@ -166,6 +165,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	mySet.commit(PoolVariableIF::VALID);
 
 	return RETURN_OK;
+
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -353,11 +353,11 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
 	info.command = deviceCommandMap.end();
-	std::pair<DeviceReplyIter, bool> result = deviceReplyMap.emplace(replyId, info);
-	if (result.second) {
-		return RETURN_OK;
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
+	if (resultPair.second) {
+		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -366,11 +366,11 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.expectedReplies = 0;
 	info.isExecuting = false;
 	info.sendReplyTo = NO_COMMANDER;
-	std::pair<DeviceCommandIter, bool> result = deviceCommandMap.emplace(deviceCommand,info);
-	if (result.second) {
-		return RETURN_OK;
+	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
+	if (resultPair.second) {
+		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -487,7 +487,7 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		return;
 	}
 //Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo * info = &(iter->second.command->second);
+	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
 		//Check if it was transition or internal command. Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
@@ -526,6 +526,7 @@ void DeviceHandlerBase::doGetWrite() {
 		if (wiretappingMode == RAW) {
 			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
 		}
+
 		//We need to distinguish here, because a raw command never expects a reply.
 		//(Could be done in eRIRM, but then child implementations need to be careful.
 		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
@@ -541,25 +542,22 @@ void DeviceHandlerBase::doGetWrite() {
 }
 
 void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result = RETURN_FAILED;
+	ReturnValue_t result;
+
 	size_t requestLen = 0;
-	// If the device handler can only request replies after a command
-	// has been sent, there should be only one reply enabled and the
-	// correct reply length will be mapped.
-	for(DeviceReplyIter iter = deviceReplyMap.begin();
-			iter != deviceReplyMap.end();iter++)
-	{
-		if(iter->second.delayCycles != 0) {
-			requestLen = iter->second.replyLen;
-			break;
-		}
+	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
+	if(iter != deviceReplyMap.end()) {
+		requestLen = iter->second.replyLen;
+	}
+	else {
+		requestLen = 0;
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
 	if (result == RETURN_OK) {
 		cookieInfo.state = COOKIE_READ_SENT;
-	}
-	else {
+	} else {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
 		//We can't inform anyone, because we don't know which command was sent last.
 		//So, we need to wait for a timeout.
@@ -583,8 +581,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie, &receivedData,
-			&receivedDataLen);
+	result = communicationInterface->readReceivedMessage(comCookie,
+			&receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -644,7 +642,7 @@ void DeviceHandlerBase::doGetRead() {
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t ** data, size_t * len) {
+		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == NULL) {
@@ -663,10 +661,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		*len = 0;
 		return result;
 	}
-
 }
 
-
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
 	if (IPCStore == NULL || len == 0) {
@@ -681,6 +677,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	}
 
 	CommandMessage message;
+
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
 			getObjectId(), address, isCommand);
 
@@ -690,14 +687,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 
 	if (result != RETURN_OK) {
 		IPCStore->deleteData(address);
-		// Silently discard data, this indicates heavy TM traffic which should
-		// not be increased by additional events.
+		//Silently discard data, this indicates heavy TM traffic which should not be increased by additional events.
 	}
 }
 
 //Default child implementations
-
-DeviceHandlerBase::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
 		return SEND_WRITE;
@@ -762,8 +757,8 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 //			DeviceCommunicationIF>(newChannelId);
 //
 //	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, logicalAddress,
-//				maxDeviceReplyLen, comParameter1, comParameter2);
+//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
+//				maxDeviceReplyLen);
 //		if (result != RETURN_OK) {
 //			return result;
 //		}
@@ -780,8 +775,8 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
 		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
 	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.
-				find((DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
 		cookieInfo.pendingCommand->second.isExecuting = true;
 		cookieInfo.state = COOKIE_WRITE_READY;
 	}
@@ -820,7 +815,7 @@ ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
 		iter = deviceReplyMap.find(command->first);
 	}
 	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo * info = &(iter->second);
+		DeviceReplyInfo *info = &(iter->second);
 		info->delayCycles = info->maxDelayCycles;
 		info->command = command;
 		command->second.expectedReplies = expectedReplies;
@@ -846,9 +841,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
 	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
 		while (numberOfSwitches > 0) {
-			if (powerSwitcher-> getSwitchState(switches[numberOfSwitches - 1])
-				== PowerSwitchIF::SWITCH_OFF)
-			{
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
 				return PowerSwitchIF::SWITCH_OFF;
 			}
 			numberOfSwitches--;
@@ -1032,7 +1026,6 @@ void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
 
 ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		CommandMessage * message) {
-	ReturnValue_t result;
 	switch (message->getCommand()) {
 	case DeviceHandlerMessage::CMD_WIRETAPPING:
 		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
@@ -1054,21 +1047,19 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_SWITCH_ADDRESS:
-		if (mode != MODE_OFF) {
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			// rework in progress
-			result = RETURN_OK;
-			//result = switchCookieChannel(
-			//		DeviceHandlerMessage::getIoBoardObjectId(message));
-			if (result == RETURN_OK) {
-				replyReturnvalueToCommand(RETURN_OK);
-			} else {
-				replyReturnvalueToCommand(CANT_SWITCH_ADDRESS);
-			}
-		}
-		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+//			result = switchCookieChannel(
+//					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
@@ -1124,7 +1115,8 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 
 			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
 			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+			true);
 
 		}
 	} else { //unrequested/aperiodic replies
@@ -1152,7 +1144,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-
 	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
 	if (iter == deviceCommandMap.end()) {
 		result = COMMAND_NOT_SUPPORTED;
@@ -1171,7 +1162,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
 }
 
 void DeviceHandlerBase::buildInternalCommand(void) {
-	// Neither Raw nor Direct could build a command
+//Neither Raw nor Direct could build a command
 	ReturnValue_t result = NOTHING_TO_SEND;
 	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
 	if (mode == MODE_NORMAL) {
@@ -1189,13 +1180,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	} else {
 		return;
 	}
-
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}
 	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter =
-				deviceCommandMap.find(deviceCommandId);
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
@@ -1210,7 +1200,6 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			cookieInfo.state = COOKIE_WRITE_READY;
 		}
 	}
-
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
 	}
@@ -1285,8 +1274,8 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 			executingTask = task_;
 }
 
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId, uint32_t parameter) {
-}
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {
-}
+void DeviceHandlerBase::performOperationHook() {}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 25ec75b9..e7a8032d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,26 +1,23 @@
 #ifndef DEVICEHANDLERBASE_H_
 #define DEVICEHANDLERBASE_H_
 
-#include <framework/action/ActionHelper.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/action/HasActionsIF.h>
-#include <framework/datapool/DataSet.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/health/HealthHelper.h>
 #include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
 #include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
+
+#include <framework/action/ActionHelper.h>
+#include <framework/health/HealthHelper.h>
+#include <framework/parameters/ParameterHelper.h>
+#include <framework/datapool/HkSwitchHelper.h>
+#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+
 #include <map>
 
 namespace Factory{
@@ -92,21 +89,22 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the largest allowed reply size
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
 	 * @param setDeviceSwitch the switch the device is connected to,
-	 *    for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is
-	 *    used to implement communication functions
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie_, uint8_t setDeviceSwitch,
+			CookieIF * comCookie, uint8_t setDeviceSwitch,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -213,12 +211,13 @@ protected:
 	/**
 	 * Build the device command to send for normal mode.
 	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for @c MODE_NORMAL are supported,
-	 * different commands can built returned depending on the submode.
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 * If variable command frequence is required, a counter can be used and
-	 * the frequency in the reply map has to be set manually
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
 	 * by calling updateReplyMap().
 	 *
 	 * @param[out] id the device command id that has been built
@@ -233,10 +232,13 @@ protected:
 	 * Build the device command to send for a transitional mode.
 	 *
 	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp() and doShutDown() as well as doTransition()
+	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition()
 	 *
-	 * A good idea is to implement a flag indicating a command has to be built and a variable containing the command number to be built
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no modes have to be checked here.
+	 * A good idea is to implement a flag indicating a command has to be built
+	 * and a variable containing the command number to be built
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
 	 *
 	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
 	 *
@@ -266,6 +268,63 @@ protected:
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
 
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c RETURN_FAILED when the reply could not be interpreted,
+	 *     e.g. logical errors or range violations occurred
+	 */
+
+	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+			const uint8_t *packet) = 0;
+
 	/**
 	 * @brief fill the #deviceCommandMap
 	 *	 	  called by the initialize() of the base class
@@ -312,85 +371,83 @@ protected:
 	virtual void fillCommandAndReplyMap() = 0;
 
 	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data.
-	 * No information check is done, e.g. range checks etc.
-	 *
-	 * Errors should be reported directly,  the base class does NOT report
-	 * any errors based on the returnvalue of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 * buffer is scanned at previous position + foundLen.
-	 * @return
-	 *     - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *     - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *             implies @c foundLen is not valid,
-	 *             base class will call scanForReply() again with ++start
-	 *     - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *             e.g. checksum error, implies @c foundLen is valid, can be used to skip some bytes
-	 *     - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *     - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of the packet
-	 *     - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *     - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *             requested by a command, but should be handled anyway
-	 *             (@see also fillCommandAndCookieMap() )
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then calls handleDeviceTM(), which either sends
-	 * a TM packet or stores the data in the DataPool depending on whether the it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted, eg. logical errors or range violations occurred
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
 	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
 	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			uint8_t periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
 	 * @details Example: Calling this in performOperation
 	 *          to track values like mode.
-	 * @param 	positionTracker Provide the child handler a way to know where the debugInterface was called
-	 * @param 	objectId Provide the child handler object Id to specify actions for spefic devices
-	 * @param 	parameter Supply a parameter of interest
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
 	 * Please delete all debugInterface calls in DHB after debugging is finished !
 	 */
-	virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0, uint32_t parameter = 0);
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
 
 	/**
 	 * Get the time needed to transit from modeFrom to modeTo.
 	 *
 	 * Used for the following transitions:
 	 * modeFrom -> modeTo:
-	 *  - MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 *  - _MODE_START_UP -> MODE_ON (do not include time to set the switches, the base class got you covered)
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
 	 *
 	 * The default implementation returns 0 !
 	 * @param modeFrom
@@ -408,40 +465,25 @@ protected:
 	 * @param[out] numberOfSwitches length of returned array
 	 * @return
 	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c NO_SWITCH or any other returnvalue if no switches exist
+	 *      - @c RETURN_FAILED if no switches exist
 	 */
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
 	/**
-	 * Can be used to perform device specific periodic operations.
-	 * This is called on the SEND_READ step of the performOperation() call
+	 * @brief 	Hook function for child handlers which is called once per
+	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
-
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
 public:
 	/**
 	 * @param parentQueueId
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-	/**
-	 * This function call handles the execution of external commands as required
-	 * by the HasActionIF.
-	 * @param actionId
-	 * @param commandedBy
-	 * @param data
-	 * @param size
-	 * @return
-	 */
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -460,6 +502,28 @@ public:
 	virtual MessageQueueId_t getCommandQueue(void) const;
 
 protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	/**
+	 * These returnvalues can be returned from abstract functions
+	 * to alter the behaviour of DHB.For error values, refer to
+	 * DeviceHandlerIF.h returnvalues.
+	 */
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+
+//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
+//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+
 	//Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
@@ -475,7 +539,7 @@ protected:
 	/**
 	 * Size of the #rawPacket.
 	 */
-	size_t rawPacketLen = 0;
+	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
@@ -502,7 +566,7 @@ protected:
 	 * indicates either that all raw messages to and from the device should be sent to #theOneWhoWantsToReadRawTraffic
 	 * or that all device TM should be downlinked to #theOneWhoWantsToReadRawTraffic
 	 */
-	enum WiretappingMode: uint8_t {
+	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
 
@@ -543,21 +607,19 @@ protected:
 	/**
 	 * Communication object used for device communication
 	 */
-	DeviceCommunicationIF *communicationInterface = nullptr;
+	DeviceCommunicationIF * communicationInterface = nullptr;
 
 	/**
-	 * Cookie used for communication. This is passed to the communication
-	 * interface.
+	 * Cookie used for communication
 	 */
-	CookieIF *comCookie;
+	CookieIF * comCookie;
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.
 		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
 		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
 	};
-	typedef std::map<DeviceCommandId_t, DeviceCommandInfo> DeviceCommandMap;
-	typedef DeviceCommandMap::iterator DeviceCommandIter;
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
 
 	/**
 	 * @brief Information about expected replies
@@ -568,15 +630,12 @@ protected:
 		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
 		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
 		size_t replyLen = 0; //!< Expected size of the reply.
-		//(Robin): This is a flag, isnt it? could we declare it bool? uint8_t always
-		// gives away the impression that this variable is more than a simple flag
-		// and true/false are also more explicit.
 		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
 		DeviceCommandMap::iterator command; //!< The command that expects this reply.
 	};
 
-	typedef std::map<DeviceCommandId_t, DeviceReplyInfo> DeviceReplyMap;
-	typedef DeviceReplyMap::iterator DeviceReplyIter;
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
 
 	/**
 	 * The MessageQueue used to receive device handler commands and to send replies.
@@ -610,7 +669,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = RETURN_OK;
+	ReturnValue_t childTransitionFailure = HasReturnvaluesIF::RETURN_OK;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 
@@ -622,35 +681,13 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
 
 	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
 
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
 	static object_id_t defaultFDIRParentId; //!< Object which may be the root cause of an identified fault.
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -671,14 +708,30 @@ protected:
 	void replyReturnvalueToCommand(ReturnValue_t status,
 			uint32_t parameter = 0);
 
-	/**
-	 * Send reply to a command, differentiate between raw command
-	 * and normal command.
-	 * @param status
-	 * @param parameter
-	 */
 	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
 
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
@@ -708,55 +761,6 @@ protected:
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command waits until it times out.
-	 * @param periodic	Indicates if the reply is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @param hasDifferentReplyId
-	 * @param replyId
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-	/**
-	 * This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 			Default is aperiodic (0)
-	 * @return	RETURN_OK when the command was successfully inserted, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
-	/**
-	 * A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return RETURN_OK if the command was successfully inserted, RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * This is a helper method to facilitate updating entries in the reply map.
-	 * @param deviceCommand		Identifier of the reply to update.
-	 * @param delayCycles		The current number of delay cycles to wait. As stated in #fillCommandAndCookieMap, to disable periodic commands, this is set to zero.
-	 * @param maxDelayCycles	The maximum number of delay cycles the reply waits until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic			Indicates if the command is periodic (i.e. it is sent by the device repeatedly without request) or not.
-	 *		 					Default is aperiodic (0). Warning: The setting always overrides the value that was entered in the map.
-	 * @return	RETURN_OK when the reply was successfully updated, COMMAND_MAP_ERROR else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
 	/**
 	 * Is the combination of mode and submode valid?
 	 *
@@ -776,6 +780,7 @@ protected:
 	 *
 	 * @return The Rmap action to execute in this step
 	 */
+
 	virtual CommunicationAction_t getComAction();
 
 	/**
@@ -798,6 +803,14 @@ protected:
 	 */
 	virtual ReturnValue_t buildChildRawCommand();
 
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
 	/**
 	 * Construct a command reply containing a raw reply.
 	 *
@@ -861,6 +874,14 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */
@@ -889,6 +910,7 @@ protected:
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 	virtual void setToExternalControl();
 	virtual void announceMode(bool recursive);
+
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
@@ -954,13 +976,12 @@ protected:
 	DeviceCommandMap deviceCommandMap;
 
 	ActionHelper actionHelper;
-
 private:
 
 	/**
 	 * State a cookie is in.
 	 *
-	 * Used to keep track of the state of the communication.
+	 * Used to keep track of the state of the RMAP communication.
 	 */
 	enum CookieState_t {
 		COOKIE_UNUSED,    //!< The Cookie is unused
@@ -1034,20 +1055,22 @@ private:
 	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
 	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
 	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 * - Maybe export this into own class to increase modularity of software
-	 *   and reduce the massive class size ?
 	 */
 	void doStateMachine(void);
 
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
 	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
 	 * but not received).
-	 * In case the reply is periodic, the counter is simply set back to a specified value.
 	 */
 	void decrementDeviceReplyMap(void);
 
@@ -1114,8 +1137,8 @@ private:
 	 *   - @c RETURN_FAILED IPCStore is NULL
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress,
-			uint8_t ** data, size_t * len);
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
 
 	/**
 	 * set all switches returned by getSwitches()
@@ -1144,16 +1167,9 @@ private:
 	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
-	//ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
-	/**
-	 * Handle device handler messages (e.g. commands sent by PUS Service 2)
-	 * @param message
-	 * @return
-	 */
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */

From 9597a0121ba7177b7b18beca9319c37be0f230d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 15:49:46 +0200
Subject: [PATCH 0262/1292] DHB update

---
 devicehandlers/DeviceHandlerBase.cpp | 9 +++++----
 devicehandlers/DeviceHandlerBase.h   | 4 +++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 63c7951c..16be66fa 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -44,6 +44,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
+	//communicationInterface->close(cookie);
 	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
@@ -355,9 +356,9 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
-		return HasReturnvaluesIF::RETURN_OK;
+		return RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return RETURN_FAILED;
 	}
 }
 
@@ -368,9 +369,9 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 	info.sendReplyTo = NO_COMMANDER;
 	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
 	if (resultPair.second) {
-		return HasReturnvaluesIF::RETURN_OK;
+		return RETURN_OK;
 	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return RETURN_FAILED;
 	}
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e7a8032d..454f0751 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -481,9 +481,11 @@ public:
 	 */
 	virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
+	/** @brief 	Implementation required for HasActionIF */
 	ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data,
 			size_t size) override;
+
 	Mode_t getTransitionSourceMode() const;
 	Submode_t getTransitionSourceSubMode() const;
 	virtual void getMode(Mode_t *mode, Submode_t *submode);
@@ -669,7 +671,7 @@ protected:
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
 	 */
-	ReturnValue_t childTransitionFailure = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t childTransitionFailure;
 
 	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
 

From 0467b6a1bf60481b74850096c60fc09304bb7ee6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 17:53:18 +0200
Subject: [PATCH 0263/1292] slight DHB improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 16be66fa..23ec1f18 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -12,6 +12,8 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+#include <iomanip>
+
 object_id_t DeviceHandlerBase::powerSwitcherId = 0;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
@@ -37,6 +39,12 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
+	if (comCookie == nullptr) {
+		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex <<
+				std::setw(8) << std::setfill('0') << this->getObjectId() <<
+				std::dec << ": Do not pass nullptr as a cookie, consider "
+				"passing a dummy cookie instead!" << std::endl;
+	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
 				defaultFDIRParentId);
@@ -44,7 +52,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	//communicationInterface->close(cookie);
 	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
@@ -646,8 +653,8 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 		uint8_t * *data, uint32_t * len) {
 	size_t lenTmp;
 
-	if (IPCStore == NULL) {
-		*data = NULL;
+	if (IPCStore == nullptr) {
+		*data = nullptr;
 		*len = 0;
 		return RETURN_FAILED;
 	}
@@ -658,7 +665,7 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 	} else {
 		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
 				storageAddress.raw);
-		*data = NULL;
+		*data = nullptr;
 		*len = 0;
 		return result;
 	}

From 8b1fef730dcb4cd4f21c3f90121b1c6a74758f63 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 18:02:58 +0200
Subject: [PATCH 0264/1292] resolved conflict

---
 devicehandlers/DeviceHandlerBase.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c48fbe5e..454f0751 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -614,11 +614,7 @@ protected:
 	/**
 	 * Cookie used for communication
 	 */
-<<<<<<< HEAD
-	CookieIF * comCookie = nullptr;
-=======
 	CookieIF * comCookie;
->>>>>>> mueller_framework
 
 	struct DeviceCommandInfo {
 		bool isExecuting; //!< Indicates if the command is already executing.

From 9da0b0b2b299b7abeb9b73dd8fdb624942de996c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 22:16:25 +0200
Subject: [PATCH 0265/1292] glob pool vec implementation in tpp file

---
 datapoolglob/GlobalPoolVector.h   | 270 ++++++++++++------------------
 datapoolglob/GlobalPoolVector.tpp |  83 +++++++++
 2 files changed, 186 insertions(+), 167 deletions(-)
 create mode 100644 datapoolglob/GlobalPoolVector.tpp

diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 63536934..d55fd777 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef POOLVECTOR_H_
-#define POOLVECTOR_H_
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
@@ -8,139 +8,79 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 /**
- * \brief	This is the access class for array-type data pool entries.
+ * @brief	This is the access class for array-type data pool entries.
  *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type- and length-safe access
- * 			to vector-style data pool entries (i.e. entries with length > 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that no array entry in
- * 			the data pool is changed until the commit call is executed.
- * 			There are two template parameters:
- * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
- * 			plain data types are supported, but in principle any type is possible.
- * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
- * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
- *	\ingroup data_pool
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
  */
-template<typename T, uint16_t vector_size>
+template<typename T, uint16_t vectorSize>
 class GlobPoolVector: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-
-protected:
-	/**
-	 * \brief	This is a call to read the array's values from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies all array values and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type, size or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if (read_out != NULL) {
-			this->valid = read_out->valid;
-			memcpy(this->value, read_out->address, read_out->getByteSize());
-
-			return HasReturnvaluesIF::RETURN_OK;
-
-		} else {
-			memset(this->value, 0, vector_size * sizeof(T));
-			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			this->valid = INVALID;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call copies the array values back to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = glob::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			memcpy(write_back->address, this->value, write_back->getByteSize());
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
 public:
 	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \detials	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vector_size];
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
 	 */
 	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-		memset(this->value, 0, vector_size * sizeof(T));
-		if (set != NULL) {
-			set->registerVariable(this);
-		}
-	}
+			ReadWriteMode_t setReadWriteMode);
+
 	/**
-	 * Copy ctor to copy classes containing Pool Variables.
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
 	 */
-//	PoolVector(const PoolVector& rhs) {
-//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
-//		memcpy(value, rhs.value, sizeof(T)*vector_size);
-//	}
+	T value[vectorSize];
 	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
 	 * 			discarded and not written back to the data pool.
 	 */
-	~GlobPoolVector() {
-	}
-	;
+	~GlobPoolVector() {};
 	/**
-	 * \brief	The operation returns the number of array entries in this variable.
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
 	 */
 	uint8_t getSize() {
-		return vector_size;
+		return vectorSize;
 	}
 	/**
-	 * \brief	This operation returns the data pool id of the variable.
+	 * @brief	This operation returns the data pool id of the variable.
 	 */
 	uint32_t getDataPoolId() const {
 		return dataPoolId;
 	}
 	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
 	 */
 	void setDataPoolId(uint32_t poolId) {
 		dataPoolId = poolId;
@@ -151,9 +91,10 @@ public:
 	ReadWriteMode_t getReadWriteMode() const {
 		return readWriteMode;
 	}
-	;
+
+
 	/**
-	 * \brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the variable is returned.
 	 */
 	bool isValid() const {
 		if (valid != INVALID)
@@ -161,65 +102,60 @@ public:
 		else
 			return false;
 	}
+	void setValid(uint8_t valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
 
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	T &operator [](int i) {
-		return value[i];
-	}
-
-	const T &operator [](int i) const {
-		return value[i];
-	}
-
-	GlobPoolVector<T, vector_size> &operator=(
-			GlobPoolVector<T, vector_size> newPoolVector) {
-
-		for (uint16_t i = 0; i < vector_size; i++) {
-			this->value[i] = newPoolVector.value[i];
-		}
-		return *this;
-	}
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
-	}
+			const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
+			bool bigEndian) override;
+protected:
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid. The operation does NOT provide
+	 * any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t read();
+
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 */
+	ReturnValue_t commit();
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
 };
 
+#include <framework/datapoolglob/GlobalPoolVector.tpp>
+
 template<typename T, uint16_t vectorSize>
 using gp_vec_t = GlobPoolVector<T, vectorSize>;
 
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
new file mode 100644
index 00000000..0b43191b
--- /dev/null
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -0,0 +1,83 @@
+#ifndef GLOBALPOOLVECTOR_TPP_
+#define GLOBALPOOLVECTOR_TPP_
+
+
+template<typename T, uint16_t vectorSize>
+inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
+		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
+	memset(this->value, 0, vectorSize * sizeof(T));
+	if (set != nullptr) {
+		set->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
+	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if (read_out != nullptr) {
+		this->valid = read_out->valid;
+		memcpy(this->value, read_out->address, read_out->getByteSize());
+
+		return HasReturnvaluesIF::RETURN_OK;
+
+	} else {
+		memset(this->value, 0, vectorSize * sizeof(T));
+		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << dataPoolId <<
+				std::dec << " failed." << std::endl;
+		this->valid = INVALID;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit() {
+	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
+			vectorSize);
+	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
+		writeBack->valid = valid;
+		memcpy(writeBack->address, this->value, writeBack->getByteSize());
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+				max_size, bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size, bool bigEndian) {
+	uint16_t i;
+	ReturnValue_t result;
+	for (i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+#endif

From 71f1722b886d002a0b8fe550771ee1ed4cde1cc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 22:20:54 +0200
Subject: [PATCH 0266/1292] removed old poolVar file

---
 datapool/PoolVariable.h                 | 294 ------------------------
 datapoolglob/GlobalPoolVariable.h       |   4 +-
 datapoolglob/GlobalPoolVariable.tpp     |   5 +-
 datapoolglob/GlobalPoolVector.h         |   1 -
 devicehandlers/DeviceHandlerBase.cpp    |   2 +-
 internalError/InternalErrorReporter.cpp |   2 +-
 power/PowerSensor.h                     |   2 +-
 thermal/CoreComponent.h                 |   2 +-
 thermal/ThermalModule.h                 |   2 +-
 9 files changed, 11 insertions(+), 303 deletions(-)
 delete mode 100644 datapool/PoolVariable.h

diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h
deleted file mode 100644
index f5442a25..00000000
--- a/datapool/PoolVariable.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * \file	PoolVariable.h
- *
- * \brief	This file contains the PoolVariable class, which locally represents a non-array data pool variable.
- *
- * \date	10/17/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVARIABLE_H_
-#define POOLVARIABLE_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-/**
- * \brief	This is the access class for non-array data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type-safe access to single
- * 			data pool entries (i.e. entries with length = 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that the variable's value in
- * 			the data pool is not changed until the commit call is executed.
- * 	\tparam	T The template parameter sets the type of the variable. Currently, all plain data types
- * 			are supported, but in principle any type is possible.
- *	\ingroup data_pool
- */
-template<typename T>
-class PoolVariable: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-protected:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = *(read_out->address);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1);
-		if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			*(write_back->address) = value;
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PoolVariable() :
-			dataPoolId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), readWriteMode(VAR_READ), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setReadWriteMode
-	 */
-	PoolVariable(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
-					setReadWriteMode), value(0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PoolVariable(const PoolVariable& rhs) :
-			dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-					rhs.readWriteMode), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVariable() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	PoolVariable<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	PoolVariable<T> &operator=(PoolVariable<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
-	}
-};
-
-typedef PoolVariable<uint8_t> db_uint8_t;
-typedef PoolVariable<uint16_t> db_uint16_t;
-typedef PoolVariable<uint32_t> db_uint32_t;
-typedef PoolVariable<int8_t> db_int8_t;
-typedef PoolVariable<int16_t> db_int16_t;
-typedef PoolVariable<int32_t> db_int32_t;
-typedef PoolVariable<uint8_t> db_bool_t;
-typedef PoolVariable<float> db_float_t;
-typedef PoolVariable<double> db_double_t;
-//Alternative (but I thing this is not as useful: code duplication, differences too small):
-
-//template <typename T>
-//class PoolReader : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//	uint8_t valid;
-//public:
-//	T value;
-//	PoolReader( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), valid(false), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolReader() {};
-//
-//	uint8_t commit() {
-//			return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			valid = read_out->valid;
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			valid = false;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return false; };
-//	bool isValid() { if (valid) return true; else return false; }
-//};
-//
-//template <typename T>
-//class PoolWriter : public PoolVariableIF {
-//private:
-//	uint32_t parameter_id;
-//public:
-//	T value;
-//	PoolWriter( uint32_t set_id, DataSetIF* set ) : parameter_id(set_id), value(0) {
-//		set->registerVariable( this );
-//	}
-//
-//	~PoolWriter() {};
-//
-//	uint8_t commit() {
-//		PoolEntry<T>* write_back = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( write_back != NULL ) {
-//			write_back->valid = true;
-//			*(write_back->address) = value;
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint8_t read() {
-//		PoolEntry<T>* read_out = ::dataPool.getData<T>( parameter_id, 1 );
-//		if ( read_out != NULL ) {
-//			value = *(read_out->address);
-//			return HasReturnvaluesIF::RETURN_OK;
-//		} else {
-//			value = 0;
-//			return CHECKOUT_FAILED;
-//		}
-//	}
-//	uint32_t getParameterId() { return parameter_id; }
-//	bool isWritable() { return true; };
-//	bool isValid() { return false; }
-//};
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index 9f80492b..eee9afc1 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,5 +1,5 @@
-#ifndef POOLVARIABLE_H_
-#define POOLVARIABLE_H_
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
 
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index 21b648e6..d55ea4e0 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef GLOBALPOOLVARIABLE_TPP_
+#define GLOBALPOOLVARIABLE_TPP_
 
 template <class T>
 inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
@@ -82,3 +83,5 @@ template <class T>
 inline void GlobPoolVar<T>::setValid(uint8_t valid) {
 	this->valid = valid;
 }
+
+#endif
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index d55fd777..24303457 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -111,7 +111,6 @@ public:
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
-
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 protected:
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 5bd4c56e..f46f854b 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -5,7 +5,7 @@
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
 #include <framework/subsystem/SubsystemBase.h>
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 72ba434a..a1e96695 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,7 +1,7 @@
 #include "InternalErrorReporter.h"
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 566f93ca..f94088a8 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -3,7 +3,7 @@
 
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapool/PIDReader.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/LimitMonitor.h>
 #include <framework/parameters/ParameterHelper.h>
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index 0b87d889..a0736c71 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -2,7 +2,7 @@
 #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/thermal/ThermalModule.h>
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index b9e8d8b8..21414f15 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -2,7 +2,7 @@
 #define THERMALMODULE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PoolVariable.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/events/EventReportingProxyIF.h>
 #include "ThermalModuleIF.h"

From 1d28e1398ea927a74a0fc492e4db468122d41afa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:41:28 +0200
Subject: [PATCH 0267/1292] DataSetBase class finished

---
 datapool/DataSetBase.cpp                | 148 ++++++++++++++++++++++++
 datapool/DataSetBase.h                  | 135 +++++++++++++++++++++
 datapool/DataSetIF.h                    |  21 ++++
 datapool/PIDReader.h                    |   2 +-
 datapool/PoolRawAccess.cpp              |   2 +-
 datapool/PoolRawAccessHelper.cpp        |   6 +-
 datapool/PoolRawAccessHelper.h          |   1 +
 datapool/PoolVariableIF.h               |   1 +
 datapoolglob/DataPoolAdmin.cpp          |   4 +-
 datapoolglob/GlobalDataSet.cpp          | 140 ++--------------------
 datapoolglob/GlobalDataSet.h            | 126 +++-----------------
 datapoolglob/GlobalPoolVariable.h       |   2 +-
 devicehandlers/DeviceHandlerBase.cpp    |   2 +-
 internalError/InternalErrorReporter.cpp |   2 +-
 power/Fuse.h                            |   1 +
 thermal/TemperatureSensor.h             |   1 +
 16 files changed, 344 insertions(+), 250 deletions(-)
 create mode 100644 datapool/DataSetBase.cpp
 create mode 100644 datapool/DataSetBase.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
new file mode 100644
index 00000000..6ff2fc83
--- /dev/null
+++ b/datapool/DataSetBase.cpp
@@ -0,0 +1,148 @@
+#include <framework/datapool/DataSetBase.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+DataSetBase::DataSetBase() {
+	for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; 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 >= DATA_SET_MAX_SIZE) {
+		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() {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	if (state == States::DATA_SET_UNINITIALISED) {
+		lockDataPool();
+		for (uint16_t count = 0; count < fillCount; count++) {
+			if (registeredVariables[count]->getReadWriteMode()
+					!= PoolVariableIF::VAR_WRITE
+					&& registeredVariables[count]->getDataPoolId()
+					!= PoolVariableIF::NO_PARAMETER) {
+				ReturnValue_t status = registeredVariables[count]->read();
+				if (status !=  HasReturnvaluesIF::RETURN_OK) {
+					result = INVALID_PARAMETER_DEFINITION;
+					break;
+				}
+			}
+		}
+		state = States::DATA_SET_WAS_READ;
+		unlockDataPool();
+	}
+	else {
+		sif::error << "DataSet::read(): "
+				"Call made in wrong position." << std::endl;
+		result = SET_WAS_ALREADY_READ;
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::commit() {
+	if (state == States::DATA_SET_WAS_READ) {
+		handleAlreadyReadDatasetCommit();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return handleUnreadDatasetCommit();
+	}
+}
+
+ReturnValue_t DataSetBase::lockDataPool() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataSetBase::unlockDataPool() {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+void DataSetBase::handleAlreadyReadDatasetCommit() {
+	lockDataPool();
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		}
+	}
+	state = States::DATA_SET_UNINITIALISED;
+	unlockDataPool();
+}
+
+ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	lockDataPool();
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				== PoolVariableIF::VAR_WRITE
+				&& registeredVariables[count]->getDataPoolId()
+				!= PoolVariableIF::NO_PARAMETER) {
+			registeredVariables[count]->commit();
+		} 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::serialize(uint8_t** buffer, size_t* size,
+		const size_t maxSize, bool bigEndian) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+		bool bigEndian) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		result = registeredVariables[count]->deSerialize(buffer, size,
+				bigEndian);
+		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;
+}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
new file mode 100644
index 00000000..6b468c11
--- /dev/null
+++ b/datapool/DataSetBase.h
@@ -0,0 +1,135 @@
+#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolVariableIF.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 lockDataPo
+ * @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();
+	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();
+
+	/**
+	 * @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();
+
+	/* DataSetIF implementation */
+	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() 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;
+
+	/* SerializeIF implementations */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				const size_t maxSize, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+
+	//SHOULDDO we could use a linked list of datapool variables
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+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.
+	 */
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+};
+
+#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 4e351416..d9cc4966 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -16,6 +16,17 @@ 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 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 );
+
 	/**
 	 * @brief	This is an empty virtual destructor,
 	 * 			as it is proposed for C++ interfaces.
@@ -29,7 +40,17 @@ public:
 	 */
 	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
 
+	/**
+	 * @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() = 0;
+	/**
+	 * @brief   Unlock call corresponding to the lock call.
+	 * @return Unlock operation result
+	 */
 	virtual ReturnValue_t unlockDataPool() = 0;
 };
 
diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h
index f83fa3b9..11206611 100644
--- a/datapool/PIDReader.h
+++ b/datapool/PIDReader.h
@@ -1,9 +1,9 @@
 #ifndef PIDREADER_H_
 #define PIDREADER_H_
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index aea84612..c0bd3c09 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,6 +1,6 @@
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index cf02b20a..6e289303 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -6,10 +6,12 @@
  */
 
 #include <framework/datapool/PoolRawAccessHelper.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 #include <cmath>
-
-#include <framework/datapoolglob/GlobalDataSet.h>
+#include <cstring>
 
 PoolRawAccessHelper::PoolRawAccessHelper(uint32_t * poolIdBuffer_,
 		uint8_t  numberOfParameters_):
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index ab881a5f..f2434241 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,6 +7,7 @@
 #ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
+#include <framework/datapool/PoolRawAccess.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
 
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9935ef75..0cbc18c5 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -18,6 +18,7 @@
  * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
+	friend class DataSetBase;
 	friend class GlobDataSet;
 	friend class LocalDataSet;
 protected:
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 2779ce5c..f32ff567 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,5 +1,7 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/DataPoolAdmin.h>
+#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/parameters/ParameterMessage.h>
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 6e09a398..503d068e 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -1,61 +1,12 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalDataPool.h>
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet() :
-		fill_count(0), state(DATA_SET_UNINITIALISED) {
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = nullptr;
-	}
-}
+GlobDataSet::GlobDataSet(): DataSetBase() {}
 
-GlobDataSet::~GlobDataSet() {
-	//Don't do anything with your variables, they are dead already!
-	// (Destructor is already called)
-}
-
-ReturnValue_t GlobDataSet::registerVariable(PoolVariableIF* variable) {
-	if (state != DATA_SET_UNINITIALISED) {
-		sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
-		return DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
-		sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
-		return POOL_VAR_NULL;
-	}
-	if (fill_count >= DATA_SET_MAX_SIZE) {
-		sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
-		return DATA_SET_FULL;
-	}
-	registeredVariables[fill_count] = variable;
-	fill_count++;
-	return RETURN_OK;
-}
-
-ReturnValue_t GlobDataSet::read() {
-	ReturnValue_t result = RETURN_OK;
-	if (state == DATA_SET_UNINITIALISED) {
-		lockDataPool();
-		for (uint16_t count = 0; count < fill_count; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-							!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status != RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
-			}
-		}
-		state = DATA_SET_WAS_READ;
-		unlockDataPool();
-	} else {
-		sif::error << "DataSet::read(): Call made in wrong position." << std::endl;
-		result = SET_WAS_ALREADY_READ;
-	}
-	return result;
-}
+// Don't do anything with your variables, they are dead already!
+// (Destructor is already called)
+GlobDataSet::~GlobDataSet() {}
 
 ReturnValue_t GlobDataSet::commit(bool valid) {
 	setEntriesValid(valid);
@@ -64,50 +15,7 @@ ReturnValue_t GlobDataSet::commit(bool valid) {
 }
 
 ReturnValue_t GlobDataSet::commit() {
-	if (state == DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit();
-		return RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit();
-	}
-}
-
-void GlobDataSet::handleAlreadyReadDatasetCommit() {
-	lockDataPool();
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
-		}
-	}
-	state = DATA_SET_UNINITIALISED;
-	unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::handleUnreadDatasetCommit() {
-	ReturnValue_t result = RETURN_OK;
-	lockDataPool();
-	for (uint16_t count = 0; count < fill_count; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commit();
-		} 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 = DATA_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
+	return DataSetBase::commit();
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
@@ -118,29 +26,8 @@ ReturnValue_t GlobDataSet::lockDataPool() {
 	return glob::dataPool.lockDataPool();
 }
 
-ReturnValue_t GlobDataSet::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, max_size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t GlobDataSet::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
 void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fill_count; count++) {
+	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				!= PoolVariableIF::VAR_READ) {
 			registeredVariables[count]->setValid(valid);
@@ -152,15 +39,4 @@ void GlobDataSet::setSetValid(bool valid) {
 	this->valid = valid;
 }
 
-ReturnValue_t GlobDataSet::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint16_t count = 0; count < fill_count; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
+
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index 365de380..c2e0b577 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,63 +1,32 @@
 #ifndef DATASET_H_
 #define DATASET_H_
 
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolRawAccess.h>
-#include <framework/datapool/PoolVarList.h>
+#include <framework/datapool/DataSetBase.h>
 
-#include <framework/serialize/SerializeAdapter.h>
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
  * 			for the global data pool.
- *
  * @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.
+ * This class uses the read-commit() semantic provided by the DataSetBase class.
+ * It extends the base class by using the global data pool,
+ * having a valid state and implementing lock und unlock calls for the global
+ * datapool.
  *
- * 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.
+ * For more information on how this class works, see the DataSetBase
+ * documentation.
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class GlobDataSet: public DataSetIF, public HasReturnvaluesIF, public SerializeIF {
+class GlobDataSet: public DataSetBase {
 public:
-	//SHOULDDO we could use a linked list of datapool variables
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
 
-
-	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 DATA_SET_UNINITIALIZED = 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 );
 	/**
-	 * @brief	The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
+	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
 	 */
 	GlobDataSet();
 
-	/**
-	 * @brief	This operation is used to register the local variables in the set.
-	 * @details	It stores the pool variable pointer in a variable list.
-	 */
-	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
-
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -67,42 +36,7 @@ public:
 	 * For each, the valid flag in the data pool is set to "invalid".
 	 */
 	~GlobDataSet();
-	/**
-	 * @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
-	 */
-	ReturnValue_t read();
-	/**
-	 * @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
-	 */
-	ReturnValue_t commit(void);
+
 	/**
 	 * Variant of method above which sets validity of all elements of the set.
 	 * @param valid Validity information from PoolVariableIF.
@@ -111,6 +45,7 @@ public:
 	 * 			     contains non write-only variables
 	 */
 	ReturnValue_t commit(bool valid);
+	ReturnValue_t commit() override;
 
 	/**
 	 * Set all entries
@@ -126,45 +61,16 @@ public:
 	 */
 	void setEntriesValid(bool valid);
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
 private:
-
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * \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 fill_count;
-	/**
-	 * States of the seet.
-	 */
-	enum 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;
-
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
-	 * 			the underlying data data pool structure
+	 * 			the global data pool.
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
@@ -172,7 +78,7 @@ private:
 
 	/**
 	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the underlying data data pool structure
+	 * 			unlocking the global data pool
 	 * @details
 	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
 	 */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index eee9afc1..cfa28e11 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -2,9 +2,9 @@
 #define GLOBALPOOLVARIABLE_H_
 
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/PoolEntry.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/serialize/SerializeAdapter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index f46f854b..8efc33d5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,10 +1,10 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a1e96695..30a02b44 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,6 +1,6 @@
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include "InternalErrorReporter.h"
 
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/ipc/MutexFactory.h>
 
diff --git a/power/Fuse.h b/power/Fuse.h
index a826a125..44f8964f 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -2,6 +2,7 @@
 #define FUSE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/datapool/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cd277784..27885b8b 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -3,6 +3,7 @@
 
 #include <framework/thermal/AbstractTemperatureSensor.h>
 #include <framework/datapoolglob/GlobalDataSet.h>
+#include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/monitoring/LimitMonitor.h>
 
 /**

From d1b315c7df5882427c41c77bf732f606c73ab50b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:54:56 +0200
Subject: [PATCH 0268/1292] pool raw access adaptions

---
 datapool/PoolRawAccess.cpp | 146 ++++++++++++--------
 datapool/PoolRawAccess.h   | 275 ++++++++++++++++++++++---------------
 2 files changed, 250 insertions(+), 171 deletions(-)

diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp
index c0bd3c09..778e1b9c 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapool/PoolRawAccess.cpp
@@ -1,54 +1,76 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize(
-				0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) {
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
 	memset(value, 0, sizeof(value));
-	if (data_set != NULL) {
-		data_set->registerVariable(this);
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
 	}
 }
 
-PoolRawAccess::~PoolRawAccess() {
-
-}
+PoolRawAccess::~PoolRawAccess() {}
 
 ReturnValue_t PoolRawAccess::read() {
-	PoolEntryIF* read_out = glob::dataPool.getRawData(dataPoolId);
-	if (read_out != NULL) {
-		valid = read_out->getValid();
-		if (read_out->getSize() > arrayEntry) {
-			arraySize = read_out->getSize();
-			typeSize = read_out->getByteSize() / read_out->getSize();
-			type = read_out->getType();
-			if (typeSize <= sizeof(value)) {
-				uint16_t arrayPosition = arrayEntry * typeSize;
-				sizeTillEnd = read_out->getByteSize() - arrayPosition;
-				uint8_t* ptr =
-						&((uint8_t*) read_out->getRawData())[arrayPosition];
-				memcpy(value, ptr, typeSize);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				//Error value type too large.
-			}
-		} else {
-			//Error index requested too large
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
 		}
 	} else {
-		//Error entry does not exist.
+		result = READ_ENTRY_NON_EXISTENT;
 	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed." << std::endl;
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
 	valid = INVALID;
 	typeSize = 0;
 	sizeTillEnd = 0;
 	memset(value, 0, sizeof(value));
-	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t PoolRawAccess::commit() {
@@ -71,7 +93,9 @@ uint8_t* PoolRawAccess::getEntry() {
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 		uint32_t* writtenBytes, uint32_t max_size) {
 	uint8_t* data_ptr = getEntry();
-//	debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
 	if (typeSize == 0)
 		return DATA_POOL_ACCESS_FAILED;
 	if (typeSize > max_size)
@@ -89,6 +113,32 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+		const size_t max_size, bool bigEndian) const {
+	if (typeSize + *size <= max_size) {
+		if (bigEndian) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+			for (uint8_t count = 0; count < typeSize; count++) {
+				(*buffer)[count] = value[typeSize - count - 1];
+			}
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			memcpy(*buffer, value, typeSize);
+#endif
+		} else {
+			memcpy(*buffer, value, typeSize);
+		}
+		*size += typeSize;
+		(*buffer) += typeSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+}
+
+
 Type PoolRawAccess::getType() {
 	return type;
 }
@@ -145,29 +195,6 @@ uint16_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
-#endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-}
 
 size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
@@ -175,8 +202,9 @@ size_t PoolRawAccess::getSerializedSize() const {
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
+	// TODO: Needs to be tested!!!
 	if (*size >= typeSize) {
-
+		*size -= typeSize;
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -187,12 +215,14 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		} else {
+		}
+		else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }
diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h
index f32aac51..452b5397 100644
--- a/datapool/PoolRawAccess.h
+++ b/datapool/PoolRawAccess.h
@@ -2,36 +2,187 @@
 #define POOLRAWACCESS_H_
 
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntryIF.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/globalfunctions/Type.h>
 
 /**
- * This class allows accessing Data Pool variables as raw bytes.
- * This is necessary to have an access method for HK data, as the PID's alone do not
- * provide a type information.
- *	\ingroup data_pool
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
  */
-class PoolRawAccess: public PoolVariableIF {
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
+			uint32_t max_size);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			uint32_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	uint8_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	uint8_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(uint8_t valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	uint16_t getSizeTillEnd() const;
+
+	size_t getSerializedSize() const;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian);
+
+protected:
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details	When executed, this operation tries to fetch the pool entry with matching
+	 * 			data pool id from the global data pool and copies the value and the valid
+	 * 			information to its local attributes. In case of a failure (wrong type or
+	 * 			pool id not found), the variable is set to zero and invalid.
+	 * 			The operation does NOT provide any mutual exclusive protection by itself !
+	 * 			If reading from the data pool without information about the type is desired,
+	 * 			initialize the raw pool access by supplying a data set and using the data set
+	 * 			read function, which calls this read function.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read();
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details	It checks type and size, as well as if the variable is writable. If so,
+	 * 			the value is copied and the valid flag is automatically set to "valid".
+	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 *
+	 */
+	ReturnValue_t commit();
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
 private:
 	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
 	 * 			is stored.
 	 */
 	uint32_t dataPoolId;
 	/**
-	 * \brief	The array entry that is fetched from the data pool.
+	 * @brief	The array entry that is fetched from the data pool.
 	 */
 	uint8_t arrayEntry;
 	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
 	 */
 	uint8_t valid;
 	/**
-	 *  \brief	This value contains the type of the data pool entry.
+	 * @brief	This value contains the type of the data pool entry.
 	 */
 	Type type;
 	/**
-	 * \brief	This value contains the size of the data pool entry in bytes.
+	 * @brief	This value contains the size of the data pool entry type in bytes.
 	 */
 	uint8_t typeSize;
 	/**
@@ -43,111 +194,9 @@ private:
 	 */
 	uint16_t sizeTillEnd;
 	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
+	 * @brief	The information whether the class is read-write or read-only is stored here.
 	 */
 	ReadWriteMode_t readWriteMode;
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-protected:
-	/**
-	 * \brief	This is a call to read the value from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read();
-	/**
-	 * \brief	The commit call writes back the variable's value to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	uint8_t value[RAW_MAX_SIZE];
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-	/**
-	 * \brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-	/**
-	 * \brief	This operation returns a pointer to the entry fetched.
-	 * \details	This means, it does not return a pointer to byte "index", but to the start byte of
-	 * 			array entry "index". Example: If the original data pool array consists of an double
-	 * 			array of size four, getEntry(1) returns &(this->value[8]).
-	 */
-	uint8_t* getEntry();
-	/**
-	 * \brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * \details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * \param buffer	A pointer to a buffer to write to
-	 * \param writtenBytes	The number of bytes written is returned with this value.
-	 * \param max_size	The maximum size that the function may write to buffer.
-	 * \return	- \c RETURN_OK if entry could be acquired
-	 * 			- \c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
-			uint32_t max_size);
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
-	/**
-	 *  \brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  \brief This operation returns the size of the entry currently stored.
-	 */
-	uint8_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	uint8_t getArraySize();
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(uint8_t valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	uint16_t getSizeTillEnd() const;
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
-
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
 };
 
 #endif /* POOLRAWACCESS_H_ */

From 767850e12546ddb7b17d344ee32a1c5bb389a593 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 17 May 2020 23:58:57 +0200
Subject: [PATCH 0269/1292] deleted poolvector

---
 datapool/PoolVector.h | 233 ------------------------------------------
 1 file changed, 233 deletions(-)
 delete mode 100644 datapool/PoolVector.h

diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h
deleted file mode 100644
index 3df61528..00000000
--- a/datapool/PoolVector.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * \file	PoolVector.h
- *
- * \brief	This file contains the PoolVector class, the header only class to handle data pool vectors.
- *
- * \date	10/23/2012
- *
- * \author	Bastian Baetz
- */
-
-#ifndef POOLVECTOR_H_
-#define POOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * \brief	This is the access class for array-type data pool entries.
- *
- * \details	To ensure safe usage of the data pool, operation is not done directly on the data pool
- * 			entries, but on local copies. This class provides simple type- and length-safe access
- * 			to vector-style data pool entries (i.e. entries with length > 1).
- * 			The class can be instantiated as read-write and read only.
- * 			It provides a commit-and-roll-back semantic, which means that no array entry in
- * 			the data pool is changed until the commit call is executed.
- * 			There are two template parameters:
- * 	\tparam	T This template parameter specifies the data type of an array entry. Currently, all
- * 			plain data types are supported, but in principle any type is possible.
- * 	\tparam vector_size	This template parameter specifies the vector size of this entry.
- * 			Using a template parameter for this is not perfect, but avoids dynamic memory allocation.
- *	\ingroup data_pool
- */
-template<typename T, uint16_t vector_size>
-class PoolVector: public PoolVariableIF {
-private:
-	/**
-	 * \brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * \brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * \brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-
-protected:
-	/**
-	 * \brief	This is a call to read the array's values from the global data pool.
-	 * \details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies all array values and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type, size or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() {
-		PoolEntry<T>* read_out = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if (read_out != NULL) {
-			this->valid = read_out->valid;
-			memcpy(this->value, read_out->address, read_out->getByteSize());
-
-			return HasReturnvaluesIF::RETURN_OK;
-
-		} else {
-			memset(this->value, 0, vector_size * sizeof(T));
-			sif::error << "PoolVector: read of DP Variable 0x" << std::hex
-					<< dataPoolId << std::dec << " failed." << std::endl;
-			this->valid = INVALID;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * \brief	The commit call copies the array values back to the data pool.
-	 * \details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() {
-		PoolEntry<T>* write_back = ::dataPool.getData<T>(this->dataPoolId,
-				vector_size);
-		if ((write_back != NULL) && (this->readWriteMode != VAR_READ)) {
-			write_back->valid = valid;
-			memcpy(write_back->address, this->value, write_back->getByteSize());
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 * \detials	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vector_size];
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode) :
-			dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-		memset(this->value, 0, vector_size * sizeof(T));
-		if (set != NULL) {
-			set->registerVariable(this);
-		}
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-//	PoolVector(const PoolVector& rhs) {
-//		PoolVector<T, vector_size> temp(rhs.dataPoolId, rhs.)
-//		memcpy(value, rhs.value, sizeof(T)*vector_size);
-//	}
-	/**
-	 * \brief	The classes destructor is empty.
-	 * \details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolVector() {
-	}
-	;
-	/**
-	 * \brief	The operation returns the number of array entries in this variable.
-	 */
-	uint8_t getSize() {
-		return vector_size;
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-	;
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-
-	void setValid(uint8_t valid) {
-		this->valid = valid;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	T &operator [](int i) {
-		return value[i];
-	}
-
-	const T &operator [](int i) const {
-		return value[i];
-	}
-
-	PoolVector<T, vector_size> &operator=(
-			PoolVector<T, vector_size> newPoolVector) {
-
-		for (uint16_t i = 0; i < vector_size; i++) {
-			this->value[i] = newPoolVector.value[i];
-		}
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-					max_size, bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		uint16_t i;
-		ReturnValue_t result;
-		for (i = 0; i < vector_size; i++) {
-			result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-					bigEndian);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-};
-
-#endif /* POOLVECTOR_H_ */

From 355bc2b9057da4f79ead6aa0e7882b9220edffd7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 15:42:47 +0200
Subject: [PATCH 0270/1292] improvements

---
 datapoolglob/GlobalPoolVariable.h    | 2 +-
 datapoollocal/LocalPoolVariable.h    | 5 +++--
 datapoollocal/LocalPoolVariable.tpp  | 5 ++++-
 globalfunctions/Type.h               | 3 +++
 housekeeping/HasHkPoolParametersIF.h | 5 +----
 5 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index cfa28e11..eb44c307 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -32,7 +32,7 @@ class GlobPoolVar: public PoolVariableIF {
 	template<typename U, uint8_t n_var> friend class PoolVarList;
 	static_assert(not std::is_same<T, bool>::value,
 			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"Warum? Darum :-)");
+			"There is no boolean type in CCSDS.");
 public:
 	/**
 	 * @brief	In the constructor, the variable can register itself in a
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 44c16a7c..39c92f60 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
@@ -100,4 +101,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
+#endif
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index fdd18bcd..4bc4c662 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
 #include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
@@ -107,3 +108,5 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, bool bigEndian) {
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
+
+#endif
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index f4146f4e..e46a37e4 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -4,6 +4,9 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
 class Type: public SerializeIF {
 public:
 	enum ActualType_t {
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 5ec9beef..ac248cf3 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -13,8 +13,7 @@ using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
 
 /**
- * @brief 	Interface for the local housekeeping managers used by the device
- * 			handler.
+ * @brief
  */
 class HasHkPoolParametersIF {
 public:
@@ -27,6 +26,4 @@ public:
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 };
 
-
-
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */

From 7e04c055b353b1cfe6817a2cc2e0fbbca4db631e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 16:13:46 +0200
Subject: [PATCH 0271/1292] tc packet stored formatting

---
 tmtcpacket/pus/TcPacketStored.cpp | 10 +++++-----
 tmtcpacket/pus/TcPacketStored.h   |  4 +++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 0187b08f..6a4d03be 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,22 +1,22 @@
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <string.h>
+#include <cstring>
 
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(NULL), storeAddress(setAddress) {
+		TcPacketBase(nullptr), storeAddress(setAddress) {
 	this->setStoreAddress(this->storeAddress);
 }
 
 TcPacketStored::TcPacketStored(uint16_t apid, uint8_t ack, uint8_t service,
 		uint8_t subservice, uint8_t sequence_count, const uint8_t* data,
-		uint32_t size) :
-		TcPacketBase(NULL) {
+		size_t size) :
+		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!this->checkAndSetStore()) {
 		return;
 	}
-	uint8_t* p_data = NULL;
+	uint8_t* p_data = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
 	if (returnValue != this->store->RETURN_OK) {
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index c57f0e0f..50639788 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -64,7 +64,9 @@ public:
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
 	 */
-	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice, uint8_t sequence_count = 0, const uint8_t* data = NULL, uint32_t size = 0 );
+	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service,
+			uint8_t subservice, uint8_t sequence_count = 0,
+			const uint8_t* data = nullptr, size_t size = 0 );
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.

From b12bace3857588cfca51e0b0c8df37fec0d6c31a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 16:40:11 +0200
Subject: [PATCH 0272/1292] changed order of input arguments (relevance)

default argument for ACK
---
 tmtcpacket/pus/TcPacketStored.cpp | 6 +++---
 tmtcpacket/pus/TcPacketStored.h   | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 6a4d03be..57b90bcc 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -8,9 +8,9 @@ TcPacketStored::TcPacketStored(store_address_t setAddress) :
 	this->setStoreAddress(this->storeAddress);
 }
 
-TcPacketStored::TcPacketStored(uint16_t apid, uint8_t ack, uint8_t service,
-		uint8_t subservice, uint8_t sequence_count, const uint8_t* data,
-		size_t size) :
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
 		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!this->checkAndSetStore()) {
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index 50639788..a9c49c2e 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -64,9 +64,9 @@ public:
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
 	 */
-	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service,
-			uint8_t subservice, uint8_t sequence_count = 0,
-			const uint8_t* data = nullptr, size_t size = 0 );
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.

From 1d4d01d1906d1300eb7fe4e65d259afe64210a81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:22:10 +0200
Subject: [PATCH 0273/1292] Added ISR calls for MQ and task mgmt

The task management defines an external function which
implements a context switch call from an ISR
---
 osal/FreeRTOS/MessageQueue.cpp   | 95 ++++++++++++++++++++------------
 osal/FreeRTOS/MessageQueue.h     | 75 +++++++++++++++++--------
 osal/FreeRTOS/TaskManagement.cpp | 24 ++++++++
 osal/FreeRTOS/TaskManagement.h   | 63 +++++++++++++++++++++
 4 files changed, 199 insertions(+), 58 deletions(-)
 create mode 100644 osal/FreeRTOS/TaskManagement.cpp
 create mode 100644 osal/FreeRTOS/TaskManagement.h

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e5da0442..38f425a4 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -2,11 +2,14 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-// TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
-
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-defaultDestination(0),lastPartner(0)  {
-	handle = xQueueCreate(message_depth, max_message_size);
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
+// Haven't found function to find system context.
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
+defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
+	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue creation failed" << std::endl;
 	}
@@ -18,6 +21,10 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+void MessageQueue::switchSystemContext(CallContext callContext) {
+	this->callContext = callContext;
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
@@ -27,6 +34,11 @@ ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
 ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
@@ -35,6 +47,27 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+}
+
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (!ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
@@ -73,17 +106,6 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return defaultDestination;
 }
@@ -92,23 +114,28 @@ bool MessageQueue::isDefaultDestinationSet() const {
 	return 0;
 }
 
+
+// static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	message->setSender(sentFrom);
-
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
-	if (result != pdPASS) {
-		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-
+        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        bool ignoreFault, CallContext callContext) {
+    message->setSender(sentFrom);
+    BaseType_t result;
+    if(callContext == CallContext::task) {
+        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()), 0);
+    }
+    else {
+        // If the call context is from an interrupt,
+        // request a context switch if a higher priority task
+        // was blocked by the interrupt.
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()),
+                &xHigherPriorityTaskWoken);
+        if(xHigherPriorityTaskWoken == pdTRUE) {
+            TaskManagement::requestContextSwitch(callContext);
+        }
+    }
+    return handleSendResult(result, ignoreFault);
 }
-
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 32f41b44..ce6ed46b 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -4,9 +4,14 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+}
+
 
-#include <FreeRTOS.h>
-#include <queue.h>
 
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
@@ -21,11 +26,17 @@
  *				methods to send a message to a user-defined or a default destination. In addition
  *				it also provides a reply method to answer to the queue it received its last message
  *				from.
+ *
  *				The MessageQueue should be used as "post box" for a single owning object. So all
  *				message queue communication is "n-to-one".
  *				For creating the queue, as well as sending and receiving messages, the class makes
  *				use of the operating system calls provided.
- *	\ingroup message_queue
+ *
+ *				Please keep in mind that FreeRTOS offers
+ *				different calls for message queue operations if called from an ISR.
+ *				For now, the system context needs to be switched manually.
+ *	@ingroup osal
+ *	@ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
@@ -43,11 +54,15 @@ public:
 	 * 							This should be left default.
 	 */
 	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
 	 * @details	This is accomplished by using the delete call provided by the operating system.
 	 */
 	virtual ~MessageQueue();
+
+	void switchSystemContext(CallContext callContext);
+
 	/**
 	 * @brief	This operation sends a message to the given destination.
 	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
@@ -74,6 +89,29 @@ public:
 	 */
 	ReturnValue_t reply( MessageQueueMessage* message );
 
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
 	 * @details	It works identically to the other receiveMessage call, but in addition returns the
@@ -107,26 +145,7 @@ public:
 	 * @brief	This method returns the message queue id of this class's message queue.
 	 */
 	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -148,12 +167,20 @@ protected:
 	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 * \param context
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::task);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;
 	MessageQueueId_t lastPartner;
+	CallContext callContext; //!< Stores the current system context
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
new file mode 100644
index 00000000..52222531
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -0,0 +1,24 @@
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+void TaskManagement::requestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::task) {
+	if(callContext == CallContext::isr) {
+		// This function depends on the partmacro.h definition for the specific device
+		requestContextSwitchFromISR();
+	} else {
+		requestContextSwitchFromTask();
+	}
+}
+
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
+
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
+	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+}
+
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
new file mode 100644
index 00000000..eaaf97e2
--- /dev/null
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -0,0 +1,63 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+#include <cstdint>
+
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern "C" void requestContextSwitchFromISR();
+
+/*!
+ * Used by functions to tell if they are being called from
+ * within an ISR or from a regular task. This is required because FreeRTOS
+ * has different functions for handling semaphores and messages from within an ISR and task.
+ */
+
+enum CallContext {
+	task = 0x00,//!< task_context
+	isr = 0xFF  //!< isr_context
+};
+
+
+class TaskManagement {
+public:
+	/**
+	 * In this function, a function dependant on the portmacro.h header function calls
+	 * to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task to unblock
+	 * and a context switch is required.
+	 */
+	static void requestContextSwitch(CallContext callContext);
+
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void requestContextSwitchFromTask(void);
+
+	/**
+	 * @return The current task handle
+	 */
+	static TaskHandle_t getCurrentTaskHandle();
+
+	/**
+	 * Get returns the minimum amount of remaining stack space in words
+	 * that was a available to the task since the task started executing.
+	 * Please note that the actual value in bytes depends
+	 * on the stack depth type.
+	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
+	 * @return Smallest value of stack remaining since the task was started in
+	 * 		   words.
+	 */
+	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From d1500a78685d18e05b94419be69f9cb09056c127 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:31:05 +0200
Subject: [PATCH 0274/1292] mq doc improvements

---
 osal/FreeRTOS/MessageQueue.cpp |   9 ++-
 osal/FreeRTOS/MessageQueue.h   | 120 ++++++++++++++++++---------------
 2 files changed, 72 insertions(+), 57 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 38f425a4..12a3173a 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,14 +50,16 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault, callContext);
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault, callContext);
 }
 
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
 		if (!ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != NULL) {
 				internalErrorReporter->queueMessageNotSent();
@@ -78,7 +80,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(message->getBuffer()), 0);
+	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
+			message->getBuffer()), 0);
 	if (result == pdPASS){
 		this->lastPartner = message->getSender();
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index ce6ed46b..c278e329 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -12,52 +12,57 @@ extern "C" {
 }
 
 
-
 //TODO this class assumes that MessageQueueId_t is the same size as void* (the FreeRTOS handle type), compiler will catch this but it might be nice to have something checking or even an always working solution
 // https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
 
 /**
- *	@brief		This class manages sending and receiving of message queue messages.
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
  *
- *	@details	Message queues are used to pass asynchronous messages between processes.
- *				They work like post boxes, where all incoming messages are stored in FIFO
- *				order. This class creates a new receiving queue and provides methods to fetch
- *				received messages. Being a child of MessageQueueSender, this class also provides
- *				methods to send a message to a user-defined or a default destination. In addition
- *				it also provides a reply method to answer to the queue it received its last message
- *				from.
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
  *
- *				The MessageQueue should be used as "post box" for a single owning object. So all
- *				message queue communication is "n-to-one".
- *				For creating the queue, as well as sending and receiving messages, the class makes
- *				use of the operating system calls provided.
- *
- *				Please keep in mind that FreeRTOS offers
- *				different calls for message queue operations if called from an ISR.
- *				For now, the system context needs to be switched manually.
- *	@ingroup osal
- *	@ingroup message_queue
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
  */
 class MessageQueue : public MessageQueueIF {
 	friend class MessageQueueSenderIF;
 public:
 	/**
 	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
-	 * 			and initialized. The message depth - the maximum number of messages to be
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
-	 * 			automatically set to the maximum message queue message size. The operating system
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
-	 * 						sender. Default is three.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
-	 * 							This should be left default.
+	 * @details
+	 * By making use of the according operating system call, a message queue is created
+	 * and initialized. The message depth - the maximum number of messages to be
+	 * buffered - may be set with the help of a parameter, whereas the message size is
+	 * automatically set to the maximum message queue message size. The operating system
+	 * sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue( size_t message_depth = 3,
+			size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
 
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
 	 */
 	virtual ~MessageQueue();
 
@@ -90,27 +95,28 @@ public:
 	ReturnValue_t reply( MessageQueueMessage* message );
 
 	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * @details	This method takes the message provided, adds the sentFrom information and passes
 	 * 			it on to the destination provided with an operating system call. The OS's return
 	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @param sendTo	This parameter specifies the message queue id to send the message to.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message,
 			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * @brief	The sendToDefault method sends a queue message to the default destination.
+	 * @details	In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -147,27 +153,34 @@ public:
 	MessageQueueId_t getId() const;
 
 	/**
-	 * \brief	This method is a simple setter for the default destination.
+	 * @brief	This method is a simple setter for the default destination.
 	 */
 	void setDefaultDestination(MessageQueueId_t defaultDestination);
 	/**
-	 * \brief	This method is a simple getter for the default destination.
+	 * @brief	This method is a simple getter for the default destination.
 	 */
 	MessageQueueId_t getDefaultDestination() const;
 
 	bool isDefaultDestinationSet() const;
 protected:
 	/**
-	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
-	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 * \param context
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
@@ -175,7 +188,6 @@ protected:
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
-
 private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination;

From f8614e23a867d21d64922329164920c41ab55c38 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:38:19 +0200
Subject: [PATCH 0275/1292] deleted copy ans assignment ctor

---
 osal/FreeRTOS/MessageQueue.cpp | 18 +++++++++---------
 osal/FreeRTOS/MessageQueue.h   | 16 +++++++++++-----
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 12a3173a..9e4b581b 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -7,11 +7,10 @@
 // As a first step towards this, introduces system context variable which needs
 // to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
-defaultDestination(0),lastPartner(0), callContext(CallContext::task)  {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
-		sif::error << "MessageQueue creation failed" << std::endl;
+		sif::error << "MessageQueue: Creation failed" << std::endl;
 	}
 }
 
@@ -57,11 +56,11 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
-		if (!ignoreFault) {
+		if (not ignoreFault) {
 			InternalErrorReporterIF* internalErrorReporter =
 					objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
+			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();
 			}
 		}
@@ -106,6 +105,7 @@ MessageQueueId_t MessageQueue::getId() const {
 }
 
 void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
 	this->defaultDestination = defaultDestination;
 }
 
@@ -114,7 +114,7 @@ MessageQueueId_t MessageQueue::getDefaultDestination() const {
 }
 
 bool MessageQueue::isDefaultDestinationSet() const {
-	return 0;
+	return defaultDestinationSet;
 }
 
 
@@ -129,9 +129,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                 static_cast<const void*>(message->getBuffer()), 0);
     }
     else {
-        // If the call context is from an interrupt,
-        // request a context switch if a higher priority task
-        // was blocked by the interrupt.
+        /* If the call context is from an interrupt,
+         * request a context switch if a higher priority task
+         * was blocked by the interrupt. */
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
         result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()),
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index c278e329..e88bbcec 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -56,8 +56,12 @@ public:
 	 * With this parameter, the maximum message size can be adjusted.
 	 * This should be left default.
 	 */
-	MessageQueue( size_t message_depth = 3,
-			size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	MessageQueue( size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
 
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.
@@ -189,10 +193,12 @@ protected:
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
 private:
+	bool defaultDestinationSet = false;
 	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination;
-	MessageQueueId_t lastPartner;
-	CallContext callContext; //!< Stores the current system context
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	//!< Stores the current system context
+	CallContext callContext =  CallContext::task;
 };
 
 #endif /* MESSAGEQUEUE_H_ */

From 41c0ca6c52a728ffaf359805efb0df0319b9dcc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:39:10 +0200
Subject: [PATCH 0276/1292] added doc for switchSystemContext

---
 osal/FreeRTOS/MessageQueue.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e88bbcec..07e95ddf 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -70,6 +70,11 @@ public:
 	 */
 	virtual ~MessageQueue();
 
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
 	void switchSystemContext(CallContext callContext);
 
 	/**

From b23728731548d900b97a70e3d32565ebcfcc50e7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 17:48:16 +0200
Subject: [PATCH 0277/1292] bin semaph sif replacements

---
 osal/FreeRTOS/BinarySemaphore.cpp | 11 +++++------
 returnvalues/FwClassIds.h         |  2 ++
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index a6a923aa..acfc53bd 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -11,8 +11,7 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-
-		error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Binary semaphore creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
@@ -26,7 +25,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -35,7 +34,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
@@ -45,7 +44,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-        error << "Binary semaphore creation failure" << std::endl;
+        sif::error << "Binary semaphore creation failure" << std::endl;
     }
     xSemaphoreGive(handle);
 }
@@ -55,7 +54,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-            error << "Binary semaphore creation failure" << std::endl;
+            sif::error << "Binary semaphore creation failure" << std::endl;
         }
         xSemaphoreGive(handle);
     }
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index d21861c0..120d8b8c 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -24,6 +24,7 @@ enum {
 	MEMORY_HELPER, //MH
 	SERIALIZE_IF, //SE
 	FIXED_MAP, //FM
+	FIXED_MULTIMAP, //FMM
 	HAS_HEALTH_IF, //HHI
 	FIFO_CLASS, //FF
 	MESSAGE_PROXY, //MQP
@@ -59,6 +60,7 @@ enum {
 	SGP4PROPAGATOR_CLASS, //SGP4 53
 	MUTEX_IF, //MUX 54
 	MESSAGE_QUEUE_IF,//MQI 55
+	SEMAPHORE_IF, //SPH 56
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 45b0193ef38b70a4f1d5be76564258bc6ab5c928 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 18:06:40 +0200
Subject: [PATCH 0278/1292] bin semaph todo

---
 osal/FreeRTOS/BinarySemaphore.h | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0ab9cdea..865da8a6 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,27 +1,24 @@
-/**
- * @file BinarySempahore.h
- *
- * @date 25.02.2020
- */
 #ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
 extern "C" {
-#include "FreeRTOS.h"
-#include "semphr.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 }
 
-
+// TODO: Counting semaphores and implement the new (better)
+//		 task notifications. However, those use task notifications require
+//		 the task handle. Maybe it would be better to make a separate class
+// 		 and switch between the classes with #ifdefs.
+//		 Task Notifications require FreeRTOS V8.2 something..
 /**
  * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
  *
- * SHOULDDO: check freeRTOS version and use new task notifications,
- * if non-ancient freeRTOS version is used.
- *
+ * @author 	R. Mueller
  * @ingroup osal
  */
 class BinarySemaphore: public HasReturnvaluesIF {

From 87bf843beffe92f7f535609cb83fcb4378f952be Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:19:50 +0200
Subject: [PATCH 0279/1292] binary semaphore IF init

---
 tasks/SemaphoreIF.h | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 tasks/SemaphoreIF.h

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
new file mode 100644
index 00000000..babac05a
--- /dev/null
+++ b/tasks/SemaphoreIF.h
@@ -0,0 +1,8 @@
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+
+
+
+
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 9ba21b1e288ba9f8e20fae9c4cc7ea6923b2651f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:30:50 +0200
Subject: [PATCH 0280/1292] semaphore if continued

---
 tasks/SemaphoreIF.h | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index babac05a..cf56f6f9 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,8 +1,49 @@
 #ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
 #define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include <framework/returnvalues/FwClassIds.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstdint>
 
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization.
+ */
+class SemaphoreIF {
+	//!< Needs to be defined in implementation.
+	static const uint32_t NO_TIMEOUT;
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t acquire(uint32_t timeoutMs) = 0;
 
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return
+	 */
+	ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 * @return
+	 */
+	uint8_t getSemaphoreCounter() = 0;
+};
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 4dd6594845deb381b80fcb2ba8e0ec27acec27e1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:38:02 +0200
Subject: [PATCH 0281/1292] integrated interface into bin semaphore

---
 osal/FreeRTOS/BinarySemaphore.cpp | 11 +++++++++++
 osal/FreeRTOS/BinarySemaphore.h   | 11 +++++++++--
 tasks/SemaphoreIF.h               | 14 +++++++-------
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index acfc53bd..c0300b81 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -132,6 +132,17 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return giveBinarySemaphore();
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	return uxSemaphoreGetCount(handle);
+}
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 865da8a6..8271d9d0 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-
+#include <framework/tasks/SemaphoreIF.h>
 extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
@@ -21,7 +21,8 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-class BinarySemaphore: public HasReturnvaluesIF {
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 
@@ -67,6 +68,12 @@ public:
 	 */
 	virtual ~BinarySemaphore();
 
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	ReturnValue_t release() override;
+
+	uint8_t getSemaphoreCounter() override;
+
 	/**
 	 * Take the binary semaphore.
 	 * If the semaphore has already been taken, the task will be blocked
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index cf56f6f9..616b992d 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -9,10 +9,11 @@
  * 			task synchronization.
  */
 class SemaphoreIF {
+public:
+	virtual~ SemaphoreIF() {};
 	//!< Needs to be defined in implementation.
 	static const uint32_t NO_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	//! The current semaphore can not be given, because it is not owned
@@ -26,24 +27,23 @@ class SemaphoreIF {
 	 * for a maximum of timeoutMs while trying to acquire the semaphore.
 	 * This can be used to achieve task synchrnization.
 	 * @param timeoutMs
-	 * @return
+	 * @return - c RETURN_OK for successfull acquisition
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
 
 	/**
 	 * Corrensponding call to release a semaphore.
-	 * @return
+	 * @return -@c RETURN_OK for successfull release
 	 */
-	ReturnValue_t release() = 0;
+	virtual ReturnValue_t release() = 0;
 
 	/**
 	 * If the semaphore is a counting semaphore then the semaphores current
 	 * count value is returned. If the semaphore is a binary semaphore then 1
 	 * is returned if the semaphore is available, and 0 is returned if the
 	 * semaphore is not available.
-	 * @return
 	 */
-	uint8_t getSemaphoreCounter() = 0;
+	virtual uint8_t getSemaphoreCounter() = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From b1d9d55f50a0e242ec57604934659c7fff50eb01 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:42:05 +0200
Subject: [PATCH 0282/1292] improved documentation

---
 tasks/SemaphoreIF.h | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 616b992d..7dde27f4 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -6,7 +6,16 @@
 
 /**
  * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization.
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
  */
 class SemaphoreIF {
 public:

From 067cd9573100952c1398b956a8b7d2cbeab93a3a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 19:42:45 +0200
Subject: [PATCH 0283/1292] removed file header

---
 osal/FreeRTOS/BinarySemaphore.cpp | 5 -----
 osal/FreeRTOS/BinarySemaphore.h   | 1 -
 2 files changed, 6 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c0300b81..e4850702 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,8 +1,3 @@
-/**
- * @file BinarySemaphore.cpp
- *
- * @date 25.02.2020
- */
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 8271d9d0..854cbba4 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -71,7 +71,6 @@ public:
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
-
 	uint8_t getSemaphoreCounter() override;
 
 	/**

From 7227c3a8667a1ead8c4160b8372d350e79617de4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 20:35:13 +0200
Subject: [PATCH 0284/1292] implemented semaph factory

---
 osal/FreeRTOS/BinarySemaphore.cpp   | 45 +++++++++++++------------
 osal/FreeRTOS/BinarySemaphore.h     | 52 +++++++++++------------------
 osal/FreeRTOS/CountingSemaphore.cpp | 26 +++++++++++++++
 osal/FreeRTOS/CountingSemaphore.h   | 21 ++++++++++++
 osal/FreeRTOS/Mutex.h               |  8 ++---
 osal/FreeRTOS/MutexFactory.cpp      |  9 ++---
 osal/FreeRTOS/SemaphoreFactory.cpp  | 33 ++++++++++++++++++
 tasks/SemaphoreFactory.h            | 45 +++++++++++++++++++++++++
 8 files changed, 177 insertions(+), 62 deletions(-)
 create mode 100644 osal/FreeRTOS/CountingSemaphore.cpp
 create mode 100644 osal/FreeRTOS/CountingSemaphore.h
 create mode 100644 osal/FreeRTOS/SemaphoreFactory.cpp
 create mode 100644 tasks/SemaphoreFactory.h

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e4850702..11e48153 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,21 +3,21 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-BinarySemaphore::BinarySemaphore() {
+Semaphore::Semaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-		sif::error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
 
-BinarySemaphore::~BinarySemaphore() {
+Semaphore::~Semaphore() {
 	vSemaphoreDelete(handle);
 }
 
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
-BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+Semaphore::Semaphore(const Semaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -25,7 +25,7 @@ BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+Semaphore& Semaphore::operator =(const Semaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -36,7 +36,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     return *this;
 }
 
-BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+Semaphore::Semaphore(Semaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -44,8 +44,8 @@ BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(
-        BinarySemaphore&& s) {
+Semaphore& Semaphore::operator =(
+        Semaphore&& s) {
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -56,15 +56,15 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
-	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = Semaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == Semaphore::BLOCK_TIMEOUT) {
+	    timeout = Semaphore::BLOCK_TIMEOUT_TICKS;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -77,7 +77,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -91,7 +91,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+ReturnValue_t Semaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -103,11 +103,11 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	}
 }
 
-SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+SemaphoreHandle_t Semaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -119,7 +119,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	}
 }
 
-void BinarySemaphore::resetSemaphore() {
+void Semaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
 		handle = xSemaphoreCreateBinary();
@@ -127,20 +127,20 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
 }
 
-ReturnValue_t BinarySemaphore::release() {
+ReturnValue_t Semaphore::release() {
 	return giveBinarySemaphore();
 }
 
-uint8_t BinarySemaphore::getSemaphoreCounter() {
+uint8_t Semaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -157,3 +157,4 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
+
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 854cbba4..6383432f 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -14,14 +14,16 @@ extern "C" {
 // 		 and switch between the classes with #ifdefs.
 //		 Task Notifications require FreeRTOS V8.2 something..
 /**
- * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
  *
  * @author 	R. Mueller
  * @ingroup osal
  */
-class BinarySemaphore: public SemaphoreIF,
+class Semaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@@ -41,35 +43,21 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	BinarySemaphore();
-
-	/**
-	 * @brief Copy ctor
-	 */
-	BinarySemaphore(const BinarySemaphore&);
-
-	/**
-	 * @brief Copy assignment
-	 */
-	BinarySemaphore& operator=(const BinarySemaphore&);
-
-	/**
-	 * @brief Move constructor
-	 */
-	BinarySemaphore (BinarySemaphore &&);
-
-	/**
-	 * Move assignment
-	 */
-	BinarySemaphore & operator=(BinarySemaphore &&);
-
-	/**
-	 * Delete the binary semaphore to prevent a memory leak
-	 */
-	virtual ~BinarySemaphore();
+	//! @brief Default ctor
+	Semaphore();
+	//! @brief Copy ctor
+	Semaphore(const Semaphore&);
+	//! @brief Copy assignment
+	Semaphore& operator=(const Semaphore&);
+	//! @brief Move ctor
+	Semaphore (Semaphore &&);
+	//! @brief Move assignment
+	Semaphore & operator=(Semaphore &&);
+	//! @brief Destructor
+	virtual ~Semaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	        Semaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -83,7 +71,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+	        Semaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -92,7 +80,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_BLOCK_TICKS);
+	        Semaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
@@ -130,7 +118,7 @@ public:
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
-private:
+protected:
 	SemaphoreHandle_t handle;
 };
 
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
new file mode 100644
index 00000000..adf3f23c
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -0,0 +1,26 @@
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
+		count(count), initCount(initCount) {
+	handle = xSemaphoreCreateCounting(count, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
new file mode 100644
index 00000000..8c059af5
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -0,0 +1,21 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+
+class CountingSemaphore: public Semaphore {
+public:
+	CountingSemaphore(uint8_t count, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+private:
+	uint8_t count = 0;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 91f29585..ccbcad26 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,10 +3,10 @@
 
 #include <framework/ipc/MutexIF.h>
 
-
-#include <FreeRTOS.h>
-#include "semphr.h"
-
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+}
 
 
 class Mutex : public MutexIF {
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index cadb54fb..08cd68c8 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,10 +1,11 @@
 #include <framework/ipc/MutexFactory.h>
 
-#include "../FreeRTOS/Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why? -> one is on heap the other on bss/data
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
 //MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = NULL;
+MutexFactory* MutexFactory::factoryInstance = nullptr;
 
 MutexFactory::MutexFactory() {
 }
@@ -13,7 +14,7 @@ MutexFactory::~MutexFactory() {
 }
 
 MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == NULL){
+	if (factoryInstance == nullptr){
 		factoryInstance = new MutexFactory();
 	}
 	return MutexFactory::factoryInstance;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
new file mode 100644
index 00000000..dd319025
--- /dev/null
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -0,0 +1,33 @@
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+	return new Semaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+		uint8_t initCount) {
+	return new CountingSemaphore(count, initCount);
+}
+
+void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
new file mode 100644
index 00000000..fa95399a
--- /dev/null
+++ b/tasks/SemaphoreFactory.h
@@ -0,0 +1,45 @@
+#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#include <framework/tasks/SemaphoreIF.h>
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore();
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount);
+	void deleteMutex(SemaphoreIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */

From 066930b110730c8c781f0b680e1f7b99f1dbe920 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 18 May 2020 20:39:48 +0200
Subject: [PATCH 0285/1292] improvements

---
 osal/FreeRTOS/BinarySemaphore.cpp  | 42 +++++++++++++++---------------
 osal/FreeRTOS/BinarySemaphore.h    | 20 +++++++-------
 osal/FreeRTOS/CountingSemaphore.h  | 10 ++++++-
 osal/FreeRTOS/SemaphoreFactory.cpp |  2 +-
 4 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 11e48153..f08e3b81 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,7 +3,7 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-Semaphore::Semaphore() {
+BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
@@ -11,13 +11,13 @@ Semaphore::Semaphore() {
 	xSemaphoreGive(handle);
 }
 
-Semaphore::~Semaphore() {
+BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
-Semaphore::Semaphore(const Semaphore& other) {
+BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -25,7 +25,7 @@ Semaphore::Semaphore(const Semaphore& other) {
     xSemaphoreGive(handle);
 }
 
-Semaphore& Semaphore::operator =(const Semaphore& s) {
+BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -36,7 +36,7 @@ Semaphore& Semaphore::operator =(const Semaphore& s) {
     return *this;
 }
 
-Semaphore::Semaphore(Semaphore&& s) {
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -44,8 +44,8 @@ Semaphore::Semaphore(Semaphore&& s) {
     xSemaphoreGive(handle);
 }
 
-Semaphore& Semaphore::operator =(
-        Semaphore&& s) {
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -56,15 +56,15 @@ Semaphore& Semaphore::operator =(
     return *this;
 }
 
-ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = Semaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == Semaphore::BLOCK_TIMEOUT) {
-	    timeout = Semaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
 	}
-	else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -77,7 +77,7 @@ ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -91,7 +91,7 @@ ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t Semaphore::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -103,11 +103,11 @@ ReturnValue_t Semaphore::giveBinarySemaphore() {
 	}
 }
 
-SemaphoreHandle_t Semaphore::getSemaphore() {
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -119,7 +119,7 @@ ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	}
 }
 
-void Semaphore::resetSemaphore() {
+void BinarySemaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
 		handle = xSemaphoreCreateBinary();
@@ -127,20 +127,20 @@ void Semaphore::resetSemaphore() {
 	}
 }
 
-ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
 }
 
-ReturnValue_t Semaphore::release() {
+ReturnValue_t BinarySemaphore::release() {
 	return giveBinarySemaphore();
 }
 
-uint8_t Semaphore::getSemaphoreCounter() {
+uint8_t BinarySemaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 6383432f..bd4ddb95 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -23,7 +23,7 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-class Semaphore: public SemaphoreIF,
+class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@@ -44,20 +44,20 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
 	//! @brief Default ctor
-	Semaphore();
+	BinarySemaphore();
 	//! @brief Copy ctor
-	Semaphore(const Semaphore&);
+	BinarySemaphore(const BinarySemaphore&);
 	//! @brief Copy assignment
-	Semaphore& operator=(const Semaphore&);
+	BinarySemaphore& operator=(const BinarySemaphore&);
 	//! @brief Move ctor
-	Semaphore (Semaphore &&);
+	BinarySemaphore (BinarySemaphore &&);
 	//! @brief Move assignment
-	Semaphore & operator=(Semaphore &&);
+	BinarySemaphore & operator=(BinarySemaphore &&);
 	//! @brief Destructor
-	virtual ~Semaphore();
+	virtual ~BinarySemaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        Semaphore::NO_BLOCK_TIMEOUT) override;
+	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -71,7 +71,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        Semaphore::NO_BLOCK_TIMEOUT);
+	        BinarySemaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -80,7 +80,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        Semaphore::NO_BLOCK_TICKS);
+	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 8c059af5..a33a0fa5 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -2,7 +2,15 @@
 #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 
-class CountingSemaphore: public Semaphore {
+/**
+ * @brief 	Counting semaphores, which can be acquire more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
 public:
 	CountingSemaphore(uint8_t count, uint8_t initCount);
 	//! @brief Copy ctor, disabled
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index dd319025..9a355891 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -20,7 +20,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
-	return new Semaphore();
+	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,

From 2790a40d6c35d27bb8e86121e02c6ca9f0ddf4ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 18:55:13 +0200
Subject: [PATCH 0286/1292] some renamings

---
 tmtcpacket/pus/TcPacketBase.cpp   | 30 +++++++++++++++---------------
 tmtcpacket/pus/TcPacketBase.h     |  4 ++--
 tmtcpacket/pus/TcPacketStored.cpp |  2 +-
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 0972ffff..32caf5bb 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -13,28 +13,28 @@ TcPacketBase::~TcPacketBase() {
 }
 
 uint8_t TcPacketBase::getService() {
-	return tcData->data_field.service_type;
+	return tcData->dataField.service_type;
 }
 
 uint8_t TcPacketBase::getSubService() {
-	return tcData->data_field.service_subtype;
+	return tcData->dataField.service_subtype;
 }
 
 uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->data_field.version_type_ack & 0b00001111;
+	return tcData->dataField.version_type_ack & 0b00001111;
 }
 
 const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->data;
+	return &tcData->appData;
 }
 
 uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
 }
 
 uint16_t TcPacketBase::getErrorControl() {
 	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->data;
+	uint8_t* p_to_buffer = &tcData->appData;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -42,8 +42,8 @@ void TcPacketBase::setErrorControl() {
 	uint32_t full_size = getFullSize();
 	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
 	uint32_t size = getApplicationDataSize();
-	(&tcData->data)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->data)[size + 1] = (crc) & 0X00FF; 		// CRCL
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
 }
 
 void TcPacketBase::setData(const uint8_t* pData) {
@@ -59,11 +59,11 @@ void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->data_field.version_type_ack & 0b10000000) >> 7;
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
 }
 
 uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->data_field.version_type_ack & 0b01110000) >> 4;
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
 }
 
 void TcPacketBase::print() {
@@ -78,14 +78,14 @@ void TcPacketBase::print() {
 void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
 		uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->data_field, 0, sizeof(tcData->data_field));
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
 	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
 	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->data_field.version_type_ack = 0b00010000;
-	tcData->data_field.version_type_ack |= (ack & 0x0F);
-	tcData->data_field.service_type = service;
-	tcData->data_field.service_subtype = subservice;
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
 }
 
 size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 136aaa0b..9b858bd9 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -24,8 +24,8 @@ struct PUSTcDataFieldHeader {
  */
 struct TcPacketPointer {
 	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader data_field;
-	uint8_t data;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
 };
 
 /**
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 57b90bcc..47cf2ecd 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -24,7 +24,7 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	}
 	this->setData(p_data);
 	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->data, data, size);
+	memcpy(&tcData->appData, data, size);
 	this->setPacketDataLength(
 			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	this->setErrorControl();

From f612b095c1c508466098576866827dc065dc9809 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 19:39:19 +0200
Subject: [PATCH 0287/1292] updated tmtc packet base

---
 tmtcpacket/pus/TcPacketBase.cpp |  7 +++----
 tmtcpacket/pus/TcPacketBase.h   | 15 +++++++++------
 tmtcpacket/pus/TmPacketBase.cpp |  5 +++++
 tmtcpacket/pus/TmPacketBase.h   |  7 +++++++
 4 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 32caf5bb..733c36df 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -51,11 +51,10 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setApplicationData(const uint8_t * pData, uint16_t dataLen) {
-	setData(pData);
-	// packet data length is actual size of data field minus 1
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
 	SpacePacketBase::setPacketDataLength(dataLen +
-			sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
 }
 
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 9b858bd9..73076176 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -168,6 +168,14 @@ public:
 	 * current content of the packet.
 	 */
 	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
 	/**
 	 * With this method, the packet data pointer can be redirected to another
 	 * location.
@@ -178,12 +186,7 @@ public:
 	 * @param p_data	A pointer to another PUS Telecommand Packet.
 	 */
 	void setData( const uint8_t* pData );
-	/**
-	 * Set application data and corresponding length field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setApplicationData(const uint8_t * pData, uint16_t dataLen);
+
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index a7bda5af..a2c27ce1 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -102,6 +102,11 @@ void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t su
 	}
 }
 
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
 void TmPacketBase::setSourceDataSize(uint16_t size) {
 	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index d03beba5..6f3c4b59 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -125,6 +125,13 @@ public:
 	 * current content of the packet.
 	 */
 	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
 	/**
 	 * With this method, the packet data pointer can be redirected to another
 	 * location.

From e2418d61a6263f67f2db96ac265f0e271766a28c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 19:53:10 +0200
Subject: [PATCH 0288/1292] improved printer

---
 globalfunctions/printer.cpp | 24 +++++++++++++++++-------
 globalfunctions/printer.h   |  7 ++++---
 2 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index bf4c5848..01ec532c 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,36 +1,46 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size, OutputType type) {
-	sif::info << "Printing data with size " << size << ": [";
+void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
+		size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
 	if(type == OutputType::HEX) {
-		printer::printHex(data, size);
+		printer::printHex(data, size, maxCharPerLine);
 	}
 	else {
-		printer::printDec(data, size);
+		printer::printDec(data, size, maxCharPerLine);
 	}
 }
 
-void printer::printHex(uint8_t *data, size_t size) {
+void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
 		}
+
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(uint8_t *data, size_t size) {
+void printer::printDec(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
 		}
 	}
 	sif::info << "]" << std::endl;
 }
-
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index 3c9d6aa0..db9f343f 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -10,9 +10,10 @@ enum class OutputType {
 	HEX
 };
 
-void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX);
-void printHex(uint8_t* data, size_t size);
-void printDec(uint8_t* data, size_t size);
+void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+		bool printInfo = true, size_t maxCharPerLine = 12);
+void printHex(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From 1aef000eff336b97917ac4c178d95749ec9cd5dc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 20:24:58 +0200
Subject: [PATCH 0289/1292] printer improvements and fixes

tc packet stored getter function
---
 globalfunctions/printer.cpp       | 10 +++++-----
 globalfunctions/printer.h         |  6 +++---
 tmtcpacket/pus/TcPacketStored.cpp | 12 ++++++++++++
 tmtcpacket/pus/TcPacketStored.h   |  3 +++
 4 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index 01ec532c..f099113c 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,8 +1,8 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
-		size_t maxCharPerLine) {
+void printer::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
@@ -15,7 +15,7 @@ void printer::print(uint8_t *data, size_t size, OutputType type, bool printInfo,
 	}
 }
 
-void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -31,10 +31,10 @@ void printer::printHex(uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printDec(const uint8_t *data, size_t size, size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
+		sif::info << static_cast<int>(data[i]);
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index db9f343f..76d28e5f 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -10,10 +10,10 @@ enum class OutputType {
 	HEX
 };
 
-void print(uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
 		bool printInfo = true, size_t maxCharPerLine = 12);
-void printHex(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printDec(uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 47cf2ecd..64aa74dc 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,6 +1,7 @@
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
+
 #include <cstring>
 
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
@@ -20,6 +21,8 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
 	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
 		return;
 	}
 	this->setData(p_data);
@@ -30,6 +33,15 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	this->setErrorControl();
 }
 
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
 TcPacketStored::TcPacketStored() :
 		TcPacketBase(NULL) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index a9c49c2e..de3eb85f 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -74,6 +74,9 @@ public:
 	 * @param Size size of the packet.
 	 */
 	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
 	/**
 	 * This is a getter for the current store address of the packet.
 	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if

From 7afaa752f37422254f962982a41038afb0fbe8da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 20:25:54 +0200
Subject: [PATCH 0290/1292] form improvement

---
 globalfunctions/printer.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index f099113c..b71d70b8 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -15,7 +15,8 @@ void printer::print(const uint8_t *data, size_t size, OutputType type,
 	}
 }
 
-void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -31,7 +32,8 @@ void printer::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine)
 	sif::info << "]" << std::endl;
 }
 
-void printer::printDec(const uint8_t *data, size_t size, size_t maxCharPerLine) {
+void printer::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);

From 9b53e2b64fe9327f55eb12b393a91c666b836dde Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 22:45:48 +0200
Subject: [PATCH 0291/1292] added informative comment for counting semaphore

---
 osal/FreeRTOS/CountingSemaphore.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index adf3f23c..2b81848a 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,8 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
+// free FreeRTOSConfig.h file.
 CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
 		count(count), initCount(initCount) {
 	handle = xSemaphoreCreateCounting(count, initCount);

From 338651af2f7a67422cda787b56b513f020325df4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 19 May 2020 23:07:28 +0200
Subject: [PATCH 0292/1292] binary printer added

---
 globalfunctions/printer.cpp | 15 ++++++++++++++-
 globalfunctions/printer.h   |  4 +++-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
index b71d70b8..a68a91ee 100644
--- a/globalfunctions/printer.cpp
+++ b/globalfunctions/printer.cpp
@@ -1,5 +1,6 @@
 #include <framework/globalfunctions/printer.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <bitset>
 
 void printer::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
@@ -10,9 +11,12 @@ void printer::print(const uint8_t *data, size_t size, OutputType type,
 	if(type == OutputType::HEX) {
 		printer::printHex(data, size, maxCharPerLine);
 	}
-	else {
+	else if (type == OutputType::DEC) {
 		printer::printDec(data, size, maxCharPerLine);
 	}
+	else if(type == OutputType::BIN) {
+	    printer::printBin(data, size);
+	}
 }
 
 void printer::printHex(const uint8_t *data, size_t size,
@@ -46,3 +50,12 @@ void printer::printDec(const uint8_t *data, size_t size,
 	}
 	sif::info << "]" << std::endl;
 }
+
+void printer::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
index 76d28e5f..33a382ec 100644
--- a/globalfunctions/printer.h
+++ b/globalfunctions/printer.h
@@ -7,13 +7,15 @@ namespace printer {
 
 enum class OutputType {
 	DEC,
-	HEX
+	HEX,
+	BIN
 };
 
 void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
 		bool printInfo = true, size_t maxCharPerLine = 12);
 void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
 void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printBin(const uint8_t* data, size_t size);
 }
 
 #endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From f6b17d6e2ea6156d06214937c70bee305707a836 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 20 May 2020 12:50:56 +0200
Subject: [PATCH 0293/1292] deleted copyctor and copy assignment

---
 osal/FreeRTOS/BinarySemaphore.cpp | 21 ---------------------
 osal/FreeRTOS/BinarySemaphore.h   |  8 ++++----
 2 files changed, 4 insertions(+), 25 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index c4a363b4..026704d6 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -15,27 +15,6 @@ BinarySemaphore::~BinarySemaphore() {
 	vSemaphoreDelete(handle);
 }
 
-// This copy ctor is important as it prevents the assignment to a ressource
-// (other.handle) variable which is later deleted!
-BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
-    handle = xSemaphoreCreateBinary();
-    if(handle == nullptr) {
-        sif::error << "Binary semaphore creation failure" << std::endl;
-    }
-    xSemaphoreGive(handle);
-}
-
-BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
-    if(this != &s) {
-        handle = xSemaphoreCreateBinary();
-        if(handle == nullptr) {
-            sif::error << "Binary semaphore creation failure" << std::endl;
-        }
-        xSemaphoreGive(handle);
-    }
-    return *this;
-}
-
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0c9c0992..5f69dc90 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -39,10 +39,10 @@ public:
 
 	//! @brief Default ctor
 	BinarySemaphore();
-	//! @brief Copy ctor
-	BinarySemaphore(const BinarySemaphore&);
-	//! @brief Copy assignment
-	BinarySemaphore& operator=(const BinarySemaphore&);
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
 	//! @brief Move ctor
 	BinarySemaphore (BinarySemaphore &&);
 	//! @brief Move assignment

From d2d1ef9a854727a0381ccab719d2a8cba8a4acf0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 22 May 2020 00:58:30 +0200
Subject: [PATCH 0294/1292] better include guards

---
 storagemanager/LocalPool.tpp     |  4 ++--
 storagemanager/PoolManager.h     |  4 ++--
 storagemanager/PoolManager.tpp   |  4 ++--
 storagemanager/StorageAccessor.h | 25 +++++++++++--------------
 4 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 59d06ab8..32724bd8 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,5 +1,5 @@
-#ifndef LOCALPOOL_TPP
-#define LOCALPOOL_TPP
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 87670a82..6e353de2 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,5 +1,5 @@
-#ifndef POOLMANAGER_H_
-#define POOLMANAGER_H_
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
 
 #include <framework/storagemanager/LocalPool.h>
 #include <framework/ipc/MutexHelper.h>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 7025d795..854e22da 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,5 +1,5 @@
-#ifndef POOLMANAGER_TPP_
-#define POOLMANAGER_TPP_
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 8949642c..f6964b93 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,22 +1,19 @@
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details	These helper can be used together with the
- * 			StorageManager classes to manage access to a storage.
- * 			It can take care of thread-safety while also providing
- * 			mechanisms to automatically clear storage data.
- */
-#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
-#define TEST_PROTOTYPES_STORAGEACCESSOR_H_
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
 #include <framework/ipc/MutexHelper.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <memory>
 
 /**
- * @brief   Accessor class which can be returned by pool managers
- *          or passed and set by pool managers to have safe access to the pool
- *          resources.
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
  */
 class ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.

From d4abfacd27b09c17f898e80c62f969610a5d6367 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 22 May 2020 01:15:02 +0200
Subject: [PATCH 0295/1292] found solution for circ dependency

had to put store_address_t in own file though
---
 storagemanager/StorageAccessor.cpp |  1 +
 storagemanager/StorageAccessor.h   |  4 ++-
 storagemanager/StorageManagerIF.h  | 56 ++----------------------------
 storagemanager/storeAddress.h      | 54 ++++++++++++++++++++++++++++
 4 files changed, 61 insertions(+), 54 deletions(-)
 create mode 100644 storagemanager/storeAddress.h

diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index cc292d6c..c0c8126b 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,4 +1,5 @@
 #include <framework/storagemanager/StorageAccessor.h>
+#include <framework/storagemanager/StorageManagerIF.h>
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index f6964b93..57c9369c 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -2,7 +2,9 @@
 #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
 #include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/storagemanager/storeAddress.h>
+
+class StorageManagerIF;
 
 /**
  * @brief 	Helper classes to facilitate safe access to storages which is also
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 559c4b9a..af5aeb73 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -3,64 +3,14 @@
 
 #include <framework/events/Event.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
+#include <framework/storagemanager/StorageAccessor.h>
+#include <framework/storagemanager/storeAddress.h>
 #include <utility>
-
-class StorageAccessor;
-class ConstStorageAccessor;
+#include <cstddef>
 
 using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
 using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
-/**
- * This union defines the type that identifies where a data packet is
- * stored in the store. It comprises of a raw part to read it as raw value and
- * a structured part to use it in pool-like stores.
- */
-union store_address_t {
-	/**
-	 * Default Constructor, initializing to INVALID_ADDRESS
-	 */
-	store_address_t():raw(0xFFFFFFFF){}
-	/**
-	 * Constructor to create an address object using the raw address
-	 *
-	 * @param rawAddress
-	 */
-	store_address_t(uint32_t rawAddress):raw(rawAddress){}
-
-	/**
-	 * Constructor to create an address object using pool
-	 * and packet indices
-	 *
-	 * @param poolIndex
-	 * @param packetIndex
-	 */
-	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
-		pool_index(poolIndex),packet_index(packetIndex){}
-	/**
-	 * A structure with two elements to access the store address pool-like.
-	 */
-	struct {
-		/**
-		 * The index in which pool the packet lies.
-		 */
-		uint16_t pool_index;
-		/**
-		 * The position in the chosen pool.
-		 */
-		uint16_t packet_index;
-	};
-	/**
-	 * Alternative access to the raw value.
-	 */
-	uint32_t raw;
-
-	bool operator==(const store_address_t& other) const {
-		return raw == other.raw;
-	}
-};
-
 /**
  * @brief	This class provides an interface for intermediate data storage.
  * @details	The Storage manager classes shall be used to store larger chunks of
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
new file mode 100644
index 00000000..5dd785a3
--- /dev/null
+++ b/storagemanager/storeAddress.h
@@ -0,0 +1,54 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#define FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#include <cstdint>
+
+/**
+ * This union defines the type that identifies where a data packet is
+ * stored in the store. It comprises of a raw part to read it as raw value and
+ * a structured part to use it in pool-like stores.
+ */
+union store_address_t {
+	/**
+	 * Default Constructor, initializing to INVALID_ADDRESS
+	 */
+	store_address_t():raw(0xFFFFFFFF){}
+	/**
+	 * Constructor to create an address object using the raw address
+	 *
+	 * @param rawAddress
+	 */
+	store_address_t(uint32_t rawAddress):raw(rawAddress){}
+
+	/**
+	 * Constructor to create an address object using pool
+	 * and packet indices
+	 *
+	 * @param poolIndex
+	 * @param packetIndex
+	 */
+	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
+		pool_index(poolIndex),packet_index(packetIndex){}
+	/**
+	 * A structure with two elements to access the store address pool-like.
+	 */
+	struct {
+		/**
+		 * The index in which pool the packet lies.
+		 */
+		uint16_t pool_index;
+		/**
+		 * The position in the chosen pool.
+		 */
+		uint16_t packet_index;
+	};
+	/**
+	 * Alternative access to the raw value.
+	 */
+	uint32_t raw;
+
+	bool operator==(const store_address_t& other) const {
+		return raw == other.raw;
+	}
+};
+
+#endif /* FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_ */

From 2f16b1e7336a1b174bfc0da4ae5437c925c6ac21 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 13:48:43 +0200
Subject: [PATCH 0296/1292] moved some files

---
 datapool/PoolRawAccessHelper.h               | 2 +-
 datapoolglob/DataPoolAdmin.cpp               | 2 +-
 datapoolglob/DataPoolParameterWrapper.cpp    | 2 +-
 {datapool => datapoolglob}/PIDReader.h       | 0
 {datapool => datapoolglob}/PIDReaderList.h   | 8 ++++----
 {datapool => datapoolglob}/PoolRawAccess.cpp | 2 +-
 {datapool => datapoolglob}/PoolRawAccess.h   | 0
 monitoring/MonitorBase.h                     | 2 +-
 power/Fuse.h                                 | 2 +-
 power/PowerSensor.h                          | 2 +-
 10 files changed, 11 insertions(+), 11 deletions(-)
 rename {datapool => datapoolglob}/PIDReader.h (100%)
 rename {datapool => datapoolglob}/PIDReaderList.h (73%)
 rename {datapool => datapoolglob}/PoolRawAccess.cpp (99%)
 rename {datapool => datapoolglob}/PoolRawAccess.h (100%)

diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index f2434241..52d9ebe5 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,9 +7,9 @@
 #ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 #define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
 
-#include <framework/datapool/PoolRawAccess.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
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index f32ff567..05de1eb2 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,7 @@
 #include <framework/datapoolglob/DataPoolAdmin.h>
-#include <framework/datapool/PoolRawAccess.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>
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index d93cd88e..062cff12 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,6 +1,6 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/DataPoolParameterWrapper.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/parameters/HasParametersIF.h>
 
 
diff --git a/datapool/PIDReader.h b/datapoolglob/PIDReader.h
similarity index 100%
rename from datapool/PIDReader.h
rename to datapoolglob/PIDReader.h
diff --git a/datapool/PIDReaderList.h b/datapoolglob/PIDReaderList.h
similarity index 73%
rename from datapool/PIDReaderList.h
rename to datapoolglob/PIDReaderList.h
index 07d1b8e6..0b838508 100644
--- a/datapool/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOL_PIDREADERLIST_H_
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
 
-#include <framework/datapool/PIDReader.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoolglob/PIDReader.h>
 template <class T, uint8_t n_var>
 class PIDReaderList {
 private:
@@ -24,4 +24,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ */
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapool/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
similarity index 99%
rename from datapool/PoolRawAccess.cpp
rename to datapoolglob/PoolRawAccess.cpp
index 778e1b9c..cc04f9b9 100644
--- a/datapool/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,5 +1,5 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolRawAccess.h>
+#include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
diff --git a/datapool/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
similarity index 100%
rename from datapool/PoolRawAccess.h
rename to datapoolglob/PoolRawAccess.h
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index d66e956d..f18ca4b5 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -2,7 +2,7 @@
 #define MONITORBASE_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PIDReader.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/monitoring/LimitViolationReporter.h>
 #include <framework/monitoring/MonitoringIF.h>
 #include <framework/monitoring/MonitoringMessageContent.h>
diff --git a/power/Fuse.h b/power/Fuse.h
index 44f8964f..0f258b63 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -3,7 +3,7 @@
 
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapool/PIDReader.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/AbsLimitMonitor.h>
 #include <framework/power/PowerComponentIF.h>
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index f94088a8..0fb47506 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -2,8 +2,8 @@
 #define POWERSENSOR_H_
 
 #include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapool/PIDReader.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
+#include <framework/datapoolglob/PIDReader.h>
 #include <framework/devicehandlers/HealthDevice.h>
 #include <framework/monitoring/LimitMonitor.h>
 #include <framework/parameters/ParameterHelper.h>

From 723e715022e6d5ada2dfdee9da5a6f3d7450faa9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 14:01:35 +0200
Subject: [PATCH 0297/1292] consistency fix

---
 storagemanager/LocalPool.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 6892b881..c155f918 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -12,7 +12,7 @@
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
  * 			a fixed pool size policy.
- * \details	The class implements the StorageManagerIF interface. While the
+ * @details	The class implements the StorageManagerIF interface. While the
  * 			total number of pools is fixed, the element sizes in one pool and
  * 			the number of pool elements per pool are set on construction.
  * 			The full amount of memory is allocated on construction.

From a37f01cd0ee31c57f8f76f3b299c2f51718e9d85 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:11:56 +0200
Subject: [PATCH 0298/1292] improved readability of mode explanations

---
 devicehandlers/DeviceHandlerIF.h | 60 ++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 34aa4114..59ee1853 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,19 +28,57 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	//!< The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
 	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
 	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
 	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);

From 18d19fbb2c7575cf7b880e0caebf5cbcbc447358 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:12:25 +0200
Subject: [PATCH 0299/1292] < removed

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 59ee1853..f6b29e25 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,7 +28,7 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//!< The device is powered on and the device handler periodically sends
+	//! The device is powered on and the device handler periodically sends
 	//! commands. The commands to be sent are selected by the handler
 	//! according to the submode.
 	static const Mode_t MODE_NORMAL = 2;

From eacda67f027dc24a65f60f08b837b2358aa094f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:36:03 +0200
Subject: [PATCH 0300/1292] added some comments for returnvalues

---
 devicehandlers/DeviceHandlerBase.h | 34 ++++++++++++++++--------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 454f0751..cfa9396a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -509,26 +509,28 @@ protected:
 	 */
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	/**
-	 * These returnvalues can be returned from abstract functions
+	/* These returnvalues can be returned from abstract functions
 	 * to alter the behaviour of DHB.For error values, refer to
-	 * DeviceHandlerIF.h returnvalues.
-	 */
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(4);
+	 * DeviceHandlerIF.h returnvalues. */
+	// (Robin): maybe this would be better in DeviceHandlerIF?
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
+
 	// Returnvalues for scanForReply()
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(5); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(6); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(7); //!< Ignore full received packet
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
 
-//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(12);
+	// Returnvalues for command building
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xC1);
+	// (Robin): Maybe this would be better in DeviceHandlerIF?
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC3);
 
-	//Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE2);
+	// (Robin): Maybe this would be better in DeviceHandlerIF?
+	// Mode handling error Codes
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xD1);
 
 	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;

From 243ea9cd8782a4edd74259351b8fb536fdf95bca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:38:51 +0200
Subject: [PATCH 0301/1292] improved dhb IF returnvalues

---
 devicehandlers/DeviceHandlerIF.h | 119 ++++++++++++++++++-------------
 1 file changed, 69 insertions(+), 50 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 34aa4114..666d9efc 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -28,19 +28,57 @@ public:
 
 	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Mode_t MODE_NORMAL = 2; //!< The device is powered on and the device handler periodically sends commands. The commands to be sent are selected by the handler according to the submode.
-	static const Mode_t MODE_RAW = 3; //!< The device is powered on and ready to perform operations. In this mode, raw commands can be sent. The device handler will send all replies received from the command back to the commanding object.
-	static const Mode_t MODE_ERROR_ON = 4; //!4< The device is shut down but the switch could not be turned off, so the device still is powered. In this mode, only a mode change to @c MODE_OFF can be commanded, which tries to switch off the device again.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The device handler performs all commands to get the device in a state ready to perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6; //!< This is a transitional state which can not be commanded. The device handler performs all actions and commands to get the device shut down. When the device is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON; //!< It is possible to set the mode to _MODE_TO_ON to use the to on transition if available.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
 	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
 	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1; //!< This is a transitional state which can not be commanded. The device is shut down and ready to be switched off. After the command to set the switch off has been sent, the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2; //!< This is a transitional state which can not be commanded. The device will be switched on in this state. After the command to set the switch on has been sent, the mode changes to @c MODE_WAIT_ON
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3; //!< This is a transitional state which can not be commanded. The switch has been commanded off and the handler waits for it to be off. When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4; //!< This is a transitional state which can not be commanded. The switch has been commanded on and the handler waits for it to be on. When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5; //!< This is a transitional state which can not be commanded. The switch has been commanded off and is off now. This state is only to do an RMAP cycle once more where the doSendRead() function will set the mode to MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
 	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
@@ -58,47 +96,34 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xA0); //!< Return this if no command sending in required
-	// Mostly used for internal handling.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA2); //!< If the command size is 0. Checked in DHB
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA3); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA4); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA5); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xAA);
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xAB);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAC);
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 
 	// Standard codes used in scanForReply
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB1); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB3); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB4); //!< Ignore full received packet
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB5);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB6);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB7);
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
 
 	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC1); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC2);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC3); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC4); //syntax etc is correct but still not ok, eg parameters where none are expected
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand
 	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
 	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
 
-	// Standard codes used in getSwitches
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xE1); //!< Return in getSwitches() to specify there are no switches
-
-	//	static const ReturnValue_t ONE_SWITCH = MAKE_RETURN_CODE(8);
-	//	static const ReturnValue_t TWO_SWITCHES = MAKE_RETURN_CODE(9);
-	// where is this used?
-	// static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(11);
-
 	/**
 	 * Communication action that will be executed.
 	 *
@@ -115,16 +140,10 @@ public:
 	/**
 	 * Default Destructor
 	 */
-	virtual ~DeviceHandlerIF() {
-
-	}
+	virtual ~DeviceHandlerIF() {}
 
 	/**
 	 * This MessageQueue is used to command the device handler.
-	 *
-	 * To command a device handler, a DeviceHandlerCommandMessage can be sent to this Queue.
-	 * The handler replies with a DeviceHandlerCommandMessage containing the DeviceHandlerCommand_t reply.
-	 *
 	 * @return the id of the MessageQueue
 	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;

From 3fd306356a4b2eefeb78bf6f4cf6d197b7c5c7ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 25 May 2020 23:43:44 +0200
Subject: [PATCH 0302/1292] fix for dh returnvalues

---
 devicehandlers/DeviceHandlerBase.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index cfa9396a..74b84111 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -522,15 +522,16 @@ protected:
 
 	// Returnvalues for command building
 	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xC1);
 	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC3);
+
+	// Returnvalues for getSwitches()
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
 
 	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	// Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xD1);
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
 
 	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;

From 242ca355f51008eb9ada619295cf397dbc49ae35 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 00:01:07 +0200
Subject: [PATCH 0303/1292] removed swappers for arraylist for now

---
 container/ArrayList.h      | 19 -------------------
 container/FixedArrayList.h |  9 +++------
 2 files changed, 3 insertions(+), 25 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index f978c984..a37a1c42 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -250,25 +250,6 @@ protected:
 	 * true if the array was allocated and needs to be deleted in the destructor.
 	 */
 	bool allocated;
-
-	/**
-	 * Swap the endianness of the Array list (not the length field !)
-	 * Useful if the case the buffer type is larger than uint8_t
-	 * @param list
-	 */
-	void swapArrayListEndianness() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		count_t i = 0;
-		// uint8_t buffer does not require swapping of entries.
-		if(sizeof(T) == 1) {
-			return;
-		}
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < size)) {
-			T newEntry = EndianSwapper::swap(entries[i]);
-			entries[i] = newEntry;
-			++i;
-		}
-	}
 };
 
 #endif /* ARRAYLIST_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 5d93db90..a2d2fa25 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -20,7 +20,8 @@ public:
 			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
+	// (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?
 	/**
@@ -30,14 +31,10 @@ public:
 	 * @param count
 	 * @param swapArrayListEndianess
 	 */
-	FixedArrayList(T * data_, count_t count,
-			bool swapArrayListEndianess = false):
+	FixedArrayList(T * data_, count_t count):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;
-		if(swapArrayListEndianess) {
-			ArrayList<T, count_t>::swapArrayListEndianness();
-		}
 	}
 
 	FixedArrayList(const FixedArrayList& other) :

From 9f2d5b64e009349a03be6990f43b8a3fddc5a02b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 01:03:26 +0200
Subject: [PATCH 0304/1292] comment improvements

---
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 devicehandlers/DeviceHandlerBase.h   | 36 ++++++++++++++++++----------
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 23ec1f18..6c769cdf 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -417,7 +417,7 @@ void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
 	transitionSourceSubMode = submode;
 	childTransitionFailure = CHILD_TIMEOUT;
 
-//transitionTargetMode is set by setMode
+	// transitionTargetMode is set by setMode
 	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 74b84111..8932e109 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -740,28 +740,40 @@ protected:
 	/**
 	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
 	 *
-	 * If the transition is complete, the mode should be set to the target mode, which can be deduced from the current mode which is
+	 * If the transition is complete, the mode should be set to the target mode,
+	 * which can be deduced from the current mode which is
 	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
 	 *
-	 * The intended target submode is already set. The origin submode can be read in subModeFrom.
+	 * The intended target submode is already set.
+	 * The origin submode can be read in subModeFrom.
 	 *
-	 * If the transition can not be completed, the child class can try to reach an working mode by setting the mode either directly
-	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW) if the device needs to be reconfigured.
+	 * If the transition can not be completed, the child class can try to reach
+	 * an working mode by setting the mode either directly
+	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW)
+	 * if the device needs to be reconfigured.
 	 *
-	 * If nothing works, the child class can wait for the timeout and the base class will reset the mode to the mode where the transition
+	 * If nothing works, the child class can wait for the timeout and the base
+	 * class will reset the mode to the mode where the transition
 	 * originated from (the child should report the reason for the failed transition).
 	 *
-	 * The intended way to send commands is to set a flag (enum) indicating which command is to be sent here
-	 * and then to check in buildTransitionCommand() for the flag. This flag can also be used by doStartUp() and
-	 * doShutDown() to get a nice and clean implementation of buildTransitionCommand() without switching through modes.
+	 * The intended way to send commands is to set a flag (enum) indicating
+	 * which command is to be sent here and then to check in
+	 * buildTransitionCommand() for the flag. This flag can also be used by
+	 * doStartUp() and doShutDown() to get a nice and clean implementation of
+	 * buildTransitionCommand() without switching through modes.
 	 *
-	 * When the the condition for the completion of the transition is met, the mode can be set, for example in the parseReply() function.
+	 * When the the condition for the completion of the transition is met, the
+	 * mode can be set, for example in the scanForReply() function.
 	 *
-	 * The default implementation goes into the target mode;
+	 * The default implementation goes into the target mode directly.
 	 *
-	 * #transitionFailure can be set to a failure code indicating the reason for a failed transition
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
 	 *
-	 * @param modeFrom the mode the transition originated from: [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed from _MODE_START_UP to _MODE_TO_ON)]
+	 * @param modeFrom
+	 * The mode the transition originated from:
+	 * [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed
+	 * from _MODE_START_UP to _MODE_TO_ON)]
 	 * @param subModeFrom the subMode of modeFrom
 	 */
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);

From a19fa231f51c6b83c0417afe08e208e2bc8c2563 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 01:21:48 +0200
Subject: [PATCH 0305/1292] comment improvements

---
 devicehandlers/DeviceHandlerBase.h | 5 +++--
 devicehandlers/DeviceHandlerIF.h   | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8932e109..832d7e08 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -232,8 +232,9 @@ protected:
 	 * Build the device command to send for a transitional mode.
 	 *
 	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_TO_POWER_DOWN. So it is used by doStartUp()
-	 * and doShutDown() as well as doTransition()
+	 * @c _MODE_START_UP and @c _MODE_SHUT_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition(), by setting those
+	 * modes in the respective functions.
 	 *
 	 * A good idea is to implement a flag indicating a command has to be built
 	 * and a variable containing the command number to be built
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 666d9efc..cb190344 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -47,6 +47,8 @@ public:
 	//! This is a transitional state which can not be commanded.
 	//! The device handler performs all actions and commands to get the device
 	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
 	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
 	//! It is possible to set the mode to _MODE_TO_ON to use the to on
 	//! transition if available.

From 1a623a6a527599efc6ee8d4e28e85c405c58cb9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 11:05:49 +0200
Subject: [PATCH 0306/1292] added override

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 832d7e08..244be322 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -494,7 +494,7 @@ public:
 	ReturnValue_t setHealth(HealthState health);
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
+			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
 	/**
 	 * Implementation of ExecutableObjectIF function
 	 *

From f7dd91891a644c660ff8ae7d6c183e84faf75d9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 26 May 2020 16:05:03 +0200
Subject: [PATCH 0307/1292] removed comments

---
 devicehandlers/DeviceHandlerBase.h | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 244be322..1debcdcb 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -510,26 +510,16 @@ protected:
 	 */
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
 
-	/* These returnvalues can be returned from abstract functions
-	 * to alter the behaviour of DHB.For error values, refer to
-	 * DeviceHandlerIF.h returnvalues. */
-	// (Robin): maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-
 	// Returnvalues for scanForReply()
 	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
 	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
 	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-
 	// Returnvalues for command building
 	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-
 	// Returnvalues for getSwitches()
 	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-
-	// (Robin): Maybe this would be better in DeviceHandlerIF?
 	// Mode handling error Codes
 	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
 	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);

From be4ac0bc8fa03faee1330a9899cb9051485eebba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 00:28:13 +0200
Subject: [PATCH 0308/1292] added semaph factory to linux

---
 osal/FreeRTOS/BinarySemaphore.cpp |  2 ++
 osal/linux/SemaphoreFactory.cpp   | 36 +++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)
 create mode 100644 osal/linux/SemaphoreFactory.cpp

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 026704d6..e6c308db 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,6 +3,8 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
new file mode 100644
index 00000000..7b80176b
--- /dev/null
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -0,0 +1,36 @@
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+		uint8_t initCount) {
+	sif::error << "Counting Semaphore not implemented for "
+			"Linux yet" << std::endl;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

From f6ae0348cb50dddefa867dc3a0344dac99efef2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 11:41:36 +0200
Subject: [PATCH 0309/1292] some linux mutex tweaks

---
 osal/linux/Mutex.cpp | 4 +++-
 osal/linux/Mutex.h   | 4 ++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 36bb3ce4..b4773267 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -25,7 +25,9 @@ Mutex::Mutex() {
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 	}
-	//After a mutex attributes object has been used to initialize one or more mutexes, any function affecting the attributes object (including destruction) shall not affect any previously initialized mutexes.
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index d02d008f..872ac3ac 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -2,7 +2,11 @@
 #define OS_RTEMS_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
+
+extern "C" {
 #include <pthread.h>
+}
+
 
 class Mutex : public MutexIF {
 public:

From badcacad49e3790df3cda101dc9da973287238de Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 11:48:11 +0200
Subject: [PATCH 0310/1292] added new timeout values

---
 osal/FreeRTOS/BinarySemaphore.cpp  | 2 --
 osal/FreeRTOS/SemaphoreFactory.cpp | 2 ++
 osal/linux/SemaphoreFactory.cpp    | 1 +
 tasks/SemaphoreIF.h                | 4 +++-
 4 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6c308db..026704d6 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -3,8 +3,6 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 9a355891..7bd71dd7 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -4,6 +4,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
 
 SemaphoreFactory::SemaphoreFactory() {
 }
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 7b80176b..b1100e75 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -2,6 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 7dde27f4..b2b113f1 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -20,8 +20,10 @@
 class SemaphoreIF {
 public:
 	virtual~ SemaphoreIF() {};
-	//!< Needs to be defined in implementation.
+	//! Needs to be defined in implementation. No blocking time
 	static const uint32_t NO_TIMEOUT;
+	//! Needs to be defined in implementation. Blocks indefinitely.
+	static const uint32_t MAX_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);

From 968d7fad815877213c154845bc058140e47ee91b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 17:07:35 +0200
Subject: [PATCH 0311/1292] replaced some timeout values

---
 osal/FreeRTOS/BinarySemaphore.cpp |  9 ++++-----
 osal/FreeRTOS/BinarySemaphore.h   | 20 ++++++--------------
 2 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 026704d6..98911ad1 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,6 +1,5 @@
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
-
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 BinarySemaphore::BinarySemaphore() {
@@ -39,11 +38,11 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
-	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 5f69dc90..7079e91f 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -3,13 +3,14 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
+
 extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 }
 
-// TODO: Counting semaphores and implement the new (better)
-//		 task notifications. However, those use task notifications require
+// TODO: Implement the new (better) task notifications.
+//		 However, those task notifications require
 //		 the task handle. Maybe it would be better to make a separate class
 // 		 and switch between the classes with #ifdefs.
 //		 Task Notifications require FreeRTOS V8.2 something..
@@ -27,15 +28,6 @@ class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! No block time, poll the semaphore. Can also be used as tick type.
-	//! Can be passed as tick type and ms value.
-	static constexpr uint32_t NO_BLOCK_TIMEOUT = 0;
-	static constexpr TickType_t NO_BLOCK_TICKS = 0;
-	//! No block time, poll the semaphore.
-	//! Can be passed as tick type and ms value.
-	static constexpr TickType_t BLOCK_TIMEOUT_TICKS = portMAX_DELAY;
-	static constexpr uint32_t BLOCK_TIMEOUT = portMAX_DELAY;
 
 	//! @brief Default ctor
 	BinarySemaphore();
@@ -51,7 +43,7 @@ public:
 	virtual ~BinarySemaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -65,7 +57,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+	       	   SemaphoreIF::NO_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -74,7 +66,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_BLOCK_TICKS);
+	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
 	 * Give back the binary semaphore

From 2d33274c2306fd51b4ea512d5d399502755f20fa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 17:42:18 +0200
Subject: [PATCH 0312/1292] implementing new task notifications

---
 osal/FreeRTOS/BinarySemaphore.cpp | 69 +++++++++++++++++++---
 osal/FreeRTOS/BinarySemaphore.h   | 95 +++++++++++++++++++++++++++----
 2 files changed, 145 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 98911ad1..f7e87983 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,6 +2,8 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+#if ( configUSE_OLD_SEMAPHORES == 1 )
+
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
@@ -51,7 +53,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-	    return SEMAPHORE_TIMEOUT;
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
@@ -96,14 +98,6 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
-
-void BinarySemaphore::resetSemaphore() {
-	if(handle != nullptr) {
-		vSemaphoreDelete(handle);
-		handle = xSemaphoreCreateBinary();
-		xSemaphoreGive(handle);
-	}
-}
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
@@ -135,3 +129,60 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
+
+
+#else
+
+BinarySemaphore::BinarySemaphore() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return giveBinarySemaphore();
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+	if (handle == nullptr) {
+		return SEMAPHORE_NULLPOINTER;
+	}
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+#endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 7079e91f..4d95fc27 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,7 +6,11 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
+#if ( configUSE_OLD_SEMAPHORES == 1 )
 #include <freertos/semphr.h>
+#else
+#include <freertos/task.h>
+#endif
 }
 
 // TODO: Implement the new (better) task notifications.
@@ -24,11 +28,13 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
+#if ( configUSE_OLD_SEMAPHORES == 1 )
+
 class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
+		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
+
 	//! @brief Default ctor
 	BinarySemaphore();
 	//! @brief Copy ctor, deleted explicitely.
@@ -46,7 +52,7 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
-
+
 	/**
 	 * Take the binary semaphore.
 	 * If the semaphore has already been taken, the task will be blocked
@@ -81,11 +87,6 @@ public:
 	 */
 	SemaphoreHandle_t getSemaphore();
 
-	/**
-	 * Reset the semaphore.
-	 */
-	void resetSemaphore();
-
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
@@ -104,9 +105,83 @@ public:
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
-
-protected:
+
+protected:
 	SemaphoreHandle_t handle;
 };
 
+
+#else
+
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() override;
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        BinarySemaphore::NO_TIMEOUT);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(TaskHandle_t taskToNotify);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
+	 *        was unblocked
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	TaskHandle_t handle;
+};
+#endif
+
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

From 8a1e0dab0370c5b454fcb9e95de0f1349000b380 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:03:46 +0200
Subject: [PATCH 0313/1292] continued with task notifications

---
 osal/FreeRTOS/BinarySemaphore.cpp   | 48 ++++++++++++++++++++++++++---
 osal/FreeRTOS/BinarySemaphore.h     |  8 +++--
 osal/FreeRTOS/CountingSemaphore.cpp |  4 +++
 3 files changed, 53 insertions(+), 7 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index f7e87983..150f8c99 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,7 +2,7 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
@@ -174,9 +174,6 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	if (handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
-	}
 	BaseType_t returncode = xTaskNotifyGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -185,4 +182,47 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	}
 }
 
+TaskHandle_t BinarySemaphore::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+
+ReturnValue_t BinarySemaphore::giveBinarySemaphore(TaskHandle_t taskHandle) {
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 #endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 4d95fc27..2ee10226 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,7 +6,7 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 #include <freertos/semphr.h>
 #else
 #include <freertos/task.h>
@@ -28,7 +28,7 @@ extern "C" {
  * @author 	R. Mueller
  * @ingroup osal
  */
-#if ( configUSE_OLD_SEMAPHORES == 1 )
+#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 
 class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
@@ -155,7 +155,7 @@ public:
 	ReturnValue_t giveBinarySemaphore();
 
 	/**
-	 * Get Handle to the semaphore.
+	 * Get handle to the task related to the semaphore.
 	 * @return
 	 */
 	TaskHandle_t getTaskHandle();
@@ -179,6 +179,8 @@ public:
 	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
 				BaseType_t * higherPriorityTaskWoken);
 
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+
 protected:
 	TaskHandle_t handle;
 };
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2b81848a..e04d3def 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,10 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+extern "C" {
+#include <freertos/semphr.h>
+}
+
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
 CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):

From b4065c776437b39613542d9beff87ba06e6242ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:46:56 +0200
Subject: [PATCH 0314/1292] seperation of semaph implementations finished

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 95 ++++++++++++++++++++++
 osal/FreeRTOS/BinSemaphUsingTask.h        | 86 ++++++++++++++++++++
 osal/FreeRTOS/BinarySemaphore.cpp         | 99 -----------------------
 osal/FreeRTOS/BinarySemaphore.h           | 93 ++-------------------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  8 ++
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 25 ++++++
 osal/FreeRTOS/CountingSemaphore.cpp       |  2 +
 osal/FreeRTOS/SemaphoreFactory.cpp        |  6 +-
 tasks/SemaphoreFactory.h                  | 10 ++-
 9 files changed, 232 insertions(+), 192 deletions(-)
 create mode 100644 osal/FreeRTOS/BinSemaphUsingTask.cpp
 create mode 100644 osal/FreeRTOS/BinSemaphUsingTask.h
 create mode 100644 osal/FreeRTOS/CountingSemaphUsingTask.cpp
 create mode 100644 osal/FreeRTOS/CountingSemaphUsingTask.h

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
new file mode 100644
index 00000000..0d732054
--- /dev/null
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -0,0 +1,95 @@
+#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+
+BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
+	return takeBinarySemaphore(timeoutMs);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release() {
+	return giveBinarySemaphore();
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > BinarySemaphoreUsingTask::NO_TIMEOUT){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
+        TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHandle) {
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return SEMAPHORE_NOT_OWNED;
+	}
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphoreFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
new file mode 100644
index 00000000..2736b1db
--- /dev/null
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -0,0 +1,86 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/SemaphoreIF.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+class BinarySemaphoreUsingTask: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphoreUsingTask();
+
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() override;
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	        SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Give back the binary semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t giveBinarySemaphore();
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphore(TaskHandle_t taskToNotify);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
+	 *        was unblocked
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+
+protected:
+	TaskHandle_t handle;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 150f8c99..d56be763 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -2,8 +2,6 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
-
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
@@ -129,100 +127,3 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
-
-
-#else
-
-BinarySemaphore::BinarySemaphore() {
-	handle = TaskManagement::getCurrentTaskHandle();
-}
-
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return giveBinarySemaphore();
-}
-
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
-	}
-	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
-	    timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
-        TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
-	}
-}
-
-TaskHandle_t BinarySemaphore::getTaskHandle() {
-	return handle;
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
-}
-
-
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(TaskHandle_t taskHandle) {
-	BaseType_t returncode = xTaskNotifyGive(taskHandle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
-	}
-}
-
-// Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
-		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2ee10226..e5c0ce4b 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -6,18 +6,9 @@
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
 #include <freertos/semphr.h>
-#else
-#include <freertos/task.h>
-#endif
 }
 
-// TODO: Implement the new (better) task notifications.
-//		 However, those task notifications require
-//		 the task handle. Maybe it would be better to make a separate class
-// 		 and switch between the classes with #ifdefs.
-//		 Task Notifications require FreeRTOS V8.2 something..
 /**
  * @brief 	OS Tool to achieve synchronization of between tasks or between
  * 			task and ISR. The default semaphore implementation creates a
@@ -25,11 +16,15 @@ extern "C" {
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
  *
+ * Please note that if the semaphore implementation is only related to
+ * the synchronization of one task, the new task notifications can be used,
+ * also see the BinSemaphUsingTask and CountingSemaphUsingTask classes.
+ * These use the task notification value instead of a queue and are
+ * faster and more efficient.
+ *
  * @author 	R. Mueller
  * @ingroup osal
  */
-#if ( configUSE_TASK_NOTIFICATIONS == 0 )
-
 class BinarySemaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
@@ -110,80 +105,4 @@ protected:
 	SemaphoreHandle_t handle;
 };
 
-
-#else
-
-class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphore();
-
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
-	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() override;
-
-	/**
-	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked
-	 * for a maximum of #timeoutMs or until the semaphore is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
-
-	/**
-	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
-	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
-
-	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t giveBinarySemaphore();
-
-	/**
-	 * Get handle to the task related to the semaphore.
-	 * @return
-	 */
-	TaskHandle_t getTaskHandle();
-
-	 /**
-	 * Wrapper function to give back semaphore from handle
-	 * @param semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t giveBinarySemaphore(TaskHandle_t taskToNotify);
-
-	/**
-	 * Wrapper function to give back semaphore from handle when called from an ISR
-	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
-	 *        was unblocked
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
-
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
-
-protected:
-	TaskHandle_t handle;
-};
-#endif
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
new file mode 100644
index 00000000..6c5d45c7
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -0,0 +1,8 @@
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
+
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
+		uint8_t initCount):
+		count(count), initCount(initCount) {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
new file mode 100644
index 00000000..c4bfb61a
--- /dev/null
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
+#include <framework/tasks/SemaphoreIF.h>
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+class CountingSemaphoreUsingTask: public SemaphoreIF {
+public:
+	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
+
+	ReturnValue_t acquire(uint32_t timeoutMs);
+	ReturnValue_t release();
+
+private:
+	TaskHandle_t handle;
+	uint8_t count = 0;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index e04d3def..2f0dfd76 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,5 +1,6 @@
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/FreeRTOS/TaskManagement.h>
 
 extern "C" {
 #include <freertos/semphr.h>
@@ -30,3 +31,4 @@ CountingSemaphore& CountingSemaphore::operator =(
 	}
 	return * this;
 }
+
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 7bd71dd7..1eee1bac 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -21,15 +21,15 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 	return SemaphoreFactory::factoryInstance;
 }
 
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
-		uint8_t initCount) {
+		uint8_t initCount, uint32_t argument) {
 	return new CountingSemaphore(count, initCount);
 }
 
-void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
 	delete semaphore;
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index fa95399a..971e97fa 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -20,19 +20,23 @@ public:
 	/**
 	 * Create a binary semaphore.
 	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
 	 * @return Pointer to newly created semaphore class instance.
 	 */
-	SemaphoreIF* createBinarySemaphore();
+	SemaphoreIF* createBinarySemaphore(uint32_t argument = 0);
 	/**
 	 * Create a counting semaphore.
 	 * Creator functons for a counting semaphore which may be acquired multiple
 	 * times.
 	 * @param count Semaphore can be taken count times.
 	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount);
-	void deleteMutex(SemaphoreIF* mutex);
+	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount,
+			uint32_t argument = 0);
+
+	void deleteSemaphore(SemaphoreIF* mutex);
 
 private:
 	/**

From eabee85ba9f1dd014abc66d13e212427dc328242 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:56:02 +0200
Subject: [PATCH 0315/1292] tweaked factory to have configurability

---
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 13 ++++++++++
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  5 ++--
 osal/FreeRTOS/SemaphoreFactory.cpp        | 30 +++++++++++++++++++++--
 3 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 6c5d45c7..10365d7e 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -6,3 +6,16 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
 		count(count), initCount(initCount) {
 	handle = TaskManagement::getCurrentTaskHandle();
 }
+
+ReturnValue_t CountingSemaphoreUsingTask::acquire(
+		uint32_t timeoutMs) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() {
+	return 0;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index c4bfb61a..7fc98e93 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -13,8 +13,9 @@ class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
 	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
 
-	ReturnValue_t acquire(uint32_t timeoutMs);
-	ReturnValue_t release();
+	ReturnValue_t acquire(uint32_t timeoutMs) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() override;
 
 private:
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 1eee1bac..6acdc7b7 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,5 +1,7 @@
 #include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
 #include <framework/tasks/SemaphoreFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
@@ -7,6 +9,9 @@ SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
 const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
 
+static const uint32_t USE_REGULAR_SEMAPHORES = 0;
+static const uint32_t USE_TASK_NOTIFICATIONS = 1;
+
 SemaphoreFactory::SemaphoreFactory() {
 }
 
@@ -22,12 +27,33 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-	return new BinarySemaphore();
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new BinarySemaphore();
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new BinarySemaphoreUsingTask();
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+				"binary semaphore" << std::endl;
+		return new BinarySemaphore();
+	}
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
 		uint8_t initCount, uint32_t argument) {
-	return new CountingSemaphore(count, initCount);
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new CountingSemaphore(count, initCount);
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new CountingSemaphoreUsingTask(count, initCount);
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+						"binary semaphore" << std::endl;
+		return new CountingSemaphore(count, initCount);
+	}
+
 }
 
 void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {

From 7145982b4ade5f3da12e8dd05161b11e45512998 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 19:59:59 +0200
Subject: [PATCH 0316/1292] improved documentation

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp | 2 +-
 osal/FreeRTOS/BinSemaphUsingTask.h   | 6 ++++++
 tasks/SemaphoreIF.h                  | 3 ++-
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 0d732054..d6bc02bc 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -19,7 +19,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs)
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphoreUsingTask::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 2736b1db..8b8a7773 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -9,6 +9,12 @@ extern "C" {
 #include <freertos/task.h>
 }
 
+/**
+ * @brief 	Binary Semaphore implementation using Task Notifications
+ * @details
+ * Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ * and general semaphore documentation.
+ */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index b2b113f1..fb181cca 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -12,7 +12,8 @@
  * A semaphore is a synchronization primitive.
  * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
  * A semaphore can be used to achieve task synchonization and track the
- * availability of resources.
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
  *
  * If mutual exlcusion of a resource is desired, a mutex should be used,
  * which is a special form of a semaphore and has an own interface.

From 88e3dc15b2604de0c337f2bf4911ee5e4780588f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:27:31 +0200
Subject: [PATCH 0317/1292] replaced old semaph api

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 16 +++++++++++++---
 osal/FreeRTOS/BinSemaphUsingTask.h        |  3 +++
 osal/FreeRTOS/BinarySemaphore.cpp         | 22 ++++++++--------------
 osal/FreeRTOS/BinarySemaphore.h           | 11 ++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 15 ++++++++++++---
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 +++---
 osal/FreeRTOS/SemaphoreFactory.cpp        |  8 ++++----
 tasks/SemaphoreFactory.h                  |  2 +-
 8 files changed, 48 insertions(+), 35 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d6bc02bc..8cdcbc33 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -4,6 +4,8 @@
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
+	xTaskNotifyGive(handle);
+	locked = false;
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
@@ -25,6 +27,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs)
 
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
 	if (returncode == pdPASS) {
+		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -36,6 +39,7 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
+		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		return SEMAPHORE_TIMEOUT;
@@ -43,11 +47,15 @@ ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+	if(not locked) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
 	BaseType_t returncode = xTaskNotifyGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return SEMAPHORE_NOT_OWNED;
+		// This should never happen
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
@@ -77,8 +85,10 @@ ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHan
 	BaseType_t returncode = xTaskNotifyGive(taskHandle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
 
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 8b8a7773..e44b838c 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -85,6 +85,9 @@ public:
 
 protected:
 	TaskHandle_t handle;
+	// This boolean is required to track whether the semaphore is locked
+	// or unlocked.
+	bool locked;
 };
 
 
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index d56be763..fa54b71f 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -7,6 +7,7 @@ BinarySemaphore::BinarySemaphore() {
 	if(handle == nullptr) {
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
+	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
 }
 
@@ -34,7 +35,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -55,7 +56,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -69,7 +70,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphore::release() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -96,26 +97,19 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
-
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return giveBinarySemaphore();
-}
 
 uint8_t BinarySemaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
-		BaseType_t * higherPriorityTaskWoken) {
+ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
+			higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
 			// Request context switch because unblocking the semaphore
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index e5c0ce4b..0c2fe3bf 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -43,9 +43,6 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
-	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
 	/**
@@ -57,8 +54,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -66,7 +63,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
@@ -74,7 +71,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t giveBinarySemaphore();
+	ReturnValue_t release() override;
 
 	/**
 	 * Get Handle to the semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 10365d7e..eecd986b 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,10 +1,19 @@
 #include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t count,
-		uint8_t initCount):
-		count(count), initCount(initCount) {
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
+		uint8_t initCount): maxCount(maxCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
 	handle = TaskManagement::getCurrentTaskHandle();
+	while(currentCount != initCount) {
+		xTaskNotifyGive(handle);
+		currentCount++;
+	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 7fc98e93..8c881d69 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -11,7 +11,7 @@ extern "C" {
 
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
-	CountingSemaphoreUsingTask(uint8_t count, uint8_t initCount);
+	CountingSemaphoreUsingTask(uint8_t maxCount, uint8_t initCount);
 
 	ReturnValue_t acquire(uint32_t timeoutMs) override;
 	ReturnValue_t release() override;
@@ -19,8 +19,8 @@ public:
 
 private:
 	TaskHandle_t handle;
-	uint8_t count = 0;
-	uint8_t initCount = 0;
+	const uint8_t maxCount;
+	uint8_t currentCount = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 6acdc7b7..05a898cd 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -40,18 +40,18 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 	}
 }
 
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		uint8_t initCount, uint32_t argument) {
 	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new CountingSemaphore(count, initCount);
+		return new CountingSemaphore(maxCount, initCount);
 	}
 	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new CountingSemaphoreUsingTask(count, initCount);
+		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
-		return new CountingSemaphore(count, initCount);
+		return new CountingSemaphore(maxCount, initCount);
 	}
 
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 971e97fa..75bbe25d 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -33,7 +33,7 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount,
+	SemaphoreIF* createCountingSemaphore(uint8_t maxCount, uint8_t initCount,
 			uint32_t argument = 0);
 
 	void deleteSemaphore(SemaphoreIF* mutex);

From c4e60946d3282c497714cb9345918069afb11047 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:30:20 +0200
Subject: [PATCH 0318/1292] improved bin semaph implementation

---
 osal/FreeRTOS/BinarySemaphore.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index fa54b71f..e6bb8dca 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -37,7 +37,7 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -59,14 +59,14 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return SEMAPHORE_TIMEOUT;
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
@@ -82,13 +82,17 @@ ReturnValue_t BinarySemaphore::release() {
 	}
 }
 
+uint8_t BinarySemaphore::getSemaphoreCounter() {
+	return uxSemaphoreGetCount(handle);
+}
+
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
 ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
@@ -96,17 +100,13 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	} else {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() {
-	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
 		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
@@ -117,7 +117,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 }

From 95bf5c1071a84696cc0e15abf9a01102764caaca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 21:33:34 +0200
Subject: [PATCH 0319/1292] improved const correctness

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 2 +-
 osal/FreeRTOS/BinSemaphUsingTask.h        | 2 +-
 osal/FreeRTOS/BinarySemaphore.cpp         | 2 +-
 osal/FreeRTOS/BinarySemaphore.h           | 2 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 5 ++---
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 2 +-
 tasks/SemaphoreIF.h                       | 2 +-
 7 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8cdcbc33..2a5ca3bd 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -63,7 +63,7 @@ TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
 	return handle;
 }
 
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() {
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
 	uint32_t notificationValue;
 	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
 	return notificationValue;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e44b838c..b65d4d80 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -26,7 +26,7 @@ public:
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 	/**
 	 * Take the binary semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6bb8dca..0d8d415c 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -82,7 +82,7 @@ ReturnValue_t BinarySemaphore::release() {
 	}
 }
 
-uint8_t BinarySemaphore::getSemaphoreCounter() {
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
 	return uxSemaphoreGetCount(handle);
 }
 
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0c2fe3bf..b883f801 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -43,7 +43,7 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 	/**
 	 * Take the binary semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index eecd986b..d08a549e 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -16,8 +16,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
 	}
 }
 
-ReturnValue_t CountingSemaphoreUsingTask::acquire(
-		uint32_t timeoutMs) {
+ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -25,6 +24,6 @@ ReturnValue_t CountingSemaphoreUsingTask::release() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() {
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
 	return 0;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 8c881d69..877a975e 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -15,7 +15,7 @@ public:
 
 	ReturnValue_t acquire(uint32_t timeoutMs) override;
 	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() override;
+	uint8_t getSemaphoreCounter() const override;
 
 private:
 	TaskHandle_t handle;
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index fb181cca..044e03a8 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -55,7 +55,7 @@ public:
 	 * is returned if the semaphore is available, and 0 is returned if the
 	 * semaphore is not available.
 	 */
-	virtual uint8_t getSemaphoreCounter() = 0;
+	virtual uint8_t getSemaphoreCounter() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */

From 63dbf995925f181f406173ba380d36b8faadb393 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 22:12:52 +0200
Subject: [PATCH 0320/1292] counting semaph implementation finished

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 42 ++++-------
 osal/FreeRTOS/BinSemaphUsingTask.h        | 32 ++-------
 osal/FreeRTOS/BinarySemaphore.cpp         | 24 +++----
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 88 +++++++++++++++++++++--
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 32 ++++++++-
 osal/FreeRTOS/CountingSemaphore.cpp       | 13 ++--
 osal/FreeRTOS/CountingSemaphore.h         |  4 +-
 tasks/SemaphoreFactory.h                  |  6 +-
 8 files changed, 154 insertions(+), 87 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 2a5ca3bd..9c2afe10 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,7 +1,6 @@
 #include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	xTaskNotifyGive(handle);
@@ -9,44 +8,29 @@ BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	return takeBinarySemaphore(timeoutMs);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release() {
-	return giveBinarySemaphore();
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphore(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+		timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
-	    timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeout);
-	if (returncode == pdPASS) {
-		locked = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
+		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
+	return acquireWithTickTimeout(timeout);
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::takeBinarySemaphoreTickTimeout(
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
 		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_TIMEOUT;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore() {
+ReturnValue_t BinarySemaphoreUsingTask::release() {
 	if(not locked) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
@@ -69,7 +53,9 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
 	return notificationValue;
 }
 
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHandle) {
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle) {
 	uint32_t notificationValue;
 	BaseType_t higherPriorityTaskWoken;
 	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
@@ -80,8 +66,8 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(TaskHandle_t taskHa
 	return notificationValue;
 }
 
-
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHandle) {
+ReturnValue_t BinarySemaphoreUsingTask::release(
+		TaskHandle_t taskHandle) {
 	BaseType_t returncode = xTaskNotifyGive(taskHandle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -93,7 +79,7 @@ ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphore(TaskHandle_t taskHan
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphoreUsingTask::giveBinarySemaphoreFromISR(
+ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
 	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
 	if(*higherPriorityTaskWoken == pdPASS) {
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index b65d4d80..cb6f6287 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -27,35 +27,17 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
 
 	/**
-	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked
-	 * for a maximum of #timeoutMs or until the semaphore is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
-	 */
-	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT);
-
-	/**
-	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * Same as acquire() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
+	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
 	        SemaphoreIF::NO_TIMEOUT);
 
-	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t giveBinarySemaphore();
-
 	/**
 	 * Get handle to the task related to the semaphore.
 	 * @return
@@ -68,7 +50,7 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	static ReturnValue_t giveBinarySemaphore(TaskHandle_t taskToNotify);
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
 
 	/**
 	 * Wrapper function to give back semaphore from handle when called from an ISR
@@ -78,11 +60,9 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(TaskHandle_t taskToNotify,
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
 				BaseType_t * higherPriorityTaskWoken);
 
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
-
 protected:
 	TaskHandle_t handle;
 	// This boolean is required to track whether the semaphore is locked
@@ -90,6 +70,4 @@ protected:
 	bool locked;
 };
 
-
-
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 0d8d415c..8891b755 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -43,21 +43,13 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-	    return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
+	return acquireWithTickTimeout(timeout);
 }
 
-ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
-        TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
@@ -65,20 +57,22 @@ ReturnValue_t BinarySemaphore::acquireWithTickTimeout(
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SemaphoreIF::SEMAPHORE_TIMEOUT;
 	}
 }
 
 ReturnValue_t BinarySemaphore::release() {
 	if (handle == nullptr) {
-		return SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SEMAPHORE_NOT_OWNED;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 }
 
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d08a549e..9beca310 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -2,7 +2,7 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
@@ -17,13 +17,93 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(uint8_t maxCount,
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	return HasReturnvaluesIF::RETURN_OK;
+	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+		timeout = SemaphoreIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeout);
+	if (returncode == pdPASS) {
+		currentCount--;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+		TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (returncode == pdPASS) {
+		currentCount--;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release() {
-	return HasReturnvaluesIF::RETURN_OK;
+	if(currentCount == maxCount) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	BaseType_t returncode = xTaskNotifyGive(handle);
+	if (returncode == pdPASS) {
+		currentCount++;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 }
 
 uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	return 0;
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken = 0;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	if(higherPriorityTaskWoken == pdTRUE) {
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return notificationValue;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release(
+		TaskHandle_t taskToNotify) {
+	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
+	if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		TaskManagement::requestContextSwitch(CallContext::isr);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 877a975e..ac0425b5 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -11,11 +11,39 @@ extern "C" {
 
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
-	CountingSemaphoreUsingTask(uint8_t maxCount, uint8_t initCount);
+	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
 
-	ReturnValue_t acquire(uint32_t timeoutMs) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+	/**
+	 * Acquire, using a timeout value in ticks
+	 * @param timeoutTicks
+	 * @return
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+			TickType_t timeoutTicks= SemaphoreIF::NO_TIMEOUT);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	/**
+	 * Release semaphore of task by supplying task handle
+	 * @param taskToNotify
+	 * @return
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+	/**
+	 * Release seamphore of a task from an ISR.
+	 * @param taskToNotify
+	 * @return
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+			BaseType_t* higherPriorityTaskWoken);
 
 private:
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2f0dfd76..a23f32a0 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -8,16 +8,17 @@ extern "C" {
 
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
-CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
-		count(count), initCount(initCount) {
-	handle = xSemaphoreCreateCounting(count, initCount);
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 	}
 }
 
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 	}
@@ -25,7 +26,7 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
 
 CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 	}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index a33a0fa5..77050f90 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -12,7 +12,7 @@
  */
 class CountingSemaphore: public BinarySemaphore {
 public:
-	CountingSemaphore(uint8_t count, uint8_t initCount);
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
 	//! @brief Copy ctor, disabled
 	CountingSemaphore(const CountingSemaphore&) = delete;
 	//! @brief Copy assignment, disabled
@@ -22,7 +22,7 @@ public:
 	//! @brief Move assignment
 	CountingSemaphore & operator=(CountingSemaphore &&);
 private:
-	uint8_t count = 0;
+	const uint8_t maxCount;
 	uint8_t initCount = 0;
 };
 
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 75bbe25d..3e21be36 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -23,7 +23,7 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return Pointer to newly created semaphore class instance.
 	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t argument = 0);
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
 	/**
 	 * Create a counting semaphore.
 	 * Creator functons for a counting semaphore which may be acquired multiple
@@ -33,8 +33,8 @@ public:
 	 * @param argument Can be used to pass implementation specific information.
 	 * @return
 	 */
-	SemaphoreIF* createCountingSemaphore(uint8_t maxCount, uint8_t initCount,
-			uint32_t argument = 0);
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
 
 	void deleteSemaphore(SemaphoreIF* mutex);
 

From 7ce505fdf9234630298dc6560b625cc44f41770a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:29:06 +0200
Subject: [PATCH 0321/1292] some safety updates and fixes

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 10 ++++++
 osal/FreeRTOS/BinSemaphUsingTask.h        |  6 +++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 40 ++++++++++++++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  9 +++++
 4 files changed, 52 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 9c2afe10..84b0b488 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,12 +1,22 @@
 #include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "Could not retrieve task handle. Please ensure the"
+				"constructor was called inside a task." << std::endl;
+	}
 	xTaskNotifyGive(handle);
 	locked = false;
 }
 
+BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index cb6f6287..cad42783 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -10,7 +10,9 @@ extern "C" {
 }
 
 /**
- * @brief 	Binary Semaphore implementation using Task Notifications
+ * @brief 	Binary Semaphore implementation using the task notification value.
+ * 			The notification value should therefore not be used
+ * 			for other purposes.
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
@@ -22,6 +24,8 @@ public:
 
 	//! @brief Default ctor
 	BinarySemaphoreUsingTask();
+	//! @brief Default dtor
+	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	        SemaphoreIF::NO_TIMEOUT) override;
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 9beca310..c29f5258 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,13 +9,35 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 				"intial cout. Setting initial count to max count." << std::endl;
 		initCount = maxCount;
 	}
+
 	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "Could not retrieve task handle. Please ensure the"
+				"constructor was called inside a task." << std::endl;
+	}
+
+	uint32_t oldNotificationValue;
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
+			&oldNotificationValue);
+	if(oldNotificationValue != 0) {
+		sif::warning << "Semaphore initiated but current notification value"
+				" is not 0. Please ensure the notification value is not used"
+				"for other purposes!" << std::endl;
+	}
+
 	while(currentCount != initCount) {
 		xTaskNotifyGive(handle);
 		currentCount++;
 	}
 }
 
+CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	// If this is not desired, don't call the destructor
+	// (or implement a boolea which disables the reset)
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -24,22 +46,16 @@ ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
+	return acquireWithTickTimeout(timeout);
 
-	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeout);
-	if (returncode == pdPASS) {
-		currentCount--;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 		TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdFALSE, timeoutTicks);
-	if (returncode == pdPASS) {
-		currentCount--;
+	// Decrement notfication value without resetting it.
+	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (getSemaphoreCounter() == oldCount - 1) {
+		currentCount --;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -63,7 +79,7 @@ ReturnValue_t CountingSemaphoreUsingTask::release() {
 }
 
 uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue;
+	uint32_t notificationValue = 0;
 	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
 	return notificationValue;
 }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index ac0425b5..2c54b31b 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -9,9 +9,18 @@ extern "C" {
 #include <freertos/task.h>
 }
 
+/**
+ * @brief 	Couting Semaphore implementation which uses the notification value
+ * 			of the task. The notification value should therefore not be used
+ * 			for other purposes
+ * @details
+ *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ *  and general semaphore documentation.
+ */
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:
 	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
+	virtual ~CountingSemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;

From 08ffe89682e72c70876d3dbfd0555161e16608e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:41:59 +0200
Subject: [PATCH 0322/1292] doc and api improvements

---
 osal/FreeRTOS/BinarySemaphore.cpp       |  4 +--
 osal/FreeRTOS/BinarySemaphore.h         | 27 ++++++++++---------
 osal/FreeRTOS/CountingSemaphUsingTask.h | 36 ++++++++++++++++++++-----
 osal/FreeRTOS/CountingSemaphore.h       |  4 +++
 4 files changed, 51 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8891b755..7d882aff 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -84,7 +84,7 @@ SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
 	}
@@ -97,7 +97,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(
+ReturnValue_t BinarySemaphore::releaseFromISR(
 		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index b883f801..f3839151 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -52,7 +52,7 @@ public:
 	 * for example by an ISR or another task.
 	 * @param timeoutMs
 	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
 	       	   SemaphoreIF::NO_TIMEOUT) override;
@@ -60,16 +60,17 @@ public:
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_TIMEOUT);
 
 	/**
-	 * Give back the binary semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
 	 */
 	ReturnValue_t release() override;
 
@@ -82,20 +83,22 @@ public:
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
 	 */
-	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
+	static ReturnValue_t release(SemaphoreHandle_t semaphore);
 
 	/**
 	 * Wrapper function to give back semaphore from handle when called from an ISR
 	 * @param semaphore
 	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
 	 *        was unblocked
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
 	 */
-	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+	static ReturnValue_t releaseFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
 
 protected:
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 2c54b31b..73d3f987 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -12,7 +12,7 @@ extern "C" {
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
  * 			of the task. The notification value should therefore not be used
- * 			for other purposes
+ * 			for other purposes.
  * @details
  *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
  *  and general semaphore documentation.
@@ -22,17 +22,37 @@ public:
 	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
 	virtual ~CountingSemaphoreUsingTask();
 
+	/**
+	 * Acquire the counting semaphore.
+	 * If no semaphores are available, the task will be blocked
+	 * for a maximum of #timeoutMs or until one is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
 	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
+
+	/**
+	 * Release a semaphore, increasing the number of available counting
+	 * semaphores up to the #maxCount value.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
 	ReturnValue_t release() override;
+
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+
 	/**
-	 * Acquire, using a timeout value in ticks
+	 * Acquire with a timeout value in ticks
 	 * @param timeoutTicks
-	 * @return
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks= SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
 
 	/**
 	 * Get handle to the task related to the semaphore.
@@ -43,13 +63,17 @@ public:
 	/**
 	 * Release semaphore of task by supplying task handle
 	 * @param taskToNotify
-	 * @return
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
 	 */
 	static ReturnValue_t release(TaskHandle_t taskToNotify);
 	/**
 	 * Release seamphore of a task from an ISR.
 	 * @param taskToNotify
-	 * @return
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
 	 */
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
 			BaseType_t* higherPriorityTaskWoken);
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 77050f90..bed3c726 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -21,6 +21,10 @@ public:
 	CountingSemaphore (CountingSemaphore &&);
 	//! @brief Move assignment
 	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
 private:
 	const uint8_t maxCount;
 	uint8_t initCount = 0;

From 60872f936ce2c2566b388e1e40bdb24194178453 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 27 May 2020 23:43:40 +0200
Subject: [PATCH 0323/1292] some output improvements

---
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index c29f5258..d34c7d6a 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -12,19 +12,19 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-		sif::error << "Could not retrieve task handle. Please ensure the"
-				"constructor was called inside a task." << std::endl;
+		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
+				"handle. Please ensure the constructor was called inside a "
+				"task." << std::endl;
 	}
 
 	uint32_t oldNotificationValue;
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
 			&oldNotificationValue);
 	if(oldNotificationValue != 0) {
-		sif::warning << "Semaphore initiated but current notification value"
-				" is not 0. Please ensure the notification value is not used"
-				"for other purposes!" << std::endl;
+		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
+				"current notification value is not 0. Please ensure the "
+				"notification value is not used for other purposes!" << std::endl;
 	}
-
 	while(currentCount != initCount) {
 		xTaskNotifyGive(handle);
 		currentCount++;

From 8676fcd9a929b619b65c1598434c75261fdb74b1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 00:47:54 +0200
Subject: [PATCH 0324/1292] yay, linux bin semaph finished

---
 osal/linux/BinarySemaphore.cpp  | 127 ++++++++++++++++++++++++++++++++
 osal/linux/BinarySemaphore.h    |  68 +++++++++++++++++
 osal/linux/MessageQueue.cpp     |   2 +-
 osal/linux/Mutex.h              |   4 +-
 osal/linux/SemaphoreFactory.cpp |   6 +-
 tasks/SemaphoreFactory.h        |   2 +-
 tasks/SemaphoreIF.h             |   2 +-
 7 files changed, 203 insertions(+), 8 deletions(-)
 create mode 100644 osal/linux/BinarySemaphore.cpp
 create mode 100644 osal/linux/BinarySemaphore.h

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
new file mode 100644
index 00000000..ed1045e0
--- /dev/null
+++ b/osal/linux/BinarySemaphore.cpp
@@ -0,0 +1,127 @@
+#include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+extern "C" {
+#include <errno.h>
+#include <string.h>
+}
+
+BinarySemaphore::BinarySemaphore() {
+	// Using unnamed semaphores for now
+	initSemaphore();
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	sem_destroy(&handle);
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+	initSemaphore();
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+	initSemaphore();
+	return * this;
+}
+
+ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+	int result = 0;
+	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
+		result = sem_trywait(&handle);
+	}
+	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	    result = sem_wait(&handle);
+	}
+	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+		timespec timeOut;
+		clock_gettime(CLOCK_REALTIME, &timeOut);
+		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+		nseconds += timeoutMs * 1000000;
+		timeOut.tv_sec = nseconds / 1000000000;
+		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+	    result = sem_timedwait(&handle, &timeOut);
+	    if(result != 0 and errno == EINVAL) {
+	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
+	    			<< std::endl;
+	    }
+	}
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(result) {
+	case(EAGAIN):
+		// Operation could not be performed without blocking (for sem_trywait)
+	case(ETIMEDOUT):
+		// Semaphore is 0
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EINTR):
+		// Call was interrupted by signal handler
+		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted"
+				<< std::endl;
+		/* No break */
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return release(&this->handle);
+}
+
+ReturnValue_t BinarySemaphore::release(sem_t *handle) {
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
+	// And another ugly cast :-D
+	return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
+	int value = 0;
+	int result = sem_getvalue(handle, &value);
+	if (result == 0) {
+		return value;
+	}
+	else if(result != 0 and errno == EINVAL) {
+		sif::debug << "BInarySemaphore::getSemaphoreCounter: Invalid"
+				" Semaphore." << std::endl;
+		return 0;
+	}
+	else {
+		// This should never happen.
+		return 0;
+	}
+}
+
+void BinarySemaphore::initSemaphore() {
+	auto result = sem_init(&handle, true, 1);
+	if(result == -1) {
+		switch(errno) {
+		case(EINVAL):
+						// Value excees SEM_VALUE_MAX
+		case(ENOSYS):
+		// System does not support process-shared semaphores
+		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
+		<< std::endl;
+		}
+	}
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
new file mode 100644
index 00000000..d18b3eaa
--- /dev/null
+++ b/osal/linux/BinarySemaphore.h
@@ -0,0 +1,68 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/SemaphoreIF.h>
+
+extern "C" {
+#include <semaphore.h>
+}
+
+/**
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
+ * @details
+ * See: http://www.man7.org/linux/man-pages/man7/sem_overview.7.html
+ * @author 	R. Mueller
+ * @ingroup osal
+ */
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
+	//! @brief Move ctor
+	BinarySemaphore (BinarySemaphore &&);
+	//! @brief Move assignment
+	BinarySemaphore & operator=(BinarySemaphore &&);
+	//! @brief Destructor
+	virtual ~BinarySemaphore();
+
+	void initSemaphore();
+
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(sem_t* handle);
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	       	   SemaphoreIF::NO_TIMEOUT) override;
+
+	/**
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	static ReturnValue_t release(sem_t* handle);
+
+protected:
+	sem_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 96d9fb4d..48ba29e8 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,7 +7,7 @@
 #include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) :
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 872ac3ac..607337ae 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
 
 #include <framework/ipc/MutexIF.h>
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index b1100e75..db4bebb3 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -20,18 +20,18 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 	return SemaphoreFactory::factoryInstance;
 }
 
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
 	return nullptr;
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
-		uint8_t initCount) {
+		uint8_t initCount, uint32_t arguments) {
 	sif::error << "Counting Semaphore not implemented for "
 			"Linux yet" << std::endl;
 	return nullptr;
 }
 
-void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
 	delete semaphore;
 }
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 3e21be36..7f8edaf1 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -36,7 +36,7 @@ public:
 	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
 			uint8_t initCount, uint32_t arguments = 0);
 
-	void deleteSemaphore(SemaphoreIF* mutex);
+	void deleteSemaphore(SemaphoreIF* semaphore);
 
 private:
 	/**
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 044e03a8..a7c5a97b 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -30,7 +30,7 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
 	//! The current semaphore can not be given, because it is not owned
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
 
 	/**
 	 * Generic call to acquire a semaphore.

From 56498e5bc12076330e8f1b74ce7955b16005d0aa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 00:50:44 +0200
Subject: [PATCH 0325/1292] linux bin semaph unlocked

---
 osal/linux/SemaphoreFactory.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index db4bebb3..8d29ffe3 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,4 +1,5 @@
 #include <framework/tasks/SemaphoreFactory.h>
+#include <framework/osal/linux/BinarySemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
@@ -21,8 +22,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	sif::error << "Semaphore not implemented for Linux yet" << std::endl;
-	return nullptr;
+	return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,

From 671f298935a640e33274e1a5fd52339e790068b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 01:41:16 +0200
Subject: [PATCH 0326/1292] implemented counting semaph for linux

---
 osal/FreeRTOS/CountingSemaphore.cpp | 10 ++++++
 osal/FreeRTOS/CountingSemaphore.h   |  1 +
 osal/linux/BinarySemaphore.cpp      | 43 +++++++++++++++++------
 osal/linux/BinarySemaphore.h        | 23 +++++++++---
 osal/linux/CountingSemaphore.cpp    | 54 +++++++++++++++++++++++++++++
 osal/linux/CountingSemaphore.h      | 37 ++++++++++++++++++++
 osal/linux/SemaphoreFactory.cpp     |  7 ++--
 7 files changed, 155 insertions(+), 20 deletions(-)
 create mode 100644 osal/linux/CountingSemaphore.cpp
 create mode 100644 osal/linux/CountingSemaphore.h

diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index a23f32a0..c838f3e2 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,6 +10,12 @@ extern "C" {
 // free FreeRTOSConfig.h file.
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
 	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
@@ -33,3 +39,7 @@ CountingSemaphore& CountingSemaphore::operator =(
 	return * this;
 }
 
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index bed3c726..dca3ab0e 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -25,6 +25,7 @@ public:
 	/* Same API as binary semaphore otherwise. acquire() can be called
 	 * until there are not semaphores left and release() can be called
 	 * until maxCount is reached. */
+	uint8_t getMaxCount() const;
 private:
 	const uint8_t maxCount;
 	uint8_t initCount = 0;
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index ed1045e0..7c76a5c4 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -30,7 +30,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
 		result = sem_trywait(&handle);
 	}
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	else if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    result = sem_wait(&handle);
 	}
 	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
@@ -50,7 +50,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	switch(result) {
+	switch(errno) {
 	case(EAGAIN):
 		// Operation could not be performed without blocking (for sem_trywait)
 	case(ETIMEDOUT):
@@ -61,8 +61,8 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
-		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted"
-				<< std::endl;
+		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
+				"Code " << strerror(errno) << std::endl;
 		/* No break */
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -70,10 +70,15 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 }
 
 ReturnValue_t BinarySemaphore::release() {
-	return release(&this->handle);
+	return BinarySemaphore::release(&this->handle);
 }
 
 ReturnValue_t BinarySemaphore::release(sem_t *handle) {
+	ReturnValue_t countResult = checkCount(handle, 1);
+	if(countResult != HasReturnvaluesIF::RETURN_OK) {
+		return countResult;
+	}
+
 	int result = sem_post(handle);
 	if(result == 0) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -102,8 +107,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 		return value;
 	}
 	else if(result != 0 and errno == EINVAL) {
-		sif::debug << "BInarySemaphore::getSemaphoreCounter: Invalid"
-				" Semaphore." << std::endl;
+		// Could be called from interrupt, use lightweight printf
+		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -112,16 +117,32 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 }
 
-void BinarySemaphore::initSemaphore() {
-	auto result = sem_init(&handle, true, 1);
+void BinarySemaphore::initSemaphore(uint8_t initCount) {
+	auto result = sem_init(&handle, true, initCount);
 	if(result == -1) {
 		switch(errno) {
 		case(EINVAL):
-						// Value excees SEM_VALUE_MAX
+			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-		<< std::endl;
+				<< std::endl;
 		}
 	}
 }
+
+ReturnValue_t BinarySemaphore::checkCount(sem_t* handle, uint8_t maxCount) {
+	int value = getSemaphoreCounter(handle);
+	if(value >= maxCount) {
+		if(maxCount == 1 and value > 1) {
+			// Binary Semaphore special case.
+			// This is a config error use lightweight printf is this is called
+			// from an interrupt
+			printf("BinarySemaphore::release: Value of binary semaphore greater"
+					" than 1!\n");
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index d18b3eaa..7836cd41 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
@@ -35,10 +35,11 @@ public:
 	//! @brief Destructor
 	virtual ~BinarySemaphore();
 
-	void initSemaphore();
+	void initSemaphore(uint8_t initCount = 1);
 
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(sem_t* handle);
+
 	/**
 	 * Take the binary semaphore.
 	 * If the semaphore has already been taken, the task will be blocked
@@ -57,10 +58,22 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
 	 *         	already available.
 	 */
-	ReturnValue_t release() override;
-
+	virtual ReturnValue_t release() override;
+	/**
+	 * This static function can be used to release a semaphore  by providing
+	 * its handle.
+	 * @param handle
+	 * @return
+	 */
 	static ReturnValue_t release(sem_t* handle);
 
+	/** Checks the validity of the semaphore count against a specified
+	 * known maxCount
+	 * @param handle
+	 * @param maxCount
+	 * @return
+	 */
+	static ReturnValue_t checkCount(sem_t* handle, uint8_t maxCount);
 protected:
 	sem_t handle;
 };
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
new file mode 100644
index 00000000..dfc4d801
--- /dev/null
+++ b/osal/linux/CountingSemaphore.cpp
@@ -0,0 +1,54 @@
+#include <framework/osal/linux/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	initSemaphore(initCount);
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	initSemaphore(initCount);
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	initSemaphore(other.initCount);
+	return * this;
+}
+
+ReturnValue_t CountingSemaphore::release() {
+	ReturnValue_t result = checkCount(&handle, maxCount);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return CountingSemaphore::release(&this->handle);
+}
+
+ReturnValue_t CountingSemaphore::release(sem_t* handle) {
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
new file mode 100644
index 00000000..ba606595
--- /dev/null
+++ b/osal/linux/CountingSemaphore.h
@@ -0,0 +1,37 @@
+#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#include <framework/osal/linux/BinarySemaphore.h>
+
+/**
+ * @brief 	Counting semaphores, which can be acquired more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	ReturnValue_t release() override;
+	static ReturnValue_t release(sem_t* sem);
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 8d29ffe3..5aec84ea 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,5 +1,6 @@
 #include <framework/tasks/SemaphoreFactory.h>
 #include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
@@ -25,11 +26,9 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	return new BinarySemaphore();
 }
 
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
-	sif::error << "Counting Semaphore not implemented for "
-			"Linux yet" << std::endl;
-	return nullptr;
+	return new CountingSemaphore(maxCount, initCount);
 }
 
 void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {

From ccf79ab5b63d5870dfd8aabde90895746f9cdc08 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 01:55:20 +0200
Subject: [PATCH 0327/1292] output correction for linux

---
 osal/linux/PeriodicPosixTask.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 28a0b946..f6a74901 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -57,9 +57,11 @@ void PeriodicPosixTask::taskFunctionality(void){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status==0){
-				sif::error << "ObjectTask: " << name << " Deadline missed." << std::endl;
+				sif::error << "PeriodicPosixTask " << name << ": Deadline "
+						"missed." << std::endl;
 			}else{
-				sif::error << "ObjectTask: X Deadline missed. " << status << std::endl;
+				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+						status << std::endl;
 			}
 			if (this->deadlineMissedFunc != NULL) {
 				this->deadlineMissedFunc();

From 3d2935ac6917b6d8f20c68011cd77cf9d5890686 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 02:23:14 +0200
Subject: [PATCH 0328/1292] linux time lib improvements

stop watch other function used (more precise for linux)
---
 osal/linux/Clock.cpp      | 17 ++++++++++++++---
 timemanager/Clock.h       | 18 ++++++++++--------
 timemanager/Stopwatch.cpp | 14 +++++---------
 timemanager/Stopwatch.h   |  9 ++-------
 4 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index e24a4fe4..b3e5c84b 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,11 +1,13 @@
-#include <sys/time.h>
-#include <time.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-
+extern "C" {
+#include <sys/time.h>
 #include <sys/sysinfo.h>
 #include <linux/sysinfo.h>
+#include <time.h>
 #include <unistd.h>
+}
 
 //#include <fstream>
 uint16_t Clock::leapSeconds = 0;
@@ -65,6 +67,15 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
 ReturnValue_t Clock::getUptime(timeval* uptime) {
 	//TODO This is not posix compatible and delivers only seconds precision
 	struct sysinfo sysInfo;
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 5f18de3e..fcfacbc0 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -2,11 +2,12 @@
 #define FRAMEWORK_TIMEMANAGER_CLOCK_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-#include <sys/time.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/globalfunctions/timevalOperations.h>
 
+#include <cstdint>
+#include <sys/time.h>
+
 typedef uint32_t millis_t;
 typedef float seconds_t;
 
@@ -22,7 +23,7 @@ public:
 	  uint32_t usecond; //!< Microseconds, 0 .. 999999
 	}   TimeOfDay_t;
 
-	/**static Clock* TimeOfDay_t();
+	/**
 	 * This method returns the number of clock ticks per second.
 	 * In RTEMS, this is typically 1000.
 	 * @return	The number of ticks.
@@ -34,22 +35,23 @@ public:
 	 * This system call sets the system time.
 	 * To set the time, it uses a TimeOfDay_t struct.
 	 * @param time The struct with the time settings to set.
-	 * @return	\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
 	 */
 	static ReturnValue_t setClock(const TimeOfDay_t* time);
 	/**
 	 * This system call sets the system time.
 	 * To set the time, it uses a timeval struct.
 	 * @param time The struct with the time settings to set.
-	 * @return	\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t setClock(const timeval* time);
 	/**
 	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields \c tv_sec with seconds and \c tv_usec with
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
 	 * microseconds since an OS-defined epoch.
 	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getClock_timeval(timeval* time);
 
@@ -57,7 +59,7 @@ public:
 	 * Get the time since boot in a timeval struct
 	 *
 	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return\c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
 	 *
 	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
 	 */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 1f287fb3..bc8b4149 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,9 +1,3 @@
-/**
- * @file Stopwatch.cpp
- *
- * @date 08.04.2020
- */
-
 #include <framework/timemanager/Stopwatch.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <iomanip>
@@ -12,11 +6,11 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(
         displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
-    startTime = Clock::getUptime();
+    Clock::getClock_timeval(&startTime);
 }
 
 void Stopwatch::start() {
-    startTime = Clock::getUptime();
+    Clock::getClock_timeval(&startTime);
 }
 
 millis_t Stopwatch::stop() {
@@ -57,5 +51,7 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
 }
 
 void Stopwatch::stopInternal() {
-    elapsedTime = Clock::getUptime() - startTime;
+	timeval endTime;
+	Clock::getClock_timeval(&endTime);
+    elapsedTime = endTime - startTime;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index f48c04ec..c57200b0 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,9 +1,3 @@
-/**
- * @file Stopwatch.h
- *
- * @date 08.04.2020
- */
-
 #ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #include <framework/timemanager/Clock.h>
@@ -14,12 +8,13 @@ enum class StopwatchDisplayMode {
 };
 
 /**
- * @brief Simple Stopwatch implementation to measure elapsed time
+ * @brief 	Simple Stopwatch implementation to measure elapsed time
  * @details
  * This class can be used to measure elapsed times. It also displays elapsed
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
  * as a float.
+ * @author 	R. Mueller
  */
 class Stopwatch {
 public:

From da403c01d0178d814896d4c26561e092c1ac2a6e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 03:03:48 +0200
Subject: [PATCH 0329/1292] retval fix, unittest running again

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 71 ++++++++++-------------
 osal/FreeRTOS/BinSemaphUsingTask.h        |  9 ++-
 osal/FreeRTOS/BinarySemaphore.cpp         | 40 ++++++-------
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 69 +++++++++-------------
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 17 +++++-
 5 files changed, 94 insertions(+), 112 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 84b0b488..51a3c563 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -9,7 +9,6 @@ BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 				"constructor was called inside a task." << std::endl;
 	}
 	xTaskNotifyGive(handle);
-	locked = false;
 }
 
 BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
@@ -32,7 +31,6 @@ ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
         TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
-		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -41,43 +39,14 @@ ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::release() {
-	if(not locked) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		// This should never happen
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
+	return release(this->handle);
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::release(
 		TaskHandle_t taskHandle) {
+	if(getSemaphoreCounter(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
 	BaseType_t returncode = xTaskNotifyGive(taskHandle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
@@ -88,14 +57,36 @@ ReturnValue_t BinarySemaphoreUsingTask::release(
 	}
 }
 
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
+	return getSemaphoreCounter(this->handle);
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
+	if(getSemaphoreCounterFromISR(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	BaseType_t higherPriorityTaskWoken;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			&higherPriorityTaskWoken);
+	return notificationValue;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index cad42783..31620880 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -31,6 +31,7 @@ public:
 	        SemaphoreIF::NO_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
 	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
 
 	/**
@@ -59,8 +60,9 @@ public:
 	/**
 	 * Wrapper function to give back semaphore from handle when called from an ISR
 	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
-	 *        was unblocked
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
@@ -69,9 +71,6 @@ public:
 
 protected:
 	TaskHandle_t handle;
-	// This boolean is required to track whether the semaphore is locked
-	// or unlocked.
-	bool locked;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 7d882aff..7b695dee 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -37,7 +37,7 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
@@ -51,7 +51,7 @@ ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 
 ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 
 	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
@@ -64,10 +64,14 @@ ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
 }
 
 ReturnValue_t BinarySemaphore::release() {
-	if (handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+	return release(handle);
+}
+
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
-	BaseType_t returncode = xSemaphoreGive(handle);
+	BaseType_t returncode = xSemaphoreGive(semaphore);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -83,33 +87,23 @@ uint8_t BinarySemaphore::getSemaphoreCounter() const {
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
-
-ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
-	if (semaphore == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
-	}
-	BaseType_t returncode = xSemaphoreGive(semaphore);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::releaseFromISR(
 		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
-		return SemaphoreIF::SEMAPHORE_NULLPOINTER;
+		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
+	// This should propably be called at the end of the (calling) ISR
+	//if(*higherPriorityTaskWoken == pdPASS) {
+		// Request context switch because unblocking the semaphore
+		// caused a high priority task unblock.
+		//TaskManagement::requestContextSwitch(CallContext::isr);
+	//}
 	if (returncode == pdPASS) {
-		if(*higherPriorityTaskWoken == pdPASS) {
-			// Request context switch because unblocking the semaphore
-		    // caused a high priority task unblock.
-			TaskManagement::requestContextSwitch(CallContext::isr);
-		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d34c7d6a..d0f63f3f 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -25,16 +25,15 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 				"current notification value is not 0. Please ensure the "
 				"notification value is not used for other purposes!" << std::endl;
 	}
-	while(currentCount != initCount) {
+	for(int i = 0; i < initCount; i++) {
 		xTaskNotifyGive(handle);
-		currentCount++;
 	}
 }
 
 CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 	// Clear notification value on destruction.
 	// If this is not desired, don't call the destructor
-	// (or implement a boolea which disables the reset)
+	// (or implement a boolean which disables the reset)
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
@@ -55,7 +54,6 @@ ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 	// Decrement notfication value without resetting it.
 	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
 	if (getSemaphoreCounter() == oldCount - 1) {
-		currentCount --;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
@@ -64,41 +62,10 @@ ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release() {
-	if(currentCount == maxCount) {
+	if(getSemaphoreCounter() == maxCount) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
-	BaseType_t returncode = xTaskNotifyGive(handle);
-	if (returncode == pdPASS) {
-		currentCount++;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		// This should never happen
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue = 0;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t task) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken = 0;
-	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
-	if(higherPriorityTaskWoken == pdTRUE) {
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
-	return notificationValue;
+	return release(handle);
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::release(
@@ -113,13 +80,31 @@ ReturnValue_t CountingSemaphoreUsingTask::release(
 	}
 }
 
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
 ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
 		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
 	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
-	if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		TaskManagement::requestContextSwitch(CallContext::isr);
-	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
+
+uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 73d3f987..797e864b 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -43,7 +43,16 @@ public:
 	ReturnValue_t release() override;
 
 	uint8_t getSemaphoreCounter() const override;
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task);
+	/**
+	 * Get the semaphore counter from an ISR.
+	 * @param task
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return
+	 */
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
+			BaseType_t* higherPriorityTaskWoken);
 
 	/**
 	 * Acquire with a timeout value in ticks
@@ -71,6 +80,9 @@ public:
 	/**
 	 * Release seamphore of a task from an ISR.
 	 * @param taskToNotify
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
 	 *         	already available.
@@ -78,10 +90,11 @@ public:
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
 			BaseType_t* higherPriorityTaskWoken);
 
+	uint8_t getMaxCount() const;
+
 private:
 	TaskHandle_t handle;
 	const uint8_t maxCount;
-	uint8_t currentCount = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */

From 78ae109a08ec58c17b1b966944992da0b74da011 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:02:13 +0200
Subject: [PATCH 0330/1292] removed context switch request

(shall be done at end of ISR, so must be performed by caller)
---
 osal/FreeRTOS/BinSemaphUsingTask.cpp | 9 ++++-----
 osal/FreeRTOS/BinSemaphUsingTask.h   | 3 ++-
 osal/FreeRTOS/BinarySemaphore.cpp    | 9 ---------
 osal/FreeRTOS/BinarySemaphore.h      | 5 +++--
 osal/FreeRTOS/MessageQueue.cpp       | 2 +-
 osal/FreeRTOS/MessageQueue.h         | 4 ++--
 osal/FreeRTOS/TaskManagement.cpp     | 4 ++--
 osal/FreeRTOS/TaskManagement.h       | 6 +++---
 8 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 51a3c563..8f5fd4d8 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -75,7 +75,7 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	if(getSemaphoreCounterFromISR(taskHandle) == 1) {
+	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
 	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
@@ -83,10 +83,9 @@ ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
 }
 
 uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	BaseType_t higherPriorityTaskWoken;
+		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue = 0;
 	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			&higherPriorityTaskWoken);
+			higherPriorityTaskWoken);
 	return notificationValue;
 }
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 31620880..e6cb2a07 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -32,7 +32,8 @@ public:
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle);
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
+			BaseType_t* higherPriorityTaskWoken);
 
 	/**
 	 * Same as acquire() with timeout in FreeRTOS ticks.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 7b695dee..b6687bb7 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -36,9 +36,6 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	}
 	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
 	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
 	    timeout = SemaphoreIF::MAX_TIMEOUT;
@@ -97,12 +94,6 @@ ReturnValue_t BinarySemaphore::releaseFromISR(
 	}
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
 			higherPriorityTaskWoken);
-	// This should propably be called at the end of the (calling) ISR
-	//if(*higherPriorityTaskWoken == pdPASS) {
-		// Request context switch because unblocking the semaphore
-		// caused a high priority task unblock.
-		//TaskManagement::requestContextSwitch(CallContext::isr);
-	//}
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index f3839151..de6092af 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -92,8 +92,9 @@ public:
 	/**
 	 * Wrapper function to give back semaphore from handle when called from an ISR
 	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
-	 *        was unblocked
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch from an ISR should
+	 * then be requested (see TaskManagement functions)
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
 	 *         	already available.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 9e4b581b..b56a6252 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -124,7 +124,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(callContext == CallContext::task) {
+    if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()), 0);
     }
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 988733f6..8daab8f6 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -199,7 +199,7 @@ protected:
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, CallContext callContext = CallContext::task);
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
@@ -209,7 +209,7 @@ private:
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
 	//!< Stores the current system context
-	CallContext callContext =  CallContext::task;
+	CallContext callContext =  CallContext::TASK;
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 4529b371..7871ab2e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -5,8 +5,8 @@ void TaskManagement::requestContextSwitchFromTask() {
 }
 
 void TaskManagement::requestContextSwitch(
-		CallContext callContext = CallContext::task) {
-	if(callContext == CallContext::isr) {
+		CallContext callContext = CallContext::TASK) {
+	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
 		requestContextSwitchFromISR();
 	} else {
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index b9874db0..39c24377 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -21,9 +21,9 @@ extern "C" void requestContextSwitchFromISR();
  * has different functions for handling semaphores and messages from within
  * an ISR and task.
  */
-enum CallContext {
-	task = 0x00,//!< task_context
-	isr = 0xFF  //!< isr_context
+enum class CallContext {
+	TASK = 0x00,//!< task_context
+	ISR = 0xFF  //!< isr_context
 };
 
 

From 5169c09fd8d56eb041011da9062bb325578a313e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:07:35 +0200
Subject: [PATCH 0331/1292] improved includes

---
 osal/FreeRTOS/Clock.cpp      | 9 +++++----
 osal/FreeRTOS/Timekeeper.cpp | 9 +--------
 osal/FreeRTOS/Timekeeper.h   | 3 ++-
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 5e597f25..d1c9f97b 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,13 +1,14 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/globalfunctions/timevalOperations.h>
-#include <stdlib.h>
-#include "Timekeeper.h"
+#include <framework/osal/FreeRTOS/Timekeeper.h>
 
 extern "C" {
-#include <FreeRTOS.h>
-#include <task.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 
+#include <stdlib.h>
+#include <time.h>
 
 //TODO sanitize input?
 //TODO much of this code can be reused for tick-only systems
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 949e1df3..9fd4af62 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,13 +1,6 @@
-/**
- * @file Timekeeper.cpp
- * @date
- */
-
 #include <framework/osal/FreeRTOS/Timekeeper.h>
 
-extern "C" {
-#include <task.h>
-}
+#include "FreeRTOSConfig.h"
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 05f0f701..8709e362 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -3,7 +3,8 @@
 
 #include <framework/timemanager/Clock.h>
 extern "C" {
-#include <FreeRTOS.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 }
 
 

From e7ae35c6592fb101ebe2fd44517a8cfc62b1096d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:09:47 +0200
Subject: [PATCH 0332/1292] improved structure a bit

---
 osal/FreeRTOS/Timekeeper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 9fd4af62..643b2747 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -4,7 +4,9 @@
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 
-Timekeeper::Timekeeper() : offset( { 0, 0 }) {}
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
 
 const timeval& Timekeeper::getOffset() const {
 	return offset;
@@ -21,8 +23,6 @@ void Timekeeper::setOffset(const timeval& offset) {
 	this->offset = offset;
 }
 
-Timekeeper::~Timekeeper() {}
-
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 	timeval uptime;
 	uptime.tv_sec = ticks / configTICK_RATE_HZ;

From d5352a9b87a604cd8535963d2a7fcc8176b2182b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:15:37 +0200
Subject: [PATCH 0333/1292] actually extern "C" is not needed

it is included by freeRTOS
---
 osal/FreeRTOS/Clock.cpp    | 6 ++----
 osal/FreeRTOS/Timekeeper.h | 3 +--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d1c9f97b..dce20265 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -2,10 +2,8 @@
 #include <framework/globalfunctions/timevalOperations.h>
 #include <framework/osal/FreeRTOS/Timekeeper.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 #include <stdlib.h>
 #include <time.h>
@@ -14,7 +12,7 @@ extern "C" {
 //TODO much of this code can be reused for tick-only systems
 
 uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
+MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void) {
 	return 1000;
@@ -131,7 +129,7 @@ ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
 
 ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
 	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
+	if (timeMutex == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 8709e362..7d3ca22b 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -2,10 +2,9 @@
 #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 
 #include <framework/timemanager/Clock.h>
-extern "C" {
+
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 
 /**

From 6a3dc94108304d9cf0cdde1cc82ecc6dc62390d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 13:18:27 +0200
Subject: [PATCH 0334/1292] removed extern "C" for freertos includes

---
 osal/FreeRTOS/BinSemaphUsingTask.h  | 2 --
 osal/FreeRTOS/BinarySemaphore.h     | 2 --
 osal/FreeRTOS/CountingSemaphore.cpp | 2 --
 osal/FreeRTOS/MessageQueue.cpp      | 2 +-
 osal/FreeRTOS/MessageQueue.h        | 7 -------
 osal/FreeRTOS/Mutex.cpp             | 2 +-
 osal/FreeRTOS/Mutex.h               | 3 ---
 7 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e6cb2a07..48c1cd12 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -4,10 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index de6092af..0938dee6 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -4,10 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tasks/SemaphoreIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
-}
 
 /**
  * @brief 	OS Tool to achieve synchronization of between tasks or between
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index c838f3e2..957f6a31 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -2,9 +2,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
 #include <freertos/semphr.h>
-}
 
 // Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
 // free FreeRTOSConfig.h file.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index b56a6252..0a579296 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,4 +1,4 @@
-#include "MessageQueue.h"
+#include <framework/osal/FreeRTOS/MessageQueue.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 8daab8f6..81b4c186 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -6,11 +6,8 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
-}
-
 
 // TODO: this class assumes that MessageQueueId_t is the same size as void*
 // (the FreeRTOS handle type), compiler will catch this but it might be nice
@@ -164,11 +161,7 @@ public:
 	MessageQueueId_t getId() const;
 
 	/**
-<<<<<<< HEAD
-	 * \brief	This method is a simple setter for the default destination.
-=======
 	 * @brief	This method is a simple setter for the default destination.
->>>>>>> mueller_BinSempahInterface
 	 */
 	void setDefaultDestination(MessageQueueId_t defaultDestination);
 	/**
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 25513a81..e304d60e 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index ef93fd34..e04cd20d 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -3,11 +3,8 @@
 
 #include <framework/ipc/MutexIF.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
-}
-
 
 /**
  * @brief OS component to implement MUTual EXclusion

From f14bacba32e97c7d74e55405d59b9230ec4e362c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 14:15:45 +0200
Subject: [PATCH 0335/1292] using nullptr now

added new distinction between blocking (MAX_TIMEOUT) and polling
(NO_TIMEOUT)
---
 ipc/MutexIF.h           |  2 +-
 osal/FreeRTOS/Mutex.cpp | 18 +++++++++++-------
 osal/FreeRTOS/Mutex.h   |  2 +-
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index a4aff1cd..dcb1cf33 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -13,7 +13,7 @@
 class MutexIF {
 public:
 	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
-
+	static const uint32_t MAX_TIMEOUT;
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
 	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index e304d60e..cc2f865f 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -3,27 +3,31 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::MAX_TIMEOUT = portMAX_DELAY;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	if(handle == NULL) {
-		sif::error << "Mutex creation failure" << std::endl;
+	if(handle == nullptr) {
+		sif::error << "Mutex: Creation failure" << std::endl;
 	}
 }
 
 Mutex::~Mutex() {
-	if (handle != 0) {
+	if (handle != nullptr) {
 		vSemaphoreDelete(handle);
 	}
 
 }
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if (handle == 0) {
+	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if (timeoutMs != NO_TIMEOUT) {
+	TickType_t timeout = MutexIF::NO_TIMEOUT;
+	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+		timeout = MutexIF::MAX_TIMEOUT;
+	}
+	else if(timeoutMs > MutexIF::NO_TIMEOUT){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -36,7 +40,7 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if (handle == 0) {
+	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index e04cd20d..90e82467 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
 	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;

From b90492562ac44f576ab7c7519826ae272d5be68e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:40:57 +0200
Subject: [PATCH 0336/1292] added author tag back at class definition

---
 storagemanager/LocalPool.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index c155f918..2d61dea5 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -22,6 +22,7 @@
  * 			0xFFFF-1 bytes.
  * 			It is possible to store empty packets in the pool.
  * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
  */
 
 template<uint8_t NUMBER_OF_POOLS = 5>

From 5cf9e938cccf450c5a4ad5b7fb74f7cc4b3705ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:45:03 +0200
Subject: [PATCH 0337/1292] added include protection

---
 storagemanager/LocalPool.tpp   | 4 ++++
 storagemanager/PoolManager.tpp | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 32724bd8..dd360a0a 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#error Include LocalPool.h instead of LocalPool.tpp!.
+#endif
+
 template<uint8_t NUMBER_OF_POOLS>
 inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 854e22da..bdc73ec2 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,6 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#error Include LocalPool.h instead of LocalPool.tpp!.
+#endif
+
 template<uint8_t NUMBER_OF_POOLS>
 inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
 		const uint16_t element_sizes[NUMBER_OF_POOLS],

From 3ef939aca8cff90c0ad51418e859eb69a76a655f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:46:26 +0200
Subject: [PATCH 0338/1292] fixed inclue protection

---
 storagemanager/LocalPool.tpp   | 2 +-
 storagemanager/PoolManager.tpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index dd360a0a..b7fa0da9 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h instead of LocalPool.tpp!.
+#error Include LocalPool.h instead of LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index bdc73ec2..97603246 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#error Include LocalPool.h instead of LocalPool.tpp!.
+#error Include LocalPool.h instead of LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>

From 6b0558d6c71a5b23b2f678d5b18e170cde60e706 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:49:11 +0200
Subject: [PATCH 0339/1292] added author tag back

---
 storagemanager/PoolManager.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 6e353de2..c74e95c0 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -10,6 +10,7 @@
  * 			a fixed pool size policy for inter-process communication.
  * @details	Uses local pool calls but is thread safe by protecting the call
  * 			with a lock.
+ * @author 	Bastian Baetz
  */
 template <uint8_t NUMBER_OF_POOLS>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {

From f13eff79c90a174011c6d3b6c617ce25b575cc76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 16:51:09 +0200
Subject: [PATCH 0340/1292] another little include guard fix

---
 storagemanager/LocalPool.tpp   | 2 +-
 storagemanager/PoolManager.tpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index b7fa0da9..764bd7be 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h instead of LocalPool.tpp!
+#error Include LocalPool.h before LocalPool.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 97603246..29b2b82a 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -2,7 +2,7 @@
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#error Include LocalPool.h instead of LocalPool.tpp!
+#error Include PoolManager.h before PoolManager.tpp!
 #endif
 
 template<uint8_t NUMBER_OF_POOLS>

From 4d4ca2f3bd87efaca572378e107f92dda2c57eb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:43:37 +0200
Subject: [PATCH 0341/1292] doc fix for stopwatch

---
 timemanager/Stopwatch.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index c57200b0..71580778 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -13,7 +13,7 @@ enum class StopwatchDisplayMode {
  * This class can be used to measure elapsed times. It also displays elapsed
  * times automatically on destruction if not explicitely deactivated in the
  * constructor. The default time format is the elapsed time in miliseconds
- * as a float.
+ * in seconds as a double.
  * @author 	R. Mueller
  */
 class Stopwatch {
@@ -41,6 +41,10 @@ public:
      * @return elapsed time in milliseconds (rounded)
      */
     millis_t stop();
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in seconds (double precision)
+     */
     seconds_t stopSeconds();
 
     /**

From 914bf8b9fc1afff3cf98675b4a98707099cb4021 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:45:53 +0200
Subject: [PATCH 0342/1292] seconds_t is double now

---
 timemanager/Clock.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index fcfacbc0..19991b81 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,7 +9,7 @@
 #include <sys/time.h>
 
 typedef uint32_t millis_t;
-typedef float seconds_t;
+typedef double seconds_t;
 
 class Clock {
 public:

From 7a22d12d0f1328ff55e3e2826e58000e191ef643 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 17:48:24 +0200
Subject: [PATCH 0343/1292] removed extern "C", not needed

---
 osal/linux/Clock.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index b3e5c84b..630b2cf4 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,13 +1,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-extern "C" {
 #include <sys/time.h>
 #include <sys/sysinfo.h>
 #include <linux/sysinfo.h>
 #include <time.h>
 #include <unistd.h>
-}
 
 //#include <fstream>
 uint16_t Clock::leapSeconds = 0;

From c8a36a79de45c228e7071cc827423e0b4a383998 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 31 May 2020 00:23:38 +0200
Subject: [PATCH 0344/1292] corrected doc for task factory interface

---
 osal/FreeRTOS/FixedTimeslotTask.h | 19 +++++++++-------
 tasks/TaskFactory.h               | 36 ++++++++++++++-----------------
 2 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 1ab8724f..fe93daff 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -10,15 +10,18 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
+
 	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	FixedTimeslotTask(const char *name, TaskPriority setPriority,
 			TaskStackSize setStack, TaskPeriod overallPeriod,
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index f7afa4a2..e1e2f5e2 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -19,16 +19,14 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param taskPriority_ Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param stackSize_ 	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param period_		Period in seconds.
-	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -36,16 +34,14 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name_ Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param taskPriority_ Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param stackSize_ 	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param period_		Period in seconds.
-	 * @param deadLineMissedFunction_ Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,

From 42f0687a6bcf0f1c947ef00dfeea95fa3e060af8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 31 May 2020 23:28:51 +0200
Subject: [PATCH 0345/1292] self deletion nullptr

---
 osal/FreeRTOS/TaskFactory.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 6b18d7a8..663b0531 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -34,9 +34,9 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == NULL) {
+	if (task == nullptr) {
 		//delete self
-		vTaskDelete(NULL);
+		vTaskDelete(nullptr);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
 		//TODO not implemented

From de6ed5c0859e528b798fdb214cf62b7a3143762e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 15:57:04 +0200
Subject: [PATCH 0346/1292] improved include guard and removed old comment

---
 osal/FreeRTOS/PeriodicTask.h | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 4ece20b3..a449328e 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,5 +1,5 @@
-#ifndef PERIODICTASK_H_
-#define PERIODICTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
@@ -17,8 +17,6 @@ class ExecutableObjectIF;
 /**
  * @brief 	This class represents a specialized task for
  * 			periodic activities of multiple objects.
- * @details
- *
  * @ingroup task_handling
  */
 class PeriodicTask: public PeriodicTaskIF {
@@ -26,24 +24,25 @@ public:
 	/**
 	 * @brief	Standard constructor of the class.
 	 * @details
-	 * The class is initialized without allocated objects. These need to be added
-	 * with #addComponent. In the underlying TaskBase class, a new operating
-	 * system task is created. In addition to the TaskBase parameters,
-	 * the period, the pointer to the aforementioned initialization function and
-	 * an optional "deadline-missed" function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values depend on
-	 * freeRTOS configuration, high number means high priority.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod The length of the period with which the task's
+	 * The class is initialized without allocated objects.
+	 * These need to be added with #addComponent.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
 	 * functionality will be executed. It is expressed in clock ticks.
 	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall be assigned.
+	 * The function pointer to the deadline missed function that shall
+	 * be assigned.
 	 */
 	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
 			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
 	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
-	 * 			lifetime, so the destructor is empty.
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
 	 */
 	virtual ~PeriodicTask(void);
 

From f0a25b5e2b0e26e549145ff429fc707a5f7c6bb3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:10:34 +0200
Subject: [PATCH 0347/1292] new timeout values for MUtexIF and SemaphIF

---
 ipc/MutexIF.h       | 17 +++++++++++++++--
 tasks/SemaphoreIF.h | 19 +++++++++++++++----
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index dcb1cf33..29e59e58 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -12,8 +12,21 @@
  */
 class MutexIF {
 public:
-	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
-	static const uint32_t MAX_TIMEOUT;
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
 	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index a7c5a97b..4fc92ebd 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -21,10 +21,21 @@
 class SemaphoreIF {
 public:
 	virtual~ SemaphoreIF() {};
-	//! Needs to be defined in implementation. No blocking time
-	static const uint32_t NO_TIMEOUT;
-	//! Needs to be defined in implementation. Blocks indefinitely.
-	static const uint32_t MAX_TIMEOUT;
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);

From 986dc2047e7ef0f52ebe8bd54fdf7f0fd565a518 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:19:48 +0200
Subject: [PATCH 0348/1292] replaced mutexIF and semaphoreIF name for timeouts

---
 datapoolglob/GlobalDataPool.cpp           |  2 +-
 events/EventManager.cpp                   |  2 +-
 health/HealthTable.cpp                    | 12 ++++++------
 internalError/InternalErrorReporter.cpp   | 18 +++++++++---------
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  8 ++++----
 osal/FreeRTOS/BinSemaphUsingTask.h        |  4 ++--
 osal/FreeRTOS/BinarySemaphore.cpp         |  8 ++++----
 osal/FreeRTOS/BinarySemaphore.h           |  4 ++--
 osal/FreeRTOS/Clock.cpp                   |  4 ++--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  8 ++++----
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  4 ++--
 osal/FreeRTOS/Mutex.cpp                   | 12 ++++++------
 osal/FreeRTOS/Mutex.h                     |  2 +-
 osal/FreeRTOS/SemaphoreFactory.cpp        |  4 ++--
 storagemanager/PoolManager.tpp            |  6 +++---
 15 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index e13765ba..18780904 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -54,7 +54,7 @@ ReturnValue_t GlobalDataPool::freeDataPoolLock() {
 }
 
 ReturnValue_t GlobalDataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
 	if ( status != RETURN_OK ) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index bff15e3c..73e77e94 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -151,7 +151,7 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 }
 
 void EventManager::unlockMutex() {
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 94b7cf0b..5d9f5c61 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -26,7 +26,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -36,7 +36,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -46,7 +46,7 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 }
 
 uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	uint32_t size = healthMap.size() * 5 + 2;
 	mutex->unlockMutex();
 	return size;
@@ -54,7 +54,7 @@ uint32_t HealthTable::getPrintSize() {
 
 bool HealthTable::hasHealth(object_id_t object) {
 	bool exits = false;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		exits = true;
@@ -64,7 +64,7 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
@@ -85,7 +85,7 @@ void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
 ReturnValue_t HealthTable::iterate(
 		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 30a02b44..8944553d 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -53,7 +53,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -62,21 +62,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -85,14 +85,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -103,7 +103,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -112,14 +112,14 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	storeHits++;
 	mutex->unlockMutex();
 }
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8f5fd4d8..d3351888 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -17,11 +17,11 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 48c1cd12..43772e5a 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -26,7 +26,7 @@ public:
 	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
+	        SemaphoreIF::BLOCKING) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
@@ -40,7 +40,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::NO_TIMEOUT);
+	        SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b6687bb7..e6d2f92f 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -36,11 +36,11 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+	    timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0938dee6..2a372cd2 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -53,7 +53,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+			SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -62,7 +62,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
+			SemaphoreIF::BLOCKING);
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index dce20265..ec07b662 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -155,7 +155,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,7 +170,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d0f63f3f..f33c7a0d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -38,11 +38,11 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 797e864b..f1d82c1d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -31,7 +31,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +61,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index cc2f865f..6d90c3f6 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -2,8 +2,8 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-const uint32_t MutexIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
@@ -23,11 +23,11 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = MutexIF::NO_TIMEOUT;
-	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
-		timeout = MutexIF::MAX_TIMEOUT;
+	TickType_t timeout = MutexIF::POLLING;
+	if(timeoutMs == MutexIF::BLOCKING) {
+		timeout = MutexIF::BLOCKING;
 	}
-	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+	else if(timeoutMs > MutexIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 90e82467..d6e0aab9 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 05a898cd..caf984f2 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,8 +6,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t SemaphoreIF::POLLING= 0;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 29b2b82a..9fb11776 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +41,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From 54edeacb2d20dcd5a01c0a11e3337b18fb3cf364 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 22:25:28 +0200
Subject: [PATCH 0349/1292] changed names for linux

---
 osal/FreeRTOS/SemaphoreFactory.cpp | 2 +-
 osal/linux/BinarySemaphore.cpp     | 6 +++---
 osal/linux/BinarySemaphore.h       | 2 +-
 osal/linux/Clock.cpp               | 4 ++--
 osal/linux/Mutex.cpp               | 5 +++--
 osal/linux/SemaphoreFactory.cpp    | 4 ++--
 6 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index caf984f2..78427f6c 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,7 +6,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING= 0;
+const uint32_t SemaphoreIF::POLLING = 0;
 const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 7c76a5c4..e2ad9b58 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -27,13 +27,13 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	int result = 0;
-	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::POLLING) {
 		result = sem_trywait(&handle);
 	}
-	else if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	else if(timeoutMs == SemaphoreIF::BLOCKING) {
 	    result = sem_wait(&handle);
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 7836cd41..9d4ed1cd 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -50,7 +50,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+	       	   SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 630b2cf4..eda5b7af 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -179,7 +179,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -194,7 +194,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index b4773267..bdcf3439 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -2,7 +2,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+const uint32_t MutexIF::POLLING = 0;
 uint8_t Mutex::count = 0;
 
 
@@ -41,7 +42,7 @@ Mutex::~Mutex() {
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	int status = 0;
-	if (timeoutMs != MutexIF::NO_TIMEOUT) {
+	if (timeoutMs != MutexIF::BLOCKING) {
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 5aec84ea..4fbd60d9 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -3,8 +3,8 @@
 #include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

From 6972e72fbf2a1a5f9dd1adae9c8274ecb1119581 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 23:52:31 +0200
Subject: [PATCH 0350/1292] fixed order

---
 ipc/FwMessageTypes.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 07e3d245..b59319aa 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -14,8 +14,9 @@ enum FW_MESSAGE_TYPE {
 	MONITORING,
 	MEMORY,
 	PARAMETER,
+	FILE_SYSTEM_MESSAGE,
 	FW_MESSAGES_COUNT,
-	FILE_SYSTEM_MESSAGE
+
 };
 }
 

From 5036cdbef3f23cc878c2ce09f66fc648fd34bbe5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 2 Jun 2020 23:54:24 +0200
Subject: [PATCH 0351/1292] queue factory first param uint32_t again

---
 ipc/QueueFactory.h             | 2 +-
 osal/FreeRTOS/QueueFactory.cpp | 2 +-
 osal/linux/QueueFactory.cpp    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 9a883fd8..09259ae3 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -18,7 +18,7 @@ public:
 	 */
 	static QueueFactory* instance();
 
-	MessageQueueIF* createMessageQueue(size_t messageDepth = 3,
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
 			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
 
 	void deleteMessageQueue(MessageQueueIF* queue);
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index a4ee5cf3..372d0d41 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -26,7 +26,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
 		size_t maxMessageSize) {
 	return new MessageQueue(messageDepth, maxMessageSize);
 }
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 2bacb815..268d0b99 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -28,7 +28,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
 		size_t maxMessageSize) {
 	return new MessageQueue(messageDepth, maxMessageSize);
 }

From 3483dff2abf171f85f61e498c6ce3c10131783ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 22:56:03 +0200
Subject: [PATCH 0352/1292] some more interface improvements

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 87 ++++++++++++---------
 serviceinterface/ServiceInterfaceBuffer.h   | 50 ++++++++----
 serviceinterface/ServiceInterfaceStream.cpp | 12 ++-
 serviceinterface/ServiceInterfaceStream.h   | 29 +++++--
 4 files changed, 119 insertions(+), 59 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 2a97ab90..b0abb929 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -3,9 +3,42 @@
 #include <cstring>
 
 // to be implemented by bsp
-extern "C" void printChar(const char*);
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+        bool errStream, bool addCrToPreamble, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), errStream(errStream) {
+	if(not errStream) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		printChar(begin, false);
+	}
+}
+
+#endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
+	if(errStream) {
+		if (c != Traits::eof()) {
+			printChar(reinterpret_cast<const char*>(&c), true);
+		}
+		return 0;
+	}
 	// Handle output
 	putChars(pbase(), pptr());
 	if (c != Traits::eof()) {
@@ -20,18 +53,13 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
+	if(errStream) {
+		return 0;
+	}
+
 	if (this->isActive) {
-		Clock::TimeOfDay_t loggerTime;
-		Clock::getDateAndTime(&loggerTime);
-		std::string preamble;
-		if(addCrToPreamble) {
-			preamble += "\r";
-		}
-		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
-				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-				+ zero_padded(loggerTime.second, 2) + "."
-				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
-		// Write log_message and time
+		auto preamble = getPreamble();
+		// Write logMessage and time
 		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
@@ -42,31 +70,20 @@ int ServiceInterfaceBuffer::sync(void) {
 }
 
 
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-        uint16_t port, bool addCrToPreamble) {
-	this->addCrToPreamble = addCrToPreamble;
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
+std::string ServiceInterfaceBuffer::getPreamble() {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	std::string preamble;
+	if(addCrToPreamble) {
+		preamble += "\r";
+	}
+	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
+							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+							+ zero_padded(loggerTime.second, 2) + "."
+							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+	return preamble;
 }
 
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		printChar(begin);
-	}
-
-}
-#endif
 
 
 #ifdef UT699
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a2bc4f4b..74facafe 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -3,43 +3,64 @@
 
 #include <iostream>
 #include <sstream>
-#include <cstdio>
 #include <iomanip>
 
 #ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
 class ServiceInterfaceBuffer:
-        public std::basic_streambuf<char,std::char_traits<char>> {
+        public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
-			bool addCrToPreamble);
+	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
+			bool addCrToPreamble, uint16_t port);
+
 protected:
 	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
 	int overflow(int c = Traits::eof()) override;
 
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
 private:
-	// For additional message information
-	std::string log_message;
+	//! For additional message information
+	std::string logMessage;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
-	// This is useful for some terminal programs which do not have
-	// implicit carriage return with newline characters.
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
 
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
-	// In this function, the characters are parsed.
+	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
+	std::string getPreamble();
+
+	/**
+	 * This helper function returns the zero padded string version of a number.
+	 * The type is deduced automatically.
+	 * @tparam T
+	 * @param num
+	 * @param width
+	 * @return
+	 */
 	template<typename T>
 	std::string zero_padded(const T& num, uint8_t width) {
 	    std::ostringstream string_to_pad;
@@ -52,6 +73,7 @@ private:
 	    return result;
 	}
 };
+
 #endif
 
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 40f52f1f..78371548 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,11 +1,15 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool errStream, bool addCrToPreamble, uint16_t port) :
+		std::ostream(&buf),
+		buf(setMessage, errStream, addCrToPreamble, port) {
+}
+
 void ServiceInterfaceStream::setActive( bool myActive) {
 	this->buf.isActive = myActive;
 }
 
-ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		bool addCrToPreamble, uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char>>(&buf),
-		buf(set_message, port, addCrToPreamble) {
+std::string ServiceInterfaceStream::getPreamble() {
+	return buf.getPreamble();
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index a445dced..52ac1310 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,11 +3,9 @@
 
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <iostream>
-#include <iosfwd>
-#include <sstream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of the log front end
 // (MUST be defined in main), to let the system know where to write to.
 namespace sif {
 extern std::ostream debug;
@@ -18,13 +16,32 @@ extern std::ostream error;
 
 
 class ServiceInterfaceStream :
-        public std::basic_ostream<char, std::char_traits<char>> {
+        public std::ostream {
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message,
-    		bool addCrToPreamble = false, uint16_t port = 1234);
+    /**
+     * This constructor is used by specifying the preamble message.
+     * Optionally, the output can be directed to stderr and a CR character
+     * can be prepended to the preamble.
+     * @param set_message
+     * @param errStream
+     * @param addCrToPreamble
+     * @param port
+     */
+    ServiceInterfaceStream(std::string setMessage,
+    		bool errStream = false, bool addCrToPreamble = false,
+			uint16_t port = 1234);
+
+    //! An inactive stream will not print anything.
 	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string getPreamble();
 };
 
 

From 1c0ca4c329c99caa75f438745b53a53f2978cd30 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:02:23 +0200
Subject: [PATCH 0353/1292] some changes to take care of activity

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index b0abb929..93de88b3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -33,7 +33,7 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 #endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
-	if(errStream) {
+	if(errStream and this->isActive) {
 		if (c != Traits::eof()) {
 			printChar(reinterpret_cast<const char*>(&c), true);
 		}
@@ -53,17 +53,18 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(errStream) {
+	if(not this->isActive or errStream) {
+		if(not errStream) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
 		return 0;
 	}
 
-	if (this->isActive) {
-		auto preamble = getPreamble();
-		// Write logMessage and time
-		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
-		// Handle output
-		this->putChars(pbase(), pptr());
-	}
+	auto preamble = getPreamble();
+	// Write logMessage and time
+	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	// Handle output
+	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
 	setp(buf, buf + BUF_SIZE - 1);
 	return 0;

From 5b93799ea659b0b93bd769657c0d00c390786e26 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:10:04 +0200
Subject: [PATCH 0354/1292] added forward declarations for service interface
 streams

---
 serviceinterface/ServiceInterfaceStream.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 52ac1310..aecd45c3 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -44,5 +44,13 @@ public:
 	std::string getPreamble();
 };
 
+// Forward declaration of interface streams. These are needed so the public
+// functions can be used by including this header
+namespace sif {
+extern ServiceInterfaceStream debugStream;
+extern ServiceInterfaceStream infoStream;
+extern ServiceInterfaceStream warningStream;
+extern ServiceInterfaceStream errorStream;
+}
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 0a512abc3364855116a4756e42aeac33c0aa2fe2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:26:27 +0200
Subject: [PATCH 0355/1292] additional clarification comment

---
 serviceinterface/ServiceInterfaceStream.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index aecd45c3..32437d81 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -7,6 +7,9 @@
 
 // Unfortunately, there must be a forward declaration of the log front end
 // (MUST be defined in main), to let the system know where to write to.
+// The ServiceInterfaceStream instances (declared below and instantiated in main)
+// can be passed to these front ends by passing their underlying buffers
+// with .rdbuf()
 namespace sif {
 extern std::ostream debug;
 extern std::ostream info;

From 5eb3d77bdbb1f4537c95d5c6919a0792b8f274e6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:29:00 +0200
Subject: [PATCH 0356/1292] clarfiying comment

---
 serviceinterface/ServiceInterfaceStream.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 32437d81..375a1875 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,11 +5,11 @@
 #include <iostream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of the log front end
-// (MUST be defined in main), to let the system know where to write to.
-// The ServiceInterfaceStream instances (declared below and instantiated in main)
-// can be passed to these front ends by passing their underlying buffers
-// with .rdbuf()
+/* Unfortunately, there must be a forward declaration of the log front end
+ * (MUST be defined in main), to let the system know where to write to.
+ * The ServiceInterfaceStream instances, which are declared below and
+ * can instantaited somewhere else can be passed to these front ends by passing
+ * their underlying buffers with .rdbuf() */
 namespace sif {
 extern std::ostream debug;
 extern std::ostream info;

From 17ed9b77967f6a8ba2deb281a730df3b33fdadb3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:38:02 +0200
Subject: [PATCH 0357/1292] OS renamed to OS_FSFW (nameclash with system
 variable)

---
 framework.mk | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/framework.mk b/framework.mk
index cb3e4f22..f2107a4c 100644
--- a/framework.mk
+++ b/framework.mk
@@ -28,11 +28,11 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/objectmanager/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 
 # select the OS
-ifeq ($(OS),rtems)
+ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
-else ifeq ($(OS),linux)
+else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
-else ifeq ($(OS),freeRTOS)
+else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else
 $(error invalid OS specified, valid OS are rtems, linux, freeRTOS)

From 925a54dec965b0c52d312616f9f42902fd5fac2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 01:06:03 +0200
Subject: [PATCH 0358/1292] more improvements for servicei nterface

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 28 +++++++----
 serviceinterface/ServiceInterfaceBuffer.h   |  5 +-
 serviceinterface/ServiceInterfaceStream.cpp | 22 ++++++++-
 serviceinterface/ServiceInterfaceStream.h   | 51 +++++++++++----------
 4 files changed, 69 insertions(+), 37 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 93de88b3..92f08cae 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -8,10 +8,11 @@ extern "C" void printChar(const char*, bool errStream);
 #ifndef UT699
 
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-        bool errStream, bool addCrToPreamble, uint16_t port):
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
 		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), errStream(errStream) {
-	if(not errStream) {
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
@@ -26,16 +27,27 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	memcpy(array, begin, length);
 
 	for(; begin != end; begin++){
-		printChar(begin, false);
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+
 	}
 }
 
 #endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
-	if(errStream and this->isActive) {
+	if(not buffered and this->isActive) {
 		if (c != Traits::eof()) {
-			printChar(reinterpret_cast<const char*>(&c), true);
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
 		}
 		return 0;
 	}
@@ -53,8 +65,8 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive or errStream) {
-		if(not errStream) {
+	if(not this->isActive) {
+		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 74facafe..e3927007 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -19,8 +19,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
-			bool addCrToPreamble, uint16_t port);
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
 
 protected:
 	bool isActive;
@@ -41,6 +41,7 @@ private:
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 78371548..bef8136e 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,9 +1,9 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool errStream, bool addCrToPreamble, uint16_t port) :
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
 		std::ostream(&buf),
-		buf(setMessage, errStream, addCrToPreamble, port) {
+		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
 }
 
 void ServiceInterfaceStream::setActive( bool myActive) {
@@ -13,3 +13,21 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 std::string ServiceInterfaceStream::getPreamble() {
 	return buf.getPreamble();
 }
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not buffered and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and buffered) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 375a1875..9b8b5b6e 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,19 +5,11 @@
 #include <iostream>
 #include <cstdio>
 
-/* Unfortunately, there must be a forward declaration of the log front end
- * (MUST be defined in main), to let the system know where to write to.
- * The ServiceInterfaceStream instances, which are declared below and
- * can instantaited somewhere else can be passed to these front ends by passing
- * their underlying buffers with .rdbuf() */
-namespace sif {
-extern std::ostream debug;
-extern std::ostream info;
-extern std::ostream warning;
-extern std::ostream error;
-}
-
-
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
 class ServiceInterfaceStream :
         public std::ostream {
 protected:
@@ -27,14 +19,14 @@ public:
      * This constructor is used by specifying the preamble message.
      * Optionally, the output can be directed to stderr and a CR character
      * can be prepended to the preamble.
-     * @param set_message
-     * @param errStream
-     * @param addCrToPreamble
-     * @param port
+     * @param setMessage message of preamble.
+     * @param addCrToPreamble Useful for applications like Puttty.
+     * @param buffered specify whether to use buffered mode.
+     * @param errStream specify which output stream to use (stderr or stdout).
      */
     ServiceInterfaceStream(std::string setMessage,
-    		bool errStream = false, bool addCrToPreamble = false,
-			uint16_t port = 1234);
+    		bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
 
     //! An inactive stream will not print anything.
 	void setActive( bool );
@@ -45,15 +37,24 @@ public:
 	 * @return Preamle consisting of log message and timestamp.
 	 */
 	std::string getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+	bool buffered = false;
 };
 
-// Forward declaration of interface streams. These are needed so the public
-// functions can be used by including this header
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
 namespace sif {
-extern ServiceInterfaceStream debugStream;
-extern ServiceInterfaceStream infoStream;
-extern ServiceInterfaceStream warningStream;
-extern ServiceInterfaceStream errorStream;
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
 }
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From a115bf1186d075ea8c6b98c03ba847f22d41251b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 14:43:33 +0200
Subject: [PATCH 0359/1292] store access improvements

---
 storagemanager/LocalPool.h        | 10 +++++-----
 storagemanager/PoolManager.h      |  3 ++-
 storagemanager/PoolManager.tpp    |  1 -
 storagemanager/StorageManagerIF.h |  3 ++-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 2d61dea5..bb94a3be 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -24,7 +24,6 @@
  * 			The local pool is NOT thread-safe.
  * @author 	Bastian Baetz
  */
-
 template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
@@ -48,9 +47,10 @@ public:
 	 * 						number of elements for each pool is determined.
 	 * 						The position of these values correspond to those in
 	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not. Default is false (local pool).
-	 * @param spillsToHigherPools
-	 * 						A variable to determine whether higher n pools are used if the store is full.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
 	 */
 	LocalPool(object_id_t setObjectId,
 			const uint16_t element_sizes[NUMBER_OF_POOLS],
@@ -117,7 +117,7 @@ private:
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a \c new call on construction.
+	 * 			a @c new call on construction.
 	 */
 	uint8_t* store[NUMBER_OF_POOLS];
 	/**
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index c74e95c0..7c2e8a71 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -12,7 +12,7 @@
  * 			with a lock.
  * @author 	Bastian Baetz
  */
-template <uint8_t NUMBER_OF_POOLS>
+template <uint8_t NUMBER_OF_POOLS = 5>
 class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
 public:
 	PoolManager(object_id_t setObjectId,
@@ -27,6 +27,7 @@ public:
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
+
 protected:
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 9fb11776..a35b810c 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -48,4 +48,3 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 }
 
 #endif
-
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d5ac5818..f8aee819 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -11,7 +11,6 @@
 using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
 using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
 
-
 /**
  * @brief	This class provides an interface for intermediate data storage.
  * @details	The Storage manager classes shall be used to store larger chunks of
@@ -80,6 +79,7 @@ public:
 	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) = 0;
 
+
 	/**
 	 * @brief 	Access the data by supplying a store ID.
 	 * @details
@@ -100,6 +100,7 @@ public:
 	virtual ReturnValue_t getData(store_address_t storeId,
 			ConstStorageAccessor& constAccessor) = 0;
 
+
 	/**
 	 * @brief	getData returns an address to data and the size of the data
 	 * 			for a given packet_id.

From 6ff1cf46c5cda5e6c9ecb85926acc68c8825b1ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:40:43 +0200
Subject: [PATCH 0360/1292] new service interface stream

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 46 ++++++++++++++++-----
 serviceinterface/ServiceInterfaceBuffer.h   | 36 +++-------------
 serviceinterface/ServiceInterfaceStream.cpp | 13 +++---
 serviceinterface/ServiceInterfaceStream.h   | 32 +++++++-------
 4 files changed, 63 insertions(+), 64 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 92f08cae..f1332637 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,7 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
+#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
@@ -16,6 +17,8 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
+	preamble.reserve(96);
+	preamble.resize(96);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -65,16 +68,22 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive) {
+	if(not this->isActive and not buffered) {
 		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
 	}
+	if(not buffered) {
+		return 0;
+	}
 
-	auto preamble = getPreamble();
+	size_t preambleSize  = 0;
+	auto preamble = getPreamble(&preambleSize);
+	uint8_t debugArray[96];
+	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -82,18 +91,35 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
 
-std::string ServiceInterfaceBuffer::getPreamble() {
+std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble;
+	std::string preamble (96, 0);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
-		preamble += "\r";
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		return "";
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
 	}
-	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
-							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-							+ zero_padded(loggerTime.second, 2) + "."
-							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 	return preamble;
 }
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e3927007..00a8e74a 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -33,18 +34,20 @@ protected:
 	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
+	bool isBuffered() const;
 private:
 	//! For additional message information
 	std::string logMessage;
+	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
-	bool buffered;
+
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-
+	bool buffered;
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
@@ -52,39 +55,12 @@ private:
 	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
-	std::string getPreamble();
-
-	/**
-	 * This helper function returns the zero padded string version of a number.
-	 * The type is deduced automatically.
-	 * @tparam T
-	 * @param num
-	 * @param width
-	 * @return
-	 */
-	template<typename T>
-	std::string zero_padded(const T& num, uint8_t width) {
-	    std::ostringstream string_to_pad;
-	    string_to_pad << std::setw(width) << std::setfill('0') << num;
-	    std::string result = string_to_pad.str();
-	    if (result.length() > width)
-	    {
-	        result.erase(0, result.length() - width);
-	    }
-	    return result;
-	}
+	std::string getPreamble(size_t * preambleSize = nullptr);
 };
 
 #endif
 
 
-
-
-
-
-
-
-
 #ifdef UT699
 class ServiceInterfaceBuffer: public std::basic_streambuf<char,
 		std::char_traits<char> > {
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index bef8136e..76481ed1 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -2,21 +2,20 @@
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&buf),
-		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
-}
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
 
 void ServiceInterfaceStream::setActive( bool myActive) {
-	this->buf.isActive = myActive;
+	this->streambuf.isActive = myActive;
 }
 
 std::string ServiceInterfaceStream::getPreamble() {
-	return buf.getPreamble();
+	return streambuf.getPreamble();
 }
 
 void ServiceInterfaceStream::print(std::string error,
 		bool withPreamble, bool withNewline, bool flush) {
-	if(not buffered and withPreamble) {
+	if(not streambuf.isBuffered() and withPreamble) {
 		*this << getPreamble() << error;
 	}
 	else {
@@ -27,7 +26,7 @@ void ServiceInterfaceStream::print(std::string error,
 		*this << "\n";
 	}
 	// if mode is non-buffered, no need to flush.
-	if(flush and buffered) {
+	if(flush and streambuf.isBuffered()) {
 		this->flush();
 	}
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 9b8b5b6e..9e19c228 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -10,25 +10,22 @@
  * std::cerr but has additional capability. Add preamble and timestamp
  * to output. Can be run in buffered or unbuffered mode.
  */
-class ServiceInterfaceStream :
-        public std::ostream {
-protected:
-    ServiceInterfaceBuffer buf;
+class ServiceInterfaceStream : public std::ostream {
 public:
-    /**
-     * This constructor is used by specifying the preamble message.
-     * Optionally, the output can be directed to stderr and a CR character
-     * can be prepended to the preamble.
-     * @param setMessage message of preamble.
-     * @param addCrToPreamble Useful for applications like Puttty.
-     * @param buffered specify whether to use buffered mode.
-     * @param errStream specify which output stream to use (stderr or stdout).
-     */
-    ServiceInterfaceStream(std::string setMessage,
-    		bool addCrToPreamble = false, bool buffered = true,
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
 			bool errStream = false, uint16_t port = 1234);
 
-    //! An inactive stream will not print anything.
+	//! An inactive stream will not print anything.
 	void setActive( bool );
 
 	/**
@@ -45,7 +42,8 @@ public:
 	void print(std::string error, bool withPreamble = true,
 			bool withNewline = true, bool flush = true);
 
-	bool buffered = false;
+protected:
+	ServiceInterfaceBuffer streambuf;
 };
 
 // Forward declaration of interface streams. These should be instantiated in

From 4d59ddc3db6d9382e61bc4492e51c63283174489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:50:26 +0200
Subject: [PATCH 0361/1292] some fixes, check for preamble size

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 15 ++++++++-------
 serviceinterface/ServiceInterfaceBuffer.h   |  9 +++++++--
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index f1332637..5c80862c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -17,8 +17,8 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
-	preamble.reserve(96);
-	preamble.resize(96);
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -36,7 +36,6 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 		else {
 			printChar(begin, false);
 		}
-
 	}
 }
 
@@ -80,8 +79,6 @@ int ServiceInterfaceBuffer::sync(void) {
 
 	size_t preambleSize  = 0;
 	auto preamble = getPreamble(&preambleSize);
-	uint8_t debugArray[96];
-	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
 	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
@@ -98,7 +95,6 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble (96, 0);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
@@ -113,7 +109,12 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 					loggerTime.second,
 					loggerTime.usecond /1000);
 	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return "";
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
 		return "";
 	}
 	currentSize += charCount;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 00a8e74a..39ea25c2 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -20,6 +20,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
 	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
 			bool buffered, bool errStream, uint16_t port);
 
@@ -41,14 +43,17 @@ private:
 	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
 
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-	bool buffered;
-	// Work in buffer mode. It is also possible to work without buffer.
+
+	//! Needed for buffered mode.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 

From 3eca16ff785b928f7015444d987a5dbed0ce99dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 20:59:52 +0200
Subject: [PATCH 0362/1292] removed exit clause

---
 objectmanager/ObjectManagerIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 3575fc16..b523727c 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -93,7 +93,6 @@ T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
-		std::exit(0);
 	}
 	SystemObjectIF* temp = this->getSystemObject(id);
 	return dynamic_cast<T*>(temp);

From 71487d60ca524042c95dffdf1582252f028f35e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:01:09 +0200
Subject: [PATCH 0363/1292] onj managerIF update

---
 objectmanager/ObjectManagerIF.h | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index b523727c..90a1ce3b 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,12 +1,5 @@
-/**
- * @file	ObjectManagerIF.h
- * @brief	This file contains the implementation of the ObjectManagerIF interface
- * @date	19.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGERIF_H_
-#define OBJECTMANAGERIF_H_
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
 #include <framework/objectmanager/SystemObjectIF.h>
@@ -20,7 +13,8 @@
  * 			inserted, removed and retrieved from the list. On getting the
  * 			object, the call checks if the object implements the requested
  * 			interface.
- * \ingroup system_objects
+ * @author	Bastian Baetz
+ * @ingroup system_objects
  */
 class ObjectManagerIF : public HasReturnvaluesIF {
 public:

From 849053b830d92ccd463779569cb6c450033b47c1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:04:24 +0200
Subject: [PATCH 0364/1292] small fix for object manager.cpp

---
 objectmanager/ObjectManager.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 1912715d..67cf5c1c 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -23,8 +23,8 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << (int)id << std::dec << " is already in use!" << std::endl;
-		exit(0); //This is very severe and difficult to handle in other places.
-		return this->INSERTION_FAILED;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
 	}
 }
 

From 569724843e7196d5c7ca0b324cd575b6aa9aa9ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:11:49 +0200
Subject: [PATCH 0365/1292] object manager improvements

---
 objectmanager/ObjectManager.cpp | 34 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 67cf5c1c..3e0bfed6 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -2,21 +2,19 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <cstdlib>
 
-ObjectManager::ObjectManager( void (*setProducer)() ) : produceObjects(setProducer) {
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
 	//There's nothing special to do in the constructor.
 }
 
 
 ObjectManager::~ObjectManager() {
-	std::map<object_id_t, SystemObjectIF*>::iterator it;
-	for (it = this->objectList.begin(); it != this->objectList.end(); it++) {
-		delete it->second;
-	}
+	// Map is STL object and deletes its own pointers.
 }
 
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	bool insert_return = this->objectList.insert( std::pair< object_id_t, SystemObjectIF* >( id, object ) ).second;
-	if (insert_return == true) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
 		return this->RETURN_OK;
@@ -44,18 +42,15 @@ ReturnValue_t ObjectManager::remove( object_id_t id ) {
 
 
 SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.find( id );
-	if (it == this->objectList.end() ) {
-		//Changed for testing different method.
-//		SystemObjectIF* object = this->produceObjects( id );
-//		return object;
-		return NULL;
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
 	} else {
-		return it->second;
+		return listIter->second;
 	}
 }
 
-ObjectManager::ObjectManager( ) : produceObjects(NULL) {
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 }
 
@@ -63,7 +58,7 @@ void ObjectManager::initialize() {
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;
-	for (std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.begin(); it != objectList.end(); it++ ) {
+	for (auto it = this->objectList.begin(); it != objectList.end(); it++ ) {
 		return_value = it->second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it->first;
@@ -79,10 +74,11 @@ void ObjectManager::initialize() {
 	}
 	//Init was successful. Now check successful interconnections.
 	error_count = 0;
-	for (std::map<object_id_t, SystemObjectIF*>::iterator it = this->objectList.begin(); it != objectList.end(); it++ ) {
-		return_value = it->second->checkObjectConnections();
+	for (auto listIter = this->objectList.begin();
+			listIter != objectList.end(); listIter++ ) {
+		return_value = listIter->second->checkObjectConnections();
 		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) it->first
+			sif::error << "Object " << std::hex <<  (int) listIter->first
 			        << " connection check failed with code 0x" << return_value
 			        << std::dec << std::endl;
 			error_count++;

From d423c001156916fe62b3113c539dee9931f359fb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:14:35 +0200
Subject: [PATCH 0366/1292] additional nullptr check

---
 objectmanager/ObjectManager.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 3e0bfed6..a5895098 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -55,6 +55,11 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 }
 
 void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager: Passed produceObjects functions is"
+				"nullptr!" << std::endl;
+		return;
+	}
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;

From e4944a067c3624a669c4703bfa0d5dce5f1b4119 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:24:44 +0200
Subject: [PATCH 0367/1292] change made was wrong (pointers in map are not
 deleted!)

---
 objectmanager/ObjectManager.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a5895098..b12c66d9 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -9,7 +9,9 @@ ObjectManager::ObjectManager( void (*setProducer)() ):
 
 
 ObjectManager::~ObjectManager() {
-	// Map is STL object and deletes its own pointers.
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
 }
 
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
@@ -99,7 +101,7 @@ void ObjectManager::initialize() {
 void ObjectManager::printList() {
 	std::map<object_id_t, SystemObjectIF*>::iterator it;
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
-	for (it = this->objectList.begin(); it != this->objectList.end(); it++) {
-		sif::debug << std::hex << it->first << " | " << it->second << std::endl;
+	for (auto const& it : objectList) {
+		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
 	}
 }

From dd193fd64d302e5592dfddc8a4395101d921b61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 21:27:37 +0200
Subject: [PATCH 0368/1292] obj manager.cpp improvements

---
 objectmanager/ObjectManager.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index b12c66d9..2f47950f 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -65,10 +65,10 @@ void ObjectManager::initialize() {
 	this->produceObjects();
 	ReturnValue_t return_value = RETURN_FAILED;
 	uint32_t error_count = 0;
-	for (auto it = this->objectList.begin(); it != objectList.end(); it++ ) {
-		return_value = it->second->initialize();
+	for (auto const& it : objectList) {
+		return_value = it.second->initialize();
 		if ( return_value != RETURN_OK ) {
-			object_id_t var = it->first;
+			object_id_t var = it.first;
 			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
 					std::setfill('0')<< var << " failed to initialize " <<
 					"with code 0x" << return_value << std::dec << std::endl;
@@ -81,11 +81,10 @@ void ObjectManager::initialize() {
 	}
 	//Init was successful. Now check successful interconnections.
 	error_count = 0;
-	for (auto listIter = this->objectList.begin();
-			listIter != objectList.end(); listIter++ ) {
-		return_value = listIter->second->checkObjectConnections();
+	for (auto const& it : objectList) {
+		return_value = it.second->checkObjectConnections();
 		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) listIter->first
+			sif::error << "Object " << std::hex <<  (int) it.first
 			        << " connection check failed with code 0x" << return_value
 			        << std::dec << std::endl;
 			error_count++;

From 904721cc3638ffac5a1c4758e84395726d2a415b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 13:44:11 +0200
Subject: [PATCH 0369/1292] improved pool entry iF

---
 datapool/PoolEntry.cpp |  38 ++++++++------
 datapool/PoolEntry.h   | 115 ++++++++++++++++++++++++++---------------
 datapool/PoolEntryIF.h |  32 ++++++------
 3 files changed, 110 insertions(+), 75 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d07c516d..a87a6c4e 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,30 +1,37 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/globalfunctions/printer.h>
+#include <cstring>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t set_length,
-		uint8_t set_valid ) : length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
-		memset(this->address, 0, this->getByteSize());
+		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 {
-		memcpy(this->address, initValue.begin(), this->getByteSize());
+		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t set_length, uint8_t set_valid ) :
-		length(set_length), valid(set_valid) {
+PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
-	if (initValue != NULL) {
-		memcpy(this->address, initValue, this->getByteSize() );
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
 	} else {
-		memset(this->address, 0, this->getByteSize() );
+		std::memset(this->address, 0, this->getByteSize() );
 	}
 }
 
-
 //As the data pool is global, this dtor is only be called on program exit.
 //Warning! Never copy pool entries!
 template <typename T>
@@ -48,21 +55,20 @@ void* PoolEntry<T>::getRawData() {
 }
 
 template <typename T>
-void PoolEntry<T>::setValid( uint8_t isValid ) {
+void PoolEntry<T>::setValid(bool isValid) {
 	this->valid = isValid;
 }
 
 template <typename T>
-uint8_t PoolEntry<T>::getValid() {
+bool PoolEntry<T>::getValid() {
 	return valid;
 }
 
 template <typename T>
 void PoolEntry<T>::print() {
-	for (uint8_t size = 0; size < this->length; size++ ) {
-		sif::debug << "| " << std::hex << (double)this->address[size]
-		           << (this->valid? " (valid) " : " (invalid) ");
-	}
+	 sif::debug << "Pool Entry Validity: " <<
+			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+	printer::print(reinterpret_cast<uint8_t*>(address), length);
 	sif::debug << std::dec << std::endl;
 }
 
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 4971ee45..1a22bb63 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,95 +1,126 @@
-#ifndef POOLENTRY_H_
-#define POOLENTRY_H_
-
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
 
 #include <framework/datapool/PoolEntryIF.h>
-#include <stddef.h>
-#include <cstring>
+
 #include <initializer_list>
 #include <type_traits>
+#include <cstddef>
+
 /**
  * @brief	This is a small helper class that defines a single data pool entry.
  * @details
  * The helper is used to store all information together with the data as a
- * single data pool entry.The content's type is defined by the template argument.
- * It is prepared for use with plain old data types, but may be extended to
- * complex types if necessary. It can be initialized with a certain value,
- * size and validity flag. It holds a pointer to the real data and offers
- * methods to access this data and to acquire additional information
- * (such as validity and array/byte size). It is NOT intended to be used
- * outside the DataPool class.
- * @author	Bastian Baetz
- * @ingroup data_pool
+ * single data pool entry. The content's type is defined by the template
+ * argument.
  *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
  */
 template <typename T>
 class PoolEntry : public PoolEntryIF {
 public:
 	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"Warum? Darum :-)");
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * @param initValue	Initializer list with values to initialize with
-	 * @param set_length	Defines the array length of this entry.
-	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @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.
+	 * @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.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry( std::initializer_list<T> initValue = {}, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.
-	 * @param initValue		A pointer to the single value or array that holds the init value.
-	 * 						With the default value (NULL), the entry is initalized with all 0.
-	 * @param set_length	Defines the array length of this entry.
-	 * @param set_valid		Sets the initialization flag. It is invalid (0) by default.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry( T* initValue = NULL, uint8_t set_length = 1, uint8_t set_valid = 0 );
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
 
 	/**
-	 * \brief	The allocated memory for the variable is freed in the destructor.
-	 * \details	As the data pool is global, this dtor is only called on program exit.
-	 * 			PoolEntries shall never be copied, as a copy might delete the variable on the heap.
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
 	 */
 	~PoolEntry();
+
 	/**
-	 * \brief	This is the address pointing to the allocated memory.
+	 * @brief	This is the address pointing to the allocated memory.
 	 */
 	T* address;
 	/**
-	 * \brief	This attribute stores the length information.
+	 * @brief	This attribute stores the length information.
 	 */
 	uint8_t length;
 	/**
-	 * \brief	Here, the validity information for a variable is stored.
+	 * @brief	Here, the validity information for a variable is stored.
 	 * 			Every entry (single variable or vector) has one valid flag.
 	 */
 	uint8_t valid;
 	/**
-	 * \brief	getSize returns the array size of the entry.
-	 * \details	A single parameter has size 1.
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
 	 */
 	uint8_t getSize();
 	/**
-	 * \brief	This operation returns the size in bytes.
-	 * \details	The size is calculated by sizeof(type) * array_size.
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
 	 */
 	uint16_t getByteSize();
 	/**
-	 * \brief	This operation returns a the address pointer casted to void*.
+	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	void* getRawData();
 	/**
-	 * \brief	This method allows to set the valid information of the pool entry.
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
 	 */
-	void setValid( uint8_t isValid );
+	void setValid( bool isValid );
 	/**
-	 * \brief	This method allows to get the valid information of the pool entry.
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
 	 */
-	uint8_t getValid();
+	bool getValid();
 	/**
-	 * \brief	This is a debug method that prints all values and the valid information to the screen.
-	 * 			It prints all array entries in a row.
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
 	 */
 	void print();
 
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index d24d553a..a075436e 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,5 +1,5 @@
-#ifndef POOLENTRYIF_H_
-#define POOLENTRYIF_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
 
 #include <framework/globalfunctions/Type.h>
 #include <cstdint>
@@ -9,55 +9,53 @@
  * 			single data pool entry.
  * @details
  * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to
- * the raw data content. It is mainly used by DataPool itself, but also as a
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
  * return pointer.
- * @author 	Bastian Baetz
+ *
+ * @author	Bastian Baetz
  * @ingroup data_pool
+ *
  */
 class PoolEntryIF {
 public:
 	/**
 	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
+	 * 			as it is required for C++ interfaces.
 	 */
-	virtual ~PoolEntryIF() {}
-
+	virtual ~PoolEntryIF() {
+	}
 	/**
 	 * @brief	getSize returns the array size of the entry.
 	 * 			A single variable parameter has size 1.
 	 */
 	virtual uint8_t getSize() = 0;
-
 	/**
 	 * @brief	This operation returns the size in bytes, which is calculated by
 	 * 			sizeof(type) * array_size.
 	 */
 	virtual uint16_t getByteSize() = 0;
-
 	/**
 	 * @brief	This operation returns a the address pointer casted to void*.
 	 */
 	virtual void* getRawData() = 0;
-
 	/**
 	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
-	virtual void setValid(uint8_t isValid) = 0;
-
+	virtual void setValid(bool isValid) = 0;
 	/**
 	 * @brief	This method allows to set the valid information of the pool entry.
 	 */
-	virtual uint8_t getValid() = 0;
-
+	virtual bool getValid() = 0;
 	/**
 	 * @brief	This is a debug method that prints all values and the valid
 	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
 	 */
 	virtual void print() = 0;
-
 	/**
-	 * @brief 	Returns the type of the entry.
+	 * Returns the type of the entry.
 	 */
 	virtual Type getType() = 0;
 };

From dd210e99af8ece3866bc898ec3daa631d90b8d9d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 13:45:18 +0200
Subject: [PATCH 0370/1292] additional include which was missing

---
 datapoolglob/PoolRawAccess.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index cc04f9b9..b10ee04c 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -3,6 +3,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/Endiness.h>
 
+#include <cstring>
+
 PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
 		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),

From d7036edb94e7d64626e3cacf3d205c2b9db143a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 15:53:20 +0200
Subject: [PATCH 0371/1292] hotfix

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 3df2abe9..e13e7eb6 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -82,7 +82,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 			}
 		}
 		//No Else If, go on with buffer
-		if (bufferLength >= *size) {
+		if (bufferLength <= *size) {
 			*size -= bufferLength;
 			memcpy(m_buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;

From abcd818f2f48f6805ca1bfadf9d9694078e6a963 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 16:44:31 +0200
Subject: [PATCH 0372/1292] printer renamed to arrayprinter

---
 globalfunctions/arrayprinter.cpp | 61 ++++++++++++++++++++++++++++++++
 globalfunctions/arrayprinter.h   | 20 +++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 globalfunctions/arrayprinter.cpp
 create mode 100644 globalfunctions/arrayprinter.h

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
new file mode 100644
index 00000000..e8fce56c
--- /dev/null
+++ b/globalfunctions/arrayprinter.cpp
@@ -0,0 +1,61 @@
+#include <framework/globalfunctions/arrayprinter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/arrayprinter.h b/globalfunctions/arrayprinter.h
new file mode 100644
index 00000000..e57d8e04
--- /dev/null
+++ b/globalfunctions/arrayprinter.h
@@ -0,0 +1,20 @@
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_
+#include <cstdint>
+#include <cstddef>
+
+enum class OutputType {
+	DEC,
+	HEX,
+	BIN
+};
+
+namespace arrayprinter {
+void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
+		bool printInfo = true, size_t maxCharPerLine = 12);
+void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
+void printBin(const uint8_t* data, size_t size);
+}
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_ARRAYPRINTER_H_ */

From 4ebd937fe036e5a9427f2bda8683bfca58d5207b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 16:47:46 +0200
Subject: [PATCH 0373/1292] deleted old printer file

---
 datapool/PoolEntry.cpp      |  4 +--
 globalfunctions/printer.cpp | 61 -------------------------------------
 globalfunctions/printer.h   | 21 -------------
 3 files changed, 2 insertions(+), 84 deletions(-)
 delete mode 100644 globalfunctions/printer.cpp
 delete mode 100644 globalfunctions/printer.h

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index a87a6c4e..d535a72b 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,6 +1,6 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/printer.h>
+#include <framework/globalfunctions/arrayprinter.h>
 #include <cstring>
 
 template <typename T>
@@ -68,7 +68,7 @@ template <typename T>
 void PoolEntry<T>::print() {
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-	printer::print(reinterpret_cast<uint8_t*>(address), length);
+	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
 	sif::debug << std::dec << std::endl;
 }
 
diff --git a/globalfunctions/printer.cpp b/globalfunctions/printer.cpp
deleted file mode 100644
index a68a91ee..00000000
--- a/globalfunctions/printer.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <framework/globalfunctions/printer.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <bitset>
-
-void printer::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		printer::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		printer::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    printer::printBin(data, size);
-	}
-}
-
-void printer::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void printer::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void printer::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
diff --git a/globalfunctions/printer.h b/globalfunctions/printer.h
deleted file mode 100644
index 33a382ec..00000000
--- a/globalfunctions/printer.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_
-#include <cstdint>
-#include <cstddef>
-
-namespace printer {
-
-enum class OutputType {
-	DEC,
-	HEX,
-	BIN
-};
-
-void print(const uint8_t* data, size_t size, OutputType type = OutputType::HEX,
-		bool printInfo = true, size_t maxCharPerLine = 12);
-void printHex(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printDec(const uint8_t* data, size_t size, size_t maxCharPerLine = 12);
-void printBin(const uint8_t* data, size_t size);
-}
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_PRINTER_H_ */

From dbeb04895b2d86731be07c4f6af7b1f7f09316fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 17:55:03 +0200
Subject: [PATCH 0374/1292] added hosted OSAL

---
 framework.mk                   |   4 +-
 osal/host/Clock.cpp            | 227 ++++++++++++++++++++++++++++++++
 osal/host/MessageQueue.cpp     | 144 +++++++++++++++++++++
 osal/host/MessageQueue.h       | 230 +++++++++++++++++++++++++++++++++
 osal/host/Mutex.cpp            |  40 ++++++
 osal/host/Mutex.h              |  28 ++++
 osal/host/MutexFactory.cpp     |  28 ++++
 osal/host/PeriodicTask.cpp     | 176 +++++++++++++++++++++++++
 osal/host/PeriodicTask.h       | 122 +++++++++++++++++
 osal/host/QueueFactory.cpp     |  41 ++++++
 osal/host/QueueMapManager.cpp  |  46 +++++++
 osal/host/QueueMapManager.h    |  47 +++++++
 osal/host/SemaphoreFactory.cpp |  40 ++++++
 osal/host/TaskFactory.cpp      |  55 ++++++++
 14 files changed, 1227 insertions(+), 1 deletion(-)
 create mode 100644 osal/host/Clock.cpp
 create mode 100644 osal/host/MessageQueue.cpp
 create mode 100644 osal/host/MessageQueue.h
 create mode 100644 osal/host/Mutex.cpp
 create mode 100644 osal/host/Mutex.h
 create mode 100644 osal/host/MutexFactory.cpp
 create mode 100644 osal/host/PeriodicTask.cpp
 create mode 100644 osal/host/PeriodicTask.h
 create mode 100644 osal/host/QueueFactory.cpp
 create mode 100644 osal/host/QueueMapManager.cpp
 create mode 100644 osal/host/QueueMapManager.h
 create mode 100644 osal/host/SemaphoreFactory.cpp
 create mode 100644 osal/host/TaskFactory.cpp

diff --git a/framework.mk b/framework.mk
index f2107a4c..2092c2fe 100644
--- a/framework.mk
+++ b/framework.mk
@@ -34,8 +34,10 @@ else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+else ifeq ($(OS_FSFW),host)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 else
-$(error invalid OS specified, valid OS are rtems, linux, freeRTOS)
+$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
 endif
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
new file mode 100644
index 00000000..78bbc58a
--- /dev/null
+++ b/osal/host/Clock.cpp
@@ -0,0 +1,227 @@
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/timemanager/Clock.h>
+
+#include <chrono>
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <fstream>
+#endif
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+using SystemClock = std::chrono::system_clock;
+
+uint32_t Clock::getTicksPerSecond(void){
+	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+	return 0;
+	//return CLOCKS_PER_SEC;
+	//uint32_t ticks = sysconf(_SC_CLK_TCK);
+	//return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	// do some magic with chrono
+#if defined(WIN32)
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+
+#endif
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+#if defined(WIN32)
+	auto now  = std::chrono::system_clock::now();
+	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto epoch = now.time_since_epoch();
+	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
+	auto fraction = now - secondsChrono;
+	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	        fraction).count();
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval timeval;
+#if defined(WIN32)
+	auto uptime  = std::chrono::milliseconds(GetTickCount64());
+	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
+	timeval.tv_sec = secondsChrono.count();
+	auto fraction = uptime - secondsChrono;
+	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	            fraction).count();
+#elif defined(LINUX)
+	double uptimeSeconds;
+	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
+	{
+		// value is rounded down automatically
+		timeval.tv_sec = uptimeSeconds;
+		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
+	}
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
+	return timeval;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// do some magic with chrono (C++20!)
+	// Right now, the library doesn't have the new features yet.
+	// so we work around that for now.
+	auto now = SystemClock::now();
+	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto fraction = now - seconds;
+	time_t tt = SystemClock::to_time_t(now);
+	struct tm* timeInfo;
+	timeInfo = gmtime(&tt);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
+	time->usecond = usecond.count();
+
+	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+	time_tm.tm_year = from->year - 1900;
+	time_tm.tm_mon = from->month - 1;
+	time_tm.tm_mday = from->day;
+
+	time_tm.tm_hour = from->hour;
+	time_tm.tm_min = from->minute;
+	time_tm.tm_sec = from->second;
+
+	time_t seconds = mktime(&time_tm);
+
+	to->tv_sec = seconds;
+	to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex == nullptr){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex == nullptr){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
new file mode 100644
index 00000000..7d5e4d97
--- /dev/null
+++ b/osal/host/MessageQueue.cpp
@@ -0,0 +1,144 @@
+#include <framework/osal/host/MessageQueue.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/host/QueueMapManager.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		messageSize(maxMessageSize), messageDepth(messageDepth) {
+	queueLock = MutexFactory::instance()->createMutex();
+	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "MessageQueue: Could not be created" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	MutexFactory::instance()->deleteMutex(queueLock);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return MessageQueueIF::NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault);
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	if(messageQueue.empty()) {
+		return MessageQueueIF::EMPTY;
+	}
+	// not sure this will work..
+	//*message = std::move(messageQueue.front());
+	MessageQueueMessage* currentMessage = &messageQueue.front();
+	std::copy(currentMessage->getBuffer(),
+			currentMessage->getBuffer() + messageSize, message->getBuffer());
+	messageQueue.pop();
+	// The last partner is the first uint32_t field in the message
+	this->lastPartner = message->getSender();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	*count = messageQueue.size();
+	// Clears the queue.
+	messageQueue = std::queue<MessageQueueMessage>();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return mqId;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
+	this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return defaultDestinationSet;
+}
+
+
+// static core function to send messages.
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        bool ignoreFault) {
+	if(message->messageSize > MessageQueueMessage::MAX_DATA_SIZE) {
+		// Actually, this should never happen or an error will be emitted
+		// in MessageQueueMessage.
+		// But I will still return a failure here.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
+			QueueMapManager::instance()->getMessageQueue(sendTo));
+	if(targetQueue == nullptr) {
+		if(not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+							objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		// TODO: Better returnvalue
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
+		MutexHelper mutexLock(targetQueue->queueLock, 20);
+		targetQueue->messageQueue.push(*message);
+	}
+	else {
+		return MessageQueueIF::FULL;
+	}
+    message->setSender(sentFrom);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::lockQueue(millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
new file mode 100644
index 00000000..a0cce001
--- /dev/null
+++ b/osal/host/MessageQueue.h
@@ -0,0 +1,230 @@
+#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+
+#include <framework/internalError/InternalErrorReporterIF.h>
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/ipc/MutexIF.h>
+#include <framework/timemanager/Clock.h>
+
+#include <queue>
+#include <memory>
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue is
+	 * created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender
+	 * parent, but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the
+	 *  destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false) override;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the
+	 * sendToDefault call of the MessageQueueSender parent class and adds its
+	 * queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault(MessageQueueMessage* message) override;
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using
+	 * the stored lastPartner information as destination. If there was no
+	 * message received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply(MessageQueueMessage* message) override;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a
+	 * 			receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 *  The OS's return value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send
+	 * the message to.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	The sendToDefault method sends a queue message to the default
+	 * 			destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue
+	 * 			and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in  addition
+	 * returns the sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in the lastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message) override;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count) override;
+	/**
+	 * @brief	This method returns the message queue id of the last
+	 * 			communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const override;
+	/**
+	 * @brief	This method returns the message queue id of this class's
+	 * 			message queue.
+	 */
+	MessageQueueId_t getId() const override;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+	ReturnValue_t lockQueue(millis_t lockTimeout);
+	ReturnValue_t unlockQueue();
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+
+	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	std::queue<MessageQueueMessage> messageQueue;
+	/**
+	 * @brief	The class stores the queue id it got assigned.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t mqId = 0;
+	size_t messageSize = 0;
+	size_t messageDepth = 0;
+
+	MutexIF* queueLock;
+
+	bool defaultDestinationSet = false;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
new file mode 100644
index 00000000..0e6e652d
--- /dev/null
+++ b/osal/host/Mutex.cpp
@@ -0,0 +1,40 @@
+#include <framework/osal/host/Mutex.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t MutexIF::NO_TIMEOUT = 0;
+const uint32_t MutexIF::MAX_TIMEOUT = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+		mutex.lock();
+		locked = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else if(timeoutMs == MutexIF::NO_TIMEOUT) {
+		if(mutex.try_lock()) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+		auto chronoMs = std::chrono::milliseconds(timeoutMs);
+		if(mutex.try_lock_for(chronoMs)) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	return MutexIF::MUTEX_TIMEOUT;
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if(not locked) {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+	mutex.unlock();
+	locked = false;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::timed_mutex* Mutex::getMutexHandle() {
+	return &mutex;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
new file mode 100644
index 00000000..dce2a9dc
--- /dev/null
+++ b/osal/host/Mutex.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+
+#include <framework/ipc/MutexIF.h>
+
+#include <mutex>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
new file mode 100644
index 00000000..25d9fa46
--- /dev/null
+++ b/osal/host/MutexFactory.cpp
@@ -0,0 +1,28 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/osal/host/Mutex.h>
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
new file mode 100644
index 00000000..57898ac2
--- /dev/null
+++ b/osal/host/PeriodicTask.cpp
@@ -0,0 +1,176 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/osal/host/Mutex.h>
+#include <framework/osal/host/PeriodicTask.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), taskName(name), period(setPeriod),
+		deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	terminateThread = true;
+	if(mainThread.joinable()) {
+		mainThread.join();
+	}
+	delete this;
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+
+
+	if (not originalTask->started) {
+		// we have to suspend/block here until the task is started.
+		// if semaphores are implemented, use them here.
+		std::unique_lock<std::mutex> lock(initMutex);
+		initCondition.wait(lock);
+	}
+
+	this->taskFunctionality();
+	sif::debug << "PeriodicTask::taskEntryPoint: "
+			"Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// Notify task to start.
+	std::lock_guard<std::mutex> lock(initMutex);
+	initCondition.notify_one();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
+	auto currentStartTime {
+	    std::chrono::duration_cast<std::chrono::milliseconds>(
+	    std::chrono::system_clock::now().time_since_epoch())
+	};
+	auto nextStartTime{ currentStartTime };
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		if(terminateThread.load()) {
+			break;
+		}
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(not delayUntil(&currentStartTime, periodChrono)) {
+			sif::warning << "PeriodicTask: " << taskName <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+bool PeriodicTask::delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
+        const std::chrono::milliseconds interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
new file mode 100644
index 00000000..19c06b52
--- /dev/null
+++ b/osal/host/PeriodicTask.h
@@ -0,0 +1,122 @@
+#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/tasks/PeriodicTaskIF.h>
+#include <framework/tasks/Typedef.h>
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
+ *
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be
+	 * added with #addComponent.
+	 * @param priority
+	 * @param stack_size
+	 * @param setPeriod
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall be
+	 * assigned.
+	 */
+	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
+			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 *  -@c RETURN_OK on success
+	 *  -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+	bool started;
+	//!< Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	std::thread mainThread;
+	std::atomic<bool> terminateThread = false;
+
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	std::condition_variable initCondition;
+	std::mutex initMutex;
+	std::string taskName;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed. So, each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context.
+	 * The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called. Afterwards
+	 * the checkAndRestartPeriod system call blocks the task until the next
+	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	bool delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
+	        const std::chrono::milliseconds interval);
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
new file mode 100644
index 00000000..691249c3
--- /dev/null
+++ b/osal/host/QueueFactory.cpp
@@ -0,0 +1,41 @@
+#include <framework/ipc/QueueFactory.h>
+#include <framework/osal/host/MessageQueue.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+		size_t maxMessageSize) {
+	// A thread-safe queue can be implemented  by using a combination
+	// of std::queue and std::mutex. This uses dynamic memory allocation
+	// which could be alleviated by using a custom allocator, external library
+	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
new file mode 100644
index 00000000..a57d2c0c
--- /dev/null
+++ b/osal/host/QueueMapManager.cpp
@@ -0,0 +1,46 @@
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+#include <framework/osal/host/QueueMapManager.h>
+
+QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
+
+QueueMapManager::QueueMapManager() {}
+
+QueueMapManager* QueueMapManager::instance() {
+	if (mqManagerInstance == nullptr){
+		mqManagerInstance = new QueueMapManager();
+	}
+	return QueueMapManager::mqManagerInstance;
+}
+
+ReturnValue_t QueueMapManager::addMessageQueue(
+		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	uint32_t currentId = queueCounter++;
+	auto returnPair = queueMap.emplace(currentId, queueToInsert);
+	if(not returnPair.second) {
+		// this should never happen for the atomic variable.
+		sif::error << "QueueMapManager: This ID is already inside the map!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if (id != nullptr) {
+		*id = currentId;
+	}
+	mapLock = MutexFactory::instance()->createMutex();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* QueueMapManager::getMessageQueue(
+		MessageQueueId_t messageQueueId) const {
+	MutexHelper(mapLock, 50);
+	auto queueIter = queueMap.find(messageQueueId);
+	if(queueIter != queueMap.end()) {
+		return queueIter->second;
+	}
+	else {
+		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
new file mode 100644
index 00000000..34f0fc95
--- /dev/null
+++ b/osal/host/QueueMapManager.h
@@ -0,0 +1,47 @@
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/osal/host/MessageQueue.h>
+#include <unordered_map>
+#include <atomic>
+
+using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
+
+
+/**
+ * An internal map to map message queue IDs to message queues.
+ * This propably should be a singleton..
+ */
+class QueueMapManager {
+public:
+	//! Returns the single instance of SemaphoreFactory.
+	static QueueMapManager* instance();
+
+	/**
+	 * Insert a message queue into the map and returns a message queue ID
+	 * @param queue The message queue to insert.
+	 * @param id The passed value will be set unless a nullptr is passed
+	 * @return
+	 */
+	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
+			id = nullptr);
+	/**
+	 * Get the message queue handle by providing a message queue ID.
+	 * @param messageQueueId
+	 * @return
+	 */
+	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
+
+private:
+	//! External instantiation is forbidden.
+	QueueMapManager();
+	std::atomic<uint32_t> queueCounter = MessageQueueIF::NO_QUEUE + 1;
+	MutexIF* mapLock;
+	QueueMap queueMap;
+	static QueueMapManager* mqManagerInstance;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
new file mode 100644
index 00000000..3719a883
--- /dev/null
+++ b/osal/host/SemaphoreFactory.cpp
@@ -0,0 +1,40 @@
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/osal/linux/BinarySemaphore.h>
+#include <framework/osal/linux/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
+			" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
+				" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
new file mode 100644
index 00000000..a13844c4
--- /dev/null
+++ b/osal/host/TaskFactory.cpp
@@ -0,0 +1,55 @@
+#include <framework/osal/host/PeriodicTask.h>
+#include <framework/tasks/TaskFactory.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/PeriodicTaskIF.h>
+
+#include <chrono>
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+// Will propably not be used for hosted implementation
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
+
+TaskFactory::TaskFactory() {
+}
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	sif::warning << "TaskFactory::createFixedTimeslotTask: Not implemented "
+			"yet" << std::endl;
+	return nullptr;
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	// This might block for some time!
+	delete task;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+

From ef3e5c4582df70896758e775bed5383b7c415689 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 18:20:21 +0200
Subject: [PATCH 0375/1292] very important bugfix for serial buffer adapter

---
 serialize/SerialBufferAdapter.cpp | 39 ++++++++++++-------------------
 serialize/SerialBufferAdapter.h   |  9 +++----
 2 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index e13e7eb6..db91a93f 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -3,22 +3,17 @@
 #include <cstring>
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
 		serializeLength(serializeLength),
-		constBuffer(static_cast<const uint8_t *>(buffer)), m_buffer(nullptr),
-		bufferLength(bufferLength) {
-
-}
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), bufferLength(bufferLength) {
-	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
-	m_buffer = member_buffer;
-	constBuffer = member_buffer;
-}
+		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		bufferLength(bufferLength) {}
 
 
 template<typename count_t>
@@ -42,8 +37,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
 		}
 		if (constBuffer != nullptr) {
 			memcpy(*buffer, constBuffer, bufferLength);
-		} else if (m_buffer != nullptr) {
-			memcpy(*buffer, m_buffer, bufferLength);
+		} else if (buffer != nullptr) {
+			memcpy(*buffer, buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
@@ -66,14 +61,11 @@ template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	// (Robin) the one of the buffer? wouldn't that be an issue for serialize
-	// as well? SerialFixedArrayListAdapter implements swapping of buffer
-	// fields (if buffer type is not uint8_t)
 	if (buffer != nullptr) {
 		if(serializeLength) {
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
-			if(bufferLength + serializedSize >= *size) {
+			if(bufferLength + serializedSize <= *size) {
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
 			}
@@ -84,7 +76,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(m_buffer, *buffer, bufferLength);
+			memcpy(buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
@@ -99,28 +91,27 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(m_buffer == nullptr) {
+	if(buffer == nullptr) {
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
-	return m_buffer;
+	return buffer;
 }
 
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getBuffer()" << std::endl;
+		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;
 }
 
 template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
 		count_t buffer_length) {
-	m_buffer = static_cast<uint8_t *>(buffer);
+	this->buffer = buffer;
 	bufferLength = buffer_length;
 }
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index d414573c..cb799be5 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -29,7 +29,7 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const void* buffer, count_t bufferLength,
+	SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
 			bool serializeLength = false);
 
 	/**
@@ -40,7 +40,8 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength Length field will be serialized with size count_t
 	 */
-	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+			bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
@@ -66,11 +67,11 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(void* buffer_, count_t bufferLength_);
+	void setBuffer(uint8_t* buffer_, count_t bufferLength_);
 private:
 	bool serializeLength = false;
 	const uint8_t *constBuffer = nullptr;
-	uint8_t *m_buffer = nullptr;
+	uint8_t *buffer = nullptr;
 	count_t bufferLength = 0;
 };
 

From 872c350a9296999af94ad2c275fd2bf34abec1b0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 18:36:22 +0200
Subject: [PATCH 0376/1292] another small bugfix (this-> was missing)

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index db91a93f..ad4ec358 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -76,7 +76,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(buffer, *buffer, bufferLength);
+			memcpy(this->buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}

From 8d3ac33b0ef0b22e35dc102f9d715878780d50df Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:18:38 +0200
Subject: [PATCH 0377/1292] reordering init list for compiler

---
 serialize/SerialBufferAdapter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ad4ec358..e409686f 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -12,7 +12,7 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
 template<typename count_t>
 SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
 		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), buffer(buffer), constBuffer(buffer),
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
 		bufferLength(bufferLength) {}
 
 

From 9fd5ef0194ebad3e2fe1bfc90b705fe7438ac29b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:28:06 +0200
Subject: [PATCH 0378/1292] updated datapool files

---
 datapool/DataSetBase.cpp  | 65 ++++++++++++++++++++++-----------------
 datapool/DataSetBase.h    | 48 ++++++++++++++++++-----------
 datapool/DataSetIF.h      |  8 +++--
 datapool/PoolVariableIF.h | 52 +++++++++++++++++++++++--------
 4 files changed, 112 insertions(+), 61 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 6ff2fc83..9104c8e7 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -31,20 +31,14 @@ ReturnValue_t DataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::read() {
+ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	if (state == States::DATA_SET_UNINITIALISED) {
-		lockDataPool();
+		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
-			if (registeredVariables[count]->getReadWriteMode()
-					!= PoolVariableIF::VAR_WRITE
-					&& registeredVariables[count]->getDataPoolId()
-					!= PoolVariableIF::NO_PARAMETER) {
-				ReturnValue_t status = registeredVariables[count]->read();
-				if (status !=  HasReturnvaluesIF::RETURN_OK) {
-					result = INVALID_PARAMETER_DEFINITION;
-					break;
-				}
+			ReturnValue_t result = readVariable(count);
+			if(result != RETURN_OK) {
+				break;
 			}
 		}
 		state = States::DATA_SET_WAS_READ;
@@ -58,47 +52,53 @@ ReturnValue_t DataSetBase::read() {
 	return result;
 }
 
-ReturnValue_t DataSetBase::commit() {
+ReturnValue_t DataSetBase::readVariable(uint16_t count) {
+	ReturnValue_t result = DataSetIF::INVALID_PARAMETER_DEFINITION;
+	// 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();
+	}
+	return result;
+}
+
+ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit();
+		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit();
+		return handleUnreadDatasetCommit(lockTimeout);
 	}
 }
 
-ReturnValue_t DataSetBase::lockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void DataSetBase::handleAlreadyReadDatasetCommit() {
-	lockDataPool();
+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]->commit();
+			registeredVariables[count]->commitWithoutLock();
 		}
 	}
 	state = States::DATA_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
+ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool();
+	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]->commit();
+			registeredVariables[count]->commitWithoutLock();
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -113,6 +113,15 @@ ReturnValue_t DataSetBase::handleUnreadDatasetCommit() {
 	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, bool bigEndian) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 6b468c11..8bf9a99a 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -2,6 +2,7 @@
 #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.
@@ -21,7 +22,8 @@
  * 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 lockDataPo
+ * 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
  */
@@ -49,14 +51,15 @@ public:
 	 *
 	 * 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
+	 * @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();
-
+	virtual ReturnValue_t read(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call initializes writing back the registered variables.
 	 * @details
@@ -67,23 +70,30 @@ public:
 	 * 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.
+	 * 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();
+	virtual ReturnValue_t commit(uint32_t lockTimeout =
+			MutexIF::BLOCKING) override;
 
-	/* DataSetIF implementation */
+	/**
+	 * 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() override;
+	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
@@ -98,12 +108,12 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 
-	//SHOULDDO we could use a linked list of datapool variables
+	// SHOULDDO we could use a linked list of datapool variables
 	//!< This definition sets the maximum number of variables to
 	//! register in one DataSet.
 	static const uint8_t DATA_SET_MAX_SIZE = 63;
-protected:
 
+protected:
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -128,8 +138,10 @@ protected:
 	 */
 	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
 
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
+private:
+	ReturnValue_t readVariable(uint16_t count);
+	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
+	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
 #endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index d9cc4966..9c5b13c8 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -2,6 +2,7 @@
 #define DATASETIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/timemanager/Clock.h>
 class PoolVariableIF;
 
 /**
@@ -33,20 +34,23 @@ 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
 	 * 			to this DataSet operation.
 	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable ) = 0;
+	virtual ReturnValue_t registerVariable(PoolVariableIF* variable) = 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() = 0;
+	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs) = 0;
 	/**
 	 * @brief   Unlock call corresponding to the lock call.
 	 * @return Unlock operation result
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 0cbc18c5..3086bbe8 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -21,18 +21,10 @@ class PoolVariableIF : public SerializeIF {
 	friend class DataSetBase;
 	friend class GlobDataSet;
 	friend class LocalDataSet;
-protected:
-	/**
-	 * @brief	The commit call shall write back a newly calculated local
-	 * 			value to the data pool.
-	 */
-	virtual ReturnValue_t commit() = 0;
-	/**
-	 * @brief	The read call shall read the value of this parameter from
-	 * 			the data pool and store the content locally.
-	 */
-	virtual ReturnValue_t read() = 0;
 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 bool VALID = 1;
 	static constexpr bool INVALID = 0;
 	static constexpr uint32_t NO_PARAMETER = 0;
@@ -61,9 +53,43 @@ public:
 	/**
 	 * @brief	With this call, the valid information of the variable is set.
 	 */
-	// why not just use a boolean here?
-	virtual void setValid(uint8_t validity) = 0;
+	virtual void setValid(bool validity) = 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;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;

From e04e6a6f1506ca90498803bbce49e854e5ed5d4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:33:57 +0200
Subject: [PATCH 0379/1292] datapoolglob update

---
 datapoolglob/GlobalDataPool.cpp     | 10 ++---
 datapoolglob/GlobalDataPool.h       |  4 +-
 datapoolglob/GlobalDataSet.cpp      | 14 +++----
 datapoolglob/GlobalDataSet.h        |  7 ++--
 datapoolglob/GlobalPoolVariable.h   | 64 +++++++++++++++++++----------
 datapoolglob/GlobalPoolVariable.tpp | 36 ++++++++++++++--
 datapoolglob/GlobalPoolVector.h     | 40 ++++++++++++++----
 datapoolglob/GlobalPoolVector.tpp   | 36 +++++++++++++++-
 datapoolglob/PIDReader.h            | 24 +++++++++--
 datapoolglob/PoolRawAccess.cpp      | 34 +++++++++++++--
 datapoolglob/PoolRawAccess.h        | 48 +++++++++++++++-------
 11 files changed, 244 insertions(+), 73 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 18780904..25acaab3 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -44,18 +44,18 @@ PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
 	}
 }
 
-ReturnValue_t GlobalDataPool::freeDataPoolLock() {
+ReturnValue_t GlobalDataPool::unlockDataPool() {
 	ReturnValue_t status = mutex->unlockMutex();
-	if ( status != RETURN_OK ) {
+	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: unlock of mutex failed with"
 				" error code: " << status << std::endl;
 	}
 	return status;
 }
 
-ReturnValue_t GlobalDataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
-	if ( status != RETURN_OK ) {
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(timeoutMs);
+	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
 	}
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index 42921a77..b9c1436f 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -95,12 +95,12 @@ public:
 	 * @brief	This is a small helper function to facilitate locking the global data pool.
 	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
 	 */
-	ReturnValue_t lockDataPool();
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
 	/**
 	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
 	 * @details	It fetches the pool's mutex id and tries to free the mutex.
 	 */
-	ReturnValue_t freeDataPoolLock();
+	ReturnValue_t unlockDataPool();
 	/**
 	 * @brief	The print call is a simple debug method.
 	 * @details	It prints the current content of the data pool.
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 503d068e..9da8d524 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -8,22 +8,22 @@ GlobDataSet::GlobDataSet(): DataSetBase() {}
 // (Destructor is already called)
 GlobDataSet::~GlobDataSet() {}
 
-ReturnValue_t GlobDataSet::commit(bool valid) {
+ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
 	setEntriesValid(valid);
 	setSetValid(valid);
-	return commit();
+	return commit(lockTimeout);
 }
 
-ReturnValue_t GlobDataSet::commit() {
-	return DataSetBase::commit();
+ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
+	return DataSetBase::commit(lockTimeout);
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.freeDataPoolLock();
+	return glob::dataPool.unlockDataPool();
 }
 
-ReturnValue_t GlobDataSet::lockDataPool() {
-	return glob::dataPool.lockDataPool();
+ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
+	return glob::dataPool.lockDataPool(timeoutMs);
 }
 
 void GlobDataSet::setEntriesValid(bool valid) {
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index c2e0b577..f0bf7daa 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -44,8 +44,8 @@ public:
 	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
 	 * 			     contains non write-only variables
 	 */
-	ReturnValue_t commit(bool valid);
-	ReturnValue_t commit() override;
+	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 
 	/**
 	 * Set all entries
@@ -74,8 +74,7 @@ private:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool() override;
-
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index eb44c307..9e3eea0c 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -72,7 +72,49 @@ public:
 	 */
 	~GlobPoolVar() {}
 
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
 protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
 	/**
 	 * @brief	To access the correct data pool entry on read and commit calls,
 	 * 			the data pool is stored.
@@ -91,26 +133,6 @@ protected:
 	 */
 	pool_rwm_t readWriteMode;
 
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 */
-	ReturnValue_t read() override;
-
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
-	 *
-	 */
-	ReturnValue_t commit() override;
-
 	/**
 	 * Empty ctor for List initialization
 	 */
@@ -138,7 +160,7 @@ public:
 
 	uint8_t getValid();
 
-	void setValid(uint8_t valid);
+	void setValid(bool valid) override;
 
 	operator T() {
 		return value;
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/datapoolglob/GlobalPoolVariable.tpp
index d55ea4e0..d61d605d 100644
--- a/datapoolglob/GlobalPoolVariable.tpp
+++ b/datapoolglob/GlobalPoolVariable.tpp
@@ -12,8 +12,38 @@ inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
 	}
 }
 
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T>
+inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
 template <class T>
-inline ReturnValue_t GlobPoolVar<T>::read() {
+inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
 	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
 	if (read_out != NULL) {
 		valid = read_out->valid;
@@ -29,7 +59,7 @@ inline ReturnValue_t GlobPoolVar<T>::read() {
 }
 
 template <class T>
-inline ReturnValue_t GlobPoolVar<T>::commit() {
+inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
 	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->valid = valid;
@@ -80,7 +110,7 @@ inline uint8_t GlobPoolVar<T>::getValid() {
 }
 
 template <class T>
-inline void GlobPoolVar<T>::setValid(uint8_t valid) {
+inline void GlobPoolVar<T>::setValid(bool valid) {
 	this->valid = valid;
 }
 
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 24303457..93092228 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -102,7 +102,7 @@ public:
 		else
 			return false;
 	}
-	void setValid(uint8_t valid) {this->valid = valid;}
+	void setValid(bool valid) {this->valid = valid;}
 	uint8_t getValid() {return valid;}
 
 	T &operator [](int i) {return value[i];}
@@ -113,7 +113,7 @@ public:
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
-protected:
+
 	/**
 	 * @brief	This is a call to read the array's values
 	 * 			from the global data pool.
@@ -122,19 +122,43 @@ protected:
 	 * data pool id from the global data pool and copies all array values
 	 * and the valid information to its local attributes.
 	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid. The operation does NOT provide
-	 * any mutual exclusive protection by itself.
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read();
-
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
 	 * It checks type and size, as well as if the variable is writable. If so,
 	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit();
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
 private:
 	/**
 	 * @brief	To access the correct data pool entry on read and commit calls,
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index 0b43191b..5710da57 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -12,8 +12,40 @@ inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
 	}
 }
 
+
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
 	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
 			vectorSize);
 	if (read_out != nullptr) {
@@ -33,7 +65,7 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::read() {
 }
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit() {
+inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
 			vectorSize);
 	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 11206611..359b871f 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -15,7 +15,8 @@ class PIDReader: public PoolVariableIF {
 protected:
 	uint32_t parameterId;
 	uint8_t valid;
-	ReturnValue_t read() {
+
+	ReturnValue_t readWithoutLock() {
 		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
 		PoolEntry<T>* read_out = glob::dataPool.getData<T>(
 				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
@@ -36,9 +37,13 @@ protected:
 	 * Reason is the possibility to access a single DP vector element, but if we commit,
 	 * we set validity of the whole vector.
 	 */
-	ReturnValue_t commit() {
+	ReturnValue_t commit(uint32_t lockTimeout) override {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	/**
 	 * Empty ctor for List initialization
 	 */
@@ -71,6 +76,19 @@ public:
 		}
 	}
 
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
 	/**
 	 * Copy ctor to copy classes containing Pool Variables.
 	 */
@@ -113,7 +131,7 @@ public:
 		return valid;
 	}
 
-	void setValid(uint8_t valid) {
+	void setValid(bool valid) {
 		this->valid = valid;
 	}
 
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index b10ee04c..39cfd58c 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -18,7 +18,21 @@ PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
 
 PoolRawAccess::~PoolRawAccess() {}
 
-ReturnValue_t PoolRawAccess::read() {
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
 	ReturnValue_t result = RETURN_FAILED;
 	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
 	if (readOut != nullptr) {
@@ -75,7 +89,21 @@ void PoolRawAccess::handleReadError(ReturnValue_t result) {
 	memset(value, 0, sizeof(value));
 }
 
-ReturnValue_t PoolRawAccess::commit() {
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
 	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
 	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
 		write_back->setValid(valid);
@@ -189,7 +217,7 @@ bool PoolRawAccess::isValid() const {
 		return false;
 }
 
-void PoolRawAccess::setValid(uint8_t valid) {
+void PoolRawAccess::setValid(bool valid) {
 	this->valid = valid;
 }
 
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 452b5397..60e3c71e 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -124,7 +124,7 @@ public:
 	 */
 	bool isValid() const;
 
-	void setValid(uint8_t valid);
+	void setValid(bool valid);
 	/**
 	 * Getter for the remaining size.
 	 */
@@ -135,31 +135,49 @@ public:
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
-protected:
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
-	 * @details	When executed, this operation tries to fetch the pool entry with matching
-	 * 			data pool id from the global data pool and copies the value and the valid
-	 * 			information to its local attributes. In case of a failure (wrong type or
-	 * 			pool id not found), the variable is set to zero and invalid.
-	 * 			The operation does NOT provide any mutual exclusive protection by itself !
-	 * 			If reading from the data pool without information about the type is desired,
-	 * 			initialize the raw pool access by supplying a data set and using the data set
-	 * 			read function, which calls this read function.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
 	 * @return -@c RETURN_OK Read successfull
 	 * 		   -@c READ_TYPE_TOO_LARGE
 	 * 		   -@c READ_INDEX_TOO_LARGE
 	 * 		   -@c READ_ENTRY_NON_EXISTENT
 	 */
-	ReturnValue_t read();
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details	It checks type and size, as well as if the variable is writable. If so,
-	 * 			the value is copied and the valid flag is automatically set to "valid".
-	 * 			The operation does NOT provide any mutual exclusive protection by itself.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
 	 *
 	 */
-	ReturnValue_t commit();
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
 
 	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
 	void handleReadError(ReturnValue_t result);

From 319fa9ddb6237c58d9fe8b0e5763b0b463ec82a4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:34:34 +0200
Subject: [PATCH 0380/1292] datapoollocal update

---
 datapoollocal/LocalDataSet.cpp      |  69 +++-------
 datapoollocal/LocalDataSet.h        | 141 +++------------------
 datapoollocal/LocalPoolVariable.h   | 143 +++++++++++++++------
 datapoollocal/LocalPoolVariable.tpp |  83 +++++++++---
 datapoollocal/LocalPoolVector.h     | 189 ++++++++++++++++++++++++++++
 datapoollocal/LocalPoolVector.tpp   | 185 +++++++++++++++++++++++++++
 6 files changed, 582 insertions(+), 228 deletions(-)
 create mode 100644 datapoollocal/LocalPoolVector.h
 create mode 100644 datapoollocal/LocalPoolVector.tpp

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 07f86e18..988f254a 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,66 +1,35 @@
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 
-LocalDataSet::LocalDataSet():
-		fill_count(0), state(DATA_SET_UNINITIALISED)
-{
-	for (unsigned count = 0; count < DATA_SET_MAX_SIZE; count++) {
-		registeredVariables[count] = nullptr;
+LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
+	if(hkOwner != nullptr) {
+		hkManager = hkOwner->getHkManagerHandle();
+	}
+	else {
+		// config error, error output here.
 	}
 }
 
-// who has the responsibility to lock the mutex? the local pool variable
-// has access to the HK manager and could call its mutex lock function.
-ReturnValue_t LocalDataSet::registerVariable(
-		PoolVariableIF *variable) {
-	return RETURN_OK;
+LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
+	HasHkPoolParametersIF* hkOwner = objectManager->get<HasHkPoolParametersIF>(
+			ownerId);
+	if(hkOwner == nullptr) {
+		// config error, error output here.
+	}
+	hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::~LocalDataSet() {
 }
 
-ReturnValue_t LocalDataSet::read() {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::commit(void) {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::commit(bool valid) {
-	return RETURN_OK;
-}
-
-void LocalDataSet::setSetValid(bool valid) {
-}
-
-void LocalDataSet::setEntriesValid(bool valid) {
-}
-
-ReturnValue_t LocalDataSet::serialize(uint8_t **buffer,
-		size_t *size, const size_t max_size, bool bigEndian) const {
-	return RETURN_OK;
-}
-
-size_t LocalDataSet::getSerializedSize() const {
-	return 0;
-}
-
-ReturnValue_t LocalDataSet::deSerialize(const uint8_t **buffer,
-		size_t *size, bool bigEndian) {
-	return RETURN_OK;
-}
-
-ReturnValue_t LocalDataSet::lockDataPool() {
-	return RETURN_OK;
+ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(timeoutMs);
 }
 
 ReturnValue_t LocalDataSet::unlockDataPool() {
-	return RETURN_OK;
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
 }
 
-void LocalDataSet::handleAlreadyReadDatasetCommit() {
-}
 
-ReturnValue_t LocalDataSet::handleUnreadDatasetCommit() {
-	return RETURN_OK;
-}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 6110175c..607d10b3 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,8 +1,12 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+class HousekeepingManager;
+
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out variables
  * 			for local data pools
@@ -24,32 +28,22 @@
  *
  * @ingroup data_pool
  */
-class LocalDataSet:
-		public DataSetIF,
-		public HasReturnvaluesIF,
-		public SerializeIF {
+class LocalDataSet: public DataSetBase {
 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 DATA_SET_UNINITIALIZED = 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 );
 	/**
-	 * @brief	The constructor simply sets the fill_count to zero and sets
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet();
+	LocalDataSet(HasHkPoolParametersIF* hkOwner);
 
 	/**
-	 * @brief	This operation is used to register the local variables in the set.
-	 * @details	It stores the pool variable pointer in a variable list.
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
 	 */
-	ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+	LocalDataSet(object_id_t ownerId);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -61,127 +55,30 @@ public:
 	 */
 	~LocalDataSet();
 
-	/**
-	 * @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
-	 */
-	ReturnValue_t read();
-
-	/**
-	 * @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
-	 */
-	ReturnValue_t commit(void);
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @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
-	 */
-	ReturnValue_t commit(bool valid);
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+protected:
 private:
-	// SHOULDDO we could use a linked list of datapool variables
-	//! This definition sets the maximum number of variables
-	//! to register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 */
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-	/**
-	 * @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 fill_count;
-
-	/**
-	 * States of the seet.
-	 */
-	enum 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;
-
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
-	 * 			the underlying data data pool structure
+	 * 			the global data pool.
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool() override;
-
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
 	/**
 	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the underlying data data pool structure
+	 * 			unlocking the global data pool
 	 * @details
 	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
+	HousekeepingManager* hkManager;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 39c92f60..cb373a71 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,56 +3,63 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
+#include <framework/serialize/SerializeAdapter.h>
 #include <framework/housekeeping/HousekeepingManager.h>
 
-#include <map>
-/**
- * @brief	This is the access class for non-array local data pool entries.
- *
- * @details
- *
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-
 /**
  * @brief 	Local Pool Variable class which is used to access the local pools.
- * @details This class is not stored in the map. Instead, it is used to access
- * 			the pool entries by using a pointer to the map storing the pool
- * 			entries. It can also be used to organize these pool entries
- * 			into data sets.
- * @tparam T
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
  */
 template<typename T>
 class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
 public:
-	static constexpr lp_id_t INVALID_POOL_ID = 0xFFFFFFFF;
+	//! Default ctor is forbidden.
+	LocalPoolVar() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
 	 * instances which can also be stored in datasets.
-	 * @param set_id
-	 * @param setReadWriteMode
-	 * @param localPoolMap
-	 * @param dataSet
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
-			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
 
 	/**
 	 * This constructor is used by data users like controllers to have
 	 * access to the local pool variables of data creators by supplying
 	 * the respective creator object ID.
-	 * @param poolId
-	 * @param poolOwner
-	 * @param setReadWriteMode
-	 * @param dataSet
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode, DataSetIF* dataSet = nullptr);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
 
 	virtual~ LocalPoolVar() {};
 
@@ -63,33 +70,91 @@ public:
 	 */
 	T value = 0;
 
-	ReturnValue_t commit() override;
-	ReturnValue_t read() override;
 	pool_rwm_t getReadWriteMode() const override;
-	uint32_t getDataPoolId() const override;
+
+	lp_id_t getDataPoolId() const override;
+	void setDataPoolId(lp_id_t poolId);
+
 	bool isValid() const override;
-	void setValid(uint8_t validity) override;
+	void setValid(bool validity) override;
+	uint8_t getValid() const;
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t max_size, bool bigEndian) const override;
+			const size_t max_size, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				bool bigEndian) override;
+			bool bigEndian) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 *
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	// std::ostream is the type for object std::cout
+//	friend std::ostream& operator<< (std::ostream &out,
+//			const LocalPoolVar &var) {
+//		out << static_cast<int>(value);
+//		return out;
+//	}
+
 private:
-	lp_id_t localPoolId = INVALID_POOL_ID;
+	//! @brief 	Pool ID of pool entry inside the used local pool.
+	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
+	//! @brief 	Read-write mode of the pool variable
 	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	//! @brief 	Specifies whether the entry is valid or invalid.
 	bool valid = false;
 
-	bool objectValid = true;
 	//! Pointer to the class which manages the HK pool.
 	HousekeepingManager* hkManager;
 };
 
 #include <framework/datapoollocal/LocalPoolVariable.tpp>
-template<class T>
-using lp_variable = LocalPoolVar<T>;
 
-using lp_bool_t = LocalPoolVar<bool>;
+template<class T>
+using lp_var_t = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<uint8_t>;
 using lp_uint8_t = LocalPoolVar<uint8_t>;
 using lp_uint16_t = LocalPoolVar<uint16_t>;
 using lp_uint32_t = LocalPoolVar<uint32_t>;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 4bc4c662..b7a0e837 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,16 +1,24 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/serialize/SerializeAdapter.h>
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
+#endif
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner is a nullptr!"
+				<< std::endl;
+		return;
+	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
 		dataSet->registerVariable(this);
@@ -21,12 +29,15 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
 		readWriteMode(readWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
 	HasHkPoolParametersIF* hkOwner =
 			objectManager->get<HasHkPoolParametersIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
-		objectValid = false;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
@@ -36,38 +47,59 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read() {
+inline ReturnValue_t LocalPoolVar<T>::read(millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return readWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
-		// TODO: special return value
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
-	if(result != RETURN_OK) {
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK and poolEntry != nullptr) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
 	this->value = *(poolEntry->address);
+	this->valid = poolEntry->valid;
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit() {
+inline ReturnValue_t LocalPoolVar<T>::commit(millis_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
-		// TODO: special return value
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::NO_TIMEOUT);
+	// Wait maximum of 50 milliseconds.
+	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, poolEntry);
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
 	*(poolEntry->address) = this->value;
+	poolEntry->valid = this->valid;
 	return RETURN_OK;
 }
 
@@ -81,16 +113,26 @@ inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
 	return localPoolId;
 }
 
+template<typename T>
+inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
+	this->localPoolId = poolId;
+}
+
 template<typename T>
 inline bool LocalPoolVar<T>::isValid() const {
 	return valid;
 }
 
 template<typename T>
-inline void LocalPoolVar<T>::setValid(uint8_t validity) {
+inline void LocalPoolVar<T>::setValid(bool validity) {
 	this->valid = validity;
 }
 
+template<typename T>
+inline uint8_t LocalPoolVar<T>::getValid() const {
+	return valid;
+}
+
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, bool bigEndian) const {
@@ -109,4 +151,11 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
 
+//template<typename T>
+//inline friend std::ostream& LocalPoolVar<T>::operator<< (std::ostream &out,
+//		const LocalPoolVar &var) {
+//	out << static_cast<int>(out);
+//}
+
+
 #endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
new file mode 100644
index 00000000..02c47113
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.h
@@ -0,0 +1,189 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolEntry.h>
+#include <framework/datapool/PoolVariableIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T &operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	HousekeepingManager* hkManager;
+};
+
+#include <framework/datapoollocal/LocalPoolVector.tpp>
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
new file mode 100644
index 00000000..78637eff
--- /dev/null
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -0,0 +1,185 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#error Include LocalPoolVector.h before LocalPoolVector.tpp!
+#endif
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		DataSetIF* dataSet) :
+		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	memset(this->value, 0, vectorSize * sizeof(T));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
+		object_id_t poolOwner, pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		readWriteMode(readWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
+		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
+				"NO_PARAMETER value!" << std::endl;
+	}
+	HasHkPoolParametersIF* hkOwner =
+			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	if(hkOwner == nullptr) {
+		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
+				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return readWithoutLock();
+}
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for read() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	memset(this->value, 0, vectorSize * sizeof(T));
+
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
+				std::dec << " failed." << std::endl;
+		return result;
+	}
+	memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
+	this->valid = poolEntry->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+		uint32_t lockTimeout) {
+	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	return commitWithoutLock();
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
+	if(readWriteMode == pool_rwm_t::VAR_READ) {
+		sif::debug << "LocalPoolVar: Invalid read write "
+				"mode for commit() call." << std::endl;
+		return PoolVariableIF::INVALID_READ_WRITE_MODE;
+	}
+	// Wait maximum of 50 milliseconds.
+	MutexHelper(hkManager->getMutexHandle(), 50);
+	PoolEntry<T>* poolEntry = nullptr;
+	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		sif::error << "PoolVector: Read of local pool variable of object "
+				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
+				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
+				std::dec << " failed.\n" << std::flush;
+		return result;
+	}
+	memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
+	poolEntry->valid = this->valid;
+	return RETURN_OK;
+}
+
+template<typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
+	return 0;
+}
+
+template<typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
+	if(i <= vectorSize) {
+		return value[i];
+	}
+	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
+	return 0;
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
+				max_size, bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
+	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+}
+
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
+		const uint8_t** buffer, size_t* size, bool bigEndian) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	for (uint16_t i = 0; i < vectorSize; i++) {
+		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
+				bigEndian);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+	}
+	return result;
+}
+
+template<typename T, uint16_t vectorSize>
+inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
+	return this->readWriteMode;
+}
+
+
+template<typename T, uint16_t vectorSize>
+inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
+	return localPoolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
+	this->localPoolId = poolId;
+}
+
+template<typename T, uint16_t vectorSize>
+inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
+	this->valid = valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
+	return valid;
+}
+
+template<typename T, uint16_t vectorSize>
+inline bool LocalPoolVector<T, vectorSize>::isValid() const {
+	return valid;
+}
+
+#endif

From 9ec2283d1397b5699796517cc47e3f82e327757a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:35:08 +0200
Subject: [PATCH 0381/1292] hk folder update

---
 housekeeping/HasHkPoolParametersIF.h | 23 ++++++++-
 housekeeping/HousekeepingManager.cpp | 46 ++++++++++++++---
 housekeeping/HousekeepingManager.h   | 77 +++++++++++++++++-----------
 housekeeping/HousekeepingMessage.cpp | 12 ++---
 housekeeping/HousekeepingMessage.h   | 15 ++----
 5 files changed, 119 insertions(+), 54 deletions(-)

diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index ac248cf3..62715a3d 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -2,9 +2,11 @@
 #define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
 #include <framework/datapool/PoolEntryIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
 #include <map>
 
 class HousekeepingManager;
+class DataSetIF;
 /**
  * @brief	Type definition for local pool entries.
  */
@@ -13,17 +15,34 @@ using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
 
 /**
- * @brief
+ * @brief 		This interface is implemented by classes which posses a local
+ * 				data pool (not the managing class)
+ * @details
+ * Any class implementing this interface shall also have a HousekeepingManager
+ * member class which handles the retrieval of the local pool data.
+ * This is required because the pool entries are templates, which makes
+ * specifying an interface rather difficult.
+ *
+ * This could be circumvented by using a wrapper/accessor function, but
+ * the LocalPoolVariable classes are templates as well, so this just shifts
+ * the problem somewhere else. Interfaces are nice, but the most
+ * pragmatic solution I found was to offer the client the full interface
+ * of the housekeeping manager.
  */
 class HasHkPoolParametersIF {
 public:
 	virtual~ HasHkPoolParametersIF() {};
 
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
+	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
+	static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0xA1);
+
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
-	virtual float setMinimalHkSamplingFrequency() = 0;
+	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
+	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
 
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/housekeeping/HousekeepingManager.cpp b/housekeeping/HousekeepingManager.cpp
index 05df0ffc..e8edcc39 100644
--- a/housekeeping/HousekeepingManager.cpp
+++ b/housekeeping/HousekeepingManager.cpp
@@ -1,17 +1,19 @@
+#include <framework/datapoollocal/LocalDataSet.h>
 #include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
+#include <array>
+
 HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
-	//todo :: nullptr check owner.
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
 		std::exit(0);
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
-	owner->setMinimalHkSamplingFrequency();
+	//owner->setMinimalHkSamplingFrequency();
 }
 
 HousekeepingManager::~HousekeepingManager() {}
@@ -24,7 +26,7 @@ ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
 		}
 		return result;
 	}
-	sif::warning << "hk manager says no" << std::endl;
+	sif::warning << "HousekeepingManager: The map" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -33,18 +35,48 @@ ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t HousekeepingManager::printPoolEntry(
+		lp_id_t localPoolId) {
+	auto poolIter = localDpMap.find(localPoolId);
+	if (poolIter == localDpMap.end()) {
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 MutexIF* HousekeepingManager::getMutexHandle() {
 	return mutex;
 }
 
-void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
-	this->samplingFrequency = frequencySeconds;
+//void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
+//	this->samplingFrequency = frequencySeconds;
+//
+//}
 
-}
+void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
+	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+			owner->getDataSetHandle(sid));
+	if(dataSetToSerialize == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return;
+	}
+	std::array<uint8_t, 256> testBuffer = {};
+	uint8_t* dataPtr = testBuffer.data();
+	size_t size = 0;
+	dataSetToSerialize->serialize(&dataPtr, &size, testBuffer.size(),
+			false);
+	// and now we send it to the TM funnel or somewhere else
 
-void HousekeepingManager::generateHousekeepingPacket(DataSetIF *dataSet) {
 }
 
 void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
+
+const HasHkPoolParametersIF* HousekeepingManager::getOwner() const {
+	return owner;
+}
diff --git a/housekeeping/HousekeepingManager.h b/housekeeping/HousekeepingManager.h
index feec69fc..43922ae6 100644
--- a/housekeeping/HousekeepingManager.h
+++ b/housekeeping/HousekeepingManager.h
@@ -5,6 +5,7 @@
 #include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/ipc/MutexIF.h>
 
+#include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
@@ -14,47 +15,36 @@
 
 
 class HousekeepingManager {
+	template<typename T>
+	friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize>
+	friend class LocalPoolVector;
+	friend class LocalDataSet;
 public:
 	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
 	HousekeepingManager(HasHkPoolParametersIF* owner);
 	virtual~ HousekeepingManager();
 
-	MutexIF* getMutexHandle();
 
 	// propably will just call respective local data set functions.
-	void generateHousekeepingPacket(DataSetIF* dataSet);
+	void generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T>
-	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> *poolEntry);
-	void setMinimalSamplingFrequency(float frequencySeconds);
-
 	/**
 	 * This function is used to fill the local data pool map with pool
-	 * entries. The default implementation is empty.
+	 * entries. It should only be called once by the pool owner.
 	 * @param localDataPoolMap
 	 * @return
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
-private:
-	//! this depends on the PST frequency.. maybe it would be better to just
-	//! set this manually with a global configuration value which is also
-	//! passed to the PST. Or force setting this in device handler.
-	float samplingFrequency = MINIMAL_SAMPLING_FREQUENCY;
+	const HasHkPoolParametersIF* getOwner() const;
 
+	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
@@ -72,24 +62,53 @@ private:
 	//! message..)
 	MessageQueueIF* hkReplyQueue = nullptr;
 	//! Used for HK packets, which are generated without requests.
+	//! Maybe this will just be the TM funnel.
 	MessageQueueIF* hkPacketQueue = nullptr;
+
+	/**
+	 * Get the pointer to the mutex. Can be used to lock the data pool
+	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * For now, only friend classes can accss this function.
+	 * @return
+	 */
+	MutexIF* getMutexHandle();
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * For now, only friend classes like LocalPoolVar may access this
+	 * function.
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T>
+	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
+	void setMinimalSamplingFrequency(float frequencySeconds);
+
 };
 
 template<class T> inline
 ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> *poolEntry) {
+		PoolEntry<T> **poolEntry) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
-		// todo: special returnvalue.
-		return HasReturnvaluesIF::RETURN_FAILED;
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
 	}
 
-	poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(poolEntry == nullptr) {
-		// todo: special returnvalue.
-		return HasReturnvaluesIF::RETURN_FAILED;
+	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(*poolEntry == nullptr) {
+		sif::debug << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return HasHkPoolParametersIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
 #endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 65d87e9e..b0109e5d 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,10 +1,10 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
-void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
-		set_t setId, store_address_t packet) {
-	message->setCommand(ADD_HK_REPORT_STRUCT);
-	message->setParameter(setId);
-	message->setParameter2(packet.raw);
-}
+//void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
+//		set_t setId, store_address_t packet) {
+//	message->setCommand(ADD_HK_REPORT_STRUCT);
+//	message->setParameter(setId);
+//	message->setParameter2(packet.raw);
+//}
 
 //void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 80dc83a6..e7ba68ba 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -4,20 +4,15 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <limits>
 
-/**
- * the sid consists of the target object ID and... something else I forgot.
- * Propably a special HK id to distinguish multiple hk pool packages
- * inside a handler or controller
- */
-typedef uint32_t set_t;
-
 union sid_t {
 	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
 	struct {
 		object_id_t objectId ;
-		set_t hkId;
+		// A generic 32 bit ID to identify unique HK packets for a single object.
+		// For example, the DeviceCommandId_t is used for DeviceHandlers
+		uint32_t ownerSetId;
 	};
 	/**
 	 * Alternative access to the raw value.
@@ -79,8 +74,8 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	static void setAddHkReportStructMessage(CommandMessage* message,
-			set_t setId, store_address_t packet);
+//	static void setAddHkReportStructMessage(CommandMessage* message,
+//			DevisetId, store_address_t packet);
 };
 
 

From 7247a1af7efde551f6e7d619e66917d9d4717562 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:36:25 +0200
Subject: [PATCH 0382/1292] new class ids

---
 returnvalues/FwClassIds.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 120d8b8c..870efb46 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -55,12 +55,14 @@ enum {
 	HAS_ACTIONS_IF, //HF
 	DEVICE_COMMUNICATION_IF, //DC
 	BSP, //BSP
-	TIME_STAMPER_IF, //TSI 52
+	TIME_STAMPER_IF, //TSI 53
 	//TODO This will shift all IDs for FLP
-	SGP4PROPAGATOR_CLASS, //SGP4 53
-	MUTEX_IF, //MUX 54
-	MESSAGE_QUEUE_IF,//MQI 55
-	SEMAPHORE_IF, //SPH 56
+	SGP4PROPAGATOR_CLASS, //SGP4 54
+	MUTEX_IF, //MUX 55
+	MESSAGE_QUEUE_IF,//MQI 56
+	SEMAPHORE_IF, //SPH 57
+	HOUSEKEEPING, //HK 58
+	POOL_VARIABLE_IF, //PVA 59
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 0d4d4123ab28a10376c8ba6c6cc7bd3be5c54e74 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:37:46 +0200
Subject: [PATCH 0383/1292] added new message  type (hk)

---
 ipc/FwMessageTypes.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index b59319aa..7daf8767 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -15,6 +15,7 @@ enum FW_MESSAGE_TYPE {
 	MEMORY,
 	PARAMETER,
 	FILE_SYSTEM_MESSAGE,
+	HOUSEKEEPING,
 	FW_MESSAGES_COUNT,
 
 };

From e9a9a543ce3fbf8a9ff57e337513e050e6004c8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:38:59 +0200
Subject: [PATCH 0384/1292] fw message count one line further

---
 ipc/FwMessageTypes.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 7daf8767..1665747e 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -16,8 +16,8 @@ enum FW_MESSAGE_TYPE {
 	PARAMETER,
 	FILE_SYSTEM_MESSAGE,
 	HOUSEKEEPING,
-	FW_MESSAGES_COUNT,
 
+	FW_MESSAGES_COUNT,
 };
 }
 

From 2b646551e96882aac5c62232b9c88a0271209440 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 20:40:22 +0200
Subject: [PATCH 0385/1292] mutex helper new output error

---
 ipc/MutexHelper.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 671cd5a6..20760b32 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -9,8 +9,12 @@ public:
 	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
-		if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed " <<
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of"
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
 					status << std::endl;
 		}
 	}

From 579115f904e5287ad0bd8d15038b6d707a72523f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 21:36:50 +0200
Subject: [PATCH 0386/1292] adapting host osal

---
 osal/host/Clock.cpp            |  4 ++--
 osal/host/Mutex.cpp            | 10 +++++-----
 osal/host/Mutex.h              |  2 +-
 osal/host/QueueFactory.cpp     |  2 +-
 osal/host/SemaphoreFactory.cpp |  4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 78bbc58a..57f2572b 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -186,7 +186,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -201,7 +201,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 0e6e652d..03948c4c 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,22 +1,22 @@
 #include <framework/osal/host/Mutex.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-const uint32_t MutexIF::MAX_TIMEOUT = 0xffffffff;
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
 
 ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
+	if(timeoutMs == MutexIF::BLOCKING) {
 		mutex.lock();
 		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutMs == MutexIF::NO_TIMEOUT) {
+	else if(timeoutMs == MutexIF::POLLING) {
 		if(mutex.try_lock()) {
 			locked = true;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+	else if(timeoutMs > MutexIF::POLLING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			locked = true;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index dce2a9dc..d882c457 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -16,7 +16,7 @@
 class Mutex : public MutexIF {
 public:
 	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
 
 	std::timed_mutex* getMutexHandle();
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 691249c3..60274c84 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -27,7 +27,7 @@ QueueFactory::QueueFactory() {
 QueueFactory::~QueueFactory() {
 }
 
-MessageQueueIF* QueueFactory::createMessageQueue(size_t messageDepth,
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
 		size_t maxMessageSize) {
 	// A thread-safe queue can be implemented  by using a combination
 	// of std::queue and std::mutex. This uses dynamic memory allocation
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 3719a883..8712d866 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -3,8 +3,8 @@
 #include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

From d74f2c7560452a9b82ddfa4020335b73d971b8a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 21:40:06 +0200
Subject: [PATCH 0387/1292] housekeeping folder added to .mk file

---
 framework.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework.mk b/framework.mk
index 2092c2fe..404055ee 100644
--- a/framework.mk
+++ b/framework.mk
@@ -10,11 +10,11 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/fdir/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/framework.mk/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/matching/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/math/*.cpp)

From 87f64d99cd1b7eae59b601140d13a5b92565f384 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 5 Jun 2020 23:18:00 +0200
Subject: [PATCH 0388/1292] implemented fixed timeslot task

---
 osal/host/FixedTimeslotTask.cpp | 191 ++++++++++++++++++++++++++++++++
 osal/host/FixedTimeslotTask.h   | 130 ++++++++++++++++++++++
 osal/host/PeriodicTask.cpp      |   6 +-
 osal/host/PeriodicTask.h        |   5 +-
 osal/host/TaskFactory.cpp       |   6 +-
 5 files changed, 330 insertions(+), 8 deletions(-)
 create mode 100644 osal/host/FixedTimeslotTask.cpp
 create mode 100644 osal/host/FixedTimeslotTask.h

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
new file mode 100644
index 00000000..48d11843
--- /dev/null
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -0,0 +1,191 @@
+#include <framework/osal/host/FixedTimeslotTask.h>
+
+#include <framework/ipc/MutexFactory.h>
+#include <framework/osal/host/Mutex.h>
+#include <framework/osal/host/FixedTimeslotTask.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+        TaskStackSize setStack, TaskPeriod setPeriod,
+        void (*setDeadlineMissedFunc)()) :
+        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
+        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+FixedTimeslotTask::~FixedTimeslotTask(void) {
+    //Do not delete objects, we were responsible for ptrs only.
+    terminateThread = true;
+    if(mainThread.joinable()) {
+        mainThread.join();
+    }
+    delete this;
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+
+    if (not originalTask->started) {
+        // we have to suspend/block here until the task is started.
+        // if semaphores are implemented, use them here.
+        std::unique_lock<std::mutex> lock(initMutex);
+        initCondition.wait(lock);
+    }
+
+    this->taskFunctionality();
+    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
+            "Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+    started = true;
+
+    // Notify task to start.
+    std::lock_guard<std::mutex> lock(initMutex);
+    initCondition.notify_one();
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    SlotListIter slotListIter = pollingSeqTable.current;
+    // Get start time for first entry.
+    chron_ms interval(slotListIter->pollingTimeMs);
+    auto currentStartTime {
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch())
+    };
+    if(interval.count() > 0) {
+        delayForInterval(&currentStartTime, interval);
+    }
+
+    /* Enter the loop that defines the task behavior. */
+    for (;;) {
+        if(terminateThread.load()) {
+            break;
+        }
+        //The component for this slot is executed and the next one is chosen.
+        this->pollingSeqTable.executeAndAdvance();
+        if (not pollingSeqTable.slotFollowsImmediately()) {
+            // we need to wait before executing the current slot
+            //this gives us the time to wait:
+            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
+            delayForInterval(&currentStartTime, interval);
+            //TODO deadline missed check
+        }
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+        uint32_t slotTimeMs, int8_t executionStep) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+    return pollingSeqTable.checkSequence();
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+    return period * 1000;
+}
+
+bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<chron_ms>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
new file mode 100644
index 00000000..bb2f757a
--- /dev/null
+++ b/osal/host/FixedTimeslotTask.h
@@ -0,0 +1,130 @@
+#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedTimeslotTaskIF.h>
+#include <framework/tasks/Typedef.h>
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief   This class represents a task for periodic activities with multiple
+ *          steps and strict timeslot requirements for these steps.
+ * @details
+ * @ingroup task_handling
+ */
+class FixedTimeslotTask: public FixedTimeslotTaskIF {
+public:
+    /**
+     * @brief   Standard constructor of the class.
+     * @details
+     * The class is initialized without allocated objects. These need to be
+     * added with #addComponent.
+     * @param priority
+     * @param stack_size
+     * @param setPeriod
+     * @param setDeadlineMissedFunc
+     * The function pointer to the deadline missed function that shall be
+     * assigned.
+     */
+    FixedTimeslotTask(const char *name, TaskPriority setPriority,
+            TaskStackSize setStack, TaskPeriod setPeriod,
+            void (*setDeadlineMissedFunc)());
+    /**
+     * @brief   Currently, the executed object's lifetime is not coupled with
+     *          the task object's lifetime, so the destructor is empty.
+     */
+    virtual ~FixedTimeslotTask(void);
+
+    /**
+     * @brief   The method to start the task.
+     * @details The method starts the task with the respective system call.
+     *          Entry point is the taskEntryPoint method described below.
+     *          The address of the task object is passed as an argument
+     *          to the system call.
+     */
+    ReturnValue_t startTask(void);
+
+    /**
+     * Add timeslot to the polling sequence table.
+     * @param componentId
+     * @param slotTimeMs
+     * @param executionStep
+     * @return
+     */
+    ReturnValue_t addSlot(object_id_t componentId,
+                   uint32_t slotTimeMs, int8_t executionStep);
+
+    ReturnValue_t checkSequence() const;
+
+    uint32_t getPeriodMs() const;
+
+    ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+    using chron_ms = std::chrono::milliseconds;
+
+    bool started;
+    //!< Typedef for the List of objects.
+    typedef std::vector<ExecutableObjectIF*> ObjectList;
+    std::thread mainThread;
+    std::atomic<bool> terminateThread = false;
+
+    //! Polling sequence table which contains the object to execute
+    //! and information like the timeslots and the passed execution step.
+    FixedSlotSequence pollingSeqTable;
+
+    std::condition_variable initCondition;
+    std::mutex initMutex;
+    std::string taskName;
+    /**
+     * @brief   The period of the task.
+     * @details
+     * The period determines the frequency of the task's execution.
+     * It is expressed in clock ticks.
+     */
+    TaskPeriod period;
+
+    /**
+     * @brief   The pointer to the deadline-missed function.
+     * @details
+     * This pointer stores the function that is executed if the task's deadline
+     * is missed. So, each may react individually on a timing failure.
+     * The pointer may be NULL, then nothing happens on missing the deadline.
+     * The deadline is equal to the next execution of the periodic task.
+     */
+    void (*deadlineMissedFunc)(void);
+    /**
+     * @brief   This is the function executed in the new task's context.
+     * @details
+     * It converts the argument back to the thread object type and copies the
+     * class instance to the task context.
+     * The taskFunctionality method is called afterwards.
+     * @param   A pointer to the task object itself is passed as argument.
+     */
+
+    void taskEntryPoint(void* argument);
+    /**
+     * @brief   The function containing the actual functionality of the task.
+     * @details
+     * The method sets and starts the task's period, then enters a loop that is
+     * repeated as long as the isRunning attribute is true. Within the loop,
+     * all performOperation methods of the added objects are called. Afterwards
+     * the checkAndRestartPeriod system call blocks the task until the next
+     *  period. On missing the deadline, the deadlineMissedFunction is executed.
+     */
+    void taskFunctionality(void);
+
+    bool delayForInterval(chron_ms * previousWakeTimeMs,
+            const chron_ms interval);
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 57898ac2..1a5024ab 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -105,7 +105,7 @@ void PeriodicTask::taskFunctionality() {
 				it != objectList.end(); ++it) {
 			(*it)->performOperation();
 		}
-		if(not delayUntil(&currentStartTime, periodChrono)) {
+		if(not delayForInterval(&currentStartTime, periodChrono)) {
 			sif::warning << "PeriodicTask: " << taskName <<
 					" missed deadline!\n" << std::flush;
 			if(deadlineMissedFunc != nullptr) {
@@ -129,8 +129,8 @@ uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
 
-bool PeriodicTask::delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
-        const std::chrono::milliseconds interval) {
+bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
+        const chron_ms interval) {
     bool shouldDelay = false;
     //Get current wakeup time
     auto currentStartTime =
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 19c06b52..d97bf089 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -64,6 +64,7 @@ public:
 	ReturnValue_t sleepFor(uint32_t ms);
 
 protected:
+	using chron_ms = std::chrono::milliseconds;
 	bool started;
 	//!< Typedef for the List of objects.
 	typedef std::vector<ExecutableObjectIF*> ObjectList;
@@ -115,8 +116,8 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	bool delayUntil(std::chrono::milliseconds * previousWakeTimeMs,
-	        const std::chrono::milliseconds interval);
+	bool delayForInterval(chron_ms * previousWakeTimeMs,
+	        const chron_ms interval);
 };
 
 #endif /* PERIODICTASK_H_ */
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index a13844c4..9db8ac4d 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,3 +1,4 @@
+#include <framework/osal/host/FixedTimeslotTask.h>
 #include <framework/osal/host/PeriodicTask.h>
 #include <framework/tasks/TaskFactory.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -36,9 +37,8 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
 	// This is going to be interesting. Time now learn the C++ threading library
 	// :-)
-	sif::warning << "TaskFactory::createFixedTimeslotTask: Not implemented "
-			"yet" << std::endl;
-	return nullptr;
+	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
+	        periodInSeconds_, deadLineMissedFunction_);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From d600d488167c891407e27b3d3f545d02e319fb2e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 01:31:08 +0200
Subject: [PATCH 0389/1292] added the decoupling of DHB from powerSwitcher

+ some first hk maanger changes, might comment them out
---
 devicehandlers/DeviceHandlerBase.cpp          | 232 +++++++++++-------
 devicehandlers/DeviceHandlerBase.h            | 215 ++++++++--------
 .../DeviceHandlerFailureIsolation.cpp         |  34 +--
 .../DeviceHandlerFailureIsolation.h           |   1 +
 4 files changed, 273 insertions(+), 209 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 02c94129..1e3bb16e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -14,7 +14,7 @@
 
 #include <iomanip>
 
-object_id_t DeviceHandlerBase::powerSwitcherId = 0;
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
@@ -26,12 +26,13 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		actionHelper(this, nullptr), hkManager(this),
 		deviceThermalStatePoolId(thermalStatePoolId),
 		deviceThermalRequestPoolId(thermalRequestPoolId),
-		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), actionHelper(this, nullptr), cookieInfo(),
+		switchOffWasReported(false), cookieInfo(),
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
@@ -52,7 +53,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
-	//communicationInterface->close(cookie);
+	delete comCookie;
 	if (defaultFDIRUsed) {
 		delete fdirInstance;
 	}
@@ -129,9 +130,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	defaultRawReceiver = rawReceiver->getDeviceQueue();
 
-	powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-	if (powerSwitcher == NULL) {
-		return RETURN_FAILED;
+	if(powerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+		if (powerSwitcher == NULL) {
+			return RETURN_FAILED;
+		}
 	}
 
 	result = healthHelper.initialize();
@@ -162,6 +165,11 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	result = hkManager.initializeHousekeepingPoolEntriesOnce();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
@@ -271,7 +279,8 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_ON: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
-		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
+		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
+				powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
 			setMode(_MODE_POWER_DOWN);
@@ -341,9 +350,10 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic,
-		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
+		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
+		size_t replyLen, bool periodic, bool hasDifferentReplyId,
+		DeviceCommandId_t replyId) {
 	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
@@ -354,7 +364,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(DeviceCommandId_t de
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, uint8_t periodic) {
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
@@ -369,7 +379,8 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
 	}
 }
 
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) {
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(
+		DeviceCommandId_t deviceCommand) {
 	DeviceCommandInfo info;
 	info.expectedReplies = 0;
 	info.isExecuting = false;
@@ -383,7 +394,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
 }
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		uint16_t delayCycles, uint16_t maxDelayCycles, uint8_t periodic) {
+		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
 	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
 			deviceReplyMap.find(deviceReply);
 	if (iter == deviceReplyMap.end()) {
@@ -576,11 +587,8 @@ void DeviceHandlerBase::doSendRead() {
 }
 
 void DeviceHandlerBase::doGetRead() {
-	size_t receivedDataLen;
-	uint8_t *receivedData;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	size_t foundLen = 0;
-	ReturnValue_t result;
+	size_t receivedDataLen = 0;
+	uint8_t *receivedData = nullptr;
 
 	if (cookieInfo.state != COOKIE_READ_SENT) {
 		cookieInfo.state = COOKIE_UNUSED;
@@ -589,8 +597,8 @@ void DeviceHandlerBase::doGetRead() {
 
 	cookieInfo.state = COOKIE_UNUSED;
 
-	result = communicationInterface->readReceivedMessage(comCookie,
-			&receivedData, &receivedDataLen);
+	ReturnValue_t result = communicationInterface->readReceivedMessage(
+			comCookie, &receivedData, &receivedDataLen);
 
 	if (result != RETURN_OK) {
 		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
@@ -608,44 +616,90 @@ void DeviceHandlerBase::doGetRead() {
 
 	if (mode == MODE_RAW) {
 		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-	} else {
-		//The loop may not execute more often than the number of received bytes (worst case).
-		//This approach avoids infinite loops due to buggy scanForReply routines (seen in bug 1077).
-		uint32_t remainingLength = receivedDataLen;
-		for (uint32_t count = 0; count < receivedDataLen; count++) {
-			result = scanForReply(receivedData, remainingLength, &foundId,
-					&foundLen);
-			switch (result) {
-			case RETURN_OK:
-				handleReply(receivedData, foundId, foundLen);
-				break;
-			case APERIODIC_REPLY: {
-				result = interpretDeviceReply(foundId, receivedData);
-				if (result != RETURN_OK) {
-					replyRawReplyIfnotWiretapped(receivedData, foundLen);
-					triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-							foundId);
-				}
-			}
-				break;
-			case IGNORE_REPLY_DATA:
-				break;
-			case IGNORE_FULL_PACKET:
-				return;
-			default:
-				//We need to wait for timeout.. don't know what command failed and who sent it.
+	}
+	else {
+		parseReply(receivedData, receivedDataLen);
+	}
+}
+
+void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
+		size_t receivedDataLen) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	size_t foundLen = 0;
+	// The loop may not execute more often than the number of received bytes
+	// (worst case). This approach avoids infinite loops due to buggy
+	// scanForReply routines.
+	uint32_t remainingLength = receivedDataLen;
+	for (uint32_t count = 0; count < receivedDataLen; count++) {
+		result = scanForReply(receivedData, remainingLength, &foundId,
+				&foundLen);
+		switch (result) {
+		case RETURN_OK:
+			handleReply(receivedData, foundId, foundLen);
+			break;
+		case APERIODIC_REPLY: {
+			result = interpretDeviceReply(foundId, receivedData);
+			if (result != RETURN_OK) {
 				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
-				break;
-			}
-			receivedData += foundLen;
-			if (remainingLength > foundLen) {
-				remainingLength -= foundLen;
-			} else {
-				return;
+				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+						foundId);
 			}
 		}
+		break;
+		case IGNORE_REPLY_DATA:
+			break;
+		case IGNORE_FULL_PACKET:
+			return;
+		default:
+			//We need to wait for timeout.. don't know what command failed and who sent it.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
+			break;
+		}
+		receivedData += foundLen;
+		if (remainingLength > foundLen) {
+			remainingLength -= foundLen;
+		} else {
+			return;
+		}
+	}
+}
 
+void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
+		DeviceCommandId_t foundId, uint32_t foundLen) {
+	ReturnValue_t result;
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
+
+	if (iter == deviceReplyMap.end()) {
+		replyRawReplyIfnotWiretapped(receivedData, foundLen);
+		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
+		return;
+	}
+
+	DeviceReplyInfo *info = &(iter->second);
+
+	if (info->delayCycles != 0) {
+
+		if (info->periodic != 0) {
+			info->delayCycles = info->maxDelayCycles;
+		} else {
+			info->delayCycles = 0;
+		}
+		result = interpretDeviceReply(foundId, receivedData);
+		if (result != RETURN_OK) {
+			// Report failed interpretation to FDIR.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
+		}
+		replyToReply(iter, result);
+	} else {
+		// Other completion failure messages are created by timeout.
+		// Powering down the device might take some time during which periodic
+		// replies may still come in.
+		if (mode != _MODE_WAIT_OFF) {
+			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
+		}
 	}
 }
 
@@ -724,42 +778,6 @@ MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
 	return commandQueue->getId();
 }
 
-void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
-		DeviceCommandId_t foundId, uint32_t foundLen) {
-	ReturnValue_t result;
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
-
-	if (iter == deviceReplyMap.end()) {
-		replyRawReplyIfnotWiretapped(receivedData, foundLen);
-		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
-		return;
-	}
-
-	DeviceReplyInfo *info = &(iter->second);
-
-	if (info->delayCycles != 0) {
-
-		if (info->periodic != 0) {
-			info->delayCycles = info->maxDelayCycles;
-		} else {
-			info->delayCycles = 0;
-		}
-		result = interpretDeviceReply(foundId, receivedData);
-		if (result != RETURN_OK) {
-			//Report failed interpretation to FDIR.
-			replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
-		}
-		replyToReply(iter, result);
-	} else {
-		//Other completion failure messages are created by timeout.
-		//Powering down the device might take some time during which periodic replies may still come in.
-		if (mode != _MODE_WAIT_OFF) {
-			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
-		}
-	}
-}
-
 //ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
 //	DeviceCommunicationIF *newCommunication = objectManager->get<
 //			DeviceCommunicationIF>(newChannelId);
@@ -791,6 +809,9 @@ void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 }
 
 void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
+	if(powerSwitcher == nullptr) {
+		return;
+	}
 	const uint8_t *switches;
 	uint8_t numberOfSwitches = 0;
 	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
@@ -805,9 +826,7 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
 
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
 		uint8_t *numberOfSwitches) {
-	*switches = &deviceSwitch;
-	*numberOfSwitches = 1;
-	return RETURN_OK;
+	return DeviceHandlerBase::NO_SWITCH;
 }
 
 void DeviceHandlerBase::modeChanged(void) {
@@ -843,6 +862,9 @@ uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
+	if(powerSwitcher == nullptr) {
+		return NO_SWITCH;
+	}
 	uint8_t numberOfSwitches = 0;
 	const uint8_t *switches;
 
@@ -1286,4 +1308,24 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 		object_id_t objectId, uint32_t parameter) {}
 
-void DeviceHandlerBase::performOperationHook() {}
+void DeviceHandlerBase::performOperationHook() {
+}
+
+ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
+		LocalDataPoolMap &localDataPoolMap) {
+	return RETURN_OK;
+}
+
+HousekeepingManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 1debcdcb..47cf0284 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,5 +1,5 @@
-#ifndef DEVICEHANDLERBASE_H_
-#define DEVICEHANDLERBASE_H_
+#ifndef DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define DEVICEHANDLERS_DEVICEHANDLERBASE_H_
 
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
@@ -11,12 +11,14 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/housekeeping/HasHkPoolParametersIF.h>
 
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 
 #include <map>
 
@@ -46,14 +48,16 @@ class StorageManagerIF;
  * If data has been received (GET_READ), the data will be interpreted.
  * The action for each step can be defined by the child class but as most
  * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
- * a default implementation is provided. NOTE: RMAP is a standard which is used for FLP.
+ * a default implementation is provided.
+ * NOTE: RMAP is a standard which is used for FLP.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are
  * two write and two send calls involved.
  *
- * Device handler instances should extend this class and implement the abstract functions.
- * Components and drivers can send so called cookies which are used for communication
- * and contain information about the communcation (e.g. slave address for I2C or RMAP structs).
+ * Device handler instances should extend this class and implement the abstract
+ * functions. Components and drivers can send so called cookies which are used
+ * for communication and contain information about the communcation (e.g. slave
+ * address for I2C or RMAP structs).
  * The following abstract methods must be implemented by a device handler:
  *  1. doStartUp()
  *  2. doShutDown()
@@ -82,7 +86,8 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasModesIF,
 		public HasHealthIF,
 		public HasActionsIF,
-		public ReceivesParameterMessagesIF {
+		public ReceivesParameterMessagesIF,
+		public HasHkPoolParametersIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -150,11 +155,9 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
-
-	/**
-	 * Destructor.
-	 */
+	/** Destructor. */
 	virtual ~DeviceHandlerBase();
+
 protected:
 	/**
 	 * @brief 	This is used to let the child class handle the transition from
@@ -322,12 +325,11 @@ protected:
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */
-
 	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
 			const uint8_t *packet) = 0;
 
 	/**
-	 * @brief fill the #deviceCommandMap
+	 * @brief fill the #DeviceCommandMap and #DeviceReplyMap
 	 *	 	  called by the initialize() of the base class
 	 * @details
 	 * This is used to let the base class know which replies are expected.
@@ -382,7 +384,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -396,7 +398,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, uint8_t periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -422,7 +424,7 @@ protected:
 	 */
 	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
 			uint16_t delayCycles, uint16_t maxDelayCycles,
-			uint8_t periodic = 0);
+			bool periodic = 0);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -471,6 +473,18 @@ protected:
 	virtual ReturnValue_t getSwitches(const uint8_t **switches,
 			uint8_t *numberOfSwitches);
 
+	/**
+	 * This function is used to initialize the local housekeeping pool
+	 * entries. The default implementation leaves the pool empty.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	virtual ReturnValue_t initializeHousekeepingPoolEntries(
+				LocalDataPoolMap& localDataPoolMap) override;
+
+	/** Get the HK manager object handle */
+	virtual HousekeepingManager* getHkManagerHandle() override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
@@ -528,114 +542,136 @@ protected:
 	static const DeviceCommandId_t NO_COMMAND_ID = -2;
 	static const MessageQueueId_t NO_COMMANDER = 0;
 
-	/**
-	 * Pointer to the raw packet that will be sent.
-	 */
+	/** Pointer to the raw packet that will be sent.*/
 	uint8_t *rawPacket = nullptr;
-	/**
-	 * Size of the #rawPacket.
-	 */
+	/** Size of the #rawPacket. */
 	uint32_t rawPacketLen = 0;
 
 	/**
 	 * The mode the device handler is currently in.
-	 *
 	 * This should never be changed directly but only with setMode()
 	 */
 	Mode_t mode;
-
 	/**
 	 * The submode the device handler is currently in.
-	 *
 	 * This should never be changed directly but only with setMode()
 	 */
 	Submode_t submode;
 
-	/**
-	 * This is the counter value from performOperation().
-	 */
+	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
-
 	/**
-	 * wiretapping flag:
+	 * Wiretapping flag:
 	 *
-	 * indicates either that all raw messages to and from the device should be sent to #theOneWhoWantsToReadRawTraffic
-	 * or that all device TM should be downlinked to #theOneWhoWantsToReadRawTraffic
+	 * indicates either that all raw messages to and from the device should be
+	 * sent to #defaultRawReceiver
+	 * or that all device TM should be downlinked to #defaultRawReceiver.
 	 */
 	enum WiretappingMode {
 		OFF = 0, RAW = 1, TM = 2
 	} wiretappingMode;
-
 	/**
-	 * A message queue that accepts raw replies
+	 * @brief 	A message queue that accepts raw replies
 	 *
-	 * Statically initialized in initialize() to a configurable object. Used when there is no method
-	 * of finding a recipient, ie raw mode and reporting erreonous replies
+	 * Statically initialized in initialize() to a configurable object.
+	 * Used when there is no method of finding a recipient, ie raw mode and
+	 * reporting erroneous replies
 	 */
 	MessageQueueId_t defaultRawReceiver = 0;
-
 	store_address_t storedRawData;
 
 	/**
-	 * the message queue which wants to read all raw traffic
-	 *
-	 * if #isWiretappingActive all raw communication from and to the device will be sent to this queue
+	 * @brief 	The message queue which wants to read all raw traffic
+	 * If #isWiretappingActive all raw communication from and to the device
+	 * will be sent to this queue
 	 */
 	MessageQueueId_t requestedRawTraffic = 0;
 
-	/**
-	 * the object used to set power switches
-	 */
-	PowerSwitchIF *powerSwitcher = nullptr;
-
 	/**
 	 * Pointer to the IPCStore.
-	 *
 	 * This caches the pointer received from the objectManager in the constructor.
 	 */
 	StorageManagerIF *IPCStore = nullptr;
-
-	/**
-	 * cached for init
-	 */
+	/** The comIF object ID is cached for the intialize() function */
 	object_id_t deviceCommunicationId;
-
-	/**
-	 * Communication object used for device communication
-	 */
+	/** Communication object used for device communication */
 	DeviceCommunicationIF * communicationInterface = nullptr;
-
-	/**
-	 * Cookie used for communication
-	 */
+	/** Cookie used for communication */
 	CookieIF * comCookie;
 
+	/** Health helper for HasHealthIF */
+	HealthHelper healthHelper;
+	/** Mode helper for HasModesIF */
+	ModeHelper modeHelper;
+	/** Parameter helper for ReceivesParameterMessagesIF */
+	ParameterHelper parameterHelper;
+	/** Action helper for HasActionsIF */
+	ActionHelper actionHelper;
+	/** Housekeeping Manager */
+	HousekeepingManager hkManager;
+
+	/**
+	 *  @brief Information about commands
+	 */
 	struct DeviceCommandInfo {
-		bool isExecuting; //!< Indicates if the command is already executing.
-		uint8_t expectedReplies; //!< Dynamic value to indicate how many replies are expected. Inititated with 0.
-		MessageQueueId_t sendReplyTo; //!< if this is != NO_COMMANDER, DHB was commanded externally and shall report everything to commander.
+		//! Indicates if the command is already executing.
+		bool isExecuting;
+		//! Dynamic value to indicate how many replies are expected.
+		//! Inititated with 0.
+		uint8_t expectedReplies;
+		//! if this is != NO_COMMANDER, DHB was commanded externally and shall
+		//! report everything to commander.
+		MessageQueueId_t sendReplyTo;
 	};
 	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
+	/**
+	 * Information about commands
+	 */
+	DeviceCommandMap deviceCommandMap;
 
 	/**
 	 * @brief Information about expected replies
-	 *
-	 * This is used to keep track of pending replies
+	 * This is used to keep track of pending replies.
 	 */
 	struct DeviceReplyInfo {
-		uint16_t maxDelayCycles; //!< The maximum number of cycles the handler should wait for a reply to this command.
-		uint16_t delayCycles; //!< The currently remaining cycles the handler should wait for a reply, 0 means there is no reply expected
+		//! The maximum number of cycles the handler should wait for a reply
+		//! to this command.
+		uint16_t maxDelayCycles;
+		//! The currently remaining cycles the handler should wait for a reply,
+		//! 0 means there is no reply expected
+		uint16_t delayCycles;
 		size_t replyLen = 0; //!< Expected size of the reply.
-		uint8_t periodic; //!< if this is !=0, the delayCycles will not be reset to 0 but to maxDelayCycles
-		DeviceCommandMap::iterator command; //!< The command that expects this reply.
+		//! if this is !=0, the delayCycles will not be reset to 0 but to
+		//! maxDelayCycles
+		bool periodic;
+		//! The dataset used to access housekeeping data related to the
+		//! respective device reply. Will point to a dataset held by
+		//! the child handler (if one is specified)
+		DataSetIF* dataSet;
+		//! The command that expects this reply.
+		DeviceCommandMap::iterator command;
 	};
 
 	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
 	using DeviceReplyIter = DeviceReplyMap::iterator;
-
 	/**
-	 * The MessageQueue used to receive device handler commands and to send replies.
+	 * This map is used to check and track correct reception of all replies.
+	 *
+	 * It has multiple use:
+	 * - It stores the information on pending replies. If a command is sent,
+	 * 	 the DeviceCommandInfo.count is incremented.
+	 * - It is used to time-out missing replies. If a command is sent, the
+	 * 	 DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
+	 * - It is queried to check if a reply from the device can be interpreted.
+	 *   scanForReply() returns the id of the command a reply was found for.
+	 * The reply is ignored in the following cases:
+	 *     - No entry for the returned id was found
+	 *     - The deviceReplyInfo.delayCycles is == 0
 	 */
+	DeviceReplyMap deviceReplyMap;
+
+	//! The MessageQueue used to receive device handler commands
+	//! and to send replies.
 	MessageQueueIF* commandQueue = nullptr;
 
 	/**
@@ -652,15 +688,6 @@ protected:
 	 */
 	uint32_t deviceThermalRequestPoolId;
 
-	/**
-	 * Taking care of the health
-	 */
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	ParameterHelper parameterHelper;
-
 	/**
 	 * Optional Error code
 	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
@@ -966,24 +993,11 @@ protected:
 	bool commandIsExecuting(DeviceCommandId_t commandId);
 
 	/**
-	 * This map is used to check and track correct reception of all replies.
+	 * set all switches returned by getSwitches()
 	 *
-	 * It has multiple use:
-	 * - it stores the information on pending replies. If a command is sent, the DeviceCommandInfo.count is incremented.
-	 * - it is used to time-out missing replies. If a command is sent, the DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
-	 * - it is queried to check if a reply from the device can be interpreted. scanForReply() returns the id of the command a reply was found for.
-	 * The reply is ignored in the following cases:
-	 *     - No entry for the returned id was found
-	 *     - The deviceReplyInfo.delayCycles is == 0
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
 	 */
-	DeviceReplyMap deviceReplyMap;
-
-	/**
-	 * Information about commands
-	 */
-	DeviceCommandMap deviceCommandMap;
-
-	ActionHelper actionHelper;
+	void commandSwitch(ReturnValue_t onOff);
 private:
 
 	/**
@@ -1016,6 +1030,9 @@ private:
 	 */
 	CookieInfo cookieInfo;
 
+	/** the object used to set power switches*/
+	PowerSwitchIF *powerSwitcher = nullptr;
+
 	/**
 	 * Used for timing out mode transitions.
 	 *
@@ -1148,12 +1165,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-	/**
-	 * set all switches returned by getSwitches()
-	 *
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	void commandSwitch(ReturnValue_t onOff);
 
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
@@ -1178,6 +1189,10 @@ private:
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+	void parseReply(const uint8_t* receivedData,
+			size_t receivedDataLen);
+	DataSetIF* getDataSetHandle(sid_t sid) override;
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 65c40219..9bc2cbe8 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -7,13 +7,15 @@
 
 object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
 
-DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent) :
-		FailureIsolationBase(owner, parent), strangeReplyCount(MAX_STRANGE_REPLIES,
-				STRANGE_REPLIES_TIME_MS, parameterDomainBase++), missedReplyCount(
-				MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
-				parameterDomainBase++), recoveryCounter(MAX_REBOOT,
-				REBOOT_TIME_MS, parameterDomainBase++), fdirState(NONE), powerConfirmation(
-				0) {
+DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
+		object_id_t parent) :
+		FailureIsolationBase(owner, parent),
+		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
+				parameterDomainBase++),
+		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
+				parameterDomainBase++),
+		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
+		fdirState(NONE), powerConfirmation(0) {
 }
 
 DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
@@ -68,9 +70,11 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
 		break;
 		//****Power*****
 	case PowerSwitchIF::SWITCH_WENT_OFF:
-		result = sendConfirmationRequest(event, powerConfirmation);
-		if (result == RETURN_OK) {
-			setFdirState(DEVICE_MIGHT_BE_OFF);
+		if(hasPowerConfirmation) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
 		}
 		break;
 	case Fuse::FUSE_WENT_OFF:
@@ -142,7 +146,8 @@ void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 
 void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
 	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
-	//This means, no fault message will come through until a MODE_ or HEALTH_INFO message comes through -> Is that ok?
+	//This means, no fault message will come through until a MODE_ or
+	//HEALTH_INFO message comes through -> Is that ok?
 	//Same issue in TxFailureIsolation!
 //	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
 //			&& (fdirState != RECOVERY_ONGOING)) {
@@ -162,10 +167,11 @@ ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
 			powerConfirmationId);
-	if (power == NULL) {
-		return RETURN_FAILED;
+	if (power != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+		hasPowerConfirmation = true;
 	}
-	powerConfirmation = power->getEventReceptionQueue();
+
 	return RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 91f6ef64..379edae3 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -28,6 +28,7 @@ protected:
 		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
 	};
 	FDIRState fdirState;
+	bool hasPowerConfirmation = false;
 	MessageQueueId_t powerConfirmation;
 	static object_id_t powerConfirmationId;
 	static const uint32_t MAX_REBOOT = 1;

From b4561465ba273718f03b8f32e73eb4d5ffcb7610 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 01:36:07 +0200
Subject: [PATCH 0390/1292] some little form improvements

---
 devicehandlers/DeviceHandlerBase.h   | 4 ++--
 framework.mk                         | 4 ++--
 housekeeping/HasHkPoolParametersIF.h | 1 -
 housekeeping/HousekeepingMessage.h   | 1 +
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 47cf0284..9b2bcdf4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,5 +1,5 @@
-#ifndef DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
 
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
diff --git a/framework.mk b/framework.mk
index 404055ee..c8822981 100644
--- a/framework.mk
+++ b/framework.mk
@@ -1,5 +1,5 @@
-# This file needs FRAMEWORK_PATH and API set correctly
-# Valid API settings: rtems, linux, freeRTOS
+# This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
+# Valid API settings: rtems, linux, freeRTOS, host
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/action/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/container/*.cpp)
diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 62715a3d..9efc6d16 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -40,7 +40,6 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
-	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e7ba68ba..61e6e199 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -19,6 +19,7 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
+
 class HousekeepingMessage {
 public:
 	/**

From 8e7593d68a8bf7f909cf87f2daea6625c6ef4010 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 02:10:21 +0200
Subject: [PATCH 0391/1292] removed error handling in separate fnctn

---
 osal/linux/MessageQueue.cpp | 74 ++++++++++++++++++++-----------------
 osal/linux/MessageQueue.h   |  4 ++
 2 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 48ba29e8..d12fa720 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,14 +1,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/linux/MessageQueue.h>
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
-#include <mqueue.h>
 #include <cstring>
 #include <errno.h>
-#include <framework/osal/linux/MessageQueue.h>
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE) {
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
+		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
@@ -17,40 +17,17 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	attributes.mq_maxmsg = messageDepth;
 	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue
+	//Set the name of the queue. The slash is mandatory!
 	sprintf(name, "/Q%u\n", queueCounter++);
 
-	//Create a nonblocking queue if the name is available (the queue is Read and
-	// writable for the owner as well as the group)
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
-		//An error occured during open
-		//We need to distinguish if it is caused by an already created queue
-		if (errno == EEXIST) {
-			//There's another queue with the same name
-			//We unlink the other queue
-			int status = mq_unlink(name);
-			if (status != 0) {
-				sif::error << "mq_unlink Failed with status: " << strerror(errno)
-						   << std::endl;
-			} else {
-				//Successful unlinking, try to open again
-				mqd_t tempId = mq_open(name,
-				O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-				S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, &attributes);
-				if (tempId != -1) {
-					//Successful mq_open
-					this->id = tempId;
-					return;
-				}
-			}
-		}
-		//Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status: "
-				<< strerror(errno) << std::endl;
-	} else {
+		ReturnValue_t result = handleError(&attributes);
+	}
+	else {
 		//Successful mq_open call
 		this->id = tempId;
 	}
@@ -69,6 +46,37 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
+	// An error occured during open
+	// We need to distinguish if it is caused by an already created queue
+	if (errno == EEXIST) {
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+					<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status: "
+				<< strerror(errno) << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
 		MessageQueueMessage* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index fdc8dab1..b44ed5c7 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -4,6 +4,8 @@
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
+
+#include <mqueue.h>
 /**
  * @brief		This class manages sending and receiving of message queue messages.
  *
@@ -172,6 +174,8 @@ private:
 	char name[5];
 
 	static uint16_t queueCounter;
+
+	ReturnValue_t handleError(mq_attr* attributes);
 };
 
 #endif /* MESSAGEQUEUE_H_ */

From d35524ecbcbcd49d8f95e37180c787f606fad493 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 12:41:17 +0200
Subject: [PATCH 0392/1292] decoupling from raw reciever, linux mq improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 67 +++++++++++++++++-----------
 devicehandlers/DeviceHandlerBase.h   |  2 +-
 health/HealthHelper.cpp              |  1 +
 osal/linux/MessageQueue.cpp          | 62 +++++++++++++++----------
 osal/linux/MessageQueue.h            |  2 +-
 5 files changed, 82 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1e3bb16e..d738b3f9 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -15,7 +15,7 @@
 #include <iomanip>
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = 0;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+	commandQueue = QueueFactory::instance()->createMessageQueue(1,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
@@ -121,15 +121,16 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return RETURN_FAILED;
 	}
 
-	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-			AcceptsDeviceResponsesIF>(rawDataReceiverId);
+	if(rawDataReceiverId != objects::NO_OBJECT) {
+		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == NULL) {
-		return RETURN_FAILED;
+		if (rawReceiver == NULL) {
+			return RETURN_FAILED;
+		}
+		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	defaultRawReceiver = rawReceiver->getDeviceQueue();
-
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == NULL) {
@@ -139,6 +140,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = healthHelper.initialize();
 	if (result != RETURN_OK) {
+		sif::error << "DeviceHandlerBase::initialize: Health Helper "
+				"initialization failure" << std::endl;
 		return result;
 	}
 
@@ -614,7 +617,7 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW) {
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
 		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
 	}
 	else {
@@ -727,7 +730,7 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == NULL || len == 0) {
+	if (IPCStore == NULL || len == 0 || sendTo == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	store_address_t address;
@@ -1131,35 +1134,47 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 		return;
 	}
 	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
-	if (iter->second.command != deviceCommandMap.end()) {//replies to a command
+	//replies to a command
+	if (iter->second.command != deviceCommandMap.end())
+	{
 		MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
 
 		if (queueId != NO_COMMANDER) {
 			//This may fail, but we'll ignore the fault.
 			actionHelper.reportData(queueId, replyId, data);
 		}
+
 		//This check should make sure we get any TM but don't get anything doubled.
 		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
 			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		} else if (forceDirectTm && (defaultRawReceiver != queueId)) {
-
-			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
-			//(progress or completed) it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-			true);
-
 		}
-	} else { //unrequested/aperiodic replies
-		if (wiretappingMode == TM) {
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		} else if (forceDirectTm) {
-			// hiding of sender needed so the service will handle it as unexpected Data, no matter what state
-			//(progress or completed) it is in
+		else if (forceDirectTm and (defaultRawReceiver != queueId) and
+					(defaultRawReceiver != MessageQueueIF::NO_QUEUE))
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
 			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-			true);
+					true);
 		}
 	}
-//Try to cast to GlobDataSet and commit data.
+	//unrequested/aperiodic replies
+	else
+	{
+		if (wiretappingMode == TM) {
+			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+		}
+		else if (forceDirectTm and defaultRawReceiver !=
+				MessageQueueIF::NO_QUEUE)
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+					true);
+		}
+	}
+	//Try to cast to GlobDataSet and commit data.
 	if (!neverInDataPool) {
 		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
 		if (dataSet != NULL) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 9b2bcdf4..3a43fa74 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -577,7 +577,7 @@ protected:
 	 * Used when there is no method of finding a recipient, ie raw mode and
 	 * reporting erroneous replies
 	 */
-	MessageQueueId_t defaultRawReceiver = 0;
+	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
 	store_address_t storedRawData;
 
 	/**
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index b7d54dc1..3a345287 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -40,6 +40,7 @@ void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
 ReturnValue_t HealthHelper::initialize() {
 	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+	// TODO: Better returnvalues
 	if ((healthTable == NULL) || eventSender == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index d12fa720..08a9ab20 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -7,7 +7,7 @@
 
 
 
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
@@ -25,7 +25,7 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize): id(0),
 	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
 	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
 	if (tempId == -1) {
-		ReturnValue_t result = handleError(&attributes);
+		handleError(&attributes);
 	}
 	else {
 		//Successful mq_open call
@@ -47,33 +47,47 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
-	// An error occured during open
-	// We need to distinguish if it is caused by an already created queue
-	if (errno == EEXIST) {
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-					<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid Name " << std::endl;
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		if (errno == EEXIST) {
+			//There's another queue with the same name
+			//We unlink the other queue
+			int status = mq_unlink(name);
+			if (status != 0) {
+				sif::error << "mq_unlink Failed with status: " << strerror(errno)
+											<< std::endl;
+			}
+			else {
+				// Successful unlinking, try to open again
+				mqd_t tempId = mq_open(name,
+						O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+						S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+				if (tempId != -1) {
+					//Successful mq_open
+					this->id = tempId;
+					return HasReturnvaluesIF::RETURN_OK;
+				}
 			}
 		}
+		break;
+	}
+
+	default:
 		// Failed either the first time or the second time
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status: "
-				<< strerror(errno) << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
 	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
 
 }
 
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index b44ed5c7..debf9cd1 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -40,7 +40,7 @@ public:
 	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
 	 * 							This should be left default.
 	 */
-	MessageQueue(size_t messageDepth = 3,
+	MessageQueue(uint32_t messageDepth = 3,
 			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
 	/**
 	 * @brief	The destructor deletes the formerly created message queue.

From 5289497ab5769fc61ba1816322c4f86377cfd36f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 12:59:43 +0200
Subject: [PATCH 0393/1292] health helper optional, diagnostic output improved

---
 devicehandlers/DeviceHandlerBase.cpp          | 39 ++++++++++++++-----
 devicehandlers/DeviceHandlerBase.h            |  1 +
 .../DeviceHandlerFailureIsolation.cpp         |  2 +
 fdir/FailureIsolationBase.cpp                 |  4 +-
 objectmanager/ObjectManager.cpp               |  7 ++--
 5 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d738b3f9..c73cf618 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -139,10 +139,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		sif::error << "DeviceHandlerBase::initialize: Health Helper "
-				"initialization failure" << std::endl;
-		return result;
+	if (result == RETURN_OK) {
+		healthHelperActive = true;
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::initialize: Health Helper "
+				"initialization failure." << std::endl;
 	}
 
 	result = modeHelper.initialize();
@@ -215,9 +217,11 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = healthHelper.handleHealthCommand(&message);
-	if (result == RETURN_OK) {
-		return;
+	if(healthHelperActive) {
+		result = healthHelper.handleHealthCommand(&message);
+		if (result == RETURN_OK) {
+			return;
+		}
 	}
 
 	result = modeHelper.handleModeCommand(&message);
@@ -996,7 +1000,9 @@ void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 }
 
 void DeviceHandlerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
+	if(healthHelperActive) {
+		healthHelper.setHealth(EXTERNAL_CONTROL);
+	}
 }
 
 void DeviceHandlerBase::announceMode(bool recursive) {
@@ -1016,11 +1022,24 @@ void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
 }
 
 HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	return healthHelper.getHealth();
+	if(healthHelperActive) {
+		return healthHelper.getHealth();
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
+				<< std::endl;
+		return HasHealthIF::HEALTHY;
+	}
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
+	if(healthHelperActive) {
+		healthHelper.setHealth(health);
+	}
+	else {
+		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
+				<< std::endl;
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3a43fa74..b079e469 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -601,6 +601,7 @@ protected:
 
 	/** Health helper for HasHealthIF */
 	HealthHelper healthHelper;
+	bool healthHelperActive = false;
 	/** Mode helper for HasModesIF */
 	ModeHelper modeHelper;
 	/** Parameter helper for ReceivesParameterMessagesIF */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9bc2cbe8..1df2afa0 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -163,6 +163,8 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
+				" initialize FailureIsolationBase." << std::endl;
 		return result;
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index c65640c2..46114467 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -19,7 +19,9 @@ FailureIsolationBase::~FailureIsolationBase() {
 ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
-	if (manager == NULL) {
+	if (manager == nullptr) {
+		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
+				" been initialized!" << std::endl;
 		return RETURN_FAILED;
 	}
 	ReturnValue_t result = manager->registerListener(eventQueue->getId());
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 2f47950f..fe7adb25 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -69,9 +69,10 @@ void ObjectManager::initialize() {
 		return_value = it.second->initialize();
 		if ( return_value != RETURN_OK ) {
 			object_id_t var = it.first;
-			sif::error << "Object 0x" << std::hex <<  std::setw(8) <<
-					std::setfill('0')<< var << " failed to initialize " <<
-					"with code 0x" << return_value << std::dec << std::endl;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << return_value << std::dec <<
+					std::endl;
 			error_count++;
 		}
 	}

From 04236859daecfcde5ed24829623d0a5dbf5da070 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:03:37 +0200
Subject: [PATCH 0394/1292] slight improvements to diagnostic ouput

---
 objectmanager/ObjectManager.cpp | 41 ++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index fe7adb25..606cd369 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -58,44 +58,43 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager: Passed produceObjects functions is"
-				"nullptr!" << std::endl;
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
 		return;
 	}
 	this->produceObjects();
-	ReturnValue_t return_value = RETURN_FAILED;
-	uint32_t error_count = 0;
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
 	for (auto const& it : objectList) {
-		return_value = it.second->initialize();
-		if ( return_value != RETURN_OK ) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
 			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << return_value << std::dec <<
-					std::endl;
-			error_count++;
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
 		}
 	}
-	if (error_count > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << error_count
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
 	}
 	//Init was successful. Now check successful interconnections.
-	error_count = 0;
+	errorCount = 0;
 	for (auto const& it : objectList) {
-		return_value = it.second->checkObjectConnections();
-		if ( return_value != RETURN_OK ) {
-			sif::error << "Object " << std::hex <<  (int) it.first
-			        << " connection check failed with code 0x" << return_value
-			        << std::dec << std::endl;
-			error_count++;
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
 		}
 	}
-	if (error_count > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << error_count
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
 	}
-
 }
 
 void ObjectManager::printList() {

From 95bc5a871b6a3e823cc6ed1c7564e3540456fda0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:56:35 +0200
Subject: [PATCH 0395/1292] improved diagnostic messages for linux

---
 devicehandlers/DeviceHandlerBase.cpp |  2 +-
 osal/linux/MessageQueue.cpp          | 32 ++++++++++++++++++++++------
 osal/linux/MessageQueue.h            |  2 +-
 osal/linux/PosixThread.cpp           |  2 +-
 4 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c73cf618..965959af 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(1,
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
 	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 08a9ab20..493c2aca 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,12 +1,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/osal/linux/MessageQueue.h>
+
+#include <fstream>
+
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
 #include <cstring>
 #include <errno.h>
 
 
-
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 		lastPartner(0), defaultDestination(NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
@@ -22,10 +24,11 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 
 	// Create a nonblocking queue if the name is available (the queue is read
 	// and writable for the owner as well as the group)
-	mqd_t tempId = mq_open(name, O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-	S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH, &attributes);
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
 	if (tempId == -1) {
-		handleError(&attributes);
+		handleError(&attributes, messageDepth);
 	}
 	else {
 		//Successful mq_open call
@@ -46,10 +49,27 @@ MessageQueue::~MessageQueue() {
 	}
 }
 
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes) {
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid Name " << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Invalid Name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg;
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			// This happens if the msg_max value is not large enough
+			// It is ignored if the executable is run in privileged mode.
+			// Run the unlockRealtime script or grant the mode manully by using:
+			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			// Permanent solution:
+			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+		}
 		break;
 	}
 	case(EEXIST): {
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index debf9cd1..2808d36e 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -175,7 +175,7 @@ private:
 
 	static uint16_t queueCounter;
 
-	ReturnValue_t handleError(mq_attr* attributes);
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
 #endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 899700f0..e8d624ca 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -138,7 +138,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	void* sp;
 	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread stack init failed with: " <<
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 	}
 

From 788f7a37459dbd445253c4876da62d0a2298c2d6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 13:59:00 +0200
Subject: [PATCH 0396/1292] better name for mq

---
 osal/linux/MessageQueue.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 493c2aca..2456a329 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -20,7 +20,7 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
 	attributes.mq_msgsize = maxMessageSize;
 	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
 	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/Q%u\n", queueCounter++);
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
 
 	// Create a nonblocking queue if the name is available (the queue is read
 	// and writable for the owner as well as the group)
@@ -53,9 +53,9 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid Name or attributes"
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
-		size_t defaultMqMaxMsg;
+		size_t defaultMqMaxMsg = 0;
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
 			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html

From 212cd58f9a7a8c7b1ed86b5a4b4f46c09f645022 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 14:45:45 +0200
Subject: [PATCH 0397/1292] issues with fixed timeslo ttask on linux

---
 osal/linux/MessageQueue.cpp |  2 +-
 osal/linux/PosixThread.cpp  | 26 +++++++++++++++++---------
 osal/linux/PosixThread.h    |  2 +-
 osal/linux/TaskFactory.cpp  | 16 ++++++++++++----
 4 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 2456a329..86d1e0d9 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -64,7 +64,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			// Run the unlockRealtime script or grant the mode manully by using:
 			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Permanent solution:
+			// Permanent solution (EventManager has mq depth of 80):
 			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index e8d624ca..cfc3ed4d 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -3,6 +3,10 @@
 #include <errno.h>
 #include <framework/osal/linux/PosixThread.h>
 
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+	strcpy(name,name_);
+}
 
 PosixThread::~PosixThread() {
 	//No deletion and no free of Stack Pointer
@@ -113,12 +117,6 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 	return currentTime_ms;
 }
 
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-	strcpy(name,name_);
-}
-
-
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	//sif::debug << "PosixThread::createTask" << std::endl;
@@ -135,14 +133,24 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
 	}
-	void* sp;
-	status = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stackSize);
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			double stackMb = (double)((double)stackSize/(double)10e6);
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
 	}
 
-	status = pthread_attr_setstack(&attributes, sp, stackSize);
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
 		sif::error << "Posix Thread attribute setStack failed with: " <<
 				strerror(status) << std::endl;
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index d96c4156..f10352b4 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -68,7 +68,7 @@ protected:
 private:
 	char name[10];
 	int priority;
-	size_t stackSize;
+	size_t stackSize = 0;
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 44f46d90..219630a7 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -13,12 +13,20 @@ TaskFactory* TaskFactory::instance() {
 	return TaskFactory::factoryInstance;
 }
 
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return static_cast<PeriodicTaskIF*>(new PeriodicPosixTask(name_, taskPriority_,stackSize_,periodInSeconds_ * 1000,deadLineMissedFunction_));
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
 }
 
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return static_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_, taskPriority_,stackSize_,periodInSeconds_*1000));
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {

From ef01b7814064e6847ce8e90ea00e8ea09bb36111 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:01:57 +0200
Subject: [PATCH 0398/1292] some issue with stack size ..

---
 osal/linux/PeriodicPosixTask.cpp |  3 ++-
 osal/linux/PosixThread.cpp       |  3 +++
 osal/linux/PosixThread.h         | 19 +++++++++++--------
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index f6a74901..df5bbf93 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -38,7 +38,8 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void){
 	started = true;
-	createTask(&taskEntryPoint,this);
+	//sif::info << stackSize << std::endl;
+	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index cfc3ed4d..5f91858f 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -128,6 +128,9 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
        default attributes.
 	 */
 	pthread_attr_t attributes;
+	//PeriodicPosixTask* task = reinterpret_cast<PeriodicPosixTask*>(arg_);
+	//sif::info << task->stackSize << std::endl;
+	sif::info << stackSize << std::endl;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
 		sif::error << "Posix Thread attribute init failed with: " <<
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index f10352b4..ad403ac4 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -54,14 +54,17 @@ protected:
 	pthread_t thread;
 
 	/**
-	 * @brief Function that has to be called by derived class because the derived class pointer has to be valid as argument
-	 * @details This function creates a pthread with the given parameters. As the function requires a pointer to the derived object
-	 * 			it has to be called after the this pointer of the derived object is valid. Sets the taskEntryPoint as
-	 * 			function to be called by new a thread.
-	 * @param name_ Name of the task
-	 * @param priority_ Priority of the task according to POSIX
-	 * @param stackSize_ Size of the stack attached to that task
-	 * @param arg_ argument of the taskEntryPoint function, needs to be this pointer of derived class
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
 	 */
 	void createTask(void* (*fnc_)(void*),void* arg_);
 

From b0634ab0a2f53fc7e1e194391f7ef4da80077931 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:26:22 +0200
Subject: [PATCH 0399/1292] fixed bug (critical!)

---
 osal/linux/FixedTimeslotTask.h | 22 +++++++++++++---------
 osal/linux/PosixThread.cpp     | 22 +++++++++++++++-------
 osal/linux/PosixThread.h       |  2 +-
 3 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 6350f347..6d523ba9 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -8,7 +8,8 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
 	virtual ~FixedTimeslotTask();
 
 	virtual ReturnValue_t startTask();
@@ -17,7 +18,9 @@ public:
 
 	virtual uint32_t getPeriodMs() const;
 
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
 	virtual ReturnValue_t checkSequence() const;
 
 	/**
@@ -34,11 +37,10 @@ public:
 protected:
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
 	 */
 	virtual void taskFunctionality();
 
@@ -46,8 +48,10 @@ private:
 	/**
 	 * @brief	This is the entry point in a new thread.
 	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
 	 */
 	static void* taskEntryPoint(void* arg);
 	FixedSlotSequence pst;
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 5f91858f..24545f6f 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,11 +1,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/osal/linux/PosixThread.h>
 #include <cstring>
 #include <errno.h>
-#include <framework/osal/linux/PosixThread.h>
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strcpy(name,name_);
+	strncpy(name,name_,16);
 }
 
 PosixThread::~PosixThread() {
@@ -128,9 +128,6 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
        default attributes.
 	 */
 	pthread_attr_t attributes;
-	//PeriodicPosixTask* task = reinterpret_cast<PeriodicPosixTask*>(arg_);
-	//sif::info << task->stackSize << std::endl;
-	sif::info << stackSize << std::endl;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
 		sif::error << "Posix Thread attribute init failed with: " <<
@@ -142,7 +139,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 		if(errno == ENOMEM) {
-			double stackMb = (double)((double)stackSize/(double)10e6);
+			uint64_t stackMb = stackSize/10e6;
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 		}
@@ -199,8 +196,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-		sif::error << "Posix Thread setname failed with: " <<
+		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+
 	}
 
 	status = pthread_attr_destroy(&attributes);
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index ad403ac4..488e1986 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -69,7 +69,7 @@ protected:
 	void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[10];
+	char name[16];
 	int priority;
 	size_t stackSize = 0;
 };

From dc9ef41bec99951a0012cfa1a6ae17edfbff5bd5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:31:45 +0200
Subject: [PATCH 0400/1292] added doc for linux

---
 osal/linux/FixedTimeslotTask.h | 12 ++++++++++++
 osal/linux/PeriodicPosixTask.h | 13 +++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 6d523ba9..d35b9ecb 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -8,6 +8,18 @@
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
 public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
 	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
 			uint32_t periodMs_);
 	virtual ~FixedTimeslotTask();
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 43647eda..85de0d59 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -9,9 +9,22 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
 	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
 			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
+
 	/**
 	 * @brief	The method to start the task.
 	 * @details	The method starts the task with the respective system call.

From 096fbec156dc27d269154bebd70b61e9d7ed1c70 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 15:40:10 +0200
Subject: [PATCH 0401/1292] cleaned includesu p a bit

---
 osal/linux/FixedTimeslotTask.cpp | 7 ++-----
 osal/linux/FixedTimeslotTask.h   | 3 +++
 osal/linux/PosixThread.h         | 9 ++++-----
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 098753a7..e5c68f9d 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,10 +1,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <unistd.h>
-#include <limits.h>
-#include <signal.h>
-#include <errno.h>
 #include <framework/osal/linux/FixedTimeslotTask.h>
 
+#include <limits.h>
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
@@ -23,7 +20,7 @@ void* FixedTimeslotTask::taskEntryPoint(void* arg) {
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-	return NULL;
+	return nullptr;
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index d35b9ecb..916e6d6c 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -64,6 +64,9 @@ private:
 	 * This method, that is the entry point in the new thread and calls
 	 * taskFunctionality of the child class. Needs a valid pointer to the
 	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
 	 */
 	static void* taskEntryPoint(void* arg);
 	FixedSlotSequence pst;
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 488e1986..07233fe5 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,12 +1,11 @@
 #ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 #define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
 
-#include <pthread.h>
-#include <sched.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
 
 class PosixThread {
 public:

From b79efa6d6c87cbb9d122b654b706a0279df093a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 16:25:06 +0200
Subject: [PATCH 0402/1292] variable for name len

---
 osal/linux/PosixThread.cpp | 2 +-
 osal/linux/PosixThread.h   | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 24545f6f..3845123c 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -5,7 +5,7 @@
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strncpy(name,name_,16);
+	strncpy(name, name_, PTHREAD_MAX_NAMELEN);
 }
 
 PosixThread::~PosixThread() {
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 07233fe5..e9d31728 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -9,6 +9,7 @@
 
 class PosixThread {
 public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
 	PosixThread(const char* name_, int priority_, size_t stackSize_);
 	virtual ~PosixThread();
 	/**
@@ -54,7 +55,7 @@ protected:
 
 	/**
 	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument
+	 *  		derived class pointer has to be valid as argument.
 	 * @details
 	 * This function creates a pthread with the given parameters. As the
 	 * function requires a pointer to the derived object it has to be called
@@ -68,7 +69,7 @@ protected:
 	void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[16];
+	char name[PTHREAD_MAX_NAMELEN];
 	int priority;
 	size_t stackSize = 0;
 };

From 262d34174ea9a7bd46b7ffd12b70e9e1258fe063 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 18:56:54 +0200
Subject: [PATCH 0403/1292] using strncat now

---
 osal/linux/PosixThread.cpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 3845123c..bc3e62ed 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -5,7 +5,8 @@
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
 		thread(0),priority(priority_),stackSize(stackSize_) {
-	strncpy(name, name_, PTHREAD_MAX_NAMELEN);
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
 }
 
 PosixThread::~PosixThread() {
@@ -59,10 +60,6 @@ void PosixThread::resume(){
 	pthread_kill(thread,SIGUSR1);
 }
 
-
-
-
-
 bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
 		const uint64_t delayTime_ms) {
 	uint64_t nextTimeToWake_ms;
@@ -162,7 +159,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 					strerror(status) << std::endl;
 	}
 
-//TODO FIFO -> This needs root privileges for the process
+	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
@@ -208,7 +205,6 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 						" did not work.." << std::endl;
 			}
 		}
-
 	}
 
 	status = pthread_attr_destroy(&attributes);

From d99be255292e7682bac12dea38258c9cc4eed707 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 20:52:28 +0200
Subject: [PATCH 0404/1292] cookie info iter was uninitialized

leads to crash
---
 devicehandlers/DeviceHandlerBase.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 965959af..30ee0394 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -32,19 +32,20 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), cookieInfo(),
-		childTransitionDelay(5000),
+		switchOffWasReported(false), childTransitionDelay(5000),
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			CommandMessage::MAX_MESSAGE_SIZE);
-	cookieInfo.state = COOKIE_UNUSED;
 	insertInCommandMap(RAW_COMMAND_ID);
+	cookieInfo.state = COOKIE_UNUSED;
+	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
 		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex <<
 				std::setw(8) << std::setfill('0') << this->getObjectId() <<
 				std::dec << ": Do not pass nullptr as a cookie, consider "
-				"passing a dummy cookie instead!" << std::endl;
+				<< std::setfill(' ') << "passing a dummy cookie instead!" <<
+				std::endl;
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -571,12 +572,12 @@ void DeviceHandlerBase::doSendRead() {
 	ReturnValue_t result;
 
 	size_t requestLen = 0;
-	DeviceReplyIter iter = deviceReplyMap.find(cookieInfo.pendingCommand->first);
-	if(iter != deviceReplyMap.end()) {
-		requestLen = iter->second.replyLen;
-	}
-	else {
-		requestLen = 0;
+	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+		DeviceReplyIter iter = deviceReplyMap.find(
+				cookieInfo.pendingCommand->first);
+		if(iter != deviceReplyMap.end()) {
+			requestLen = iter->second.replyLen;
+		}
 	}
 
 	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);

From ea548dea5bbd969ca17cf9cb48a6b5cfad5e8fda Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 21:16:47 +0200
Subject: [PATCH 0405/1292] map lock init

---
 osal/host/QueueMapManager.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index a57d2c0c..e7c86f30 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -4,7 +4,9 @@
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
-QueueMapManager::QueueMapManager() {}
+QueueMapManager::QueueMapManager() {
+    mapLock = MutexFactory::instance()->createMutex();
+}
 
 QueueMapManager* QueueMapManager::instance() {
 	if (mqManagerInstance == nullptr){

From 8216b26fdee2f5e7dc552b0d037219149abc7edb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:15:05 +0200
Subject: [PATCH 0406/1292] datapoollocal updates

---
 datapoollocal/LocalPoolVariable.h   |  8 +++-----
 datapoollocal/LocalPoolVariable.tpp | 12 ++++++------
 datapoollocal/LocalPoolVector.h     |  6 ++++++
 datapoollocal/LocalPoolVector.tpp   | 15 +++++++++++++++
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index cb373a71..b6bfa5b8 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -131,11 +131,9 @@ protected:
 	ReturnValue_t commitWithoutLock() override;
 
 	// std::ostream is the type for object std::cout
-//	friend std::ostream& operator<< (std::ostream &out,
-//			const LocalPoolVar &var) {
-//		out << static_cast<int>(value);
-//		return out;
-//	}
+	template <typename U>
+	friend std::ostream& operator<< (std::ostream &out,
+			const LocalPoolVar<U> &var);
 
 private:
 	//! @brief 	Pool ID of pool entry inside the used local pool.
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b7a0e837..663b73f5 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -151,11 +151,11 @@ inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
 	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
 }
 
-//template<typename T>
-//inline friend std::ostream& LocalPoolVar<T>::operator<< (std::ostream &out,
-//		const LocalPoolVar &var) {
-//	out << static_cast<int>(out);
-//}
-
+template<typename T>
+inline std::ostream& operator<< (std::ostream &out,
+		const LocalPoolVar<T> &var) {
+    out << var.value;
+    return out;
+}
 
 #endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 02c47113..74615151 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -5,6 +5,7 @@
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/serialize/SerializeAdapter.h>
+#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 
@@ -179,6 +180,11 @@ private:
 	ReadWriteMode_t readWriteMode;
 	//! @brief	Pointer to the class which manages the HK pool.
 	HousekeepingManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
 };
 
 #include <framework/datapoollocal/LocalPoolVector.tpp>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 78637eff..9a00e5df 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -15,6 +15,7 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 				"NO_PARAMETER value!" << std::endl;
 	}
 	memset(this->value, 0, vectorSize * sizeof(T));
+	hkManager = hkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
@@ -182,4 +183,18 @@ inline bool LocalPoolVector<T, vectorSize>::isValid() const {
 	return valid;
 }
 
+template<typename T, uint16_t vectorSize>
+inline std::ostream& operator<< (std::ostream &out,
+        const LocalPoolVector<T, vectorSize> &var) {
+    out << "Vector: [";
+    for(int i = 0;i < vectorSize; i++) {
+        out << var.value[i];
+        if(i < vectorSize - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
+}
+
 #endif

From 70212d9f4e979b1092e151cc7cb666b085acddad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:15:42 +0200
Subject: [PATCH 0407/1292] slight formatting

---
 housekeeping/HasHkPoolParametersIF.h | 1 +
 housekeeping/HousekeepingMessage.h   | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HasHkPoolParametersIF.h b/housekeeping/HasHkPoolParametersIF.h
index 9efc6d16..62715a3d 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/housekeeping/HasHkPoolParametersIF.h
@@ -40,6 +40,7 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
 			LocalDataPoolMap& localDataPoolMap) = 0;
+	//virtual float setMinimalHkSamplingFrequency() = 0;
 	virtual HousekeepingManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 61e6e199..e7ba68ba 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -19,7 +19,6 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
-
 class HousekeepingMessage {
 public:
 	/**

From 9ed92e5e6f24721446613138f81939c763ae4783 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:21:51 +0200
Subject: [PATCH 0408/1292] clock typedefs renamed

---
 timemanager/Clock.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 19991b81..121c63df 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -8,8 +8,9 @@
 #include <cstdint>
 #include <sys/time.h>
 
-typedef uint32_t millis_t;
-typedef double seconds_t;
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+typedef uint32_t dur_millis_t;
+typedef double dur_seconds_t;
 
 class Clock {
 public:

From 3d8993b0c599636fb7549ade76ca08cb47f0b4f2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:23:20 +0200
Subject: [PATCH 0409/1292] new typedef names

---
 timemanager/Stopwatch.cpp | 4 ++--
 timemanager/Stopwatch.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index bc8b4149..52118d58 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -13,12 +13,12 @@ void Stopwatch::start() {
     Clock::getClock_timeval(&startTime);
 }
 
-millis_t Stopwatch::stop() {
+dur_millis_t Stopwatch::stop() {
     stopInternal();
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-seconds_t Stopwatch::stopSeconds() {
+dur_seconds_t Stopwatch::stopSeconds() {
     stopInternal();
     return timevalOperations::toDouble(elapsedTime);
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 71580778..630202cc 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -40,12 +40,12 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    millis_t stop();
+    dur_millis_t stop();
     /**
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)
      */
-    seconds_t stopSeconds();
+    dur_seconds_t stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display

From 65999ac6d6c2d8d1cc1b7b30f38366bf67f96054 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:30:16 +0200
Subject: [PATCH 0410/1292] pool var no param is one now

---
 datapool/PoolVariableIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 3086bbe8..6a2900bf 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -27,7 +27,7 @@ public:
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0;
+	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
 
 	enum ReadWriteMode_t {
 		VAR_READ, VAR_WRITE, VAR_READ_WRITE

From c81613690be10ae70c6e18f373a303d77b80052c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 6 Jun 2020 23:41:54 +0200
Subject: [PATCH 0411/1292] no_queue value is 0xffffffff now

---
 ipc/MessageQueueIF.h              |  2 ++
 ipc/MessageQueueSenderIF.h        |  2 +-
 memory/MemoryHelper.cpp           | 26 ++++++++++++--------------
 tcdistribution/PUSDistributor.cpp | 27 ++++++++++++---------------
 4 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index c67f3870..480019eb 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -2,6 +2,8 @@
 #define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
 
 // COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
 
 /**
  * @defgroup message_queue Message Queue
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 6eb7733d..ae66cd12 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -16,7 +16,7 @@ typedef uint32_t MessageQueueId_t;
 
 class MessageQueueSenderIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0;
+	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
 
 	virtual ~MessageQueueSenderIF() {}
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2a830c5a..b078d6ec 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -33,15 +33,6 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	}
 }
 
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != NULL) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
 void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
 	busy = false;
@@ -185,11 +176,18 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 }
 
 ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_!=NULL){
-		this->queueToUse = queueToUse_;
-	}else{
-		return MessageQueueIF::NO_QUEUE;
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
+	this->queueToUse = queueToUse_;
 	return initialize();
 }
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index f4764c4e..bcf6d571 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -4,15 +4,13 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcservices/PusVerificationReport.h>
 
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(), currentPacket(), tcStatus(
-				RETURN_FAILED), packetSource(setPacketSource) {
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
 
-}
-
-PUSDistributor::~PUSDistributor() {
-
-}
+PUSDistributor::~PUSDistributor() {}
 
 iterator_t PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
@@ -45,18 +43,17 @@ iterator_t PUSDistributor::selectDestination() {
 //}
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
 	uint16_t serviceId = service->getIdentifier();
 	//info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
-	errorCode = this->queueMap.insert(
-			std::pair<uint32_t, MessageQueueId_t>(serviceId, queue)).second;
-	if (errorCode == false) {
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
 		//TODO Return Code
-		returnValue = MessageQueueIF::NO_QUEUE;
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				"exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	return returnValue;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MessageQueueId_t PUSDistributor::getRequestQueue() {

From 33cc8591dc2f2ca920dbe86d05e35f8aa40c736c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:17:24 +0200
Subject: [PATCH 0412/1292] yaaay, hardcoded values

---
 health/HealthHelper.cpp        |  5 ++--
 health/HealthHelper.h          | 11 ++++----
 memory/MemoryHelper.cpp        |  8 +++---
 memory/MemoryHelper.h          | 10 +++----
 modes/ModeHelper.cpp           | 48 ++++++++++++++++++++++------------
 modes/ModeHelper.h             |  8 ++++--
 parameters/ParameterHelper.cpp |  4 +--
 parameters/ParameterHelper.h   |  9 ++++---
 8 files changed, 61 insertions(+), 42 deletions(-)

diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 3a345287..fdfc0967 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,9 +1,8 @@
 #include <framework/health/HealthHelper.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		healthTable(NULL), eventSender(NULL), objectId(objectId), parentQueue(
-				0), owner(owner) {
+		objectId(objectId), owner(owner) {
 }
 
 HealthHelper::~HealthHelper() {
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 24fd0d14..a17a69f3 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,11 +1,12 @@
-#ifndef HEALTHHELPER_H_
-#define HEALTHHELPER_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
 
 #include <framework/events/EventManagerIF.h>
 #include <framework/events/EventReportingProxyIF.h>
 #include <framework/health/HasHealthIF.h>
 #include <framework/health/HealthMessage.h>
 #include <framework/health/HealthTableIF.h>
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
@@ -39,12 +40,12 @@ public:
 	 *
 	 * only valid after initialize() has been called
 	 */
-	HealthTableIF *healthTable;
+	HealthTableIF *healthTable = nullptr;
 
 	/**
 	 * Proxy to forward events.
 	 */
-	EventReportingProxyIF* eventSender;
+	EventReportingProxyIF* eventSender = nullptr;
 
 	/**
 	 * Try to handle the message.
@@ -100,7 +101,7 @@ private:
 	/**
 	 * The Queue of the parent
 	 */
-	MessageQueueId_t parentQueue;
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
 
 	/**
 	 * The one using the healthHelper.
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index b078d6ec..de609252 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -5,10 +5,10 @@
 #include <framework/serialize/EndianSwapper.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) :
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand(
-				CommandMessage::CMD_NONE), lastSender(0), reservedSpaceInIPC(
-				NULL), busy(false) {
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
 }
 
 ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 2ff82eb3..da6b9bdb 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,5 +1,5 @@
-#ifndef MEMORYHELPER_H_
-#define MEMORYHELPER_H_
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
 #include <framework/ipc/CommandMessage.h>
 #include <framework/memory/AcceptsMemoryMessagesIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -16,11 +16,11 @@ public:
 private:
 	HasMemoryIF* workOnThis;
 	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
+	StorageManagerIF* ipcStore = nullptr;
 	store_address_t ipcAddress;
 	Command_t lastCommand;
-	MessageQueueId_t lastSender;
-	uint8_t* reservedSpaceInIPC;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
 	bool busy;
 	void handleMemoryLoad(CommandMessage* message);
 	void handleMemoryCheckOrDump(CommandMessage* message);
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index d9266c35..66726772 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,13 +1,11 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/modes/ModeHelper.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
-		theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode(
-				HasModesIF::SUBMODE_NONE), owner(owner), parentQueueId(0), forced(
-				false) {
-}
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
 
 ModeHelper::~ModeHelper() {
 
@@ -71,27 +69,45 @@ ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
 	return initialize();
 }
 
-void ModeHelper::modeChanged(Mode_t mode, Submode_t submode) {
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
 	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE) {
-		if ((mode != commandedMode) || (submode != commandedSubmode)) {
+	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
 			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, mode, submode);
-		} else {
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
 			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					mode, submode);
+					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
 				owner->getCommandQueue());
 	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
-			&& parentQueueId != MessageQueueSenderIF::NO_QUEUE) {
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply, owner->getCommandQueue());
+			and parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+				owner->getCommandQueue());
 	}
-	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
 }
 
 void ModeHelper::startTimer(uint32_t timeoutMs) {
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 87f6d411..b7f5868d 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,6 +1,7 @@
 #ifndef MODEHELPER_H_
 #define MODEHELPER_H_
 
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/modes/ModeMessage.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/timemanager/Countdown.h>
@@ -9,7 +10,7 @@ class HasModesIF;
 
 class ModeHelper {
 public:
-	MessageQueueId_t theOneWhoCommandedAMode;
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 	Mode_t commandedMode;
 	Submode_t commandedSubmode;
 
@@ -39,11 +40,14 @@ public:
 	void setForced(bool forced);
 protected:
 	HasModesIF *owner;
-	MessageQueueId_t parentQueueId;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
 
 	Countdown countdown;
 
 	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
 };
 
 #endif /* MODEHELPER_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 4ba2a1d9..e0756882 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -3,9 +3,7 @@
 #include <framework/parameters/ParameterMessage.h>
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner), ownerQueueId(0), storage(NULL){
-
-}
+		owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index e2fefdba..defe2925 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,6 +1,7 @@
-#ifndef PARAMETERHELPER_H_
-#define PARAMETERHELPER_H_
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
 
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/parameters/ParameterMessage.h>
 #include <framework/parameters/ReceivesParameterMessagesIF.h>
 
@@ -15,9 +16,9 @@ public:
 private:
 	ReceivesParameterMessagesIF *owner;
 
-	MessageQueueId_t ownerQueueId;
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
 
-	StorageManagerIF *storage;
+	StorageManagerIF *storage = nullptr;
 
 	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id, const ParameterWrapper *description);
 

From 3c80bdfefa8149823ed9fb6273cabaac3d02ccc0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:18:19 +0200
Subject: [PATCH 0413/1292] some linebreaks

---
 parameters/ParameterHelper.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index defe2925..352cf0a9 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -20,9 +20,11 @@ private:
 
 	StorageManagerIF *storage = nullptr;
 
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id, const ParameterWrapper *description);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
 
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
 };
 
 #endif /* PARAMETERHELPER_H_ */

From d0b218c18e2cdd65405903626566f5c996064876 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 01:40:48 +0200
Subject: [PATCH 0414/1292] renaming for host os

---
 osal/host/MessageQueue.cpp | 2 +-
 osal/host/MessageQueue.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7d5e4d97..7e68fd5b 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -135,7 +135,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::lockQueue(millis_t lockTimeout) {
+ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
 	return queueLock->lockMutex(lockTimeout);
 }
 
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index a0cce001..619b5e91 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -182,7 +182,7 @@ public:
 
 	bool isDefaultDestinationSet() const override;
 
-	ReturnValue_t lockQueue(millis_t lockTimeout);
+	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
 	ReturnValue_t unlockQueue();
 protected:
 	/**

From fe5b50d8857bb07d7c84d2a89e8cf79d65f6d7a6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 02:22:18 +0200
Subject: [PATCH 0415/1292] improved documentation signigicantly

---
 datapool/PoolVariableIF.h                     | 14 +++---
 .../LocalDataPoolManager.cpp                  | 25 ++++++-----
 .../LocalDataPoolManager.h                    | 45 +++++++++++++------
 datapoollocal/LocalDataSet.cpp                |  6 +--
 datapoollocal/LocalDataSet.h                  |  8 ++--
 datapoollocal/LocalPoolVariable.h             | 34 ++++++++------
 datapoollocal/LocalPoolVariable.tpp           | 10 ++---
 datapoollocal/LocalPoolVector.h               |  6 +--
 datapoollocal/LocalPoolVector.tpp             |  6 +--
 .../OwnsLocalDataPoolIF.h                     | 33 ++++++++------
 devicehandlers/DeviceHandlerBase.cpp          |  4 +-
 devicehandlers/DeviceHandlerBase.h            | 14 +++---
 12 files changed, 118 insertions(+), 87 deletions(-)
 rename housekeeping/HousekeepingManager.cpp => datapoollocal/LocalDataPoolManager.cpp (69%)
 rename housekeeping/HousekeepingManager.h => datapoollocal/LocalDataPoolManager.h (71%)
 rename housekeeping/HasHkPoolParametersIF.h => datapoollocal/OwnsLocalDataPoolIF.h (58%)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 6a2900bf..30b87839 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,12 +1,12 @@
-#ifndef POOLVARIABLEIF_H_
-#define POOLVARIABLEIF_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeIF.h>
 
-
 /**
- * @brief	This interface is used to control data pool variable representations.
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
  * @details
  * To securely handle data pool variables, all pool entries are locally
  * managed by data pool variable access classes, which are called pool
@@ -39,7 +39,8 @@ public:
 	 */
 	virtual ~PoolVariableIF() {}
 	/**
-	 * @brief	This method returns if the variable is write-only, read-write or read-only.
+	 * @brief	This method returns if the variable is write-only,
+	 * 			read-write or read-only.
 	 */
 	virtual ReadWriteMode_t getReadWriteMode() const = 0;
 	/**
@@ -47,7 +48,8 @@ public:
 	 */
 	virtual uint32_t getDataPoolId() const = 0;
 	/**
-	 * @brief	With this call, the valid information of the variable is returned.
+	 * @brief	With this call, the valid information of the
+	 * 			variable is returned.
 	 */
 	virtual bool isValid() const = 0;
 	/**
diff --git a/housekeeping/HousekeepingManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
similarity index 69%
rename from housekeeping/HousekeepingManager.cpp
rename to datapoollocal/LocalDataPoolManager.cpp
index e8edcc39..78e57c8c 100644
--- a/housekeeping/HousekeepingManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,12 +1,12 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
 #include <array>
 
-HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
+LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
 		std::exit(0);
@@ -16,11 +16,12 @@ HousekeepingManager::HousekeepingManager(HasHkPoolParametersIF* owner) {
 	//owner->setMinimalHkSamplingFrequency();
 }
 
-HousekeepingManager::~HousekeepingManager() {}
+LocalDataPoolManager::~LocalDataPoolManager() {}
 
-ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
+ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeHousekeepingPoolEntries(localDpMap);
+		ReturnValue_t result =
+				owner->initializeHousekeepingPoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -30,24 +31,24 @@ ReturnValue_t HousekeepingManager::initializeHousekeepingPoolEntriesOnce() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t HousekeepingManager::handleHousekeepingMessage(
+ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage *message) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t HousekeepingManager::printPoolEntry(
+ReturnValue_t LocalDataPoolManager::printPoolEntry(
 		lp_id_t localPoolId) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* HousekeepingManager::getMutexHandle() {
+MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
@@ -56,7 +57,7 @@ MutexIF* HousekeepingManager::getMutexHandle() {
 //
 //}
 
-void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
+void LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -73,10 +74,10 @@ void HousekeepingManager::generateHousekeepingPacket(sid_t sid) {
 
 }
 
-void HousekeepingManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
+void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
 
-const HasHkPoolParametersIF* HousekeepingManager::getOwner() const {
+const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 	return owner;
 }
diff --git a/housekeeping/HousekeepingManager.h b/datapoollocal/LocalDataPoolManager.h
similarity index 71%
rename from housekeeping/HousekeepingManager.h
rename to datapoollocal/LocalDataPoolManager.h
index 43922ae6..c8a6bf15 100644
--- a/housekeeping/HousekeepingManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -2,19 +2,35 @@
 #define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
 #include <framework/datapool/DataSetIF.h>
 #include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
 #include <framework/ipc/MutexIF.h>
 
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
 
 #include <map>
 
-
-class HousekeepingManager {
+/**
+ * @brief 	This class is the managing instance for local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this class as a member and implement
+ * the OwnsLocalDataPoolIF.
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ *
+ */
+class LocalDataPoolManager {
 	template<typename T>
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
@@ -23,8 +39,8 @@ class HousekeepingManager {
 public:
 	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
-	HousekeepingManager(HasHkPoolParametersIF* owner);
-	virtual~ HousekeepingManager();
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
+	virtual~ LocalDataPoolManager();
 
 
 	// propably will just call respective local data set functions.
@@ -40,7 +56,7 @@ public:
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
-	const HasHkPoolParametersIF* getOwner() const;
+	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
@@ -48,14 +64,14 @@ private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
-	LocalDataPoolMap localDpMap;
+	LocalDataPool localDpMap;
 
 	//! Every housekeeping data manager has a mutex to protect access
 	//! to it's data pool.
 	MutexIF * mutex = nullptr;
 
 	//! The class which actually owns the manager (and its datapool).
-	HasHkPoolParametersIF* owner = nullptr;
+	OwnsLocalDataPoolIF* owner = nullptr;
 
 	//! Used for replies.
 	//! (maybe we dont need this, the sender can be retrieved from command
@@ -85,27 +101,28 @@ private:
 	 * 						supplied pointer.
 	 * @return
 	 */
-	template <class T>
-	ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry);
-	void setMinimalSamplingFrequency(float frequencySeconds);
+	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+			PoolEntry<T> **poolEntry);
 
+	void setMinimalSamplingFrequency(float frequencySeconds);
 };
 
+
 template<class T> inline
-ReturnValue_t HousekeepingManager::fetchPoolEntry(lp_id_t localPoolId,
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localDpMap.find(localPoolId);
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_NOT_FOUND;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return HasHkPoolParametersIF::POOL_ENTRY_TYPE_CONFLICT;
+		return OwnsLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 988f254a..243c9cc1 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,7 +1,7 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 
-LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
+LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
 	if(hkOwner != nullptr) {
 		hkManager = hkOwner->getHkManagerHandle();
 	}
@@ -11,7 +11,7 @@ LocalDataSet::LocalDataSet(HasHkPoolParametersIF *hkOwner): DataSetBase() {
 }
 
 LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
-	HasHkPoolParametersIF* hkOwner = objectManager->get<HasHkPoolParametersIF>(
+	OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
 			ownerId);
 	if(hkOwner == nullptr) {
 		// config error, error output here.
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 607d10b3..54da5562 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -2,10 +2,10 @@
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
-class HousekeepingManager;
+class LocalDataPoolManager;
 
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out variables
@@ -35,7 +35,7 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(HasHkPoolParametersIF* hkOwner);
+	LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
@@ -78,7 +78,7 @@ private:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index b6bfa5b8..4b6e24aa 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,11 +3,11 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/serialize/SerializeAdapter.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 
 /**
  * @brief 	Local Pool Variable class which is used to access the local pools.
@@ -29,9 +29,12 @@ public:
 	/**
 	 * This constructor is used by the data creators to have pool variable
 	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner Pointer of the owner. This will generally be the calling
 	 * class itself which passes "this".
@@ -39,7 +42,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVar(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+	LocalPoolVar(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
@@ -47,12 +50,14 @@ public:
 	 * This constructor is used by data users like controllers to have
 	 * access to the local pool variables of data creators by supplying
 	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
+	 * @param hkOwner object ID of the pool owner.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
@@ -99,7 +104,7 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -109,7 +114,8 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -144,7 +150,7 @@ private:
 	bool valid = false;
 
 	//! Pointer to the class which manages the HK pool.
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 };
 
 #include <framework/datapoollocal/LocalPoolVariable.tpp>
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 663b73f5..0140b29d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -33,8 +33,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	HasHkPoolParametersIF* hkOwner =
-			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	OwnsLocalDataPoolIF* hkOwner =
+			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
@@ -47,7 +47,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
 	return readWithoutLock();
 }
@@ -75,7 +75,7 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
 	return commitWithoutLock();
 }
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 74615151..1c5f1d65 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -4,8 +4,8 @@
 #include <framework/datapool/DataSetIF.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapool/PoolVariableIF.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/serialize/SerializeAdapter.h>
-#include <framework/housekeeping/HousekeepingManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 
@@ -46,7 +46,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, HasHkPoolParametersIF* hkOwner,
+	LocalPoolVector(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
@@ -179,7 +179,7 @@ private:
 	 */
 	ReadWriteMode_t readWriteMode;
 	//! @brief	Pointer to the class which manages the HK pool.
-	HousekeepingManager* hkManager;
+	LocalDataPoolManager* hkManager;
 
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 9a00e5df..bd35eed3 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,7 +7,7 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasHkPoolParametersIF* hkOwner, pool_rwm_t setReadWriteMode,
+		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet) :
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -29,8 +29,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	HasHkPoolParametersIF* hkOwner =
-			objectManager->get<HasHkPoolParametersIF>(poolOwner);
+	OwnsLocalDataPoolIF* hkOwner =
+			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/housekeeping/HasHkPoolParametersIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
similarity index 58%
rename from housekeeping/HasHkPoolParametersIF.h
rename to datapoollocal/OwnsLocalDataPoolIF.h
index 62715a3d..cf94f946 100644
--- a/housekeeping/HasHkPoolParametersIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -5,33 +5,40 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <map>
 
-class HousekeepingManager;
+class LocalDataPoolManager;
 class DataSetIF;
 /**
  * @brief	Type definition for local pool entries.
  */
 using lp_id_t = uint32_t;
-using LocalDataPoolMap =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPoolMap::iterator;
+using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPool::iterator;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class)
+ * 				data pool (not the managing class). It defines the relationship
+ * 				between the local data pool owner and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a HousekeepingManager
- * member class which handles the retrieval of the local pool data.
+ * Any class implementing this interface shall also have a LocalDataPoolManager
+ * member class which contains the actual pool data structure
+ * and exposes the public interface for it.
  * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult.
+ * specifying an interface rather difficult. The local data pool can be
+ * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
+ * classes.
  *
- * This could be circumvented by using a wrapper/accessor function, but
+ * Architectural Note:
+ * This could be circumvented by using a wrapper/accessor function or
+ * implementing the templated function in this interface..
+ * The first solution sounds better than the second but
  * the LocalPoolVariable classes are templates as well, so this just shifts
  * the problem somewhere else. Interfaces are nice, but the most
  * pragmatic solution I found was to offer the client the full interface
- * of the housekeeping manager.
+ * of the LocalDataPoolManager.
  */
-class HasHkPoolParametersIF {
+class OwnsLocalDataPoolIF {
 public:
-	virtual~ HasHkPoolParametersIF() {};
+	virtual~ OwnsLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
 	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
@@ -39,9 +46,9 @@ public:
 
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-			LocalDataPoolMap& localDataPoolMap) = 0;
+			LocalDataPool& localDataPoolMap) = 0;
 	//virtual float setMinimalHkSamplingFrequency() = 0;
-	virtual HousekeepingManager* getHkManagerHandle() = 0;
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
 };
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 30ee0394..59bfb6af 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1347,11 +1347,11 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
-		LocalDataPoolMap &localDataPoolMap) {
+		LocalDataPool &localDataPoolMap) {
 	return RETURN_OK;
 }
 
-HousekeepingManager* DeviceHandlerBase::getHkManagerHandle() {
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b079e469..4ee3d652 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -11,15 +11,13 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/housekeeping/HasHkPoolParametersIF.h>
-
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/housekeeping/HousekeepingManager.h>
-
+#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <map>
 
 namespace Factory{
@@ -87,7 +85,7 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasHealthIF,
 		public HasActionsIF,
 		public ReceivesParameterMessagesIF,
-		public HasHkPoolParametersIF {
+		public OwnsLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
@@ -480,10 +478,10 @@ protected:
 	 * @return
 	 */
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-				LocalDataPoolMap& localDataPoolMap) override;
+				LocalDataPool& localDataPoolMap) override;
 
 	/** Get the HK manager object handle */
-	virtual HousekeepingManager* getHkManagerHandle() override;
+	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
@@ -609,7 +607,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	HousekeepingManager hkManager;
+	LocalDataPoolManager hkManager;
 
 	/**
 	 *  @brief Information about commands

From 73932f0349a958aa15b932f23e56dfa4277a02a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 13:58:51 +0200
Subject: [PATCH 0416/1292] object maanager tweaks

---
 objectmanager/ObjectManager.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 606cd369..cfdf6562 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -23,6 +23,7 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
 		//This is very severe and difficult to handle in other places.
 		std::exit(INSERTION_FAILED);
 	}
@@ -31,8 +32,8 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
-		sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		           << (int)id << std::dec << " removed." << std::endl;
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
 		return RETURN_OK;
 	} else {
 		sif::error << "ObjectManager::removeObject: Requested object "

From 98e6ca5f78b19e679f5f527db1c3612f8e1f214a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 15:22:32 +0200
Subject: [PATCH 0417/1292] removed locks in lockless functions

---
 datapoollocal/LocalPoolVariable.tpp |  2 --
 datapoollocal/LocalPoolVector.h     | 10 +++++++---
 datapoollocal/LocalPoolVector.tpp   | 16 ++++++++++------
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0140b29d..9dcd0699 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -87,8 +87,6 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	// Wait maximum of 50 milliseconds.
-	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 1c5f1d65..a8d0a7bb 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -70,8 +70,9 @@ public:
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
 	 */
 	T value[vectorSize];
 	/**
@@ -109,7 +110,7 @@ public:
 	void setValid(bool valid) override;
 	uint8_t getValid() const;
 
-	T &operator [](int i);
+	T& operator [](int i);
 	const T &operator [](int i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
@@ -142,6 +143,7 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
 	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -185,6 +187,8 @@ private:
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
+
+
 };
 
 #include <framework/datapoollocal/LocalPoolVector.tpp>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index bd35eed3..a18f8327 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -85,8 +85,6 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				"mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
-	// Wait maximum of 50 milliseconds.
-	MutexHelper(hkManager->getMutexHandle(), 50);
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
@@ -106,8 +104,11 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	if(i <= vectorSize) {
 		return value[i];
 	}
-	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
-	return 0;
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -115,8 +116,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	if(i <= vectorSize) {
 		return value[i];
 	}
-	sif::warning << "LocalPoolVector: Invalid index" << std::endl;
-	return 0;
+	// If this happens, I have to set some value. I consider this
+	// a configuration error, but I wont exit here.
+	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+			" last value!" << std::endl;
+	return value[i];
 }
 
 template<typename T, uint16_t vectorSize>

From 3b4413a6ee268d2759a5ef94c1ce8348c7f4d425 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 16:12:23 +0200
Subject: [PATCH 0418/1292] added queue lock for  receiveMessage

---
 osal/host/MessageQueue.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7e68fd5b..3e30c8ed 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -61,6 +61,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
+	MutexHelper mutexLock(queueLock, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());

From 4a90f41122339e106b7ec52f45fcd982dccc5c39 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 18:53:55 +0200
Subject: [PATCH 0419/1292] generate HK packet function continued

---
 datapoollocal/LocalDataPoolManager.cpp | 42 ++++++++++++++-------
 datapoollocal/LocalDataPoolManager.h   | 14 +++++--
 tmtcservices/CommandingServiceBase.cpp | 52 +++++++++++++-------------
 tmtcservices/CommandingServiceBase.h   | 20 +++++-----
 4 files changed, 77 insertions(+), 51 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 78e57c8c..0a5747dc 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/objectmanager/frameworkObjects.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
@@ -13,7 +14,15 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
-	//owner->setMinimalHkSamplingFrequency();
+	if(mutex == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not create mutex." << std::endl;
+	}
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not set IPC store." << std::endl;
+	}
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
@@ -52,32 +61,37 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-//void HousekeepingManager::setMinimalSamplingFrequency(float frequencySeconds) {
-//	this->samplingFrequency = frequencySeconds;
-//
-//}
-
-void LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found" << std::endl;
-		return;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	store_address_t storeId;
+	size_t hkSize = dataSetToSerialize->getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId, hkSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+	            "Could not get free element from IPC store." << std::endl;
+	    return result;
 	}
-	std::array<uint8_t, 256> testBuffer = {};
-	uint8_t* dataPtr = testBuffer.data();
 	size_t size = 0;
-	dataSetToSerialize->serialize(&dataPtr, &size, testBuffer.size(),
-			false);
-	// and now we send it to the TM funnel or somewhere else
-
+	dataSetToSerialize->serialize(&storePtr, &size, hkSize, false);
+	// and now we have to set a HK message and send it the queue.
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
 	this->hkPacketQueue = msgQueue;
 }
 
+void LocalDataPoolManager::setHkReplyQueue(MessageQueueIF *replyQueue) {
+    this->hkReplyQueue = replyQueue;
+}
+
 const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 	return owner;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c8a6bf15..14e7693c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -37,14 +37,15 @@ class LocalDataPoolManager {
 	friend class LocalPoolVector;
 	friend class LocalDataSet;
 public:
-	static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
 
 	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
 	virtual~ LocalDataPoolManager();
 
+	/* Copying forbidden */
+	LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
-	// propably will just call respective local data set functions.
-	void generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
@@ -55,7 +56,12 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
+	//! Set the queue for HK packets, which are sent unrequested.
 	void setHkPacketQueue(MessageQueueIF* msgQueue);
+	//! Set the queue for replies. This can be set manually or by the owner
+	//! class if the manager if message are relayed by it.
+	void setHkReplyQueue(MessageQueueIF* replyQueue);
+
 	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
@@ -81,6 +87,8 @@ private:
 	//! Maybe this will just be the TM funnel.
 	MessageQueueIF* hkPacketQueue = nullptr;
 
+	//! Global IPC store is used to store all packets.
+	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
 	 * eternally. Use with care and don't forget to unlock locked mutexes!
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5b397756..adc9400f 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -218,7 +218,7 @@ void CommandingServiceBase::handleRequestQueue() {
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
 		size_t headerSize) {
 	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
@@ -228,36 +228,38 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		this->tmPacketCounter++;
 	}
+	return result;
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		object_id_t objectId, const uint8_t *data, size_t dataLen) {
-	uint8_t buffer[sizeof(object_id_t)];
-	uint8_t* pBuffer = buffer;
-	size_t size = 0;
-	SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
-			sizeof(object_id_t), true);
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, buffer, size);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
+            sizeof(object_id_t), true);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
 }
 
 
-void CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		SerializeIF* content, SerializeIF* header) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, content, header);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 259ed1a3..e79e806d 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -212,36 +212,38 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask;
 
-	// todo: why do these functions not have returnvalues? the caller should be
-	// able to check whether the send operations actually work.
 	/**
-	 * Send TM data from pointer to data. If a header is supplied it is added before data
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
 	 * @param subservice Number of subservice
 	 * @param data Pointer to the data in the Packet
 	 * @param dataLen Lenght of data in the Packet
 	 * @param headerData HeaderData will be placed before data
 	 * @param headerSize Size of HeaderData
 	 */
-	void sendTmPacket(uint8_t subservice, const uint8_t *data, size_t dataLen,
-			const uint8_t* headerData = nullptr,size_t headerSize = 0);
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
 
 	/**
-	 * To send TM packets of objects that still need to be serialized and consist of an object ID with appended data
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
 	 * @param subservice Number of subservice
 	 * @param objectId ObjectId is placed before data
 	 * @param data Data to append to the packet
 	 * @param dataLen Length of Data
 	 */
-	void sendTmPacket(uint8_t subservice, object_id_t objectId,
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
 			const uint8_t *data, size_t dataLen);
 
 	/**
-	 * To send packets has data which is in form of a SerializeIF or Adapters implementing it
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
 	 * @param subservice Number of subservice
 	 * @param content This is a pointer to the serialized packet
 	 * @param header Serialize IF header which will be placed before content
 	 */
-	void sendTmPacket(uint8_t subservice, SerializeIF* content,
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
 	virtual void handleUnrequestedReply(CommandMessage *reply);

From e8bc2cec9f267079f29e78c94d90d4e107e7eba0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 23:26:52 +0200
Subject: [PATCH 0420/1292] small comment in semaph factory

---
 osal/host/SemaphoreFactory.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 8712d866..0c077f68 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -23,6 +23,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
 	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
 			" Returning nullptr!\n" << std::flush;
 	return nullptr;
@@ -30,6 +31,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
 	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
 				" Returning nullptr!\n" << std::flush;
 	return nullptr;

From 2649fa150706bc93d88137dc1de595d2d17272b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 7 Jun 2020 23:38:15 +0200
Subject: [PATCH 0421/1292] small small command message tweaks

---
 ipc/CommandMessage.h | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 21c393e5..6190e903 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,13 +1,5 @@
-/**
- * @file	CommandMessage.h
- * @brief	This file defines the CommandMessage class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef COMMANDMESSAGE_H_
-#define COMMANDMESSAGE_H_
-
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
 #include <framework/ipc/FwMessageTypes.h>
 #include <config/ipc/MissionMessageTypes.h>
@@ -15,10 +7,11 @@
 #include <framework/ipc/MessageQueueMessage.h>
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef ReturnValue_t Command_t;
+typedef uint16_t Command_t;
 
 /**
- * @brief Used to pass command messages between tasks
+ * @brief 	Used to pass command messages between tasks
+ * @author	Bastian Baetz
  */
 class CommandMessage : public MessageQueueMessage {
 public:
@@ -27,9 +20,12 @@ public:
 
 
 	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::COMMAND;
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );//!< Used internally, will be ignored
+	//! Used internally, will be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
 	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );//!< Reply indicating that the current command was rejected, par1 should contain the error code
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
 
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue
@@ -40,11 +36,13 @@ public:
 	/**
 	 * Default Constructor, does not initialize anything.
 	 *
-	 * This constructor should be used when receiving a Message, as the content is filled by the MessageQueue.
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
 	 */
 	CommandMessage();
 	/**
-	 * This constructor creates a new message with all message content initialized
+	 * This constructor creates a new message with all message content
+	 * initialized
 	 *
 	 * @param command	The DeviceHandlerCommand_t that will be sent
 	 * @param parameter1	The first parameter
@@ -60,7 +58,8 @@ public:
 	}
 
 	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message, usually used after receiving
+	 * Read the DeviceHandlerCommand_t that is stored in the message,
+	 * usually used after receiving.
 	 *
 	 * @return the Command stored in the Message
 	 */
@@ -126,7 +125,8 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
-	void setReplyRejected(ReturnValue_t reason, Command_t initialCommand = CMD_NONE);
+	void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand = CMD_NONE);
 	size_t getMinimumMessageSize() const;
 };
 

From 4c41456ddffb6800119c0e6a0d90f4ff03bd4618 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 01:22:21 +0200
Subject: [PATCH 0422/1292] thoughts on message queuee message

new interface. What if there are MQ messages with different sizes?
-> generic interface

furthermore, maybe command message should be refactored to operate
on a mq message instead of implementing it
---
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 39 +++++++++++++++++------
 housekeeping/HousekeepingMessage.cpp   |  8 +++++
 housekeeping/HousekeepingMessage.h     | 17 ++++++----
 ipc/CommandMessage.h                   |  3 +-
 ipc/MessageQueueMessage.h              |  4 ++-
 ipc/MessageQueueMessageIF.h            | 44 ++++++++++++++++++++++++++
 8 files changed, 100 insertions(+), 19 deletions(-)
 create mode 100644 ipc/MessageQueueMessageIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0a5747dc..37dbed36 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -41,7 +41,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage *message) {
+		MessageQueueMessage *message) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 14e7693c..1d25fa48 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -46,7 +46,7 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+	ReturnValue_t handleHousekeepingMessage(MessageQueueMessage* message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 59bfb6af..94c9dc63 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -8,6 +8,8 @@
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
+#include <framework/ipc/MessageQueueMessage.h>
 #include <framework/subsystem/SubsystemBase.h>
 #include <framework/ipc/QueueFactory.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
@@ -36,7 +38,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
 		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
-			CommandMessage::MAX_MESSAGE_SIZE);
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
@@ -212,40 +214,59 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	// This is not ideal. What if it is not a command message? (e.g. another
+	// message with 3 parameters). The full buffer is filled anyway
+	// and I could just copy the content into the other message but
+	// all I need are few additional functions the other message type offers.
+	CommandMessage cmdMessage;
+	ReturnValue_t result = commandQueue->receiveMessage(&cmdMessage);
 	if (result != RETURN_OK) {
 		return;
 	}
 
+	// This is really annoying. I can't cast a parent object to a child.
+	// But I want to use another message format..
+//	CommandMessage* cmdMessage = dynamic_cast<CommandMessage*>(msgPtr);
+//	if(cmdMessage == nullptr) {
+//		sif::error << "DeviceHandlerBase::readCommandQueue: Could not cast"
+//				" message to CommandMessage!" << std::endl;
+//		return;
+//	}
+
 	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&cmdMessage);
 		if (result == RETURN_OK) {
 			return;
 		}
 	}
 
-	result = modeHelper.handleModeCommand(&message);
+	result = modeHelper.handleModeCommand(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = actionHelper.handleActionMessage(&message);
+	result = actionHelper.handleActionMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = parameterHelper.handleParameterMessage(&message);
+	result = parameterHelper.handleParameterMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = handleDeviceHandlerMessage(&message);
+//	HousekeepingMessage* hkMessage = dynamic_cast<HousekeepingMessage*>(msgPtr);
+//	result = hkManager.handleHousekeepingMessage(hkMessage);
+//	if (result == RETURN_OK) {
+//		return;
+//	}
+
+	result = handleDeviceHandlerMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = letChildHandleMessage(&message);
+	result = letChildHandleMessage(&cmdMessage);
 	if (result == RETURN_OK) {
 		return;
 	}
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index b0109e5d..c94a69d7 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,5 +1,13 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
+HousekeepingMessage::HousekeepingMessage() {
+
+}
+
+void HousekeepingMessage::setHkReportMessage() {
+}
+
+
 //void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
 //		set_t setId, store_address_t packet) {
 //	message->setCommand(ADD_HK_REPORT_STRUCT);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e7ba68ba..67edc4ed 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -5,12 +5,14 @@
 #include <limits>
 
 union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS = std::numeric_limits<uint64_t>::max();
+	static constexpr uint64_t INVALID_ADDRESS =
+			std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
 	struct {
 		object_id_t objectId ;
-		// A generic 32 bit ID to identify unique HK packets for a single object.
+		// A generic 32 bit ID to identify unique HK packets for a single
+		// object.
 		// For example, the DeviceCommandId_t is used for DeviceHandlers
 		uint32_t ownerSetId;
 	};
@@ -19,15 +21,17 @@ union sid_t {
 	 */
 	uint64_t raw;
 };
-class HousekeepingMessage {
+
+
+class HousekeepingMessage: public MessageQueueMessage {
 public:
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage() = delete;
-	HousekeepingMessage(const HousekeepingMessage&) = delete;
-	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+	HousekeepingMessage();
+//	HousekeepingMessage(const HousekeepingMessage&) = delete;
+//	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
 
 	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
@@ -76,6 +80,7 @@ public:
 
 //	static void setAddHkReportStructMessage(CommandMessage* message,
 //			DevisetId, store_address_t packet);
+	static void setHkReportMessage();
 };
 
 
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 6190e903..d7b6820d 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -28,7 +28,8 @@ public:
 	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
 
 	/**
-	 * This is the size of a message as it is seen by the MessageQueue
+	 * This is the size of a message as it is seen by the MessageQueue.
+	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
 	static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE
 			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 4d82bd88..93671321 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,6 +1,7 @@
 #ifndef MESSAGEQUEUEMESSAGE_H_
 #define MESSAGEQUEUEMESSAGE_H_
 
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 #include <stddef.h>
 
@@ -23,7 +24,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage {
+class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
@@ -43,6 +44,7 @@ public:
 	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
 	 */
 	MessageQueueMessage(uint8_t* data, size_t size);
+
 	/**
 	 * @brief	The size information of each message is stored in this attribute.
 	 * @details
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
new file mode 100644
index 00000000..3bd4a9d6
--- /dev/null
+++ b/ipc/MessageQueueMessageIF.h
@@ -0,0 +1,44 @@
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+#include <framework/ipc/MessageQueueSenderIF.h>
+#include <cstddef>
+
+class MessageQueueMessageIF {
+public:
+	virtual ~MessageQueueMessageIF() {};
+
+	/**
+	 * @brief	With this method, the whole content and the message
+	 * 			size is set to zero.
+	 */
+	virtual void clear() = 0;
+	/**
+	 * @brief	This is a debug method that prints the content
+	 * 			(till messageSize) to the debug output.
+	 */
+	virtual void print() = 0;
+	virtual const uint8_t* getBuffer() const = 0;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	virtual uint8_t* getBuffer() = 0;
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to sending the message.
+	 * @param setId	The message queue id that identifies the sending message queue.
+	 */
+	virtual void setSender(MessageQueueId_t setId) = 0;
+	/**
+	 * @brief	This helper function is used by the MessageQueue class to
+	 * 			check the size of an incoming message.
+	 * @details
+	 * The method must be overwritten by child classes if size checks shall
+	 * be more strict.
+	 * @return	The default implementation returns HEADER_SIZE.
+	 */
+	virtual size_t getMinimumMessageSize() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */

From 0ea249aac46c7416aa5b908b9c5f844ac8e09388 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 12:25:20 +0200
Subject: [PATCH 0423/1292] messagetype namespace im small letters now

---
 action/ActionMessage.h                |  2 +-
 devicehandlers/DeviceHandlerMessage.h |  2 +-
 health/HealthMessage.h                |  2 +-
 housekeeping/HousekeepingMessage.h    |  2 +-
 ipc/CommandMessage.cpp                | 36 +++++++++++++--------------
 ipc/CommandMessage.h                  |  3 ++-
 ipc/FwMessageTypes.h                  |  4 +--
 ipc/MessageQueueMessageIF.h           | 15 +++++++----
 memory/FileSystemMessage.h            |  2 +-
 memory/MemoryMessage.h                |  2 +-
 modes/ModeMessage.h                   |  2 +-
 monitoring/MonitoringMessage.h        |  2 +-
 parameters/ParameterMessage.h         |  2 +-
 subsystem/modes/ModeSequenceMessage.h |  2 +-
 tmstorage/TmStoreMessage.h            |  2 +-
 15 files changed, 43 insertions(+), 37 deletions(-)

diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 5d8332cb..59ad619e 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -10,7 +10,7 @@ class ActionMessage {
 private:
 	ActionMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::ACTION;
+	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);
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index c91bb0a4..2bdf03b2 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -25,7 +25,7 @@ public:
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::DEVICE_HANDLER_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
 	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
 //	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
 	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index 7fd00904..13e79b88 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -6,7 +6,7 @@
 
 class HealthMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::HEALTH_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
 	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
 	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 67edc4ed..3ba6f94d 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -33,7 +33,7 @@ public:
 //	HousekeepingMessage(const HousekeepingMessage&) = delete;
 //	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
 
-	static constexpr uint8_t MESSAGE_ID = MESSAGE_TYPE::HOUSEKEEPING;
+	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
 			MAKE_COMMAND_ID(1);
 	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index fa41c653..544ee43c 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,9 +1,4 @@
-/**
- * @file	CommandMessage.cpp
- * @brief	This file defines the CommandMessage class.
- * @date	20.06.2013
- * @author	baetz
- */
+#include "MissionMessageTypes.h"
 
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
@@ -15,7 +10,8 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-namespace MESSAGE_TYPE {
+namespace messagetypes {
+// Implemented in config.
 void clearMissionMessage(CommandMessage* message);
 }
 
@@ -39,6 +35,10 @@ Command_t CommandMessage::getCommand() const {
 	return command;
 }
 
+uint8_t CommandMessage::getMessageType() const {
+	return getCommand() >> 8 & 0xff;
+}
+
 void CommandMessage::setCommand(Command_t command) {
 	memcpy(getData(), &command, sizeof(command));
 }
@@ -66,36 +66,36 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 }
 
 void CommandMessage::clearCommandMessage() {
-	switch((getCommand()>>8) & 0xff){
-	case  MESSAGE_TYPE::MODE_COMMAND:
+	switch(getMessageType()){
+	case messagetypes::MODE_COMMAND:
 		ModeMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::HEALTH_COMMAND:
+	case messagetypes::HEALTH_COMMAND:
 		HealthMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MODE_SEQUENCE:
+	case messagetypes::MODE_SEQUENCE:
 		ModeSequenceMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::ACTION:
+	case messagetypes::ACTION:
 		ActionMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::DEVICE_HANDLER_COMMAND:
+	case messagetypes::DEVICE_HANDLER_COMMAND:
 		DeviceHandlerMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MEMORY:
+	case messagetypes::MEMORY:
 		MemoryMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::MONITORING:
+	case messagetypes::MONITORING:
 		MonitoringMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::TM_STORE:
+	case messagetypes::TM_STORE:
 		TmStoreMessage::clear(this);
 		break;
-	case MESSAGE_TYPE::PARAMETER:
+	case messagetypes::PARAMETER:
 		ParameterMessage::clear(this);
 		break;
 	default:
-		MESSAGE_TYPE::clearMissionMessage(this);
+		messagetypes::clearMissionMessage(this);
 		break;
 	}
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index d7b6820d..a5c187f5 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -19,7 +19,7 @@ public:
 	static const ReturnValue_t UNKNOW_COMMAND = MAKE_RETURN_CODE(0x01);
 
 
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
 	//! Used internally, will be ignored
 	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
 	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
@@ -66,6 +66,7 @@ public:
 	 */
 	Command_t getCommand() const;
 
+	uint8_t getMessageType() const;
 	/**
 	 * Set the DeviceHandlerCOmmand_t of the message
 	 *
diff --git a/ipc/FwMessageTypes.h b/ipc/FwMessageTypes.h
index 1665747e..8b49c122 100644
--- a/ipc/FwMessageTypes.h
+++ b/ipc/FwMessageTypes.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_IPC_FWMESSAGETYPES_H_
 #define FRAMEWORK_IPC_FWMESSAGETYPES_H_
 
-namespace MESSAGE_TYPE {
+namespace messagetypes {
 //Remember to add new Message Types to the clearCommandMessage function!
-enum FW_MESSAGE_TYPE {
+enum FsfwMessageTypes {
 	COMMAND = 0,
 	MODE_COMMAND,
 	HEALTH_COMMAND,
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 3bd4a9d6..70c87d3c 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -17,24 +17,29 @@ public:
 	 * 			(till messageSize) to the debug output.
 	 */
 	virtual void print() = 0;
+
+	/**
+	 * @brief	Get read-only pointer to the raw buffer.
+	 * @return
+	 */
 	virtual const uint8_t* getBuffer() const = 0;
+
 	/**
 	 * @brief	This method is used to get the complete data of the message.
 	 */
 	virtual uint8_t* getBuffer() = 0;
+
 	/**
 	 * @brief	This method is used to set the sender's message queue id
 	 * 			information prior to sending the message.
-	 * @param setId	The message queue id that identifies the sending message queue.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.
-	 * @details
-	 * The method must be overwritten by child classes if size checks shall
-	 * be more strict.
-	 * @return	The default implementation returns HEADER_SIZE.
 	 */
 	virtual size_t getMinimumMessageSize() = 0;
 };
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index b6fd7309..9f9c1496 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -16,7 +16,7 @@ class FileSystemMessage {
 private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::FILE_SYSTEM_MESSAGE;
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index bcc262e9..e2c87ca3 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -9,7 +9,7 @@ class MemoryMessage {
 private:
 	MemoryMessage(); //A private ctor inhibits instantiation
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MEMORY;
+	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
 	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index f72fdeec..675c614b 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -17,7 +17,7 @@ class ModeMessage {
 private:
 	ModeMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MODE_COMMAND;
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
 	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
 	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
 	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index d2ff9b4d..793e1fbf 100644
--- a/monitoring/MonitoringMessage.h
+++ b/monitoring/MonitoringMessage.h
@@ -6,7 +6,7 @@
 
 class MonitoringMessage: public CommandMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MONITORING;
+	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
 	//Object id could be useful, but we better manage that on service level (register potential reporters).
 	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
 	virtual ~MonitoringMessage();
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 0f286675..43283294 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -9,7 +9,7 @@ class ParameterMessage {
 private:
 	ParameterMessage();
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::PARAMETER;
+	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
 	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
 	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 830cf532..61d1b628 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -7,7 +7,7 @@
 
 class ModeSequenceMessage {
 public:
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::MODE_SEQUENCE;
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
 
 	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
 	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 0883063c..bd6b2def 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -41,7 +41,7 @@ public:
 
 	static store_address_t getStoreId(const CommandMessage* cmd);
 	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = MESSAGE_TYPE::TM_STORE;
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
 	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
 	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);

From 07302e0d2aa55dc7a0ed77c595e94f3c4ae9899f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 17:44:54 +0200
Subject: [PATCH 0424/1292] removed include

---
 ipc/CommandMessage.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 544ee43c..f9e2e010 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,5 +1,3 @@
-#include "MissionMessageTypes.h"
-
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
 #include <framework/ipc/CommandMessage.h>

From b1f91439c6325593c59099cbf93d214c27820fc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 8 Jun 2020 17:50:09 +0200
Subject: [PATCH 0425/1292] deleted copy ctor taskes const ref now

---
 storagemanager/StorageAccessor.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 57c9369c..06947974 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -84,8 +84,8 @@ public:
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator= (const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;

From 8ff6506ad90965f6a42d2b03a1fa2b2638f436c9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Jun 2020 02:18:39 +0200
Subject: [PATCH 0426/1292] MessageQueue refactoring complete

---
 action/ActionHelper.cpp                | 17 ++++---
 action/CommandActionHelper.cpp         |  3 +-
 action/SimpleActionHelper.cpp          |  3 +-
 controller/ControllerBase.cpp          | 17 +++----
 datalinklayer/MapPacketExtraction.cpp  |  6 +--
 datapool/HkSwitchHelper.cpp            | 11 ++---
 datapoolglob/DataPoolAdmin.cpp         |  9 ++--
 devicehandlers/AssemblyBase.cpp        |  3 +-
 devicehandlers/DeviceHandlerBase.cpp   | 29 ++++++------
 devicehandlers/HealthDevice.cpp        |  7 +--
 health/HealthHelper.cpp                | 20 +++++----
 ipc/CommandMessage.cpp                 | 62 ++++++++++++++++++++------
 ipc/CommandMessage.h                   | 28 +++++++++---
 ipc/MessageQueueIF.h                   | 16 +++----
 ipc/MessageQueueMessage.cpp            |  2 +-
 ipc/MessageQueueMessage.h              |  2 +-
 ipc/MessageQueueMessageIF.h            | 29 +++++++++---
 ipc/MessageQueueSenderIF.h             | 16 ++-----
 memory/MemoryHelper.cpp                | 15 ++++---
 modes/ModeHelper.cpp                   | 31 +++++++------
 monitoring/LimitViolationReporter.cpp  |  3 +-
 osal/FreeRTOS/MessageQueue.cpp         | 18 ++++----
 osal/FreeRTOS/MessageQueue.h           | 19 ++++----
 osal/FreeRTOS/QueueFactory.cpp         |  2 +-
 parameters/ParameterHelper.cpp         |  9 ++--
 power/Fuse.cpp                         |  3 +-
 power/PowerSensor.cpp                  |  3 +-
 subsystem/Subsystem.cpp                | 14 +++---
 subsystem/SubsystemBase.cpp            | 43 +++++++++---------
 thermal/AbstractTemperatureSensor.cpp  | 11 ++---
 thermal/Heater.cpp                     |  9 ++--
 tmstorage/TmStoreMessage.cpp           |  2 +-
 tmstorage/TmStoreMessage.h             |  2 +-
 tmtcservices/CommandingServiceBase.cpp | 20 +++++----
 34 files changed, 293 insertions(+), 191 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 19a84d82..0df5f2d4 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -16,7 +16,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 				ActionMessage::getStoreId(command));
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		return CommandMessage::UNKNOW_COMMAND;
+		return CommandMessage::UNKNOWN_COMMAND;
 	}
 }
 
@@ -33,13 +33,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	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;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
@@ -54,7 +56,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -62,7 +65,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -71,7 +75,8 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
 	size_t maxSize = data->getSerializedSize();
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 77295401..c871a2d0 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -53,7 +53,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ActionMessage::setCommand(&command, actionId, storeId);
 	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6861fc28..f97474b1 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -36,7 +36,8 @@ void SimpleActionHelper::resetHelper() {
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (isExecuting) {
 		ipcStore->deleteData(dataAddress);
 		ActionMessage::setStepReply(&reply, actionId, 0,
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 7b11bdfa..ad0a0b97 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -56,26 +56,27 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		commandQueue->reply(&message);
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
 	}
 
 }
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 11b0792a..4ea45e89 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -16,9 +16,9 @@
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
-				packetBuffer), packetDestination(setPacketDestination), packetStore(
-				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
 	memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 844fcd90..6a923776 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -21,14 +21,15 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage message;
-	while (actionQueue->receiveMessage(&message) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			continue;
 		}
-		message.setToUnknownCommand();
-		actionQueue->reply(&message);
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
 	}
 
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 05de1eb2..6387263f 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -66,7 +66,8 @@ ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
 }
 
 void DataPoolAdmin::handleCommand() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -282,7 +283,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -294,7 +296,8 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 //identical to ParameterHelper::rejectCommand()
 void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
 	commandQueue->sendMessage(to, &reply);
 }
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index bd85d1de..a5dcad21 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -148,7 +148,8 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
 
 void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
 		HealthState health) {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
 			health);
 	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 94c9dc63..11cffc74 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -218,8 +218,9 @@ void DeviceHandlerBase::readCommandQueue() {
 	// message with 3 parameters). The full buffer is filled anyway
 	// and I could just copy the content into the other message but
 	// all I need are few additional functions the other message type offers.
-	CommandMessage cmdMessage;
-	ReturnValue_t result = commandQueue->receiveMessage(&cmdMessage);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
 	}
@@ -234,23 +235,23 @@ void DeviceHandlerBase::readCommandQueue() {
 //	}
 
 	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&cmdMessage);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			return;
 		}
 	}
 
-	result = modeHelper.handleModeCommand(&cmdMessage);
+	result = modeHelper.handleModeCommand(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = actionHelper.handleActionMessage(&cmdMessage);
+	result = actionHelper.handleActionMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = parameterHelper.handleParameterMessage(&cmdMessage);
+	result = parameterHelper.handleParameterMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -261,17 +262,17 @@ void DeviceHandlerBase::readCommandQueue() {
 //		return;
 //	}
 
-	result = handleDeviceHandlerMessage(&cmdMessage);
+	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	result = letChildHandleMessage(&cmdMessage);
+	result = letChildHandleMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
 
-	replyReturnvalueToCommand(CommandMessage::UNKNOW_COMMAND);
+	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
 
 }
 
@@ -492,12 +493,13 @@ void DeviceHandlerBase::setMode(Mode_t newMode) {
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 		uint32_t parameter) {
+	MessageQueueMessage message;
 	//This is actually the reply protocol for raw and misc DH commands.
 	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, parameter);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
+		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, parameter);
 		commandQueue->reply(&reply);
 	}
 }
@@ -767,9 +769,10 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		return;
 	}
 
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&message,
+	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
 
 //	this->DeviceHandlerCommand = CommandMessage::CMD_NONE;
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index ea0b99ff..1c9d18f6 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -13,10 +13,11 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&message);
+		healthHelper.handleHealthCommand(&command);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index fdfc0967..b23a8bd2 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -65,29 +65,31 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	if (parentQueue == 0) {
 		return;
 	}
-	CommandMessage message;
-	HealthMessage::setHealthMessage(&message, HealthMessage::HEALTH_INFO,
+	MessageQueueMessage message;
+	CommandMessage information(&message);
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &message,
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
 			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 	}
 }
 
-void HealthHelper::handleSetHealthCommand(CommandMessage* message) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(message));
-	if (message->getSender() == 0) {
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		HealthMessage::setHealthMessage(&reply,
 				HealthMessage::REPLY_HEALTH_SET);
 	} else {
-		reply.setReplyRejected(result, message->getCommand());
+		reply.setReplyRejected(result, command->getCommand());
 	}
-	if (MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index f9e2e010..cd75aee4 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -14,14 +14,26 @@ void clearMissionMessage(CommandMessage* message);
 }
 
 
-CommandMessage::CommandMessage() {
-	this->messageSize = COMMAND_MESSAGE_SIZE;
+CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
+			internalMessage(receiverMessage) {
+	if(receiverMessage == nullptr) {
+		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
+				" as the message queue message, pass the address of an actual"
+				" message!" << std::endl;
+	}
+	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
 	setCommand(CMD_NONE);
 }
 
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-		uint32_t parameter2) {
-	this->messageSize = COMMAND_MESSAGE_SIZE;
+CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
+		Command_t command, uint32_t parameter1, uint32_t parameter2):
+				internalMessage(messageToSet) {
+	if(messageToSet == nullptr) {
+		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
+				" as the message queue message, pass the address of an actual"
+				" message!" << std::endl;
+	}
+	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
@@ -29,7 +41,7 @@ CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
 
 Command_t CommandMessage::getCommand() const {
 	Command_t command;
-	memcpy(&command, getData(), sizeof(Command_t));
+	memcpy(&command, internalMessage->getData(), sizeof(Command_t));
 	return command;
 }
 
@@ -38,29 +50,35 @@ uint8_t CommandMessage::getMessageType() const {
 }
 
 void CommandMessage::setCommand(Command_t command) {
-	memcpy(getData(), &command, sizeof(command));
+	memcpy(internalMessage->getData(), &command, sizeof(command));
 }
 
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, getData() + sizeof(Command_t), sizeof(parameter1));
+	memcpy(&parameter1, internalMessage->getData() + sizeof(Command_t),
+			sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(getData() + sizeof(Command_t), &parameter1, sizeof(parameter1));
+	memcpy(internalMessage->getData() + sizeof(Command_t),
+			&parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, getData() + sizeof(Command_t) + sizeof(uint32_t),
-			sizeof(parameter2));
+	memcpy(&parameter2, internalMessage->getData() + sizeof(Command_t)
+			+ sizeof(uint32_t), sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(getData() + sizeof(Command_t) + sizeof(uint32_t), &parameter2,
-			sizeof(parameter2));
+	memcpy(internalMessage-> getData() + sizeof(Command_t) + sizeof(uint32_t),
+			&parameter2, sizeof(parameter2));
+}
+
+void CommandMessage::clear() {
+	clearCommandMessage();
 }
 
 void CommandMessage::clearCommandMessage() {
@@ -109,7 +127,7 @@ size_t CommandMessage::getMinimumMessageSize() const {
 void CommandMessage::setToUnknownCommand() {
 	Command_t initialCommand = getCommand();
 	clearCommandMessage();
-	setReplyRejected(UNKNOW_COMMAND, initialCommand);
+	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
@@ -118,3 +136,19 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 	setParameter(reason);
 	setParameter2(initialCommand);
 }
+
+MessageQueueId_t CommandMessage::getSender() const {
+	return internalMessage->getSender();
+}
+
+uint8_t* CommandMessage::getBuffer() {
+	return internalMessage->getBuffer();
+}
+
+void CommandMessage::setSender(MessageQueueId_t setId) {
+	internalMessage->setSender(setId);
+}
+
+const uint8_t* CommandMessage::getBuffer() const {
+	return internalMessage->getBuffer();
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a5c187f5..f6fd86cb 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -13,10 +13,10 @@ typedef uint16_t Command_t;
  * @brief 	Used to pass command messages between tasks
  * @author	Bastian Baetz
  */
-class CommandMessage : public MessageQueueMessage {
+class CommandMessage: public MessageQueueMessageIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOW_COMMAND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
 
 	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
@@ -31,7 +31,7 @@ public:
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
-	static const size_t COMMAND_MESSAGE_SIZE = HEADER_SIZE
+	static const size_t COMMAND_MESSAGE_SIZE = MessageQueueMessage::HEADER_SIZE
 			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
 
 	/**
@@ -40,7 +40,7 @@ public:
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage();
+	CommandMessage(MessageQueueMessage* receiverMessage);
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -49,7 +49,7 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(Command_t command,
+	CommandMessage(MessageQueueMessage* messageToSet, Command_t command,
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
@@ -58,6 +58,8 @@ public:
 	virtual ~CommandMessage() {
 	}
 
+	uint8_t * getBuffer() override;
+	const uint8_t * getBuffer() const override;
 	/**
 	 * Read the DeviceHandlerCommand_t that is stored in the message,
 	 * usually used after receiving.
@@ -66,6 +68,16 @@ public:
 	 */
 	Command_t getCommand() const;
 
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to sending the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	MessageQueueId_t getSender() const override;
+
 	uint8_t getMessageType() const;
 	/**
 	 * Set the DeviceHandlerCOmmand_t of the message
@@ -102,6 +114,7 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
+	void clear() override;
 	/**
 	 * Set the command to CMD_NONE and try to find
 	 * the correct class to handle a more detailed
@@ -129,7 +142,10 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-	size_t getMinimumMessageSize() const;
+	size_t getMinimumMessageSize() const override;
+
+private:
+	MessageQueueMessage* internalMessage;
 };
 
 
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 480019eb..500f71e2 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -15,7 +15,7 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 class MessageQueueIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueSenderIF::NO_QUEUE; //!< Ugly hack.
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
 	/**
@@ -41,7 +41,7 @@ public:
 	 * @return RETURN_OK if ok
 	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
 	 */
-	virtual ReturnValue_t reply( MessageQueueMessage* message ) = 0;
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -50,7 +50,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) = 0;
 
 	/**
@@ -65,7 +65,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) = 0;
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -95,7 +95,7 @@ public:
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault = false ) = 0;
 
 	/**
@@ -107,7 +107,7 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false ) = 0;
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
 
 	/**
 	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
@@ -118,7 +118,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
@@ -128,7 +128,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message )  = 0;
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 544d18e8..c3e1cb7a 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -51,7 +51,7 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-size_t MessageQueueMessage::getMinimumMessageSize() {
+size_t MessageQueueMessage::getMinimumMessageSize() const {
 	return this->HEADER_SIZE;
 }
 
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 93671321..29d1a869 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -132,7 +132,7 @@ public:
 	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
-	virtual size_t getMinimumMessageSize();
+	virtual size_t getMinimumMessageSize() const;
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 70c87d3c..0a6288b0 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,10 +1,23 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
 #include <cstddef>
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues.. */
+typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
 public:
+	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
+
 	virtual ~MessageQueueMessageIF() {};
 
 	/**
@@ -12,11 +25,11 @@ public:
 	 * 			size is set to zero.
 	 */
 	virtual void clear() = 0;
-	/**
-	 * @brief	This is a debug method that prints the content
-	 * 			(till messageSize) to the debug output.
-	 */
-	virtual void print() = 0;
+//	/**
+//	 * @brief	This is a debug method that prints the content
+//	 * 			(till messageSize) to the debug output.
+//	 */
+//	virtual void print() = 0;
 
 	/**
 	 * @brief	Get read-only pointer to the raw buffer.
@@ -37,11 +50,13 @@ public:
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
 
+	virtual MessageQueueId_t getSender() const = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.
 	 */
-	virtual size_t getMinimumMessageSize() = 0;
+	virtual size_t getMinimumMessageSize() const = 0;
 };
 
 
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index ae66cd12..3172454f 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,22 +1,11 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-class MessageQueueMessage;
-
-
-//TODO: Actually, the definition of this ID to be a uint32_t is not ideal and breaks layering.
-//However, it is difficult to keep layering, as the ID is stored in many places and sent around in
-//MessageQueueMessage.
-//Ideally, one would use the (current) object_id_t only, however, doing a lookup of queueIDs for every
-//call does not sound ideal.
-//In a first step, I'll circumvent the issue by not touching it, maybe in a second step.
-//This also influences Interface design (getCommandQueue) and some other issues..
-typedef uint32_t MessageQueueId_t;
 
 class MessageQueueSenderIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
 
 	virtual ~MessageQueueSenderIF() {}
 
@@ -26,7 +15,8 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = MessageQueueSenderIF::NO_QUEUE,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	MessageQueueSenderIF() {}
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index de609252..2c384651 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -51,14 +51,16 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		break;
 	default:
 		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
 		return;
 	}
 	//Only reached on success
-	CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	MessageQueueMessage message;
+	CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
 	queueToUse->sendMessage(lastSender, &reply);
 	ipcStore->deleteData(ipcAddress);
 }
@@ -66,7 +68,8 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size) {
 	busy = false;
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -151,7 +154,8 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 		completeLoad(returnCode, p_data, size, dataPointer);
 	} else {
 		//At least inform sender.
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
@@ -169,7 +173,8 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 				reservedSpaceInIPC);
 		completeDump(returnCode, dataPointer, size);
 	} else {
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
 		queueToUse->sendMessage(lastSender, &reply);
 	}
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 66726772..b79082af 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -11,31 +11,32 @@ ModeHelper::~ModeHelper() {
 
 }
 
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
-	CommandMessage reply;
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	Mode_t mode;
 	Submode_t submode;
-	switch (message->getCommand()) {
+	switch (command->getCommand()) {
 	case ModeMessage::CMD_MODE_COMMAND_FORCED:
 		forced = true;
 		/* NO BREAK falls through*/
 	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(message);
-		submode = ModeMessage::getSubmode(message);
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
 		uint32_t timeout;
 		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 					owner->getCommandQueue());
 			break;
 		}
 		//Free to start transition
-		theOneWhoCommandedAMode = message->getSender();
+		theOneWhoCommandedAMode = command->getSender();
 		commandedMode = mode;
 		commandedSubmode = submode;
 
-		if ((parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 				&& (theOneWhoCommandedAMode != parentQueueId)) {
 			owner->setToExternalControl();
 		}
@@ -48,7 +49,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* message) {
 		owner->getMode(&mode, &submode);
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
-		MessageQueueSenderIF::sendMessage(message->getSender(), &reply,
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 				owner->getCommandQueue());
 	}
 		break;
@@ -73,13 +74,14 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
 	sendModeReplyMessage(ownerMode, ownerSubmode);
 	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueSenderIF::NO_QUEUE;
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
 }
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueSenderIF::NO_QUEUE)
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
 		{
@@ -99,9 +101,10 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 
 void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueSenderIF::NO_QUEUE)
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 	{
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 234a0bff..1378d754 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -31,7 +31,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	CommandMessage report;
+	MessageQueueMessage message;
+	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
 	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 0a579296..8c6ec80b 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -25,21 +25,21 @@ void MessageQueue::switchSystemContext(CallContext callContext) {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return NO_REPLY_PARTNER;
@@ -47,7 +47,7 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
 			ignoreFault, callContext);
@@ -69,7 +69,7 @@ ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	if(status == HasReturnvaluesIF::RETURN_OK) {
@@ -78,7 +78,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){
@@ -120,7 +120,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 81b4c186..6165c1cf 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -85,14 +85,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -100,7 +100,7 @@ public:
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
@@ -113,8 +113,9 @@ public:
 	 * 					This variable is set to zero by default.
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false );
 
 	/**
 	 * @brief	The sendToDefault method sends a queue message to the default destination.
@@ -123,7 +124,7 @@ public:
 	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 
 	/**
@@ -133,7 +134,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -144,7 +145,7 @@ public:
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -191,7 +192,7 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 372d0d41..beb4969b 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,7 +7,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e0756882..8b91020f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -102,7 +102,8 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -123,8 +124,10 @@ ReturnValue_t ParameterHelper::initialize() {
 	}
 }
 
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason, Command_t initialCommand) {
-	CommandMessage reply;
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
 	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index eee91984..a80a111f 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -163,7 +163,8 @@ void Fuse::setAllMonitorsToUnchecked() {
 }
 
 void Fuse::checkCommandQueue() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 5433acc9..b1aea270 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -74,7 +74,8 @@ void PowerSensor::setAllMonitorsToUnchecked() {
 }
 
 void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 52f2c474..d774b4d5 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -309,7 +309,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
 		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
 		commandQueue->reply(&reply);
@@ -317,7 +318,8 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
 		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
+		MessageQueueMessage message;
+		CommandMessage reply(&message);
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
 		commandQueue->reply(&reply);
@@ -330,11 +332,12 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 }
 
 void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	MessageQueueMessage message;
 	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, 0);
 		commandQueue->reply(&reply);
 	}
 }
@@ -617,7 +620,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	for (uint8_t i = 0; i < count; i++) {
 		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
 	}
-	CommandMessage reply;
+	MessageQueueMessage message;
+	CommandMessage reply(&message);
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
 	if (commandQueue->reply(&reply) != RETURN_OK) {
 		IPCStore->deleteData(address);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 6df0b64f..5527f215 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -9,7 +9,7 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
 				setObjectId), modeHelper(this), parentId(parent) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			CommandMessage::MAX_MESSAGE_SIZE);
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 SubsystemBase::~SubsystemBase() {
@@ -77,8 +77,8 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 }
 
 void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
@@ -100,17 +100,17 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 
 		if (healthHelper.healthTable->hasHealth(object)) {
 			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&message,
+				ModeMessage::setModeMessage(&command,
 						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
 						SUBMODE_NONE);
 			} else {
 				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&message,
+					ModeMessage::setModeMessage(&command,
 							ModeMessage::CMD_MODE_COMMAND_FORCED,
 							tableIter.value->getMode(), submodeToCommand);
 				} else {
 					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&message,
+						ModeMessage::setModeMessage(&command,
 								ModeMessage::CMD_MODE_COMMAND,
 								tableIter.value->getMode(), submodeToCommand);
 					} else {
@@ -119,12 +119,12 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 				}
 			}
 		} else {
-			ModeMessage::setModeMessage(&message, ModeMessage::CMD_MODE_COMMAND,
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
 					tableIter.value->getMode(), submodeToCommand);
 		}
 
-		if ((iter->second.mode == ModeMessage::getMode(&message))
-				&& (iter->second.submode == ModeMessage::getSubmode(&message))
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
 				&& !modeHelper.isForced()) {
 			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
 		}
@@ -297,7 +297,8 @@ void SubsystemBase::setToExternalControl() {
 void SubsystemBase::announceMode(bool recursive) {
 	triggerEvent(MODE_INFO, mode, submode);
 	if (recursive) {
-		CommandMessage command;
+		MessageQueueMessage message;
+		CommandMessage command(&message);
 		ModeMessage::setModeMessage(&command,
 				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
 		commandAllChildren(&command);
@@ -306,31 +307,33 @@ void SubsystemBase::announceMode(bool recursive) {
 
 void SubsystemBase::checkCommandQueue() {
 	ReturnValue_t result;
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 
-	for (result = commandQueue->receiveMessage(&message); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&message)) {
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
 
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = modeHelper.handleModeCommand(&message);
+		result = modeHelper.handleModeCommand(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleModeReply(&message);
+		result = handleModeReply(&command);
 		if (result == RETURN_OK) {
 			continue;
 		}
 
-		result = handleCommandMessage(&message);
+		result = handleCommandMessage(&command);
 		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOW_COMMAND,
-					message.getCommand());
+			MessageQueueMessage message;
+			CommandMessage reply(&message);
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
 			replyToCommand(&reply);
 		}
 	}
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index be143410..759af87e 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -44,18 +44,19 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		result = parameterHelper.handleParameterMessage(&message);
+		result = parameterHelper.handleParameterMessage(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		message.setToUnknownCommand();
+		command.setToUnknownCommand();
 		commandQueue->reply(&message);
 	}
 }
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 29daa15d..6e191fc1 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -279,14 +279,15 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	CommandMessage message;
-	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	MessageQueueMessage message;
+	CommandMessage command(&message);
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&message);
+		result = healthHelper.handleHealthCommand(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			return;
 		}
-		parameterHelper.handleParameterMessage(&message);
+		parameterHelper.handleParameterMessage(&command);
 	}
 }
 
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 4509ba91..669ecc0e 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -74,7 +74,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
 	case DELETE_STORE_CONTENT_BLOCKS:
 	case DOWNLINK_STORE_CONTENT_BLOCKS:
 	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(UNKNOW_COMMAND);
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
 		cmd->setParameter(0);
 		cmd->setParameter2(0);
 		break;
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index bd6b2def..93c23e40 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -5,7 +5,7 @@
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tmstorage/TmStorePackets.h>
 #include <framework/objectmanager/SystemObjectIF.h>
-class TmStoreMessage: public CommandMessage {
+class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
 			bool setEnabled);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index adc9400f..a4fc1110 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -77,7 +77,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply, nextCommand;
+	MessageQueueMessage replyMessage;
+	CommandMessage reply(&replyMessage);
+	MessageQueueMessage nextCommandMessage;
+	CommandMessage nextCommand(&nextCommandMessage);
 	ReturnValue_t result, sendResult = RETURN_OK;
 	bool isStep = false;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
@@ -268,16 +271,17 @@ void CommandingServiceBase::startExecution(
 		typename FixedMap<MessageQueueId_t,
 				CommandingServiceBase::CommandInfo>::Iterator *iter) {
 	ReturnValue_t result, sendResult = RETURN_OK;
-	CommandMessage message;
+	MessageQueueMessage message;
+	CommandMessage command(&message);
 	(*iter)->subservice = storedPacket->getSubService();
-	result = prepareCommand(&message, (*iter)->subservice,
+	result = prepareCommand(&command, (*iter)->subservice,
 			storedPacket->getApplicationData(),
 			storedPacket->getApplicationDataSize(), &(*iter)->state,
 			(*iter)->objectId);
 
 	switch (result) {
 	case RETURN_OK:
-		if (message.getCommand() != CommandMessage::CMD_NONE) {
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			sendResult = commandQueue->sendMessage((*iter).value->first,
 					&message);
 		}
@@ -286,20 +290,20 @@ void CommandingServiceBase::startExecution(
 			(*iter)->step = 0;
 //			(*iter)->state = 0;
 			(*iter)->subservice = storedPacket->getSubService();
-			(*iter)->command = message.getCommand();
+			(*iter)->command = command.getCommand();
 			(*iter)->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
 			(*iter)->tcInfo.tcPacketId = storedPacket->getPacketId();
 			(*iter)->tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			message.clearCommandMessage();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
 	case EXECUTION_COMPLETE:
-		if (message.getCommand() != CommandMessage::CMD_NONE) {
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			//Fire-and-forget command.
 			sendResult = commandQueue->sendMessage((*iter).value->first,
 					&message);
@@ -310,7 +314,7 @@ void CommandingServiceBase::startExecution(
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			message.clearCommandMessage();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}

From 47aa9ddcc382393279c0a769e51e7d732cf25a35 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 9 Jun 2020 02:46:19 +0200
Subject: [PATCH 0427/1292] doc for mqm improved

---
 ipc/CommandMessage.cpp      |   8 +++
 ipc/CommandMessage.h        |  56 +++++++++++--------
 ipc/MessageQueueMessage.h   | 107 +++++++++++++++++++++---------------
 ipc/MessageQueueMessageIF.h |  28 +++++++---
 4 files changed, 127 insertions(+), 72 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index cd75aee4..44424e02 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -152,3 +152,11 @@ void CommandMessage::setSender(MessageQueueId_t setId) {
 const uint8_t* CommandMessage::getBuffer() const {
 	return internalMessage->getBuffer();
 }
+
+uint8_t* CommandMessage::getData() {
+	return internalMessage->getData();
+}
+
+const uint8_t* CommandMessage::getData() const {
+	return internalMessage->getData();
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index f6fd86cb..772bd774 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,16 +1,25 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
+#include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 #include <config/ipc/MissionMessageTypes.h>
 
-#include <framework/ipc/MessageQueueMessage.h>
+
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
 /**
- * @brief 	Used to pass command messages between tasks
+ * @brief 	Used to pass command messages between tasks. Primary message type
+ * 			for IPC. Contains sender, 2-byte command field, and 2 4-byte
+ * 			parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * MessageQueueMessage by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
  * @author	Bastian Baetz
  */
 class CommandMessage: public MessageQueueMessageIF {
@@ -53,13 +62,10 @@ public:
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
-	 * Default Destructor
+	 * @brief 	Default Destructor
 	 */
-	virtual ~CommandMessage() {
-	}
+	virtual ~CommandMessage() {}
 
-	uint8_t * getBuffer() override;
-	const uint8_t * getBuffer() const override;
 	/**
 	 * Read the DeviceHandlerCommand_t that is stored in the message,
 	 * usually used after receiving.
@@ -68,53 +74,54 @@ public:
 	 */
 	Command_t getCommand() const;
 
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to sending the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
+	/*
+	 * MessageQueueMessageIF functions, which generally just call the
+	 * respective functions of the internal message
 	 */
+	uint8_t * getBuffer() override;
+	const uint8_t * getBuffer() const override;
 	void setSender(MessageQueueId_t setId) override;
-
 	MessageQueueId_t getSender() const override;
+	uint8_t * getData() override;
+	const uint8_t* getData() const override;
+	size_t getMinimumMessageSize() const override;
 
+	/**
+	 * Extract message ID, which is the first byte of the command ID.
+	 * @return
+	 */
 	uint8_t getMessageType() const;
 	/**
-	 * Set the DeviceHandlerCOmmand_t of the message
-	 *
+	 * Set the command type of the message
 	 * @param the Command to be sent
 	 */
 	void setCommand(Command_t command);
 
 	/**
 	 * Get the first parameter of the message
-	 *
 	 * @return the first Parameter of the message
 	 */
 	uint32_t getParameter() const;
 
 	/**
 	 * Set the first parameter of the message
-	 *
 	 * @param the first parameter of the message
 	 */
 	void setParameter(uint32_t parameter1);
 
 	/**
 	 * Get the second parameter of the message
-	 *
 	 * @return the second Parameter of the message
 	 */
 	uint32_t getParameter2() const;
 
 	/**
 	 * Set the second parameter of the message
-	 *
 	 * @param the second parameter of the message
 	 */
 	void setParameter2(uint32_t parameter2);
 
-	void clear() override;
+
 	/**
 	 * Set the command to CMD_NONE and try to find
 	 * the correct class to handle a more detailed
@@ -126,6 +133,7 @@ public:
 	 *
 	 */
 	void clearCommandMessage();
+	void clear() override;
 
 	/**
 	 * check if a message was cleared
@@ -134,7 +142,6 @@ public:
 	 */
 	bool isClearedCommandMessage();
 
-
 	/**
 	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
 	 * Is needed quite often, so we better code it once only.
@@ -142,9 +149,14 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-	size_t getMinimumMessageSize() const override;
 
 private:
+	/**
+	 * @brief 	Pointer to the message containing the data.
+	 * @details
+	 * The command message does not actually own the memory containing a
+	 * message, it just oprates on it via a pointer to a message queue message.
+	 */
 	MessageQueueMessage* internalMessage;
 };
 
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 29d1a869..bee39ae6 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUEMESSAGE_H_
-#define MESSAGEQUEUEMESSAGE_H_
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
@@ -8,7 +8,6 @@
 /**
  *	@brief		This class is the representation and data organizer
  *				for interprocess messages.
- *
  *	@details
  *	To facilitate and standardize interprocess communication, this class was
  *	created to handle a lightweight "interprocess message protocol".
@@ -28,12 +27,14 @@ class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
-	 * @details	The messageSize attribute is set to the header's size and the
-	 * 			whole content is set to zero.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
 	 */
 	MessageQueueMessage();
 	/**
-	 * @brief	With this constructor the class is initialized with the given content.
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
 	 * @details
 	 * If the passed message size fits into the buffer, the passed data is
 	 * copied to the internal buffer and the messageSize information is set.
@@ -46,7 +47,14 @@ public:
 	MessageQueueMessage(uint8_t* data, size_t size);
 
 	/**
-	 * @brief	The size information of each message is stored in this attribute.
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
 	 * @details
 	 * It is public to simplify usage and to allow for passing the size
 	 * address as a pointer. Care must be taken when inheriting from this class,
@@ -59,19 +67,26 @@ public:
 	 */
 	size_t messageSize;
 	/**
-	 * @brief	This constant defines the maximum size of the data content, excluding the header.
-	 * @details	It may be changed if necessary, but in general should be kept as small as possible.
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
 	/**
-	 * @brief	This constants defines the size of the header, which is added to every message.
+	 * @brief	This constants defines the size of the header,
+	 * 			which is added to every message.
 	 */
 	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 	/**
-	 * @brief	This constant defines the maximum total size in bytes of a sent message.
-	 * @details	It is the sum of the maximum data and the header size. Be aware that this constant
-	 * 			is used to define the buffer sizes for every message queue in the system. So, a change
-	 * 			here may have significant impact on the required resources.
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
 	 */
 	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
 	/**
@@ -81,58 +96,64 @@ public:
 	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
-	 * @brief	This is the internal buffer that contains the actual message data.
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
 	 */
 	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
 public:
 	/**
-	 * @brief	As no memory is allocated in this class, the destructor is empty.
+	 * @brief	This method is used to get the complete data of the message.
 	 */
-	virtual ~MessageQueueMessage();
+	const uint8_t* getBuffer() const override;
 	/**
 	 * @brief	This method is used to get the complete data of the message.
 	 */
-	const uint8_t* getBuffer() const;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer();
+	uint8_t* getBuffer() override;
 	/**
 	 * @brief	This method is used to fetch the data content of the message.
-	 * @details It shall be used by child classes to add data at the right position.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
 	 */
-	const uint8_t* getData() const;
+	const uint8_t* getData() const override;
 	/**
 	 * @brief	This method is used to fetch the data content of the message.
-	 * @details It shall be used by child classes to add data at the right position.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
 	 */
-	uint8_t* getData();
+	uint8_t* getData() override;
 	/**
-	 * @brief	This method is used to extract the sender's message queue id information from a
-	 * 			received message.
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
 	 */
-	MessageQueueId_t getSender() const;
+	MessageQueueId_t getSender() const override;
 	/**
-	 * @brief	With this method, the whole content and the message size is set to zero.
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
 	 */
-	void clear();
+	void clear() override;
+
 	/**
-	 * @brief	This is a debug method that prints the content (till messageSize) to the debug output.
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
 	 */
-	void print();
+	void setSender(MessageQueueId_t setId) override;
 	/**
-	 * @brief	This method is used to set the sender's message queue id information prior to
-	 * 			sending the message.
-	 * @param setId	The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId);
-	/**
-	 * @brief	This helper function is used by the MessageQueue class to check the size of an
-	 * 			incoming message.
-	 * @details	The method must be overwritten by child classes if size checks shall be more strict.
+	 * @brief	This helper function is used by the MessageQueue class to check
+	 * 			the size of an incoming message.
+	 * @details
+	 * The method must be overwritten by child classes if size
+	 * checks shall be more strict.
 	 * @return	The default implementation returns HEADER_SIZE.
 	 */
-	virtual size_t getMinimumMessageSize() const;
+	virtual size_t getMinimumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content
+	 * 			(till messageSize) to the debug output.
+	 */
+	void print();
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 0a6288b0..197a26fd 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -11,7 +11,9 @@
  * lookup of queueIDs for every call does not sound ideal.
  * In a first step, I'll circumvent the issue by not touching it,
  * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues.. */
+ * (getCommandQueue) and some other issues..
+ */
+
 typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
@@ -25,14 +27,9 @@ public:
 	 * 			size is set to zero.
 	 */
 	virtual void clear() = 0;
-//	/**
-//	 * @brief	This is a debug method that prints the content
-//	 * 			(till messageSize) to the debug output.
-//	 */
-//	virtual void print() = 0;
 
 	/**
-	 * @brief	Get read-only pointer to the raw buffer.
+	 * @brief	Get read-only pointer to the complete data of the message.
 	 * @return
 	 */
 	virtual const uint8_t* getBuffer() const = 0;
@@ -50,8 +47,25 @@ public:
 	 */
 	virtual void setSender(MessageQueueId_t setId) = 0;
 
+	/**
+	 * @brief	This method is used to extract the sender's message queue id
+	 * 			information from a received message.
+	 */
 	virtual MessageQueueId_t getSender() const = 0;
 
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	virtual const uint8_t* getData() const = 0;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	virtual uint8_t* getData() = 0;
+
 	/**
 	 * @brief	This helper function is used by the MessageQueue class to
 	 * 			check the size of an incoming message.

From 3277d199ac166db242ff1fb7b5edfab6fa2964ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 01:07:50 +0200
Subject: [PATCH 0428/1292] linux mq update

---
 osal/linux/MessageQueue.cpp | 102 +++++++++++++++++++++---------------
 1 file changed, 60 insertions(+), 42 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 86d1e0d9..a9c140c6 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -56,16 +56,23 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
 		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
 			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
 			// This happens if the msg_max value is not large enough
 			// It is ignored if the executable is run in privileged mode.
-			// Run the unlockRealtime script or grant the mode manully by using:
+			// Run the unlockRealtime script or grant the mode manually by using:
 			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Permanent solution (EventManager has mq depth of 80):
-			// echo msg_max | sudo tee /proc/sys/fs/mqueue/msg_max
+			// Persistent solution for session:
+			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			// Permanent solution:
+			// sudo nano /etc/sysctl.conf
+			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			// Apply changes with: sudo sysctl -p
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
@@ -75,24 +82,22 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 	case(EEXIST): {
 		// An error occured during open
 		// We need to distinguish if it is caused by an already created queue
-		if (errno == EEXIST) {
-			//There's another queue with the same name
-			//We unlink the other queue
-			int status = mq_unlink(name);
-			if (status != 0) {
-				sif::error << "mq_unlink Failed with status: " << strerror(errno)
-											<< std::endl;
-			}
-			else {
-				// Successful unlinking, try to open again
-				mqd_t tempId = mq_open(name,
-						O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-						S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-				if (tempId != -1) {
-					//Successful mq_open
-					this->id = tempId;
-					return HasReturnvaluesIF::RETURN_OK;
-				}
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
 			}
 		}
 		break;
@@ -150,12 +155,13 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		//Success but no message received
 		return MessageQueueIF::EMPTY;
 	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
 		memset(message->getData(), 0, message->MAX_DATA_SIZE);
 		switch(errno){
 		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages currently on the specified queue.
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
@@ -165,9 +171,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * The pointer to the buffer for storing the received message, msg_ptr, is NULL.
-			 * * The number of bytes requested, msg_len is less than zero.
-			 * * msg_len is anything other than the mq_msgsize of the specified queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't been set in the queue's mq_flags.
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
@@ -175,8 +184,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 		case EMSGSIZE:
 			/*
 			 * This value indicates one of the following:
-			 * * the QNX extended option MQ_READBUF_DYNAMIC hasn't been set, and the given msg_len is shorter than the mq_msgsize for the given queue.
-			 * * the extended option MQ_READBUF_DYNAMIC has been set, but the given msg_len is too short for the message that would have been received.
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
 			 */
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
@@ -224,9 +237,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * mq_attr is NULL.
-			 * * MQ_MULT_NOTIFY had been set for this queue, and the given mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 *
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
 			 */
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
@@ -275,7 +289,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
 		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
 						objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != NULL) {
 				internalErrorReporter->queueMessageNotSent();
@@ -283,10 +298,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		}
 		switch(errno){
 		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the MQ_NONBLOCK flag was set in its attributes, and the specified queue is full.
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
 			return MessageQueueIF::FULL;
 		case EBADF:
-			//mq_des doesn't represent a valid message queue descriptor, or mq_des wasn't opened for writing.
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
 					   << " sent from " << sentFrom << std::endl;
@@ -296,13 +314,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EINVAL:
 			/*
 			 * This value indicates one of the following:
-			 * * msg_ptr is NULL.
-			 * * msg_len is negative.
-			 * * msg_prio is greater than MQ_PRIO_MAX.
-			 * * msg_prio is less than 0.
-			 * * MQ_PRIO_RESTRICT is set in the mq_attr of mq_des,
-			 *   and msg_prio is greater than the priority of the calling process.
-			 * */
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
 			/*NO BREAK*/

From 20e3b3c0e2eeec791f2f7c25e1893808af28c0eb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 01:10:16 +0200
Subject: [PATCH 0429/1292] 0 replaced by MQIF::NO_QUEUE

---
 osal/linux/MessageQueue.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a9c140c6..a0749ded 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -9,8 +9,9 @@
 #include <errno.h>
 
 
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize): id(0),
-		lastPartner(0), defaultDestination(NO_QUEUE) {
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;

From 52c887925fe68f0729db72925c24e3b703ca600b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 20:53:28 +0200
Subject: [PATCH 0430/1292] iomanip include

---
 objectmanager/ObjectManager.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index cfdf6562..1c54355a 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,5 +1,6 @@
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <iomanip>
 #include <cstdlib>
 
 ObjectManager::ObjectManager( void (*setProducer)() ):

From 606957dc243f31d18d80f51885f4684fc134186b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 21:26:45 +0200
Subject: [PATCH 0431/1292] PSB update

---
 tmtcservices/PusServiceBase.cpp | 74 +++++++++++++++++++--------------
 tmtcservices/PusServiceBase.h   |  8 ++--
 2 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index c27defe6..f5d1e30b 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -9,10 +9,11 @@
 object_id_t PusServiceBase::packetSource = 0;
 object_id_t PusServiceBase::packetDestination = 0;
 
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId), errorParameter1(
-				0), errorParameter2(0), requestQueue(NULL) {
-	requestQueue = QueueFactory::instance()->createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
 }
 
 PusServiceBase::~PusServiceBase() {
@@ -20,51 +21,60 @@ PusServiceBase::~PusServiceBase() {
 }
 
 ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::handleRequestQueue() {
 	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: " << std::hex << this->requestQueue.getId()
-		// << std::dec << " returned: " << status << std::endl;
+		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: "
+		//      << std::hex << this->requestQueue.getId()
+		//      << std::dec << " returned: " << status << std::endl;
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
-			//	info << "Service " << (uint16_t) this->serviceId << ": new packet!" << std::endl;
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
 
-			ReturnValue_t return_code = this->handleRequest(currentPacket.getSubService());
+			result = this->handleRequest(currentPacket.getSubService());
 
-			// debug << "Service " << (uint16_t)this->serviceId << ": handleRequest returned: " << (int)return_code << std::endl;
-			if (return_code == RETURN_OK) {
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
 						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			} else {
+			}
+			else {
 				this->verifyReporter.sendFailureReport(
 						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						return_code, 0, errorParameter1, errorParameter2);
+						result, 0, errorParameter1, errorParameter2);
 			}
 			this->currentPacket.deletePacket();
 			errorParameter1 = 0;
 			errorParameter2 = 0;
-		} else if (status == MessageQueueIF::EMPTY) {
+		}
+		else if (status == MessageQueueIF::EMPTY) {
 			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId << ": no new packet." << std::endl;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
 			break;
-		} else {
-
+		}
+		else {
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< (uint16_t) this->serviceId
 					<< ": Error receiving packet. Code: " << std::hex << status
 					<< std::dec << std::endl;
 		}
 	}
-	ReturnValue_t return_code = this->performService();
-	if (return_code == RETURN_OK) {
-		return RETURN_OK;
-	} else {
-
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) return_code
-				<< std::endl;
-		return RETURN_FAILED;
-	}
 }
 
 uint16_t PusServiceBase::getIdentifier() {
@@ -80,19 +90,21 @@ ReturnValue_t PusServiceBase::initialize() {
 	if (result != RETURN_OK) {
 		return result;
 	}
-	AcceptsTelemetryIF* dest_service = objectManager->get<AcceptsTelemetryIF>(
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
 			packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((dest_service != NULL) && (distributor != NULL)) {
+	if ((destService != nullptr) && (distributor != nullptr)) {
 		this->requestQueue->setDefaultDestination(
-				dest_service->getReportReceptionQueue());
+				destService->getReportReceptionQueue());
 		distributor->registerService(this);
 		return RETURN_OK;
-	} else {
+	}
+	else {
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< (uint32_t) this->serviceId << ": Configuration error."
-				<< " Make sure packetSource and packetDestination are defined correctly" << std::endl;
+				<< " Make sure packetSource and packetDestination are defined "
+			       "correctly" << std::endl;
 		return RETURN_FAILED;
 	}
 }
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index dbb1754c..5f741410 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -97,16 +97,16 @@ protected:
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint32_t errorParameter1;
+	uint32_t errorParameter1 = 0;
 	/**
 	 * One of two error parameters for additional error information.
 	 */
-	uint32_t errorParameter2;
+	uint32_t errorParameter2 = 0;
 	/**
 	 * This is a complete instance of the Telecommand reception queue of the class.
 	 * It is initialized on construction of the class.
 	 */
-	MessageQueueIF* requestQueue;
+	MessageQueueIF* requestQueue = nullptr;
 	/**
 	 * An instance of the VerificationReporter class, that simplifies sending any kind of
 	 * Verification Message to the TC Verification Service.
@@ -127,6 +127,8 @@ private:
 	 * Remember that one packet must be completely handled in one #handleRequest call.
 	 */
 	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
 };
 
 #endif /* PUSSERVICEBASE_H_ */

From 659594bac71505492c01feff182a2577f79fb1fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 21:35:47 +0200
Subject: [PATCH 0432/1292] better include guard and doc form improvement

---
 tmtcservices/PusServiceBase.h | 80 +++++++++++++++++++++--------------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 5f741410..39600c41 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,5 +1,5 @@
-#ifndef PUSSERVICEBASE_H_
-#define PUSSERVICEBASE_H_
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
@@ -9,7 +9,6 @@
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/tmtcservices/VerificationCodes.h>
 #include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 
 namespace Factory{
@@ -17,18 +16,22 @@ void setStaticFrameworkObjectIds();
 }
 
 /**
- * \defgroup pus_services PUS Service Framework
+ * @defgroup pus_services PUS Service Framework
  * These group contains all implementations of PUS Services in the OBSW.
  * Most of the Services are directly taken from the ECSS PUS Standard.
  */
 
 /**
- * \brief This class is the basis for all PUS Services, which can immediately process Telecommand Packets.
- * It manages Telecommand reception and the generation of Verification Reports. Every class that inherits
- * from this abstract class has to implement handleRequest and performService. Services that are created with this
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
  * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified on construction.
- * \ingroup pus_services
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
  */
 class PusServiceBase : public ExecutableObjectIF,
         public AcceptsTelecommandsIF,
@@ -37,49 +40,61 @@ class PusServiceBase : public ExecutableObjectIF,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**
-	 * The constructor for the class.
-	 * The passed values are set, but inter-object initialization is done in the initialize method.
-	 * @param setObjectId		The system object identifier of this Service instance.
-	 * @param set_apid			The APID the Service is instantiated for.
-	 * @param set_service_id	The Service Identifier as specified in ECSS PUS.
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
 	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId);
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
 	/**
 	 * The destructor is empty.
 	 */
 	virtual ~PusServiceBase();
 	/**
-	 * @brief The handleRequest method shall handle any kind of Telecommand Request immediately.
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
 	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the verifyReporter, but Completion
-	 * Success or Failure Reports are generated automatically after execution of this method.
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
 	 *
 	 * If a Telecommand can not be executed within one call cycle,
 	 * this Base class is not the right parent.
 	 *
-	 * The child class may add additional error information by setting #errorParameters which are
-	 * attached to the generated verification message.
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
 	 *
 	 * Subservice checking should be implemented in this method.
 	 *
-	 * @return	The returned status_code is directly taken as main error code in the Verification Report.
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
 	 * 			On success, RETURN_OK shall be returned.
 	 */
 	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
 	/**
-	 * In performService, implementations can handle periodic, non-TC-triggered activities.
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
 	 * The performService method is always called.
-	 * @return	A success or failure code that does not trigger any kind of verification message.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
 	 */
 	virtual ReturnValue_t performService() = 0;
 	/**
 	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends completion verification messages and deletes
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
 	 * the TC requests afterwards.
 	 * performService is always executed afterwards.
-	 * @return	\c RETURN_OK if the periodic performService was successful.
-	 * 			\c RETURN_FAILED else.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
 	 */
 	ReturnValue_t performOperation(uint8_t opCode);
 	virtual uint16_t getIdentifier();
@@ -103,13 +118,13 @@ protected:
 	 */
 	uint32_t errorParameter2 = 0;
 	/**
-	 * This is a complete instance of the Telecommand reception queue of the class.
-	 * It is initialized on construction of the class.
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
 	 */
 	MessageQueueIF* requestQueue = nullptr;
 	/**
-	 * An instance of the VerificationReporter class, that simplifies sending any kind of
-	 * Verification Message to the TC Verification Service.
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
 	 */
 	VerificationReporter verifyReporter;
 	/**
@@ -124,7 +139,8 @@ protected:
 private:
 	/**
 	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one #handleRequest call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
 	 */
 	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
 

From 5007041bc87e39a44284de14f465fa0478cbc2a0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:12:29 +0200
Subject: [PATCH 0433/1292] cleaned up includes and improved doc a bit

---
 tmtcservices/CommandingServiceBase.cpp |  27 +++---
 tmtcservices/CommandingServiceBase.h   | 114 ++++++++++++++-----------
 2 files changed, 76 insertions(+), 65 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index adc9400f..361baf3b 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,22 +1,21 @@
-/*
- * CommandingServiceBase.cpp
- *
- *  Created on: 28.08.2019
- *      Author: gaisser
- */
+#include <framework/tcdistribution/PUSDistributorIF.h>
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/tmtcservices/CommandingServiceBase.h>
+#include <framework/tmtcservices/TmTcMessage.h>
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcpacket/pus/TcPacketStored.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
 
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeout_seconds, object_id_t setPacketSource,
+		uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
 		object_id_t setPacketDestination, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service), timeout_seconds(
-				commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore(
-		NULL), commandQueue(NULL), requestQueue(NULL), commandMap(
-				numberOfParallelCommands), failureParameter1(0), failureParameter2(
-				0), packetSource(setPacketSource), packetDestination(
-				setPacketDestination),executingTask(NULL) {
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands), packetSource(setPacketSource),
+		packetDestination(setPacketDestination) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }
@@ -369,7 +368,7 @@ void CommandingServiceBase::checkTimeout() {
 	typename FixedMap<MessageQueueId_t,
 			CommandingServiceBase::CommandInfo>::Iterator iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeout_seconds * 1000)) < uptime) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index e79e806d..37f6891c 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,35 +1,33 @@
-#ifndef COMMANDINGSERVICEBASE_H_
-#define COMMANDINGSERVICEBASE_H_
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
-#include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
-#include <framework/serialize/SerializeAdapter.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
+#include <framework/ipc/MessageQueueIF.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
+
 #include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/timemanager/Clock.h>
+#include <framework/ipc/CommandMessage.h>
+#include <framework/container/FixedMap.h>
+#include <framework/container/FIFO.h>
+#include <framework/serialize/SerializeIF.h>
+
+class TcPacketStored;
 
 /**
- * \brief This class is the basis for all PUS Services, which have to relay Telecommands to software bus.
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
  *
- * It manages Telecommand reception and the generation of Verification Reports like PUSServiceBase.
- * Every class that inherits from this abstract class has to implement four adaption points:
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
  *   - isValidSubservice
  *   - getMessageQueueAndObject
  *   - prepareCommand
  *   - handleReply
- * \ingroup pus_services
+ * @author gaisser
+ * @ingroup pus_services
  */
 class CommandingServiceBase: public SystemObject,
 		public AcceptsTelecommandsIF,
@@ -59,7 +57,7 @@ public:
 	 */
 	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
 			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeout_seconds, object_id_t setPacketSource,
+			uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
 			object_id_t setPacketDestination, size_t queueDepth = 20);
 	virtual ~CommandingServiceBase();
 
@@ -113,8 +111,9 @@ protected:
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
 	/**
-	 * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved.
-	 * The target message queue ID can then be acquired by using the target interface.
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
 	 * @param subservice
 	 * @param tcData Application Data of TC Packet
 	 * @param tcDataLen
@@ -129,10 +128,10 @@ protected:
 			object_id_t *objectId) = 0;
 
 	/**
-	 * After the Message Queue and Object ID are determined,
-	 * the command is prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object.
-	 * It contains all necessary information for the device to execute telecommands.
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
 	 * @param message
 	 * @param subservice
 	 * @param tcData
@@ -146,25 +145,40 @@ protected:
 			uint32_t *state, object_id_t objectId) = 0;
 
 	/**
-	 * This function is responsible for the communication between the Command Service Base
-	 * and the respective PUS Commanding Service once the execution has started.
-	 * The PUS Commanding Service receives replies from the target device and forwards them by calling this function.
-	 * There are different translations of these replies to specify how the Command Service proceeds.
-	 * @param reply[out] Command Message which contains information about the command
-	 * @param previousCommand [out]
-	 * @param state
-	 * @param optionalNextCommand
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled
+	 * @param reply
+	 * This is the reply in form of a command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
 	 * @param objectId Source object ID
 	 * @param isStep Flag value to mark steps of command execution
-	 * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success
-	 *         - @c INVALID_REPLY can handle unrequested replies
-	 *         - Anything else triggers a TC verification failure
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * @param reply
+	 */
+	virtual void handleUnrequestedReply(CommandMessage *reply);
+
+	virtual void doPeriodicOperation();
+
+
 	struct CommandInfo {
 		struct tcInfo {
 			uint8_t ackFlags;
@@ -184,33 +198,35 @@ protected:
 
 	const uint8_t service;
 
-	const uint16_t timeout_seconds;
+	const uint16_t timeoutSeconds;
 
-	uint8_t tmPacketCounter;
+	uint8_t tmPacketCounter = 0;
 
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
-	StorageManagerIF *TCStore;
+	StorageManagerIF *TCStore = nullptr;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
-	MessageQueueIF* requestQueue;
+	MessageQueueIF* requestQueue = nullptr;
 
 	VerificationReporter verificationReporter;
 
 	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
 
-	uint32_t failureParameter1; //!< May be set be children to return a more precise failure condition.
-	uint32_t failureParameter2; //!< May be set be children to return a more precise failure condition.
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
 
 	object_id_t packetSource;
 
 	object_id_t packetDestination;
 
 	/**
-	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
 	 */
-	PeriodicTaskIF* executingTask;
+	PeriodicTaskIF* executingTask = nullptr;
 
 	/**
 	 * @brief   Send TM data from pointer to data.
@@ -246,10 +262,6 @@ protected:
 	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
-	virtual void handleUnrequestedReply(CommandMessage *reply);
-
-	virtual void doPeriodicOperation();
-
 	void checkAndExecuteFifo(
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 

From bb9a299e33ce7429314acb58606f964613a31589 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:19:40 +0200
Subject: [PATCH 0434/1292] added back removed comments

---
 tmtcservices/CommandingServiceBase.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 37f6891c..f97eabb0 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -132,11 +132,12 @@ protected:
 	 * prepared by using an implementation specific CommandMessage type
 	 * which is sent to the target object. It contains all necessary information
 	 * for the device to execute telecommands.
-	 * @param message
-	 * @param subservice
-	 * @param tcData
-	 * @param tcDataLen
-	 * @param state
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
 	 * @param objectId Target object ID
 	 * @return
 	 */

From 3268806f75a3ea8ceaf7ce933276133d26b05719 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 10 Jun 2020 22:51:54 +0200
Subject: [PATCH 0435/1292] split up huge function to be more readable

---
 tmtcservices/CommandingServiceBase.cpp | 193 ++++++++++++++-----------
 tmtcservices/CommandingServiceBase.h   |   7 +
 2 files changed, 113 insertions(+), 87 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 361baf3b..4c557f82 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -56,7 +56,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			objectManager->get<AcceptsTelemetryIF>(packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((packetForwarding == NULL) && (distributor == NULL)) {
+	if (packetForwarding == nullptr or distributor == nullptr) {
 		return RETURN_FAILED;
 	}
 
@@ -67,7 +67,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
-	if ((IPCStore == NULL) || (TCStore == NULL)) {
+	if (IPCStore == nullptr or TCStore == nullptr) {
 		return RETURN_FAILED;
 	}
 
@@ -76,97 +76,116 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply, nextCommand;
-	ReturnValue_t result, sendResult = RETURN_OK;
-	bool isStep = false;
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		isStep = false;
-		typename FixedMap<MessageQueueId_t,
-				CommandingServiceBase::CommandInfo>::Iterator iter;
-		if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
-			handleUnrequestedReply(&reply);
-			continue;
-		}
-		if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
-			handleUnrequestedReply(&reply);
-			continue;
-		}
-		nextCommand.setCommand(CommandMessage::CMD_NONE);
-		result = handleReply(&reply, iter->command, &iter->state, &nextCommand,
-				iter->objectId, &isStep);
-		switch (result) {
-		case EXECUTION_COMPLETE:
-		case RETURN_OK:
-		case NO_STEP_MESSAGE:
-			iter->command = nextCommand.getCommand();
-			if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
-				sendResult = commandQueue->sendMessage(reply.getSender(),
-						&nextCommand);
-			}
-			if (sendResult == RETURN_OK) {
-				if (isStep) {
-					if (result != NO_STEP_MESSAGE) {
-						verificationReporter.sendSuccessReport(
-								TC_VERIFY::PROGRESS_SUCCESS,
-								iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-								iter->tcInfo.tcSequenceControl, ++iter->step);
-					}
-				} else {
-					verificationReporter.sendSuccessReport(
-							TC_VERIFY::COMPLETION_SUCCESS,
-							iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, 0);
-					checkAndExecuteFifo(&iter);
-				}
-			} else {
-				if (isStep) {
-					nextCommand.clearCommandMessage();
-					verificationReporter.sendFailureReport(
-							TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-							iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, sendResult,
-							++iter->step, failureParameter1, failureParameter2);
-				} else {
-					nextCommand.clearCommandMessage();
-					verificationReporter.sendFailureReport(
-							TC_VERIFY::COMPLETION_FAILURE,
-							iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-							iter->tcInfo.tcSequenceControl, sendResult, 0,
-							failureParameter1, failureParameter2);
-				}
-				failureParameter1 = 0;
-				failureParameter2 = 0;
-				checkAndExecuteFifo(&iter);
-			}
-			break;
-		case INVALID_REPLY:
-			//might be just an unrequested reply at a bad moment
-			handleUnrequestedReply(&reply);
-			break;
-		default:
-			if (isStep) {
-				verificationReporter.sendFailureReport(
-						TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-						iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-						result, ++iter->step, failureParameter1,
-						failureParameter2);
-			} else {
-				verificationReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-						iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-						result, 0, failureParameter1, failureParameter2);
-			}
-			failureParameter1 = 0;
-			failureParameter2 = 0;
-			checkAndExecuteFifo(&iter);
-			break;
-		}
-
+		handleCommandMessage(reply);
 	}
 }
 
 
+void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter;
+	if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
+		handleUnrequestedReply(&reply);
+		return;
+	}
+	if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
+		handleUnrequestedReply(&reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(&reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(&reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(&iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage& nextCommand, CommandMessage& reply,
+		bool& isStep) {
+	iter->command = nextCommand.getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply.getSender(),
+				&nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(&iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand.clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand.clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(&iter);
+	}
+}
+
 void CommandingServiceBase::handleRequestQueue() {
 	TmTcMessage message;
 	ReturnValue_t result;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index f97eabb0..9a68a2d3 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -267,6 +267,9 @@ protected:
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 
 private:
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+			CommandingServiceBase::CommandInfo>::Iterator;
+
 	/**
 	 * This method handles internal execution of a command,
 	 * once it has been started by @sa{startExecution()} in the Request Queue handler.
@@ -298,6 +301,10 @@ private:
 	void startExecution(TcPacketStored *storedPacket,
 			typename FixedMap<MessageQueueId_t, CommandInfo>::Iterator *iter);
 
+	void handleCommandMessage(CommandMessage& reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage& nextCommand,CommandMessage& reply, bool& isStep);
+
 	void checkTimeout();
 };
 

From a9c7ad84c8b93c39021194e99306e023432b4ee0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 02:03:18 +0200
Subject: [PATCH 0436/1292] added new interface to host and linux osal

---
 ipc/CommandMessage.cpp      |  8 ++++++++
 ipc/CommandMessage.h        |  2 ++
 ipc/MessageQueueMessage.cpp |  8 ++++++++
 ipc/MessageQueueMessage.h   |  4 ++++
 ipc/MessageQueueMessageIF.h | 12 ++++++++++++
 osal/host/MessageQueue.cpp  | 30 ++++++++++++++++++++----------
 osal/host/MessageQueue.h    | 16 ++++++++--------
 osal/host/QueueFactory.cpp  |  2 +-
 osal/linux/MessageQueue.cpp | 25 +++++++++++++------------
 osal/linux/MessageQueue.h   | 21 +++++++++++++--------
 osal/linux/QueueFactory.cpp |  2 +-
 11 files changed, 90 insertions(+), 40 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 44424e02..7d2ecc9b 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -160,3 +160,11 @@ uint8_t* CommandMessage::getData() {
 const uint8_t* CommandMessage::getData() const {
 	return internalMessage->getData();
 }
+
+size_t CommandMessage::getMessageSize() const {
+	return COMMAND_MESSAGE_SIZE;
+}
+
+size_t CommandMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 772bd774..25d608f0 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -85,6 +85,8 @@ public:
 	uint8_t * getData() override;
 	const uint8_t* getData() const override;
 	size_t getMinimumMessageSize() const override;
+	size_t getMessageSize() const override;
+	size_t getMaximumMessageSize() const override;
 
 	/**
 	 * Extract message ID, which is the first byte of the command ID.
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index c3e1cb7a..8430a8ea 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -67,3 +67,11 @@ void MessageQueueMessage::print() {
 void MessageQueueMessage::clear() {
 	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
 }
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+	return this->MAX_MESSAGE_SIZE;
+}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index bee39ae6..31a43f66 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -149,6 +149,10 @@ public:
 	 */
 	virtual size_t getMinimumMessageSize() const override;
 
+	virtual size_t getMessageSize() const override;
+
+	virtual size_t getMaximumMessageSize() const override;
+
 	/**
 	 * @brief	This is a debug method that prints the content
 	 * 			(till messageSize) to the debug output.
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 197a26fd..05330ce9 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -71,6 +71,18 @@ public:
 	 * 			check the size of an incoming message.
 	 */
 	virtual size_t getMinimumMessageSize() const = 0;
+
+	/**
+	 * Get message size of current message implementation.
+	 * @return
+	 */
+	virtual size_t getMessageSize() const = 0;
+
+	/**
+	 * Get maximum allowed size of current message implementation.
+	 * @return
+	 */
+	virtual size_t getMaximumMessageSize() const = 0;
 };
 
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 3e30c8ed..7af5fbd9 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -18,20 +18,20 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
@@ -40,13 +40,13 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
 			ignoreFault);
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	if(status == HasReturnvaluesIF::RETURN_OK) {
@@ -55,7 +55,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(messageQueue.empty()) {
 		return MessageQueueIF::EMPTY;
 	}
@@ -102,9 +102,9 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessage *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
-	if(message->messageSize > MessageQueueMessage::MAX_DATA_SIZE) {
+	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
 		// in MessageQueueMessage.
 		// But I will still return a failure here.
@@ -127,7 +127,17 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock, 20);
-		targetQueue->messageQueue.push(*message);
+		// not ideal, works for now though.
+		MessageQueueMessage* mqmMessage =
+				dynamic_cast<MessageQueueMessage*>(message);
+		if(message != nullptr) {
+			targetQueue->messageQueue.push(*mqmMessage);
+		}
+		else {
+			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
+					"is not MessageQueueMessage!" << std::endl;
+		}
+
 	}
 	else {
 		return MessageQueueIF::FULL;
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 619b5e91..7fc77f7a 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -77,7 +77,7 @@ public:
 	 * is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false) override;
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the
@@ -85,7 +85,7 @@ public:
 	 * queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t sendToDefault(MessageQueueMessage* message) override;
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using
@@ -93,7 +93,7 @@ public:
 	 * message received yet (i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply(MessageQueueMessage* message) override;
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a
@@ -113,7 +113,7 @@ public:
 	 * is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
 	/**
@@ -127,7 +127,7 @@ public:
 	 * sender's queue id into the message. This variable is set to zero by
 	 * default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
@@ -140,7 +140,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) override;
 
 	/**
@@ -153,7 +153,7 @@ public:
 	 * function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message) override;
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -205,7 +205,7 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 
 	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 60274c84..225bb8c7 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -7,7 +7,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index a0749ded..605dea2a 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -118,15 +118,15 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), false);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
@@ -134,21 +134,21 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	*receivedFrom = this->lastPartner;
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	unsigned int messagePriority = 0;
 	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->MAX_MESSAGE_SIZE,&messagePriority);
+			message->getMaximumMessageSize(),&messagePriority);
 	if (status > 0) {
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@@ -158,7 +158,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send
 		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+		memset(message->getData(), 0, message->getMaximumMessageSize());
 		switch(errno){
 		case EAGAIN:
 			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
@@ -259,13 +259,13 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
 
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
@@ -281,11 +281,12 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessage *message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()), message->messageSize,0);
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
 
 	//TODO: Check if we're in ISR.
 	if (result != 0) {
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 2808d36e..91066bf7 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -56,14 +56,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -71,7 +71,7 @@ public:
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -80,7 +80,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -91,7 +91,7 @@ public:
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -114,7 +114,9 @@ public:
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false );
 	/**
 	 * \brief	The sendToDefault method sends a queue message to the default destination.
 	 * \details	In all other aspects, it works identical to the sendMessage method.
@@ -122,7 +124,8 @@ public:
 	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -145,7 +148,9 @@ protected:
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE,bool ignoreFault=false);
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
 private:
 	/**
 	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 268d0b99..8bd9d52c 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,7 +9,7 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);

From 206235ed47e0b086acc06015aeb36484bfeeab76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:03:09 +0200
Subject: [PATCH 0437/1292] dataset base bugfixes

---
 datapool/DataSetBase.cpp | 10 +++++++---
 health/HealthHelper.cpp  |  2 +-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 9104c8e7..60b20f29 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -36,7 +36,7 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
-			ReturnValue_t result = readVariable(count);
+			result = readVariable(count);
 			if(result != RETURN_OK) {
 				break;
 			}
@@ -46,14 +46,15 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	}
 	else {
 		sif::error << "DataSet::read(): "
-				"Call made in wrong position." << std::endl;
+				"Call made in wrong position. Don't forget to commit"
+				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
 	return result;
 }
 
 ReturnValue_t DataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = DataSetIF::INVALID_PARAMETER_DEFINITION;
+	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() !=
@@ -62,6 +63,9 @@ ReturnValue_t DataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		result = registeredVariables[count]->readWithoutLock();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			result = INVALID_PARAMETER_DEFINITION;
+		}
 	}
 	return result;
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index b23a8bd2..df259b52 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -62,7 +62,7 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
 
 void HealthHelper::informParent(HasHealthIF::HealthState health,
 		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == 0) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
 	MessageQueueMessage message;

From 6838a9e7687a7232f903b5b39c11fe026bf476ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:19:22 +0200
Subject: [PATCH 0438/1292] serial buffer adapter bugfix

---
 serialize/SerialBufferAdapter.cpp | 16 ++++++++--------
 serialize/SerialBufferAdapter.h   |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index e409686f..d417ba45 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -21,29 +21,29 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
+		size_t* size_, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
 				&bufferLength);
 	}
-	if (*size + serializedLength > max_size) {
+	if (*size_ + serializedLength > max_size) {
 		return BUFFER_TOO_SHORT;
 	} else {
 		if (serializeLength) {
-			AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
+			AutoSerializeAdapter::serialize(&bufferLength, buffer_, size_,
 					max_size, bigEndian);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer, constBuffer, bufferLength);
+			memcpy(*buffer_, this->constBuffer, bufferLength);
 		} else if (buffer != nullptr) {
-			memcpy(*buffer, buffer, bufferLength);
+			memcpy(*buffer_, this->buffer, bufferLength);
 		} else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
+		*size_ += bufferLength;
+		(*buffer_) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index cb799be5..02690021 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -45,7 +45,7 @@ public:
 
 	virtual ~SerialBufferAdapter();
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer_, size_t* size,
 			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;

From f578c3ea29731f29153741b1ee99ae95c02782c6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 11 Jun 2020 16:46:18 +0200
Subject: [PATCH 0439/1292] set buffer: const buffer is set too

---
 serialize/SerialBufferAdapter.cpp | 15 ++++++++++-----
 serialize/SerialBufferAdapter.h   |  2 +-
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index d417ba45..5e834fe2 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -37,9 +37,13 @@ ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
 		}
 		if (constBuffer != nullptr) {
 			memcpy(*buffer_, this->constBuffer, bufferLength);
-		} else if (buffer != nullptr) {
+		}
+		else if (buffer != nullptr) {
+			// This will propably be never reached, constBuffer should always be
+			// set if non-const buffer is set.
 			memcpy(*buffer_, this->buffer, bufferLength);
-		} else {
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		*size_ += bufferLength;
@@ -93,7 +97,7 @@ template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(buffer == nullptr) {
 		sif::error << "Wrong access function for stored type !"
-				 " Use getConstBuffer()" << std::endl;
+				 " Use getConstBuffer()." << std::endl;
 		return nullptr;
 	}
 	return buffer;
@@ -110,9 +114,10 @@ const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 
 template<typename count_t>
 void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t buffer_length) {
+		count_t bufferLength) {
 	this->buffer = buffer;
-	bufferLength = buffer_length;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
 }
 
 
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 02690021..a30451a1 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -67,7 +67,7 @@ public:
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
-	void setBuffer(uint8_t* buffer_, count_t bufferLength_);
+	void setBuffer(uint8_t* buffer, count_t bufferLength);
 private:
 	bool serializeLength = false;
 	const uint8_t *constBuffer = nullptr;

From 7b538e9750001a7b91a89fbde5a47f9b619674eb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 12 Jun 2020 20:23:39 +0200
Subject: [PATCH 0440/1292] introduced command message base and

command message IF
---
 housekeeping/HousekeepingMessage.cpp |  17 +---
 housekeeping/HousekeepingMessage.h   |  13 ++-
 ipc/CommandMessage.cpp               | 128 +++++++++------------------
 ipc/CommandMessage.h                 |  79 +++++------------
 ipc/CommandMessageBase.cpp           |  55 ++++++++++++
 ipc/CommandMessageBase.h             |  73 +++++++++++++++
 ipc/CommandMessageIF.h               |  25 ++++++
 ipc/MessageQueueMessage.cpp          |   4 +
 ipc/MessageQueueMessage.h            |   3 +-
 ipc/MessageQueueMessageIF.h          |   4 +-
 10 files changed, 232 insertions(+), 169 deletions(-)
 create mode 100644 ipc/CommandMessageBase.cpp
 create mode 100644 ipc/CommandMessageBase.h
 create mode 100644 ipc/CommandMessageIF.h

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index c94a69d7..d9daf974 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,18 +1,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 
-HousekeepingMessage::HousekeepingMessage() {
+HousekeepingMessage::HousekeepingMessage(MessageQueueMessage *message):
+		CommandMessageBase	(message) {}
 
-}
+HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setHkReportMessage() {
-}
-
-
-//void HousekeepingMessage::setAddHkReportStructMessage(CommandMessage *message,
-//		set_t setId, store_address_t packet) {
-//	message->setCommand(ADD_HK_REPORT_STRUCT);
-//	message->setParameter(setId);
-//	message->setParameter2(packet.raw);
-//}
-
-//void Housekeeping
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 3ba6f94d..d0cbd0eb 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,6 +1,8 @@
 #ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
 #define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/FwMessageTypes.h>
+#include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <limits>
 
@@ -23,15 +25,14 @@ union sid_t {
 };
 
 
-class HousekeepingMessage: public MessageQueueMessage {
+class HousekeepingMessage : public CommandMessageBase {
 public:
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage();
-//	HousekeepingMessage(const HousekeepingMessage&) = delete;
-//	HousekeepingMessage operator=(const HousekeepingMessage &) = delete;
+	HousekeepingMessage(MessageQueueMessage* message);
+	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
@@ -78,8 +79,6 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-//	static void setAddHkReportStructMessage(CommandMessage* message,
-//			DevisetId, store_address_t packet);
 	static void setHkReportMessage();
 };
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 7d2ecc9b..8f53b77c 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,6 +1,7 @@
+#include <framework/ipc/CommandMessage.h>
+
 #include <framework/devicehandlers/DeviceHandlerMessage.h>
 #include <framework/health/HealthMessage.h>
-#include <framework/ipc/CommandMessage.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/modes/ModeMessage.h>
 #include <framework/monitoring/MonitoringMessage.h>
@@ -8,82 +9,86 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-
 CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
-			internalMessage(receiverMessage) {
+			CommandMessageBase(receiverMessage) {
 	if(receiverMessage == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
+	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
 	setCommand(CMD_NONE);
 }
 
 CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
-				internalMessage(messageToSet) {
+				CommandMessageBase(messageToSet) {
 	if(messageToSet == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->messageSize = COMMAND_MESSAGE_SIZE;
+	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
 }
 
-Command_t CommandMessage::getCommand() const {
-	Command_t command;
-	memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-	return command;
-}
-
-uint8_t CommandMessage::getMessageType() const {
-	return getCommand() >> 8 & 0xff;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-	memcpy(internalMessage->getData(), &command, sizeof(command));
-}
-
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, internalMessage->getData() + sizeof(Command_t),
-			sizeof(parameter1));
+	memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(internalMessage->getData() + sizeof(Command_t),
-			&parameter1, sizeof(parameter1));
+	memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, internalMessage->getData() + sizeof(Command_t)
-			+ sizeof(uint32_t), sizeof(parameter2));
+	memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(internalMessage-> getData() + sizeof(Command_t) + sizeof(uint32_t),
-			&parameter2, sizeof(parameter2));
+	memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+			sizeof(parameter2));
 }
 
+size_t CommandMessage::getMinimumMessageSize() const {
+	return COMMAND_MESSAGE_SIZE;
+}
+
+size_t CommandMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+	return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+	Command_t initialCommand = getCommand();
+	clearCommandMessage();
+	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+		Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+	setParameter(reason);
+	setParameter2(initialCommand);
+}
+
+
 void CommandMessage::clear() {
 	clearCommandMessage();
 }
 
 void CommandMessage::clearCommandMessage() {
-	switch(getMessageType()){
-	case messagetypes::MODE_COMMAND:
+	switch(this->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
 		ModeMessage::clear(this);
 		break;
 	case messagetypes::HEALTH_COMMAND:
@@ -115,56 +120,3 @@ void CommandMessage::clearCommandMessage() {
 		break;
 	}
 }
-
-bool CommandMessage::isClearedCommandMessage() {
-	return getCommand() == CMD_NONE;
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-	Command_t initialCommand = getCommand();
-	clearCommandMessage();
-	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-	setParameter(reason);
-	setParameter2(initialCommand);
-}
-
-MessageQueueId_t CommandMessage::getSender() const {
-	return internalMessage->getSender();
-}
-
-uint8_t* CommandMessage::getBuffer() {
-	return internalMessage->getBuffer();
-}
-
-void CommandMessage::setSender(MessageQueueId_t setId) {
-	internalMessage->setSender(setId);
-}
-
-const uint8_t* CommandMessage::getBuffer() const {
-	return internalMessage->getBuffer();
-}
-
-uint8_t* CommandMessage::getData() {
-	return internalMessage->getData();
-}
-
-const uint8_t* CommandMessage::getData() const {
-	return internalMessage->getData();
-}
-
-size_t CommandMessage::getMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
-}
-
-size_t CommandMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 25d608f0..434f8c8c 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,33 +1,35 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
+#include <framework/ipc/CommandMessageBase.h>
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
-#include <config/ipc/MissionMessageTypes.h>
 
-
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessageIF* message);
+}
 
 /**
- * @brief 	Used to pass command messages between tasks. Primary message type
- * 			for IPC. Contains sender, 2-byte command field, and 2 4-byte
- * 			parameters.
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
  * @details
  * It operates on an external memory which is contained inside a
- * MessageQueueMessage by taking its address.
+ * class implementing MessageQueueMessageIF by taking its address.
  * This allows for a more flexible designs of message implementations.
  * The pointer can be passed to different message implementations without
  * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
  * @author	Bastian Baetz
  */
-class CommandMessage: public MessageQueueMessageIF {
+class CommandMessage: public CommandMessageBase {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
 	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
 
-
 	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
 	//! Used internally, will be ignored
 	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
@@ -66,39 +68,11 @@ public:
 	 */
 	virtual ~CommandMessage() {}
 
-	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message,
-	 * usually used after receiving.
-	 *
-	 * @return the Command stored in the Message
-	 */
-	Command_t getCommand() const;
-
-	/*
-	 * MessageQueueMessageIF functions, which generally just call the
-	 * respective functions of the internal message
-	 */
-	uint8_t * getBuffer() override;
-	const uint8_t * getBuffer() const override;
-	void setSender(MessageQueueId_t setId) override;
-	MessageQueueId_t getSender() const override;
-	uint8_t * getData() override;
-	const uint8_t* getData() const override;
+	/** MessageQueueMessageIF functions used for minimum size check. */
 	size_t getMinimumMessageSize() const override;
-	size_t getMessageSize() const override;
+	/** MessageQueueMessageIF functions used for maximum size check. */
 	size_t getMaximumMessageSize() const override;
 
-	/**
-	 * Extract message ID, which is the first byte of the command ID.
-	 * @return
-	 */
-	uint8_t getMessageType() const;
-	/**
-	 * Set the command type of the message
-	 * @param the Command to be sent
-	 */
-	void setCommand(Command_t command);
-
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -123,19 +97,17 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
+	void clear() override;
 
 	/**
-	 * Set the command to CMD_NONE and try to find
-	 * the correct class to handle a more detailed
-	 * clear.
-	 * Also, calls a mission-specific clearMissionMessage
-	 * function to separate between framework and mission
-	 * messages. Not optimal, may be replaced by totally
-	 * different auto-delete solution (e.g. smart pointers).
+	 * Set the command to CMD_NONE and try to find the correct class to handle
+	 * a more detailed clear.
+	 * Also, calls a mission-specific clearMissionMessage function to separate
+	 * between framework and mission messages. Not optimal, may be replaced by
+	 * totally different auto-delete solution (e.g. smart pointers).
 	 *
 	 */
 	void clearCommandMessage();
-	void clear() override;
 
 	/**
 	 * check if a message was cleared
@@ -151,15 +123,6 @@ public:
 	void setToUnknownCommand();
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
-
-private:
-	/**
-	 * @brief 	Pointer to the message containing the data.
-	 * @details
-	 * The command message does not actually own the memory containing a
-	 * message, it just oprates on it via a pointer to a message queue message.
-	 */
-	MessageQueueMessage* internalMessage;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
new file mode 100644
index 00000000..aa84bd1e
--- /dev/null
+++ b/ipc/CommandMessageBase.cpp
@@ -0,0 +1,55 @@
+#include <framework/ipc/CommandMessageBase.h>
+#include <cstring>
+
+CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
+		internalMessage(message) {
+}
+
+Command_t CommandMessageBase::getCommand() const {
+	Command_t command;
+	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
+	return command;
+}
+
+void CommandMessageBase::setCommand(Command_t command) {
+	std::memcpy(internalMessage->getData(), &command, sizeof(command));
+}
+
+uint8_t CommandMessageBase::getMessageType() const {
+	// first byte of command ID.
+	return getCommand() >> 8 & 0xff;
+}
+
+MessageQueueId_t CommandMessageBase::getSender() const {
+	return internalMessage->getSender();
+}
+
+uint8_t* CommandMessageBase::getBuffer() {
+	return internalMessage->getBuffer();
+}
+
+void CommandMessageBase::setSender(MessageQueueId_t setId) {
+	internalMessage->setSender(setId);
+}
+
+const uint8_t* CommandMessageBase::getBuffer() const {
+	return internalMessage->getBuffer();
+}
+
+// Header includes command ID.
+uint8_t* CommandMessageBase::getData() {
+	return internalMessage->getData() + sizeof(Command_t);
+}
+
+// Header includes command ID.
+const uint8_t* CommandMessageBase::getData() const {
+	return internalMessage->getData() + sizeof(Command_t);
+}
+
+void CommandMessageBase::setMessageSize(size_t messageSize) {
+	internalMessage->setMessageSize(messageSize);
+}
+
+size_t CommandMessageBase::getMessageSize() const {
+	return internalMessage->getMessageSize();
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
new file mode 100644
index 00000000..fa3fd477
--- /dev/null
+++ b/ipc/CommandMessageBase.h
@@ -0,0 +1,73 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
+#include <framework/ipc/CommandMessageIF.h>
+#include <framework/ipc/MessageQueueMessage.h>
+
+/**
+ * @brief	Base implementation of a generic command message, which has
+ * 			a Command_t ID and message type ID in the header in addition
+ * 			to the sender message queue ID.
+ * @details
+ * This is the base implementation serves as a base for other command messages
+ * and which implements most functions required for MessageQueueMessageIF.
+ * The only functions which have to be supplied by a specific command message
+ * impelementations are the size related functions which are used for
+ * size checks:
+ *
+ *  1. getMinimumMessageSize()
+ *  2. getMaximumMessageSize()
+ *
+ * Don't forget to set the message size of the passed message in the concrete
+ * commandmessage implementation!
+ */
+class CommandMessageBase: public CommandMessageIF {
+public:
+	CommandMessageBase(MessageQueueMessageIF* message);
+
+	/**
+	 * Read the DeviceHandlerCommand_t that is stored in the message,
+	 * usually used after receiving.
+	 *
+	 * @return the Command stored in the Message
+	 */
+	virtual Command_t getCommand() const override;
+	/**
+	 * Set the command type of the message. Default implementation also
+	 * sets the message type, which will be the first byte of the command ID.
+	 * @param the Command to be sent
+	 */
+	virtual void setCommand(Command_t command);
+
+	/**
+	 * Extract message ID, which is the first byte of the command ID for the
+	 * default implementation.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const override;
+
+	/*
+	 * MessageQueueMessageIF functions, which generally just call the
+	 * respective functions of the internal message queue message.
+	 */
+	virtual uint8_t * getBuffer() override;
+	virtual const uint8_t * getBuffer() const override;
+	virtual void setSender(MessageQueueId_t setId) override;
+	virtual MessageQueueId_t getSender() const override;
+	virtual uint8_t * getData() override;
+	virtual const uint8_t* getData() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMessageSize() const override;
+
+protected:
+	/**
+	 * @brief 	Pointer to the message containing the data.
+	 * @details
+	 * The command message does not actually own the memory containing a
+	 * message, it just oprates on it via a pointer to a message queue message.
+	 */
+	MessageQueueMessageIF* internalMessage;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
new file mode 100644
index 00000000..fbc40f88
--- /dev/null
+++ b/ipc/CommandMessageIF.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+
+#include <framework/ipc/MessageQueueMessageIF.h>
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF: public MessageQueueMessageIF {
+public:
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+};
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 8430a8ea..b173f2c4 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -75,3 +75,7 @@ size_t MessageQueueMessage::getMessageSize() const {
 size_t MessageQueueMessage::getMaximumMessageSize() const {
 	return this->MAX_MESSAGE_SIZE;
 }
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 31a43f66..2eb1f4f5 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -3,7 +3,7 @@
 
 #include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
-#include <stddef.h>
+#include <cstddef>
 
 /**
  *	@brief		This class is the representation and data organizer
@@ -150,6 +150,7 @@ public:
 	virtual size_t getMinimumMessageSize() const override;
 
 	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
 
 	virtual size_t getMaximumMessageSize() const override;
 
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 05330ce9..f34cab98 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -24,7 +24,8 @@ public:
 
 	/**
 	 * @brief	With this method, the whole content and the message
-	 * 			size is set to zero.
+	 * 			size is set to zero. Implementations should also take care
+	 * 			to clear data which is stored indirectly (e.g. storage data).
 	 */
 	virtual void clear() = 0;
 
@@ -77,6 +78,7 @@ public:
 	 * @return
 	 */
 	virtual size_t getMessageSize() const = 0;
+	virtual void setMessageSize(size_t messageSize) = 0;
 
 	/**
 	 * Get maximum allowed size of current message implementation.

From 6b67f46c802aa1b421689097d3faf96668073c71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 13 Jun 2020 17:37:48 +0200
Subject: [PATCH 0441/1292] evil hidden bug found.

CSB uses CommandMessageIF now
---
 datapoollocal/LocalDataPoolManager.cpp |  4 +-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 devicehandlers/DeviceHandlerBase.cpp   | 28 ++++--------
 devicehandlers/HealthDevice.cpp        |  2 +-
 housekeeping/HousekeepingMessage.cpp   | 45 +++++++++++++++++--
 housekeeping/HousekeepingMessage.h     | 29 +++++++++---
 ipc/CommandMessage.cpp                 | 33 +++++++++++---
 ipc/CommandMessage.h                   | 12 +++--
 ipc/CommandMessageBase.cpp             |  6 ++-
 ipc/CommandMessageBase.h               |  6 ++-
 ipc/CommandMessageIF.h                 | 16 +++++++
 ipc/MessageQueueMessage.h              |  4 +-
 osal/FreeRTOS/MessageQueue.cpp         |  2 +-
 osal/FreeRTOS/MessageQueue.h           | 22 ++++-----
 tmtcservices/CommandingServiceBase.cpp | 62 +++++++++++++++++---------
 tmtcservices/CommandingServiceBase.h   | 23 +++++++---
 tmtcservices/VerificationReporter.cpp  | 10 ++---
 17 files changed, 214 insertions(+), 92 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 37dbed36..58694508 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -41,8 +41,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		MessageQueueMessage *message) {
-	return HasReturnvaluesIF::RETURN_OK;
+		HousekeepingMessage& message) {
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 1d25fa48..d1a2d410 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -46,7 +46,7 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
-	ReturnValue_t handleHousekeepingMessage(MessageQueueMessage* message);
+	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 11cffc74..bf699848 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -225,15 +225,6 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	// This is really annoying. I can't cast a parent object to a child.
-	// But I want to use another message format..
-//	CommandMessage* cmdMessage = dynamic_cast<CommandMessage*>(msgPtr);
-//	if(cmdMessage == nullptr) {
-//		sif::error << "DeviceHandlerBase::readCommandQueue: Could not cast"
-//				" message to CommandMessage!" << std::endl;
-//		return;
-//	}
-
 	if(healthHelperActive) {
 		result = healthHelper.handleHealthCommand(&command);
 		if (result == RETURN_OK) {
@@ -256,11 +247,11 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-//	HousekeepingMessage* hkMessage = dynamic_cast<HousekeepingMessage*>(msgPtr);
-//	result = hkManager.handleHousekeepingMessage(hkMessage);
-//	if (result == RETURN_OK) {
-//		return;
-//	}
+	HousekeepingMessage hkMessage(&message);
+	result = hkManager.handleHousekeepingMessage(hkMessage);
+	if (result == RETURN_OK) {
+		return;
+	}
 
 	result = handleDeviceHandlerMessage(&command);
 	if (result == RETURN_OK) {
@@ -758,7 +749,7 @@ ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
 
 void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == NULL || len == 0 || sendTo == MessageQueueIF::NO_QUEUE) {
+	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	store_address_t address;
@@ -775,13 +766,12 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
 
-//	this->DeviceHandlerCommand = CommandMessage::CMD_NONE;
-
-	result = commandQueue->sendMessage(sendTo, &message);
+	result = commandQueue->sendMessage(sendTo, &command);
 
 	if (result != RETURN_OK) {
 		IPCStore->deleteData(address);
-		//Silently discard data, this indicates heavy TM traffic which should not be increased by additional events.
+		// Silently discard data, this indicates heavy TM traffic which
+		// should not be increased by additional events.
 	}
 }
 
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 1c9d18f6..7e3a59bd 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -5,7 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
 HealthDevice::~HealthDevice() {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d9daf974..6dd1a711 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,7 +1,46 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
+#include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(MessageQueueMessage *message):
-		CommandMessageBase	(message) {}
+HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
+		CommandMessageBase(message) {
+}
 
-HousekeepingMessage::~HousekeepingMessage() {}
+HousekeepingMessage::~HousekeepingMessage() {
+}
 
+void HousekeepingMessage::setHkReportMessage(sid_t sid,
+		store_address_t storeId) {
+	CommandMessageBase::setCommand(HK_REPORT);
+	setSid(sid);
+	setParameter(storeId.raw);
+}
+
+size_t HousekeepingMessage::getMinimumMessageSize() const {
+	return HK_MESSAGE_SIZE;
+}
+
+size_t HousekeepingMessage::getMaximumMessageSize() const {
+	return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}
+
+void HousekeepingMessage::clear() {
+	// clear IPC store where it is needed.
+}
+
+sid_t HousekeepingMessage::getSid() const {
+	sid_t sid;
+	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
+	return sid;
+}
+
+uint8_t* HousekeepingMessage::getData() {
+	return internalMessage->getBuffer() + sizeof(sid_t);
+}
+
+void HousekeepingMessage::setParameter(uint32_t parameter) {
+	memcpy(getData(), &parameter, sizeof(parameter));
+}
+
+void HousekeepingMessage::setSid(sid_t sid) {
+	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index d0cbd0eb..4e9d4553 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -13,13 +13,15 @@ union sid_t {
 
 	struct {
 		object_id_t objectId ;
-		// A generic 32 bit ID to identify unique HK packets for a single
-		// object.
-		// For example, the DeviceCommandId_t is used for DeviceHandlers
+		/**
+		 * A generic 32 bit ID to identify unique HK packets for a single
+		 * object. For example, the DeviceCommandId_t is used for
+		 * DeviceHandlers
+		 */
 		uint32_t ownerSetId;
 	};
 	/**
-	 * Alternative access to the raw value.
+	 * Alternative access to the raw value. This is also the size of the type.
 	 */
 	uint64_t raw;
 };
@@ -27,14 +29,18 @@ union sid_t {
 
 class HousekeepingMessage : public CommandMessageBase {
 public:
+
+	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
+			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
 	/**
 	 * No instances of a message shall be created, instead
 	 * a CommandMessage instance is manipulated.
 	 */
-	HousekeepingMessage(MessageQueueMessage* message);
+	HousekeepingMessage(MessageQueueMessageIF* message);
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
+
 	static constexpr Command_t ADD_HK_REPORT_STRUCT =
 			MAKE_COMMAND_ID(1);
 	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
@@ -79,7 +85,18 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	static void setHkReportMessage();
+	void setHkReportMessage(sid_t sid, store_address_t storeId);
+
+	void setParameter(uint32_t parameter);
+
+	virtual void clear() override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	virtual uint8_t* getData() override;
+private:
+	sid_t getSid() const;
+	void setSid(sid_t sid);
 };
 
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 8f53b77c..9d448aed 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -9,18 +9,25 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-CommandMessage::CommandMessage(MessageQueueMessage* receiverMessage):
+CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 			CommandMessageBase(receiverMessage) {
 	if(receiverMessage == nullptr) {
 		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
+		return;
 	}
-	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
-	setCommand(CMD_NONE);
+	if(receiverMessage->getMaximumMessageSize() <
+			MINIMUM_COMMAND_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
-CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
+CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
 				CommandMessageBase(messageToSet) {
 	if(messageToSet == nullptr) {
@@ -28,7 +35,14 @@ CommandMessage::CommandMessage(MessageQueueMessage* messageToSet,
 				" as the message queue message, pass the address of an actual"
 				" message!" << std::endl;
 	}
-	internalMessage->setMessageSize(COMMAND_MESSAGE_SIZE);
+	if(messageToSet->getMaximumMessageSize() <
+			MINIMUM_COMMAND_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
@@ -57,7 +71,7 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 }
 
 size_t CommandMessage::getMinimumMessageSize() const {
-	return COMMAND_MESSAGE_SIZE;
+	return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
 size_t CommandMessage::getMaximumMessageSize() const {
@@ -81,6 +95,13 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 	setParameter2(initialCommand);
 }
 
+ReturnValue_t CommandMessage::getRejectedReplyReason(
+		Command_t* initialCommand) const {
+	if(initialCommand != nullptr) {
+		*initialCommand  = getParameter2();
+	}
+	return getParameter();
+}
 
 void CommandMessage::clear() {
 	clearCommandMessage();
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 434f8c8c..8e1e9c8c 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -42,8 +42,9 @@ public:
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
-	static const size_t COMMAND_MESSAGE_SIZE = MessageQueueMessage::HEADER_SIZE
-			+ sizeof(Command_t) + 2 * sizeof(uint32_t);
+	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+			MessageQueueMessage::HEADER_SIZE + sizeof(Command_t) +
+			2 * sizeof(uint32_t);
 
 	/**
 	 * Default Constructor, does not initialize anything.
@@ -51,7 +52,7 @@ public:
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage(MessageQueueMessage* receiverMessage);
+	CommandMessage(MessageQueueMessageIF* receiverMessage);
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -60,7 +61,7 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(MessageQueueMessage* messageToSet, Command_t command,
+	CommandMessage(MessageQueueMessageIF* messageToSet, Command_t command,
 			uint32_t parameter1, uint32_t parameter2);
 
 	/**
@@ -121,8 +122,11 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
+
 	void setReplyRejected(ReturnValue_t reason,
 			Command_t initialCommand = CMD_NONE);
+	ReturnValue_t getRejectedReplyReason(
+			Command_t* initialCommand = nullptr) const;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index aa84bd1e..3ffe4daa 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -12,7 +12,7 @@ Command_t CommandMessageBase::getCommand() const {
 }
 
 void CommandMessageBase::setCommand(Command_t command) {
-	std::memcpy(internalMessage->getData(), &command, sizeof(command));
+	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
 }
 
 uint8_t CommandMessageBase::getMessageType() const {
@@ -53,3 +53,7 @@ void CommandMessageBase::setMessageSize(size_t messageSize) {
 size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
+
+MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
+	return internalMessage;
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index fa3fd477..b2b7d5f2 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -22,6 +22,9 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
+	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+			sizeof(Command_t);
+
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -58,6 +61,7 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	virtual MessageQueueMessageIF* getInternalMessage() const override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
@@ -65,7 +69,7 @@ protected:
 	 * The command message does not actually own the memory containing a
 	 * message, it just oprates on it via a pointer to a message queue message.
 	 */
-	MessageQueueMessageIF* internalMessage;
+	MessageQueueMessageIF* internalMessage = nullptr;
 };
 
 
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index fbc40f88..44853c38 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -6,6 +6,12 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
+// TODO: actually, this interface propably does not have to implement
+// MQM IF, because there is a getter function for the internal message..
+// But it is also convenient to have the full access to all MQM IF functions.
+// That way, I can just pass CommandMessages to functions expecting a MQM IF.
+// The command message implementations just forwards the calls. Maybe
+// we should just leave it like that.
 class CommandMessageIF: public MessageQueueMessageIF {
 public:
 	virtual ~CommandMessageIF() {};
@@ -20,6 +26,16 @@ public:
 	 * @return
 	 */
 	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * This function is used to get a pointer to the internal message, as
+	 * the command message implementations always operate on the memory
+	 * contained in the message queue message implementation.
+	 * This pointer can be used to set the internal message of different
+	 * command message implementations.
+	 * @return
+	 */
+	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
 };
 
 #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 2eb1f4f5..8716df54 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -88,12 +88,12 @@ public:
 	 * queue in the system. So, a change here may have significant impact on
 	 * the required resources.
 	 */
-	static const size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
 	/**
 	 * @brief Defines the minimum size of a message where only the
 	 * 		  header is included
 	 */
-	static const size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
 private:
 	/**
 	 * @brief	This is the internal buffer that contains the
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 8c6ec80b..d44b0bc0 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -101,7 +101,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 }
 
 MessageQueueId_t MessageQueue::getId() const {
-	return (MessageQueueId_t) handle;
+	return reinterpret_cast<MessageQueueId_t>(handle);
 }
 
 void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 6165c1cf..c13a8a20 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -3,7 +3,7 @@
 
 #include <framework/internalError/InternalErrorReporterIF.h>
 #include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
+#include <framework/ipc/MessageQueueMessageIF.h>
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
 #include <freertos/FreeRTOS.h>
@@ -85,14 +85,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -100,7 +100,7 @@ public:
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply( MessageQueueMessageIF* message );
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 
 	/**
 	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
@@ -113,9 +113,10 @@ public:
 	 * 					This variable is set to zero by default.
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
 
 	/**
 	 * @brief	The sendToDefault method sends a queue message to the default destination.
@@ -125,7 +126,8 @@ public:
 	 * 					This variable is set to zero by default.
 	 */
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -135,7 +137,7 @@ public:
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
 	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom);
+			MessageQueueId_t *receivedFrom) override;
 
 	/**
 	 * @brief	This function reads available messages from the message queue.
@@ -145,7 +147,7 @@ public:
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 72351995..65053cc8 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -81,40 +81,58 @@ void CommandingServiceBase::handleCommandQueue() {
 	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(reply);
+		if(reply.getInternalMessage() == nullptr) {
+			// This should never happen unless the passed message maximum size
+			// is too small!
+			sif::error << "CommandingServiceBase::handleCommandMessage: Reply"
+					"does not satisfy minimum requirements for a command "
+					"message!" << std::endl;
+			continue;
+		}
+		handleCommandMessage(&reply);
 	}
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	bool isStep = false;
 	MessageQueueMessage message;
 	CommandMessage nextCommand(&message);
-	CommandMapIter iter;
-	if (reply.getSender() == MessageQueueIF::NO_QUEUE) {
-		handleUnrequestedReply(&reply);
-		return;
-	}
-	if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) {
-		handleUnrequestedReply(&reply);
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
 		return;
 	}
 	nextCommand.setCommand(CommandMessage::CMD_NONE);
 
+
 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(&reply, iter->command, &iter->state,
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
 			&nextCommand, iter->objectId, &isStep);
 
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED is returned), a failure verification
+	 * will be generated with the reason as the return code and the initial
+	 * command as failure parameter 1 */
+	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
+			result == RETURN_FAILED) {
+		result = reply->getRejectedReplyReason(
+				reinterpret_cast<Command_t*>(&failureParameter1));
+	}
+
 	switch (result) {
 	case EXECUTION_COMPLETE:
 	case RETURN_OK:
 	case NO_STEP_MESSAGE:
 		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, nextCommand, reply, isStep);
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
 		break;
 	case INVALID_REPLY:
 		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(&reply);
+		handleUnrequestedReply(reply);
 		break;
 	default:
 		if (isStep) {
@@ -138,17 +156,17 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage& reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage& nextCommand, CommandMessage& reply,
+		CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply,
 		bool& isStep) {
-	iter->command = nextCommand.getCommand();
+	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
 	// sendResult as RETURN_OK
 	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand.getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply.getSender(),
-				&nextCommand);
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
 	}
 
 	if (sendResult == RETURN_OK) {
@@ -168,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand.clearCommandMessage();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand.clearCommandMessage();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -366,9 +384,9 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 }
 
 
-void CommandingServiceBase::handleUnrequestedReply(
-		CommandMessage* reply) {
-	reply->clearCommandMessage();
+void CommandingServiceBase::handleUnrequestedReply(CommandMessageIF* reply) {
+	CommandMessage commandReply(reply->getInternalMessage());
+	commandReply.clear();
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 1dcafff8..5adfe4a6 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -147,9 +147,11 @@ protected:
 
 	/**
 	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled
+	 * to a command from another software component are handled.
 	 * @param reply
-	 * This is the reply in form of a command message.
+	 * This is the reply which can be accessed via the command message
+	 * interface. The internal message pointer can be passed to different
+	 * command message implementations (see CommandMessageIF)
 	 * @param previousCommand
 	 * Command_t of related command
 	 * @param state [out/in]
@@ -163,9 +165,12 @@ protected:
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
 	 * - @c INVALID_REPLY calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
+	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
+	 *   a failure verification message with the reason as the error parameter
+	 *   and the initial command as failure parameter 1.
 	 */
-	virtual ReturnValue_t handleReply(const CommandMessage *reply,
+	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
 			Command_t previousCommand, uint32_t *state,
 			CommandMessage *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
@@ -173,9 +178,13 @@ protected:
 	/**
 	 * This function can be overidden to handle unrequested reply,
 	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
 	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
 	 */
-	virtual void handleUnrequestedReply(CommandMessage *reply);
+	virtual void handleUnrequestedReply(CommandMessageIF *reply);
 
 	virtual void doPeriodicOperation();
 
@@ -303,9 +312,9 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessage& reply);
+	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage& nextCommand,CommandMessage& reply, bool& isStep);
+			CommandMessage* nextCommand,CommandMessage* reply, bool& isStep);
 
 	void checkTimeout();
 };
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4484fb9b..b0247944 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -24,9 +24,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendSuccessReport: Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
 	}
 }
 
@@ -40,9 +39,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendSuccessReport: Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
 	}
 }
 

From 8c03f6a823afca715f51d01cbecdbaa5e6ca185e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 13 Jun 2020 21:01:01 +0200
Subject: [PATCH 0442/1292] command message only passed IF now

---
 ipc/CommandMessage.cpp                 | 74 +++-----------------------
 ipc/CommandMessage.h                   | 33 ------------
 ipc/CommandMessageBase.cpp             | 23 ++++++++
 ipc/CommandMessageBase.h               | 21 ++++++--
 ipc/CommandMessageCleaner.cpp          | 45 ++++++++++++++++
 ipc/CommandMessageCleaner.h            | 16 ++++++
 ipc/CommandMessageIF.h                 | 34 ++++++++++++
 memory/MemoryHelper.cpp                |  2 +-
 tmtcservices/CommandingServiceBase.cpp | 16 +++---
 tmtcservices/CommandingServiceBase.h   |  8 +--
 10 files changed, 155 insertions(+), 117 deletions(-)
 create mode 100644 ipc/CommandMessageCleaner.cpp
 create mode 100644 ipc/CommandMessageCleaner.h

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 9d448aed..39290688 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,13 +1,5 @@
 #include <framework/ipc/CommandMessage.h>
-
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-#include <framework/parameters/ParameterMessage.h>
+#include <cstring>
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 			CommandMessageBase(receiverMessage) {
@@ -50,23 +42,23 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
+	std::memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
+	std::memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+	std::memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
 			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+	std::memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
 			sizeof(parameter2));
 }
 
@@ -84,60 +76,6 @@ bool CommandMessage::isClearedCommandMessage() {
 
 void CommandMessage::setToUnknownCommand() {
 	Command_t initialCommand = getCommand();
-	clearCommandMessage();
+	this->clear();
 	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-	setParameter(reason);
-	setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getRejectedReplyReason(
-		Command_t* initialCommand) const {
-	if(initialCommand != nullptr) {
-		*initialCommand  = getParameter2();
-	}
-	return getParameter();
-}
-
-void CommandMessage::clear() {
-	clearCommandMessage();
-}
-
-void CommandMessage::clearCommandMessage() {
-	switch(this->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(this);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(this);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(this);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(this);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(this);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(this);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(this);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(this);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(this);
-		break;
-	default:
-		messagetypes::clearMissionMessage(this);
-		break;
-	}
-}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 8e1e9c8c..72f39357 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -5,11 +5,6 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessageIF* message);
-}
-
 /**
  * @brief 	Default command message used to pass command messages between tasks.
  * 			Primary message type for IPC. Contains sender, 2-byte command ID
@@ -27,17 +22,6 @@ void clearMissionMessage(CommandMessageIF* message);
  */
 class CommandMessage: public CommandMessageBase {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, will be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 3 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 0xD1 );
-
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
@@ -98,18 +82,6 @@ public:
 	 */
 	void setParameter2(uint32_t parameter2);
 
-	void clear() override;
-
-	/**
-	 * Set the command to CMD_NONE and try to find the correct class to handle
-	 * a more detailed clear.
-	 * Also, calls a mission-specific clearMissionMessage function to separate
-	 * between framework and mission messages. Not optimal, may be replaced by
-	 * totally different auto-delete solution (e.g. smart pointers).
-	 *
-	 */
-	void clearCommandMessage();
-
 	/**
 	 * check if a message was cleared
 	 *
@@ -122,11 +94,6 @@ public:
 	 * Is needed quite often, so we better code it once only.
 	 */
 	void setToUnknownCommand();
-
-	void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand = CMD_NONE);
-	ReturnValue_t getRejectedReplyReason(
-			Command_t* initialCommand = nullptr) const;
 };
 
 
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 3ffe4daa..7085ab88 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -1,4 +1,5 @@
 #include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/CommandMessageCleaner.h>
 #include <cstring>
 
 CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
@@ -57,3 +58,25 @@ size_t CommandMessageBase::getMessageSize() const {
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
+
+void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
+		Command_t initialCommand) {
+	std::memcpy(getData(), &reason, sizeof(reason));
+	std::memcpy(getData() + sizeof(reason), &initialCommand,
+			sizeof(initialCommand));
+}
+
+ReturnValue_t CommandMessageBase::getReplyRejectedReason(
+		Command_t *initialCommand) const {
+	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+	std::memcpy(&reason, getData(), sizeof(reason));
+	if(initialCommand != nullptr) {
+		std::memcpy(initialCommand, getData() + sizeof(reason),
+				sizeof(Command_t));
+	}
+	return reason;
+}
+
+void CommandMessageBase::clear() {
+	CommandMessageCleaner::clearCommandMessage(this);
+}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index b2b7d5f2..d2f24c7e 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -22,9 +22,6 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
-	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
-			sizeof(Command_t);
-
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -61,7 +58,25 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) override;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const override;
+
 	virtual MessageQueueMessageIF* getInternalMessage() const override;
+
+	virtual void clear() override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
new file mode 100644
index 00000000..7153a8e7
--- /dev/null
+++ b/ipc/CommandMessageCleaner.cpp
@@ -0,0 +1,45 @@
+#include <framework/ipc/CommandMessageCleaner.h>
+
+#include <framework/devicehandlers/DeviceHandlerMessage.h>
+#include <framework/health/HealthMessage.h>
+#include <framework/memory/MemoryMessage.h>
+#include <framework/modes/ModeMessage.h>
+#include <framework/monitoring/MonitoringMessage.h>
+#include <framework/subsystem/modes/ModeSequenceMessage.h>
+#include <framework/tmstorage/TmStoreMessage.h>
+#include <framework/parameters/ParameterMessage.h>
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(dynamic_cast<CommandMessage*>(message));
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
new file mode 100644
index 00000000..0bd369a2
--- /dev/null
+++ b/ipc/CommandMessageCleaner.h
@@ -0,0 +1,16 @@
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include <framework/ipc/CommandMessageIF.h>
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessageIF* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessageIF* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 44853c38..fbfbddbb 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -2,6 +2,9 @@
 #define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
 
 #include <framework/ipc/MessageQueueMessageIF.h>
+#include <framework/ipc/FwMessageTypes.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
@@ -14,6 +17,20 @@ typedef uint16_t Command_t;
 // we should just leave it like that.
 class CommandMessageIF: public MessageQueueMessageIF {
 public:
+	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+			sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
 	virtual ~CommandMessageIF() {};
 
 	/**
@@ -27,6 +44,22 @@ public:
 	 */
 	virtual uint8_t getMessageType() const = 0;
 
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
 	/**
 	 * This function is used to get a pointer to the internal message, as
 	 * the command message implementations always operate on the memory
@@ -36,6 +69,7 @@ public:
 	 * @return
 	 */
 	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
+
 };
 
 #endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2c384651..fb4d9eb6 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -119,7 +119,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		break;
 	}
 	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clearCommandMessage();
+		reply.clear();
 	}
 }
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 65053cc8..97856b40 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -94,7 +94,7 @@ void CommandingServiceBase::handleCommandQueue() {
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) {
 	bool isStep = false;
 	MessageQueueMessage message;
 	CommandMessage nextCommand(&message);
@@ -119,7 +119,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getRejectedReplyReason(
+		result = reply->getReplyRejectedReason(
 				reinterpret_cast<Command_t*>(&failureParameter1));
 	}
 
@@ -156,8 +156,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand, CommandMessage* reply,
-		bool& isStep) {
+		CommandMapIter iter, CommandMessageIF* nextCommand,
+		CommandMessageIF* reply, bool& isStep) {
 	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
@@ -186,14 +186,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand->clearCommandMessage();
+			nextCommand->clear();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -329,7 +329,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -346,7 +346,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			command.clearCommandMessage();
+			command.clear();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 5adfe4a6..5e2c3171 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -141,7 +141,7 @@ protected:
 	 * @param objectId Target object ID
 	 * @return
 	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage *message,
+	virtual ReturnValue_t prepareCommand(CommandMessageIF *message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
@@ -172,7 +172,7 @@ protected:
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
 			Command_t previousCommand, uint32_t *state,
-			CommandMessage *optionalNextCommand, object_id_t objectId,
+			CommandMessageIF *optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
 	/**
@@ -312,9 +312,9 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessage* reply);
+	void handleCommandMessage(CommandMessageIF* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand,CommandMessage* reply, bool& isStep);
+			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
 
 	void checkTimeout();
 };

From 9f69191f234d84e8d73b6ceeeabac3699466aaea Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 14 Jun 2020 17:59:14 +0200
Subject: [PATCH 0443/1292] optimized command messages a bit

---
 ipc/CommandMessage.cpp     |  4 ----
 ipc/CommandMessage.h       |  6 ++----
 ipc/CommandMessageBase.cpp |  8 ++++++++
 ipc/CommandMessageBase.h   | 16 +++++++++++++++-
 4 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 39290688..64d4d41c 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -66,10 +66,6 @@ size_t CommandMessage::getMinimumMessageSize() const {
 	return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
-size_t CommandMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
-
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 72f39357..a09494c6 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -24,11 +24,11 @@ class CommandMessage: public CommandMessageBase {
 public:
 	/**
 	 * This is the size of a message as it is seen by the MessageQueue.
+	 * It can hold the CommandMessage header plus 2 4-byte parameters.
 	 * 14 of the 24 available MessageQueueMessage bytes are used.
 	 */
 	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-			MessageQueueMessage::HEADER_SIZE + sizeof(Command_t) +
-			2 * sizeof(uint32_t);
+			CommandMessageIF::HEADER_SIZE + 2 * sizeof(uint32_t);
 
 	/**
 	 * Default Constructor, does not initialize anything.
@@ -55,8 +55,6 @@ public:
 
 	/** MessageQueueMessageIF functions used for minimum size check. */
 	size_t getMinimumMessageSize() const override;
-	/** MessageQueueMessageIF functions used for maximum size check. */
-	size_t getMaximumMessageSize() const override;
 
 	/**
 	 * Get the first parameter of the message
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 7085ab88..80f9d378 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -55,10 +55,18 @@ size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
 
+size_t CommandMessageBase::getMaximumMessageSize() const {
+	return internalMessage->getMaximumMessageSize();
+}
+
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
 
+size_t CommandMessageBase::getMinimumMessageSize() const {
+	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+}
+
 void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
 		Command_t initialCommand) {
 	std::memcpy(getData(), &reason, sizeof(reason));
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index d2f24c7e..b237b68f 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -15,13 +15,21 @@
  * size checks:
  *
  *  1. getMinimumMessageSize()
- *  2. getMaximumMessageSize()
  *
+ * The maximum message size generally depends on the buffer size of the passed
+ * internal message.
  * Don't forget to set the message size of the passed message in the concrete
  * commandmessage implementation!
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
+	//! This minimum size is derived from the interface requirement to be able
+	//! to set a rejected reply, which contains a returnvalue and the initial
+	//! command.
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_BASE_SIZE =
+			CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+			sizeof(Command_t);
+
 	CommandMessageBase(MessageQueueMessageIF* message);
 
 	/**
@@ -58,6 +66,12 @@ public:
 	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
+	//! This depends on the maximum message size of the passed internal message.
+	virtual size_t getMaximumMessageSize() const override;
+
+	//! Return the constant minimum message size.
+	virtual size_t getMinimumMessageSize() const override;
+
 	/**
 	 * A command message can be rejected and needs to offer a function
 	 * to set a rejected reply

From 6ecf1cf534b1eaf45be731263a241b629fa3d937 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 14 Jun 2020 19:03:28 +0200
Subject: [PATCH 0444/1292] hk message continued

---
 housekeeping/HousekeepingMessage.cpp | 57 +++++++++++++++++++++-------
 housekeeping/HousekeepingMessage.h   | 28 ++++++++++----
 2 files changed, 64 insertions(+), 21 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 6dd1a711..d47fb92a 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,9 +3,25 @@
 
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
+	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
+		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+				" can not hold minimum "<< HK_MESSAGE_SIZE
+				<< " bytes!" << std::endl;
+		return;
+	}
+	message->setMessageSize(HK_MESSAGE_SIZE);
 }
 
-HousekeepingMessage::~HousekeepingMessage() {
+HousekeepingMessage::~HousekeepingMessage() {}
+
+void HousekeepingMessage::setParameter(uint32_t parameter) {
+	std::memcpy(getData(), &parameter, sizeof(parameter));
+}
+
+uint32_t HousekeepingMessage::getParameter() const {
+	uint32_t parameter;
+	std::memcpy(&parameter, getData(), sizeof(parameter));
+	return parameter;
 }
 
 void HousekeepingMessage::setHkReportMessage(sid_t sid,
@@ -15,32 +31,45 @@ void HousekeepingMessage::setHkReportMessage(sid_t sid,
 	setParameter(storeId.raw);
 }
 
+void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
+		store_address_t storeId) {
+	CommandMessageBase::setCommand(DIAGNOSTICS_REPORT);
+	setSid(sid);
+	setParameter(storeId.raw);
+}
+
 size_t HousekeepingMessage::getMinimumMessageSize() const {
 	return HK_MESSAGE_SIZE;
 }
 
-size_t HousekeepingMessage::getMaximumMessageSize() const {
-	return MessageQueueMessage::MAX_MESSAGE_SIZE;
-}
-
-void HousekeepingMessage::clear() {
-	// clear IPC store where it is needed.
-}
-
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
 	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
 	return sid;
 }
 
-uint8_t* HousekeepingMessage::getData() {
-	return internalMessage->getBuffer() + sizeof(sid_t);
-}
 
-void HousekeepingMessage::setParameter(uint32_t parameter) {
-	memcpy(getData(), &parameter, sizeof(parameter));
+sid_t HousekeepingMessage::getHkReportMessage(
+		store_address_t *storeIdToSet) const {
+	if(storeIdToSet != nullptr) {
+		*storeIdToSet = getParameter();
+	}
+	return getSid();
 }
 
 void HousekeepingMessage::setSid(sid_t sid) {
 	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
 }
+
+
+uint8_t* HousekeepingMessage::getData() {
+	return CommandMessageBase::getData() + sizeof(sid_t);
+}
+
+const uint8_t* HousekeepingMessage::getData() const {
+	return CommandMessageBase::getData() + sizeof(sid_t);
+}
+
+void HousekeepingMessage::clear() {
+	// clear IPC store where it is needed.
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 4e9d4553..c5e31fda 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -27,14 +27,22 @@ union sid_t {
 };
 
 
+/**
+ * @brief	Special command message type for housekeeping messages
+ * @details
+ * This message is slightly larger than regular command messages to accomodate
+ * the uint64_t structure ID (SID).
+ */
 class HousekeepingMessage : public CommandMessageBase {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
 			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
+
 	/**
-	 * No instances of a message shall be created, instead
-	 * a CommandMessage instance is manipulated.
+	 * The HK message is initialized with a pointer to a message which holds
+	 * the message data, see CommandMessageIF and getInternalMessage().
+	 * @param message
 	 */
 	HousekeepingMessage(MessageQueueMessageIF* message);
 	virtual ~HousekeepingMessage();
@@ -85,18 +93,24 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
-	void setHkReportMessage(sid_t sid, store_address_t storeId);
 
 	void setParameter(uint32_t parameter);
+	uint32_t getParameter() const;
+
+	void setHkReportMessage(sid_t sid, store_address_t storeId);
+	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
+	//! Get the respective SID and store ID. Command ID can be used beforehand
+	//! to distinguish between diagnostics and regular HK packets
+	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
 
-	virtual void clear() override;
 	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	virtual uint8_t* getData() override;
+	virtual void clear() override;
 private:
 	sid_t getSid() const;
 	void setSid(sid_t sid);
+
+	virtual uint8_t* getData() override;
+	virtual const uint8_t* getData() const override;
 };
 
 

From c9d8bd59f0120dca352352dab737d39c43896131 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 11:11:42 +0200
Subject: [PATCH 0445/1292] ctor improved

---
 ipc/CommandMessage.cpp | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 64d4d41c..163a6a2d 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -10,31 +10,18 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 		return;
 	}
 	if(receiverMessage->getMaximumMessageSize() <
-			MINIMUM_COMMAND_MESSAGE_SIZE) {
+			getMinimumMessageSize()) {
 		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
 				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
-	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
+	internalMessage->setMessageSize(getMinimumMessageSize());
 }
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
 		Command_t command, uint32_t parameter1, uint32_t parameter2):
-				CommandMessageBase(messageToSet) {
-	if(messageToSet == nullptr) {
-		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
-				" as the message queue message, pass the address of an actual"
-				" message!" << std::endl;
-	}
-	if(messageToSet->getMaximumMessageSize() <
-			MINIMUM_COMMAND_MESSAGE_SIZE) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
-				<< " bytes!" << std::endl;
-		return;
-	}
-	internalMessage->setMessageSize(MINIMUM_COMMAND_MESSAGE_SIZE);
+		CommandMessage(messageToSet) {
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);

From e39d5689e537be8ae3595383005d62e656ad554d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 16:56:22 +0200
Subject: [PATCH 0446/1292] device com IF formattign

---
 devicehandlers/DeviceCommunicationIF.h | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index bb095116..20565025 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,5 +1,5 @@
-#ifndef DEVICECOMMUNICATIONIF_H_
-#define DEVICECOMMUNICATIONIF_H_
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
 
 #include <framework/devicehandlers/CookieIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
@@ -19,8 +19,8 @@
  * the device handler to allow reuse of these components.
  * @details
  * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data
- * is polled by a component. There are four generic steps of device communication:
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
  *
  *   1. Send data to a device
  *   2. Get acknowledgement for sending
@@ -77,8 +77,8 @@ public:
 	 *  - @c RETURN_OK for successfull send
 	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen) = 0;
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetWrite().
@@ -103,7 +103,8 @@ public:
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
 
 	/**
 	 * Called by DHB in the GET_WRITE doGetRead().
@@ -119,8 +120,8 @@ public:
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1
 	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size) = 0;
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
 };
 
 #endif /* DEVICECOMMUNICATIONIF_H_ */

From 7871ee7ca810bc49380b3362b3d0c9e1c0e49e0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 15 Jun 2020 17:39:52 +0200
Subject: [PATCH 0447/1292] mutex helper little formatting correction

---
 ipc/MutexHelper.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 20760b32..c9579e9b 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -10,7 +10,7 @@ public:
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of"
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){

From 813e82415affa80420751065d83454ae88d47262 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 16 Jun 2020 11:03:24 +0200
Subject: [PATCH 0448/1292] additional doc info

---
 devicehandlers/DeviceCommunicationIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index 20565025..a2662d46 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -72,7 +72,7 @@ public:
 	 * by implementing and calling related drivers or wrapper functions.
 	 * @param cookie
 	 * @param data
-	 * @param len
+	 * @param len If this is 0, nothing shall be sent.
 	 * @return
 	 *  - @c RETURN_OK for successfull send
 	 *  - Everything else triggers failure event with returnvalue as parameter 1

From 38676308e332ead072d35238c95953b7e64abaec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:37:55 +0200
Subject: [PATCH 0449/1292] improved array list a bit

---
 container/ArrayList.h | 176 ++++++++++++++++++++----------------------
 1 file changed, 84 insertions(+), 92 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index a37a1c42..8138864b 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,5 +1,5 @@
-#ifndef ARRAYLIST_H_
-#define ARRAYLIST_H_
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeAdapter.h>
@@ -7,8 +7,9 @@
 
 /**
  * @brief 	A List that stores its values in an array.
- * @details The backend is an array that can be allocated
- * 			by the class itself or supplied via ctor.
+ * @details
+ * The underlying storage is an array that can be allocated by the class
+ * itself or supplied via ctor.
  *
  * @ingroup container
  */
@@ -19,81 +20,13 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator() :
-				value(0) {
-
-		}
-
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
-
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
-
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
-
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
-
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
-
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
-
-		T operator*() {
-			return *value;
-		}
-
-		T *operator->() {
-			return value;
-		}
-
-		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);
-		}
-	}
-	;
+    /**
+     * 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;
 
 	/**
 	 * Number of Elements stored in this List
@@ -134,6 +67,78 @@ public:
 		}
 	}
 
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        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
 	 *
@@ -223,19 +228,6 @@ public:
 		return (maxSize_ - size);
 	}
 
-private:
-	/**
-	 * This is the copy constructor
-	 *
-	 * It is private, as copying is too ambigous in this case. (Allocate a new backend? Use the same?
-	 * What to do in an modifying call?)
-	 *
-	 * @param other
-	 */
-	ArrayList(const ArrayList& other) :
-			size(other.size), entries(other.entries), maxSize_(other.maxSize_),
-			allocated(false) {}
-
 protected:
 	/**
 	 * pointer to the array in which the entries are stored

From f8f10a173033b71d0bb4916cf89243327c0c2921 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:41:10 +0200
Subject: [PATCH 0450/1292] slight hybrid iter improvements

---
 container/HybridIterator.h | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 1c56aa13..db1ce4bc 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -8,13 +8,11 @@ template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
 		public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() :
-			value(NULL), linked(NULL), end(NULL) {
-	}
+	HybridIterator() {}
 
 	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(
-					iter->value), linked(true), end(NULL) {
+		LinkedElement<T>::Iterator(*iter), value(iter->value),
+		linked(true) {
 
 	}
 
@@ -66,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(HybridIterator other) {
+	bool operator==(const HybridIterator& other) {
 		return value == other.value;
 	}
 
-	bool operator!=(HybridIterator other) {
+	bool operator!=(const HybridIterator& other) {
 		return !(*this == other);
 	}
 
@@ -82,11 +80,11 @@ public:
 		return value;
 	}
 
-	T* value;
+	T* value = nullptr;
 
 private:
-	bool linked;
-	T *end;
+	bool linked = false;
+	T *end = nullptr;
 };
 
 #endif /* HYBRIDITERATOR_H_ */

From b68ad9e4f9182f8e216e69b34d58138e4044494f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 19:50:26 +0200
Subject: [PATCH 0451/1292] new ctor for simple ring buffer which does not

allocate
---
 container/RingBufferBase.h     |  8 +++++---
 container/SimpleRingBuffer.cpp | 12 +++++++++---
 container/SimpleRingBuffer.h   | 30 ++++++++++++++++++++++++------
 3 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 3ef782d8..1beb51c2 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -2,12 +2,14 @@
 #define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(uint32_t startAddress, uint32_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size), overwriteOld(overwriteOld) {
+	RingBufferBase(uint32_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;
 		}
@@ -83,7 +85,7 @@ protected:
 	const uint32_t start;
 	uint32_t write;
 	uint32_t read[N_READ_PTRS];
-	const uint32_t size;
+	const size_t size;
 	const bool overwriteOld;
 	void incrementWrite(uint32_t amount) {
 		write = ((write + amount - start) % size) + start;
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 63dc3514..4e50109b 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,11 +1,16 @@
 #include <framework/container/SimpleRingBuffer.h>
-#include <string.h>
+#include <cstring>
 
-SimpleRingBuffer::SimpleRingBuffer(uint32_t size, bool overwriteOld) :
-		RingBufferBase<>(0, size, overwriteOld), buffer(NULL) {
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld) :
+		RingBufferBase<>(0, size, overwriteOld) {
 	buffer = new uint8_t[size];
 }
 
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+        bool overwriteOld):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {}
+
+
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
@@ -66,3 +71,4 @@ ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 4552a1c0..b5bc2c1c 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,13 +5,29 @@
 #include <stddef.h>
 
 /**
- * @brief 	Circular buffer implementation, useful for buffering into data streams.
- * @details Note that the deleteData() has to be called to increment the read pointer
+ * @brief 	Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
  * @ingroup containers
  */
 class SimpleRingBuffer: public RingBufferBase<> {
 public:
-	SimpleRingBuffer(uint32_t size, bool overwriteOld);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     */
+	SimpleRingBuffer(const size_t size, bool overwriteOld);
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 */
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+
 	virtual ~SimpleRingBuffer();
 
 	/**
@@ -30,7 +46,8 @@ public:
 	 * @param trueAmount
 	 * @return
 	 */
-	ReturnValue_t readData(uint8_t* data, uint32_t amount, bool readRemaining = false, uint32_t* trueAmount = NULL);
+	ReturnValue_t readData(uint8_t* data, uint32_t amount,
+	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
 
 	/**
 	 * Delete data starting by incrementing read pointer
@@ -39,11 +56,12 @@ public:
 	 * @param trueAmount
 	 * @return
 	 */
-	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false, uint32_t* trueAmount = NULL);
+	ReturnValue_t deleteData(uint32_t amount, bool deleteRemaining = false,
+	        uint32_t* trueAmount = nullptr);
 private:
 //	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer;
+	uint8_t* buffer = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */

From d5ae74f86073c2f9847f4abbd9ed921cdb5ae094 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:21:49 +0200
Subject: [PATCH 0452/1292] bugfix hk message size

---
 housekeeping/HousekeepingMessage.cpp | 4 ++--
 housekeeping/HousekeepingMessage.h   | 4 ++--
 ipc/CommandMessage.cpp               | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d47fb92a..d7efd703 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -4,8 +4,8 @@
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
 	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< HK_MESSAGE_SIZE
+		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
+		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index c5e31fda..75afc8ea 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -36,8 +36,8 @@ union sid_t {
 class HousekeepingMessage : public CommandMessageBase {
 public:
 
-	static constexpr size_t HK_MESSAGE_SIZE = sizeof(MessageQueueId_t)
-			+ sizeof(Command_t) + sizeof(sid_t) * sizeof(uint32_t);
+	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+	        sizeof(sid_t) + sizeof(uint32_t);
 
 	/**
 	 * The HK message is initialized with a pointer to a message which holds
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 163a6a2d..9a8a82f2 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -12,7 +12,7 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 	if(receiverMessage->getMaximumMessageSize() <
 			getMinimumMessageSize()) {
 		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< MINIMUM_COMMAND_MESSAGE_SIZE
+				" can not hold minimum "<< getMinimumMessageSize()
 				<< " bytes!" << std::endl;
 		return;
 	}

From 259517ac9ba0cc51e61980883467374b3ed849f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:22:09 +0200
Subject: [PATCH 0453/1292] single linked list improvement

---
 container/SinglyLinkedList.h | 46 ++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 54e7687c..ed466086 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -1,8 +1,9 @@
-#ifndef SINGLYLINKEDLIST_H_
-#define SINGLYLINKEDLIST_H_
+#ifndef FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+#define FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
+
+#include <cstddef>
+#include <cstdint>
 
-#include <stddef.h>
-#include <stdint.h>
 /**
  * @brief	Linked list data structure,
  * 			each entry has a pointer to the next entry (singly)
@@ -47,12 +48,11 @@ public:
 		}
 	};
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = NULL) : value(setElement),
-		next(setNext) {
-	}
-	virtual ~LinkedElement(){
+	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+	       value(setElement), next(setNext) {}
+
+	virtual ~LinkedElement(){}
 
-	}
 	virtual LinkedElement* getNext() const {
 		return next;
 	}
@@ -69,7 +69,7 @@ public:
 		return this;
 	}
 	LinkedElement* end() {
-		return NULL;
+		return nullptr;
 	}
 private:
 	LinkedElement *next;
@@ -78,21 +78,21 @@ private:
 template<typename T>
 class SinglyLinkedList {
 public:
-	SinglyLinkedList() :
-			start(NULL) {
-	}
+    using ElementIterator = typename LinkedElement<T>::Iterator;
+
+	SinglyLinkedList() {}
+
+	SinglyLinkedList(ElementIterator start) :
+			start(start.value) {}
 
-	SinglyLinkedList(typename LinkedElement<T>::Iterator start) :
-			start(start.value) {
-	}
 	SinglyLinkedList(LinkedElement<T>* startElement) :
-				start(startElement) {
-		}
-	typename LinkedElement<T>::Iterator begin() const {
-		return LinkedElement<T>::Iterator::Iterator(start);
+			start(startElement) {}
+
+	ElementIterator begin() const {
+		return ElementIterator::Iterator(start);
 	}
-	typename LinkedElement<T>::Iterator::Iterator end() const {
-		return LinkedElement<T>::Iterator::Iterator();
+	typename ElementIterator::Iterator end() const {
+		return ElementIterator::Iterator();
 	}
 
 	uint32_t getSize() const {
@@ -108,7 +108,7 @@ public:
 		start = setStart;
 	}
 protected:
-	LinkedElement<T> *start;
+	LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */

From bb16fd80b8d60813f0605737e2cdd47d729effbf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:37:45 +0200
Subject: [PATCH 0454/1292] singly linked list improvements

---
 container/SinglyLinkedList.h | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index ed466086..7fffdaac 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -61,8 +61,8 @@ public:
 		this->next = next;
 	}
 
-	void setEnd() {
-		this->next = nullptr;
+	virtual void setEnd() {
+	    this->next = nullptr;
 	}
 
 	LinkedElement* begin() {
@@ -107,6 +107,11 @@ public:
 	void setStart(LinkedElement<T>* setStart) {
 		start = setStart;
 	}
+
+    void setEnd(LinkedElement<T>* setEnd) {
+        setEnd->setEnd();
+    }
+
 protected:
 	LinkedElement<T> *start = nullptr;
 };

From ed26992d7f1decf404e04d39477836381ec5635b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:40:40 +0200
Subject: [PATCH 0455/1292] shoulddo added

---
 container/SinglyLinkedList.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 7fffdaac..79562cd4 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -112,6 +112,8 @@ public:
         setEnd->setEnd();
     }
 
+    // SHOULDDO: Insertion operation ?
+
 protected:
 	LinkedElement<T> *start = nullptr;
 };

From 583efec3f8d93efab38c792a9f264f29b0bc01c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:45:44 +0200
Subject: [PATCH 0456/1292] nullptr

---
 container/SinglyLinkedList.h | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 79562cd4..3c0078fc 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -15,11 +15,8 @@ public:
 	T *value;
 	class Iterator {
 	public:
-		LinkedElement<T> *value;
-		Iterator() :
-				value(NULL) {
-
-		}
+		LinkedElement<T> *value = nullptr;
+		Iterator() {}
 
 		Iterator(LinkedElement<T> *element) :
 				value(element) {

From 84b8d733c0065280fbb1e39d81bcb8f20fc1ddb7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 03:03:17 +0200
Subject: [PATCH 0457/1292] hk continued

---
 datapool/DataSetBase.h                 |  2 +-
 datapoollocal/LocalDataPoolManager.cpp | 96 +++++++++++++++++++-------
 datapoollocal/LocalDataPoolManager.h   | 42 +++++++----
 datapoollocal/LocalDataSet.cpp         | 68 ++++++++++++++----
 datapoollocal/LocalDataSet.h           | 24 +++++++
 datapoollocal/OwnsLocalDataPoolIF.h    |  4 +-
 housekeeping/HousekeepingMessage.h     |  3 +-
 returnvalues/FwClassIds.h              |  3 +-
 8 files changed, 186 insertions(+), 56 deletions(-)

diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8bf9a99a..a914ec6b 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -102,7 +102,7 @@ public:
 	virtual ReturnValue_t unlockDataPool() override;
 
 	/* SerializeIF implementations */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 				const size_t maxSize, bool bigEndian) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 58694508..a9d131eb 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,16 +1,17 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/frameworkObjects.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
+#include <framework/ipc/QueueFactory.h>
 
 #include <array>
 
-LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
+LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+        uint32_t replyQueueDepth, bool appendValidityBuffer):
+        appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		std::exit(0);
+		return;
 	}
 	this->owner = owner;
 	mutex = MutexFactory::instance()->createMutex();
@@ -23,6 +24,8 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner) {
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
+	hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
+	        HousekeepingMessage::HK_MESSAGE_SIZE);
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
@@ -36,13 +39,21 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 		}
 		return result;
 	}
-	sif::warning << "HousekeepingManager: The map" << std::endl;
+	sif::warning << "HousekeepingManager: The map should only be initialized "
+	        "once!" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		HousekeepingMessage& message) {
-	return HasReturnvaluesIF::RETURN_FAILED;
+    Command_t command = message.getCommand();
+    switch(command) {
+    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
+        return generateHousekeepingPacket(message.getSid());
+    default:
+        return CommandMessageIF::UNKNOWN_COMMAND;
+    }
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
@@ -51,7 +62,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+		return POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
@@ -61,6 +72,15 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t destinationQueueId) {
+    this->currentHkPacketDestination = destinationQueueId;
+}
+
+const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+    return owner;
+}
+
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
@@ -70,28 +90,56 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	store_address_t storeId;
-	size_t hkSize = dataSetToSerialize->getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, hkSize,&storePtr);
+	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
+	        dataSetToSerialize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
-	            "Could not get free element from IPC store." << std::endl;
 	    return result;
 	}
-	size_t size = 0;
-	dataSetToSerialize->serialize(&storePtr, &size, hkSize, false);
-	// and now we have to set a HK message and send it the queue.
-	return HasReturnvaluesIF::RETURN_OK;
+
+	// and now we set a HK message and send it the HK packet destination.
+	MessageQueueMessage message;
+	HousekeepingMessage hkMessage(&message);
+	hkMessage.setHkReportMessage(sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_NOT_SET;
+	}
+
+	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	}
+	else {
+	    result = hkQueue->sendToDefault(&hkMessage);
+	}
+
+	return result;
 }
 
-void LocalDataPoolManager::setHkPacketQueue(MessageQueueIF *msgQueue) {
-	this->hkPacketQueue = msgQueue;
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        store_address_t *storeId, LocalDataSet* dataSet) {
+    size_t hkSize = dataSet->getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+
+    if(appendValidityBuffer) {
+        result = dataSet->serializeWithValidityBuffer(&storePtr,
+                &size, hkSize, false);
+    }
+    else {
+        result = dataSet->serialize(&storePtr, &size, hkSize, false);
+    }
+
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
+                "Serialization proccess failed!" << std::endl;
+    }
+    return result;
 }
 
-void LocalDataPoolManager::setHkReplyQueue(MessageQueueIF *replyQueue) {
-    this->hkReplyQueue = replyQueue;
-}
 
-const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
-	return owner;
-}
+
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d1a2d410..c649cd68 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -13,6 +13,8 @@
 
 #include <map>
 
+class LocalDataSet;
+
 /**
  * @brief 	This class is the managing instance for local data pool.
  * @details
@@ -37,8 +39,16 @@ class LocalDataPoolManager {
 	friend class LocalPoolVector;
 	friend class LocalDataSet;
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+
+    static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
+    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
+
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+	        uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
 	virtual~ LocalDataPoolManager();
 
 	/* Copying forbidden */
@@ -57,10 +67,7 @@ public:
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
 	//! Set the queue for HK packets, which are sent unrequested.
-	void setHkPacketQueue(MessageQueueIF* msgQueue);
-	//! Set the queue for replies. This can be set manually or by the owner
-	//! class if the manager if message are relayed by it.
-	void setHkReplyQueue(MessageQueueIF* replyQueue);
+	void setHkPacketDestination(MessageQueueId_t destinationQueueId);
 
 	const OwnsLocalDataPoolIF* getOwner() const;
 
@@ -70,6 +77,10 @@ private:
 	//! This is the map holding the actual data. Should only be initialized
 	//! once !
 	bool mapInitialized = false;
+	//! This specifies whether a validity buffer is appended at the end
+	//! of generated housekeeping packets.
+	bool appendValidityBuffer = true;
+
 	LocalDataPool localDpMap;
 
 	//! Every housekeeping data manager has a mutex to protect access
@@ -79,13 +90,14 @@ private:
 	//! The class which actually owns the manager (and its datapool).
 	OwnsLocalDataPoolIF* owner = nullptr;
 
-	//! Used for replies.
-	//! (maybe we dont need this, the sender can be retrieved from command
-	//! message..)
-	MessageQueueIF* hkReplyQueue = nullptr;
-	//! Used for HK packets, which are generated without requests.
-	//! Maybe this will just be the TM funnel.
-	MessageQueueIF* hkPacketQueue = nullptr;
+	//! Queue used for communication, for example commands.
+	//! Is also used to send messages.
+	MessageQueueIF* hkQueue = nullptr;
+
+	//! HK replies will always be a reply to the commander, but HK packet
+	//! can be sent to another destination by specifying this message queue
+	//! ID, for example to a dedicated housekeeping service implementation.
+	MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
 
 	//! Global IPC store is used to store all packets.
 	StorageManagerIF* ipcStore = nullptr;
@@ -113,6 +125,8 @@ private:
 			PoolEntry<T> **poolEntry);
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
+	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
+	        LocalDataSet* dataSet);
 };
 
 
@@ -123,14 +137,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localDpMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+		return POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return OwnsLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+		return POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 243c9cc1..bb4aafef 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,22 +1,25 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
 
+#include <cmath>
+#include <cstring>
+
 LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
-	if(hkOwner != nullptr) {
-		hkManager = hkOwner->getHkManagerHandle();
-	}
-	else {
-		// config error, error output here.
-	}
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
-	OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
-			ownerId);
-	if(hkOwner == nullptr) {
-		// config error, error output here.
-	}
-	hkManager = hkOwner->getHkManagerHandle();
+    OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
 }
 
 LocalDataSet::~LocalDataSet() {
@@ -27,9 +30,50 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 	return mutex->lockMutex(timeoutMs);
 }
 
+ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, const size_t maxSize, bool bigEndian) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit, true);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                bigEndian);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
 ReturnValue_t LocalDataSet::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
 }
 
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
+        bool value) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1UL << shiftNumber;
+}
 
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 54da5562..0c3b3bd8 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -55,6 +55,20 @@ public:
 	 */
 	~LocalDataSet();
 
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, const size_t maxSize, bool bigEndian) const ;
 protected:
 private:
 	/**
@@ -79,6 +93,16 @@ private:
 	ReturnValue_t unlockDataPool() override;
 
 	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Sets the bit at the bit-position of a byte provided by its address
+	 * to the specified value (zero or one).
+	 * @param byte Pointer to byte to bitset.
+	 * @param position MSB first, 0 to 7 possible.
+	 * @param value Value to set.
+	 * @return
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position, bool value) const;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
index cf94f946..8d657879 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -40,9 +40,7 @@ class OwnsLocalDataPoolIF {
 public:
 	virtual~ OwnsLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING;
-	static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0XA0);
-	static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0xA1);
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual ReturnValue_t initializeHousekeepingPoolEntries(
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 75afc8ea..c6a33c83 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -96,6 +96,7 @@ public:
 
 	void setParameter(uint32_t parameter);
 	uint32_t getParameter() const;
+	sid_t getSid() const;
 
 	void setHkReportMessage(sid_t sid, store_address_t storeId);
 	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
@@ -106,7 +107,7 @@ public:
 	virtual size_t getMinimumMessageSize() const override;
 	virtual void clear() override;
 private:
-	sid_t getSid() const;
+
 	void setSid(sid_t sid);
 
 	virtual uint8_t* getData() override;
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 870efb46..ddee539e 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -61,8 +61,9 @@ enum {
 	MUTEX_IF, //MUX 55
 	MESSAGE_QUEUE_IF,//MQI 56
 	SEMAPHORE_IF, //SPH 57
-	HOUSEKEEPING, //HK 58
+	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
+	HOUSEKEEPING_MANAGER, //HKM 60
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 60ae2d45655330a3d81dd897b8dfb0ff6456dcd4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 14:25:03 +0200
Subject: [PATCH 0458/1292] continued with hk data pool

added deadline missed check for fixed timeslot task,
improved doc for both periodic task and fixed timeslot task
---
 datapool/DataSetBase.cpp               |  4 ++
 datapool/DataSetBase.h                 |  2 +
 datapool/DataSetIF.h                   |  1 +
 datapoollocal/LocalDataPoolManager.cpp | 40 ++++++++++++++++-
 datapoollocal/LocalDataPoolManager.h   |  2 +
 datapoollocal/LocalDataSet.cpp         | 16 +++++++
 datapoollocal/LocalDataSet.h           |  5 ++-
 datapoollocal/OwnsLocalDataPoolIF.h    | 30 +++++++++++--
 devicehandlers/DeviceHandlerBase.cpp   | 17 +++++++-
 devicehandlers/DeviceHandlerBase.h     | 11 ++++-
 events/EventManager.cpp                | 11 +++--
 events/EventManager.h                  |  4 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp    | 60 +++++++++++++++++---------
 osal/FreeRTOS/FixedTimeslotTask.h      | 49 ++++++++++-----------
 osal/FreeRTOS/PeriodicTask.cpp         | 30 +++++++------
 osal/FreeRTOS/PeriodicTask.h           | 49 ++++++++++++---------
 serialize/SerializeAdapter.h           | 15 +++++++
 tasks/ExecutableObjectIF.h             |  6 ++-
 tmtcservices/CommandingServiceBase.cpp |  5 ++-
 tmtcservices/CommandingServiceBase.h   |  4 +-
 20 files changed, 261 insertions(+), 100 deletions(-)

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index 60b20f29..b788d05d 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -53,6 +53,10 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	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
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index a914ec6b..8f7d892a 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -101,6 +101,8 @@ public:
 	 */
 	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, bool bigEndian) const override;
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 9c5b13c8..437f324f 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -43,6 +43,7 @@ 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
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a9d131eb..e0731a96 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -33,7 +33,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
 		ReturnValue_t result =
-				owner->initializeHousekeepingPoolEntries(localDpMap);
+				owner->initializePoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -48,6 +48,14 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		HousekeepingMessage& message) {
     Command_t command = message.getCommand();
     switch(command) {
+    // I think those are the only commands which can be handled here..
+    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
+    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
+        // We should use OwnsLocalPoolDataIF to specify those functions..
+        return HasReturnvaluesIF::RETURN_OK;
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
+        return generateSetStructurePacket(message.getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
         return generateHousekeepingPacket(message.getSid());
@@ -114,13 +122,41 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	return result;
 }
 
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
+    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, false);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
+
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         store_address_t *storeId, LocalDataSet* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket: "
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 "Could not get free element from IPC store." << std::endl;
         return result;
     }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c649cd68..b6491724 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,6 +56,8 @@ public:
 	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateSetStructurePacket(sid_t sid);
+
 	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
 
 	/**
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index bb4aafef..27ad4bc2 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,5 +1,6 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/serialize/SerializeAdapter.h>
 
 #include <cmath>
 #include <cstring>
@@ -67,6 +68,21 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
 	return mutex->unlockMutex();
 }
 
+ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, const size_t maxSize, bool bigEndian) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, bigEndian);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
         bool value) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 0c3b3bd8..48138e63 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -68,7 +68,10 @@ public:
 	 * @return
 	 */
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, const size_t maxSize, bool bigEndian) const ;
+	        size_t* size, const size_t maxSize, bool bigEndian) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+            size_t* size, const size_t maxSize, bool bigEndian) const;
 protected:
 private:
 	/**
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/OwnsLocalDataPoolIF.h
index 8d657879..6fc10889 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/OwnsLocalDataPoolIF.h
@@ -42,12 +42,36 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t initializeHousekeepingPoolEntries(
-			LocalDataPool& localDataPoolMap) = 0;
-	//virtual float setMinimalHkSamplingFrequency() = 0;
+
+	/** Is used by pool owner to initialize the pool map once */
+	virtual ReturnValue_t initializePoolEntries(
+	        LocalDataPool& localDataPoolMap) = 0;
+
+	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
 	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+
+	/* These function can be implemented by pool owner, as they are required
+	 * by the housekeeping message interface */
+	virtual ReturnValue_t addDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t removeDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
 };
 
 #endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index bf699848..1ae056a6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1350,7 +1350,7 @@ void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
 void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
+	executingTask = task_;
 }
 
 // Default implementations empty.
@@ -1360,7 +1360,7 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
-ReturnValue_t DeviceHandlerBase::initializeHousekeepingPoolEntries(
+ReturnValue_t DeviceHandlerBase::initializePoolEntries(
 		LocalDataPool &localDataPoolMap) {
 	return RETURN_OK;
 }
@@ -1369,6 +1369,19 @@ LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
+ReturnValue_t DeviceHandlerBase::addDataSet(sid_t sid) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::removeDataSet(sid_t sid) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
+        dur_seconds_t newInterval) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4ee3d652..1290742c 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -477,12 +477,17 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeHousekeepingPoolEntries(
+	virtual ReturnValue_t initializePoolEntries(
 				LocalDataPool& localDataPoolMap) override;
 
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
+	virtual ReturnValue_t addDataSet(sid_t sid) override;
+	virtual ReturnValue_t removeDataSet(sid_t sid) override;
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
@@ -703,7 +708,9 @@ protected:
 
 	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
 
-	PeriodicTaskIF* executingTask = nullptr;//!< Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	//! Pointer to the task which executes this component, is invalid
+	//! before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;
 
 	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
 
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 73e77e94..539f9e27 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -8,13 +8,16 @@
 const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
 		sizeof(ReporterRangeMatcher) };
-//If one checks registerListener calls, there are around 40 (to max 50) objects registering for certain events.
-//Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher. So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// If one checks registerListener calls, there are around 40 (to max 50)
+// objects registering for certain events.
+// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
+// So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
 EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId), eventReportQueue(NULL), mutex(NULL), factoryBackend(
-				0, POOL_SIZES, N_ELEMENTS, false, true) {
+		SystemObject(setObjectId),
+		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
diff --git a/events/EventManager.h b/events/EventManager.h
index 76dde9f8..6fac8352 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -36,11 +36,11 @@ public:
 	ReturnValue_t performOperation(uint8_t opCode);
 protected:
 
-	MessageQueueIF* eventReportQueue;
+	MessageQueueIF* eventReportQueue = nullptr;
 
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
-	MutexIF* mutex;
+	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool<N_POOLS> factoryBackend;
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 18ec1092..de99413e 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,6 +1,7 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include "FixedTimeslotTask.h"
 
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
@@ -18,16 +19,19 @@ FixedTimeslotTask::~FixedTimeslotTask() {
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
 
-	//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place.
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	// Task should not start until explicitly requested
-	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
-	// but not if the scheduler is not running.
-	// to be able to accommodate both cases we check a member which is set in #startTask()
-	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
-	// if it is set, the scheduler was not running before #startTask() was called and we can continue
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
 
-	if (!originalTask->started) {
+	if (not originalTask->started) {
 		vTaskSuspend(NULL);
 	}
 
@@ -81,7 +85,8 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 }
 
 void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
 	SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
@@ -101,17 +106,30 @@ void FixedTimeslotTask::taskFunctionality() {
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		//The component for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			// we need to wait before executing the current slot
-			//this gives us the time to wait:
-			intervalMs = this->pst.getIntervalToPreviousSlotMs();
-			interval = pdMS_TO_TICKS(intervalMs);
-			vTaskDelayUntil(&xLastWakeTime, interval);
-			//TODO deadline missed check
-		}
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        /* If all operations are finished and the difference of the
+	         * current time minus the last wake time is larger than the
+	         * expected wait period, a deadline was missed. */
+	        if(xTaskGetTickCount() - xLastWakeTime >=
+	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+#ifdef DEBUG
+	            sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+	                    " missed deadline!\n" << std::flush;
+#endif
+	            if(deadlineMissedFunc != nullptr) {
+	                this->deadlineMissedFunc();
+	            }
+	            // Continue immediately, no need to wait.
+	            break;
+	        }
+
+	        // we need to wait before executing the current slot
+	        //this gives us the time to wait:
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
 	}
 }
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index fe93daff..39db667c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,12 +1,12 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
 #include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
@@ -29,16 +29,18 @@ public:
 
 	/**
 	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
 	 */
 	virtual ~FixedTimeslotTask(void);
 
 	ReturnValue_t startTask(void);
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
 	 */
 	static void missedDeadlineCounter();
 	/**
@@ -62,30 +64,29 @@ protected:
 	FixedSlotSequence pst;
 
 	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
 	 */
 	void (*deadlineMissedFunc)(void);
 	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
 	 */
 	static void taskEntryPoint(void* argument);
 
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
 };
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index a8e40561..31867639 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -12,8 +12,8 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			setStack, this, setPriority, &handle);
 	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. Status: "
-		           << status << std::endl;
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
 	}
 
 }
@@ -23,14 +23,17 @@ PeriodicTask::~PeriodicTask(void) {
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {
-	//The argument is re-interpreted as PeriodicTask. The Task object is global, so it is found from any place.
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
 	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	// Task should not start until explicitly requested
-	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
-	// but not if the scheduler is not running.
-	// to be able to accommodate both cases we check a member which is set in #startTask()
-	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
-	// if it is set, the scheduler was not running before #startTask() was called and we can continue
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
 
 	if (not originalTask->started) {
 		vTaskSuspend(NULL);
@@ -61,9 +64,9 @@ void PeriodicTask::taskFunctionality() {
 	TickType_t xLastWakeTime;
 	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
 	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to explicitly.
-	 After this assignment, xLastWakeTime is updated automatically internally within
-	 vTaskDelayUntil(). */
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
 	xLastWakeTime = xTaskGetTickCount();
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -76,12 +79,15 @@ void PeriodicTask::taskFunctionality() {
 		 * current time minus the last wake time is larger than the
 		 * wait period, a deadline was missed. */
 		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
+#ifdef DEBUG
 			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
 					" missed deadline!\n" << std::flush;
+#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}
+
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
 
 	}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index a449328e..fd1dd0df 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -5,10 +5,8 @@
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 #include <vector>
 
@@ -22,7 +20,8 @@ class ExecutableObjectIF;
 class PeriodicTask: public PeriodicTaskIF {
 public:
 	/**
-	 * @brief	Standard constructor of the class.
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @details
 	 * The class is initialized without allocated objects.
 	 * These need to be added with #addComponent.
@@ -38,8 +37,9 @@ public:
 	 * The function pointer to the deadline missed function that shall
 	 * be assigned.
 	 */
-	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
-			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	PeriodicTask(const char *name, TaskPriority setPriority,
+	        TaskStackSize setStack, TaskPeriod setPeriod,
+	        void (*setDeadlineMissedFunc)());
 	/**
 	 * @brief	Currently, the executed object's lifetime is not coupled with
 	 * 			the task object's lifetime, so the destructor is empty.
@@ -58,7 +58,9 @@ public:
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.
 	 * @param object Id of the object to add.
-	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 * @return
+	 * -@c RETURN_OK on success
+	 * -@c RETURN_FAILED if the object could not be added.
 	 */
 	ReturnValue_t addComponent(object_id_t object);
 
@@ -69,40 +71,47 @@ protected:
 	bool started;
 	TaskHandle_t handle;
 
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
 	/**
 	 * @brief	This attribute holds a list of objects to be executed.
 	 */
 	ObjectList objectList;
 	/**
 	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
 	 */
 	TaskPeriod period;
 	/**
 	 * @brief	The pointer to the deadline-missed function.
-	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
-	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
-	 * 			of the periodic task.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed so each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
 	 */
 	void (*deadlineMissedFunc)(void);
 	/**
 	 * @brief	This is the function executed in the new task's context.
-	 * @details	It converts the argument back to the thread object type and copies the class instance
-	 * 			to the task context. The taskFunctionality method is called afterwards.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context. The taskFunctionality method is
+	 * called afterwards.
 	 * @param	A pointer to the task object itself is passed as argument.
 	 */
 
 	static void taskEntryPoint(void* argument);
 	/**
 	 * @brief	The function containing the actual functionality of the task.
-	 * @details	The method sets and starts
-	 * 			the task's period, then enters a loop that is repeated as long as the isRunning
-	 * 			attribute is true. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
-	 * 			until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called.
+	 * Afterwards the checkAndRestartPeriod system call blocks the task until
+	 * the next period.
+	 * On missing the deadline, the deadlineMissedFunction is executed.
 	 */
 	void taskFunctionality(void);
 };
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 87e4457a..62c20204 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -65,6 +65,21 @@
 // No type specification necessary here.
 class AutoSerializeAdapter {
 public:
+    /**
+     * Serialize object into buffer.
+     * @tparam T Type of object.
+     * @param object Object to serialize
+     * @param buffer
+     * Serialize into this buffer, pointer to pointer has to be passed,
+     * *buffer will be incremented automatically.
+     * @param size [out]
+     * Update passed size value, will be incremented by serialized size
+     * @param max_size
+     * Maximum size for range checking
+     * @param bigEndian
+     * Set to true if host-to-network conversion or vice-versa is needed
+     * @return
+     */
 	template<typename T>
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
 			size_t* size, const size_t max_size, bool bigEndian) {
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 5c5955c1..516b4084 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -37,8 +37,10 @@ public:
 
 	/**
 	 * @brief Function called during setup assignment of object to task
-	 * @details Has to be called from the function that assigns the object to a task and
-	 * 			enables the object implementation to overwrite this function and get a reference to the executing task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
 	 * @param task_ Pointer to the taskIF of this task
 	 */
 	virtual void setTaskIF(PeriodicTaskIF* task_) {
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 97856b40..4d29c10e 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -412,5 +412,6 @@ void CommandingServiceBase::checkTimeout() {
 	}
 }
 
-
-
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 5e2c3171..05f50709 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -97,9 +97,7 @@ public:
 	 * 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_){
-		executingTask = task_;
-	};
+	virtual void setTaskIF(PeriodicTaskIF* task_);
 
 protected:
 	/**

From eb4ce980fe93feaba64f01cf13d43d96aaa7d20a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 14:32:04 +0200
Subject: [PATCH 0459/1292] small fixed

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +-
 osal/FreeRTOS/PeriodicTask.h        | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index de99413e..ea324d35 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,7 +114,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	        if(xTaskGetTickCount() - xLastWakeTime >=
 	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
 #ifdef DEBUG
-	            sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;
 #endif
 	            if(deadlineMissedFunc != nullptr) {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index fd1dd0df..b9930a73 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -22,6 +22,7 @@ public:
 	/**
 	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * TODO: why does this need to be called before vTaskStartScheduler?
 	 * @details
 	 * The class is initialized without allocated objects.
 	 * These need to be added with #addComponent.

From 2de811e0afd0ae6a1dc9e4d700bedc693a888691 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:14:56 +0200
Subject: [PATCH 0460/1292] moved timeslot files to task folder

implmented setting task IF for regular periodic tasks
---
 osal/FreeRTOS/FixedTimeslotTask.cpp           | 10 +++----
 osal/FreeRTOS/FixedTimeslotTask.h             | 10 +++----
 osal/FreeRTOS/PeriodicTask.cpp                | 14 ++++++----
 osal/FreeRTOS/PeriodicTask.h                  |  9 ++++---
 osal/host/FixedTimeslotTask.h                 |  2 +-
 osal/linux/PeriodicPosixTask.cpp              |  7 ++++-
 osal/linux/PeriodicPosixTask.h                |  3 ++-
 .../FixedSequenceSlot.cpp                     | 15 ++++-------
 {devicehandlers => tasks}/FixedSequenceSlot.h | 25 +++++++-----------
 .../FixedSlotSequence.cpp                     |  2 +-
 {devicehandlers => tasks}/FixedSlotSequence.h |  6 ++---
 tasks/FixedTimeslotTaskIF.h                   | 11 ++++++--
 tasks/PeriodicTaskIF.h                        | 26 ++++++++++++++++---
 13 files changed, 82 insertions(+), 58 deletions(-)
 rename {devicehandlers => tasks}/FixedSequenceSlot.cpp (53%)
 rename {devicehandlers => tasks}/FixedSequenceSlot.h (78%)
 rename {devicehandlers => tasks}/FixedSlotSequence.cpp (98%)
 rename {devicehandlers => tasks}/FixedSlotSequence.h (97%)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index ea324d35..f3a65fcd 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -62,11 +62,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		if(slotTimeMs == 0) {
-			// FreeRTOS throws a sanity error for zero values, so we set
-			// the time to one millisecond.
-			slotTimeMs = 1;
-		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -101,7 +96,9 @@ void FixedTimeslotTask::taskFunctionality() {
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time
-	vTaskDelayUntil(&xLastWakeTime, interval);
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -137,3 +134,4 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 39db667c..183fad20 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
@@ -49,13 +49,13 @@ public:
 	static uint32_t deadlineMissedCount;
 
 	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
+			int8_t executionStep) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkSequence() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 
 protected:
 	bool started;
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 31867639..43928f7c 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -70,9 +70,8 @@ void PeriodicTask::taskFunctionality() {
 	xLastWakeTime = xTaskGetTickCount();
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (auto const& object: objectList) {
+			object->performOperation();
 		}
 
 		/* If all operations are finished and the difference of the
@@ -93,12 +92,17 @@ void PeriodicTask::taskFunctionality() {
 	}
 }
 
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	if(setTaskIF) {
+	    newObject->setTaskIF(this);
+	}
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index b9930a73..a580f519 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -54,7 +54,7 @@ public:
 	 * 			The address of the task object is passed as an argument
 	 * 			to the system call.
 	 */
-	ReturnValue_t startTask(void);
+	ReturnValue_t startTask() override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.
@@ -63,11 +63,12 @@ public:
 	 * -@c RETURN_OK on success
 	 * -@c RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index bb2f757a..b12cc6d3 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index df5bbf93..ca7011b0 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -24,9 +24,14 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implements ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	if(setTaskIF) {
+	    newObject->setTaskIF(this);
+	}
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 85de0d59..1d62a565 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -39,7 +39,8 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) override;
 
 	uint32_t getPeriodMs() const;
 
diff --git a/devicehandlers/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
similarity index 53%
rename from devicehandlers/FixedSequenceSlot.cpp
rename to tasks/FixedSequenceSlot.cpp
index bb97a8e5..c46b4fc0 100644
--- a/devicehandlers/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,19 +1,14 @@
-/**
- * @file	PollingSlot.cpp
- * @brief	This file defines the PollingSlot class.
- * @date	19.12.2012
- * @author	baetz
- */
-
-#include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
-		handler(NULL), pollingTimeMs(setTime), opcode(setSequenceId) {
+		pollingTimeMs(setTime), opcode(setSequenceId) {
 	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	handler->setTaskIF(executingTask);
+	if(executingTask != nullptr) {
+	    handler->setTaskIF(executingTask);
+	}
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/devicehandlers/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
similarity index 78%
rename from devicehandlers/FixedSequenceSlot.h
rename to tasks/FixedSequenceSlot.h
index 7868cce3..72a35c74 100644
--- a/devicehandlers/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,22 +1,17 @@
-/**
- * @file	FixedSequenceSlot.h
- * @brief	This file defines the PollingSlot class.
- * @date	19.12.2012
- * @author	baetz
- */
-
-#ifndef FIXEDSEQUENCESLOT_H_
-#define FIXEDSEQUENCESLOT_H_
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 class PeriodicTaskIF;
 
 /**
- * @brief	This class is the representation of a single polling sequence table entry.
- *
- * @details	The PollingSlot class is the representation of a single polling
- * 			sequence table entry.
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
  */
 class FixedSequenceSlot {
 public:
@@ -27,7 +22,7 @@ public:
 	/**
 	 * @brief	Handler identifies which device handler object is executed in this slot.
 	 */
-	ExecutableObjectIF*	handler;
+	ExecutableObjectIF*	handler = nullptr;
 
 	/**
 	 * @brief	This attribute defines when a device handler object is executed.
@@ -43,7 +38,7 @@ public:
 	 * @details	The state of this value decides what communication routine is
 	 * 			called in the PST executable or the device handler object.
 	 */
-	uint8_t			opcode;
+	uint8_t	opcode;
 
 	/**
 	 * @brief 	Operator overload for the comparison operator to
diff --git a/devicehandlers/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
similarity index 98%
rename from devicehandlers/FixedSlotSequence.cpp
rename to tasks/FixedSlotSequence.cpp
index aeb97f3a..3e542bfc 100644
--- a/devicehandlers/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,5 +1,5 @@
-#include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
diff --git a/devicehandlers/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
similarity index 97%
rename from devicehandlers/FixedSlotSequence.h
rename to tasks/FixedSlotSequence.h
index 145cdbc3..7de1884c 100644
--- a/devicehandlers/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,8 +1,8 @@
-#ifndef FIXEDSLOTSEQUENCE_H_
-#define FIXEDSLOTSEQUENCE_H_
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
 
-#include <framework/devicehandlers/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 
 #include <set>
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 7edd6751..023b5ee0 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -12,11 +12,18 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
 
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
 	virtual ReturnValue_t addSlot(object_id_t componentId,
 			uint32_t slotTimeMs, int8_t executionStep) = 0;
+	/** Check whether the sequence is valid */
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 
-
-
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 304a7de6..6f490977 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,9 +1,11 @@
-#ifndef PERIODICTASKIF_H_
-#define PERIODICTASKIF_H_
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
 
 #include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/timemanager/Clock.h>
 #include <cstddef>
 class ExecutableObjectIF;
+
 /**
  * New version of TaskIF
  * Follows RAII principles, i.e. there's no create or delete method.
@@ -17,11 +19,27 @@ public:
 	 */
 	virtual ~PeriodicTaskIF() { }
 	/**
-	 * @brief	With the startTask method, a created task can be started for the first time.
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
 	 */
 	virtual ReturnValue_t startTask() = 0;
 
-	virtual ReturnValue_t addComponent(object_id_t object) {return HasReturnvaluesIF::RETURN_FAILED;};
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object,
+	        bool setTaskIF = true) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
 
 	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
 

From 1b0e7c84c7ac2fff9e8b7129110271681c147620 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:15:58 +0200
Subject: [PATCH 0461/1292] linux periodic task improvements

---
 osal/linux/PeriodicPosixTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index ca7011b0..afdd3a52 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,12 +1,13 @@
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
 #include <framework/osal/linux/PeriodicPosixTask.h>
 
+#include <errno.h>
+
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
 		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
-		PosixThread(name_,priority_,stackSize_),objectList(),started(false),
-		periodMs(period_),deadlineMissedFunc(deadlineMissedFunc_) {
+		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
+		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
 }
 
 PeriodicPosixTask::~PeriodicPosixTask() {

From 2c04b87418f2552f836775e4c3eaa1b14bcd033c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:18:00 +0200
Subject: [PATCH 0462/1292] corrected includes

---
 osal/linux/FixedTimeslotTask.h | 2 +-
 osal/rtems/PollingTask.cpp     | 2 +-
 osal/rtems/PollingTask.h       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 916e6d6c..409cd982 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
 
 #include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/osal/linux/PosixThread.h>
 #include <pthread.h>
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 6b0c0fbd..a6be7ddf 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,4 +1,4 @@
-#include <framework/devicehandlers/FixedSequenceSlot.h>
+#include <framework/tasks/FixedSequenceSlot.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/osal/rtems/PollingTask.h>
 #include <framework/osal/rtems/RtemsBasic.h>
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 82ec65a2..5bf8cf57 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
 #ifndef POLLINGTASK_H_
 #define POLLINGTASK_H_
 
-#include <framework/devicehandlers/FixedSlotSequence.h>
+#include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include "TaskBase.h"
 

From 3936fe93609875c7f49332a8a5f24b09d67b7c1c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:34:19 +0200
Subject: [PATCH 0463/1292] linux fix

---
 osal/linux/PeriodicPosixTask.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index afdd3a52..fe8ac19c 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -22,7 +22,8 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 	return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
+		bool setTaskIF) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {

From 95b646046b162d2c47e0a231ae8fad35cc733f21 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:43:29 +0200
Subject: [PATCH 0464/1292] debug output working again

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 539f9e27..1eb88c32 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -133,7 +133,7 @@ void EventManager::printEvent(EventMessage* message) {
 		break;
 	default:
 		string = translateObject(message->getReporter());
-		sif::error << "EVENT: ";
+		sif::error << "EventManager: ";
 		if (string != 0) {
 			sif::error << string;
 		} else {

From 45a55044ddd3ded4cac2522313f1db53ac62c1d4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 20:47:36 +0200
Subject: [PATCH 0465/1292] using debug stream now

---
 events/EventManager.cpp | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 1eb88c32..30f5ed71 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -133,20 +133,23 @@ void EventManager::printEvent(EventMessage* message) {
 		break;
 	default:
 		string = translateObject(message->getReporter());
-		sif::error << "EventManager: ";
+		sif::debug << "EventManager: ";
 		if (string != 0) {
-			sif::error << string;
-		} else {
-			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+			sif::debug << string;
 		}
-		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
-				<< std::dec << message->getEventId() << ") " << std::endl;
-
-		sif::error << std::hex << "P1 Hex: 0x" << message->getParameter1() << ", P1 Dec: "
-		        << std::dec << message->getParameter1() << std::endl;
-		sif::error << std::hex << "P2 Hex: 0x" << message->getParameter2() << ", P2 Dec: "
-		        <<  std::dec << message->getParameter2() << std::endl;
+		else {
+			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::debug << " reported " << translateEvents(message->getEvent())
+				<< " (" << std::dec << message->getEventId() << ") "
+				<< std::endl;
 
+		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
+				<< ", P1 Dec: " << std::dec << message->getParameter1()
+				<< std::endl;
+		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
+				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
+				<< std::endl;
 		break;
 	}
 

From 109fdad8b36ca1fe99f0ebad89fb28b04fa7d197 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 15:34:35 +0200
Subject: [PATCH 0466/1292] size check for message queue

---
 osal/FreeRTOS/MessageQueue.cpp | 11 +++++++++--
 osal/FreeRTOS/MessageQueue.h   |  1 +
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index d44b0bc0..cf6130f8 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -7,7 +7,8 @@
 // As a first step towards this, introduces system context variable which needs
 // to be switched manually
 // Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize) {
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == NULL) {
 		sif::error << "MessageQueue: Creation failed" << std::endl;
@@ -120,10 +121,16 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
+    if(message->getMaximumMessageSize() > maxMessageSize) {
+    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
+    			"too large for queue!" << std::endl;
+    	return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
     if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
                 static_cast<const void*>(message->getBuffer()), 0);
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index c13a8a20..b7e52bb3 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -204,6 +204,7 @@ private:
 	QueueHandle_t handle;
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
 	//!< Stores the current system context
 	CallContext callContext =  CallContext::TASK;
 };

From 3b2fa978e1b86ccf1b9c113ab958dcaf81e63b4a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 19:06:10 +0200
Subject: [PATCH 0467/1292] replaced break with continue

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index f3a65fcd..5d16a408 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -118,7 +118,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	                this->deadlineMissedFunc();
 	            }
 	            // Continue immediately, no need to wait.
-	            break;
+	            continue;
 	        }
 
 	        // we need to wait before executing the current slot

From 5734a0a0e948df50c57f9d589a2eddac479bb70b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 19:22:52 +0200
Subject: [PATCH 0468/1292] some fixes necessary to perform size check

---
 action/ActionHelper.cpp               |  3 ++-
 datalinklayer/MapPacketExtraction.cpp |  3 ++-
 ipc/MessageQueueSenderIF.h            |  2 +-
 monitoring/LimitViolationReporter.cpp |  3 ++-
 osal/FreeRTOS/MessageQueue.cpp        |  8 ++++----
 osal/FreeRTOS/MessageQueue.h          |  5 +++--
 osal/FreeRTOS/QueueFactory.cpp        |  6 +++---
 tmtcservices/VerificationReporter.cpp | 12 ++++++++----
 8 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 0df5f2d4..026df4e1 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,7 +101,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 	//TODO Service Implementation sucks at the moment
 	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE);
 	} else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 4ea45e89..87b46556 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -117,7 +117,8 @@ ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
 	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
 	if (status == RETURN_OK) {
 		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE);
 	}
 	return status;
 }
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 3172454f..912f4d7e 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -15,7 +15,7 @@ public:
 	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
+			MessageQueueMessageIF* message, size_t maxMessageSize,
 			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
 			bool ignoreFault=false);
 private:
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 1378d754..c6e2b5db 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -34,7 +34,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	MessageQueueMessage message;
 	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 ReturnValue_t LimitViolationReporter::checkClassLoaded() {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index cf6130f8..0280869d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,7 +50,7 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+	return sendMessageFromMessageQueue(sendTo, message, maxMessageSize, sentFrom,
 			ignoreFault, callContext);
 }
 
@@ -121,11 +121,11 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-        bool ignoreFault, CallContext callContext) {
+        MessageQueueMessageIF* message, size_t maxSize,
+        MessageQueueId_t sentFrom, bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(message->getMaximumMessageSize() > maxMessageSize) {
+    if(message->getMaximumMessageSize() > maxSize) {
     	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
     			"too large for queue!" << std::endl;
     	return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b7e52bb3..e87e884f 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -194,8 +194,9 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault=false,
+			CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index beb4969b..ec678890 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,9 +7,9 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom, bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
 			sentFrom,ignoreFault);
 }
 
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index b0247944..a54c1f8d 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -22,7 +22,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getAcknowledgeFlags(),
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -37,7 +38,8 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	}
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -55,7 +57,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), error_code, step,
 			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
@@ -72,7 +75,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	}
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
 			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue, &message);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "

From dadc867d9ed44d82782d2f3f66cc0f54b50bfe00 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 20:18:13 +0200
Subject: [PATCH 0469/1292] adapted MessageQueueSenderIF function calls

---
 events/EventManager.cpp             |  3 ++-
 events/EventManagerIF.h             |  3 ++-
 health/HealthHelper.cpp             |  6 ++++--
 modes/ModeHelper.cpp                | 11 +++++++----
 osal/FreeRTOS/FixedTimeslotTask.cpp | 16 +++++++---------
 osal/FreeRTOS/MessageQueue.cpp      | 12 ++++++++++--
 osal/FreeRTOS/QueueFactory.cpp      |  5 +++++
 parameters/ParameterHelper.cpp      |  6 ++++--
 tmtcpacket/pus/TmPacketStored.cpp   |  3 ++-
 9 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 30f5ed71..a5d14569 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -52,7 +52,8 @@ void EventManager::notifyListeners(EventMessage* message) {
 	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
 		if (iter->second.match(message)) {
 			MessageQueueSenderIF::sendMessage(iter->first, message,
-					message->getSender());
+			        MessageQueueMessage::MAX_MESSAGE_SIZE,
+			        message->getSender());
 		}
 	}
 	unlockMutex();
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bc0de432..053e320b 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -44,7 +44,8 @@ public:
 				eventmanagerQueue = eventmanager->getEventReportQueue();
 			}
 		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message,
+		        MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
 	}
 
 };
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index df259b52..935bf5e3 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -70,7 +70,8 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+	        MessageQueueMessage::MAX_MESSAGE_SIZE,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 	}
@@ -90,7 +91,8 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 		reply.setReplyRejected(result, command->getCommand());
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+	        MessageQueueMessage::MAX_MESSAGE_SIZE,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
 
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index b79082af..f636c0bf 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -28,7 +28,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-					owner->getCommandQueue());
+			        MessageQueueMessage::MAX_MESSAGE_SIZE,
+			        owner->getCommandQueue());
 			break;
 		}
 		//Free to start transition
@@ -50,7 +51,8 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
 		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE,
+		       owner->getCommandQueue());
 	}
 		break;
 	case ModeMessage::CMD_MODE_ANNOUNCE:
@@ -95,7 +97,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE, owner->getCommandQueue());
 	}
 }
 
@@ -109,7 +111,8 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
 		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-				owner->getCommandQueue());
+		        MessageQueueMessage::MAX_MESSAGE_SIZE,
+		        owner->getCommandQueue());
 	}
 }
 
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 5d16a408..4d4ec996 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -105,11 +105,14 @@ void FixedTimeslotTask::taskFunctionality() {
 		//The component for this slot is executed and the next one is chosen.
 	    this->pst.executeAndAdvance();
 	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
 	        /* If all operations are finished and the difference of the
 	         * current time minus the last wake time is larger than the
 	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >=
-	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
 #ifdef DEBUG
 	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;
@@ -117,14 +120,9 @@ void FixedTimeslotTask::taskFunctionality() {
 	            if(deadlineMissedFunc != nullptr) {
 	                this->deadlineMissedFunc();
 	            }
-	            // Continue immediately, no need to wait.
-	            continue;
 	        }
-
-	        // we need to wait before executing the current slot
-	        //this gives us the time to wait:
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
 	    }
 	}
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 0280869d..c9adf229 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -80,6 +80,12 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+    if(message->getMaximumMessageSize() < maxMessageSize) {
+        sif::error << "MessageQueue::receiveMessage: Message size "
+                << message->getMaximumMessageSize() <<
+                " too small to receive data!" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){
@@ -126,8 +132,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     message->setSender(sentFrom);
     BaseType_t result;
     if(message->getMaximumMessageSize() > maxSize) {
-    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size"
-    			"too large for queue!" << std::endl;
+    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
+    			 << message->getMaximumMessageSize() << " too large for queue"
+    			  " with max. message size " << maxSize << "!"
+    			 << std::endl;
     	return HasReturnvaluesIF::RETURN_FAILED;
     }
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index ec678890..d754b2b9 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -9,6 +9,11 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, size_t maxSize,
 			MessageQueueId_t sentFrom, bool ignoreFault) {
+    if(maxSize == 0) {
+        sif::error << "MessageQueueSenderIF::sendMessage: Max Size is 0!"
+                << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
 			sentFrom,ignoreFault);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 8b91020f..68ff5ab0 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -107,7 +107,8 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -129,5 +130,6 @@ void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 	MessageQueueMessage message;
 	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply,
+	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
 }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 42d0d038..d589db8d 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -117,7 +117,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom);
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+	        &tmMessage, MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {

From 6a7f47e06d95c91f8f9885c38f0716894735a10a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:46:44 +0200
Subject: [PATCH 0470/1292] doc fix

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 56 ++++++++++++++++++++---------
 osal/FreeRTOS/FixedTimeslotTask.h   |  6 +++-
 2 files changed, 45 insertions(+), 17 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 4d4ec996..57c927f9 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -82,7 +82,7 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the
     // start time for the first entry.
-	SlotListIter slotListIter = pst.current;
+	auto slotListIter = pst.current;
 
 	//The start time for the first entry is read.
 	uint32_t intervalMs = slotListIter->pollingTimeMs;
@@ -90,9 +90,9 @@ void FixedTimeslotTask::taskFunctionality() {
 
 	TickType_t xLastWakeTime;
 	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to explicitly.
-	 After this assignment, xLastWakeTime is updated automatically internally within
-	 vTaskDelayUntil(). */
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time
@@ -109,18 +109,8 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        /* If all operations are finished and the difference of the
-	         * current time minus the last wake time is larger than the
-	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
-#ifdef DEBUG
-	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-	                    " missed deadline!\n" << std::flush;
-#endif
-	            if(deadlineMissedFunc != nullptr) {
-	                this->deadlineMissedFunc();
-	            }
-	        }
+	        checkMissedDeadline(xLastWakeTime, interval);
+
 	        // Wait for the interval. This exits immediately if a deadline was
 	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
@@ -128,6 +118,40 @@ void FixedTimeslotTask::taskFunctionality() {
 	}
 }
 
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Tick count has overflown
+    if(currentTickCount < xLastWakeTime) {
+        // Time to wake has overflown as well. If the tick count
+        // is larger than the time to wake, a deadline was missed.
+        if(timeToWake < xLastWakeTime and
+                currentTickCount > timeToWake) {
+            handleMissedDeadline();
+        }
+    }
+    // No tick count overflow. If the timeToWake has not overflown
+    // and the current tick count is larger than the time to wake,
+    // a deadline was missed.
+    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 183fad20..32289f4b 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -12,7 +12,7 @@ class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * Keep in Mind that you need to call before vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
 	 * @param setPriority Number of priorities specified by
@@ -89,6 +89,10 @@ protected:
 	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
 #endif /* POLLINGTASK_H_ */

From a82dbcbd501a6c035430f8394d5eaebe06480918 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:47:18 +0200
Subject: [PATCH 0471/1292] minor doc correction

---
 osal/FreeRTOS/FixedTimeslotTask.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 32289f4b..27d08190 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -12,7 +12,7 @@ class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
 
 	/**
-	 * Keep in Mind that you need to call before vTaskStartScheduler()!
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
 	 * @param setPriority Number of priorities specified by

From 847292ea30e3c71678b0cf994e6436caad71a463 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:10:19 +0200
Subject: [PATCH 0472/1292] added overflow checking for periodic task

---
 osal/FreeRTOS/PeriodicTask.cpp | 47 +++++++++++++++++++++++++---------
 osal/FreeRTOS/PeriodicTask.h   |  4 +++
 2 files changed, 39 insertions(+), 12 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 43928f7c..fa49150e 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -74,18 +74,7 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 
-		/* If all operations are finished and the difference of the
-		 * current time minus the last wake time is larger than the
-		 * wait period, a deadline was missed. */
-		if(xTaskGetTickCount() - xLastWakeTime >= xPeriod) {
-#ifdef DEBUG
-			sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-					" missed deadline!\n" << std::flush;
-#endif
-			if(deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
+		checkMissedDeadline(xLastWakeTime, xPeriod);
 
 		vTaskDelayUntil(&xLastWakeTime, xPeriod);
 
@@ -110,3 +99,37 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Tick count has overflown
+    if(currentTickCount < xLastWakeTime) {
+        // Time to wake has overflown as well. If the tick count
+        // is larger than the time to wake, a deadline was missed.
+        if(timeToWake < xLastWakeTime and
+                currentTickCount > timeToWake) {
+            handleMissedDeadline();
+        }
+    }
+    // No tick count overflow. If the timeToWake has not overflown
+    // and the current tick count is larger than the time to wake,
+    // a deadline was missed.
+    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+        handleMissedDeadline();
+    }
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index a580f519..09aa6bc7 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -116,6 +116,10 @@ protected:
 	 * On missing the deadline, the deadlineMissedFunction is executed.
 	 */
 	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
 #endif /* PERIODICTASK_H_ */

From f7d55a8a37559bf9717b49e414c19db99c5113e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:15:35 +0200
Subject: [PATCH 0473/1292] equal to pull request now

---
 osal/FreeRTOS/PeriodicTask.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index fa49150e..170eb0a4 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -89,10 +89,11 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	            "it implement ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	if(setTaskIF) {
-	    newObject->setTaskIF(this);
-	}
 	objectList.push_back(newObject);
+
+	if(setTaskIF) {
+	     newObject->setTaskIF(this);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

From 64a02c55ba9c0f067e64b460b66750b613a31526 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 01:37:25 +0200
Subject: [PATCH 0474/1292] linux fixed, size checks added

---
 osal/linux/MessageQueue.cpp      | 50 +++++++++++++++++++++++++-------
 osal/linux/MessageQueue.h        |  6 ++--
 osal/linux/PeriodicPosixTask.cpp | 14 +++++----
 osal/linux/PeriodicPosixTask.h   |  6 ++--
 osal/linux/QueueFactory.cpp      |  6 ++--
 5 files changed, 58 insertions(+), 24 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 605dea2a..c4b24a13 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -11,7 +11,8 @@
 
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE) {
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
 	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
 	mq_attr attributes;
 	this->id = 0;
@@ -142,6 +143,19 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+	        sif::error << "MessageQueue::receiveMessage: Message size "
+	                << message->getMaximumMessageSize() <<
+	                " too small to receive data!" << std::endl;
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	unsigned int messagePriority = 0;
 	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
 			message->getMaximumMessageSize(),&messagePriority);
@@ -258,18 +272,20 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 	this->defaultDestination = defaultDestination;
 }
 
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message,sentFrom,ignoreFault);
-
-}
-
 ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
 
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, maxMessageSize,
+			sentFrom,ignoreFault);
+
+}
+
 MessageQueueId_t MessageQueue::getDefaultDestination() const {
 	return this->defaultDestination;
 }
@@ -281,8 +297,22 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
+		MessageQueueMessageIF *message, size_t maxSize,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() > maxSize) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
+				<< message->getMaximumMessageSize() << " too large for queue"
+				" with max. message size " << maxSize << "!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
 			reinterpret_cast<const char*>(message->getBuffer()),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 91066bf7..22725d18 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -149,7 +149,8 @@ protected:
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	/**
@@ -176,9 +177,10 @@ private:
 	/**
 	 * The name of the message queue, stored for unlinking
 	 */
-	char name[5];
+	char name[16];
 
 	static uint16_t queueCounter;
+	const size_t maxMessageSize;
 
 	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index fe8ac19c..db4005b0 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -31,10 +31,11 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 	            "it implements ExecutableObjectIF" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	objectList.push_back(newObject);
+
 	if(setTaskIF) {
 	    newObject->setTaskIF(this);
 	}
-	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -43,14 +44,14 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 }
 
 
-ReturnValue_t PeriodicPosixTask::startTask(void){
+ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
 	//sif::info << stackSize << std::endl;
 	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void PeriodicPosixTask::taskFunctionality(void){
+void PeriodicPosixTask::taskFunctionality(void) {
 	if(!started){
 		suspend();
 	}
@@ -64,14 +65,15 @@ void PeriodicPosixTask::taskFunctionality(void){
 		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status==0){
+			if(status == 0){
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
-			}else{
+			}
+			else {
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
 			}
-			if (this->deadlineMissedFunc != NULL) {
+			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 1d62a565..9b477e36 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -32,7 +32,7 @@ public:
 	 * 			The address of the task object is passed as an argument
 	 * 			to the system call.
 	 */
-	ReturnValue_t startTask(void);
+	ReturnValue_t startTask(void) override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.
@@ -42,9 +42,9 @@ public:
 	ReturnValue_t addComponent(object_id_t object,
 	        bool setTaskIF = true) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 
 private:
 	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 8bd9d52c..95264a42 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,10 +9,10 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
+			MessageQueueMessageIF* message, size_t maxSize,
+			MessageQueueId_t sentFrom, bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
+			maxSize, sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {

From c0beef44630f991e7307727bbcca6adc81bb48a0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:27:44 +0200
Subject: [PATCH 0475/1292] some include guards, todo comments

---
 devicehandlers/DeviceHandlerFailureIsolation.cpp | 2 +-
 devicehandlers/DeviceHandlerFailureIsolation.h   | 1 +
 fdir/ConfirmsFailuresIF.h                        | 1 +
 fdir/FailureIsolationBase.cpp                    | 3 ++-
 health/HealthTable.h                             | 4 ++--
 health/HealthTableIF.h                           | 8 +++++---
 ipc/MessageQueueSenderIF.h                       | 1 -
 returnvalues/HasReturnvaluesIF.h                 | 4 ++--
 8 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 1df2afa0..46e73cd8 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -137,7 +137,7 @@ void DeviceHandlerFailureIsolation::decrementFaultCounters() {
 
 void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
 	clearFaultCounters();
-	if (!recoveryCounter.incrementAndCheck()) {
+	if (not recoveryCounter.incrementAndCheck()) {
 		startRecovery(reason);
 	} else {
 		setFaulty(reason);
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 379edae3..4343d88b 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -31,6 +31,7 @@ protected:
 	bool hasPowerConfirmation = false;
 	MessageQueueId_t powerConfirmation;
 	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
 	static const uint32_t MAX_REBOOT = 1;
 	static const uint32_t REBOOT_TIME_MS = 180000;
 	static const uint32_t MAX_STRANGE_REPLIES = 10;
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 99cd212a..460749ee 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -4,6 +4,7 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+// TODO: Documentation.
 class ConfirmsFailuresIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 46114467..018fbe6a 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -9,7 +9,8 @@ FailureIsolationBase::FailureIsolationBase(object_id_t owner,
 		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
 		eventQueue(NULL), ownerId(owner), owner(NULL),
 		faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+			EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 FailureIsolationBase::~FailureIsolationBase() {
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 32a7eee2..194ad259 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHTABLE_H_
-#define HEALTHTABLE_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
 
 #include <framework/health/HealthTableIF.h>
 #include <framework/objectmanager/SystemObject.h>
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index 6fdfc2c0..c8d2c74a 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHTABLEIF_H_
-#define HEALTHTABLEIF_H_
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
 
 #include <framework/health/ManagesHealthIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
@@ -8,6 +8,8 @@
 
 
 class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
 	friend class HealthCommandingService;
 public:
 	virtual ~HealthTableIF() {
@@ -23,4 +25,4 @@ protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
 };
 
-#endif /* HEALTHTABLEIF_H_ */
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 912f4d7e..8bc14948 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -12,7 +12,6 @@ public:
 	/**
 	 * Allows sending messages without actually "owing" a message queue.
 	 * Not sure whether this is actually a good idea.
-	 * Must be implemented by a subclass.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, size_t maxMessageSize,
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9bbaf601..b51dfc82 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,5 +1,5 @@
-#ifndef HASRETURNVALUESIF_H_
-#define HASRETURNVALUESIF_H_
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
 
 #include <framework/returnvalues/FwClassIds.h>
 #include <config/returnvalues/classIds.h>

From e27310da40a420e78cc894746301d318da632bc9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:47:31 +0200
Subject: [PATCH 0476/1292] updates for tmtcbridge

---
 tmtcservices/TmTcBridge.cpp | 17 +++++------------
 tmtcservices/TmTcBridge.h   | 11 ++++++-----
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index c5eaf78b..f9a7d3bc 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -3,6 +3,7 @@
 #include <framework/ipc/QueueFactory.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
 TmTcBridge::TmTcBridge(object_id_t objectId_,
         object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
@@ -85,7 +86,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 		return RETURN_FAILED;
 	}
 
-	if(tmStored && communicationLinkUp) {
+	if(tmStored and communicationLinkUp) {
 		result = handleStoredTm();
 	}
 	return result;
@@ -141,11 +142,11 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
 	uint8_t counter = 0;
 	ReturnValue_t result = RETURN_OK;
-	while(not tmFifo.empty() && counter < sentPacketsPerCycle) {
+	while(not tmFifo.empty() and counter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
-		const uint8_t* data = NULL;
+		const uint8_t* data = nullptr;
 		size_t size = 0;
 		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
@@ -186,14 +187,6 @@ MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
 }
 
 
-
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	sif::info << "TMTC Bridge: Printing data: [";
-	for(uint32_t i = 0; i < dataLen; i++) {
-		sif::info << std::hex << (int)data[i];
-		if(i < dataLen-1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
+	arrayprinter::print(data, dataLen);
 }
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 0a1fcfab..3e0432d8 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -43,26 +43,27 @@ public:
 	 */
 	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
-	void registerCommConnect();
-	void registerCommDisconnect();
+	virtual void registerCommConnect();
+	virtual void registerCommDisconnect();
 
 	/**
 	 * Initializes necessary FSFW components for the TMTC Bridge
 	 * @return
 	 */
-	ReturnValue_t initialize() override;
+	virtual ReturnValue_t initialize() override;
 
 	/**
 	 * @brief	Handles TMTC reception
 	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
 	/**
 	 * Return TMTC Reception Queue
 	 * @param virtualChannel
 	 * @return
 	 */
-	MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;
+	MessageQueueId_t getReportReceptionQueue(
+			uint8_t virtualChannel = 0) override;
 protected:
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.

From 45ffb7549aa0654f1423ef5cd8dd0f012ab0537a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 10:58:48 +0200
Subject: [PATCH 0477/1292] storage accessor const in own file now

---
 storagemanager/ConstStorageAccessor.cpp |  93 +++++++++++++++++++
 storagemanager/ConstStorageAccessor.h   | 116 ++++++++++++++++++++++++
 storagemanager/StorageAccessor.cpp      |  98 +-------------------
 storagemanager/StorageAccessor.h        | 109 +---------------------
 4 files changed, 215 insertions(+), 201 deletions(-)
 create mode 100644 storagemanager/ConstStorageAccessor.cpp
 create mode 100644 storagemanager/ConstStorageAccessor.h

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
new file mode 100644
index 00000000..be3188c1
--- /dev/null
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -0,0 +1,93 @@
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/storagemanager/ConstStorageAccessor.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	sif::info << "StorageAccessor: Printing data: [";
+	for(uint16_t iPool = 0; iPool < size_; iPool++) {
+		sif::info << std::hex << (int)constDataPointer[iPool];
+		if(iPool < size_ - 1){
+			sif::info << " , ";
+		}
+	}
+	sif::info << " ] " << std::endl;
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
new file mode 100644
index 00000000..cf8ca08f
--- /dev/null
+++ b/storagemanager/ConstStorageAccessor.h
@@ -0,0 +1,116 @@
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include <framework/storagemanager/storeAddress.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor (ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index c0c8126b..b827b9c0 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,96 +1,6 @@
 #include <framework/storagemanager/StorageAccessor.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
-
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
@@ -120,7 +30,8 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(dataPointer, dataPointer + size_, pointer);
@@ -141,7 +52,8 @@ ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool entry!" << std::endl;
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(data, data + size, dataPointer + offset);
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 06947974..c5e38306 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,117 +1,10 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 #define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
 
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/storeAddress.h>
+#include <framework/storagemanager/ConstStorageAccessor.h>
 
 class StorageManagerIF;
 
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
 /**
  * @brief   Child class for modifyable data. Also has a normal pointer member.
  */

From 446e7d2f82d46ce9690d3f2c4c84b166407a8c2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 11:00:40 +0200
Subject: [PATCH 0478/1292] const storage accessor improvement

---
 storagemanager/ConstStorageAccessor.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index be3188c1..0bfde58c 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,6 +1,7 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/storagemanager/ConstStorageAccessor.h>
 #include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
@@ -73,18 +74,11 @@ store_address_t ConstStorageAccessor::getId() const {
 }
 
 void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT) {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 		return;
 	}
-	sif::info << "StorageAccessor: Printing data: [";
-	for(uint16_t iPool = 0; iPool < size_; iPool++) {
-		sif::info << std::hex << (int)constDataPointer[iPool];
-		if(iPool < size_ - 1){
-			sif::info << " , ";
-		}
-	}
-	sif::info << " ] " << std::endl;
+	arrayprinter::print(constDataPointer, size_);
 }
 
 void ConstStorageAccessor::assignStore(StorageManagerIF* store) {

From 2ecd7c44937180ab0aad13a1185ed9cc54c9eaa4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 11:05:40 +0200
Subject: [PATCH 0479/1292] some minor improvements

---
 storagemanager/LocalPool.h     | 11 +++++++----
 storagemanager/PoolManager.h   |  3 +++
 storagemanager/PoolManager.tpp |  6 +++---
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index bb94a3be..7e349dcd 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -35,7 +35,7 @@ public:
 	/**
 	 * @brief	This is the default constructor for a pool manager instance.
 	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with \c new) for store and size_list. These
+	 * 			allocates memory (with @c new) for store and size_list. These
 	 * 			regions are all set to zero on start up.
 	 * @param setObjectId	The object identifier to be set. This allows for
 	 * 						multiple instances of LocalPool in the system.
@@ -87,7 +87,7 @@ public:
 	ReturnValue_t initialize() override;
 protected:
 	/**
-	 * With this helper method, a free element of \c size is reserved.
+	 * With this helper method, a free element of @c size is reserved.
 	 * @param size	The minimum packet size that shall be reserved.
 	 * @param[out] address Storage ID of the reserved data.
 	 * @return	- #RETURN_OK on success,
@@ -100,7 +100,8 @@ protected:
 private:
 	/**
 	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type if increase is required.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
 	 */
 	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
 	/**
@@ -126,7 +127,9 @@ private:
 	 * 			is also dynamically allocated there.
 	 */
 	uint32_t* size_list[NUMBER_OF_POOLS];
-	bool spillsToHigherPools; //!< A variable to determine whether higher n pools are used if the store is full.
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
 	/**
 	 * @brief	This method safely stores the given data in the given packet_id.
 	 * @details	It also sets the size in size_list. The method does not perform
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 7c2e8a71..3c1c1217 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -29,6 +29,9 @@ public:
 			store_address_t* storeId = nullptr) override;
 
 protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
 
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index a35b810c..4ca22b85 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +41,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
+	MutexHelper mutexHelper(mutex, mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From 6f4682e1c8848e8fb578af9329c6f274e84a6f60 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 12:53:30 +0200
Subject: [PATCH 0480/1292] hasactionsIF include guard and doc

---
 action/HasActionsIF.h | 47 ++++++++++++++++++++++++-------------------
 1 file changed, 26 insertions(+), 21 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 12ecb89a..9c2a9c01 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,5 +1,5 @@
-#ifndef HASACTIONSIF_H_
-#define HASACTIONSIF_H_
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
 
 #include <framework/action/ActionHelper.h>
 #include <framework/action/ActionMessage.h>
@@ -11,22 +11,26 @@
  * Interface for component which uses actions
  *
  * @details
- * This interface is used to execute actions in the component. Actions, in the sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed to change
- * the main mode of operation, which is handled with the HasModesIF described below.
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
  *
- * The HasActionsIF allows components to define such actions and make them available
- * for other components to use. Implementing the interface is straightforward: There’s a
- * single executeAction call, which provides an identifier for the action to execute, as well
- * as arbitrary parameters for input. Aside from direct, software-based
- * actions, it is used in device handler components as an interface to forward commands to
- * devices.
- * Implementing components of the interface are supposed to check identifier (ID) and
- * parameters and immediately start execution of the action. It is, however, not required to
- * immediately finish execution. Instead, this may be deferred to a later point in time, at
- * which the component needs to inform the caller about finished or failed execution.
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
  *
- * \ingroup interfaces
+ * @ingroup interfaces
  */
 class HasActionsIF {
 public:
@@ -43,13 +47,14 @@ public:
 	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.
+	 * 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;
+	virtual ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;
 };
 
 
-#endif /* HASACTIONSIF_H_ */
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */

From 5f16d30d822a26fd42ddd2cdc4bc5211db695f41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 13:47:38 +0200
Subject: [PATCH 0481/1292] all ones value for return failed now

---
 returnvalues/HasReturnvaluesIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index b51dfc82..6ead6fbb 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -12,7 +12,8 @@ typedef uint16_t ReturnValue_t;
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 0xFFFF;
+	//! This will be the alll-ones value irrespective of used unsigned datatype.
+	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
 };
 

From 67366c25a0bd0b4e532cb8ee48d3d795215c773b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 13:49:25 +0200
Subject: [PATCH 0482/1292] typo fix

---
 returnvalues/HasReturnvaluesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 6ead6fbb..7a861b50 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -12,7 +12,7 @@ typedef uint16_t ReturnValue_t;
 class HasReturnvaluesIF {
 public:
 	static const ReturnValue_t RETURN_OK = 0;
-	//! This will be the alll-ones value irrespective of used unsigned datatype.
+	//! This will be the all-ones value irrespective of used unsigned datatype.
 	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
 };

From 56455a5fa290d69f62ad6a17a2ad66b311401c5e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 14:11:53 +0200
Subject: [PATCH 0483/1292] added static function as alternative to macro

---
 returnvalues/HasReturnvaluesIF.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 7a861b50..04acd66e 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -15,6 +15,10 @@ public:
 	//! This will be the all-ones value irrespective of used unsigned datatype.
 	static const ReturnValue_t RETURN_FAILED = -1;
 	virtual ~HasReturnvaluesIF() {}
+
+	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
 };
 
 #endif /* HASRETURNVALUESIF_H_ */

From 905c1a92e38865558e25bebb10a8c7ca380d2ab6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 23 Jun 2020 21:03:22 +0200
Subject: [PATCH 0484/1292] reverted some changes

---
 action/ActionHelper.cpp               |  3 +--
 datalinklayer/MapPacketExtraction.cpp |  3 +--
 events/EventManager.cpp               |  1 -
 events/EventManagerIF.h               |  3 +--
 health/HealthHelper.cpp               |  2 --
 housekeeping/HousekeepingMessage.cpp  | 10 +++++-----
 housekeeping/HousekeepingMessage.h    |  2 +-
 ipc/CommandMessage.cpp                | 22 +++++++++++-----------
 ipc/CommandMessage.h                  |  2 +-
 ipc/CommandMessageBase.cpp            | 16 ++++++----------
 ipc/CommandMessageBase.h              |  7 -------
 ipc/MessageQueueMessage.cpp           | 16 ++++++----------
 ipc/MessageQueueMessage.h             | 12 ------------
 ipc/MessageQueueMessageIF.h           | 14 +-------------
 ipc/MessageQueueSenderIF.h            |  7 +++----
 modes/ModeHelper.cpp                  |  5 +----
 monitoring/LimitViolationReporter.cpp |  3 +--
 osal/FreeRTOS/MessageQueue.cpp        | 19 ++++++-------------
 osal/FreeRTOS/MessageQueue.h          |  5 ++---
 osal/FreeRTOS/QueueFactory.cpp        | 11 +++--------
 parameters/ParameterHelper.cpp        |  6 ++----
 tmtcpacket/pus/TmPacketStored.cpp     |  2 +-
 tmtcservices/VerificationReporter.cpp |  8 ++++----
 23 files changed, 57 insertions(+), 122 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 026df4e1..0df5f2d4 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,8 +101,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 	//TODO Service Implementation sucks at the moment
 	if (hideSender){
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE);
+		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
 	} else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 87b46556..4ea45e89 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -117,8 +117,7 @@ ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
 	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
 	if (status == RETURN_OK) {
 		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
 	}
 	return status;
 }
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index a5d14569..04be6f68 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -52,7 +52,6 @@ void EventManager::notifyListeners(EventMessage* message) {
 	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
 		if (iter->second.match(message)) {
 			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        MessageQueueMessage::MAX_MESSAGE_SIZE,
 			        message->getSender());
 		}
 	}
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index 053e320b..bc0de432 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -44,8 +44,7 @@ public:
 				eventmanagerQueue = eventmanager->getEventReportQueue();
 			}
 		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}
 
 };
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 935bf5e3..0b3bffcb 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -70,7 +70,6 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
@@ -91,7 +90,6 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 		reply.setReplyRejected(result, command->getCommand());
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d7efd703..f425d16e 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,13 +3,13 @@
 
 HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
 		CommandMessageBase(message) {
-	if(message->getMaximumMessageSize() < HK_MESSAGE_SIZE) {
+	if(message->getMessageSize() < HK_MESSAGE_SIZE) {
 		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
 		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
 				<< " bytes!" << std::endl;
 		return;
 	}
-	message->setMessageSize(HK_MESSAGE_SIZE);
+	//message->setMessageSize(HK_MESSAGE_SIZE);
 }
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -38,9 +38,9 @@ void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 	setParameter(storeId.raw);
 }
 
-size_t HousekeepingMessage::getMinimumMessageSize() const {
-	return HK_MESSAGE_SIZE;
-}
+//size_t HousekeepingMessage::getMinimumMessageSize() const {
+//	return HK_MESSAGE_SIZE;
+//}
 
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index c6a33c83..f568a418 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -104,7 +104,7 @@ public:
 	//! to distinguish between diagnostics and regular HK packets
 	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
 
-	virtual size_t getMinimumMessageSize() const override;
+	//virtual size_t getMinimumMessageSize() const override;
 	virtual void clear() override;
 private:
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 9a8a82f2..11355e38 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -9,14 +9,14 @@ CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
 				" message!" << std::endl;
 		return;
 	}
-	if(receiverMessage->getMaximumMessageSize() <
-			getMinimumMessageSize()) {
-		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-				" can not hold minimum "<< getMinimumMessageSize()
-				<< " bytes!" << std::endl;
-		return;
-	}
-	internalMessage->setMessageSize(getMinimumMessageSize());
+//	if(receiverMessage->getMessageSize() <
+//			getMinimumMessageSize()) {
+//		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
+//				" can not hold minimum "<< getMinimumMessageSize()
+//				<< " bytes!" << std::endl;
+//		return;
+//	}
+//	internalMessage->setMessageSize(getMinimumMessageSize());
 }
 
 CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
@@ -49,9 +49,9 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
 			sizeof(parameter2));
 }
 
-size_t CommandMessage::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
+//size_t CommandMessage::getMinimumMessageSize() const {
+//	return MINIMUM_COMMAND_MESSAGE_SIZE;
+//}
 
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a09494c6..ae4016b0 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -54,7 +54,7 @@ public:
 	virtual ~CommandMessage() {}
 
 	/** MessageQueueMessageIF functions used for minimum size check. */
-	size_t getMinimumMessageSize() const override;
+	//size_t getMinimumMessageSize() const override;
 
 	/**
 	 * Get the first parameter of the message
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index 80f9d378..ea50f4ea 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -47,25 +47,21 @@ const uint8_t* CommandMessageBase::getData() const {
 	return internalMessage->getData() + sizeof(Command_t);
 }
 
-void CommandMessageBase::setMessageSize(size_t messageSize) {
-	internalMessage->setMessageSize(messageSize);
-}
+//void CommandMessageBase::setMessageSize(size_t messageSize) {
+//	//internalMessage->setMessageSize(messageSize);
+//}
 
 size_t CommandMessageBase::getMessageSize() const {
 	return internalMessage->getMessageSize();
 }
 
-size_t CommandMessageBase::getMaximumMessageSize() const {
-	return internalMessage->getMaximumMessageSize();
-}
-
 MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
 	return internalMessage;
 }
 
-size_t CommandMessageBase::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
-}
+//size_t CommandMessageBase::getMinimumMessageSize() const {
+//	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+//}
 
 void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
 		Command_t initialCommand) {
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index b237b68f..1ee1b970 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -63,15 +63,8 @@ public:
 	virtual MessageQueueId_t getSender() const override;
 	virtual uint8_t * getData() override;
 	virtual const uint8_t* getData() const override;
-	virtual void setMessageSize(size_t messageSize) override;
 	virtual size_t getMessageSize() const override;
 
-	//! This depends on the maximum message size of the passed internal message.
-	virtual size_t getMaximumMessageSize() const override;
-
-	//! Return the constant minimum message size.
-	virtual size_t getMinimumMessageSize() const override;
-
 	/**
 	 * A command message can be rejected and needs to offer a function
 	 * to set a rejected reply
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index b173f2c4..f3665074 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -51,9 +51,9 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-	return this->HEADER_SIZE;
-}
+//size_t MessageQueueMessage::getMinimumMessageSize() const {
+//	return this->HEADER_SIZE;
+//}
 
 void MessageQueueMessage::print() {
 	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
@@ -69,13 +69,9 @@ void MessageQueueMessage::clear() {
 }
 
 size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
 	return this->MAX_MESSAGE_SIZE;
 }
 
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
+//void MessageQueueMessage::setMessageSize(size_t messageSize) {
+//	this->messageSize = messageSize;
+//}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 8716df54..a994c323 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -139,20 +139,8 @@ public:
 	 * The message queue id that identifies the sending message queue.
 	 */
 	void setSender(MessageQueueId_t setId) override;
-	/**
-	 * @brief	This helper function is used by the MessageQueue class to check
-	 * 			the size of an incoming message.
-	 * @details
-	 * The method must be overwritten by child classes if size
-	 * checks shall be more strict.
-	 * @return	The default implementation returns HEADER_SIZE.
-	 */
-	virtual size_t getMinimumMessageSize() const override;
 
 	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-
-	virtual size_t getMaximumMessageSize() const override;
 
 	/**
 	 * @brief	This is a debug method that prints the content
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index f34cab98..19c69bfb 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -68,23 +68,11 @@ public:
 	virtual uint8_t* getData() = 0;
 
 	/**
-	 * @brief	This helper function is used by the MessageQueue class to
-	 * 			check the size of an incoming message.
-	 */
-	virtual size_t getMinimumMessageSize() const = 0;
-
-	/**
-	 * Get message size of current message implementation.
+	 * Get constant message size of current message implementation.
 	 * @return
 	 */
 	virtual size_t getMessageSize() const = 0;
-	virtual void setMessageSize(size_t messageSize) = 0;
 
-	/**
-	 * Get maximum allowed size of current message implementation.
-	 * @return
-	 */
-	virtual size_t getMaximumMessageSize() const = 0;
 };
 
 
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 8bc14948..e4b9670e 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -10,17 +10,16 @@ public:
 	virtual ~MessageQueueSenderIF() {}
 
 	/**
-	 * Allows sending messages without actually "owing" a message queue.
+	 * Allows sending messages without actually "owning" a message queue.
 	 * Not sure whether this is actually a good idea.
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxMessageSize,
+			MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault=false);
+			bool ignoreFault = false);
 private:
 	MessageQueueSenderIF() {}
 };
 
 
-
 #endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index f636c0bf..59a6d974 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -28,7 +28,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			ModeMessage::cantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        MessageQueueMessage::MAX_MESSAGE_SIZE,
 			        owner->getCommandQueue());
 			break;
 		}
@@ -51,7 +50,6 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
 				submode);
 		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE,
 		       owner->getCommandQueue());
 	}
 		break;
@@ -97,7 +95,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 					ownerMode, ownerSubmode);
 		}
 		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE, owner->getCommandQueue());
+		        owner->getCommandQueue());
 	}
 }
 
@@ -111,7 +109,6 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
 		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        MessageQueueMessage::MAX_MESSAGE_SIZE,
 		        owner->getCommandQueue());
 	}
 }
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index c6e2b5db..1378d754 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -34,8 +34,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	MessageQueueMessage message;
 	CommandMessage report(&message);
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
 
 ReturnValue_t LimitViolationReporter::checkClassLoaded() {
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index c9adf229..464a4f16 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -50,8 +50,8 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, maxMessageSize, sentFrom,
-			ignoreFault, callContext);
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
+	        callContext);
 }
 
 
@@ -80,9 +80,9 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-    if(message->getMaximumMessageSize() < maxMessageSize) {
+    if(message->getMessageSize() < maxMessageSize) {
         sif::error << "MessageQueue::receiveMessage: Message size "
-                << message->getMaximumMessageSize() <<
+                << message->getMessageSize() <<
                 " too small to receive data!" << std::endl;
         return HasReturnvaluesIF::RETURN_FAILED;
     }
@@ -127,17 +127,10 @@ bool MessageQueue::isDefaultDestinationSet() const {
 
 // static core function to send messages.
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, size_t maxSize,
-        MessageQueueId_t sentFrom, bool ignoreFault, CallContext callContext) {
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault, CallContext callContext) {
     message->setSender(sentFrom);
     BaseType_t result;
-    if(message->getMaximumMessageSize() > maxSize) {
-    	sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
-    			 << message->getMaximumMessageSize() << " too large for queue"
-    			  " with max. message size " << maxSize << "!"
-    			 << std::endl;
-    	return HasReturnvaluesIF::RETURN_FAILED;
-    }
 
     if(callContext == CallContext::TASK) {
         result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e87e884f..b7e52bb3 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -194,9 +194,8 @@ protected:
 	 * @param context Specify whether call is made from task or from an ISR.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault=false,
-			CallContext callContext = CallContext::TASK);
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
 
 	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
 
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index d754b2b9..beb4969b 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -7,14 +7,9 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom, bool ignoreFault) {
-    if(maxSize == 0) {
-        sif::error << "MessageQueueSenderIF::sendMessage: Max Size is 0!"
-                << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message, maxSize,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
 			sentFrom,ignoreFault);
 }
 
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 68ff5ab0..8b91020f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -107,8 +107,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -130,6 +129,5 @@ void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 	MessageQueueMessage message;
 	CommandMessage reply(&message);
 	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply,
-	        MessageQueueMessage::MAX_MESSAGE_SIZE, ownerQueueId);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index d589db8d..c0ff874b 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -118,7 +118,7 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 	}
 	TmTcMessage tmMessage(getStoreAddress());
 	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-	        &tmMessage, MessageQueueMessage::MAX_MESSAGE_SIZE, sentFrom);
+	        &tmMessage, sentFrom);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		deletePacket();
 		if (doErrorReporting) {
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index a54c1f8d..bcb4756c 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -23,7 +23,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -39,7 +39,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
@@ -58,7 +58,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 			current_packet->getPacketSequenceControl(), error_code, step,
 			parameter1, parameter2);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
@@ -76,7 +76,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
 			tcSequenceControl, error_code, step, parameter1, parameter2);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message, MessageQueueMessage::MAX_MESSAGE_SIZE);
+	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error
 				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "

From 3bf29a7315d926dc1447e954494f393061ee2c8a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:24:15 +0200
Subject: [PATCH 0485/1292] removed CommandMessageBase, changed interfaces

---
 action/ActionHelper.cpp                |  15 +--
 action/CommandActionHelper.cpp         |   3 +-
 action/SimpleActionHelper.cpp          |   3 +-
 controller/ControllerBase.cpp          |   3 +-
 datapool/HkSwitchHelper.cpp            |   3 +-
 datapoolglob/DataPoolAdmin.cpp         |   9 +-
 datapoollocal/LocalDataPoolManager.cpp |  33 +++--
 datapoollocal/LocalDataPoolManager.h   |   2 +-
 devicehandlers/AssemblyBase.cpp        |   3 +-
 devicehandlers/DeviceHandlerBase.cpp   |  18 +--
 devicehandlers/HealthDevice.cpp        |   3 +-
 health/HealthHelper.cpp                |   6 +-
 housekeeping/HousekeepingMessage.cpp   |  22 ++--
 housekeeping/HousekeepingMessage.h     |   7 +-
 ipc/CommandMessage.cpp                 |  77 ++++++++----
 ipc/CommandMessage.h                   |  73 ++++++++---
 ipc/CommandMessageBase.cpp             | 168 ++++++++++++-------------
 ipc/CommandMessageBase.h               |  67 +++-------
 ipc/CommandMessageIF.h                 |  34 +++--
 ipc/MessageQueueMessage.cpp            |  41 +++---
 ipc/MessageQueueMessage.h              |  16 ++-
 ipc/MessageQueueMessageIF.h            |  11 +-
 memory/MemoryHelper.cpp                |  15 +--
 modes/ModeHelper.cpp                   |   9 +-
 monitoring/LimitViolationReporter.cpp  |   3 +-
 parameters/ParameterHelper.cpp         |   6 +-
 power/Fuse.cpp                         |   3 +-
 power/PowerSensor.cpp                  |   3 +-
 subsystem/Subsystem.cpp                |  14 +--
 subsystem/SubsystemBase.cpp            |  14 +--
 thermal/AbstractTemperatureSensor.cpp  |   5 +-
 thermal/Heater.cpp                     |   3 +-
 tmtcservices/CommandingServiceBase.cpp |  28 ++---
 tmtcservices/CommandingServiceBase.h   |  10 +-
 34 files changed, 348 insertions(+), 382 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 0df5f2d4..57b64686 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -33,15 +33,13 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 }
 
 void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	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) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
 }
@@ -56,8 +54,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	size_t size = 0;
 	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -65,8 +62,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
 		queueToUse->sendMessage(commandedBy, &reply);
 		return;
@@ -75,8 +71,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
 
 ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	store_address_t storeAddress;
 	uint8_t *dataPtr;
 	size_t maxSize = data->getSerializedSize();
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index c871a2d0..77295401 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -53,8 +53,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 
 ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 		ActionId_t actionId, store_address_t storeId) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ActionMessage::setCommand(&command, actionId, storeId);
 	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index f97474b1..6861fc28 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -36,8 +36,7 @@ void SimpleActionHelper::resetHelper() {
 
 void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 		ActionId_t actionId, store_address_t dataAddress) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (isExecuting) {
 		ipcStore->deleteData(dataAddress);
 		ActionMessage::setStepReply(&reply, actionId, 0,
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index ad0a0b97..674d0fc8 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -56,8 +56,7 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 }
 
 void ControllerBase::handleQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result;
 	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 6a923776..cf5114f7 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -21,8 +21,7 @@ ReturnValue_t HkSwitchHelper::initialize() {
 }
 
 ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
 		ReturnValue_t result = commandActionHelper.handleReply(&command);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 6387263f..05de1eb2 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -66,8 +66,7 @@ ReturnValue_t DataPoolAdmin::getParameter(uint8_t domainId,
 }
 
 void DataPoolAdmin::handleCommand() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -283,8 +282,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -296,8 +294,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
 //identical to ParameterHelper::rejectCommand()
 void DataPoolAdmin::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	reply.setReplyRejected(reason, initialCommand);
 	commandQueue->sendMessage(to, &reply);
 }
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e0731a96..bc57468a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -45,8 +45,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		HousekeepingMessage& message) {
-    Command_t command = message.getCommand();
+		CommandMessage* message) {
+    Command_t command = message->getCommand();
     switch(command) {
     // I think those are the only commands which can be handled here..
     case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
@@ -55,10 +55,10 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
         return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        return generateSetStructurePacket(message.getSid());
+        //return generateSetStructurePacket(message->getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        return generateHousekeepingPacket(message.getSid());
+        //return generateHousekeepingPacket(message->getSid());
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
@@ -105,19 +105,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	MessageQueueMessage message;
-	HousekeepingMessage hkMessage(&message);
-	hkMessage.setHkReportMessage(sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_NOT_SET;
-	}
-
-	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
-	}
-	else {
-	    result = hkQueue->sendToDefault(&hkMessage);
-	}
+	//HousekeepingMessage hkMessage;
+//	hkMessage.setHkReportMessage(sid, storeId);
+//	if(hkQueue == nullptr) {
+//	    return QUEUE_NOT_SET;
+//	}
+//
+//	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+//	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+//	}
+//	else {
+//	    result = hkQueue->sendToDefault(&hkMessage);
+//	}
 
 	return result;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index b6491724..9d072bf4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -58,7 +58,7 @@ public:
 	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
-	ReturnValue_t handleHousekeepingMessage(HousekeepingMessage& message);
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * This function is used to fill the local data pool map with pool
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index a5dcad21..bd85d1de 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -148,8 +148,7 @@ void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
 
 void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
 		HealthState health) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
 			health);
 	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1ae056a6..0442be89 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -214,12 +214,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	// This is not ideal. What if it is not a command message? (e.g. another
-	// message with 3 parameters). The full buffer is filled anyway
-	// and I could just copy the content into the other message but
-	// all I need are few additional functions the other message type offers.
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != RETURN_OK) {
 		return;
@@ -247,8 +242,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	HousekeepingMessage hkMessage(&message);
-	result = hkManager.handleHousekeepingMessage(hkMessage);
+	result = hkManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -484,13 +478,12 @@ void DeviceHandlerBase::setMode(Mode_t newMode) {
 
 void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-	MessageQueueMessage message;
 	//This is actually the reply protocol for raw and misc DH commands.
 	if (status == RETURN_OK) {
-		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, parameter);
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
 		commandQueue->reply(&reply);
 	}
 }
@@ -760,8 +753,7 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 		return;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
 			getObjectId(), address, isCommand);
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 7e3a59bd..0bce34ec 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -13,8 +13,7 @@ HealthDevice::~HealthDevice() {
 }
 
 ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		healthHelper.handleHealthCommand(&command);
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 0b3bffcb..e01e6fbb 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -65,8 +65,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	MessageQueueMessage message;
-	CommandMessage information(&message);
+	CommandMessage information;
 	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
@@ -81,8 +80,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
 		return;
 	}
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		HealthMessage::setHealthMessage(&reply,
 				HealthMessage::REPLY_HEALTH_SET);
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index f425d16e..0d0f9860 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,15 +1,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(MessageQueueMessageIF* message):
-		CommandMessageBase(message) {
-	if(message->getMessageSize() < HK_MESSAGE_SIZE) {
-		sif::error << "HousekeepingMessage::HousekeepingMessage: Passed "
-		        "message buffer can not hold minimum " << HK_MESSAGE_SIZE
-				<< " bytes!" << std::endl;
-		return;
-	}
-	//message->setMessageSize(HK_MESSAGE_SIZE);
+HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
 }
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -26,14 +18,14 @@ uint32_t HousekeepingMessage::getParameter() const {
 
 void HousekeepingMessage::setHkReportMessage(sid_t sid,
 		store_address_t storeId) {
-	CommandMessageBase::setCommand(HK_REPORT);
+	CommandMessage::setCommand(HK_REPORT);
 	setSid(sid);
 	setParameter(storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 		store_address_t storeId) {
-	CommandMessageBase::setCommand(DIAGNOSTICS_REPORT);
+	CommandMessage::setCommand(DIAGNOSTICS_REPORT);
 	setSid(sid);
 	setParameter(storeId.raw);
 }
@@ -44,7 +36,7 @@ void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
 
 sid_t HousekeepingMessage::getSid() const {
 	sid_t sid;
-	std::memcpy(&sid.raw, CommandMessageBase::getData(), sizeof(sid.raw));
+	std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
 	return sid;
 }
 
@@ -58,16 +50,16 @@ sid_t HousekeepingMessage::getHkReportMessage(
 }
 
 void HousekeepingMessage::setSid(sid_t sid) {
-	std::memcpy(CommandMessageBase::getData(), &sid.raw, sizeof(sid.raw));
+	std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
 }
 
 
 uint8_t* HousekeepingMessage::getData() {
-	return CommandMessageBase::getData() + sizeof(sid_t);
+	return CommandMessage::getData() + sizeof(sid_t);
 }
 
 const uint8_t* HousekeepingMessage::getData() const {
-	return CommandMessageBase::getData() + sizeof(sid_t);
+	return CommandMessage::getData() + sizeof(sid_t);
 }
 
 void HousekeepingMessage::clear() {
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index f568a418..8958201e 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
 #define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#include <framework/ipc/CommandMessageBase.h>
+
+#include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
@@ -33,7 +34,7 @@ union sid_t {
  * This message is slightly larger than regular command messages to accomodate
  * the uint64_t structure ID (SID).
  */
-class HousekeepingMessage : public CommandMessageBase {
+class HousekeepingMessage : public CommandMessage {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@@ -44,7 +45,7 @@ public:
 	 * the message data, see CommandMessageIF and getInternalMessage().
 	 * @param message
 	 */
-	HousekeepingMessage(MessageQueueMessageIF* message);
+	HousekeepingMessage();
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 11355e38..6aa433df 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,57 +1,64 @@
 #include <framework/ipc/CommandMessage.h>
+#include <framework/ipc/CommandMessageCleaner.h>
 #include <cstring>
 
-CommandMessage::CommandMessage(MessageQueueMessageIF* receiverMessage):
-			CommandMessageBase(receiverMessage) {
-	if(receiverMessage == nullptr) {
-		sif::error << "CommandMessage::CommandMessage: Don't pass a nullptr"
-				" as the message queue message, pass the address of an actual"
-				" message!" << std::endl;
-		return;
-	}
-//	if(receiverMessage->getMessageSize() <
-//			getMinimumMessageSize()) {
-//		sif::error << "CommandMessage::ComandMessage: Passed message buffer"
-//				" can not hold minimum "<< getMinimumMessageSize()
-//				<< " bytes!" << std::endl;
-//		return;
-//	}
-//	internalMessage->setMessageSize(getMinimumMessageSize());
+CommandMessage::CommandMessage() {
+	MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
 }
 
-CommandMessage::CommandMessage(MessageQueueMessageIF* messageToSet,
-		Command_t command, uint32_t parameter1, uint32_t parameter2):
-		CommandMessage(messageToSet) {
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
 	setCommand(command);
 	setParameter(parameter1);
 	setParameter2(parameter2);
 }
 
+Command_t CommandMessage::getCommand() const {
+  Command_t command;
+  std::memcpy(&command, getData(), sizeof(Command_t));
+  return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+  std::memcpy(getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+  // first byte of command ID.
+  return getCommand() >> 8 & 0xff;
+}
+
 uint32_t CommandMessage::getParameter() const {
 	uint32_t parameter1;
-	std::memcpy(&parameter1, CommandMessageBase::getData(), sizeof(parameter1));
+	std::memcpy(&parameter1, MessageQueueMessage::getData(), sizeof(parameter1));
 	return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	std::memcpy(CommandMessageBase::getData(), &parameter1, sizeof(parameter1));
+	std::memcpy(MessageQueueMessage::getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
 	uint32_t parameter2;
-	std::memcpy(&parameter2, CommandMessageBase::getData() + sizeof(uint32_t),
+	std::memcpy(&parameter2, MessageQueueMessage::getData() + sizeof(uint32_t),
 			sizeof(parameter2));
 	return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	std::memcpy(CommandMessageBase::getData()  + sizeof(uint32_t), &parameter2,
+	std::memcpy(MessageQueueMessage::getData()  + sizeof(uint32_t), &parameter2,
 			sizeof(parameter2));
 }
 
-//size_t CommandMessage::getMinimumMessageSize() const {
-//	return MINIMUM_COMMAND_MESSAGE_SIZE;
-//}
+size_t CommandMessage::getMinimumMessageSize() const {
+	return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
 
 bool CommandMessage::isClearedCommandMessage() {
 	return getCommand() == CMD_NONE;
@@ -62,3 +69,21 @@ void CommandMessage::setToUnknownCommand() {
 	this->clear();
 	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+      Command_t initialCommand) {
+  std::memcpy(getData(), &reason, sizeof(reason));
+  std::memcpy(getData() + sizeof(reason), &initialCommand,
+          sizeof(initialCommand));
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+      Command_t *initialCommand) const {
+  ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+  std::memcpy(&reason, getData(), sizeof(reason));
+  if(initialCommand != nullptr) {
+      std::memcpy(initialCommand, getData() + sizeof(reason),
+              sizeof(Command_t));
+  }
+  return reason;
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index ae4016b0..a319a0cf 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGE_H_
 
-#include <framework/ipc/CommandMessageBase.h>
+#include <framework/ipc/CommandMessageIF.h>
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/ipc/FwMessageTypes.h>
 
@@ -20,23 +20,21 @@
  * currently has an internal message size of 28 bytes.
  * @author	Bastian Baetz
  */
-class CommandMessage: public CommandMessageBase {
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
 public:
-	/**
-	 * This is the size of a message as it is seen by the MessageQueue.
-	 * It can hold the CommandMessage header plus 2 4-byte parameters.
-	 * 14 of the 24 available MessageQueueMessage bytes are used.
-	 */
-	static const size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-			CommandMessageIF::HEADER_SIZE + 2 * sizeof(uint32_t);
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
 
 	/**
-	 * Default Constructor, does not initialize anything.
-	 *
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
 	 * This constructor should be used when receiving a Message, as the
 	 * content is filled by the MessageQueue.
 	 */
-	CommandMessage(MessageQueueMessageIF* receiverMessage);
+	CommandMessage();
 	/**
 	 * This constructor creates a new message with all message content
 	 * initialized
@@ -45,17 +43,13 @@ public:
 	 * @param parameter1	The first parameter
 	 * @param parameter2	The second parameter
 	 */
-	CommandMessage(MessageQueueMessageIF* messageToSet, Command_t command,
-			uint32_t parameter1, uint32_t parameter2);
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
 
 	/**
 	 * @brief 	Default Destructor
 	 */
 	virtual ~CommandMessage() {}
 
-	/** MessageQueueMessageIF functions used for minimum size check. */
-	//size_t getMinimumMessageSize() const override;
-
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -91,8 +85,49 @@ public:
 	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
 	 * Is needed quite often, so we better code it once only.
 	 */
-	void setToUnknownCommand();
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+    virtual void clear() override;
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
 };
 
-
 #endif /* COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
index ea50f4ea..745e6c5f 100644
--- a/ipc/CommandMessageBase.cpp
+++ b/ipc/CommandMessageBase.cpp
@@ -1,86 +1,86 @@
-#include <framework/ipc/CommandMessageBase.h>
-#include <framework/ipc/CommandMessageCleaner.h>
-#include <cstring>
-
-CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
-		internalMessage(message) {
-}
-
-Command_t CommandMessageBase::getCommand() const {
-	Command_t command;
-	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-	return command;
-}
-
-void CommandMessageBase::setCommand(Command_t command) {
-	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessageBase::getMessageType() const {
-	// first byte of command ID.
-	return getCommand() >> 8 & 0xff;
-}
-
-MessageQueueId_t CommandMessageBase::getSender() const {
-	return internalMessage->getSender();
-}
-
-uint8_t* CommandMessageBase::getBuffer() {
-	return internalMessage->getBuffer();
-}
-
-void CommandMessageBase::setSender(MessageQueueId_t setId) {
-	internalMessage->setSender(setId);
-}
-
-const uint8_t* CommandMessageBase::getBuffer() const {
-	return internalMessage->getBuffer();
-}
-
-// Header includes command ID.
-uint8_t* CommandMessageBase::getData() {
-	return internalMessage->getData() + sizeof(Command_t);
-}
-
-// Header includes command ID.
-const uint8_t* CommandMessageBase::getData() const {
-	return internalMessage->getData() + sizeof(Command_t);
-}
-
-//void CommandMessageBase::setMessageSize(size_t messageSize) {
-//	//internalMessage->setMessageSize(messageSize);
+//#include <framework/ipc/CommandMessageBase.h>
+//#include <framework/ipc/CommandMessageCleaner.h>
+//#include <cstring>
+//
+//CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
+//		internalMessage(message) {
 //}
-
-size_t CommandMessageBase::getMessageSize() const {
-	return internalMessage->getMessageSize();
-}
-
-MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
-	return internalMessage;
-}
-
-//size_t CommandMessageBase::getMinimumMessageSize() const {
-//	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+//
+//Command_t CommandMessageBase::getCommand() const {
+//	Command_t command;
+//	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
+//	return command;
+//}
+//
+//void CommandMessageBase::setCommand(Command_t command) {
+//	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
+//}
+//
+//uint8_t CommandMessageBase::getMessageType() const {
+//	// first byte of command ID.
+//	return getCommand() >> 8 & 0xff;
+//}
+//
+//MessageQueueId_t CommandMessageBase::getSender() const {
+//	return internalMessage->getSender();
+//}
+//
+//uint8_t* CommandMessageBase::getBuffer() {
+//	return internalMessage->getBuffer();
+//}
+//
+//void CommandMessageBase::setSender(MessageQueueId_t setId) {
+//	internalMessage->setSender(setId);
+//}
+//
+//const uint8_t* CommandMessageBase::getBuffer() const {
+//	return internalMessage->getBuffer();
+//}
+//
+//// Header includes command ID.
+//uint8_t* CommandMessageBase::getData() {
+//	return internalMessage->getData() + sizeof(Command_t);
+//}
+//
+//// Header includes command ID.
+//const uint8_t* CommandMessageBase::getData() const {
+//	return internalMessage->getData() + sizeof(Command_t);
+//}
+//
+////void CommandMessageBase::setMessageSize(size_t messageSize) {
+////	//internalMessage->setMessageSize(messageSize);
+////}
+//
+//size_t CommandMessageBase::getMessageSize() const {
+//	return internalMessage->getMessageSize();
+//}
+//
+//MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
+//	return internalMessage;
+//}
+//
+////size_t CommandMessageBase::getMinimumMessageSize() const {
+////	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
+////}
+//
+//void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
+//		Command_t initialCommand) {
+//	std::memcpy(getData(), &reason, sizeof(reason));
+//	std::memcpy(getData() + sizeof(reason), &initialCommand,
+//			sizeof(initialCommand));
+//}
+//
+//ReturnValue_t CommandMessageBase::getReplyRejectedReason(
+//		Command_t *initialCommand) const {
+//	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+//	std::memcpy(&reason, getData(), sizeof(reason));
+//	if(initialCommand != nullptr) {
+//		std::memcpy(initialCommand, getData() + sizeof(reason),
+//				sizeof(Command_t));
+//	}
+//	return reason;
+//}
+//
+//void CommandMessageBase::clear() {
+//	CommandMessageCleaner::clearCommandMessage(this);
 //}
-
-void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
-		Command_t initialCommand) {
-	std::memcpy(getData(), &reason, sizeof(reason));
-	std::memcpy(getData() + sizeof(reason), &initialCommand,
-			sizeof(initialCommand));
-}
-
-ReturnValue_t CommandMessageBase::getReplyRejectedReason(
-		Command_t *initialCommand) const {
-	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-	std::memcpy(&reason, getData(), sizeof(reason));
-	if(initialCommand != nullptr) {
-		std::memcpy(initialCommand, getData() + sizeof(reason),
-				sizeof(Command_t));
-	}
-	return reason;
-}
-
-void CommandMessageBase::clear() {
-	CommandMessageCleaner::clearCommandMessage(this);
-}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
index 1ee1b970..59795114 100644
--- a/ipc/CommandMessageBase.h
+++ b/ipc/CommandMessageBase.h
@@ -23,67 +23,28 @@
  */
 class CommandMessageBase: public CommandMessageIF {
 public:
-	//! This minimum size is derived from the interface requirement to be able
-	//! to set a rejected reply, which contains a returnvalue and the initial
-	//! command.
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_BASE_SIZE =
-			CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-			sizeof(Command_t);
+
 
 	CommandMessageBase(MessageQueueMessageIF* message);
 
-	/**
-	 * Read the DeviceHandlerCommand_t that is stored in the message,
-	 * usually used after receiving.
-	 *
-	 * @return the Command stored in the Message
-	 */
-	virtual Command_t getCommand() const override;
-	/**
-	 * Set the command type of the message. Default implementation also
-	 * sets the message type, which will be the first byte of the command ID.
-	 * @param the Command to be sent
-	 */
-	virtual void setCommand(Command_t command);
 
-	/**
-	 * Extract message ID, which is the first byte of the command ID for the
-	 * default implementation.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const override;
 
-	/*
-	 * MessageQueueMessageIF functions, which generally just call the
-	 * respective functions of the internal message queue message.
-	 */
-	virtual uint8_t * getBuffer() override;
-	virtual const uint8_t * getBuffer() const override;
-	virtual void setSender(MessageQueueId_t setId) override;
-	virtual MessageQueueId_t getSender() const override;
-	virtual uint8_t * getData() override;
-	virtual const uint8_t* getData() const override;
-	virtual size_t getMessageSize() const override;
+//	/*
+//	 * MessageQueueMessageIF functions, which generally just call the
+//	 * respective functions of the internal message queue message.
+//	 */
+//	virtual uint8_t * getBuffer() override;
+//	virtual const uint8_t * getBuffer() const override;
+//	virtual void setSender(MessageQueueId_t setId) override;
+//	virtual MessageQueueId_t getSender() const override;
+//	virtual uint8_t * getData() override;
+//	virtual const uint8_t* getData() const override;
+//	virtual size_t getMessageSize() const override;
 
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) override;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const override;
 
-	virtual MessageQueueMessageIF* getInternalMessage() const override;
+	//virtual MessageQueueMessageIF* getInternalMessage() const override;
+
 
-	virtual void clear() override;
 protected:
 	/**
 	 * @brief 	Pointer to the message containing the data.
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index fbfbddbb..ca050c32 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -5,20 +5,24 @@
 #include <framework/ipc/FwMessageTypes.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
-
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
-// TODO: actually, this interface propably does not have to implement
-// MQM IF, because there is a getter function for the internal message..
-// But it is also convenient to have the full access to all MQM IF functions.
-// That way, I can just pass CommandMessages to functions expecting a MQM IF.
-// The command message implementations just forwards the calls. Maybe
-// we should just leave it like that.
-class CommandMessageIF: public MessageQueueMessageIF {
+class CommandMessageIF: virtual public MessageQueueMessageIF {
 public:
-	static constexpr size_t HEADER_SIZE = sizeof(MessageQueueId_t) +
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
 			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
 	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
@@ -60,15 +64,9 @@ public:
 	virtual ReturnValue_t getReplyRejectedReason(
 			Command_t* initialCommand = nullptr) const  = 0;
 
-	/**
-	 * This function is used to get a pointer to the internal message, as
-	 * the command message implementations always operate on the memory
-	 * contained in the message queue message implementation.
-	 * This pointer can be used to set the internal message of different
-	 * command message implementations.
-	 * @return
-	 */
-	virtual MessageQueueMessageIF* getInternalMessage() const = 0;
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
 
 };
 
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index f3665074..0f4d861b 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,10 +1,10 @@
 #include <framework/ipc/MessageQueueMessage.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <string.h>
+#include <framework/globalfunctions/arrayprinter.h>
+#include <cstring>
 
 MessageQueueMessage::MessageQueueMessage() :
-		messageSize(this->HEADER_SIZE) {
+		messageSize(getMinimumMessageSize()) {
 	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 }
 
@@ -51,17 +51,15 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
 }
 
-//size_t MessageQueueMessage::getMinimumMessageSize() const {
-//	return this->HEADER_SIZE;
-//}
-
-void MessageQueueMessage::print() {
-	sif::debug << "MessageQueueMessage has size: " << this->messageSize <<
-			std::hex << std::endl;
-	for (uint8_t count = 0; count < this->messageSize; count++) {
-		sif::debug << (uint32_t) this->internalBuffer[count] << ":";
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
 	}
-	sif::debug << std::dec << std::endl;
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
 }
 
 void MessageQueueMessage::clear() {
@@ -69,9 +67,18 @@ void MessageQueueMessage::clear() {
 }
 
 size_t MessageQueueMessage::getMessageSize() const {
-	return this->MAX_MESSAGE_SIZE;
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
 }
 
-//void MessageQueueMessage::setMessageSize(size_t messageSize) {
-//	this->messageSize = messageSize;
-//}
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index a994c323..c4e82a94 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -23,7 +23,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage: public MessageQueueMessageIF {
+class MessageQueueMessage: virtual public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
@@ -74,11 +74,7 @@ public:
 	 * as small as possible.
 	 */
 	static const size_t MAX_DATA_SIZE = 24;
-	/**
-	 * @brief	This constants defines the size of the header,
-	 * 			which is added to every message.
-	 */
-	static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
+
 	/**
 	 * @brief	This constant defines the maximum total size in bytes
 	 * 			of a sent message.
@@ -141,12 +137,14 @@ public:
 	void setSender(MessageQueueId_t setId) override;
 
 	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
 
 	/**
-	 * @brief	This is a debug method that prints the content
-	 * 			(till messageSize) to the debug output.
+	 * @brief	This is a debug method that prints the content.
 	 */
-	void print();
+	void print(bool printWholeMessage);
 };
 
 #endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 19c69bfb..c6c677c1 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -18,7 +18,12 @@ typedef uint32_t MessageQueueId_t;
 
 class MessageQueueMessageIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = 0xffffffff;
+	static const MessageQueueId_t NO_QUEUE = -1;
+    /**
+     * @brief   This constants defines the size of the header,
+     *          which is added to every message.
+     */
+    static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);
 
 	virtual ~MessageQueueMessageIF() {};
 
@@ -73,6 +78,10 @@ public:
 	 */
 	virtual size_t getMessageSize() const = 0;
 
+    virtual void setMessageSize(size_t messageSize) = 0;
+    virtual size_t getMinimumMessageSize() const = 0;
+    virtual size_t getMaximumMessageSize() const = 0;
+
 };
 
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index fb4d9eb6..ea7ef9e1 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -51,16 +51,14 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 		break;
 	default:
 		ipcStore->deleteData(ipcAddress);
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
 		return;
 	}
 	//Only reached on success
-	MessageQueueMessage message;
-	CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
 	queueToUse->sendMessage(lastSender, &reply);
 	ipcStore->deleteData(ipcAddress);
 }
@@ -68,8 +66,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
 		const uint8_t* dataToCopy, const uint32_t size) {
 	busy = false;
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -154,8 +151,7 @@ void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
 		completeLoad(returnCode, p_data, size, dataPointer);
 	} else {
 		//At least inform sender.
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
 				MemoryMessage::CMD_MEMORY_LOAD);
 		queueToUse->sendMessage(lastSender, &reply);
@@ -173,8 +169,7 @@ void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
 				reservedSpaceInIPC);
 		completeDump(returnCode, dataPointer, size);
 	} else {
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
 		queueToUse->sendMessage(lastSender, &reply);
 	}
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 59a6d974..030f1db3 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -12,8 +12,7 @@ ModeHelper::~ModeHelper() {
 }
 
 ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	Mode_t mode;
 	Submode_t submode;
 	switch (command->getCommand()) {
@@ -79,8 +78,7 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
@@ -101,8 +99,7 @@ void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 
 void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
 			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
 	{
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 1378d754..234a0bff 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -31,8 +31,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	MessageQueueMessage message;
-	CommandMessage report(&message);
+	CommandMessage report;
 	MonitoringMessage::setLimitViolationReport(&report, storeId);
 	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 8b91020f..20e7e8ec 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -102,8 +102,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 		return result;
 	}
 
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 
 	ParameterMessage::setParameterDumpReply(&reply, id, address);
 
@@ -126,8 +125,7 @@ ReturnValue_t ParameterHelper::initialize() {
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
 		Command_t initialCommand) {
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	reply.setReplyRejected(reason, initialCommand);
 	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index a80a111f..eee91984 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -163,8 +163,7 @@ void Fuse::setAllMonitorsToUnchecked() {
 }
 
 void Fuse::checkCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index b1aea270..5433acc9 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -74,8 +74,7 @@ void PowerSensor::setAllMonitorsToUnchecked() {
 }
 
 void PowerSensor::checkCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index d774b4d5..52f2c474 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -309,8 +309,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
 		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
 		commandQueue->reply(&reply);
@@ -318,8 +317,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 		break;
 	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
 		uint32_t free = modeTables.maxSize() - modeTables.size();
-		MessageQueueMessage message;
-		CommandMessage reply(&message);
+		CommandMessage reply;
 		ModeSequenceMessage::setModeSequenceMessage(&reply,
 				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
 		commandQueue->reply(&reply);
@@ -332,12 +330,11 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 }
 
 void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	MessageQueueMessage message;
 	if (status == RETURN_OK) {
-		CommandMessage reply(&message, CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
 		commandQueue->reply(&reply);
 	} else {
-		CommandMessage reply(&message, CommandMessage::REPLY_REJECTED, status, 0);
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
 		commandQueue->reply(&reply);
 	}
 }
@@ -620,8 +617,7 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
 	for (uint8_t i = 0; i < count; i++) {
 		elements[i]->serialize(&storeBuffer, &size, maxSize, true);
 	}
-	MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
 	if (commandQueue->reply(&reply) != RETURN_OK) {
 		IPCStore->deleteData(address);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 5527f215..737accef 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -77,8 +77,7 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 }
 
 void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
@@ -129,7 +128,7 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
 			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
 		}
 		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &message);
+				iter->second.commandQueue, &command);
 		if (result == RETURN_OK) {
 			++commandsOutstanding;
 		}
@@ -297,8 +296,7 @@ void SubsystemBase::setToExternalControl() {
 void SubsystemBase::announceMode(bool recursive) {
 	triggerEvent(MODE_INFO, mode, submode);
 	if (recursive) {
-		MessageQueueMessage message;
-		CommandMessage command(&message);
+		CommandMessage command;
 		ModeMessage::setModeMessage(&command,
 				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
 		commandAllChildren(&command);
@@ -307,8 +305,7 @@ void SubsystemBase::announceMode(bool recursive) {
 
 void SubsystemBase::checkCommandQueue() {
 	ReturnValue_t result;
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 
 	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
@@ -330,8 +327,7 @@ void SubsystemBase::checkCommandQueue() {
 
 		result = handleCommandMessage(&command);
 		if (result != RETURN_OK) {
-			MessageQueueMessage message;
-			CommandMessage reply(&message);
+			CommandMessage reply;
 			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
 					command.getCommand());
 			replyToCommand(&reply);
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 759af87e..41230f59 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -44,8 +44,7 @@ ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
 }
 
 void AbstractTemperatureSensor::handleCommandQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		result = healthHelper.handleHealthCommand(&command);
@@ -57,7 +56,7 @@ void AbstractTemperatureSensor::handleCommandQueue() {
 			return;
 		}
 		command.setToUnknownCommand();
-		commandQueue->reply(&message);
+		commandQueue->reply(&command);
 	}
 }
 
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 6e191fc1..b1cf38f2 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -279,8 +279,7 @@ ReturnValue_t Heater::initialize() {
 }
 
 void Heater::handleQueue() {
-	MessageQueueMessage message;
-	CommandMessage command(&message);
+	CommandMessage command;
 	ReturnValue_t result = commandQueue->receiveMessage(&command);
 	if (result == HasReturnvaluesIF::RETURN_OK) {
 		result = healthHelper.handleHealthCommand(&command);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4d29c10e..bd6fa5b5 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -76,28 +76,18 @@ ReturnValue_t CommandingServiceBase::initialize() {
 }
 
 void CommandingServiceBase::handleCommandQueue() {
-    MessageQueueMessage message;
-	CommandMessage reply(&message);
+	CommandMessage reply;
 	ReturnValue_t result = RETURN_FAILED;
 	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
 			result = commandQueue->receiveMessage(&reply)) {
-		if(reply.getInternalMessage() == nullptr) {
-			// This should never happen unless the passed message maximum size
-			// is too small!
-			sif::error << "CommandingServiceBase::handleCommandMessage: Reply"
-					"does not satisfy minimum requirements for a command "
-					"message!" << std::endl;
-			continue;
-		}
 		handleCommandMessage(&reply);
 	}
 }
 
 
-void CommandingServiceBase::handleCommandMessage(CommandMessageIF* reply) {
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	bool isStep = false;
-	MessageQueueMessage message;
-	CommandMessage nextCommand(&message);
+	CommandMessage nextCommand;
 	CommandMapIter iter = commandMap.find(reply->getSender());
 
 	// handle unrequested reply first
@@ -303,8 +293,7 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
         CommandMapIter iter) {
     ReturnValue_t result = RETURN_OK;
-    MessageQueueMessage message;
-    CommandMessage command(&message);
+    CommandMessage command;
     iter->subservice = storedPacket->getSubService();
     result = prepareCommand(&command, iter->subservice,
             storedPacket->getApplicationData(),
@@ -316,7 +305,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 	case RETURN_OK:
 		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			sendResult = commandQueue->sendMessage(iter.value->first,
-					&message);
+					&command);
 		}
 		if (sendResult == RETURN_OK) {
 			Clock::getUptime(&iter->uptimeOfStart);
@@ -338,7 +327,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 		if (command.getCommand() != CommandMessage::CMD_NONE) {
 			//Fire-and-forget command.
 			sendResult = commandQueue->sendMessage(iter.value->first,
-					&message);
+					&command);
 		}
 		if (sendResult == RETURN_OK) {
 			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
@@ -384,9 +373,8 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 }
 
 
-void CommandingServiceBase::handleUnrequestedReply(CommandMessageIF* reply) {
-	CommandMessage commandReply(reply->getInternalMessage());
-	commandReply.clear();
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clear();
 }
 
 
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 05f50709..54a0dc7a 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -139,7 +139,7 @@ protected:
 	 * @param objectId Target object ID
 	 * @return
 	 */
-	virtual ReturnValue_t prepareCommand(CommandMessageIF *message,
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
 			uint32_t *state, object_id_t objectId) = 0;
 
@@ -168,9 +168,9 @@ protected:
 	 *   a failure verification message with the reason as the error parameter
 	 *   and the initial command as failure parameter 1.
 	 */
-	virtual ReturnValue_t handleReply(const CommandMessageIF *reply,
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
 			Command_t previousCommand, uint32_t *state,
-			CommandMessageIF *optionalNextCommand, object_id_t objectId,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
 			bool *isStep) = 0;
 
 	/**
@@ -182,7 +182,7 @@ protected:
 	 * Reply which is non-const so the default implementation can clear the
 	 * message.
 	 */
-	virtual void handleUnrequestedReply(CommandMessageIF *reply);
+	virtual void handleUnrequestedReply(CommandMessage* reply);
 
 	virtual void doPeriodicOperation();
 
@@ -310,7 +310,7 @@ private:
 
 	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
 
-	void handleCommandMessage(CommandMessageIF* reply);
+	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
 			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
 

From c7c49b4239fe42f4c4da47eba686c41ff687cf17 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:30:32 +0200
Subject: [PATCH 0486/1292] deleted command messge base

---
 ipc/CommandMessageBase.cpp             | 86 --------------------------
 ipc/CommandMessageBase.h               | 60 ------------------
 ipc/CommandMessageIF.h                 |  2 +-
 ipc/MessageQueueMessage.h              |  2 +-
 tmtcservices/CommandingServiceBase.cpp |  4 +-
 tmtcservices/CommandingServiceBase.h   |  2 +-
 6 files changed, 5 insertions(+), 151 deletions(-)
 delete mode 100644 ipc/CommandMessageBase.cpp
 delete mode 100644 ipc/CommandMessageBase.h

diff --git a/ipc/CommandMessageBase.cpp b/ipc/CommandMessageBase.cpp
deleted file mode 100644
index 745e6c5f..00000000
--- a/ipc/CommandMessageBase.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//#include <framework/ipc/CommandMessageBase.h>
-//#include <framework/ipc/CommandMessageCleaner.h>
-//#include <cstring>
-//
-//CommandMessageBase::CommandMessageBase(MessageQueueMessageIF *message):
-//		internalMessage(message) {
-//}
-//
-//Command_t CommandMessageBase::getCommand() const {
-//	Command_t command;
-//	std::memcpy(&command, internalMessage->getData(), sizeof(Command_t));
-//	return command;
-//}
-//
-//void CommandMessageBase::setCommand(Command_t command) {
-//	std::memcpy(internalMessage->getData(), &command, sizeof(Command_t));
-//}
-//
-//uint8_t CommandMessageBase::getMessageType() const {
-//	// first byte of command ID.
-//	return getCommand() >> 8 & 0xff;
-//}
-//
-//MessageQueueId_t CommandMessageBase::getSender() const {
-//	return internalMessage->getSender();
-//}
-//
-//uint8_t* CommandMessageBase::getBuffer() {
-//	return internalMessage->getBuffer();
-//}
-//
-//void CommandMessageBase::setSender(MessageQueueId_t setId) {
-//	internalMessage->setSender(setId);
-//}
-//
-//const uint8_t* CommandMessageBase::getBuffer() const {
-//	return internalMessage->getBuffer();
-//}
-//
-//// Header includes command ID.
-//uint8_t* CommandMessageBase::getData() {
-//	return internalMessage->getData() + sizeof(Command_t);
-//}
-//
-//// Header includes command ID.
-//const uint8_t* CommandMessageBase::getData() const {
-//	return internalMessage->getData() + sizeof(Command_t);
-//}
-//
-////void CommandMessageBase::setMessageSize(size_t messageSize) {
-////	//internalMessage->setMessageSize(messageSize);
-////}
-//
-//size_t CommandMessageBase::getMessageSize() const {
-//	return internalMessage->getMessageSize();
-//}
-//
-//MessageQueueMessageIF* CommandMessageBase::getInternalMessage() const {
-//	return internalMessage;
-//}
-//
-////size_t CommandMessageBase::getMinimumMessageSize() const {
-////	return MINIMUM_COMMAND_MESSAGE_BASE_SIZE;
-////}
-//
-//void CommandMessageBase::setReplyRejected(ReturnValue_t reason,
-//		Command_t initialCommand) {
-//	std::memcpy(getData(), &reason, sizeof(reason));
-//	std::memcpy(getData() + sizeof(reason), &initialCommand,
-//			sizeof(initialCommand));
-//}
-//
-//ReturnValue_t CommandMessageBase::getReplyRejectedReason(
-//		Command_t *initialCommand) const {
-//	ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-//	std::memcpy(&reason, getData(), sizeof(reason));
-//	if(initialCommand != nullptr) {
-//		std::memcpy(initialCommand, getData() + sizeof(reason),
-//				sizeof(Command_t));
-//	}
-//	return reason;
-//}
-//
-//void CommandMessageBase::clear() {
-//	CommandMessageCleaner::clearCommandMessage(this);
-//}
diff --git a/ipc/CommandMessageBase.h b/ipc/CommandMessageBase.h
deleted file mode 100644
index 59795114..00000000
--- a/ipc/CommandMessageBase.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_
-#include <framework/ipc/CommandMessageIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-
-/**
- * @brief	Base implementation of a generic command message, which has
- * 			a Command_t ID and message type ID in the header in addition
- * 			to the sender message queue ID.
- * @details
- * This is the base implementation serves as a base for other command messages
- * and which implements most functions required for MessageQueueMessageIF.
- * The only functions which have to be supplied by a specific command message
- * impelementations are the size related functions which are used for
- * size checks:
- *
- *  1. getMinimumMessageSize()
- *
- * The maximum message size generally depends on the buffer size of the passed
- * internal message.
- * Don't forget to set the message size of the passed message in the concrete
- * commandmessage implementation!
- */
-class CommandMessageBase: public CommandMessageIF {
-public:
-
-
-	CommandMessageBase(MessageQueueMessageIF* message);
-
-
-
-//	/*
-//	 * MessageQueueMessageIF functions, which generally just call the
-//	 * respective functions of the internal message queue message.
-//	 */
-//	virtual uint8_t * getBuffer() override;
-//	virtual const uint8_t * getBuffer() const override;
-//	virtual void setSender(MessageQueueId_t setId) override;
-//	virtual MessageQueueId_t getSender() const override;
-//	virtual uint8_t * getData() override;
-//	virtual const uint8_t* getData() const override;
-//	virtual size_t getMessageSize() const override;
-
-
-	//virtual MessageQueueMessageIF* getInternalMessage() const override;
-
-
-protected:
-	/**
-	 * @brief 	Pointer to the message containing the data.
-	 * @details
-	 * The command message does not actually own the memory containing a
-	 * message, it just oprates on it via a pointer to a message queue message.
-	 */
-	MessageQueueMessageIF* internalMessage = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEBASE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index ca050c32..2cb6324e 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -8,7 +8,7 @@
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
 typedef uint16_t Command_t;
 
-class CommandMessageIF: virtual public MessageQueueMessageIF {
+class CommandMessageIF {
 public:
     /**
      * Header consists of sender ID and command ID.
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index c4e82a94..3d5d4283 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -23,7 +23,7 @@
  *	receive messages from other tasks.
  *	@ingroup message_queue
  */
-class MessageQueueMessage: virtual public MessageQueueMessageIF {
+class MessageQueueMessage: public MessageQueueMessageIF {
 public:
 	/**
 	 * @brief	The class is initialized empty with this constructor.
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index bd6fa5b5..acf66389 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -146,8 +146,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 }
 
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessageIF* nextCommand,
-		CommandMessageIF* reply, bool& isStep) {
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
 	iter->command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 54a0dc7a..8806bd52 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -312,7 +312,7 @@ private:
 
 	void handleCommandMessage(CommandMessage* reply);
 	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessageIF* nextCommand,CommandMessageIF* reply, bool& isStep);
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
 
 	void checkTimeout();
 };

From af24cc7d047cccf09ff5a002a86aa222b18b19ed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 00:49:13 +0200
Subject: [PATCH 0487/1292] some bugfixes

---
 ipc/CommandMessage.cpp         | 82 +++++++++++++++++++---------------
 ipc/CommandMessage.h           | 30 +++++++------
 ipc/CommandMessageCleaner.cpp  | 20 ++++-----
 ipc/CommandMessageCleaner.h    |  6 +--
 osal/FreeRTOS/MessageQueue.cpp |  6 ---
 5 files changed, 74 insertions(+), 70 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 6aa433df..2b0c34d5 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -3,57 +3,57 @@
 #include <cstring>
 
 CommandMessage::CommandMessage() {
-	MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
     setCommand(CMD_NONE);
 }
 
 CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
         uint32_t parameter2) {
     MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-	setCommand(command);
-	setParameter(parameter1);
-	setParameter2(parameter2);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
 }
 
 Command_t CommandMessage::getCommand() const {
-  Command_t command;
-  std::memcpy(&command, getData(), sizeof(Command_t));
-  return command;
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
 }
 
 void CommandMessage::setCommand(Command_t command) {
-  std::memcpy(getData(), &command, sizeof(Command_t));
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
 }
 
 uint8_t CommandMessage::getMessageType() const {
-  // first byte of command ID.
-  return getCommand() >> 8 & 0xff;
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
 }
 
 uint32_t CommandMessage::getParameter() const {
-	uint32_t parameter1;
-	std::memcpy(&parameter1, MessageQueueMessage::getData(), sizeof(parameter1));
-	return parameter1;
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
 }
 
 void CommandMessage::setParameter(uint32_t parameter1) {
-	std::memcpy(MessageQueueMessage::getData(), &parameter1, sizeof(parameter1));
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
 }
 
 uint32_t CommandMessage::getParameter2() const {
-	uint32_t parameter2;
-	std::memcpy(&parameter2, MessageQueueMessage::getData() + sizeof(uint32_t),
-			sizeof(parameter2));
-	return parameter2;
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
 }
 
 void CommandMessage::setParameter2(uint32_t parameter2) {
-	std::memcpy(MessageQueueMessage::getData()  + sizeof(uint32_t), &parameter2,
-			sizeof(parameter2));
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
 }
 
 size_t CommandMessage::getMinimumMessageSize() const {
-	return MINIMUM_COMMAND_MESSAGE_SIZE;
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
 void CommandMessage::clear() {
@@ -61,29 +61,37 @@ void CommandMessage::clear() {
 }
 
 bool CommandMessage::isClearedCommandMessage() {
-	return getCommand() == CMD_NONE;
+    return getCommand() == CMD_NONE;
 }
 
 void CommandMessage::setToUnknownCommand() {
-	Command_t initialCommand = getCommand();
-	this->clear();
-	setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
 }
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
-      Command_t initialCommand) {
-  std::memcpy(getData(), &reason, sizeof(reason));
-  std::memcpy(getData() + sizeof(reason), &initialCommand,
-          sizeof(initialCommand));
+        Command_t initialCommand) {
+    std::memcpy(getData(), &reason, sizeof(reason));
+    std::memcpy(getData() + sizeof(reason), &initialCommand,
+            sizeof(initialCommand));
 }
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
-      Command_t *initialCommand) const {
-  ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-  std::memcpy(&reason, getData(), sizeof(reason));
-  if(initialCommand != nullptr) {
-      std::memcpy(initialCommand, getData() + sizeof(reason),
-              sizeof(Command_t));
-  }
-  return reason;
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
+    std::memcpy(&reason, getData(), sizeof(reason));
+    if(initialCommand != nullptr) {
+        std::memcpy(initialCommand, getData() + sizeof(reason),
+                sizeof(Command_t));
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index a319a0cf..53df1c08 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -50,6 +50,22 @@ public:
 	 */
 	virtual ~CommandMessage() {}
 
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
@@ -105,20 +121,6 @@ public:
 
     virtual void clear() override;
 
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
     /**
      * Extract message ID, which is the first byte of the command ID for the
      * default implementation.
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 7153a8e7..23e6e168 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -9,34 +9,34 @@
 #include <framework/tmstorage/TmStoreMessage.h>
 #include <framework/parameters/ParameterMessage.h>
 
-void CommandMessageCleaner::clearCommandMessage(CommandMessageIF* message) {
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	switch(message->getMessageType()){
 	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ModeMessage::clear(message);
 		break;
 	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(dynamic_cast<CommandMessage*>(message));
+		HealthMessage::clear(message);
 		break;
 	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ModeSequenceMessage::clear(message);
 		break;
 	case messagetypes::ACTION:
-		ActionMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ActionMessage::clear(message);
 		break;
 	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(dynamic_cast<CommandMessage*>(message));
+		DeviceHandlerMessage::clear(message);
 		break;
 	case messagetypes::MEMORY:
-		MemoryMessage::clear(dynamic_cast<CommandMessage*>(message));
+		MemoryMessage::clear(message);
 		break;
 	case messagetypes::MONITORING:
-		MonitoringMessage::clear(dynamic_cast<CommandMessage*>(message));
+		MonitoringMessage::clear(message);
 		break;
 	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(dynamic_cast<CommandMessage*>(message));
+		TmStoreMessage::clear(message);
 		break;
 	case messagetypes::PARAMETER:
-		ParameterMessage::clear(dynamic_cast<CommandMessage*>(message));
+		ParameterMessage::clear(message);
 		break;
 	default:
 		messagetypes::clearMissionMessage(message);
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index 0bd369a2..48aaa478 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,15 +1,15 @@
 #ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
 #define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include <framework/ipc/CommandMessageIF.h>
+#include <framework/ipc/CommandMessage.h>
 
 namespace messagetypes {
 // Implemented in config.
-void clearMissionMessage(CommandMessageIF* message);
+void clearMissionMessage(CommandMessage* message);
 }
 
 class CommandMessageCleaner {
 public:
-	static void clearCommandMessage(CommandMessageIF* message);
+	static void clearCommandMessage(CommandMessage* message);
 };
 
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 464a4f16..8eb669ed 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -80,12 +80,6 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-    if(message->getMessageSize() < maxMessageSize) {
-        sif::error << "MessageQueue::receiveMessage: Message size "
-                << message->getMessageSize() <<
-                " too small to receive data!" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
 	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
 			message->getBuffer()), 0);
 	if (result == pdPASS){

From 16cbbb2693a18cc588661270c482325d4257e95f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 01:11:48 +0200
Subject: [PATCH 0488/1292] linux fixes

---
 osal/linux/MessageQueue.cpp | 15 +++------------
 osal/linux/MessageQueue.h   |  3 +--
 osal/linux/QueueFactory.cpp |  6 +++---
 3 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index c4b24a13..b11b9b6f 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -281,8 +281,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, maxMessageSize,
-			sentFrom,ignoreFault);
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
 
 }
 
@@ -297,22 +296,14 @@ bool MessageQueue::isDefaultDestinationSet() const {
 uint16_t MessageQueue::queueCounter = 0;
 
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, size_t maxSize,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
 	if(message == nullptr) {
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	if(message->getMaximumMessageSize() > maxSize) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message size "
-				<< message->getMaximumMessageSize() << " too large for queue"
-				" with max. message size " << maxSize << "!"
-				<< std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
 	message->setSender(sentFrom);
 	int result = mq_send(sendTo,
 			reinterpret_cast<const char*>(message->getBuffer()),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 22725d18..8e3a5191 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -149,8 +149,7 @@ protected:
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom = NO_QUEUE,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault=false);
 private:
 	/**
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 95264a42..8bd9d52c 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -9,10 +9,10 @@ QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, size_t maxSize,
-			MessageQueueId_t sentFrom, bool ignoreFault) {
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
 	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			maxSize, sentFrom,ignoreFault);
+			sentFrom,ignoreFault);
 }
 
 QueueFactory* QueueFactory::instance() {

From 7f3607c3d998fb4473fd7b35b3ddf9ebff7b1dbb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 02:00:26 +0200
Subject: [PATCH 0489/1292] hk service fixed

---
 housekeeping/HousekeepingMessage.cpp | 66 ++++++++++------------------
 housekeeping/HousekeepingMessage.h   | 27 +++++-------
 ipc/CommandMessage.cpp               | 12 +++++
 ipc/CommandMessage.h                 | 14 ++----
 4 files changed, 50 insertions(+), 69 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 0d0f9860..64b07c17 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,67 +1,47 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <cstring>
 
-HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
-}
-
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setParameter(uint32_t parameter) {
-	std::memcpy(getData(), &parameter, sizeof(parameter));
-}
-
-uint32_t HousekeepingMessage::getParameter() const {
-	uint32_t parameter;
-	std::memcpy(&parameter, getData(), sizeof(parameter));
-	return parameter;
-}
-
-void HousekeepingMessage::setHkReportMessage(sid_t sid,
+void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 		store_address_t storeId) {
-	CommandMessage::setCommand(HK_REPORT);
-	setSid(sid);
-	setParameter(storeId.raw);
+	message->setCommand(HK_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	message->setParameter(storeId.raw);
 }
 
-void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
-		store_address_t storeId) {
-	CommandMessage::setCommand(DIAGNOSTICS_REPORT);
-	setSid(sid);
-	setParameter(storeId.raw);
+void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+		sid_t sid, store_address_t storeId) {
+	message->setCommand(DIAGNOSTICS_REPORT);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
 }
-
-//size_t HousekeepingMessage::getMinimumMessageSize() const {
-//	return HK_MESSAGE_SIZE;
-//}
-
-sid_t HousekeepingMessage::getSid() const {
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
-	std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
 	return sid;
 }
 
 
-sid_t HousekeepingMessage::getHkReportMessage(
-		store_address_t *storeIdToSet) const {
+sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter();
+		*storeIdToSet = getParameter(message);
 	}
-	return getSid();
+	return getSid(message);
 }
 
-void HousekeepingMessage::setSid(sid_t sid) {
-	std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
 
 
-uint8_t* HousekeepingMessage::getData() {
-	return CommandMessage::getData() + sizeof(sid_t);
+void HousekeepingMessage::setParameter(CommandMessage *message,
+		uint32_t parameter) {
+	message->setParameter3(parameter);
 }
 
-const uint8_t* HousekeepingMessage::getData() const {
-	return CommandMessage::getData() + sizeof(sid_t);
-}
-
-void HousekeepingMessage::clear() {
-	// clear IPC store where it is needed.
+uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
+	return message->getParameter3();
 }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 8958201e..e2a69805 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -34,7 +34,7 @@ union sid_t {
  * This message is slightly larger than regular command messages to accomodate
  * the uint64_t structure ID (SID).
  */
-class HousekeepingMessage : public CommandMessage {
+class HousekeepingMessage {
 public:
 
 	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@@ -45,7 +45,7 @@ public:
 	 * the message data, see CommandMessageIF and getInternalMessage().
 	 * @param message
 	 */
-	HousekeepingMessage();
+	HousekeepingMessage() = delete;
 	virtual ~HousekeepingMessage();
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
@@ -94,25 +94,22 @@ public:
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
+	static sid_t getSid(const CommandMessage* message);
 
-	void setParameter(uint32_t parameter);
-	uint32_t getParameter() const;
-	sid_t getSid() const;
+	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
 
-	void setHkReportMessage(sid_t sid, store_address_t storeId);
-	void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
 	//! Get the respective SID and store ID. Command ID can be used beforehand
 	//! to distinguish between diagnostics and regular HK packets
-	sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
+	static sid_t getHkReportMessage(const CommandMessage* message,
+			store_address_t * storeIdToSet);
 
-	//virtual size_t getMinimumMessageSize() const override;
-	virtual void clear() override;
 private:
-
-	void setSid(sid_t sid);
-
-	virtual uint8_t* getData() override;
-	virtual const uint8_t* getData() const override;
+	static void setSid(CommandMessage* message, sid_t sid);
+	static void setParameter(CommandMessage* message, uint32_t parameter);
+	static uint32_t getParameter(const CommandMessage* message);
 };
 
 
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 2b0c34d5..e1d4dfae 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -52,6 +52,18 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
             sizeof(parameter2));
 }
 
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
 size_t CommandMessage::getMinimumMessageSize() const {
     return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 53df1c08..021fa49a 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -66,29 +66,21 @@ public:
 
     virtual uint8_t* getData() override;
     virtual const uint8_t* getData() const override;
+
 	/**
 	 * Get the first parameter of the message
 	 * @return the first Parameter of the message
 	 */
 	uint32_t getParameter() const;
-
 	/**
 	 * Set the first parameter of the message
 	 * @param the first parameter of the message
 	 */
 	void setParameter(uint32_t parameter1);
-
-	/**
-	 * Get the second parameter of the message
-	 * @return the second Parameter of the message
-	 */
 	uint32_t getParameter2() const;
-
-	/**
-	 * Set the second parameter of the message
-	 * @param the second parameter of the message
-	 */
 	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
 
 	/**
 	 * check if a message was cleared

From 6f2bb4125d7e4cd9baaf812c3dcd118883f65e71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 02:02:57 +0200
Subject: [PATCH 0490/1292] bugfix

---
 housekeeping/HousekeepingMessage.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 64b07c17..2335f03d 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -8,21 +8,16 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	message->setParameter(storeId.raw);
+	setParameter(message, storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 		sid_t sid, store_address_t storeId) {
 	message->setCommand(DIAGNOSTICS_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
 	setParameter(message, storeId.raw);
 }
-sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
-	sid_t sid;
-	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
-	return sid;
-}
-
 
 sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
@@ -32,6 +27,12 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
+	sid_t sid;
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
+	return sid;
+}
+
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }

From 8d633bf1278e473a23ab67ee86458771a5c45bc2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:40:48 +0200
Subject: [PATCH 0491/1292] took over changed for singly linked list

---
 container/SinglyLinkedList.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 3c0078fc..a78a1467 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -88,14 +88,15 @@ public:
 	ElementIterator begin() const {
 		return ElementIterator::Iterator(start);
 	}
-	typename ElementIterator::Iterator end() const {
+
+	ElementIterator end() const {
 		return ElementIterator::Iterator();
 	}
 
-	uint32_t getSize() const {
-		uint32_t size = 0;
+	size_t getSize() const {
+		size_t size = 0;
 		LinkedElement<T> *element = start;
-		while (element != NULL) {
+		while (element != nullptr) {
 			size++;
 			element = element->getNext();
 		}

From 0c32a964529105b611b600938c84df647f8fa0cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:54:41 +0200
Subject: [PATCH 0492/1292] some more singly linked list improvements

---
 container/SinglyLinkedList.h | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index a78a1467..85a92e6a 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -16,8 +16,13 @@ public:
 	class Iterator {
 	public:
 		LinkedElement<T> *value = nullptr;
+		//! Creates an uninitialized iterator which points to nullptr.
 		Iterator() {}
 
+		/**
+		 * Initialize iterator at specified linked element.
+		 * @param element
+		 */
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
 		}
@@ -72,6 +77,11 @@ private:
 	LinkedElement *next;
 };
 
+/**
+ * @brief 	SinglyLinkedList data structure which keeps a pointer to its
+ * 			first element to perform all operations.
+ * @tparam T
+ */
 template<typename T>
 class SinglyLinkedList {
 public:
@@ -90,7 +100,11 @@ public:
 	}
 
 	ElementIterator end() const {
-		return ElementIterator::Iterator();
+		LinkedElement<T> *element = start;
+		while (element != nullptr) {
+			element = element->getNext();
+		}
+		return ElementIterator::Iterator(element);
 	}
 
 	size_t getSize() const {

From 08f25370f3505ebf39f26166b2bf5a4000c28461 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 12:03:52 +0200
Subject: [PATCH 0493/1292] moved typedefs into namespace

---
 tasks/FixedSlotSequence.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 7de1884c..61883658 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -6,9 +6,6 @@
 
 #include <set>
 
-using SlotList = std::multiset<FixedSequenceSlot>;
-using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
 /**
  * @brief	This class is the representation of a Polling Sequence Table in software.
  * @details
@@ -27,6 +24,8 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
  */
 class FixedSlotSequence {
 public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
 
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.

From ba5b8bd682e1e3e36612a9c8974a4b27c8bf1151 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 26 Jun 2020 13:28:58 +0200
Subject: [PATCH 0494/1292] hybrid iter update

---
 container/HybridIterator.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index db1ce4bc..f2fd6b28 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,5 +1,5 @@
-#ifndef HYBRIDITERATOR_H_
-#define HYBRIDITERATOR_H_
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
 #include <framework/container/ArrayList.h>
 #include <framework/container/SinglyLinkedList.h>
@@ -17,23 +17,23 @@ public:
 	}
 
 	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(
-					start->value), linked(true), end(NULL) {
+		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) {
+			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) {
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+			linked(false), end(++lastElement) {
 		if (value == end) {
 			value = NULL;
 		}
@@ -42,17 +42,17 @@ public:
 	HybridIterator& operator++() {
 		if (linked) {
 			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != NULL) {
+			if (LinkedElement<T>::Iterator::value != nullptr) {
 				value = LinkedElement<T>::Iterator::value->value;
 			} else {
-				value = NULL;
+				value = nullptr;
 			}
 		} else {
 			ArrayList<T, count_t>::Iterator::operator++();
 			value = ArrayList<T, count_t>::Iterator::value;
 
 			if (value == end) {
-				value = NULL;
+				value = nullptr;
 			}
 		}
 		return *this;
@@ -64,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(const HybridIterator& other) {
+	bool operator==(const HybridIterator& other) const {
 		return value == other.value;
 	}
 
-	bool operator!=(const HybridIterator& other) {
+	bool operator!=(const HybridIterator& other) const {
 		return !(*this == other);
 	}
 
@@ -87,4 +87,4 @@ private:
 	T *end = nullptr;
 };
 
-#endif /* HYBRIDITERATOR_H_ */
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

From b81b458ba6cc5c6819b9dae6045e25469a1d43cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:44:18 +0200
Subject: [PATCH 0495/1292] exec task if new init function, some corrections

---
 ipc/CommandMessage.cpp                 |  5 ++---
 osal/host/FixedTimeslotTask.cpp        |  2 +-
 osal/host/QueueMapManager.h            |  2 +-
 tasks/ExecutableObjectIF.h             | 13 +++++++++++--
 tasks/FixedSequenceSlot.cpp            |  1 +
 tmtcservices/CommandingServiceBase.cpp |  4 ++--
 6 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index e1d4dfae..0aeaa79a 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -84,9 +84,8 @@ void CommandMessage::setToUnknownCommand() {
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
         Command_t initialCommand) {
-    std::memcpy(getData(), &reason, sizeof(reason));
-    std::memcpy(getData() + sizeof(reason), &initialCommand,
-            sizeof(initialCommand));
+    setParameter(reason);
+    setParameter2(initialCommand);
 }
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 48d11843..dac399f6 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -92,7 +92,7 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 void FixedTimeslotTask::taskFunctionality() {
     // A local iterator for the Polling Sequence Table is created to
     // find the start time for the first entry.
-    SlotListIter slotListIter = pollingSeqTable.current;
+    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
     // Get start time for first entry.
     chron_ms interval(slotListIter->pollingTimeMs);
     auto currentStartTime {
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 34f0fc95..499b1622 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	std::atomic<uint32_t> queueCounter = MessageQueueIF::NO_QUEUE + 1;
+	std::atomic<uint32_t> queueCounter = 1;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 516b4084..f66b53da 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -43,9 +43,18 @@ public:
 	 * a reference to the executing task
 	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
 
-	}
+	/**
+	 * This function will be called after the object was assigned to a specific
+	 * task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	//virtual ReturnValue_t initializeAfterTaskCreation() = 0;
 };
 
 #endif /* EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index c46b4fc0..430ce019 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -9,6 +9,7 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	if(executingTask != nullptr) {
 	    handler->setTaskIF(executingTask);
 	}
+	//handler->initializeAfterTaskCreation();
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index acf66389..5a48bd63 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -109,8 +109,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getReplyRejectedReason(
-				reinterpret_cast<Command_t*>(&failureParameter1));
+		result = reply->getReplyRejectedReason();
+		failureParameter1 = iter->command;
 	}
 
 	switch (result) {

From d5d968a39365b2b0c285d8f283a054050e94be3b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:46:16 +0200
Subject: [PATCH 0496/1292] some more correctioons

---
 datapoollocal/LocalDataPoolManager.cpp | 24 ++++++++++++------------
 ipc/CommandMessage.cpp                 |  6 ++----
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index bc57468a..55d36a9a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -105,18 +105,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	//HousekeepingMessage hkMessage;
-//	hkMessage.setHkReportMessage(sid, storeId);
-//	if(hkQueue == nullptr) {
-//	    return QUEUE_NOT_SET;
-//	}
-//
-//	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-//	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
-//	}
-//	else {
-//	    result = hkQueue->sendToDefault(&hkMessage);
-//	}
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_NOT_SET;
+	}
+
+	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	}
+	else {
+	    result = hkQueue->sendToDefault(&hkMessage);
+	}
 
 	return result;
 }
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 0aeaa79a..1470fe85 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -90,11 +90,9 @@ void CommandMessage::setReplyRejected(ReturnValue_t reason,
 
 ReturnValue_t CommandMessage::getReplyRejectedReason(
         Command_t *initialCommand) const {
-    ReturnValue_t reason = HasReturnvaluesIF::RETURN_FAILED;
-    std::memcpy(&reason, getData(), sizeof(reason));
+    ReturnValue_t reason = getParameter();
     if(initialCommand != nullptr) {
-        std::memcpy(initialCommand, getData() + sizeof(reason),
-                sizeof(Command_t));
+        *initialCommand = getParameter2();
     }
     return reason;
 }

From 003e70bf4785a8b9e57a8f8ab5f67ae0b0dfade3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 15:55:20 +0200
Subject: [PATCH 0497/1292] new initializeAfterTaskCreation()

---
 osal/FreeRTOS/PeriodicTask.cpp   |  3 ++-
 osal/linux/PeriodicPosixTask.cpp |  4 +++-
 osal/rtems/MultiObjectTask.cpp   |  3 ++-
 tasks/ExecutableObjectIF.h       | 25 +++++++++----------------
 tasks/FixedSequenceSlot.cpp      |  2 +-
 5 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 170eb0a4..2ebfebf4 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -94,7 +94,8 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 	if(setTaskIF) {
 	     newObject->setTaskIF(this);
 	}
-	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index db4005b0..b811274b 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -36,7 +36,9 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 	if(setTaskIF) {
 	    newObject->setTaskIF(this);
 	}
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index bb8c2c81..6b9c8c8e 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -78,7 +78,8 @@ ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
-	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
 }
 
 uint32_t MultiObjectTask::getPeriodMs() const {
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index f66b53da..d716cdfb 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,15 +1,5 @@
-/**
- * @file	ExecutableObjectIF.h
- *
- * @brief	This file contains the definition for the ExecutableObjectIF interface.
- *
- * @author	Bastian Baetz
- *
- * @date	12.03.2012
- */
-
-#ifndef EXECUTABLEOBJECTIF_H_
-#define EXECUTABLEOBJECTIF_H_
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
 
 class PeriodicTaskIF;
 
@@ -20,6 +10,7 @@ class PeriodicTaskIF;
  * @brief	The interface provides a method to execute objects within a task.
  * @details	The performOperation method, that is required by the interface is
  * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
  */
 class ExecutableObjectIF {
 public:
@@ -46,15 +37,17 @@ public:
 	virtual void setTaskIF(PeriodicTaskIF* task_) {};
 
 	/**
-	 * This function will be called after the object was assigned to a specific
-	 * task.
+	 * This function should be called after the object was assigned to a
+	 * specific task.
 	 *
 	 * Example: Can be used to get task execution frequency.
 	 * The task is created after initialize() and the object ctors have been
 	 * called so the execution frequency can't be cached in initialize()
 	 * @return
 	 */
-	//virtual ReturnValue_t initializeAfterTaskCreation() = 0;
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
 };
 
-#endif /* EXECUTABLEOBJECTIF_H_ */
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 430ce019..4331aada 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -9,7 +9,7 @@ FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 	if(executingTask != nullptr) {
 	    handler->setTaskIF(executingTask);
 	}
-	//handler->initializeAfterTaskCreation();
+	handler->initializeAfterTaskCreation();
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}

From ae6314d8cd43a0ad8f0c1a7b9bd567be378203d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:06:53 +0200
Subject: [PATCH 0498/1292] added task handle member

---
 tmtcservices/PusServiceBase.cpp | 11 +++++++++++
 tmtcservices/PusServiceBase.h   | 17 +++++++++++++----
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index f5d1e30b..82e5ff5c 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -32,6 +32,10 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	return RETURN_OK;
 }
 
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
 void PusServiceBase::handleRequestQueue() {
 	TmTcMessage message;
 	ReturnValue_t result = RETURN_FAILED;
@@ -108,3 +112,10 @@ ReturnValue_t PusServiceBase::initialize() {
 		return RETURN_FAILED;
 	}
 }
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 39600c41..6d3d9bac 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -96,11 +96,20 @@ public:
 	 * @return	@c RETURN_OK if the periodic performService was successful.
 	 * 			@c RETURN_FAILED else.
 	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	virtual uint16_t getIdentifier();
-	MessageQueueId_t getRequestQueue();
-	virtual ReturnValue_t initialize();
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
 	/**
 	 * The APID of this instance of the Service.
 	 */

From 044aa259e6298bf8accff8c8ab53cd373ed186bc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:37:55 +0200
Subject: [PATCH 0499/1292] dhb cached pst interval now

---
 devicehandlers/DeviceHandlerBase.cpp |  9 +++++++++
 devicehandlers/DeviceHandlerBase.h   | 11 +++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0442be89..3994dc12 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1374,6 +1374,15 @@ ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
+    // In this function, the task handle should be valid in any case.
+    // We still check to be 1000 % sure :-)
+    if(executingTask != nullptr) {
+        pstIntervalMs = executingTask->getPeriodMs();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 1290742c..b2b4798d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -11,6 +11,8 @@
 #include <framework/modes/HasModesIF.h>
 #include <framework/power/PowerSwitchIF.h>
 #include <framework/ipc/MessageQueueIF.h>
+#include <framework/tasks/PeriodicTaskIF.h>
+
 #include <framework/action/ActionHelper.h>
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
@@ -18,6 +20,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+
 #include <map>
 
 namespace Factory{
@@ -563,6 +566,8 @@ protected:
 
 	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint32_t pstIntervalMs = 0;
+
 	/**
 	 * Wiretapping flag:
 	 *
@@ -1196,9 +1201,11 @@ private:
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	void parseReply(const uint8_t* receivedData,
-			size_t receivedDataLen);
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 	DataSetIF* getDataSetHandle(sid_t sid) override;
+
+	void parseReply(const uint8_t* receivedData,
+	            size_t receivedDataLen);
 };
 
 #endif /* DEVICEHANDLERBASE_H_ */

From 691be0dcd4f6c8586b4a29b866bc7d9808d345c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:39:55 +0200
Subject: [PATCH 0500/1292] dhb doc improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 3994dc12..cebe8953 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1375,8 +1375,8 @@ ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
 }
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
-    // In this function, the task handle should be valid in any case.
-    // We still check to be 1000 % sure :-)
+    // In this function, the task handle should be valid if the task
+    // was implemented correctly. We still check to be 1000 % sure :-)
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }

From 48df3cbe8382423b671d7b5d651e3b623f4e2d90 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:43:02 +0200
Subject: [PATCH 0501/1292] csb comment improved

---
 tmtcservices/CommandingServiceBase.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8806bd52..37fa0a04 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -276,7 +276,6 @@ protected:
 	void checkAndExecuteFifo(CommandMapIter iter);
 
 private:
-
 	/**
 	 * This method handles internal execution of a command,
 	 * once it has been started by @sa{startExecution()} in the request
@@ -296,10 +295,13 @@ private:
 	void handleCommandQueue();
 
 	/**
+	 * @brief       Handler function for request queue
+	 * @details
 	 * Sequence of request queue handling:
 	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates Start Success Reports TM[1,3] in subfunction @sa{startExecution()}
-	 * or Start Failure Report TM[1,4] by using the TC Verification Service
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
 	 */
 	void handleRequestQueue();
 

From e2a36efce3d210c85c1ba924cd627a43b1cac922 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:47:58 +0200
Subject: [PATCH 0502/1292] csb changes taken over

---
 tmtcservices/CommandingServiceBase.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 5a48bd63..f8af15af 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -57,7 +57,9 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (packetForwarding == nullptr or distributor == nullptr) {
-		return RETURN_FAILED;
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	distributor->registerService(this);
@@ -68,7 +70,9 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
-		return RETURN_FAILED;
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	return RETURN_OK;
@@ -109,8 +113,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
 			result == RETURN_FAILED) {
-		result = reply->getReplyRejectedReason();
-		failureParameter1 = iter->command;
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
 	}
 
 	switch (result) {
@@ -176,14 +180,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	}
 	else {
 		if (isStep) {
-			nextCommand->clear();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
 					iter->tcInfo.tcPacketId,
 					iter->tcInfo.tcSequenceControl, sendResult,
 					++iter->step, failureParameter1, failureParameter2);
 		} else {
-			nextCommand->clear();
+			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
 					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
@@ -318,7 +322,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
-			command.clear();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -335,7 +339,7 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
-			command.clear();
+			command.clearCommandMessage();
 			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
@@ -374,7 +378,7 @@ void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 
 
 void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clear();
+	reply->clearCommandMessage();
 }
 
 

From 85cc936d5da669f8f74ea02c87a8204f4a6235c4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 29 Jun 2020 16:50:45 +0200
Subject: [PATCH 0503/1292] added back clear CommandMessage function

---
 ipc/CommandMessage.cpp | 4 ++++
 ipc/CommandMessage.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 1470fe85..8c296abd 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -68,6 +68,10 @@ size_t CommandMessage::getMinimumMessageSize() const {
     return MINIMUM_COMMAND_MESSAGE_SIZE;
 }
 
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
 void CommandMessage::clear() {
     CommandMessageCleaner::clearCommandMessage(this);
 }
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 021fa49a..d843e4c5 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -111,7 +111,9 @@ public:
     ReturnValue_t getReplyRejectedReason(
             Command_t* initialCommand = nullptr) const override;
 
+
     virtual void clear() override;
+    void clearCommandMessage();
 
     /**
      * Extract message ID, which is the first byte of the command ID for the

From 3a850018550b319476a4ec8b68bd75b035909df2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 00:48:48 +0200
Subject: [PATCH 0504/1292] bit setter correction

---
 datapoollocal/LocalDataSet.cpp |  7 +++----
 datapoollocal/LocalDataSet.h   | 10 +++-------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 27ad4bc2..3fc8592e 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -42,7 +42,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
         if(registeredVariables[count]->isValid()) {
             // set validity buffer here.
             this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit, true);
+                    validBufferIndexBit);
             if(validBufferIndexBit == 7) {
                 validBufferIndex ++;
                 validBufferIndexBit = 0;
@@ -83,13 +83,12 @@ ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position,
-        bool value) const {
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1UL << shiftNumber;
+    *byte |= 1 << shiftNumber;
 }
 
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 48138e63..aea699d8 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -98,14 +98,10 @@ private:
 	LocalDataPoolManager* hkManager;
 
 	/**
-	 * Sets the bit at the bit-position of a byte provided by its address
-	 * to the specified value (zero or one).
-	 * @param byte Pointer to byte to bitset.
-	 * @param position MSB first, 0 to 7 possible.
-	 * @param value Value to set.
-	 * @return
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
 	 */
-	void bitSetter(uint8_t* byte, uint8_t position, bool value) const;
+	void bitSetter(uint8_t* byte, uint8_t position) const;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */

From 2de972bb8a9a35b81824f5c6bc5d00802c32dadd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 15:51:19 +0200
Subject: [PATCH 0505/1292] const store accessor copy ctor fixx

---
 storagemanager/ConstStorageAccessor.h | 6 +++---
 storagemanager/StorageAccessor.h      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index cf8ca08f..020030a9 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -80,13 +80,13 @@ public:
 	 * @return
 	 */
 	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
 
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index c5e38306..475b2f4f 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -26,7 +26,7 @@ public:
 	 * @return
 	 */
 	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From 1820b5f95c4e3d03c06cd7c0ee9b2fa6639adac9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 16:02:07 +0200
Subject: [PATCH 0506/1292] hotfix for copy ctor

---
 storagemanager/ConstStorageAccessor.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index cf8ca08f..020030a9 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -80,13 +80,13 @@ public:
 	 * @return
 	 */
 	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
 
 	//! The copy ctor and copy assignemnt should be deleted implicitely
 	//! according to https://foonathan.net/2019/02/special-member-functions/
 	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
-	ConstStorageAccessor (ConstStorageAccessor&) = delete;
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
 protected:
 	const uint8_t* constDataPointer = nullptr;
 	store_address_t storeId;

From 837fecf8599a54102c59ea549ac56a876ff5c32b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 30 Jun 2020 21:22:26 +0200
Subject: [PATCH 0507/1292] added hk receiver obj id to dhb ctor

---
 datapoollocal/LocalDataPoolManager.cpp    | 66 +++++++++++++-----
 datapoollocal/LocalDataPoolManager.h      | 84 +++++++++++++++--------
 devicehandlers/AcceptsDeviceResponsesIF.h | 17 ++---
 devicehandlers/ChildHandlerBase.cpp       |  7 +-
 devicehandlers/ChildHandlerBase.h         |  6 +-
 devicehandlers/DeviceHandlerBase.cpp      | 34 +++++----
 devicehandlers/DeviceHandlerBase.h        | 23 ++++---
 housekeeping/AcceptsHkPacketsIF.h         | 11 +++
 tmtcservices/CommandingServiceBase.h      |  2 +-
 9 files changed, 169 insertions(+), 81 deletions(-)
 create mode 100644 housekeeping/AcceptsHkPacketsIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 55d36a9a..bb06206e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,6 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/housekeeping/AcceptsHkPacketsIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 #include <framework/ipc/QueueFactory.h>
@@ -7,7 +8,7 @@
 #include <array>
 
 LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
-        uint32_t replyQueueDepth, bool appendValidityBuffer):
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
@@ -24,16 +25,44 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
-	hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
-	        HousekeepingMessage::HK_MESSAGE_SIZE);
+	hkQueue = queueToUse;
+}
+
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
+        object_id_t hkDestination) {
+    if(queueToUse == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
+                "invalid!" << std::endl;
+    }
+    hkQueue = queueToUse;
+
+    if(hkDestination == objects::NO_OBJECT) {
+        return initializeHousekeepingPoolEntriesOnce();
+    }
+
+    AcceptsHkPacketsIF* hkReceiver =
+            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
+    if(hkReceiver != nullptr) {
+        setHkPacketDestination(hkReceiver->getHkQueue());
+    }
+    else {
+        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
+                " queue ID from HK destination object ID. Make sure it exists"
+                " and the object impements AcceptsHkPacketsIF!" << std::endl;
+    }
+    return initializeHousekeepingPoolEntriesOnce();
+}
+
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t hkDestination) {
+    this->hkDestination = hkDestination;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result =
-				owner->initializePoolEntries(localDpMap);
+		ReturnValue_t result = owner->initializePoolEntries(localDpMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -80,16 +109,12 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t destinationQueueId) {
-    this->currentHkPacketDestination = destinationQueueId;
-}
-
 const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        MessageQueueId_t sendTo) {
 	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -108,14 +133,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
 	CommandMessage hkMessage;
 	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
 	if(hkQueue == nullptr) {
-	    return QUEUE_NOT_SET;
+	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
 
-	if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
+	if(sendTo != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(sendTo, &hkMessage);
 	}
 	else {
-	    result = hkQueue->sendToDefault(&hkMessage);
+	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+	                " Destination is not set properly!" << std::endl;
+	        return QUEUE_OR_DESTINATION_NOT_SET;
+	    }
+	    else {
+	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+	    }
 	}
 
 	return result;
@@ -149,6 +181,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     return result;
 }
 
+void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+}
+
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         store_address_t *storeId, LocalDataSet* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
@@ -177,4 +212,3 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 }
 
 
-
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9d072bf4..3841b99c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -44,18 +44,45 @@ public:
     static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
     static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
 
-    static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
     //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
 
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
-	        uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	/**
+	 * Initializes the map by calling the map initialization function of the
+	 * owner abd assigns the queue to use.
+	 * @param queueToUse
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse,
+	        object_id_t hkDestination);
+	/**
+	 * This function is used to set the default HK packet destination.
+	 * This destination will usually only be set once.
+	 * @param hkDestination
+	 */
+	void setHkPacketDestination(MessageQueueId_t hkDestination);
+
 	virtual~ LocalDataPoolManager();
 
-	/* Copying forbidden */
-	LocalDataPoolManager(const LocalDataPoolManager &) = delete;
-	LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	/**
+	 * Generate a housekeeping packet with a given SID.
+	 * @param sid
+	 * @return
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
+	        = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -68,40 +95,43 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	//! Set the queue for HK packets, which are sent unrequested.
-	void setHkPacketDestination(MessageQueueId_t destinationQueueId);
-
 	const OwnsLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 private:
-	//! This is the map holding the actual data. Should only be initialized
-	//! once !
+	/** This is the map holding the actual data. Should only be initialized
+	 * once ! */
 	bool mapInitialized = false;
-	//! This specifies whether a validity buffer is appended at the end
-	//! of generated housekeeping packets.
+	/** This specifies whether a validity buffer is appended at the end
+	 * of generated housekeeping packets. */
 	bool appendValidityBuffer = true;
 
 	LocalDataPool localDpMap;
 
-	//! Every housekeeping data manager has a mutex to protect access
-	//! to it's data pool.
+	/** Every housekeeping data manager has a mutex to protect access
+	 * to it's data pool. */
 	MutexIF * mutex = nullptr;
-
-	//! The class which actually owns the manager (and its datapool).
+	/** The class which actually owns the manager (and its datapool). */
 	OwnsLocalDataPoolIF* owner = nullptr;
-
-	//! Queue used for communication, for example commands.
-	//! Is also used to send messages.
+	/**
+	 * @brief Queue used for communication, for example commands.
+	 * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+	 */
 	MessageQueueIF* hkQueue = nullptr;
 
-	//! HK replies will always be a reply to the commander, but HK packet
-	//! can be sent to another destination by specifying this message queue
-	//! ID, for example to a dedicated housekeeping service implementation.
-	MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
+	/**
+	 * HK replies will always be a reply to the commander, but HK packet
+	 * can be sent to another destination by specifying this message queue
+	 * ID, for example to a dedicated housekeeping service implementation.
+	 */
+	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
 
-	//! Global IPC store is used to store all packets.
+	/** Global IPC store is used to store all packets. */
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index c811158f..fcf5237d 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,15 +1,12 @@
-/**
- * @file	AcceptsDeviceResponsesIF.h
- * @brief	This file defines the AcceptsDeviceResponsesIF class.
- * @date	15.05.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSDEVICERESPONSESIF_H_
-#define ACCEPTSDEVICERESPONSESIF_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
 
 #include <framework/ipc/MessageQueueSenderIF.h>
 
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
 class AcceptsDeviceResponsesIF {
 public:
 	/**
@@ -19,4 +16,4 @@ public:
 	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index c3484676..3e5bcc60 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -5,10 +5,11 @@
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
 		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId, uint32_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			setDeviceSwitch,  thermalStatePoolId,
+		    hkDestination, setDeviceSwitch,  thermalStatePoolId,
 			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 493b22ee..10021631 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -8,9 +8,9 @@ class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			uint32_t parent, FailureIsolationBase* customFdir = nullptr,
-			size_t cmdQueueSize = 20);
+			object_id_t hkDestination, uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId, uint32_t parent,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cebe8953..867bf415 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -22,21 +22,21 @@ object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
-		size_t cmdQueueSize) :
+		uint8_t setDeviceSwitch, object_id_t hkDestination,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this),
+		actionHelper(this, nullptr), hkManager(this, nullptr),
 		deviceThermalStatePoolId(thermalStatePoolId),
 		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
-		SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		switchOffWasReported(false), hkDestination(hkDestination),
+		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
@@ -173,7 +173,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initializeHousekeepingPoolEntriesOnce();
+	result = hkManager.initialize(commandQueue, hkDestination);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -315,6 +315,12 @@ void DeviceHandlerBase::doStateMachine() {
 	case _MODE_WAIT_OFF: {
 		uint32_t currentUptime;
 		Clock::getUptime(&currentUptime);
+
+		if(powerSwitcher == nullptr) {
+		    setMode(MODE_OFF);
+		    return;
+		}
+
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
 			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
 					0);
@@ -696,19 +702,23 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 
 	if (info->delayCycles != 0) {
 
-		if (info->periodic != 0) {
+		if (info->periodic != false) {
 			info->delayCycles = info->maxDelayCycles;
-		} else {
+		}
+		else {
 			info->delayCycles = 0;
 		}
+
 		result = interpretDeviceReply(foundId, receivedData);
+
 		if (result != RETURN_OK) {
 			// Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
 			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
 		}
 		replyToReply(iter, result);
-	} else {
+	}
+	else {
 		// Other completion failure messages are created by timeout.
 		// Powering down the device might take some time during which periodic
 		// replies may still come in.
@@ -719,7 +729,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 }
 
 ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t * *data, uint32_t * len) {
+		uint8_t** data, uint32_t * len) {
 	size_t lenTmp;
 
 	if (IPCStore == nullptr) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b2b4798d..3fdab9ed 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -107,6 +107,7 @@ public:
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
 			CookieIF * comCookie, uint8_t setDeviceSwitch,
+			object_id_t hkDestination = objects::NO_OBJECT,
 			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
 			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
 			FailureIsolationBase* fdirInstance = nullptr,
@@ -652,11 +653,13 @@ protected:
 		size_t replyLen = 0; //!< Expected size of the reply.
 		//! if this is !=0, the delayCycles will not be reset to 0 but to
 		//! maxDelayCycles
-		bool periodic;
+		bool periodic = false;
 		//! The dataset used to access housekeeping data related to the
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
-		DataSetIF* dataSet;
+		DataSetIF* dataSet = nullptr;
+		float collectionInterval = 0.0;
+		uint32_t intervalCounter = 0;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1035,18 +1038,19 @@ private:
 	};
 
 	/**
-	 * Info about the #cookie
-	 *
+	 * @brief   Info about the #cookie
 	 * Used to track the state of the communication
 	 */
 	CookieInfo cookieInfo;
 
-	/** the object used to set power switches*/
+	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
+	/** Cached for initialize() */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
 	/**
-	 * Used for timing out mode transitions.
-	 *
+	 * @brief   Used for timing out mode transitions.
 	 * Set when setMode() is called.
 	 */
 	uint32_t timeoutStart = 0;
@@ -1057,11 +1061,12 @@ private:
 	uint32_t childTransitionDelay;
 
 	/**
-	 * The mode the current transition originated from
+	 * @brief   The mode the current transition originated from
 	 *
 	 * This is private so the child can not change it and fuck up the timeouts
 	 *
-	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!! (it is _MODE_POWER_DOWN during this modes)
+	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
+	 * (it is _MODE_POWER_DOWN during this modes)
 	 *
 	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
 	 */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
new file mode 100644
index 00000000..f44e1d95
--- /dev/null
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include <framework/ipc/MessageQueueMessageIF.h>
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 37fa0a04..700503c6 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -89,7 +89,7 @@ public:
 	 */
 	virtual MessageQueueId_t getCommandQueue();
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
 	/**
 	 * Implementation of ExecutableObjectIF function

From d7bff31a4cfd5e720847a0c9525a4099b97560ac Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jul 2020 14:17:55 +0200
Subject: [PATCH 0508/1292] compiling again

---
 datapool/DataSetBase.cpp                |   8 +-
 datapool/DataSetBase.h                  |   5 +-
 datapool/PoolRawAccessHelper.cpp        |  20 ++--
 datapool/PoolRawAccessHelper.h          |   6 +-
 datapoolglob/GlobalPoolVariable.h       |  14 +--
 datapoolglob/GlobalPoolVector.h         |   4 +-
 datapoolglob/GlobalPoolVector.tpp       |  16 ++--
 datapoolglob/PIDReader.h                |   6 +-
 datapoolglob/PoolRawAccess.cpp          |  70 +++++++-------
 datapoolglob/PoolRawAccess.h            |  14 +--
 datapoollocal/LocalDataPoolManager.cpp  |   7 +-
 datapoollocal/LocalDataSet.cpp          |  12 ++-
 datapoollocal/LocalDataSet.h            |   6 +-
 datapoollocal/LocalPoolVariable.h       |   6 +-
 datapoollocal/LocalPoolVariable.tpp     |  12 +--
 datapoollocal/LocalPoolVector.h         |   5 +-
 datapoollocal/LocalPoolVector.tpp       |  16 ++--
 health/HealthTableIF.h                  |   2 +-
 power/PowerComponent.h                  |   9 --
 serialize/SerialBufferAdapter.cpp       |   8 +-
 serialize/SerialFixedArrayListAdapter.h |  35 +++----
 serialize/SerializeAdapter.h            |   3 +-
 serialize/SerializeAdapterInternal.h    | 118 ------------------------
 tmtcpacket/pus/TmPacketStored.cpp       |   2 +-
 24 files changed, 144 insertions(+), 260 deletions(-)
 delete mode 100644 serialize/SerializeAdapterInternal.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index b788d05d..55801eb1 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -131,11 +131,11 @@ ReturnValue_t DataSetBase::unlockDataPool() {
 }
 
 ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, bool bigEndian) const {
+		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,
-				bigEndian);
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -144,11 +144,11 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 }
 
 ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
+        SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t count = 0; count < fillCount; count++) {
 		result = registeredVariables[count]->deSerialize(buffer, size,
-				bigEndian);
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8f7d892a..8eae6a09 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -105,10 +105,11 @@ public:
 
 	/* SerializeIF implementations */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize, bool bigEndian) const override;
+				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,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	// SHOULDDO we could use a linked list of datapool variables
 	//!< This definition sets the maximum number of variables to
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 6e289303..2324a56c 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -24,8 +24,9 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
 }
 
 ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
-		const size_t max_size, bool bigEndian) {
-	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
+		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++) {
@@ -44,9 +45,10 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 }
 
 ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
-		size_t * size, const size_t max_size, bool bigEndian) {
+		size_t * size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = RETURN_OK;
-	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
+	SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
 	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
@@ -76,8 +78,8 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
 		bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
-	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
-			&poolIdBuffer,remainingParameters, false);
+	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;
@@ -109,8 +111,8 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 
 		GlobDataSet currentDataSet;
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
-				&currentDataSet,PoolVariableIF::VAR_READ);
+		PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
+				&currentDataSet, PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
@@ -137,7 +139,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
 		}
 
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
-				argStruct.max_size, argStruct.bigEndian);
+				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 "
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 52d9ebe5..0d8f8d6d 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -43,7 +43,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 	/**
 	 * Serializes data pool entries into provided buffer with the validity mask buffer
@@ -56,7 +56,7 @@ public:
 	 * 			@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
-			const size_t max_size, bool bigEndian);
+			const size_t max_size, SerializeIF::Endianness streamEndianness);
 
 
 private:
@@ -71,7 +71,7 @@ private:
 		uint8_t ** buffer;
 		size_t * size;
 		const size_t max_size;
-		bool bigEndian;
+		SerializeIF::Endianness streamEndianness;
 	};
 	/**
 	 * Helper function to serialize single pool entries
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index 9e3eea0c..b4aa6c4c 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -181,18 +181,20 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override {
-		return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
-				bigEndian);
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
 	}
 
 	virtual size_t getSerializedSize() const {
-		return SerializeAdapter<T>::getSerializedSize(&value);
+		return SerializeAdapter::getSerializedSize(&value);
 	}
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
 	}
 };
 
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 93092228..0e03f77d 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -109,10 +109,10 @@ public:
 	const T &operator [](int i) const {return value[i];}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			size_t max_size, Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index 5710da57..ccf33138 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -79,12 +79,13 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				max_size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
@@ -94,17 +95,18 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	uint16_t i;
 	ReturnValue_t result;
 	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+		        streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 1b337f28..a1116040 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -16,9 +16,9 @@ protected:
 	uint32_t parameterId;
 	uint8_t valid;
 	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = ::dataPool.getData<T>(
-				DataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
 		if (read_out != NULL) {
 			valid = read_out->valid;
 			value = read_out->address[arrayIndex];
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 39cfd58c..bec54ab3 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -145,27 +145,29 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 
 
 ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	if (typeSize + *size <= max_size) {
-		if (bigEndian) {
+        size_t maxSize, Endianness streamEndianness) const {
+    //TODO integer overflow
+    if (typeSize + *size <= maxSize) {
+#warning use endian swapper
+        if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				(*buffer)[count] = value[typeSize - count - 1];
-			}
+            for (uint8_t count = 0; count < typeSize; count++) {
+                (*buffer)[count] = value[typeSize - count - 1];
+            }
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(*buffer, value, typeSize);
+            memcpy(*buffer, value, typeSize);
 #endif
-		} else {
-			memcpy(*buffer, value, typeSize);
-		}
-		*size += typeSize;
-		(*buffer) += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
+        } else {
+            memcpy(*buffer, value, typeSize);
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
 }
 
 
@@ -231,28 +233,26 @@ size_t PoolRawAccess::getSerializedSize() const {
 }
 
 ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
-		bool bigEndian) {
-	// TODO: Needs to be tested!!!
-	if (*size >= typeSize) {
-		*size -= typeSize;
-		if (bigEndian) {
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        *size -= typeSize;
+        if (1) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-			for (uint8_t count = 0; count < typeSize; count++) {
-				value[count] = (*buffer)[typeSize - count - 1];
-			}
+            for (uint8_t count = 0; count < typeSize; count++) {
+                value[count] = (*buffer)[typeSize - count - 1];
+            }
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			memcpy(value, *buffer, typeSize);
+            memcpy(value, *buffer, typeSize);
 #endif
-		}
-		else {
-			memcpy(value, *buffer, typeSize);
-		}
-		*buffer += typeSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
+        } else {
+            memcpy(value, *buffer, typeSize);
+        }
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 60e3c71e..ea07356e 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -69,8 +69,13 @@ public:
 	 * @return - @c RETURN_OK if serialization was successfull
 	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
 	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
 
 	/**
 	 * With this method, the content can be set from a big endian buffer safely.
@@ -130,11 +135,6 @@ public:
 	 */
 	uint16_t getSizeTillEnd() const;
 
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
 	 * @details
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index bb06206e..78116138 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -173,7 +173,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     }
     size_t size = 0;
     result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, false);
+            expectedSize, SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 "Expected size is not equal to serialized size" << std::endl;
@@ -198,10 +198,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 
     if(appendValidityBuffer) {
         result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, false);
+                &size, hkSize, SerializeIF::Endianness::MACHINE);
     }
     else {
-        result = dataSet->serialize(&storePtr, &size, hkSize, false);
+        result = dataSet->serialize(&storePtr, &size, hkSize,
+                SerializeIF::Endianness::MACHINE);
     }
 
     if(result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 3fc8592e..72d79103 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -32,7 +32,8 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 }
 
 ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, const size_t maxSize, bool bigEndian) const {
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
     uint8_t validityMask[validityMaskSize];
@@ -52,7 +53,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
             }
         }
         result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                bigEndian);
+                streamEndianness);
         if (result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
@@ -69,11 +70,12 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
 }
 
 ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, const size_t maxSize, bool bigEndian) const {
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
     for (uint16_t count = 0; count < fillCount; count++) {
         lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, bigEndian);
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index aea699d8..e997b729 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -68,10 +68,12 @@ public:
 	 * @return
 	 */
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-            size_t* size, const size_t maxSize, bool bigEndian) const;
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
 protected:
 private:
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 4b6e24aa..98782b8d 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -84,11 +84,11 @@ public:
 	void setValid(bool validity) override;
 	uint8_t getValid() const;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 9dcd0699..7f9fbf13 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -133,20 +133,20 @@ inline uint8_t LocalPoolVar<T>::getValid() const {
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
-	return AutoSerializeAdapter::serialize(&value,
-			buffer, size ,max_size, bigEndian);
+		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+	return SerializeAdapter::serialize(&value,
+			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
 inline size_t LocalPoolVar<T>::getSerializedSize() const {
-	return AutoSerializeAdapter::getSerializedSize(&value);
+	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, bool bigEndian) {
-	return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
+		size_t* size, SerializeIF::Endianness streamEndianness) {
+	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a8d0a7bb..f6532894 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -114,10 +114,11 @@ public:
 	const T &operator [](int i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const override;
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
 	virtual size_t getSerializedSize() const override;
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian) override;
+	        SerializeIF::Endianness streamEndianness) override;
 
 	/**
 	 * @brief	This is a call to read the array's values
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a18f8327..872c49ec 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -125,11 +125,12 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size, bool bigEndian) const {
+		size_t* size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
-				max_size, bigEndian);
+		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+				maxSize, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}
@@ -139,16 +140,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
 
 template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
+	return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size, bool bigEndian) {
+		const uint8_t** buffer, size_t* size,
+		SerializeIF::Endianness streamEndianness) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
-				bigEndian);
+		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+				streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			break;
 		}
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index c8d2c74a..e4606286 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -19,7 +19,7 @@ public:
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
 	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
 	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 1c550776..61ab3674 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -20,21 +20,12 @@ public:
 	float getMax();
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-<<<<<<< HEAD
-			const size_t max_size, bool bigEndian) const;
-
-	size_t getSerializedSize() const;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			bool bigEndian);
-=======
 			size_t maxSize, Endianness streamEndianness) const override;
 
 	size_t getSerializedSize() const override;
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) override;
->>>>>>> upstream/mohr_serialize
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 69f40a34..1224bba1 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -36,18 +36,18 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 					maxSize, streamEndianness);
 		}
 		if (constBuffer != nullptr) {
-			memcpy(*buffer_, this->constBuffer, bufferLength);
+			memcpy(*buffer, this->constBuffer, bufferLength);
 		}
 		else if (buffer != nullptr) {
 			// This will propably be never reached, constBuffer should always be
 			// set if non-const buffer is set.
-			memcpy(*buffer_, this->buffer, bufferLength);
+			memcpy(*buffer, this->buffer, bufferLength);
 		}
 		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
-		*size_ += bufferLength;
-		(*buffer_) += bufferLength;
+		*size += bufferLength;
+		(*buffer) += bufferLength;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 }
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 6ad154a8..196af67c 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -39,30 +39,25 @@ public:
 	 */
 	template<typename... Args>
 	SerialFixedArrayListAdapter(Args... args) :
-	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
-	{}
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const  override {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
-				buffer, size, max_size, bigEndian);
-	}
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+                buffer, size, maxSize, streamEndianness);
+    }
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
-	}
+    size_t getSerializedSize() const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+    }
 
-	size_t getSerializedSize() const {
-		return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
-	}
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
-	}
 };
 
-
-
 #endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index f8042861..2be39d5c 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -2,8 +2,9 @@
 #define SERIALIZEADAPTER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/serialize/EndianSwapper.h>
+#include <framework/container/IsDerivedFrom.h>
 #include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapterInternal.h>
 #include <type_traits>
 
  /**
diff --git a/serialize/SerializeAdapterInternal.h b/serialize/SerializeAdapterInternal.h
deleted file mode 100644
index c57af0c9..00000000
--- a/serialize/SerializeAdapterInternal.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * @file 	SerializeAdapterInternal.h
- *
- * @date	13.04.2020
- * @author	R. Mueller
- */
-
-#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/IsDerivedFrom.h>
-#include <framework/serialize/EndianSwapper.h>
-
-/**
- * This template specialization will be chosen for fundamental types or
- * anything else not implementing SerializeIF, based on partial
- * template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T, int>
-class SerializeAdapter_ {
-public:
-	/**
-	 *
-	 * @param object
-	 * @param buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-	    // function eventuelly serializes structs here.
-	    // does this work on every architecture?
-	    // static_assert(std::is_fundamental<T>::value);
-		size_t ignoredSize = 0;
-		if (size == nullptr) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
-	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer contains the data. Non-Const pointer to non-const
-	 * 				 pointer to const data.
-	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		T tmp;
-		if (*size >= sizeof(T)) {
-			*size -= sizeof(T);
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
-	}
-
-	size_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-};
-
-/**
- * This template specialization will be chosen for class derived from
- * SerializeIF, based on partial template specialization.
- * @tparam T
- * @tparam
- */
-template<typename T>
-class SerializeAdapter_<T, true> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-
-	size_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
-	}
-};
-
-#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 14cf6a03..d6a4a69f 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -84,7 +84,7 @@ void TmPacketStored::deletePacket() {
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
 	const uint8_t *temp_data = NULL;
-	uint32_t temp_size;
+	size_t temp_size;
 	if (!checkAndSetStore()) {
 		return;
 	}

From 47b8ed2321c1a71743cb50fa555cbb3f6b2a3a62 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 1 Jul 2020 14:34:16 +0200
Subject: [PATCH 0509/1292] split up long debug message

---
 datapoollocal/LocalDataPoolManager.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 78116138..9c70c74f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -47,8 +47,9 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
     }
     else {
         sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. Make sure it exists"
-                " and the object impements AcceptsHkPacketsIF!" << std::endl;
+                " queue ID from HK destination object ID. " << std::flush;
+        sif::warning << "Make sure it exists and the object impements "
+                "AcceptsHkPacketsIF!" << std::endl;
     }
     return initializeHousekeepingPoolEntriesOnce();
 }

From 3e069c34aa6a076f0394ab6bdf3c66f14294ba53 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jul 2020 16:29:29 +0200
Subject: [PATCH 0510/1292] datasetbase stays same f or now

---
 datapool/{StaticDataSetBase.cpp => DataSetBase.cpp} | 2 +-
 datapool/{StaticDataSetBase.h => DataSetBase.h}     | 6 +++---
 datapoolglob/GlobalDataSet.h                        | 2 +-
 datapoollocal/LocalDataSet.h                        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename datapool/{StaticDataSetBase.cpp => DataSetBase.cpp} (98%)
 rename datapool/{StaticDataSetBase.h => DataSetBase.h} (97%)

diff --git a/datapool/StaticDataSetBase.cpp b/datapool/DataSetBase.cpp
similarity index 98%
rename from datapool/StaticDataSetBase.cpp
rename to datapool/DataSetBase.cpp
index 3815534e..b788d05d 100644
--- a/datapool/StaticDataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,4 +1,4 @@
-#include <framework/datapool/StaticDataSetBase.h>
+#include <framework/datapool/DataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 DataSetBase::DataSetBase() {
diff --git a/datapool/StaticDataSetBase.h b/datapool/DataSetBase.h
similarity index 97%
rename from datapool/StaticDataSetBase.h
rename to datapool/DataSetBase.h
index 708849ce..8f7d892a 100644
--- a/datapool/StaticDataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_
+#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>
@@ -146,4 +146,4 @@ private:
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_STATICDATASETBASE_H_ */
+#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index dec66dbc..f0bf7daa 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef DATASET_H_
 #define DATASET_H_
 
-#include <framework/datapool/StaticDataSetBase.h>
+#include <framework/datapool/DataSetBase.h>
 
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 52a227e5..aea699d8 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/StaticDataSetBase.h>
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 

From 099e6281ecdaccf39127da33e7b86b6eaa3f2335 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 2 Jul 2020 16:54:53 +0200
Subject: [PATCH 0511/1292] DataSetBase not bound to max size anymore

---
 datapool/DataSetBase.cpp             |  9 ++++++---
 datapool/DataSetBase.h               | 13 ++++++-------
 datapoolglob/GlobalDataSet.cpp       |  4 +++-
 datapoolglob/GlobalDataSet.h         |  6 ++++++
 datapoollocal/LocalDataSet.cpp       | 14 ++++++++++++--
 datapoollocal/LocalDataSet.h         | 10 ++++++++--
 datapoollocal/StaticLocalDataSet.cpp |  6 ++++++
 datapoollocal/StaticLocalDataSet.h   | 11 +++++++++++
 8 files changed, 58 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/StaticLocalDataSet.cpp
 create mode 100644 datapoollocal/StaticLocalDataSet.h

diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index b788d05d..3d38e143 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,8 +1,11 @@
 #include <framework/datapool/DataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-DataSetBase::DataSetBase() {
-	for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; count++) {
+DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
+        const size_t maxFillCount):
+        registeredVariables(registeredVariablesArray),
+        maxFillCount(maxFillCount) {
+	for (uint8_t count = 0; count < maxFillCount; count++) {
 		registeredVariables[count] = nullptr;
 	}
 }
@@ -21,7 +24,7 @@ ReturnValue_t DataSetBase::registerVariable(
 				"Pool variable is nullptr." << std::endl;
 		return DataSetIF::POOL_VAR_NULL;
 	}
-	if (fillCount >= DATA_SET_MAX_SIZE) {
+	if (fillCount >= maxFillCount) {
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
 		return DataSetIF::DATA_SET_FULL;
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index 8f7d892a..12ae2b53 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -37,7 +37,8 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	DataSetBase();
+	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxFillCount);
 	virtual~ DataSetBase();
 
 	/**
@@ -110,11 +111,6 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) override;
 
-	// SHOULDDO we could use a linked list of datapool variables
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
 protected:
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
@@ -137,8 +133,11 @@ protected:
 
 	/**
 	 * @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[DATA_SET_MAX_SIZE] = { };
+	PoolVariableIF** registeredVariables = nullptr;
+	const size_t maxFillCount = 0;
 
 private:
 	ReturnValue_t readVariable(uint16_t count);
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 9da8d524..883f6157 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -2,7 +2,9 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet(): DataSetBase() {}
+GlobDataSet::GlobDataSet(): DataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
 
 // Don't do anything with your variables, they are dead already!
 // (Destructor is already called)
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index f0bf7daa..519b08c0 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -61,6 +61,10 @@ public:
 	 */
 	void setEntriesValid(bool valid);
 
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
 private:
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
@@ -85,6 +89,8 @@ private:
 
 	void handleAlreadyReadDatasetCommit();
 	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
 };
 
 #endif /* DATASET_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 3fc8592e..c5142bfc 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,20 +5,30 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
+LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase()  {
+LocalDataSet::LocalDataSet(object_id_t ownerId,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
     OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
             ownerId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
+        return;
     }
     hkManager = hkOwner->getHkManagerHandle();
 }
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index aea699d8..1a894130 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -5,6 +5,8 @@
 #include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
+#include <vector>
+
 class LocalDataPoolManager;
 
 /**
@@ -35,7 +37,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
+	LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
@@ -43,7 +46,8 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(object_id_t ownerId);
+	LocalDataSet(object_id_t ownerId,
+	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -102,6 +106,8 @@ private:
 	 * (most significant bit) to 7 (least significant bit)
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+	std::vector<PoolVariableIF*> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
new file mode 100644
index 00000000..15d4251a
--- /dev/null
+++ b/datapoollocal/StaticLocalDataSet.cpp
@@ -0,0 +1,6 @@
+#include <framework/datapoollocal/StaticLocalDataSet.h>
+
+
+
+
+
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
new file mode 100644
index 00000000..15a79aae
--- /dev/null
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -0,0 +1,11 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#include <framework/datapool/DataSetBase.h>
+
+
+class StaticLocalDataSet: public DataSetBase {
+
+};
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From 72768a68152b3fb6778e7c90aead2b6f46d596ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 00:51:49 +0200
Subject: [PATCH 0512/1292] started unix udp bridge

---
 osal/linux/TmTcUnixUdpBridge.cpp | 37 ++++++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.h   | 28 ++++++++++++++++++++++++
 tmtcservices/TmTcBridge.cpp      |  6 +++---
 tmtcservices/TmTcBridge.h        |  2 +-
 4 files changed, 69 insertions(+), 4 deletions(-)
 create mode 100644 osal/linux/TmTcUnixUdpBridge.cpp
 create mode 100644 osal/linux/TmTcUnixUdpBridge.h

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
new file mode 100644
index 00000000..02c17312
--- /dev/null
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -0,0 +1,37 @@
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t ccsdsPacketDistributor):
+		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	if(socket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		// check errno here.
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(UDP_SERVER_PORT);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			sizeof(serverAddress));
+	if(result== -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << UDP_SERVER_PORT << " to server socket!"
+				<< std::endl;
+		// check errno here.
+		return;
+	}
+
+
+
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
new file mode 100644
index 00000000..b84d9fe1
--- /dev/null
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include <framework/tmtcservices/TmTcBridge.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+public:
+	static constexpr int UDP_SERVER_PORT = 7;
+	static constexpr int UDP_CLIENT_PORT = 2008;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	virtual~ TmTcUnixUdpBridge();
+
+protected:
+
+private:
+	int serverSocket = 0;
+	const int serverSocketOptions = 0;
+	struct sockaddr_in clientAddress;
+	struct sockaddr_in serverAddress;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index f9a7d3bc..092884bb 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -5,9 +5,9 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/globalfunctions/arrayprinter.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId_,
-        object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
-        ccsdsPacketDistributor(ccsdsPacketDistributor_)
+TmTcBridge::TmTcBridge(object_id_t objectId,
+        object_id_t ccsdsPacketDistributor): SystemObject(objectId),
+        ccsdsPacketDistributor(ccsdsPacketDistributor)
 {
     TmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e0432d8..b50e9e1b 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -22,7 +22,7 @@ public:
 	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
 	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
-	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
+	TmTcBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
 	virtual ~TmTcBridge();
 
 	/**

From e0a3257f8b945da09aba28e784ebc2756e72f984 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 23:20:29 +0200
Subject: [PATCH 0513/1292] even better output for unset max msg size

---
 osal/linux/MessageQueue.cpp | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index b11b9b6f..3d5d7a5a 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -62,22 +62,27 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		// Just an additional helpful printout :-)
 		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
 				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			// This happens if the msg_max value is not large enough
-			// It is ignored if the executable is run in privileged mode.
-			// Run the unlockRealtime script or grant the mode manually by using:
-			// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
 
-			// Persistent solution for session:
-			// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
 
-			// Permanent solution:
-			// sudo nano /etc/sysctl.conf
-			// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			// Apply changes with: sudo sysctl -p
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
 		}
 		break;
 	}

From 571da391087a8c03220989ed61b1333543aef4ee Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 4 Jul 2020 23:52:44 +0200
Subject: [PATCH 0514/1292] continued new bridge

---
 osal/linux/TmTcUnixUdpBridge.cpp | 29 ++++++++++++++++++++++++++---
 osal/linux/TmTcUnixUdpBridge.h   | 12 ++++++++----
 2 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 02c17312..c2c0c353 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -2,8 +2,19 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t ccsdsPacketDistributor):
+		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
+		uint16_t clientPort):
 		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
@@ -14,7 +25,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 
 	serverAddress.sin_family = AF_INET;
 	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	serverAddress.sin_port = htons(UDP_SERVER_PORT);
+	serverAddress.sin_port = htons(setServerPort);
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
@@ -23,7 +34,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			sizeof(serverAddress));
 	if(result== -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-				"local port " << UDP_SERVER_PORT << " to server socket!"
+				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
 		// check errno here.
 		return;
@@ -35,3 +46,15 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 }
+
+ReturnValue_t TmTcUnixUdpBridge::handleTc() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index b84d9fe1..ab2e2d67 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -8,14 +8,18 @@
 
 class TmTcUnixUdpBridge: public TmTcBridge {
 public:
-	static constexpr int UDP_SERVER_PORT = 7;
-	static constexpr int UDP_CLIENT_PORT = 2008;
+	static constexpr int DEFAULT_UDP_SERVER_PORT = 7;
+	static constexpr int DEFAULT_UDP_CLIENT_PORT = 2008;
 
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
+			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
 protected:
-
+	virtual ReturnValue_t handleTc() override;
+	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
+			size_t * size) override;
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;

From 5cee12684142153d01f31627b0bd9b17bcee31d2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:06:30 +0200
Subject: [PATCH 0515/1292] formatting

---
 osal/linux/TmTcUnixUdpBridge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index c2c0c353..045e475a 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -32,7 +32,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			sizeof(serverAddress));
-	if(result== -1) {
+	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;

From c160000027bbe6311fd9c0d318c62a51179129ac Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 12:44:08 +0200
Subject: [PATCH 0516/1292] Corrected filename of EndianConverter.h

---
 memory/MemoryHelper.cpp                          | 2 +-
 serialize/{EndianSwapper.h => EndianConverter.h} | 0
 serialize/SerializeAdapter.h                     | 3 +--
 3 files changed, 2 insertions(+), 3 deletions(-)
 rename serialize/{EndianSwapper.h => EndianConverter.h} (100%)

diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 7c8f7610..b07f450c 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -2,7 +2,7 @@
 #include <framework/memory/MemoryHelper.h>
 #include <framework/memory/MemoryMessage.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianSwapper.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
diff --git a/serialize/EndianSwapper.h b/serialize/EndianConverter.h
similarity index 100%
rename from serialize/EndianSwapper.h
rename to serialize/EndianConverter.h
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 2be39d5c..bb364eae 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -2,8 +2,7 @@
 #define SERIALIZEADAPTER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
-#include <framework/container/IsDerivedFrom.h>
+#include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>
 #include <type_traits>
 

From 24240b6c7d73d124af1caae18ead919ccde203c8 Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 15:46:00 +0200
Subject: [PATCH 0517/1292] Documented EndianConverter and changed length to
 size_t

---
 serialize/EndianConverter.h | 59 ++++++++++++++++++++++++++++++-------
 1 file changed, 48 insertions(+), 11 deletions(-)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 4ab28ecf..81117a5e 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -5,15 +5,41 @@
 #include <cstring>
 #include <iostream>
 
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
 class EndianConverter {
 private:
 	EndianConverter() {};
 public:
 	/**
-	 * Swap the endianness of a variable with arbitrary type
-	 * @tparam T Type of variable
-	 * @param in variable
-	 * @return Variable with swapped endianness
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
 	 */
 	template<typename T>
 	static T convertBigEndian(T in) {
@@ -23,7 +49,7 @@ public:
 		T tmp;
 		uint8_t *pointerOut = (uint8_t*) &tmp;
 		uint8_t *pointerIn = (uint8_t*) &in;
-		for (uint8_t count = 0; count < sizeof(T); count++) {
+		for (size_t count = 0; count < sizeof(T); count++) {
 			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 		}
 		return tmp;
@@ -34,12 +60,16 @@ public:
 #endif
 	}
 
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
 	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			uint32_t size) {
+			size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < size; count++) {
+		for (size_t count = 0; count < size; count++) {
 			out[size - count - 1] = in[count];
 		}
 		return;
@@ -49,7 +79,10 @@ public:
 #endif
 	}
 
-
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
 	template<typename T>
 	static T convertLittleEndian(T in) {
 #ifndef BYTE_ORDER_SYSTEM
@@ -58,7 +91,7 @@ public:
 			T tmp;
 			uint8_t *pointerOut = (uint8_t *) &tmp;
 			uint8_t *pointerIn = (uint8_t *) &in;
-			for (uint8_t count = 0; count < sizeof(T); count++) {
+			for (size_t count = 0; count < sizeof(T); count++) {
 				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
 			}
 			return tmp;
@@ -68,12 +101,16 @@ public:
 	#error Unknown Byte Order
 	#endif
 	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
 	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			uint32_t size) {
+			size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 	#error BYTE_ORDER_SYSTEM not defined
 	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (uint8_t count = 0; count < size; count++) {
+			for (size_t count = 0; count < size; count++) {
 				out[size - count - 1] = in[count];
 			}
 			return;

From 1a177d2efa05f62c86fe33352cf3608d1b96340b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:28:06 +0200
Subject: [PATCH 0518/1292] integrated pool raw access serialize changes

---
 datapoolglob/PoolRawAccess.cpp | 84 +++++++++++++---------------------
 datapoolglob/PoolRawAccess.h   |  6 +--
 2 files changed, 34 insertions(+), 56 deletions(-)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index bec54ab3..cd4138d3 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,7 +1,7 @@
 #include <framework/datapoolglob/GlobalDataPool.h>
 #include <framework/datapoolglob/PoolRawAccess.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/Endiness.h>
+#include <framework/serialize/EndianConverter.h>
 
 #include <cstring>
 
@@ -130,15 +130,7 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 		return DATA_POOL_ACCESS_FAILED;
 	if (typeSize > max_size)
 		return INCORRECT_SIZE;
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-	for (uint8_t count = 0; count < typeSize; count++) {
-		buffer[count] = data_ptr[typeSize - count - 1];
-	}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-	memcpy(buffer, data_ptr, typeSize);
-#endif
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
 	*writtenBytes = typeSize;
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -146,21 +138,18 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
 
 ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
         size_t maxSize, Endianness streamEndianness) const {
-    //TODO integer overflow
     if (typeSize + *size <= maxSize) {
-#warning use endian swapper
-        if (1) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-            for (uint8_t count = 0; count < typeSize; count++) {
-                (*buffer)[count] = value[typeSize - count - 1];
-            }
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-            memcpy(*buffer, value, typeSize);
-#endif
-        } else {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
             memcpy(*buffer, value, typeSize);
+            break;
         }
         *size += typeSize;
         (*buffer) += typeSize;
@@ -175,11 +164,11 @@ Type PoolRawAccess::getType() {
 	return type;
 }
 
-uint8_t PoolRawAccess::getSizeOfType() {
+size_t PoolRawAccess::getSizeOfType() {
 	return typeSize;
 }
 
-uint8_t PoolRawAccess::getArraySize(){
+size_t PoolRawAccess::getArraySize(){
 	return arraySize;
 }
 
@@ -191,22 +180,14 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
 	return readWriteMode;
 }
 
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t* buffer,
-		uint32_t setSize) {
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
 	if (typeSize == setSize) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (uint8_t count = 0; count < typeSize; count++) {
-			value[count] = buffer[typeSize - count - 1];
-		}
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(value, buffer, typeSize);
-#endif
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
-				<< (uint32_t) typeSize << ", Requested: " << setSize
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
 				<< std::endl;
 		return INCORRECT_SIZE;
 	}
@@ -232,27 +213,24 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
         Endianness streamEndianness) {
 
     if (*size >= typeSize) {
-        *size -= typeSize;
-        if (1) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-            for (uint8_t count = 0; count < typeSize; count++) {
-                value[count] = (*buffer)[typeSize - count - 1];
-            }
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-            memcpy(value, *buffer, typeSize);
-#endif
-        } else {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
             memcpy(value, *buffer, typeSize);
+            break;
         }
+    	*size -= typeSize;
         *buffer += typeSize;
         return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::STREAM_TOO_SHORT;
     }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index ea07356e..2ef1d653 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -85,7 +85,7 @@ public:
 	 * 			- @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			uint32_t setSize);
+			size_t setSize);
 	/**
 	 *  @brief This operation returns the type of the entry currently stored.
 	 */
@@ -93,12 +93,12 @@ public:
 	/**
 	 *  @brief This operation returns the size of the entry currently stored.
 	 */
-	uint8_t getSizeOfType();
+	size_t getSizeOfType();
 	/**
 	 *
 	 * @return the size of the datapool array
 	 */
-	uint8_t getArraySize();
+	size_t getArraySize();
 	/**
 	 * @brief	This operation returns the data pool id of the variable.
 	 */

From b86e5664c470bf1b1c9615abb8557d51d3f86eb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 00:33:03 +0200
Subject: [PATCH 0519/1292] include which was missing, pool raw access size_t
 replacements

---
 datapoolglob/PoolRawAccess.cpp | 5 ++++-
 datapoolglob/PoolRawAccess.h   | 8 ++++----
 serialize/SerializeAdapter.h   | 1 +
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index cd4138d3..4355cd0f 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -204,7 +204,7 @@ void PoolRawAccess::setValid(bool valid) {
 	this->valid = valid;
 }
 
-uint16_t PoolRawAccess::getSizeTillEnd() const {
+size_t PoolRawAccess::getSizeTillEnd() const {
 	return sizeTillEnd;
 }
 
@@ -233,4 +233,7 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
         *buffer += typeSize;
         return HasReturnvaluesIF::RETURN_OK;
     }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
 }
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 2ef1d653..f58efdd0 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -133,7 +133,7 @@ public:
 	/**
 	 * Getter for the remaining size.
 	 */
-	uint16_t getSizeTillEnd() const;
+	size_t getSizeTillEnd() const;
 
 	/**
 	 * @brief	This is a call to read the value from the global data pool.
@@ -202,15 +202,15 @@ private:
 	/**
 	 * @brief	This value contains the size of the data pool entry type in bytes.
 	 */
-	uint8_t typeSize;
+	size_t typeSize;
 	/**
 	 * The size of the DP array (single values return 1)
 	 */
-	uint8_t arraySize;
+	size_t arraySize;
 	/**
 	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
 	 */
-	uint16_t sizeTillEnd;
+	size_t sizeTillEnd;
 	/**
 	 * @brief	The information whether the class is read-write or read-only is stored here.
 	 */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index bb364eae..4534ffb8 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,6 +1,7 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
+#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/EndianConverter.h>
 #include <framework/serialize/SerializeIF.h>

From 9dcf0c711854aff22789f0bdcb5375bde51e74bd Mon Sep 17 00:00:00 2001
From: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date: Fri, 3 Jul 2020 15:50:29 +0200
Subject: [PATCH 0520/1292] size_t for DataPoolAdmin

---
 datapoolglob/DataPoolAdmin.cpp | 8 ++++----
 datapoolglob/DataPoolAdmin.h   | 6 +++---
 datapoolglob/PoolRawAccess.cpp | 2 +-
 datapoolglob/PoolRawAccess.h   | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index edbac6eb..4d0e5530 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
 }
 
 ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
 	if (actionId != SET_VALIDITY) {
 		return INVALID_ACTION_ID;
 	}
@@ -91,7 +91,7 @@ void DataPoolAdmin::handleCommand() {
 }
 
 ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
-		const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
+		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;
@@ -129,7 +129,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
 	return ACTIVITY_COMPLETED;
 }
 
-ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
+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);
@@ -151,7 +151,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
 				PoolVariableIF::VAR_READ);
 		status = rawSet.read();
 		if (status == RETURN_OK) {
-			uint32_t temp = 0;
+			size_t temp = 0;
 			status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
 			if (status != RETURN_OK) {
 				return RETURN_FAILED;
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 5f995893..653fdd8e 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -30,12 +30,12 @@ public:
 	MessageQueueId_t getCommandQueue() const;
 
 	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			uint32_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
 			uint8_t** dataPointer, uint8_t* copyHere);
 
 	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
 
 	//not implemented as ParameterHelper is no used
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 4355cd0f..783418cc 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -121,7 +121,7 @@ uint8_t* PoolRawAccess::getEntry() {
 }
 
 ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		uint32_t* writtenBytes, uint32_t max_size) {
+		size_t* writtenBytes, size_t max_size) {
 	uint8_t* data_ptr = getEntry();
 	// debug << "PoolRawAccess::getEntry: Array position: " <<
 	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index f58efdd0..22dc312d 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -57,8 +57,8 @@ public:
 	 * @return	- @c RETURN_OK if entry could be acquired
 	 * 			- @c RETURN_FAILED else.
 	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
-			uint32_t max_size);
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
 
 	/**
 	 * @brief 	Serialize raw pool entry into provided buffer directly

From fcf3f04377910154f4a8302481b5f0cbec5273fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 01:25:49 +0200
Subject: [PATCH 0521/1292] diag output for inits improved

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++++--
 fdir/FailureIsolationBase.cpp        | 6 ++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 867bf415..fcb61ace 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -128,8 +128,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-		if (rawReceiver == NULL) {
-			return RETURN_FAILED;
+		if (rawReceiver == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
+					"ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					" and implements AcceptsDeviceResponsesIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 018fbe6a..a2fc9ea1 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -35,8 +35,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 			return result;
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == NULL) {
-			return RETURN_FAILED;
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
 	if (faultTreeParent != 0) {

From 9e2fa165506192b18ca2ea4fa2540c7918c9e480 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 15:31:02 +0200
Subject: [PATCH 0522/1292] mq stack error improved

---
 osal/linux/MessageQueue.cpp      |  2 +-
 osal/linux/PosixThread.cpp       |  6 ++++--
 osal/linux/TmTcUnixUdpBridge.cpp | 21 ++++++++++++++++++---
 osal/linux/TmTcUnixUdpBridge.h   |  2 ++
 4 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 3d5d7a5a..ce1da17c 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -47,7 +47,7 @@ MessageQueue::~MessageQueue() {
 	status = mq_unlink(name);
 	if(status != 0){
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) <<std::endl;
+				   << strerror(errno) << std::endl;
 	}
 }
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index bc3e62ed..d84c8d9d 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -149,8 +149,10 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-		sif::error << "Posix Thread attribute setStack failed with: " <<
-				strerror(status) << std::endl;
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 045e475a..3beef3d4 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,6 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <errno.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
@@ -20,6 +21,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 		// check errno here.
+		handleSocketError();
 		return;
 	}
 
@@ -39,9 +41,6 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		// check errno here.
 		return;
 	}
-
-
-
 }
 
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
@@ -58,3 +57,19 @@ ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+void TmTcUnixUdpBridge::handleSocketError() {
+	// See: https://man7.org/linux/man-pages/man2/socket.2.html
+	switch(errno) {
+	case(EACCES):
+	case(EINVAL):
+	case(EMFILE):
+	case(ENFILE):
+	case(EAFNOSUPPORT):
+	case(ENOBUFS):
+	case(ENOMEM):
+	case(EPROTONOSUPPORT):
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+	}
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index ab2e2d67..ccab1b1f 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -25,6 +25,8 @@ private:
 	const int serverSocketOptions = 0;
 	struct sockaddr_in clientAddress;
 	struct sockaddr_in serverAddress;
+
+	void handleSocketError();
 };
 
 

From 26ab1983dcad5ae88addd3aa9b947db9ee6edfc6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 18:22:39 +0200
Subject: [PATCH 0523/1292] new ports

---
 osal/linux/TmTcUnixUdpBridge.cpp | 43 ++++++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.h   |  7 ++++--
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 3beef3d4..60f4214e 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -39,6 +39,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
 		// check errno here.
+		handleBindError();
 		return;
 	}
 }
@@ -59,6 +60,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::handleSocketError() {
+
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
 	switch(errno) {
 	case(EACCES):
@@ -71,5 +73,46 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(EPROTONOSUPPORT):
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+				<< std::endl;
+		break;
 	}
 }
+
+void TmTcUnixUdpBridge::handleBindError() {
+	// See: https://man7.org/linux/man-pages/man2/bind.2.html
+	switch(errno) {
+	case(EACCES):
+		/*
+		 Ephermeral ports can be shown with following command:
+		 sysctl -A | grep ip_local_port_range
+		 */
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Port access issue."
+				"Ports 1-1024 are reserved on UNIX systems and require root "
+				"rights while ephermeral ports should not be used as well."
+				<< std::endl;
+		break;
+	case(EADDRINUSE):
+	case(EBADF):
+	case(EINVAL):
+	case(ENOTSOCK):
+	case(EADDRNOTAVAIL):
+	case(EFAULT):
+	case(ELOOP):
+	case(ENAMETOOLONG):
+	case(ENOENT):
+	case(ENOMEM):
+	case(ENOTDIR):
+	case(EROFS):
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+					<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+						<< std::endl;
+		break;
+	}
+
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index ccab1b1f..7c55ea82 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -8,8 +8,10 @@
 
 class TmTcUnixUdpBridge: public TmTcBridge {
 public:
-	static constexpr int DEFAULT_UDP_SERVER_PORT = 7;
-	static constexpr int DEFAULT_UDP_CLIENT_PORT = 2008;
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr int DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr int DEFAULT_UDP_CLIENT_PORT = 7302;
 
 	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
@@ -27,6 +29,7 @@ private:
 	struct sockaddr_in serverAddress;
 
 	void handleSocketError();
+	void handleBindError();
 };
 
 

From 724fee09ff30d8c1e435870a93cd4800e6ac0c86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 18:58:16 +0200
Subject: [PATCH 0524/1292] new task for tc unix polling

---
 osal/linux/TcUnixUdpPollingTask.cpp |  8 ++++++++
 osal/linux/TcUnixUdpPollingTask.h   | 28 ++++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.cpp    | 23 ++++++++++++++---------
 osal/linux/TmTcUnixUdpBridge.h      |  1 -
 4 files changed, 50 insertions(+), 10 deletions(-)
 create mode 100644 osal/linux/TcUnixUdpPollingTask.cpp
 create mode 100644 osal/linux/TcUnixUdpPollingTask.h

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
new file mode 100644
index 00000000..0703904c
--- /dev/null
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -0,0 +1,8 @@
+#include <framework/osal/linux/TcSocketPollingTask.h>
+
+TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge): SystemObject(objectId) {
+}
+
+TcSocketPollingTask::~TcSocketPollingTask() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
new file mode 100644
index 00000000..ffed08a7
--- /dev/null
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcSocketPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+public:
+	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+	virtual~ TcSocketPollingTask();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+private:
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 60f4214e..ff8b6588 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -47,15 +47,15 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 }
 
-ReturnValue_t TmTcUnixUdpBridge::handleTc() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+	ssize_t result = send(serverSocket, data, dataLen, flags);
+	if(result < 0) {
+		//handle error
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
+				"with error " << strerror(errno) << std::endl;
+	}
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -114,5 +114,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 						<< std::endl;
 		break;
 	}
-
+}
+
+
+ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
+	// TC reception handled by separate polling task because it is blocking.
+	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 7c55ea82..a969083d 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -18,7 +18,6 @@ public:
 	virtual~ TmTcUnixUdpBridge();
 
 protected:
-	virtual ReturnValue_t handleTc() override;
 	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
 			size_t * size) override;
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;

From 327b1e9d2f242c49c331533a6d8c34407bf0060f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 19:11:21 +0200
Subject: [PATCH 0525/1292] file renamed

---
 osal/linux/TcUnixUdpPollingTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 0703904c..c470d96f 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,4 +1,4 @@
-#include <framework/osal/linux/TcSocketPollingTask.h>
+#include <framework/osal/linux/TcUnixUdpPollingTask.h>
 
 TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge): SystemObject(objectId) {

From 2395e487aee6c5cc6701a4e0a50de2ea676e4f0c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 20:42:05 +0200
Subject: [PATCH 0526/1292] udp polling taks init

---
 osal/linux/TcUnixUdpPollingTask.cpp | 8 ++++++++
 osal/linux/TcUnixUdpPollingTask.h   | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index c470d96f..21ad1d9a 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -6,3 +6,11 @@ TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 
 TcSocketPollingTask::~TcSocketPollingTask() {
 }
+
+ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcSocketPollingTask::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index ffed08a7..eda7fe5d 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/tasks/ExecutableObjectIF.h>
+#include <sys/socket.h>
 
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
@@ -14,6 +15,7 @@
  */
 class TcSocketPollingTask: public SystemObject,
 		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
 public:
 	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
 	virtual~ TcSocketPollingTask();
@@ -21,6 +23,8 @@ public:
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
 private:
+	//! Sender Address is cached here.
+	const struct sockaddr senderAddress;
 };
 
 

From ebec074655d40dd60c4553c8b94ce3018d6f7358 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 5 Jul 2020 23:53:13 +0200
Subject: [PATCH 0527/1292] Split up FIFO into StaticFIFO and normale FIFO

---
 container/FIFO.h                      | 88 +++++----------------------
 container/FIFOBase.h                  | 59 ++++++++++++++++++
 container/FIFOBase.tpp                | 76 +++++++++++++++++++++++
 container/StaticFIFO.h                | 23 +++++++
 globalfunctions/timevalOperations.cpp |  7 +++
 globalfunctions/timevalOperations.h   |  1 +
 osal/linux/TcUnixUdpPollingTask.cpp   | 66 +++++++++++++++++++-
 osal/linux/TcUnixUdpPollingTask.h     | 30 +++++++--
 osal/linux/TmTcUnixUdpBridge.cpp      | 19 +++++-
 osal/linux/TmTcUnixUdpBridge.h        | 16 ++++-
 tmtcservices/CommandingServiceBase.h  |  4 +-
 tmtcservices/TmTcBridge.h             |  4 +-
 12 files changed, 309 insertions(+), 84 deletions(-)
 create mode 100644 container/FIFOBase.h
 create mode 100644 container/FIFOBase.tpp
 create mode 100644 container/StaticFIFO.h

diff --git a/container/FIFO.h b/container/FIFO.h
index f70c78b0..217ddbca 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,82 +1,26 @@
-#ifndef FIFO_H_
-#define FIFO_H_
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+#include <vector>
 
 /**
- * @brief Simple First-In-First-Out data structure
+ * @brief 	Simple First-In-First-Out data structure. The maximum size
+ * 			can be set in the constructor. THe public interface of
+ * 			FIFOBase exposes the user interface for the FIFO.
  * @tparam T Entry Type
  * @tparam capacity Maximum capacity
  */
-template<typename T, uint8_t capacity>
-class FIFO {
-private:
-	uint8_t readIndex, writeIndex, currentSize;
-	T data[capacity];
-
-	uint8_t next(uint8_t current) {
-		++current;
-		if (current == capacity) {
-			current = 0;
-		}
-		return current;
-	}
+template<typename T>
+class FIFO: public FIFOBase<T> {
 public:
-	FIFO() :
-			readIndex(0), writeIndex(0), currentSize(0) {
-	}
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity) {
+		values.reserve(maxCapacity);
+		values.resize(maxCapacity);
+	};
 
-	bool empty() {
-		return (currentSize == 0);
-	}
-
-	bool full() {
-		return (currentSize == capacity);
-	}
-
-	uint8_t size(){
-		return currentSize;
-	}
-
-	ReturnValue_t insert(T value) {
-		if (full()) {
-			return FULL;
-		} else {
-			data[writeIndex] = value;
-			writeIndex = next(writeIndex);
-			++currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t retrieve(T *value) {
-		if (empty()) {
-			return EMPTY;
-		} else {
-			*value = data[readIndex];
-			readIndex = next(readIndex);
-			--currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t peek(T * value) {
-	    if(empty()) {
-	        return EMPTY;
-	    } else {
-	       *value = data[readIndex];
-	       return HasReturnvaluesIF::RETURN_OK;
-	    }
-	}
-
-	ReturnValue_t pop() {
-		T value;
-		return this->retrieve(&value);
-	}
-
-	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);
+private:
+	std::vector<T> values;
 };
 
-#endif /* FIFO_H_ */
+#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
new file mode 100644
index 00000000..c6a74d2f
--- /dev/null
+++ b/container/FIFOBase.h
@@ -0,0 +1,59 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+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);
+
+
+	/** Default ctor, no input arguments required. */
+	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();
+
+	bool empty();
+	bool full();
+	size_t size();
+
+private:
+	T* values;
+	size_t maxCapacity;
+
+	size_t readIndex = 0;
+	size_t writeIndex = 0;
+	size_t currentSize = 0;
+
+	size_t next(size_t current);
+};
+
+#include <framework/container/FIFOBase.tpp>
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
new file mode 100644
index 00000000..011ce6de
--- /dev/null
+++ b/container/FIFOBase.tpp
@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+#define FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#error Include FIFOBase.h before FIFOBase.tpp!
+#endif
+
+template<typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+		values(values), maxCapacity(maxCapacity) {};
+
+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;
+	}
+};
+
+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;
+	}
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::peek(T* value) {
+	if(empty()) {
+		return EMPTY;
+	} else {
+		*value = values[readIndex];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::pop() {
+	T value;
+	return this->retrieve(&value);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::empty() {
+	return (currentSize == 0);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::full() {
+	return (currentSize == maxCapacity);
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::size() {
+	return currentSize;
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::next(size_t current) {
+	++current;
+	if (current == maxCapacity) {
+		current = 0;
+	}
+	return current;
+}
+
+#endif
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
new file mode 100644
index 00000000..651c4989
--- /dev/null
+++ b/container/StaticFIFO.h
@@ -0,0 +1,23 @@
+#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
+#define FRAMEWORK_CONTAINER_STATICFIFO_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time. The public interface of FIFOBase exposes
+ * 			the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class StaticFIFO: public FIFOBase<T> {
+public:
+	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
+
+private:
+	std::array<T, capacity> values;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index 253b6eb7..1da45d7b 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -90,3 +90,10 @@ double timevalOperations::toDouble(const timeval timeval) {
 	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
 	return result / 1000000.;
 }
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}
diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index a553e60a..3977d5d9 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -41,6 +41,7 @@ namespace timevalOperations {
  * @return seconds
  */
 double toDouble(const timeval timeval);
+timeval toTimeval(const double seconds);
 }
 
 #endif /* TIMEVALOPERATIONS_H_ */
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 21ad1d9a..79dbdce2 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,16 +1,80 @@
 #include <framework/osal/linux/TcUnixUdpPollingTask.h>
 
 TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
-		object_id_t tmtcUnixUdpBridge): SystemObject(objectId) {
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+
+	// Set receive timeout.
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&receptionTimeout, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
+				"timeout failed with " << strerror(errno) << std::endl;
+		return;
+	}
 }
 
 TcSocketPollingTask::~TcSocketPollingTask() {
 }
 
 ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new data permanently. The call will block until the specified
+	// length of bytes has been received or a timeout occured.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		socklen_t senderSockLen = 0;
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				receptionBuffer.data(), frameSize, receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
+		if(bytesReceived < 0) {
+			//handle error
+			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
+					"failed with " << strerror(errno) << std::endl;
+			continue;
+		}
+		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TcSocketPollingTask::initialize() {
+	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
+
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index eda7fe5d..09ee6c99 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,8 +1,11 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #include <framework/objectmanager/SystemObject.h>
+#include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/tasks/ExecutableObjectIF.h>
+
 #include <sys/socket.h>
+#include <vector>
 
 /**
  * @brief 	This class can be used to implement the polling of a Unix socket,
@@ -17,15 +20,34 @@ class TcSocketPollingTask: public SystemObject,
 		public ExecutableObjectIF {
 	friend class TmTcUnixUdpBridge;
 public:
-	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge);
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
 	virtual~ TcSocketPollingTask();
 
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
+
 private:
-	//! Sender Address is cached here.
-	const struct sockaddr senderAddress;
-};
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	int serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead();
 
 
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index ff8b6588..710761b4 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,11 +1,14 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <errno.h>
+#include <framework/ipc/MutexHelper.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
 		uint16_t clientPort):
 		TmTcBridge(objectId, ccsdsPacketDistributor) {
+	mutex = MutexFactory::instance()->createMutex();
+
 	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
 	if(serverPort != 0xFFFF) {
 		setServerPort = serverPort;
@@ -16,6 +19,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setClientPort = clientPort;
 	}
 
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
@@ -26,14 +30,16 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	}
 
 	serverAddress.sin_family = AF_INET;
+	// Accept packets from any interface.
 	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 	serverAddress.sin_port = htons(setServerPort);
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
+	serverSocketLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			sizeof(serverAddress));
+			serverSocketLen);
 	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
@@ -81,6 +87,17 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	}
 }
 
+void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, 10);
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+	}
+}
+
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index a969083d..15d256cd 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -7,16 +7,20 @@
 #include <netinet/udp.h>
 
 class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcSocketPollingTask;
 public:
 	// The ports chosen here should not be used by any other process.
 	// List of used ports on Linux: /etc/services
-	static constexpr int DEFAULT_UDP_SERVER_PORT = 7301;
-	static constexpr int DEFAULT_UDP_CLIENT_PORT = 7302;
+	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
 
 	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
+	void setTimeout(float timeoutSeconds);
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
 protected:
 	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
 			size_t * size) override;
@@ -24,8 +28,16 @@ protected:
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;
+
 	struct sockaddr_in clientAddress;
+	socklen_t clientSocketLen = 0;
+
 	struct sockaddr_in serverAddress;
+	socklen_t serverSocketLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
 
 	void handleSocketError();
 	void handleBindError();
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 700503c6..169eebe1 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -10,7 +10,7 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
+#include <framework/container/StaticFIFO.h>
 #include <framework/serialize/SerializeIF.h>
 
 class TcPacketStored;
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		StaticFIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index b50e9e1b..a24aa805 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -8,7 +8,7 @@
 #include <framework/objectmanager/SystemObject.h>
 
 #include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/container/FIFO.h>
+#include <framework/container/StaticFIFO.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public ExecutableObjectIF,
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 2158208a2fbbd98c1fa5ced154866803f80d04f1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 00:33:55 +0200
Subject: [PATCH 0528/1292] new pus parser

---
 osal/linux/TcUnixUdpPollingTask.cpp |  1 -
 osal/linux/TcUnixUdpPollingTask.h   |  2 +-
 tmtcservices/PusParser.cpp          | 10 ++++++
 tmtcservices/PusParser.h            | 51 +++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 2 deletions(-)
 create mode 100644 tmtcservices/PusParser.cpp
 create mode 100644 tmtcservices/PusParser.h

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 79dbdce2..f237a0f2 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -75,6 +75,5 @@ ReturnValue_t TcSocketPollingTask::initialize() {
 }
 
 ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 09ee6c99..a6b0e9d4 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -49,6 +49,6 @@ private:
 
 	ReturnValue_t handleSuccessfullTcRead();
 
-
+};
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
new file mode 100644
index 00000000..76934e33
--- /dev/null
+++ b/tmtcservices/PusParser.cpp
@@ -0,0 +1,10 @@
+#include <framework/tmtcservices/PusParser.h>
+
+PusParser::PusParser(uint16_t maxExpectedPusPackets,
+		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
+}
+
+ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
+		size_t frameSize) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
new file mode 100644
index 00000000..8fbf9652
--- /dev/null
+++ b/tmtcservices/PusParser.h
@@ -0,0 +1,51 @@
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include <framework/container/FIFO.h>
+
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for PUS packets.
+ * 			Can be used if PUS packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the payload length field of PUS packets to find
+ * the respective PUS packet sizes.
+ *
+ * The parser parses a buffer by taking a pointer and the maximum size to scan.
+ * If PUS packets are found, they are stored in a FIFO which stores pairs
+ * consisting of the index in the buffer and the respective packet sizes.
+ *
+ * If the parser detects split packets (which means that the size of the
+ * next packet is larger than the remaining size to scan), it can either
+ * store that split packet or throw away the packet.
+ */
+class PusParser {
+public:
+	/**
+	 * Parser constructor.
+	 * @param maxExpectedPusPackets
+	 * Maximum expected number of PUS packets. A good estimate is to divide
+	 * the frame size by the minimum size of a PUS packet (12 bytes)
+	 * @param storeSplitPackets
+	 * Specifies whether split packets are also stored inside the FIFO,
+	 * with the size being the remaining frame size.
+	 */
+	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
+
+	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+private:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+	//! A FIFO is used to store information about multiple PUS packets
+	//! inside the receive buffer. The maximum number of entries is defined
+	//! by the first constructor argument.
+	FIFO<indexSizePair> indexSizePairFIFO;
+
+	bool storeSplitPackets = false;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From bb5de8f11041014ad9f6c33c98fc6d6e0822afc3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 13:41:07 +0200
Subject: [PATCH 0529/1292] merged new changes

---
 container/FIFO.h       | 11 +++++++++--
 container/FIFOBase.h   |  8 ++++++--
 container/StaticFIFO.h | 11 +++++++++--
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 217ddbca..7251321f 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -4,10 +4,15 @@
 #include <framework/container/FIFOBase.h>
 #include <vector>
 
+namespace fsfw {
+
 /**
  * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor. THe public interface of
- * 			FIFOBase exposes the user interface for the FIFO.
+ * 			can be set in the constructor.
+ * @details
+ * The maximum capacity can be determined at run-time, so this container
+ * performs dynamic memory allocation!
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
  * @tparam T Entry Type
  * @tparam capacity Maximum capacity
  */
@@ -23,4 +28,6 @@ private:
 	std::vector<T> values;
 };
 
+}
+
 #endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index c6a74d2f..ac5c6e2c 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -4,6 +4,8 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
 
+namespace fsfw {
+
 template <typename T>
 class FIFOBase {
 public:
@@ -11,8 +13,8 @@ public:
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
 
-
-	/** Default ctor, no input arguments required. */
+	/** Default ctor, takes pointer to first entry of underlying container
+	 *  and maximum capacity */
 	FIFOBase(T* values, const size_t maxCapacity);
 
 	/**
@@ -56,4 +58,6 @@ private:
 
 #include <framework/container/FIFOBase.tpp>
 
+}
+
 #endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
index 651c4989..f3128200 100644
--- a/container/StaticFIFO.h
+++ b/container/StaticFIFO.h
@@ -3,11 +3,16 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/container/FIFOBase.h>
+#include <array>
+
+namespace fsfw {
 
 /**
  * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time. The public interface of FIFOBase exposes
- * 			the user interface for the FIFO.
+ * 			compile time
+ * @details
+ * Performs no dynamic memory allocation.
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
  * @tparam T Entry Type
  * @tparam capacity Maximum capacity
  */
@@ -20,4 +25,6 @@ private:
 	std::array<T, capacity> values;
 };
 
+}
+
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */

From b61e1df8bcd2177f06cbdb28e7c4352cee75422c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 13:43:41 +0200
Subject: [PATCH 0530/1292] fifo in namespace now

---
 tmtcservices/CommandingServiceBase.h | 2 +-
 tmtcservices/PusParser.h             | 2 +-
 tmtcservices/TmTcBridge.h            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 169eebe1..72fe13f2 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		StaticFIFO<store_address_t, 3> fifo;
+		fsfw::StaticFIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 8fbf9652..ef177079 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -42,7 +42,7 @@ private:
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
-	FIFO<indexSizePair> indexSizePairFIFO;
+	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
 };
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index a24aa805..23f7dcfa 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	fsfw::StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 78283ddbeecefb733fe68408befb3337ad869173 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 14:09:33 +0200
Subject: [PATCH 0531/1292] queue map manager: not using std::atomic anymore

---
 osal/host/QueueMapManager.cpp | 5 ++++-
 osal/host/QueueMapManager.h   | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index e7c86f30..89b9a948 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -17,6 +17,10 @@ QueueMapManager* QueueMapManager::instance() {
 
 ReturnValue_t QueueMapManager::addMessageQueue(
 		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	// Not thread-safe, but it is assumed all message queues are created
+	// at software initialization now. If this is to be made thread-safe in
+	// the future, it propably would be sufficient to lock the increment
+	// operation here
 	uint32_t currentId = queueCounter++;
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
@@ -28,7 +32,6 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	if (id != nullptr) {
 		*id = currentId;
 	}
-	mapLock = MutexFactory::instance()->createMutex();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 499b1622..a2a1b658 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -36,7 +36,7 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
-	std::atomic<uint32_t> queueCounter = 1;
+	uint32_t queueCounter = 1;
 	MutexIF* mapLock;
 	QueueMap queueMap;
 	static QueueMapManager* mqManagerInstance;

From f442a5889ec4bb213f35668a9320dd4cfedeee94 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 16:34:11 +0200
Subject: [PATCH 0532/1292] pus parser continued

---
 returnvalues/FwClassIds.h  |  1 +
 tmtcservices/PusParser.cpp | 33 +++++++++++++++++++++++++++++++++
 tmtcservices/PusParser.h   | 11 +++++++++++
 3 files changed, 45 insertions(+)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index ddee539e..abee534a 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -64,6 +64,7 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
+	PUS_PARSER, //PUSP 61
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 76934e33..5f326b44 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -1,4 +1,5 @@
 #include <framework/tmtcservices/PusParser.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 PusParser::PusParser(uint16_t maxExpectedPusPackets,
 		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
@@ -6,5 +7,37 @@ PusParser::PusParser(uint16_t maxExpectedPusPackets,
 
 ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		size_t frameSize) {
+	if(frame == nullptr) {
+		sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	// Size of a pus packet is the value in the packet length field plus 7.
+	uint16_t packetSize = (frame[4] << 8 | frame[5]) + 7;
+	if(packetSize > 0) {
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return NO_PACKET_FOUND;
+	}
+
+	if(frameSize > packetSize) {
+		return readMultiplePackets(frameSize);
+
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+//ReturnValue_t PusParser::readMultiplePackets(size_t frameSize) {
+//	size_t endOfBuffer = frameSize - 1;
+//	size_t endIndex = firstPacketSize;
+//	size_t startIndex = 0;
+//	while (endIndex < endOfBuffer) {
+//		ReturnValue_t result = readNextPacket(&startIndex, &endIndex);
+//		if(result != RETURN_OK) {
+//			return;
+//		}
+//	}
+//}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index ef177079..cdc887ed 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -23,6 +23,9 @@
  */
 class PusParser {
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+
 	/**
 	 * Parser constructor.
 	 * @param maxExpectedPusPackets
@@ -34,6 +37,12 @@ public:
 	 */
 	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
 
+	/**
+	 * Parse a given frame for PUS packets
+	 * @param frame
+	 * @param frameSize
+	 * @return -@c NO_PACKET_FOUND if no packet was found.
+	 */
 	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
 private:
 	//! The first entry is the index inside the buffer while the second index
@@ -45,6 +54,8 @@ private:
 	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
+
+	ReturnValue_t readMultiplePackets(size_t frameSize);
 };
 
 

From 8ba75fc3c2fad46fc0e37fe17a627a99cfa3f09a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 19:36:21 +0200
Subject: [PATCH 0533/1292] pus parser implemented

---
 tmtcservices/PusParser.cpp | 113 ++++++++++++++++++++++++++++++-------
 tmtcservices/PusParser.h   |  32 +++++++++--
 2 files changed, 120 insertions(+), 25 deletions(-)

diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 5f326b44..21d44efa 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -13,31 +13,106 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	// Size of a pus packet is the value in the packet length field plus 7.
-	uint16_t packetSize = (frame[4] << 8 | frame[5]) + 7;
-	if(packetSize > 0) {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		return HasReturnvaluesIF::RETURN_OK;
+	if(indexSizePairFIFO.full()) {
+		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	else {
+
+
+	size_t lengthField = frame[4] << 8 | frame[5];
+
+	if(lengthField == 0) {
 		return NO_PACKET_FOUND;
 	}
 
-	if(frameSize > packetSize) {
-		return readMultiplePackets(frameSize);
+	size_t packetSize = lengthField + 7;
+	if(lengthField > 0) {
+		// Size of a pus packet is the value in the packet length field plus 7.
+		if(packetSize > frameSize)
+		{
+			if(storeSplitPackets)
+			{
+				indexSizePairFIFO.insert(indexSizePair(0, frameSize));
+			}
+			else
+			{
+				sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+						"larger than remaining frame," << std::endl;
+				sif::debug << "Throwing away packet. Detected packet size: "
+						<< packetSize << std::endl;
+			}
+			return SPLIT_PACKET;
+		}
+		else
+		{
+			indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+			if(packetSize == frameSize) {
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+	}
 
+	// packet size is smaller than frame size, parse for more packets.
+	return readMultiplePackets(frame, frameSize, packetSize);
+}
+
+ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
+		size_t frameSize, size_t startIndex) {
+	while (startIndex < frameSize) {
+		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-//ReturnValue_t PusParser::readMultiplePackets(size_t frameSize) {
-//	size_t endOfBuffer = frameSize - 1;
-//	size_t endIndex = firstPacketSize;
-//	size_t startIndex = 0;
-//	while (endIndex < endOfBuffer) {
-//		ReturnValue_t result = readNextPacket(&startIndex, &endIndex);
-//		if(result != RETURN_OK) {
-//			return;
-//		}
-//	}
-//}
+fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
+	return &indexSizePairFIFO;
+}
+
+PusParser::indexSizePair PusParser::getNextFifoPair() {
+	indexSizePair nextIndexSizePair;
+	indexSizePairFIFO.retrieve(&nextIndexSizePair);
+	return nextIndexSizePair;
+}
+
+ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
+		size_t frameSize, size_t& currentIndex) {
+	// sif::debug << startIndex << std::endl;
+	uint16_t lengthField = frame[currentIndex + 4] << 8 |
+			frame[currentIndex + 5];
+	if(lengthField == 0) {
+		// It is assumed that no packet follows.
+		currentIndex = frameSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t nextPacketSize = lengthField + 7;
+	size_t remainingSize = frameSize - currentIndex;
+	if(nextPacketSize > remainingSize)
+	{
+		if(storeSplitPackets)
+		{
+			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
+		}
+		else
+		{
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< nextPacketSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+
+	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
+			nextPacketSize));
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		// FIFO full.
+		sif::debug << "PusParser: Issue inserting into start index size "
+		        "FIFO, it is full!" << std::endl;
+	}
+	currentIndex += nextPacketSize;
+
+	return result;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index cdc887ed..82aff57e 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -23,9 +23,13 @@
  */
 class PusParser {
 public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
 	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
 	/**
 	 * Parser constructor.
 	 * @param maxExpectedPusPackets
@@ -44,10 +48,24 @@ public:
 	 * @return -@c NO_PACKET_FOUND if no packet was found.
 	 */
 	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+
+	/**
+	 * Accessor function to get a reference to the internal FIFO which
+	 * stores pairs of indexi and packet sizes. This FIFO is filled
+	 * by the parsePusPackets() function.
+	 * @return
+	 */
+	fsfw::FIFO<indexSizePair>* fifo();
+
+	/**
+	 * Retrieve the next index and packet size pair from the FIFO.
+	 * This also removed it from the FIFO. Please note that if the FIFO
+	 * is empty, an empty pair will be returned.
+	 * @return
+	 */
+	indexSizePair getNextFifoPair();
 private:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
+
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
@@ -55,8 +73,10 @@ private:
 
 	bool storeSplitPackets = false;
 
-	ReturnValue_t readMultiplePackets(size_t frameSize);
+	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
+			size_t startIndex);
+	ReturnValue_t readNextPacket(const uint8_t *frame,
+			size_t frameSize, size_t& startIndex);
 };
 
-
 #endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From fd1e612ea5d931d20177405a827c34bf52ee7c54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 20:17:05 +0200
Subject: [PATCH 0534/1292] pus parser fixes

---
 tmtcservices/PusParser.cpp | 40 +++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 21d44efa..b43b0519 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -18,7 +18,6 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-
 	size_t lengthField = frame[4] << 8 | frame[5];
 
 	if(lengthField == 0) {
@@ -26,32 +25,32 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	}
 
 	size_t packetSize = lengthField + 7;
-	if(lengthField > 0) {
-		// Size of a pus packet is the value in the packet length field plus 7.
-		if(packetSize > frameSize)
+	// Size of a pus packet is the value in the packet length field plus 7.
+	if(packetSize > frameSize)
+	{
+		if(storeSplitPackets)
 		{
-			if(storeSplitPackets)
-			{
-				indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-			}
-			else
-			{
-				sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-						"larger than remaining frame," << std::endl;
-				sif::debug << "Throwing away packet. Detected packet size: "
-						<< packetSize << std::endl;
-			}
-			return SPLIT_PACKET;
+			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
 		}
 		else
 		{
-			indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-			if(packetSize == frameSize) {
-				return HasReturnvaluesIF::RETURN_OK;
-			}
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< packetSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+	else
+	{
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		if(packetSize == frameSize) {
+			sif::info << "test2" << std::endl;
+			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
 
+
 	// packet size is smaller than frame size, parse for more packets.
 	return readMultiplePackets(frame, frameSize, packetSize);
 }
@@ -59,6 +58,7 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 		size_t frameSize, size_t startIndex) {
 	while (startIndex < frameSize) {
+		sif::info << "test" << std::endl;
 		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From cb691db807d562c8f84178d48650464c4cb58ecc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 23:07:38 +0200
Subject: [PATCH 0535/1292] fifo tweaks, pus parser fixes

---
 container/FIFO.h           | 6 ++----
 container/FIFOBase.h       | 4 +++-
 container/FIFOBase.tpp     | 5 +++++
 tmtcservices/PusParser.cpp | 3 ---
 4 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 7251321f..19daaf1b 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -19,10 +19,8 @@ namespace fsfw {
 template<typename T>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity) {
-		values.reserve(maxCapacity);
-		values.resize(maxCapacity);
-	};
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
+			values(maxCapacity) {};
 
 private:
 	std::vector<T> values;
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index ac5c6e2c..6ed7d924 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -45,9 +45,11 @@ public:
 	bool full();
 	size_t size();
 
+	size_t getMaxCapacity() const;
+
 private:
 	T* values;
-	size_t maxCapacity;
+	size_t maxCapacity = 0;
 
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 011ce6de..48a060ff 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -73,4 +73,9 @@ inline size_t FIFOBase<T>::next(size_t current) {
 	return current;
 }
 
+template<typename T>
+inline size_t FIFOBase<T>::getMaxCapacity() const {
+	return maxCapacity;
+}
+
 #endif
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index b43b0519..175c2893 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -45,12 +45,10 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	{
 		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
 		if(packetSize == frameSize) {
-			sif::info << "test2" << std::endl;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
 
-
 	// packet size is smaller than frame size, parse for more packets.
 	return readMultiplePackets(frame, frameSize, packetSize);
 }
@@ -58,7 +56,6 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 		size_t frameSize, size_t startIndex) {
 	while (startIndex < frameSize) {
-		sif::info << "test" << std::endl;
 		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From 4f1f610ae03bd4f0fecc9e19ecafa5803ee8a231 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 16:36:41 +0200
Subject: [PATCH 0536/1292] doc and improvements for DLE encoder

---
 globalfunctions/DleEncoder.cpp | 39 +++++++++++----------
 globalfunctions/DleEncoder.h   | 64 +++++++++++++++++++++++++++++-----
 returnvalues/FwClassIds.h      |  3 +-
 3 files changed, 78 insertions(+), 28 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index a68f1524..ee934785 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,18 +1,16 @@
 #include <framework/globalfunctions/DleEncoder.h>
 
-DleEncoder::DleEncoder() {
-}
+DleEncoder::DleEncoder() {}
 
-DleEncoder::~DleEncoder() {
-}
+DleEncoder::~DleEncoder() {}
 
 ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
-		uint32_t maxDestStreamlen, uint32_t *decodedLen) {
-	uint32_t encodedIndex = 0, decodedIndex = 0;
+		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+		size_t maxDestStreamlen, size_t *decodedLen) {
+	size_t encodedIndex = 0, decodedIndex = 0;
 	uint8_t nextByte;
 	if (*sourceStream != STX) {
-		return RETURN_FAILED;
+		return DECODING_ERROR;
 	}
 	++encodedIndex;
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
@@ -20,14 +18,18 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 			&& (sourceStream[encodedIndex] != STX)) {
 		if (sourceStream[encodedIndex] == DLE) {
 			nextByte = sourceStream[encodedIndex + 1];
-			if (nextByte == 0x10) {
+			// The next byte is a DLE character that was escaped by another
+			// DLE character, so we can write it to the destination stream.
+			if (nextByte == DLE) {
 				destStream[decodedIndex] = nextByte;
 			} else {
+			    // The next byte is a STX, DTX or 0x0D character which
+			    // was escaped by a DLE character
 				if ((nextByte == 0x42) || (nextByte == 0x43)
 						|| (nextByte == 0x4D)) {
 					destStream[decodedIndex] = nextByte - 0x40;
 				} else {
-					return RETURN_FAILED;
+				    return DECODING_ERROR;
 				}
 			}
 			++encodedIndex;
@@ -38,7 +40,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		++decodedIndex;
 	}
 	if (sourceStream[encodedIndex] != ETX) {
-		return RETURN_FAILED;
+		return DECODING_ERROR;
 	} else {
 		*readLen = ++encodedIndex;
 		*decodedLen = decodedIndex;
@@ -47,12 +49,12 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 }
 
 ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		uint32_t sourceLen, uint8_t* destStream, uint32_t maxDestLen,
-		uint32_t* encodedLen, bool addStxEtx) {
+		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+		size_t* encodedLen, bool addStxEtx) {
 	if (maxDestLen < 2) {
-		return RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
-	uint32_t encodedIndex = 0, sourceIndex = 0;
+	size_t encodedIndex = 0, sourceIndex = 0;
 	uint8_t nextByte;
 	if (addStxEtx) {
 		destStream[0] = STX;
@@ -62,15 +64,16 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		nextByte = sourceStream[sourceIndex];
 		if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
 			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
+				return STREAM_TOO_SHORT;
 			} else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
+				// Escaped byte will be actual byte + 0x40.
 				destStream[encodedIndex] = nextByte + 0x40;
 			}
 		} else if (nextByte == DLE) {
 			if (encodedIndex + 1 >= maxDestLen) {
-				return RETURN_FAILED;
+			    return STREAM_TOO_SHORT;
 			} else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
@@ -90,6 +93,6 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		*encodedLen = encodedIndex;
 		return RETURN_OK;
 	} else {
-		return RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
 }
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index fc155600..0f4a4c8f 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,25 +1,71 @@
-#ifndef DLEENCODER_H_
-#define DLEENCODER_H_
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
 
+/**
+ * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
+ *          decode arbitrary data with ASCII control characters
+ * @details
+ * List of control codes:
+ * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * This encoder can be used to achieve a basic transport layer when using
+ * char based transmission systems.
+ * The passed source strean is converted into a encoded stream by adding
+ * a STX marker at the startr of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX and DLE occurences in the source stream are escaped
+ * by a DLE character.
+ */
 class DleEncoder: public HasReturnvaluesIF {
 private:
 	DleEncoder();
 	virtual ~DleEncoder();
 
 public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
+	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
+	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
+
+	//! Start Of Text character. First character is encoded stream
 	static const uint8_t STX = 0x02;
+	//! End Of Text character. Last character in encoded stream
 	static const uint8_t ETX = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! in the source stream.
 	static const uint8_t DLE = 0x10;
 
-	static ReturnValue_t decode(const uint8_t *sourceStream,
-			uint32_t sourceStreamLen, uint32_t *readLen, uint8_t *destStream,
-			uint32_t maxDestStreamlen, uint32_t *decodedLen);
+    /**
+     * Encodes the give data stream by preceding it with the STX marker
+     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * the stream are escaped by DLE characters.
+     * @param sourceStream
+     * @param sourceLen
+     * @param destStream
+     * @param maxDestLen
+     * @param encodedLen
+     * @param addStxEtx
+     * Adding STX and ETX can be omitted, if they are added manually.
+     * @return
+     */
+    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
 
-	static ReturnValue_t encode(const uint8_t *sourceStream, uint32_t sourceLen,
-			uint8_t *destStream, uint32_t maxDestLen, uint32_t *encodedLen,
-			bool addStxEtx = true);
+    /**
+     * Converts an encoded stream back
+     * @param sourceStream
+     * @param sourceStreamLen
+     * @param readLen
+     * @param destStream
+     * @param maxDestStreamlen
+     * @param decodedLen
+     * @return
+     */
+	static ReturnValue_t decode(const uint8_t *sourceStream,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
 };
 
-#endif /* DLEENCODER_H_ */
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index abee534a..7e4d8953 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -64,7 +64,8 @@ enum {
 	LOCAL_POOL_OWNER_IF, //LPIF 58
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
-	PUS_PARSER, //PUSP 61
+	DLE_ENCODER, //DLEE 61
+	PUS_PARSER, //PUSP 62
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 359163886ba2d926cefe8f57b6691818a1e70b8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:06:30 +0200
Subject: [PATCH 0537/1292] pus srv5 and 1 moved to framework

---
 framework.mk                            |   2 +-
 pus/Service1TelecommandVerification.cpp | 100 ++++++++++++++
 pus/Service1TelecommandVerification.h   |  94 ++++++++++++++
 pus/Service5EventReporting.cpp          |  92 +++++++++++++
 pus/Service5EventReporting.h            |  86 ++++++++++++
 pus/servicepackets/Service1Packets.h    | 166 ++++++++++++++++++++++++
 pus/servicepackets/Service5Packets.h    |  83 ++++++++++++
 7 files changed, 622 insertions(+), 1 deletion(-)
 create mode 100644 pus/Service1TelecommandVerification.cpp
 create mode 100644 pus/Service1TelecommandVerification.h
 create mode 100644 pus/Service5EventReporting.cpp
 create mode 100644 pus/Service5EventReporting.h
 create mode 100644 pus/servicepackets/Service1Packets.h
 create mode 100644 pus/servicepackets/Service5Packets.h

diff --git a/framework.mk b/framework.mk
index c8822981..bfbd4b1f 100644
--- a/framework.mk
+++ b/framework.mk
@@ -58,4 +58,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)
\ No newline at end of file
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
\ No newline at end of file
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
new file mode 100644
index 00000000..4ce2ce54
--- /dev/null
+++ b/pus/Service1TelecommandVerification.cpp
@@ -0,0 +1,100 @@
+#include <framework/pus/Service1TelecommandVerification.h>
+#include <framework/pus/servicepackets/Service1Packets.h>
+
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcservices/AcceptsTelemetryIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::initialize: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
new file mode 100644
index 00000000..1d4b6719
--- /dev/null
+++ b/pus/Service1TelecommandVerification.h
@@ -0,0 +1,94 @@
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/ipc/MessageQueueIF.h>
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
new file mode 100644
index 00000000..fe55059c
--- /dev/null
+++ b/pus/Service5EventReporting.cpp
@@ -0,0 +1,92 @@
+#include <framework/pus/Service5EventReporting.h>
+#include <framework/pus/servicepackets/Service5Packets.h>
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/events/EventManagerIF.h>
+#include <framework/ipc/QueueFactory.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice)
+	{
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
new file mode 100644
index 00000000..79b7c5e7
--- /dev/null
+++ b/pus/Service5EventReporting.h
@@ -0,0 +1,86 @@
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include <framework/tmtcservices/PusServiceBase.h>
+#include <framework/events/EventMessage.h>
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
new file mode 100644
index 00000000..b01942c6
--- /dev/null
+++ b/pus/servicepackets/Service1Packets.h
@@ -0,0 +1,166 @@
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
new file mode 100644
index 00000000..f8f730c3
--- /dev/null
+++ b/pus/servicepackets/Service5Packets.h
@@ -0,0 +1,83 @@
+/**
+ * \file Service5Packets.h
+ *
+ * Structure of Event Report.
+ * It consists of:
+ * 		1. Report ID(RID). This is the Event ID in the FSFW
+ *		2. Object ID of the reporter (e.g. subsystem)
+ *		2. Parameter 1
+ *		3. Parameter 2
+ *
+ * Created on: 21.05.2019
+ * Author: R. Mueller, J. Meier
+ */
+
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
+
+/**
+ * \brief Subservice 1, 2, 3, 4
+ * \ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */

From 7698f3f13e4ff5886c6c56145e56111a49a6ff4f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:18:33 +0200
Subject: [PATCH 0538/1292] moved srv2 to framework

---
 pus/Service2DeviceAccess.cpp         | 178 +++++++++++++++++++++++++++
 pus/Service2DeviceAccess.h           |  96 +++++++++++++++
 pus/servicepackets/Service2Packets.h |  76 ++++++++++++
 pus/servicepackets/Service5Packets.h |  25 ++--
 4 files changed, 359 insertions(+), 16 deletions(-)
 create mode 100644 pus/Service2DeviceAccess.cpp
 create mode 100644 pus/Service2DeviceAccess.h
 create mode 100644 pus/servicepackets/Service2Packets.h

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
new file mode 100644
index 00000000..5c6ad506
--- /dev/null
+++ b/pus/Service2DeviceAccess.cpp
@@ -0,0 +1,178 @@
+#include <framework/pus/Service2DeviceAccess.h>
+#include <framework/pus/servicepackets/Service2Packets.h>
+
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/devicehandlers/DeviceHandlerMessage.h>
+#include <framework/serialize/EndianConverter.h>
+#include <framework/action/ActionMessage.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId, object_id_t tcSource,
+        object_id_t tmDestination):
+        CommandingServiceBase(objectId, apid, serviceId,
+	        NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS,
+	        tcSource, tmDestination) {}
+
+Service2DeviceAccess::~Service2DeviceAccess() {}
+
+ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING:
+	case Subservice::TOGGLE_WIRETAPPING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+
+}
+
+ReturnValue_t Service2DeviceAccess::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData,
+	        &tcDataLen, SerializeIF::Endianness::BIG) != RETURN_OK) {
+		sif::error << "Service 2: Target ID not found. ID: " <<
+				std::hex << objectIdToSet ;
+		return CommandingServiceBase::INVALID_TC;
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
+	DeviceHandlerIF* possibleTarget =
+			objectManager->get<DeviceHandlerIF>(*objectId);
+	if(possibleTarget == nullptr) {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		uint32_t* state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING: {
+		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	break;
+	case Subservice::TOGGLE_WIRETAPPING: {
+		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::prepareRawCommand(
+        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
+	RawCommand RawCommand(tcData,tcDataLen);
+	// store command into the Inter Process Communication Store
+	store_address_t storeAddress;
+	ReturnValue_t result = IPCStore->addData(&storeAddress,
+	        RawCommand.getCommand(), RawCommand.getCommandSize());
+	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
+	        storeAddress);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
+		CommandMessage *messageToSet, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	WiretappingToggle command;
+	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
+			command.getWiretappingMode());
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t* state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool* isStep) {
+	switch(reply->getCommand()) {
+	case CommandMessage::REPLY_COMMAND_OK:
+		return HasReturnvaluesIF::RETURN_OK;
+	case CommandMessage::REPLY_REJECTED:
+		return reply->getReplyRejectedReason();
+	default:
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+}
+
+// All device handlers set service 2 as default raw receiver for wiretapping
+// so we have to handle those unrequested messages.
+void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
+	switch(reply->getCommand()) {
+	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+		break;
+	case DeviceHandlerMessage::REPLY_RAW_REPLY:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::RAW_REPLY));
+		break;
+	default:
+		sif::error << "Unknown message in Service2DeviceAccess::"
+				"handleUnrequestedReply with command ID " <<
+				reply->getCommand() << std::endl;
+		break;
+	}
+	//Must be reached by all cases to clear message
+	reply->clear();
+}
+
+void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
+		uint8_t subservice) {
+	// Raw Wiretapping
+	// Get Address of Data from Message
+	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = IPCStore->getData(storeAddress,&data,&size);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
+		        "handleUnrequestedReply with failure ID "<< result
+		        << std::endl;
+		return;
+	}
+
+	// Init our dummy packet and correct endianness of object ID before
+	// sending it back.
+	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
+	        data);
+	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
+	sendTmPacket(subservice,TmPacket.data,size,reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId),sizeof(TmPacket.objectId));
+}
+
+MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
+	return commandQueue->getId();
+}
+
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
new file mode 100644
index 00000000..ecab6101
--- /dev/null
+++ b/pus/Service2DeviceAccess.h
@@ -0,0 +1,96 @@
+#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief   Raw Commanding and Wiretapping of devices.
+ * @details
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This service provides the capability to communicate with devices in their
+ * native protocols with raw commands through the DeviceHandlerIF.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base
+ * template class. There is constant interaction between this Service Base und
+ * a Subclass like this service
+ * There are 4 adaption points for component implementation through the
+ * Commanding Service Base.
+ *
+ * This service employs custom subservices exclusively.  This includes a
+ * wiretapping subservice to monitor all traffic between target devices and
+ * this service.
+ *
+ *   - TC[2,128]: Raw Commanding
+ *   - TC[2,129]: Toggle Wiretapping
+ *   - TM[2,130]: Wiretapping Packet TM
+ *   - TM[2,131]: Wiretapping Packet TC
+ * @ingroup pus_services
+ */
+class Service2DeviceAccess : public CommandingServiceBase,
+		public AcceptsDeviceResponsesIF
+{
+public:
+	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, object_id_t tcSource,
+	        object_id_t tmDestination);
+	virtual ~Service2DeviceAccess();
+
+	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
+	        object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+	/**
+	 * @brief 	Generates TM packets containing either the TC wiretapping
+	 * 			packets or the TM wiretapping packets.
+	 * Note that for service 2, all telemetry will be treated as an
+	 * unrequested reply regardless of wiretapping mode.
+	 * @param reply
+	 */
+	void handleUnrequestedReply(CommandMessage* reply) override;
+
+	MessageQueueId_t getDeviceQueue() override;
+private:
+	/**
+	 * Generates TM packets for Wiretapping Service
+	 * @param reply
+	 * @param subservice
+	 */
+	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
+
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+
+	enum class Subservice {
+		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
+		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	};
+};
+
+
+#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
new file mode 100644
index 00000000..f292611e
--- /dev/null
+++ b/pus/servicepackets/Service2Packets.h
@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	RawCommand(const uint8_t* buffer, size_t size) {
+		// Deserialize Adapter to get correct endianness
+		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
+		        SerializeIF::Endianness::BIG);
+		commandBuffer = buffer;
+		// size is decremented by AutoSerializeAdapter,
+		// remaining size is data size
+		dataSize = size;
+	}
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getCommand() {
+		return commandBuffer;
+	}
+
+	size_t getCommandSize() const {
+		return dataSize;
+	}
+private:
+	object_id_t objectId = 0;
+	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
+	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
+};
+
+
+/**
+ * @brief Subservice 129: Command packet to set wiretapping mode
+ * @ingroup spacepackets
+ */
+class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
+public:
+	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
+	WiretappingToggle(){
+		setStart(&objectId);
+		objectId.setNext(&wiretappingMode);
+	}
+
+	uint8_t getWiretappingMode() const {
+		return wiretappingMode.entry;
+	}
+private:
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
+};
+
+
+/**
+ * @brief Subservices 130 and 131: TM packets
+ * @ingroup spacepackets
+ */
+class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
+public:
+	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
+	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
+	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
+	    objectId(objectId), data(buffer) {
+	}
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index f8f730c3..14219c93 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,17 +1,3 @@
-/**
- * \file Service5Packets.h
- *
- * Structure of Event Report.
- * It consists of:
- * 		1. Report ID(RID). This is the Event ID in the FSFW
- *		2. Object ID of the reporter (e.g. subsystem)
- *		2. Parameter 1
- *		3. Parameter 2
- *
- * Created on: 21.05.2019
- * Author: R. Mueller, J. Meier
- */
-
 #ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 #define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 
@@ -20,8 +6,15 @@
 
 
 /**
- * \brief Subservice 1, 2, 3, 4
- * \ingroup spacepackets
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
  */
 class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
 public:

From 684b56ac883b0ee0528edc55b492977518611430 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:21:47 +0200
Subject: [PATCH 0539/1292] srv2 tweak: CSB params now configurable

---
 pus/Service2DeviceAccess.cpp |  5 +++--
 pus/Service2DeviceAccess.h   | 15 +++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 5c6ad506..d1f8faf3 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -12,9 +12,10 @@
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         uint16_t apid, uint8_t serviceId, object_id_t tcSource,
-        object_id_t tmDestination):
+        object_id_t tmDestination, uint8_t numberOfParallelCommands,
+        uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	        NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS,
+	        numberOfParallelCommands, commandTimeoutSeconds,
 	        tcSource, tmDestination) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index ecab6101..20fc30b9 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -14,12 +14,12 @@
  * This service provides the capability to communicate with devices in their
  * native protocols with raw commands through the DeviceHandlerIF.
  *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base
- * template class. There is constant interaction between this Service Base und
- * a Subclass like this service
+ * This is a gateway service. It relays device commands to the software bus.
+ * This service is very closely tied to the CommandingServiceBase
+ * template class.
+ *
  * There are 4 adaption points for component implementation through the
- * Commanding Service Base.
+ * CommandingServiceBase.
  *
  * This service employs custom subservices exclusively.  This includes a
  * wiretapping subservice to monitor all traffic between target devices and
@@ -37,11 +37,10 @@ class Service2DeviceAccess : public CommandingServiceBase,
 public:
 	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
 	        uint8_t serviceId, object_id_t tcSource,
-	        object_id_t tmDestination);
+	        object_id_t tmDestination, uint8_t numberOfParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
 	virtual ~Service2DeviceAccess();
 
-	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 protected:
 	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
 	ReturnValue_t isValidSubservice(uint8_t subservice) override;

From 06d389ed1e6157f1fe736c5dacf121eec247ea14 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:25:52 +0200
Subject: [PATCH 0540/1292] increased srv2 readability

---
 pus/Service2DeviceAccess.cpp | 24 ++++++------------------
 pus/Service2DeviceAccess.h   |  2 --
 2 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index d1f8faf3..ee48b46d 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -34,29 +34,17 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		MessageQueueId_t* id, object_id_t* objectId) {
-	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData,
+                &tcDataLen, SerializeIF::Endianness::BIG);
 
-	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
 	return result;
 
 }
 
-ReturnValue_t Service2DeviceAccess::checkAndAcquireTargetID(
-		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
-	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData,
-	        &tcDataLen, SerializeIF::Endianness::BIG) != RETURN_OK) {
-		sif::error << "Service 2: Target ID not found. ID: " <<
-				std::hex << objectIdToSet ;
-		return CommandingServiceBase::INVALID_TC;
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
 	DeviceHandlerIF* possibleTarget =
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 20fc30b9..4dab0fa0 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -73,8 +73,6 @@ private:
 	 */
 	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
 
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 

From dd48f7ccadc824b275ea3bf2af0da1c9820ad61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:28:00 +0200
Subject: [PATCH 0541/1292] some form improvements

---
 pus/Service2DeviceAccess.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index ee48b46d..391c1116 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -144,7 +144,7 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-	ReturnValue_t result = IPCStore->getData(storeAddress,&data,&size);
+	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
@@ -157,8 +157,8 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
 	        data);
 	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-	sendTmPacket(subservice,TmPacket.data,size,reinterpret_cast<uint8_t*>(
-			&TmPacket.objectId),sizeof(TmPacket.objectId));
+	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId), sizeof(TmPacket.objectId));
 }
 
 MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {

From 399fc0e287048b1fb8e1343185d637c78a791a80 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 7 Jul 2020 17:42:37 +0200
Subject: [PATCH 0542/1292] fifo replacements

---
 container/DynamicFIFO.h              | 27 +++++++++++++++++++++++++
 container/FIFO.h                     | 23 +++++++++------------
 container/FIFOBase.h                 |  4 ----
 container/SimpleRingBuffer.cpp       |  6 +++---
 container/SimpleRingBuffer.h         |  2 +-
 container/StaticFIFO.h               | 30 ----------------------------
 tmtcservices/CommandingServiceBase.h |  4 ++--
 tmtcservices/PusParser.cpp           |  2 +-
 tmtcservices/PusParser.h             |  7 +++----
 tmtcservices/TmTcBridge.h            |  4 ++--
 10 files changed, 48 insertions(+), 61 deletions(-)
 create mode 100644 container/DynamicFIFO.h
 delete mode 100644 container/StaticFIFO.h

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
new file mode 100644
index 00000000..3a5242c7
--- /dev/null
+++ b/container/DynamicFIFO.h
@@ -0,0 +1,27 @@
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include <framework/container/FIFOBase.h>
+#include <vector>
+
+/**
+ * @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!
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T>
+class DynamicFIFO: public FIFOBase<T> {
+public:
+	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
+			values(maxCapacity) {};
+
+private:
+	std::vector<T> values;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 19daaf1b..ecb218fd 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,31 +1,26 @@
 #ifndef FRAMEWORK_CONTAINER_FIFO_H_
 #define FRAMEWORK_CONTAINER_FIFO_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/container/FIFOBase.h>
-#include <vector>
-
-namespace fsfw {
+#include <array>
 
 /**
- * @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 with size fixed at
+ * 			compile time
  * @details
- * The maximum capacity can be determined at run-time, so this container
- * performs dynamic memory allocation!
+ * Performs no dynamic memory allocation.
  * The public interface of FIFOBase exposes the user interface for the FIFO.
  * @tparam T Entry Type
  * @tparam capacity Maximum capacity
  */
-template<typename T>
+template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+	FIFO(): FIFOBase<T>(values.data(), capacity) {};
 
 private:
-	std::vector<T> values;
+	std::array<T, capacity> values;
 };
 
-}
-
-#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 6ed7d924..8bdb333f 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -4,8 +4,6 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
 
-namespace fsfw {
-
 template <typename T>
 class FIFOBase {
 public:
@@ -60,6 +58,4 @@ private:
 
 #include <framework/container/FIFOBase.tpp>
 
-}
-
 #endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 4e50109b..731c9dc9 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -17,7 +17,7 @@ SimpleRingBuffer::~SimpleRingBuffer() {
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 		uint32_t amount) {
-	if (availableWriteSpace() >= amount || overwriteOld) {
+	if (availableWriteSpace() >= amount or overwriteOld) {
 		uint32_t amountTillWrap = writeTillWrap();
 		if (amountTillWrap >= amount) {
 			memcpy(&buffer[write], data, amount);
@@ -43,7 +43,7 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != NULL) {
+	if (trueAmount != nullptr) {
 		*trueAmount = amount;
 	}
 	if (amountTillWrap >= amount) {
@@ -65,7 +65,7 @@ ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
-	if (trueAmount != NULL) {
+	if (trueAmount != nullptr) {
 		*trueAmount = amount;
 	}
 	incrementRead(amount, READ_PTR);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index b5bc2c1c..30dd184c 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
 
 #include <framework/container/RingBufferBase.h>
-#include <stddef.h>
+#include <cstddef>
 
 /**
  * @brief 	Circular buffer implementation, useful for buffering
diff --git a/container/StaticFIFO.h b/container/StaticFIFO.h
deleted file mode 100644
index f3128200..00000000
--- a/container/StaticFIFO.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
-#define FRAMEWORK_CONTAINER_STATICFIFO_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/FIFOBase.h>
-#include <array>
-
-namespace fsfw {
-
-/**
- * @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.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class StaticFIFO: public FIFOBase<T> {
-public:
-	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
-
-private:
-	std::array<T, capacity> values;
-};
-
-}
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 72fe13f2..700503c6 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -10,7 +10,7 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/container/FixedMap.h>
-#include <framework/container/StaticFIFO.h>
+#include <framework/container/FIFO.h>
 #include <framework/serialize/SerializeIF.h>
 
 class TcPacketStored;
@@ -199,7 +199,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		fsfw::StaticFIFO<store_address_t, 3> fifo;
+		FIFO<store_address_t, 3> fifo;
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 175c2893..4198e36e 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -64,7 +64,7 @@ ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
+DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
 	return &indexSizePairFIFO;
 }
 
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 82aff57e..88570bb2 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -1,8 +1,7 @@
 #ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
 #define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
 
-#include <framework/container/FIFO.h>
-
+#include <framework/container/DynamicFIFO.h>
 #include <utility>
 #include <cstdint>
 
@@ -55,7 +54,7 @@ public:
 	 * by the parsePusPackets() function.
 	 * @return
 	 */
-	fsfw::FIFO<indexSizePair>* fifo();
+	DynamicFIFO<indexSizePair>* fifo();
 
 	/**
 	 * Retrieve the next index and packet size pair from the FIFO.
@@ -69,7 +68,7 @@ private:
 	//! A FIFO is used to store information about multiple PUS packets
 	//! inside the receive buffer. The maximum number of entries is defined
 	//! by the first constructor argument.
-	fsfw::FIFO<indexSizePair> indexSizePairFIFO;
+	DynamicFIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 23f7dcfa..5b933c79 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include <framework/container/FIFO.h>
 #include <framework/tmtcservices/AcceptsTelemetryIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/ipc/MessageQueueIF.h>
@@ -8,7 +9,6 @@
 #include <framework/objectmanager/SystemObject.h>
 
 #include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/container/StaticFIFO.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public ExecutableObjectIF,
@@ -143,7 +143,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	fsfw::StaticFIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 2efcda735f84166665c2c1b42dc604048a7bbb34 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 02:20:38 +0200
Subject: [PATCH 0543/1292] message arriving.

big clean up in tcdistribution folder
---
 osal/linux/TcUnixUdpPollingTask.cpp |  73 +++++++++++-----
 osal/linux/TcUnixUdpPollingTask.h   |  13 ++-
 osal/linux/TmTcUnixUdpBridge.cpp    |  15 ++--
 osal/linux/TmTcUnixUdpBridge.h      |   2 +-
 tcdistribution/CCSDSDistributor.cpp |  39 +++++----
 tcdistribution/CCSDSDistributor.h   |  87 ++++++++++---------
 tcdistribution/PUSDistributor.cpp   |   4 +-
 tcdistribution/PUSDistributor.h     |  52 +++++++-----
 tcdistribution/TcDistributor.cpp    |   5 +-
 tcdistribution/TcDistributor.h      | 124 ++++++++++++++--------------
 tmtcservices/PusServiceBase.cpp     |  11 ++-
 tmtcservices/TmTcBridge.h           |   2 +-
 12 files changed, 253 insertions(+), 174 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index f237a0f2..83f7a3da 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,7 @@
 #include <framework/osal/linux/TcUnixUdpPollingTask.h>
+#include <framework/globalfunctions/arrayprinter.h>
 
-TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
+TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
 		tmtcBridgeId(tmtcUnixUdpBridge) {
@@ -23,23 +24,13 @@ TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
 	else {
 		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
 	}
-
-	// Set receive timeout.
-	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-			&receptionTimeout, sizeof(receptionTimeout));
-	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
-				"timeout failed with " << strerror(errno) << std::endl;
-		return;
-	}
 }
 
-TcSocketPollingTask::~TcSocketPollingTask() {
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {
 }
 
-ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
-	// Poll for new data permanently. The call will block until the specified
-	// length of bytes has been received or a timeout occured.
+ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
 	while(1) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
@@ -48,21 +39,34 @@ ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
 				receptionBuffer.data(), frameSize, receptionFlags,
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
-			//handle error
+			// handle error
 			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
 					"failed with " << strerror(errno) << std::endl;
+			if(errno == EAGAIN or errno == EWOULDBLOCK) {
+				sif::info << "timeout" << std::endl;
+			}
 			continue;
 		}
 		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 				<< " bytes received" << std::endl;
 
-		ReturnValue_t result = handleSuccessfullTcRead();
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcSocketPollingTask::initialize() {
+ReturnValue_t TcUnixUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
 	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
@@ -70,10 +74,41 @@ ReturnValue_t TcSocketPollingTask::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
+	targetTcDestination = tmtcBridge->getReportReceptionQueue();
+
 	serverUdpSocket = tmtcBridge->serverSocket;
+
+	// Set receive timeout.
+//	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+//			&receptionTimeout, sizeof(receptionTimeout));
+//	if(result == -1) {
+//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+//				"receive timeout failed with " << strerror(errno) << std::endl;
+//		return ObjectManagerIF::CHILD_INIT_FAILED;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
-	return HasReturnvaluesIF::RETURN_OK;
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId = 0;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::debug << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
 }
+
+
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index a6b0e9d4..3503d505 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
 #define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/tasks/ExecutableObjectIF.h>
@@ -16,7 +17,7 @@
  * This class caches the IP address of the sender. It is assumed there
  * is only one sender for now.
  */
-class TcSocketPollingTask: public SystemObject,
+class TcUnixUdpPollingTask: public SystemObject,
 		public ExecutableObjectIF {
 	friend class TmTcUnixUdpBridge;
 public:
@@ -24,17 +25,21 @@ public:
 	//! 0.5  default milliseconds timeout for now.
 	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
 
-	TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
 			size_t frameSize = 0, double timeoutSeconds = -1);
-	virtual~ TcSocketPollingTask();
+	virtual~ TcUnixUdpPollingTask();
 
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
 
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
 private:
 	//! TMTC bridge is cached.
 	object_id_t tmtcBridgeId = objects::NO_OBJECT;
 	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
 	//! Reception flags: https://linux.die.net/man/2/recvfrom.
 	int receptionFlags = 0;
 
@@ -47,7 +52,7 @@ private:
 	size_t frameSize = 0;
 	timeval receptionTimeout;
 
-	ReturnValue_t handleSuccessfullTcRead();
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
 
 };
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 710761b4..a337b8ae 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -101,7 +101,7 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
-	case(EACCES):
+	case(EACCES): {
 		/*
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
@@ -110,7 +110,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 				"Ports 1-1024 are reserved on UNIX systems and require root "
 				"rights while ephermeral ports should not be used as well."
 				<< std::endl;
-		break;
+	}
+	break;
 	case(EADDRINUSE):
 	case(EBADF):
 	case(EINVAL):
@@ -122,15 +123,17 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOENT):
 	case(ENOMEM):
 	case(ENOTDIR):
-	case(EROFS):
+	case(EROFS): {
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
-					<< " with " << strerror(errno) << std::endl;
+				<< " with " << strerror(errno) << std::endl;
 		break;
-	default:
+	}
+	default: {
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
-						<< std::endl;
+				<< std::endl;
 		break;
 	}
+	}
 }
 
 
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 15d256cd..2fb606b0 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -7,7 +7,7 @@
 #include <netinet/udp.h>
 
 class TmTcUnixUdpBridge: public TmTcBridge {
-	friend class TcSocketPollingTask;
+	friend class TcUnixUdpPollingTask;
 public:
 	// The ports chosen here should not be used by any other process.
 	// List of used ports on Linux: /etc/services
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 878b8f7d..199e2ed1 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -2,30 +2,37 @@
 #include <framework/tcdistribution/CCSDSDistributor.h>
 #include <framework/tmtcpacket/SpacePacketBase.h>
 
-CCSDSDistributor::CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId ) :
-		TcDistributor( setObjectId ), default_apid( setDefaultApid ), tcStore(NULL) {
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
 }
 
-CCSDSDistributor::~CCSDSDistributor() {
+CCSDSDistributor::~CCSDSDistributor() {}
 
-}
-
-iterator_t CCSDSDistributor::selectDestination() {
-//	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* p_packet = NULL;
+TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
 	size_t size = 0;
-	//TODO check returncode?
-	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
-	SpacePacketBase current_packet( p_packet );
-//	info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex << current_packet.getAPID() << std::dec << std::endl;
-	iterator_t position = this->queueMap.find( current_packet.getAPID() );
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMessageQueueMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
 	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to create acceptance failure report.
-		return this->queueMap.find( this->default_apid );
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
 	}
-
 }
 
 MessageQueueId_t CCSDSDistributor::getRequestQueue() {
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 9dce34f2..22025f76 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,58 +1,69 @@
-#ifndef CCSDSDISTRIBUTOR_H_
-#define CCSDSDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/tcdistribution/CCSDSDistributorIF.h>
 #include <framework/tcdistribution/TcDistributor.h>
 #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+
 /**
- * An instantiation of the CCSDSDistributorIF.
- * It receives Space Packets, and selects a destination depending on the APID of the telecommands.
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
  * The Secondary Header (with Service/Subservice) is ignored.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class CCSDSDistributor : public TcDistributor, public CCSDSDistributorIF, public AcceptsTelecommandsIF {
-protected:
-	/**
-	 * This implementation checks if an Application with fitting APID has registered and forwards the
-	 * packet to the according message queue.
-	 * If the packet is not found, it returns the queue to \c default_apid, where a Acceptance Failure
-	 * message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	iterator_t selectDestination();
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t default_apid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles pure Space Packets and there
-	 * exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore;
-	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
 public:
 	/**
-	 * The constructor sets the default APID and calls the TcDistributor ctor with a certain object id.
-	 * \c tcStore is set in the \c initialize method.
-	 * @param set_default_apid The default APID, where packets with unknown destination are sent to.
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param set_default_apid The default APID, where packets with unknown
+	 * destination are sent to.
 	 */
 	CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId );
 	/**
 	 * The destructor is empty.
 	 */
 	~CCSDSDistributor();
-	MessageQueueId_t getRequestQueue();
-	ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id );
-	ReturnValue_t registerApplication( AcceptsTelecommandsIF* application );
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
 	uint16_t getIdentifier();
-	ReturnValue_t initialize();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMessageQueueMapIter selectDestination();
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 };
 
-
-
-#endif /* CCSDSDISTRIBUTOR_H_ */
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index bcf6d571..f13b5f8d 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -12,9 +12,9 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 
 PUSDistributor::~PUSDistributor() {}
 
-iterator_t PUSDistributor::selectDestination() {
+TcDistributor::TcMessageQueueMapIter PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
-	iterator_t queueMapIt = this->queueMap.end();
+	TcMessageQueueMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 8d774662..3d6717bd 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,5 +1,5 @@
-#ifndef PUSDISTRIBUTOR_H_
-#define PUSDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/tcdistribution/PUSDistributorIF.h>
@@ -9,37 +9,42 @@
 #include <framework/tmtcservices/VerificationReporter.h>
 
 /**
- * This class accepts PUS Telecommands and forwards them to Application services.
- * In addition, the class performs a formal packet check and sends acceptance success
- * or failure messages.
- * \ingroup tc_distribution
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
  */
 class PUSDistributor: public TcDistributor,
 		public PUSDistributorIF,
 		public AcceptsTelecommandsIF {
 public:
 	/**
-	 * The ctor passes \c set_apid to the checker class and calls the TcDistribution ctor with a certain object id.
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
 	 * @param setApid The APID of this receiving Application.
 	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets. Must implement CCSDSDistributorIF.
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
 	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource);
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
 	/**
 	 * The destructor is empty.
 	 */
 	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service);
-	MessageQueueId_t getRequestQueue();
-	uint16_t getIdentifier();
-	ReturnValue_t initialize();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
 protected:
 	/**
 	 * This attribute contains the class, that performs a formal packet check.
 	 */
 	TcPacketCheck checker;
 	/**
-	 * With this class, verification messages are sent to the TC Verification service.
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
 	 */
 	VerificationReporter verifyChannel;
 	/**
@@ -47,21 +52,26 @@ protected:
 	 */
 	TcPacketStored currentPacket;
 	/**
-	 * With this variable, the current check status is stored to generate acceptance messages later.
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
 	 */
 	ReturnValue_t tcStatus;
 
 	const object_id_t packetSource;
 	/**
-	 * This method reads the packet service, checks if such a service is registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification messages.
-	 * @return Iterator to map entry of found service id or iterator to \c map.end().
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
 	 */
-	iterator_t selectDestination();
+	TcMessageQueueMapIter selectDestination();
 	/**
-	 * The callback here handles the generation of acceptance success/failure messages.
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
 	 */
 	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
 };
 
-#endif /* PUSDISTRIBUTOR_H_ */
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 57921459..7bebbb9c 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -15,7 +15,6 @@ TcDistributor::~TcDistributor() {
 
 ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 	ReturnValue_t status = RETURN_OK;
-//	debug << "TcDistributor: performing Operation." << std::endl;
 	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
 			status = tcQueue->receiveMessage(&currentMessage)) {
 		status = handlePacket();
@@ -29,7 +28,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcDistributor::handlePacket() {
 
-	iterator_t queueMapIt = this->selectDestination();
+	TcMessageQueueMapIter queueMapIt = this->selectDestination();
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if (queueMapIt != this->queueMap.end()) {
 		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
@@ -41,7 +40,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 void TcDistributor::print() {
 	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
 			<< std::endl;
-	for (iterator_t it = this->queueMap.begin(); it != this->queueMap.end();
+	for (TcMessageQueueMapIter it = this->queueMap.begin(); it != this->queueMap.end();
 			it++) {
 		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
 				<< std::endl;
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index b80f08e6..5c958de0 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,5 +1,6 @@
-#ifndef TCDISTRIBUTOR_H_
-#define TCDISTRIBUTOR_H_
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@@ -9,16 +10,12 @@
 #include <framework/ipc/MessageQueueIF.h>
 #include <map>
 
-
 /**
- * \defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands belong to this group.
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
  */
 
-/**
- * This typedef simplifies writing down the \c map iterator.
- */
-typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
 
 /**
  * This is the base class to implement distributors for Space Packets.
@@ -28,59 +25,15 @@ typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
  * message queue ids to some identifier. The process of unpacking the
  * destination information from the packet is handled by the child class
  * implementations.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
-class TcDistributor : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	std::map<uint32_t, MessageQueueId_t> queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual iterator_t selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
 public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMessageQueueMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
 	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
 	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
@@ -110,6 +63,57 @@ public:
 	 * queueMap.
 	 */
 	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMessageQueueMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
 };
 
 
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 82e5ff5c..cb1e633f 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -41,9 +41,14 @@ void PusServiceBase::handleRequestQueue() {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-		//	debug << "PusServiceBase::performOperation: Receiving from MQ ID: "
-		//      << std::hex << this->requestQueue.getId()
-		//      << std::dec << " returned: " << status << std::endl;
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
 		if (status == RETURN_OK) {
 			this->currentPacket.setStoreAddress(message.getStorageId());
 			//info << "Service " << (uint16_t) this->serviceId <<
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 5b933c79..a009c962 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -62,7 +62,7 @@ public:
 	 * @param virtualChannel
 	 * @return
 	 */
-	MessageQueueId_t getReportReceptionQueue(
+	virtual MessageQueueId_t getReportReceptionQueue(
 			uint8_t virtualChannel = 0) override;
 protected:
 	//! Used to send and receive TMTC messages.

From 264914e86a1b9a2854dbc8d83ed96445a1255482 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 03:18:09 +0200
Subject: [PATCH 0544/1292] tmtcbridge tweaks.

UDP bridge now working :-D
---
 osal/linux/MessageQueue.cpp          |  8 ++--
 osal/linux/PeriodicPosixTask.cpp     |  8 ++--
 osal/linux/TcUnixUdpPollingTask.cpp  | 69 ++++++++++++++++------------
 osal/linux/TcUnixUdpPollingTask.h    |  8 ++++
 osal/linux/TmTcUnixUdpBridge.cpp     | 43 +++++++----------
 osal/linux/TmTcUnixUdpBridge.h       |  7 +--
 tcdistribution/CCSDSDistributor.cpp  |  4 +-
 tcdistribution/CCSDSDistributor.h    |  8 ++--
 tcdistribution/PUSDistributor.cpp    |  4 +-
 tcdistribution/PUSDistributor.h      |  2 +-
 tcdistribution/TcDistributor.cpp     |  4 +-
 tcdistribution/TcDistributor.h       |  4 +-
 tmtcservices/AcceptsTelecommandsIF.h | 10 ++--
 tmtcservices/TmTcBridge.cpp          | 26 +++++++----
 tmtcservices/TmTcBridge.h            | 34 ++++++--------
 15 files changed, 121 insertions(+), 118 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index ce1da17c..153f43d3 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -155,10 +155,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
-	        sif::error << "MessageQueue::receiveMessage: Message size "
-	                << message->getMaximumMessageSize() <<
-	                " too small to receive data!" << std::endl;
-	        return HasReturnvaluesIF::RETURN_FAILED;
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	unsigned int messagePriority = 0;
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index b811274b..4b0c77fc 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -68,12 +68,12 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
 			if(status == 0){
-				sif::error << "PeriodicPosixTask " << name << ": Deadline "
-						"missed." << std::endl;
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
 			}
 			else {
-				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-						status << std::endl;
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 83f7a3da..97fbd044 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -26,8 +26,7 @@ TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 	}
 }
 
-TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {
-}
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
 
 ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	// Poll for new UDP datagrams in permanent loop.
@@ -59,6 +58,30 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId = 0;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::debug << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
 ReturnValue_t TcUnixUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
@@ -74,41 +97,27 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	targetTcDestination = tmtcBridge->getReportReceptionQueue();
-
 	serverUdpSocket = tmtcBridge->serverSocket;
 
-	// Set receive timeout.
-//	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-//			&receptionTimeout, sizeof(receptionTimeout));
-//	if(result == -1) {
-//		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-//				"receive timeout failed with " << strerror(errno) << std::endl;
-//		return ObjectManagerIF::CHILD_INIT_FAILED;
-//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId = 0;
-	ReturnValue_t result = tcStore->addData(&storeId,
-			receptionBuffer.data(), bytesRead);
-	// arrayprinter::print(receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-				"storage failed" << std::endl;
-		sif::debug << "Packet size: " << bytesRead << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination will be set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
 
-	TmTcMessage message(storeId);
-	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Serial Polling: Sending message to queue failed"
-				<< std::endl;
-		tcStore->deleteData(storeId);
+void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
+	timeval tval;
+	tval = timevalOperations::toTimeval(timeoutSeconds);
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&tval, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
 	}
-	return result;
 }
 
 
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 3503d505..86591e8d 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -29,8 +29,16 @@ public:
 			size_t frameSize = 0, double timeoutSeconds = -1);
 	virtual~ TcUnixUdpPollingTask();
 
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
 	StorageManagerIF* tcStore = nullptr;
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index a337b8ae..4dc61c50 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,8 +1,9 @@
 #include <framework/osal/linux/TmTcUnixUdpBridge.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
 #include <framework/ipc/MutexHelper.h>
 
+#include <errno.h>
+
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
 		uint16_t clientPort):
@@ -14,17 +15,16 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setServerPort = serverPort;
 	}
 
-	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-	if(clientPort != 0xFFFF) {
-		setClientPort = clientPort;
-	}
+//	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+//	if(clientPort != 0xFFFF) {
+//		setClientPort = clientPort;
+//	}
 
 	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
 	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
-		// check errno here.
 		handleSocketError();
 		return;
 	}
@@ -44,7 +44,6 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
-		// check errno here.
 		handleBindError();
 		return;
 	}
@@ -57,14 +56,21 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 	ssize_t result = send(serverSocket, data, dataLen, flags);
 	if(result < 0) {
-		//handle error
+		// todo: handle errors
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
 				"with error " << strerror(errno) << std::endl;
 	}
-
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, 10);
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+	}
+}
+
 void TmTcUnixUdpBridge::handleSocketError() {
 
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
@@ -87,17 +93,6 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	}
 }
 
-void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
-}
-
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, 10);
-	// Set new IP address if it has changed.
-	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
-	}
-}
-
 void TmTcUnixUdpBridge::handleBindError() {
 	// See: https://man7.org/linux/man-pages/man2/bind.2.html
 	switch(errno) {
@@ -128,16 +123,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	}
-	default: {
+	default:
 		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
 				<< std::endl;
 		break;
 	}
-	}
 }
 
-
-ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
-	// TC reception handled by separate polling task because it is blocking.
-	return HasReturnvaluesIF::RETURN_OK;
-}
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 2fb606b0..538664d8 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 #define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
 
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 #include <framework/tmtcservices/TmTcBridge.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -18,13 +19,11 @@ public:
 			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
-	void setTimeout(float timeoutSeconds);
 	void checkAndSetClientAddress(sockaddr_in clientAddress);
 
 protected:
-	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
-			size_t * size) override;
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
 private:
 	int serverSocket = 0;
 	const int serverSocketOptions = 0;
@@ -43,6 +42,4 @@ private:
 	void handleBindError();
 };
 
-
-
 #endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 199e2ed1..24c93730 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -9,7 +9,7 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 
 CCSDSDistributor::~CCSDSDistributor() {}
 
-TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
@@ -25,7 +25,7 @@ TcDistributor::TcMessageQueueMapIter CCSDSDistributor::selectDestination() {
 
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMessageQueueMapIter position = this->queueMap.find(currentPacket.getAPID());
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
 	} else {
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 22025f76..60877753 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -24,14 +24,14 @@ public:
 	 * 			TcDistributor ctor with a certain object id.
 	 * @details
 	 * @c tcStore is set in the @c initialize method.
-	 * @param set_default_apid The default APID, where packets with unknown
+	 * @param setDefaultApid The default APID, where packets with unknown
 	 * destination are sent to.
 	 */
-	CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId );
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
 	/**
 	 * The destructor is empty.
 	 */
-	~CCSDSDistributor();
+	virtual ~CCSDSDistributor();
 
 	MessageQueueId_t getRequestQueue() override;
 	ReturnValue_t registerApplication( uint16_t apid,
@@ -49,7 +49,7 @@ protected:
 	 * where a Acceptance Failure message should be generated.
 	 * @return Iterator to map entry of found APID or iterator to default APID.
 	 */
-	TcMessageQueueMapIter selectDestination();
+	TcMqMapIter selectDestination() override;
 	/**
 	 * The default APID, where packets with unknown APID are sent to.
 	 */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index f13b5f8d..d6e20acf 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -12,9 +12,9 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 
 PUSDistributor::~PUSDistributor() {}
 
-TcDistributor::TcMessageQueueMapIter PUSDistributor::selectDestination() {
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 //	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
-	TcMessageQueueMapIter queueMapIt = this->queueMap.end();
+	TcMqMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 3d6717bd..4a22f936 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -66,7 +66,7 @@ protected:
 	 * @return Iterator to map entry of found service id
 	 * or iterator to @c map.end().
 	 */
-	TcMessageQueueMapIter selectDestination();
+	TcMqMapIter selectDestination() override;
 	/**
 	 * The callback here handles the generation of acceptance
 	 * success/failure messages.
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 7bebbb9c..0190cc97 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -28,7 +28,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 
 ReturnValue_t TcDistributor::handlePacket() {
 
-	TcMessageQueueMapIter queueMapIt = this->selectDestination();
+	TcMqMapIter queueMapIt = this->selectDestination();
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if (queueMapIt != this->queueMap.end()) {
 		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
@@ -40,7 +40,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 void TcDistributor::print() {
 	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
 			<< std::endl;
-	for (TcMessageQueueMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
 			it++) {
 		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
 				<< std::endl;
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 5c958de0..73425302 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -32,7 +32,7 @@ class TcDistributor : public SystemObject,
 		public HasReturnvaluesIF {
 public:
 	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMessageQueueMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
 	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
@@ -90,7 +90,7 @@ protected:
 	 * packet and select the map entry which represents the packet's target.
 	 * @return	An iterator to the map element to forward to or queuMap.end().
 	 */
-	virtual TcMessageQueueMapIter selectDestination() = 0;
+	virtual TcMqMapIter selectDestination() = 0;
 	/**
 	 * The handlePacket method calls the child class's selectDestination method
 	 * and forwards the packet to its destination, if found.
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 0952d3a6..2878dd5d 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELECOMMANDSIF_H_
-#define ACCEPTSTELECOMMANDSIF_H_
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
 
 #include <framework/ipc/MessageQueueSenderIF.h>
 
@@ -26,9 +26,9 @@ public:
 	/**
 	 * @brief	Getter for the service id.
 	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service id. If the receiver can handle Telecommands, but for
+	 * 			service ID. If the receiver can handle Telecommands, but for
 	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service id or 0.
+	 * @return	The service ID or 0.
 	 */
 	virtual uint16_t getIdentifier() = 0;
 	/**
@@ -40,4 +40,4 @@ public:
 };
 
 
-#endif /* ACCEPTSTELECOMMANDSIF_H_ */
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 092884bb..9c3e5b94 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -9,7 +9,7 @@ TmTcBridge::TmTcBridge(object_id_t objectId,
         object_id_t ccsdsPacketDistributor): SystemObject(objectId),
         ccsdsPacketDistributor(ccsdsPacketDistributor)
 {
-    TmTcReceptionQueue = QueueFactory::instance()->
+    tmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
@@ -55,7 +55,8 @@ ReturnValue_t TmTcBridge::initialize() {
 	if (tcDistributor == NULL) {
 		return RETURN_FAILED;
 	}
-	TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+
+	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
 	return RETURN_OK;
 }
 
@@ -73,10 +74,7 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t TmTcBridge::handleTc() {
-	uint8_t * recvBuffer = nullptr;
-	size_t recvLen = 0;
-	ReturnValue_t result = receiveTc(&recvBuffer, &recvLen);
-	return result;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TmTcBridge::handleTm() {
@@ -97,8 +95,8 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
-		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
+	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
+		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
 		if(communicationLinkUp == false) {
 			result = storeDownlinkData(&message);
@@ -183,10 +181,20 @@ void TmTcBridge::registerCommDisconnect() {
 }
 
 MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
-	return TmTcReceptionQueue->getId();
+	return tmTcReceptionQueue->getId();
 }
 
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	arrayprinter::print(data, dataLen);
 }
+
+uint16_t TmTcBridge::getIdentifier() {
+	// This is no PUS service, so we just return 0
+	return 0;
+}
+
+MessageQueueId_t TmTcBridge::getRequestQueue() {
+	// Default implementation: Relay TC messages to TC distributor directly.
+	return tmTcReceptionQueue->getDefaultDestination();
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index a009c962..3fcbf84c 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,16 +1,18 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
-#include <framework/container/FIFO.h>
+#include <framework/objectmanager/SystemObject.h>
 #include <framework/tmtcservices/AcceptsTelemetryIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 
+#include <framework/container/FIFO.h>
 #include <framework/tmtcservices/TmTcMessage.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
+		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF,
 		public SystemObject {
@@ -57,17 +59,19 @@ public:
 	 */
 	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-	/**
-	 * Return TMTC Reception Queue
-	 * @param virtualChannel
-	 * @return
-	 */
+
+	/** AcceptsTelemetryIF override */
 	virtual MessageQueueId_t getReportReceptionQueue(
 			uint8_t virtualChannel = 0) override;
+
+	/** AcceptsTelecommandsIF override */
+	virtual uint16_t getIdentifier() override;
+	virtual MessageQueueId_t getRequestQueue() override;
+
 protected:
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.
-	MessageQueueIF* TmTcReceptionQueue = nullptr;
+	MessageQueueIF* tmTcReceptionQueue = nullptr;
 	StorageManagerIF* tcStore = nullptr;
 	StorageManagerIF* tmStore = nullptr;
 	object_id_t ccsdsPacketDistributor = 0;
@@ -79,23 +83,11 @@ protected:
 	 * @brief 	Handle TC reception
 	 * @details
 	 * Default implementation provided, but is empty.
-	 * Child handler should override this in most cases orsend TC to the
-	 * TC distributor directly with the address of the reception queue by
-	 * calling getReportRecptionQueue()
+	 * In most cases, TC reception will be handled in a separate task anyway.
 	 * @return
 	 */
 	virtual ReturnValue_t handleTc();
 
-	/**
-	 * Implemented by child class. Perform receiving of Telecommand,
-	 * for example by implementing specific drivers or wrappers,
-	 * e.g. UART Communication or an ethernet stack
-	 * @param recvBuffer [out] Received data
-	 * @param size [out] Size of received data
-	 * @return
-	 */
-	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, size_t * size) = 0;
-
 	/**
 	 * Handle Telemetry. Default implementation provided.
 	 * Calls sendTm()

From 94f9b1e1ef0ecdbd0f92751284f74dc02310b7c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:41:15 +0200
Subject: [PATCH 0545/1292] dle encoder doc finished and hopefully correct

---
 globalfunctions/DleEncoder.cpp | 128 +++++++++++++++++++--------------
 globalfunctions/DleEncoder.h   |  21 ++++--
 2 files changed, 89 insertions(+), 60 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index ee934785..d727d665 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -4,50 +4,6 @@ DleEncoder::DleEncoder() {}
 
 DleEncoder::~DleEncoder() {}
 
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-		size_t maxDestStreamlen, size_t *decodedLen) {
-	size_t encodedIndex = 0, decodedIndex = 0;
-	uint8_t nextByte;
-	if (*sourceStream != STX) {
-		return DECODING_ERROR;
-	}
-	++encodedIndex;
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// The next byte is a DLE character that was escaped by another
-			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE) {
-				destStream[decodedIndex] = nextByte;
-			} else {
-			    // The next byte is a STX, DTX or 0x0D character which
-			    // was escaped by a DLE character
-				if ((nextByte == 0x42) || (nextByte == 0x43)
-						|| (nextByte == 0x4D)) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				} else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		} else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-		++encodedIndex;
-		++decodedIndex;
-	}
-	if (sourceStream[encodedIndex] != ETX) {
-		return DECODING_ERROR;
-	} else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
 ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
 		size_t* encodedLen, bool addStxEtx) {
@@ -60,39 +16,105 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		destStream[0] = STX;
 		++encodedIndex;
 	}
-	while ((encodedIndex < maxDestLen) && (sourceIndex < sourceLen)) {
+
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
 		nextByte = sourceStream[sourceIndex];
-		if ((nextByte == STX) || (nextByte == ETX) || (nextByte == 0x0D)) {
+		// STX, ETX and CR characters in the stream need to be escaped with DLE
+		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
 			if (encodedIndex + 1 >= maxDestLen) {
 				return STREAM_TOO_SHORT;
-			} else {
+			}
+			else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
-				// Escaped byte will be actual byte + 0x40.
+				/* Escaped byte will be actual byte + 0x40. This prevents
+				 * STX, ETX, and carriage return characters from appearing
+				 * in the encoded data stream at all, so when polling an
+				 * encoded stream, the transmission can be stopped at ETX.
+				 * 0x40 was chosen at random with special requirements:
+				 *  - Prevent going from one control char to another
+				 *  - Prevent overflow for common characters */
 				destStream[encodedIndex] = nextByte + 0x40;
 			}
-		} else if (nextByte == DLE) {
+		}
+		// DLE characters are simply escaped with DLE.
+		else if (nextByte == DLE) {
 			if (encodedIndex + 1 >= maxDestLen) {
 			    return STREAM_TOO_SHORT;
-			} else {
+			}
+			else {
 				destStream[encodedIndex] = DLE;
 				++encodedIndex;
 				destStream[encodedIndex] = DLE;
 			}
-		} else {
+		}
+		else {
 			destStream[encodedIndex] = nextByte;
 		}
 		++encodedIndex;
 		++sourceIndex;
 	}
-	if ((sourceIndex == sourceLen) && (encodedIndex < maxDestLen)) {
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
 		if (addStxEtx) {
 			destStream[encodedIndex] = ETX;
 			++encodedIndex;
 		}
 		*encodedLen = encodedIndex;
 		return RETURN_OK;
-	} else {
+	}
+	else {
 		return STREAM_TOO_SHORT;
 	}
 }
+
+ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
+		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+		size_t maxDestStreamlen, size_t *decodedLen) {
+	size_t encodedIndex = 0, decodedIndex = 0;
+	uint8_t nextByte;
+	if (*sourceStream != STX) {
+		return DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX)
+			&& (sourceStream[encodedIndex] != STX)) {
+		if (sourceStream[encodedIndex] == DLE) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// The next byte is a DLE character that was escaped by another
+			// DLE character, so we can write it to the destination stream.
+			if (nextByte == DLE) {
+				destStream[decodedIndex] = nextByte;
+			}
+			else {
+			    /* The next byte is a STX, DTX or 0x0D character which
+			     * was escaped by a DLE character. The actual byte was
+				 * also encoded by adding + 0x40 to preven having control chars,
+				 * in the stream at all, so we convert it back. */
+				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
+					destStream[decodedIndex] = nextByte - 0x40;
+				} else {
+				    return DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX) {
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 0f4a4c8f..36cb1d3f 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -14,9 +14,15 @@
  * This encoder can be used to achieve a basic transport layer when using
  * char based transmission systems.
  * The passed source strean is converted into a encoded stream by adding
- * a STX marker at the startr of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX and DLE occurences in the source stream are escaped
- * by a DLE character.
+ * a STX marker at the start of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
+ * escaped by a DLE character. The encoder also replaces escaped control chars
+ * by another char, so STX, ETX and CR should not appear anywhere in the actual
+ * encoded data stream.
+ *
+ * When using a strictly char based reception of packets enoded with DLE,
+ * STX can be used to notify a reader that actual data will start to arrive
+ * while ETX can be used to notify the reader that the data has ended.
  */
 class DleEncoder: public HasReturnvaluesIF {
 private:
@@ -29,12 +35,13 @@ public:
 	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
 
 	//! Start Of Text character. First character is encoded stream
-	static const uint8_t STX = 0x02;
+	static constexpr uint8_t STX = 0x02;
 	//! End Of Text character. Last character in encoded stream
-	static const uint8_t ETX = 0x03;
+	static constexpr uint8_t ETX = 0x03;
 	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
 	//! in the source stream.
-	static const uint8_t DLE = 0x10;
+	static constexpr uint8_t DLE = 0x10;
+	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
 
     /**
      * Encodes the give data stream by preceding it with the STX marker
@@ -54,7 +61,7 @@ public:
             bool addStxEtx = true);
 
     /**
-     * Converts an encoded stream back
+     * Converts an encoded stream back.
      * @param sourceStream
      * @param sourceStreamLen
      * @param readLen

From 01b10803766e61833eaa9762327a48e0fff76c29 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:53:46 +0200
Subject: [PATCH 0546/1292] readability increase

---
 globalfunctions/DleEncoder.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index d727d665..c8f78872 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -17,7 +17,8 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 		++encodedIndex;
 	}
 
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen) {
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+	{
 		nextByte = sourceStream[sourceIndex];
 		// STX, ETX and CR characters in the stream need to be escaped with DLE
 		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
@@ -80,7 +81,8 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
 			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
+			&& (sourceStream[encodedIndex] != STX))
+	{
 		if (sourceStream[encodedIndex] == DLE) {
 			nextByte = sourceStream[encodedIndex + 1];
 			// The next byte is a DLE character that was escaped by another
@@ -95,7 +97,8 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 				 * in the stream at all, so we convert it back. */
 				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
 					destStream[decodedIndex] = nextByte - 0x40;
-				} else {
+				}
+				else {
 				    return DECODING_ERROR;
 				}
 			}
@@ -104,6 +107,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		else {
 			destStream[decodedIndex] = sourceStream[encodedIndex];
 		}
+
 		++encodedIndex;
 		++decodedIndex;
 	}

From b56aa94f99730cee982eebc09dd8fa88a3fbc077 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 12:54:40 +0200
Subject: [PATCH 0547/1292] additional doc

---
 globalfunctions/DleEncoder.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 36cb1d3f..29851dfe 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -46,7 +46,8 @@ public:
     /**
      * Encodes the give data stream by preceding it with the STX marker
      * and ending it with an ETX marker. STX, ETX and DLE characters inside
-     * the stream are escaped by DLE characters.
+     * the stream are escaped by DLE characters and also replaced by adding
+     * 0x40 (which is reverted in the decoing process).
      * @param sourceStream
      * @param sourceLen
      * @param destStream

From 5ec78b065c4ca0ba486b9837c0e4c0eba40d5b15 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 13:29:57 +0200
Subject: [PATCH 0548/1292] error handling for invalid dest queues improved

---
 ipc/MessageQueueIF.h                  | 14 +++----
 objectmanager/frameworkObjects.h      |  4 ++
 osal/linux/MessageQueue.cpp           | 13 ++++---
 tmtcservices/VerificationReporter.cpp | 56 +++++++++++++++------------
 tmtcservices/VerificationReporter.h   | 39 ++++++++++++++-----
 5 files changed, 78 insertions(+), 48 deletions(-)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 500f71e2..c0575442 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -18,18 +18,14 @@ public:
 	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	/**
-	 * No new messages on the queue
-	 */
+	//! No new messages on the queue
 	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	/**
-	 * No space left for more messages
-	 */
+	//! No space left for more messages
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	/**
-	 * Returned if a reply method was called without partner
-	 */
+	//! Returned if a reply method was called without partner
 	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
 
 	virtual ~MessageQueueIF() {}
 	/**
diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index c3deafc4..46d5feea 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -3,6 +3,9 @@
 
 namespace objects {
 enum framework_objects {
+	// Default verification reporter.
+	PUS_SERVICE_1 = 0x53000000,
+
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
 //	MODE_STORE = 0x53010100,
@@ -12,6 +15,7 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+
 	NO_OBJECT = 0xFFFFFFFF
 };
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 153f43d3..236e61b6 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -330,13 +330,16 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			//MQ_NONBLOCK flag was set in its attributes, and the
 			//specified queue is full.
 			return MessageQueueIF::FULL;
-		case EBADF:
+		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send mqSendTo: " << sendTo
-					   << " sent from " << sentFrom << std::endl;
-			/*NO BREAK*/
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
 		case EINTR:
 			//The call was interrupted by a signal.
 		case EINVAL:
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index bcb4756c..40f7e57f 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,17 +1,18 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
 #include <framework/tmtcservices/VerificationReporter.h>
 
-object_id_t VerificationReporter::messageReceiver = 0;
+#include <framework/ipc/MessageQueueIF.h>
+#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/objectmanager/frameworkObjects.h>
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
 
 VerificationReporter::VerificationReporter() :
-		acknowledgeQueue() {
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
 }
 
-VerificationReporter::~VerificationReporter() {
-	//Default, empty
-}
+VerificationReporter::~VerificationReporter() {}
 
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		TcPacketBase* current_packet, uint8_t set_step) {
@@ -23,10 +24,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 			current_packet->getPacketId(),
 			current_packet->getPacketSequenceControl(), 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
+			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -39,10 +41,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
 			tcSequenceControl, 0, set_step);
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
+			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				"to queue. Code: " << std::hex << (uint16_t) status << std::endl;
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -60,9 +63,9 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
@@ -78,20 +81,25 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error
-				<< "VerificationReporter::sendFailureReport Error writing to queue. Code: "
-				<< (uint16_t) status << std::endl;
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
 	}
 }
 
 void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
-	if (temp != NULL) {
-		this->acknowledgeQueue = temp->getVerificationQueue();
-	} else {
-		sif::error
-				<< "VerificationReporter::VerificationReporter: Configuration error."
-				<< std::endl;
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
 	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
 }
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 370c44c8..f13998d9 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,5 +1,5 @@
-#ifndef VERIFICATIONREPORTER_H_
-#define VERIFICATIONREPORTER_H_
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
 
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tmtcservices/PusVerificationReport.h>
@@ -8,24 +8,43 @@ namespace Factory{
 void setStaticFrameworkObjectIds();
 }
 
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
 class VerificationReporter {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	VerificationReporter();
 	virtual ~VerificationReporter();
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet, uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl, uint8_t set_step = 0);
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet, ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
 	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl, ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
 			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
 	void initialize();
+
 private:
 	static object_id_t messageReceiver;
 	MessageQueueId_t acknowledgeQueue;
-
-
 };
 
-#endif /* VERIFICATIONREPORTER_H_ */
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 236ad1b85b600acecc741127faa19c72925542fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 15:06:46 +0200
Subject: [PATCH 0549/1292] a lot of debug output added

---
 osal/linux/TcUnixUdpPollingTask.cpp   |  1 +
 osal/linux/TmTcUnixUdpBridge.cpp      | 54 ++++++++++++++++++++-------
 osal/linux/TmTcUnixUdpBridge.h        | 11 ++++--
 tmtcservices/PusServiceBase.cpp       | 20 +++++-----
 tmtcservices/TmTcBridge.cpp           | 32 ++++++++++------
 tmtcservices/TmTcBridge.h             | 17 ++++++---
 tmtcservices/VerificationReporter.cpp |  8 ++--
 7 files changed, 93 insertions(+), 50 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 97fbd044..122301da 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -53,6 +53,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
 
 		}
+		tmtcBridge->registerCommConnect();
 		tmtcBridge->checkAndSetClientAddress(senderAddress);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 4dc61c50..40e96561 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -3,11 +3,12 @@
 #include <framework/ipc/MutexHelper.h>
 
 #include <errno.h>
+#include <arpa/inet.h>
 
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t ccsdsPacketDistributor, uint16_t serverPort,
-		uint16_t clientPort):
-		TmTcBridge(objectId, ccsdsPacketDistributor) {
+		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+		uint16_t serverPort, uint16_t clientPort):
+		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
 	mutex = MutexFactory::instance()->createMutex();
 
 	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
@@ -15,13 +16,14 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		setServerPort = serverPort;
 	}
 
-//	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-//	if(clientPort != 0xFFFF) {
-//		setClientPort = clientPort;
-//	}
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
 
 	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
-	serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(socket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
@@ -36,10 +38,14 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
-	serverSocketLen = sizeof(serverAddress);
+	clientAddress.sin_family = AF_INET;
+	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	clientAddress.sin_port = htons(setClientPort);
+
+	serverAddressLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			serverSocketLen);
+			serverAddressLen);
 	if(result == -1) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
@@ -54,20 +60,35 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
-	ssize_t result = send(serverSocket, data, dataLen, flags);
-	if(result < 0) {
+	sif::debug << "Client Port: "<<ntohs(clientAddress.sin_port) << std::endl;
+	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
+			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	if(bytesSent < 0) {
 		// todo: handle errors
-		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
-				"with error " << strerror(errno) << std::endl;
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
+				<< std::endl;
+		sif::error << "Error: " << strerror(errno) << std::endl;
+		handleSendError();
 	}
+	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+			" sent." << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 	MutexHelper lock(mutex, 10);
+
+	char ipAddress [15];
+	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 	// Set new IP address if it has changed.
 	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		sif::info << "setting new address" << std::endl;
 		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+		clientAddressLen = sizeof(clientAddress);
 	}
 }
 
@@ -130,3 +151,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 	}
 }
 
+void TmTcUnixUdpBridge::handleSendError() {
+
+
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 538664d8..dbddc6c3 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -15,8 +15,9 @@ public:
 	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
 	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
 
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
-			 uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId,
+			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
 	void checkAndSetClientAddress(sockaddr_in clientAddress);
@@ -26,13 +27,14 @@ protected:
 
 private:
 	int serverSocket = 0;
+
 	const int serverSocketOptions = 0;
 
 	struct sockaddr_in clientAddress;
-	socklen_t clientSocketLen = 0;
+	socklen_t clientAddressLen = 0;
 
 	struct sockaddr_in serverAddress;
-	socklen_t serverSocketLen = 0;
+	socklen_t serverAddressLen = 0;
 
 	//! Access to the client address is mutex protected as it is set
 	//! by another task.
@@ -40,6 +42,7 @@ private:
 
 	void handleSocketError();
 	void handleBindError();
+	void handleSendError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index cb1e633f..4385609b 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -103,19 +103,17 @@ ReturnValue_t PusServiceBase::initialize() {
 			packetDestination);
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-	if ((destService != nullptr) && (distributor != nullptr)) {
-		this->requestQueue->setDefaultDestination(
-				destService->getReportReceptionQueue());
-		distributor->registerService(this);
-		return RETURN_OK;
-	}
-	else {
+	if (destService == nullptr or distributor == nullptr) {
 		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< (uint32_t) this->serviceId << ": Configuration error."
-				<< " Make sure packetSource and packetDestination are defined "
-			       "correctly" << std::endl;
-		return RETURN_FAILED;
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 9c3e5b94..8c44f7de 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -5,9 +5,11 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/globalfunctions/arrayprinter.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId,
-        object_id_t ccsdsPacketDistributor): SystemObject(objectId),
-        ccsdsPacketDistributor(ccsdsPacketDistributor)
+TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+		object_id_t tmStoreId, object_id_t tcStoreId):
+		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
+		tcDestination(tcDestination)
+
 {
     tmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
@@ -42,18 +44,24 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 }
 
 ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == NULL) {
-		return RETURN_FAILED;
+	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	if (tcStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-	tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-	if (tmStore == NULL) {
-		return RETURN_FAILED;
+	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	if (tmStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor);
-	if (tcDistributor == NULL) {
-		return RETURN_FAILED;
+			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	if (tcDistributor == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3fcbf84c..3e3d1b71 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -24,7 +24,8 @@ public:
 	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
 	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
-	TmTcBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor);
+	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId);
 	virtual ~TmTcBridge();
 
 	/**
@@ -69,14 +70,20 @@ public:
 	virtual MessageQueueId_t getRequestQueue() override;
 
 protected:
+	//! Cached for initialize function.
+	object_id_t tmStoreId = objects::NO_OBJECT;
+	object_id_t tcStoreId = objects::NO_OBJECT;
+	object_id_t tcDestination = objects::NO_OBJECT;
+
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.
 	MessageQueueIF* tmTcReceptionQueue = nullptr;
-	StorageManagerIF* tcStore = nullptr;
+
 	StorageManagerIF* tmStore = nullptr;
-	object_id_t ccsdsPacketDistributor = 0;
-	//! Used to specify whether communication link is up
-	bool communicationLinkUp = false;
+	StorageManagerIF* tcStore = nullptr;
+
+	//! Used to specify whether communication link is up by default.
+	bool communicationLinkUp = true;
 	bool tmStored = false;
 
 	/**
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 40f7e57f..79e650f1 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -16,7 +16,7 @@ VerificationReporter::~VerificationReporter() {}
 
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		TcPacketBase* current_packet, uint8_t set_step) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(set_report_id,
@@ -35,7 +35,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		uint8_t set_step) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
 		this->initialize();
 	}
 	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
@@ -52,7 +52,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 void VerificationReporter::sendFailureReport(uint8_t report_id,
 		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
 		uint32_t parameter1, uint32_t parameter2) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(report_id,
@@ -73,7 +73,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
 		uint32_t parameter2) {
-	if (this->acknowledgeQueue == 0) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
 		this->initialize();
 	}
 	PusVerificationMessage message(report_id, ackFlags, tcPacketId,

From 8046d005a46e734aa2112cbd6f617920da2ec753 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:18:54 +0200
Subject: [PATCH 0550/1292] CSB static framework id setting

---
 osal/linux/FixedTimeslotTask.cpp       |  2 +-
 osal/linux/TcUnixUdpPollingTask.cpp    | 35 +++++++++++++------
 osal/linux/TcUnixUdpPollingTask.h      |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp       | 48 ++++++++++++++++----------
 pus/Service2DeviceAccess.cpp           |  3 +-
 tcdistribution/PUSDistributor.cpp      |  8 ++---
 tmtcservices/CommandingServiceBase.cpp | 18 +++++++---
 tmtcservices/CommandingServiceBase.h   | 28 ++++++++++++---
 tmtcservices/PusServiceBase.cpp        |  5 ++-
 9 files changed, 99 insertions(+), 50 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index e5c68f9d..9d7d08f6 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -45,7 +45,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	}
 
 	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
+			" not found, not adding it to pst" << std::dec << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 122301da..8cf7b285 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,15 +39,14 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
-			sif::error << "TcSocketPollingTask::performOperation: recvfrom "
-					"failed with " << strerror(errno) << std::endl;
-			if(errno == EAGAIN or errno == EWOULDBLOCK) {
-				sif::info << "timeout" << std::endl;
-			}
+			sif::error << "TcSocketPollingTask::performOperation: Reception"
+					"error." << std::endl;
+			handleReadError();
+
 			continue;
 		}
-		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-				<< " bytes received" << std::endl;
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//				<< " bytes received" << std::endl;
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -61,14 +60,14 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 
 
 ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId = 0;
+	store_address_t storeId;
 	ReturnValue_t result = tcStore->addData(&storeId,
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
-		sif::debug << "Packet size: " << bytesRead << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -121,4 +120,18 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	}
 }
 
-
+void TcUnixUdpPollingTask::handleReadError() {
+	switch(errno) {
+	case(EAGAIN): {
+		// todo: When working in timeout mode, this will occur more often
+		// and is not an error.
+		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
+				<< std::endl;
+		break;
+	}
+	default: {
+		sif::error << "TcUnixUdpPollingTask::handleReadError: "
+				<< strerror(errno) << std::endl;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 86591e8d..d8de1458 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -61,7 +61,7 @@ private:
 	timeval receptionTimeout;
 
 	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-
+	void handleReadError();
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 40e96561..92fbbdfa 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -32,17 +32,20 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	}
 
 	serverAddress.sin_family = AF_INET;
+
 	// Accept packets from any interface.
+	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
 	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 	serverAddress.sin_port = htons(setServerPort);
+	serverAddressLen = sizeof(serverAddress);
 	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
 			sizeof(serverSocketOptions));
 
 	clientAddress.sin_family = AF_INET;
 	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
 	clientAddress.sin_port = htons(setClientPort);
+	clientAddressLen = sizeof(clientAddress);
 
-	serverAddressLen = sizeof(serverAddress);
 	int result = bind(serverSocket,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
@@ -60,33 +63,38 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
-	sif::debug << "Client Port: "<<ntohs(clientAddress.sin_port) << std::endl;
+
+	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+	clientAddressLen = sizeof(serverAddress);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
 	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
 			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
 	if(bytesSent < 0) {
-		// todo: handle errors
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
-		sif::error << "Error: " << strerror(errno) << std::endl;
 		handleSendError();
 	}
-	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-			" sent." << std::endl;
+//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//			" sent." << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 	MutexHelper lock(mutex, 10);
 
-	char ipAddress [15];
-	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 
-	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
-			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 	// Set new IP address if it has changed.
 	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-		sif::info << "setting new address" << std::endl;
 		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
 		clientAddressLen = sizeof(clientAddress);
 	}
@@ -104,11 +112,11 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	default:
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
 		break;
 	}
@@ -122,7 +130,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Port access issue."
+		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
 				"Ports 1-1024 are reserved on UNIX systems and require root "
 				"rights while ephermeral ports should not be used as well."
 				<< std::endl;
@@ -140,19 +148,21 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
+		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 		break;
 	}
 	default:
-		sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
+		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
 		break;
 	}
 }
 
 void TmTcUnixUdpBridge::handleSendError() {
-
-
+	switch(errno) {
+	default:
+		sif::error << "Error: " << strerror(errno) << std::endl;
+	}
 }
 
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 391c1116..4648aa9c 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -15,8 +15,7 @@ Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         object_id_t tmDestination, uint8_t numberOfParallelCommands,
         uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	        numberOfParallelCommands, commandTimeoutSeconds,
-	        tcSource, tmDestination) {}
+	        numberOfParallelCommands, commandTimeoutSeconds) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
 
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index d6e20acf..969380d6 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,12 +13,12 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-//	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
 	TcMqMapIter queueMapIt = this->queueMap.end();
 	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
 	if (currentPacket.getWholeData() != NULL) {
 		tcStatus = checker.checkPacket(&currentPacket);
-//		info << "PUSDistributor::handlePacket: packetCheck returned with " << (int)tc_status << std::endl;
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
 		uint32_t queue_id = currentPacket.getService();
 		queueMapIt = this->queueMap.find(queue_id);
 	} else {
@@ -29,8 +29,8 @@ TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 	}
 
 	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: error with " << (int) tcStatus
-				<< ", 0x"<< std::hex << (int) tcStatus << std::endl;
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
 		return this->queueMap.end();
 	} else {
 		return queueMapIt;
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 0c5f5eab..63a3d943 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -8,18 +8,28 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcpacket/pus/TmPacketStored.h>
 
+object_id_t CommandingServiceBase::packetSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::packetDestination = objects::NO_OBJECT;
+
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
-		object_id_t setPacketDestination, size_t queueDepth) :
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
 		SystemObject(setObjectId), apid(apid), service(service),
 		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands), packetSource(setPacketSource),
-		packetDestination(setPacketDestination) {
+		commandMap(numberOfParallelCommands) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }
 
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
 
 CommandingServiceBase::~CommandingServiceBase() {
 	QueueFactory::instance()->deleteMessageQueue(commandQueue);
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 700503c6..e9b5f047 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -15,6 +15,10 @@
 
 class TcPacketStored;
 
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
 /**
  * @brief 	This class is the basis for all PUS Services, which have to
  * 			relay Telecommands to software bus.
@@ -33,6 +37,7 @@ class CommandingServiceBase: public SystemObject,
 		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
@@ -57,10 +62,24 @@ public:
 	 */
 	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
 			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
-			object_id_t setPacketDestination, size_t queueDepth = 20);
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
 	virtual ~CommandingServiceBase();
 
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
 	/***
 	 * This is the periodically called function.
 	 * Handle request queue for external commands.
@@ -229,9 +248,8 @@ protected:
 	uint32_t failureParameter1 = 0;
 	uint32_t failureParameter2 = 0;
 
-	object_id_t packetSource;
-
-	object_id_t packetDestination;
+	static object_id_t packetSource;
+	static object_id_t packetDestination;
 
 	/**
 	 * Pointer to the task which executes this component,
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 4385609b..877eff3e 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -79,9 +79,8 @@ void PusServiceBase::handleRequestQueue() {
 		}
 		else {
 			sif::error << "PusServiceBase::performOperation: Service "
-					<< (uint16_t) this->serviceId
-					<< ": Error receiving packet. Code: " << std::hex << status
-					<< std::dec << std::endl;
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
 		}
 	}
 }

From dc27cc9aff73e6c17eb36281d056bd7c217ba6b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:37:26 +0200
Subject: [PATCH 0551/1292] srv8 added to framework

---
 pus/Service2DeviceAccess.cpp         |   7 +-
 pus/Service2DeviceAccess.h           |   3 +-
 pus/Service8FunctionManagement.cpp   | 129 +++++++++++++++++++++++++
 pus/Service8FunctionManagement.h     |  64 +++++++++++++
 pus/servicepackets/Service8Packets.h | 136 +++++++++++++++++++++++++++
 5 files changed, 334 insertions(+), 5 deletions(-)
 create mode 100644 pus/Service8FunctionManagement.cpp
 create mode 100644 pus/Service8FunctionManagement.h
 create mode 100644 pus/servicepackets/Service8Packets.h

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 4648aa9c..1d5f21eb 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -11,14 +11,14 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId, object_id_t tcSource,
-        object_id_t tmDestination, uint8_t numberOfParallelCommands,
+        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
         uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
 	        numberOfParallelCommands, commandTimeoutSeconds) {}
 
 Service2DeviceAccess::~Service2DeviceAccess() {}
 
+
 ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)){
 	case Subservice::RAW_COMMANDING:
@@ -41,7 +41,6 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
 
 	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
 	return result;
-
 }
 
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
@@ -55,6 +54,7 @@ ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
 ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		uint32_t* state, object_id_t objectId) {
@@ -100,6 +100,7 @@ ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
 	return result;
 }
 
+
 ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
 		Command_t previousCommand, uint32_t* state,
 		CommandMessage* optionalNextCommand, object_id_t objectId,
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 4dab0fa0..1a0bede0 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -36,8 +36,7 @@ class Service2DeviceAccess : public CommandingServiceBase,
 {
 public:
 	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, object_id_t tcSource,
-	        object_id_t tmDestination, uint8_t numberOfParallelCommands = 4,
+	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
 	        uint16_t commandTimeoutSeconds = 60);
 	virtual ~Service2DeviceAccess();
 
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
new file mode 100644
index 00000000..47afeae6
--- /dev/null
+++ b/pus/Service8FunctionManagement.cpp
@@ -0,0 +1,129 @@
+#include <framework/pus/Service8FunctionManagement.h>
+#include <framework/pus/servicepackets/Service8Packets.h>
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/action/HasActionsIF.h>
+#include <framework/devicehandlers/DeviceHandlerIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+		uint16_t commandTimeoutSeconds):
+		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		commandTimeoutSeconds) {}
+
+Service8FunctionManagement::~Service8FunctionManagement() {}
+
+
+ReturnValue_t Service8FunctionManagement::isValidSubservice(
+		uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::DIRECT_COMMANDING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	if(tcDataLen < sizeof(object_id_t)) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	SerializeAdapter::deSerialize(objectId, &tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check HasActionIF property of target
+	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service8FunctionManagement::prepareCommand(
+		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
+		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	if(subservice == static_cast<uint8_t>(Subservice::DIRECT_COMMANDING)) {
+		result = prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+	}
+	return result;
+}
+
+ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
+		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+	// Create direct command instance by extracting data from Telecommand
+	DirectCommand command(tcData,tcDataLen);
+
+	// store additional parameters into the Inter Process Communication Store
+	store_address_t parameterAddress;
+	ReturnValue_t result = IPCStore->addData(&parameterAddress,
+			command.getParameters(),command.getParametersSize());
+
+	// setCommand expects a Command Message, an Action ID and a store adress
+	// pointing to additional parameters
+	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
+	return result;
+}
+
+
+ReturnValue_t Service8FunctionManagement::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t* state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool* isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	ActionId_t actionId = ActionMessage::getActionId(reply);
+	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
+
+	switch(replyId)  {
+	case ActionMessage::COMPLETION_SUCCESS: {
+		DirectReply completionReply(objectId, actionId,returnCode);
+		result = CommandingServiceBase::EXECUTION_COMPLETE;
+		break;
+	}
+	case ActionMessage::STEP_SUCCESS: {
+		*isStep = true;
+		result = HasReturnvaluesIF::RETURN_OK;
+		break;
+	}
+	case ActionMessage::DATA_REPLY: {
+		store_address_t storeId = ActionMessage::getStoreId(reply);
+		size_t size = 0;
+		const uint8_t * buffer = nullptr;
+		result = IPCStore->getData(storeId, &buffer, &size);
+		if(result != RETURN_OK) {
+			sif::error << "Service 8: Could not retrieve data for data reply";
+			return result;
+		}
+		DataReply dataReply(objectId,actionId,buffer,size);
+		sendTmPacket(static_cast<uint8_t>(
+				Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+		result = IPCStore ->deleteData(storeId);
+		break;
+	}
+	case ActionMessage::STEP_FAILED:
+		*isStep = true;
+		/*No break, falls through*/
+	case ActionMessage::COMPLETION_FAILED:
+		result = ActionMessage::getReturnCode(reply);
+		break;
+	default:
+		result = INVALID_REPLY;
+	}
+	return result;
+}
+
+
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
new file mode 100644
index 00000000..e06c554c
--- /dev/null
+++ b/pus/Service8FunctionManagement.h
@@ -0,0 +1,64 @@
+#ifndef MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+#define MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief Functional commanding.
+ * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
+ * Dissertation Baetz p. 115, 116, 165-167
+ *
+ * This service provides the capability to perform functions of an
+ * application process and provides high-level commanding as opposed to the
+ * Raw Access provided by Service 2. Examples for these functions can include
+ * control and operation of payload or the AOCS subsystem.
+ * This service will be the primary means to control the spacecraft as it is
+ * considered safer than the Raw Access provided
+ * by Service 2 and is generally sufficient for most tasks.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * subclass like this service.
+ *
+ * Service Capability:
+ * 	 - TC[8,128]: Direct Commanding
+ *   - TM[8,130]: Direct Commanding Data Reply
+ *
+ * @ingroup pus_services
+ */
+class Service8FunctionManagement : public CommandingServiceBase
+{
+public:
+	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId, uint8_t numParallelCommands = 4,
+			uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service8FunctionManagement();
+
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+				uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+private:
+	enum class Subservice {
+		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
+		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	};
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+	ReturnValue_t prepareDirectCommand(CommandMessage* message,
+			const uint8_t* tcData, size_t tcDataLen);
+};
+
+#endif /* MISSION_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
new file mode 100644
index 00000000..5ef91280
--- /dev/null
+++ b/pus/servicepackets/Service8Packets.h
@@ -0,0 +1,136 @@
+/**
+ * \file Service8Packets.h
+ *
+ * \brief Structure of a Direct Command.
+ * Normal reply (subservice 130) consists of
+ *   1. Target object ID
+ *   2. Action ID (taget device has specified functions with action IDs)
+ *   3. Return Code
+ *   4. Optional step number for step replies
+ *
+ * Data reply (subservice 132) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ *
+ *  \date 01.07.2019
+ *  \author R. Mueller
+ */
+
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+
+#include <framework/action/ActionMessage.h>
+#include <framework/objectmanager/SystemObjectIF.h>
+#include <framework/serialize/SerialBufferAdapter.h>
+#include <framework/serialize/SerializeElement.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/serialize/SerialFixedArrayListAdapter.h>
+
+
+/**
+ * \brief Subservice 128
+ * \ingroup spacepackets
+ */
+class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	//typedef uint16_t typeOfMaxData;
+	//static const typeOfMaxData MAX_DATA = 256;
+	DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) {
+		size_t size = sizeof(objectId);
+		SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size,
+		        SerializeIF::Endianness::BIG);
+		size = sizeof(actionId);
+		SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size,
+		        SerializeIF::Endianness::BIG);
+		parameterBuffer = dataBuffer_;
+		parametersSize = size_ - sizeof(objectId) - sizeof(actionId);
+	}
+	ActionId_t getActionId() const {
+		return actionId;
+	}
+
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getParameters() {
+		return parameterBuffer;
+	}
+
+	uint32_t getParametersSize() const {
+		return parametersSize;
+	}
+
+private:
+	DirectCommand(const DirectCommand &command);
+	object_id_t objectId;
+	ActionId_t actionId;
+	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
+	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
+
+};
+
+
+/**
+ * \brief Subservice 130
+ * \ingroup spacepackets
+ */
+class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+	DataReply(object_id_t objectId_, ActionId_t actionId_,
+		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
+		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
+		setLinks();
+	}
+
+private:
+	DataReply(const DataReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&replyData);
+	}
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<ActionId_t> actionId;
+	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
+};
+
+
+/**
+ * \brief Subservice 132
+ * \ingroup spacepackets
+ */
+class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+
+	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
+			bool isStep_ = false, uint8_t step_ = 0):
+			isStep(isStep_), objectId(objectId_), actionId(actionId_),
+			returnCode(returnCode_),step(step_)  {
+		setLinks();
+	}
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&returnCode);
+		if(isStep) {
+			returnCode.setNext(&step);
+		}
+	}
+	bool isDataReply; //!< [EXPORT] : [IGNORE]
+	bool isStep; //!< [EXPORT] : [IGNORE]
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
+	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
+
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */

From 64c290ffe44ce6a4352152bcb1a04ff643bfd395 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 8 Jul 2020 18:38:58 +0200
Subject: [PATCH 0552/1292] include guard fix

---
 pus/Service8FunctionManagement.cpp | 2 +-
 pus/Service8FunctionManagement.h   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 47afeae6..24338464 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -67,7 +67,7 @@ ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 	// Create direct command instance by extracting data from Telecommand
 	DirectCommand command(tcData,tcDataLen);
 
-	// store additional parameters into the Inter Process Communication Store
+	// store additional parameters into the IPC Store
 	store_address_t parameterAddress;
 	ReturnValue_t result = IPCStore->addData(&parameterAddress,
 			command.getParameters(),command.getParametersSize());
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index e06c554c..54c98b97 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
-#define MISSION_SERVICE8FUNCTIONMANAGEMENT_H_
+#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
 #include <framework/tmtcservices/CommandingServiceBase.h>
 
@@ -61,4 +61,4 @@ private:
 			const uint8_t* tcData, size_t tcDataLen);
 };
 
-#endif /* MISSION_DEVICE2DEVICECOMMANDING_H_ */
+#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */

From ac9e6e1337acc8a5f68811be1f5da30c69a3e52e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 00:59:10 +0200
Subject: [PATCH 0553/1292] continued with local data pool manager

---
 datapoolglob/GlobalDataSet.h                  |  6 +-
 ...LocalDataPoolIF.h => HasLocalDataPoolIF.h} |  4 +-
 datapoollocal/LocalDataPoolManager.cpp        | 14 +--
 datapoollocal/LocalDataPoolManager.h          | 95 ++++++++++++++-----
 datapoollocal/LocalDataSet.cpp                |  4 +-
 datapoollocal/LocalDataSet.h                  |  4 +-
 datapoollocal/LocalPoolVariable.h             |  4 +-
 datapoollocal/LocalPoolVariable.tpp           |  6 +-
 datapoollocal/LocalPoolVector.h               |  2 +-
 datapoollocal/LocalPoolVector.tpp             |  6 +-
 devicehandlers/DeviceHandlerBase.h            |  5 +-
 11 files changed, 97 insertions(+), 53 deletions(-)
 rename datapoollocal/{OwnsLocalDataPoolIF.h => HasLocalDataPoolIF.h} (97%)

diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index 519b08c0..d237cc1b 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,5 +1,5 @@
-#ifndef DATASET_H_
-#define DATASET_H_
+#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 
 #include <framework/datapool/DataSetBase.h>
 
@@ -93,4 +93,4 @@ private:
 	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
 };
 
-#endif /* DATASET_H_ */
+#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoollocal/OwnsLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
similarity index 97%
rename from datapoollocal/OwnsLocalDataPoolIF.h
rename to datapoollocal/HasLocalDataPoolIF.h
index 6fc10889..0095f894 100644
--- a/datapoollocal/OwnsLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -36,9 +36,9 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * pragmatic solution I found was to offer the client the full interface
  * of the LocalDataPoolManager.
  */
-class OwnsLocalDataPoolIF {
+class HasLocalDataPoolIF {
 public:
-	virtual~ OwnsLocalDataPoolIF() {};
+	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 9c70c74f..02016abf 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -7,7 +7,7 @@
 
 #include <array>
 
-LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
@@ -63,7 +63,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localDpMap);
+		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -96,8 +96,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
 		lp_id_t localPoolId) {
-	auto poolIter = localDpMap.find(localPoolId);
-	if (poolIter == localDpMap.end()) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
 				" Pool entry not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
@@ -110,7 +110,7 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
@@ -213,4 +213,6 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
     return result;
 }
 
-
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3841b99c..847c309c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,12 +1,13 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
 #include <framework/datapool/DataSetIF.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/ipc/MutexIF.h>
 
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
@@ -20,7 +21,7 @@ class LocalDataSet;
  * @details
  * The actual data pool structure is a member of this class. Any class which
  * has a local data pool shall have this class as a member and implement
- * the OwnsLocalDataPoolIF.
+ * the HasLocalDataPoolIF.
  *
  * Users of the data pool use the helper classes LocalDataSet,
  * LocalPoolVariable and LocalPoolVector to access pool entries in
@@ -57,16 +58,24 @@ public:
      * @param queueToUse
      * @param appendValidityBuffer
      */
-	LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 	        bool appendValidityBuffer = true);
+	virtual~ LocalDataPoolManager();
+
 	/**
 	 * Initializes the map by calling the map initialization function of the
-	 * owner abd assigns the queue to use.
+	 * owner and assigns the queue to use.
 	 * @param queueToUse
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 	        object_id_t hkDestination);
+	/**
+	 * This should be called in the periodic handler of the owner.
+	 * It performs all the periodic functionalities of the data pool manager.
+	 * @return
+	 */
+	ReturnValue_t performHkOperation();
 	/**
 	 * This function is used to set the default HK packet destination.
 	 * This destination will usually only be set once.
@@ -74,8 +83,6 @@ public:
 	 */
 	void setHkPacketDestination(MessageQueueId_t hkDestination);
 
-	virtual~ LocalDataPoolManager();
-
 	/**
 	 * Generate a housekeeping packet with a given SID.
 	 * @param sid
@@ -95,28 +102,64 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	const OwnsLocalDataPoolIF* getOwner() const;
+	const HasLocalDataPoolIF* getOwner() const;
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC: HK packets are generated in fixed intervals
+     *  2. UPDATED: HK packets are generated if a value was updated
+     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     */
+    enum class ReportingType: uint8_t {
+        PERIODIC,
+        ON_UPDATE,
+        REQUESTED
+    };
+
     /* Copying forbidden */
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
 private:
-	/** This is the map holding the actual data. Should only be initialized
-	 * once ! */
-	bool mapInitialized = false;
-	/** This specifies whether a validity buffer is appended at the end
-	 * of generated housekeeping packets. */
-	bool appendValidityBuffer = true;
+    LocalDataPool localPoolMap;
+    /** Every housekeeping data manager has a mutex to protect access
+     * to it's data pool. */
+    MutexIF* mutex = nullptr;
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
 
-	LocalDataPool localDpMap;
+    /**
+     * The data pool manager will keep an internal map of HK receivers.
+     */
+    struct HkReceiver {
+        LocalDataSet* dataSet = nullptr;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+        ReportingType reportingType = ReportingType::PERIODIC;
+        bool reportingStatus = true;
+        /** Different members of this union will be used depending on reporting
+         * type */
+        union hkParameter {
+            /** This parameter will be used for the PERIODIC type */
+            dur_seconds_t collectionInterval = 0;
+            /** This parameter will be used for the ON_UPDATE type */
+            bool hkDataChanged;
+        };
+    };
+
+    /** Using a multimap as the same object might request multiple datasets */
+    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+
+    HkReceiversMap hkReceiversMap;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
 
-	/** Every housekeeping data manager has a mutex to protect access
-	 * to it's data pool. */
-	MutexIF * mutex = nullptr;
-	/** The class which actually owns the manager (and its datapool). */
-	OwnsLocalDataPoolIF* owner = nullptr;
 	/**
 	 * @brief Queue used for communication, for example commands.
 	 * Is also used to send messages. Can be set either in the constructor
@@ -165,10 +208,10 @@ private:
 template<class T> inline
 ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
-	auto poolIter = localDpMap.find(localPoolId);
-	if (poolIter == localDpMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
 	}
 
@@ -182,4 +225,4 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 }
 
 
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 272a1b6f..2a42cd38 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,7 +5,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
         DataSetBase(poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
@@ -23,7 +23,7 @@ LocalDataSet::LocalDataSet(object_id_t ownerId,
         DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
-    OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             ownerId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 20c647ca..2c70de82 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #include <framework/datapool/DataSetBase.h>
 #include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/serialize/SerializeIF.h>
 
 #include <vector>
@@ -37,7 +37,7 @@ public:
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
+	LocalDataSet(HasLocalDataPoolIF *hkOwner,
 	        const size_t maxNumberOfVariables);
 
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 98782b8d..73d691d7 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -3,8 +3,8 @@
 
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 
 #include <framework/serialize/SerializeAdapter.h>
@@ -42,7 +42,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVar(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
+	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7f9fbf13..0b96bb4f 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
+		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -33,8 +33,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	OwnsLocalDataPoolIF* hkOwner =
-			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index f6532894..3083646f 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -46,7 +46,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, OwnsLocalDataPoolIF* hkOwner,
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
 			DataSetIF* dataSet = nullptr);
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 872c49ec..b7f2fe19 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,7 +7,7 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		OwnsLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
+		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
 		DataSetIF* dataSet) :
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
@@ -29,8 +29,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
 	}
-	OwnsLocalDataPoolIF* hkOwner =
-			objectManager->get<OwnsLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
 				"the correct interface HasHkPoolParametersIF!" << std::endl;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3fdab9ed..ce7f7b9f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -17,10 +17,9 @@
 #include <framework/health/HealthHelper.h>
 #include <framework/parameters/ParameterHelper.h>
 #include <framework/datapool/HkSwitchHelper.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
-
 #include <map>
 
 namespace Factory{
@@ -88,7 +87,7 @@ class DeviceHandlerBase: public DeviceHandlerIF,
 		public HasHealthIF,
 		public HasActionsIF,
 		public ReceivesParameterMessagesIF,
-		public OwnsLocalDataPoolIF {
+		public HasLocalDataPoolIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	/**

From 6f50356964da86b311b9e96b08d33de6c2b76233 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 14:26:15 +0200
Subject: [PATCH 0554/1292] new shared ring buffer

---
 container/RingBufferBase.h           | 73 ++++++++++++++++------------
 container/SharedRingBuffer.cpp       | 32 ++++++++++++
 container/SharedRingBuffer.h         | 42 ++++++++++++++++
 container/SimpleRingBuffer.cpp       | 27 ++++++----
 container/SimpleRingBuffer.h         | 44 ++++++++++++-----
 devicehandlers/ChildHandlerBase.cpp  | 16 +++---
 devicehandlers/ChildHandlerBase.h    |  4 +-
 devicehandlers/DeviceHandlerBase.cpp | 38 ++++++++++-----
 devicehandlers/DeviceHandlerBase.h   | 19 ++++----
 globalfunctions/DleEncoder.cpp       |  3 +-
 timemanager/Clock.h                  |  4 +-
 11 files changed, 216 insertions(+), 86 deletions(-)
 create mode 100644 container/SharedRingBuffer.cpp
 create mode 100644 container/SharedRingBuffer.h

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 1beb51c2..86896b9e 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -7,29 +7,23 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(uint32_t startAddress, const size_t size, bool overwriteOld) :
+	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;
 		}
 	}
-	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;
-		}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
 	}
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount || overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
+	bool isEmpty(uint8_t n = 0) {
+		return (availableReadData(n) == 0);
 	}
+
 	uint32_t availableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
@@ -37,54 +31,55 @@ public:
 		//One less to avoid ambiguous full/empty problem.
 		return (((read[n] + size) - write - 1) % size);
 	}
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
-	}
-	virtual ~RingBufferBase() {
 
-	}
 	uint32_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;
 		}
 	}
+
 	uint32_t getWrite() const {
 		return write;
 	}
+
 	void setWrite(uint32_t write) {
 		this->write = write;
 	}
+
 	void clear() {
 		write = start;
 		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
 			read[count] = start;
 		}
 	}
-	uint32_t writeTillWrap() {
+
+	size_t writeTillWrap() {
 		return (start + size) - write;
 	}
-	uint32_t readTillWrap(uint8_t n = 0) {
+
+	size_t readTillWrap(uint8_t n = 0) {
 		return (start + size) - read[n];
 	}
-	uint32_t getStart() const {
+
+	size_t getStart() const {
 		return start;
 	}
+
 	bool overwritesOld() const {
 		return overwriteOld;
 	}
-	uint32_t maxSize() const {
+
+	size_t maxSize() const {
 		return size - 1;
 	}
 protected:
-	const uint32_t start;
-	uint32_t write;
-	uint32_t read[N_READ_PTRS];
+	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) {
@@ -93,6 +88,24 @@ protected:
 	void incrementRead(uint32_t amount, uint8_t n = 0) {
 		read[n] = ((read[n] + amount - start) % size) + start;
 	}
+
+	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;
+		}
+	}
+
+	ReturnValue_t writeData(uint32_t amount) {
+		if (availableWriteSpace() >= amount or overwriteOld) {
+			incrementWrite(amount);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
new file mode 100644
index 00000000..36315753
--- /dev/null
+++ b/container/SharedRingBuffer.cpp
@@ -0,0 +1,32 @@
+#include <framework/container/SharedRingBuffer.h>
+#include <framework/ipc/MutexFactory.h>
+#include <framework/ipc/MutexHelper.h>
+
+SharedRingBuffer::SharedRingBuffer(const size_t size, bool overwriteOld):
+		SimpleRingBuffer(size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld): SimpleRingBuffer(buffer, size, overwriteOld) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
+		size_t amount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return writeData(data,amount);
+}
+
+ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
+		dur_millis_t timeout, bool incrementReadPtr, bool readRemaining,
+		size_t *trueAmount) {
+	MutexHelper(mutex, timeout);
+	return readData(data,amount, incrementReadPtr, readRemaining, trueAmount);
+}
+
+ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
+		bool deleteRemaining, size_t *trueAmount, dur_millis_t timeout) {
+	MutexHelper(mutex, timeout);
+	return deleteData(amount, deleteRemaining, trueAmount);
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
new file mode 100644
index 00000000..41186619
--- /dev/null
+++ b/container/SharedRingBuffer.h
@@ -0,0 +1,42 @@
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#include <framework/container/SimpleRingBuffer.h>
+#include <framework/ipc/MutexIF.h>
+#include <framework/timemanager/Clock.h>
+
+class SharedRingBuffer: 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(const size_t size, bool overwriteOld);
+
+	/**
+	 * 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(uint8_t* buffer, const size_t size, bool overwriteOld);
+
+	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount,
+			dur_millis_t timeout = 10);
+	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
+			dur_millis_t timeout = 10, bool incrementReadPtr = false,
+			bool readRemaining = false, size_t *trueAmount = nullptr);
+	ReturnValue_t deleteDataProtected(size_t amount,
+			bool deleteRemaining = false, size_t* trueAmount = nullptr,
+			dur_millis_t timeout = 10);
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 731c9dc9..69d94143 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -16,12 +16,14 @@ SimpleRingBuffer::~SimpleRingBuffer() {
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		uint32_t amount) {
+		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
-		uint32_t amountTillWrap = writeTillWrap();
+		size_t amountTillWrap = writeTillWrap();
 		if (amountTillWrap >= amount) {
+			// remaining size in buffer is sufficient to fit full amount.
 			memcpy(&buffer[write], data, amount);
-		} else {
+		}
+		else {
 			memcpy(&buffer[write], data, amountTillWrap);
 			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
 		}
@@ -32,12 +34,13 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 	}
 }
 
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
-		bool readRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
-	uint32_t amountTillWrap = readTillWrap(READ_PTR);
+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;
@@ -52,12 +55,16 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, uint32_t amount,
 		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
 		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
 	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SimpleRingBuffer::deleteData(uint32_t amount,
-		bool deleteRemaining, uint32_t* trueAmount) {
-	uint32_t availableData = availableReadData(READ_PTR);
+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;
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 30dd184c..cf78814f 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -18,6 +18,8 @@ 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.
      */
 	SimpleRingBuffer(const size_t size, bool overwriteOld);
 	/**
@@ -25,41 +27,59 @@ public:
 	 * @param buffer
 	 * @param size
 	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
 	 */
 	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
 
 	virtual ~SimpleRingBuffer();
 
 	/**
-	 * Write to circular buffer and increment write pointer by amount
+	 * Write to circular buffer and increment write pointer by amount.
 	 * @param data
 	 * @param amount
-	 * @return
+	 * @return -@c RETURN_OK if write operation was successfull
+	 * -@c RETURN_FAILED if
 	 */
-	ReturnValue_t writeData(const uint8_t* data, uint32_t amount);
+	ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
 	/**
-	 * Read from circular buffer at read pointer
+	 * 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
-	 * @param trueAmount
+	 * 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, uint32_t amount,
-	        bool readRemaining = false, uint32_t* trueAmount = nullptr);
+	ReturnValue_t readData(uint8_t* data, size_t amount,
+			bool incrementReadPtr = false, bool readRemaining = false,
+			size_t* trueAmount = nullptr);
 
 	/**
-	 * Delete data starting by incrementing read pointer
+	 * Delete data by incrementing read pointer.
 	 * @param amount
 	 * @param deleteRemaining
-	 * @param trueAmount
+	 * 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(uint32_t amount, bool deleteRemaining = false,
-	        uint32_t* trueAmount = nullptr);
+	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+	        size_t* trueAmount = nullptr);
 private:
-//	static const uint8_t TEMP_READ_PTR = 1;
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
 };
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 3e5bcc60..9e5019b4 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -4,15 +4,19 @@
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
-		uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId, uint32_t parent,
+		uint8_t setDeviceSwitch, object_id_t hkDestination,
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t parent,
 		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-		    hkDestination, setDeviceSwitch,  thermalStatePoolId,
-			thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setDeviceSwitch(setDeviceSwitch);
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
 }
 
 ChildHandlerBase::~ChildHandlerBase() {
@@ -26,7 +30,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 
 	MessageQueueId_t parentQueue = 0;
 
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
 		if (parent == NULL) {
 			return RETURN_FAILED;
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 10021631..5c216e86 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -7,9 +7,9 @@
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
+			CookieIF * cookie, uint8_t setDeviceSwitch,
 			object_id_t hkDestination, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, uint32_t parent,
+			uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index fcb61ace..08d92130 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -18,43 +18,55 @@
 
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
+object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		uint8_t setDeviceSwitch, object_id_t hkDestination,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+		FailureIsolationBase* fdirInstance,
+		size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
 		actionHelper(this, nullptr), hkManager(this, nullptr),
-		deviceThermalStatePoolId(thermalStatePoolId),
-		deviceThermalRequestPoolId(thermalRequestPoolId),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), hkDestination(hkDestination),
 		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
+		transitionSourceSubMode(SUBMODE_NONE) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 	insertInCommandMap(RAW_COMMAND_ID);
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex <<
-				std::setw(8) << std::setfill('0') << this->getObjectId() <<
-				std::dec << ": Do not pass nullptr as a cookie, consider "
-				<< std::setfill(' ') << "passing a dummy cookie instead!" <<
-				std::endl;
+		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << this->getObjectId()
+				<< std::dec << ": Do not pass nullptr as a cookie, consider "
+				<< std::setfill(' ') << "passing a dummy cookie instead!"
+				<< std::endl;
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFDIRParentId);
+				defaultFdirParentId);
 	}
 }
 
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
+void DeviceHandlerBase::setThermalStateRequestPoolIds(
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+	this->deviceThermalRequestPoolId = thermalStatePoolId;
+	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+}
+
+
+void DeviceHandlerBase::setDeviceSwitch(uint8_t deviceSwitch) {
+	this->deviceSwitch = deviceSwitch;
+}
+
 DeviceHandlerBase::~DeviceHandlerBase() {
 	delete comCookie;
 	if (defaultFDIRUsed) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3fdab9ed..2adaa80e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -106,13 +106,14 @@ public:
 	 * @param cmdQueueSize
 	 */
 	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, uint8_t setDeviceSwitch,
-			object_id_t hkDestination = objects::NO_OBJECT,
-			uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
-			uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
-			FailureIsolationBase* fdirInstance = nullptr,
+			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
+	void setDeviceSwitch(uint8_t deviceSwitch);
+	void setHkDestination(object_id_t hkDestination);
+	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId);
+
 	/**
 	 * @brief 	This function is the device handler base core component and is
 	 * 			called periodically.
@@ -691,14 +692,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalStatePoolId;
+	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
 	 * this is the datapool variable with the thermal request of the device
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalRequestPoolId;
+	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
 	 * Optional Error code
@@ -724,7 +725,7 @@ protected:
 
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
-	static object_id_t defaultFDIRParentId; //!< Object which may be the root cause of an identified fault.
+	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
 	/**
 	 * Helper function to report a missed reply
 	 *
@@ -1082,7 +1083,7 @@ private:
 	 *
 	 * for devices using two switches override getSwitches()
 	 */
-	const uint8_t deviceSwitch;
+	uint8_t deviceSwitch;
 
 	/**
 	 * read the command queue
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index c8f78872..f4bd765d 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -81,8 +81,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
 			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX))
-	{
+			&& (sourceStream[encodedIndex] != STX)) {
 		if (sourceStream[encodedIndex] == DLE) {
 			nextByte = sourceStream[encodedIndex + 1];
 			// The next byte is a DLE character that was escaped by another
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 121c63df..65e152bf 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,8 +9,8 @@
 #include <sys/time.h>
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
-typedef uint32_t dur_millis_t;
-typedef double dur_seconds_t;
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
 
 class Clock {
 public:

From ecd740a1015f47d60ec73b48d54f632dc6aa38bd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 15:47:50 +0200
Subject: [PATCH 0555/1292] ring buffer base calls made protected

---
 container/RingBufferBase.h     | 48 ++++++++++++++++++----------------
 container/SharedRingBuffer.cpp | 36 ++++++++++++++++---------
 container/SharedRingBuffer.h   | 28 ++++++++++++++------
 3 files changed, 68 insertions(+), 44 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 86896b9e..f42a4288 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -24,30 +24,20 @@ public:
 		return (availableReadData(n) == 0);
 	}
 
-	uint32_t availableReadData(uint8_t n = 0) const {
+	size_t availableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
-	uint32_t availableWriteSpace(uint8_t n = 0) const  {
+	size_t availableWriteSpace(uint8_t n = 0) const  {
 		//One less to avoid ambiguous full/empty problem.
 		return (((read[n] + size) - write - 1) % size);
 	}
 
-	uint32_t getRead(uint8_t n = 0) const {
-		return read[n];
+	bool overwritesOld() const {
+		return overwriteOld;
 	}
 
-	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;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
+	size_t maxSize() const {
+		return size - 1;
 	}
 
 	void clear() {
@@ -69,13 +59,6 @@ public:
 		return start;
 	}
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t maxSize() const {
-		return size - 1;
-	}
 protected:
 	const size_t start;
 	size_t write;
@@ -106,6 +89,25 @@ protected:
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
+
+
+	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;
+		}
+	}
+
+	uint32_t getWrite() const {
+		return write;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
 };
 
 #endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 36315753..64cbc669 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -2,31 +2,41 @@
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 
-SharedRingBuffer::SharedRingBuffer(const size_t size, bool overwriteOld):
-		SimpleRingBuffer(size, overwriteOld) {
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		bool overwriteOld, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld),
+		mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
-SharedRingBuffer::SharedRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld): SimpleRingBuffer(buffer, size, overwriteOld) {
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
+		const size_t size, bool overwriteOld, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld),
+		mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
-		size_t amount, dur_millis_t timeout) {
-	MutexHelper(mutex, timeout);
-	return writeData(data,amount);
+		size_t amount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::writeData(data,amount);
 }
 
 ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
-		dur_millis_t timeout, bool incrementReadPtr, bool readRemaining,
+		bool incrementReadPtr, bool readRemaining,
 		size_t *trueAmount) {
-	MutexHelper(mutex, timeout);
-	return readData(data,amount, incrementReadPtr, readRemaining, trueAmount);
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
+			readRemaining, trueAmount);
 }
 
 ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount, dur_millis_t timeout) {
-	MutexHelper(mutex, timeout);
-	return deleteData(amount, deleteRemaining, trueAmount);
+		bool deleteRemaining, size_t *trueAmount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
+}
+
+size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
+	MutexHelper(mutex, mutexTimeout);
+	return ((write + size) - read[n]) % size;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 41186619..e045b72a 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -2,9 +2,11 @@
 #define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
 #include <framework/container/SimpleRingBuffer.h>
 #include <framework/ipc/MutexIF.h>
+#include <framework/objectmanager/SystemObject.h>
 #include <framework/timemanager/Clock.h>
 
-class SharedRingBuffer: public SimpleRingBuffer {
+class SharedRingBuffer: public SystemObject,
+		public SimpleRingBuffer {
 public:
 	/**
 	 * This constructor allocates a new internal buffer with the supplied size.
@@ -13,7 +15,8 @@ public:
 	 * If the ring buffer is overflowing at a write operartion, the oldest data
 	 * will be overwritten.
 	 */
-	SharedRingBuffer(const size_t size, bool overwriteOld);
+	SharedRingBuffer(object_id_t objectId, const size_t size,
+			bool overwriteOld, dur_millis_t mutexTimeout = 10);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -23,17 +26,26 @@ public:
 	 * If the ring buffer is overflowing at a write operartion, the oldest data
 	 * will be overwritten.
 	 */
-	SharedRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld);
+	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+			bool overwriteOld, dur_millis_t mutexTimeout = 10);
 
-	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount,
-			dur_millis_t timeout = 10);
+	void setMutexTimeout(dur_millis_t newTimeout);
+
+	/** Performs mutex protected SimpleRingBuffer::writeData call */
+	ReturnValue_t writeDataProtected(const uint8_t* data, size_t amount);
+
+	/** Performs mutex protected SimpleRingBuffer::readData call */
 	ReturnValue_t readDataProtected(uint8_t *data, size_t amount,
-			dur_millis_t timeout = 10, bool incrementReadPtr = false,
+			bool incrementReadPtr = false,
 			bool readRemaining = false, size_t *trueAmount = nullptr);
+
+	/** Performs mutex protected SimpleRingBuffer::deleteData call */
 	ReturnValue_t deleteDataProtected(size_t amount,
-			bool deleteRemaining = false, size_t* trueAmount = nullptr,
-			dur_millis_t timeout = 10);
+			bool deleteRemaining = false, size_t* trueAmount = nullptr);
+
+	size_t getAvailableReadDataProtected (uint8_t n = 0) const;
 private:
+	dur_millis_t mutexTimeout;
 	MutexIF* mutex = nullptr;
 };
 

From 32ef807341f2b868af94a11507db532990a4c771 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 15:49:52 +0200
Subject: [PATCH 0556/1292] newline

---
 container/SharedRingBuffer.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index e045b72a..f7d3bc3c 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
 #define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
 #include <framework/container/SimpleRingBuffer.h>
 #include <framework/ipc/MutexIF.h>
 #include <framework/objectmanager/SystemObject.h>

From 5a351474d2de7e2b38c2ccf232f1a9ba6241bf10 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:31:33 +0200
Subject: [PATCH 0557/1292] DHB ctor simplified

---
 datapoollocal/LocalDataPoolManager.h |  1 +
 devicehandlers/DeviceHandlerBase.cpp | 12 ++++++++----
 devicehandlers/DeviceHandlerBase.h   |  1 +
 fdir/FailureIsolationBase.cpp        | 11 ++++++++---
 fdir/FailureIsolationBase.h          |  7 +++++--
 tcdistribution/PUSDistributor.cpp    |  2 +-
 6 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3841b99c..d5cfb1a3 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -67,6 +67,7 @@ public:
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 	        object_id_t hkDestination);
+
 	/**
 	 * This function is used to set the default HK packet destination.
 	 * This destination will usually only be set once.
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 08d92130..48d366b6 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -19,11 +19,11 @@
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
-		FailureIsolationBase* fdirInstance,
-		size_t cmdQueueSize) :
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
 		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
@@ -31,8 +31,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		actionHelper(this, nullptr), hkManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), hkDestination(hkDestination),
-		childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
+		switchOffWasReported(false), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN),
 		transitionSourceSubMode(SUBMODE_NONE) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
@@ -189,6 +189,10 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
 	result = hkManager.initialize(commandQueue, hkDestination);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2adaa80e..52349656 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1048,6 +1048,7 @@ private:
 	PowerSwitchIF *powerSwitcher = nullptr;
 
 	/** Cached for initialize() */
+	static object_id_t defaultHkDestination;
 	object_id_t hkDestination = objects::NO_OBJECT;
 
 	/**
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index a2fc9ea1..8bc88002 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (ownerId != 0) {
+	if (faultTreeParent != objects::NO_OBJECT) {
 		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -41,10 +41,15 @@ ReturnValue_t FailureIsolationBase::initialize() {
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
-	if (faultTreeParent != 0) {
+	if (faultTreeParent != objects::NO_OBJECT) {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
-		if (parentIF == NULL) {
+		if (parentIF == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Parent object"
+					<< "invalid." << std::endl;
+			sif::error << "Make sure it implements ConfirmsFailuresIF."
+					<< std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 			return RETURN_FAILED;
 		}
 		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 894f6356..dea149bd 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -17,8 +17,11 @@ public:
 	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
 	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
 	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
-	FailureIsolationBase(object_id_t owner, object_id_t parent = 0,
+
+	FailureIsolationBase(object_id_t owner,
+			object_id_t parent = objects::NO_OBJECT,
 			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
+
 	virtual ~FailureIsolationBase();
 	virtual ReturnValue_t initialize();
 
@@ -26,7 +29,7 @@ public:
 	 * This is called by the DHB in performOperation()
 	 */
 	void checkForFailures();
-	MessageQueueId_t getEventReceptionQueue();
+	MessageQueueId_t getEventReceptionQueue() override;
 	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);
 protected:
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 969380d6..5eb50103 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -50,7 +50,7 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	if (not returnPair.second) {
 		//TODO Return Code
 		sif::error << "PUSDistributor::registerService: Service ID already"
-				"exists in map." << std::endl;
+				" exists in map." << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;

From a5d3d9ea8030d5f14a7c584641b68a5bf4f21d58 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:46:57 +0200
Subject: [PATCH 0558/1292] improved init function

---
 devicehandlers/DeviceHandlerBase.cpp | 38 ++++++++++++++++++----------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 48d366b6..b47c58fc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -122,8 +122,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
-	if (communicationInterface == NULL) {
-		return RETURN_FAILED;
+	if (communicationInterface == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: Communication interface "
+				"invalid." << std::endl;
+		sif::error << "Make sure it is set up properly and implements"
+				" DeviceCommunicationIF" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
@@ -132,8 +136,10 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
+	if (IPCStore == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
+				"factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	if(rawDataReceiverId != objects::NO_OBJECT) {
@@ -152,8 +158,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-		if (powerSwitcher == NULL) {
-			return RETURN_FAILED;
+		if (powerSwitcher == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Power switcher "
+					<< "object ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					<< " and implements PowerSwitchIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
 
@@ -189,14 +199,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+//	if(hkDestination == objects::NO_OBJECT) {
+//		hkDestination = defaultHkDestination;
+//	}
+//
+//	result = hkManager.initialize(commandQueue, hkDestination);
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		return result;
+//	}
 
 	fillCommandAndReplyMap();
 

From da30680d04bffca3ebd17a446fc7cad765a6770f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 16:54:18 +0200
Subject: [PATCH 0559/1292] readability improvement

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b47c58fc..4358503e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -228,7 +228,7 @@ void DeviceHandlerBase::decrementDeviceReplyMap() {
 		if (iter->second.delayCycles != 0) {
 			iter->second.delayCycles--;
 			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic != 0) {
+				if (iter->second.periodic) {
 					iter->second.delayCycles = iter->second.maxDelayCycles;
 				}
 				replyToReply(iter, TIMEOUT);

From ceb61979048feb501a31530ac363aaf53c6b5e43 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 17:01:12 +0200
Subject: [PATCH 0560/1292] some minor improvements

---
 devicehandlers/DeviceHandlerBase.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b60acd52..3c5edf55 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -386,7 +386,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -400,7 +400,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = 0);
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -426,7 +426,7 @@ protected:
 	 */
 	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
 			uint16_t delayCycles, uint16_t maxDelayCycles,
-			bool periodic = 0);
+			bool periodic = false);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -1214,5 +1214,5 @@ private:
 	            size_t receivedDataLen);
 };
 
-#endif /* DEVICEHANDLERBASE_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
 

From ad049cc634b1c0aa9b0505bc4de42cb6a89a6679 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 19:41:52 +0200
Subject: [PATCH 0561/1292] tmtc bridge formatting improvements

---
 tmtcservices/TmTcBridge.cpp | 27 +++++++++++++++------------
 tmtcservices/TmTcBridge.h   | 11 +++++++----
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c44f7de..b55803cb 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -24,8 +24,9 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-	    sif::warning << "TmTcBridge: Number of packets sent per cycle "
-	               "exceeds limits. Keeping default value." << std::endl;
+	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
+	             << "packets sent per cycle exceeds limits. "
+	             << "Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
 }
@@ -37,8 +38,9 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-        sif::warning << "TmTcBridge: Number of packets stored "
-                   "exceeds limits. Keeping default value." << std::endl;
+        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
+                << "packets stored exceeds limits. "
+                << "Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
 }
@@ -72,11 +74,13 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TCs" << std::endl;
+		sif::debug << "TmTcBridge::performOperation: "
+		        << "Error handling TCs" << std::endl;
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TMs" << std::endl;
+	    sif::debug << "TmTcBridge::performOperation: "
+	                    << "Error handling TMs" << std::endl;
 	}
 	return result;
 }
@@ -88,7 +92,7 @@ ReturnValue_t TmTcBridge::handleTc() {
 ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
 		return RETURN_FAILED;
 	}
 
@@ -118,7 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl;
+			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 
@@ -129,13 +133,12 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 }
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	//debug << "TMTC Bridge: Comm Link down. "
-	//		 "Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId = 0;
 
 	if(tmFifo.full()) {
-		sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
-				 "reached! Overwriting old data" << std::endl;
+		sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+		        << "of stored packet IDs reached! "
+		        << "Overwriting old data" << std::endl;
 		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
 	}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e3d1b71..993cd5b9 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -76,13 +76,14 @@ protected:
 	object_id_t tcDestination = objects::NO_OBJECT;
 
 	//! Used to send and receive TMTC messages.
-	//! TmTcMessage is used to transport messages between tasks.
+	//! The TmTcMessage class is used to transport messages between tasks.
 	MessageQueueIF* tmTcReceptionQueue = nullptr;
 
 	StorageManagerIF* tmStore = nullptr;
 	StorageManagerIF* tcStore = nullptr;
 
-	//! Used to specify whether communication link is up by default.
+	//! Used to specify whether communication link is up. Will be true
+	//! by default, so telemetry will be handled immediately.
 	bool communicationLinkUp = true;
 	bool tmStored = false;
 
@@ -103,7 +104,8 @@ protected:
 	virtual ReturnValue_t handleTm();
 
 	/**
-	 * Read the TM Queue and send TM if necessary. Default implementation provided
+	 * Read the TM Queue and send TM if necessary.
+	 * Default implementation provided
 	 * @return
 	 */
 	virtual ReturnValue_t handleTmQueue();
@@ -116,7 +118,8 @@ protected:
 
 	/**
 	 * Implemented by child class. Perform sending of Telemetry by implementing
-	 * communication drivers or wrappers, e.g. UART communication or lwIP stack.
+	 * communication drivers or wrappers, e.g. serial communication or a socket
+	 * call.
 	 * @param data
 	 * @param dataLen
 	 * @return

From 57418eb877888bed655eb8f3fee2d58b6f4cbe82 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 20:04:49 +0200
Subject: [PATCH 0562/1292] distrinction between default settings

and individual settings for service
---
 devicehandlers/DeviceHandlerBase.h     |  1 +
 tmtcservices/CommandingServiceBase.cpp | 12 ++++++++++--
 tmtcservices/CommandingServiceBase.h   |  6 ++++--
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 3c5edf55..61fb701d 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1048,6 +1048,7 @@ private:
 
 	/** Cached for initialize() */
 	static object_id_t defaultHkDestination;
+	/** HK destination can also be set individually */
 	object_id_t hkDestination = objects::NO_OBJECT;
 
 	/**
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 63a3d943..4c9b5375 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -8,8 +8,8 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcpacket/pus/TmPacketStored.h>
 
-object_id_t CommandingServiceBase::packetSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::packetDestination = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
 
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
@@ -62,10 +62,18 @@ ReturnValue_t CommandingServiceBase::initialize() {
 		return result;
 	}
 
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
 	AcceptsTelemetryIF* packetForwarding =
 			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
+
 	if (packetForwarding == nullptr or distributor == nullptr) {
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index e9b5f047..ec38bdee 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -248,8 +248,10 @@ protected:
 	uint32_t failureParameter1 = 0;
 	uint32_t failureParameter2 = 0;
 
-	static object_id_t packetSource;
-	static object_id_t packetDestination;
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
 
 	/**
 	 * Pointer to the task which executes this component,

From cdd877032fe211cd6e9e56940352f608b7e90efb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 23:20:48 +0200
Subject: [PATCH 0563/1292] doc for system object IF improved

---
 objectmanager/SystemObjectIF.h | 56 ++++++++++++++++------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 7540f80f..b7590509 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,26 +1,19 @@
-/**
- * @file	SystemObjectIF.h
- * @brief	This file contains the definition of the SystemObjectIF interface.
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef SYSTEMOBJECTIF_H_
-#define SYSTEMOBJECTIF_H_
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
 
 #include <framework/events/EventReportingProxyIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
+#include <cstdint>
 /**
- * \defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are contained in this group.
- * System Objects are software elements that can be controlled externally. They all have a unique
- * object identifier.
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
  */
 
 /**
  * This is the typedef for object identifiers.
- * \ingroup system_objects
+ * @ingroup system_objects
  */
 typedef uint32_t object_id_t;
 
@@ -29,7 +22,8 @@ typedef uint32_t object_id_t;
  * list.
  * It does not provide any method definitions, still it is required to
  * perform a type check with dynamic_cast.
- * \ingroup system_objects
+ * @author  Bastian Baetz
+ * @ingroup system_objects
  */
 class SystemObjectIF : public EventReportingProxyIF {
 public:
@@ -41,24 +35,28 @@ public:
 	/**
 	 * The empty virtual destructor as required for C++ interfaces.
 	 */
-	virtual ~SystemObjectIF() {
-	}
+	virtual ~SystemObjectIF() {}
 	/**
-	 * Initializes all inter-object dependencies.
-	 * This is necessary to avoid circular dependencies of not-fully
-	 * initialized objects on start up.
-	 * @return	- \c RETURN_OK in case the initialization was successful
-	 * 			- \c RETURN_FAILED otherwise
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
 	 */
 	virtual ReturnValue_t initialize() = 0;
 	/**
-	 * Checks, if all object-object interconnections are satisfying for operation.
-	 * Some objects need certain other objects (or a certain number), to be registered as children.
-	 * These checks can be done in this method.
-	 * @return	- \c RETURN_OK in case the check was successful
-	 * 			- \c any other code otherwise
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
 	 */
 	virtual ReturnValue_t checkObjectConnections() = 0;
 };
 
-#endif /* SYSTEMOBJECTIF_H_ */
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */

From 1fde3c2c992f3fd96cd0098bfb23c5ab6fa51589 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 00:19:25 +0200
Subject: [PATCH 0564/1292] added srv200, CSB doc

---
 pus/CService200ModeCommanding.cpp      | 133 +++++++++++++++++++++++++
 pus/CService200ModeCommanding.h        |  85 ++++++++++++++++
 pus/servicepackets/Service200Packets.h |  56 +++++++++++
 tmtcpacket/pus/TmPacketStored.cpp      |   1 +
 tmtcservices/CommandingServiceBase.h   |  23 +++--
 5 files changed, 290 insertions(+), 8 deletions(-)
 create mode 100644 pus/CService200ModeCommanding.cpp
 create mode 100644 pus/CService200ModeCommanding.h
 create mode 100644 pus/servicepackets/Service200Packets.h

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
new file mode 100644
index 00000000..753ec38b
--- /dev/null
+++ b/pus/CService200ModeCommanding.cpp
@@ -0,0 +1,133 @@
+#include <framework/pus/CService200ModeCommanding.h>
+#include <framework/pus/servicepackets/Service200Packets.h>
+
+#include <framework/modes/HasModesIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/modes/ModeMessage.h>
+
+CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+        CommandingServiceBase(objectId, apid, serviceId,
+	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+
+CService200ModeCommanding::~CService200ModeCommanding() {}
+
+ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_MODE_COMMAND):
+	case(Subservice::COMMAND_MODE_READ):
+	case(Subservice::COMMAND_MODE_ANNCOUNCE):
+		return RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId)
+{
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, uint32_t tcDataLen) {
+	size_t size = tcDataLen;
+	if (SerializeAdapter::deSerialize(objectIdToSet, &tcData, &size,
+	        SerializeIF::Endianness::BIG)
+			!= HasReturnvaluesIF::RETURN_OK)
+		return CommandingServiceBase::INVALID_TC;
+	else
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* MessageQueueToSet, object_id_t* objectId) {
+	HasModesIF * possibleTarget = objectManager->get<HasModesIF>(*objectId);
+	if(possibleTarget!=NULL){
+		*MessageQueueToSet = possibleTarget->getCommandQueue();
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::prepareCommand(
+		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	ModePacket modeCommandPacket;
+	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	else {
+		ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+				ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+				modeCommandPacket.getSubmode());
+		return result;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch(replyId) {
+	case(ModeMessage::REPLY_MODE_REPLY): {
+		result = prepareModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
+		result = prepareWrongModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_CANT_REACH_MODE): {
+		result = prepareCantReachModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_MODE_INFO):
+		result = INVALID_REPLY;
+		break;
+	default:
+		result = RETURN_FAILED;
+	}
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::prepareModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket modeReplyPacket(objectId,
+			ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	CantReachModePacket cantReachModePacket(objectId,
+	        ModeMessage::getCantReachModeReason(reply));
+	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	        &cantReachModePacket);
+}
+
+
+
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
new file mode 100644
index 00000000..ede61a84
--- /dev/null
+++ b/pus/CService200ModeCommanding.h
@@ -0,0 +1,85 @@
+#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+
+#include <framework/tmtcservices/CommandingServiceBase.h>
+
+/**
+ * @brief Custom PUS service to set mode of all objects implementing HasModesIF
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * @ingroup pus_services
+ */
+class CService200ModeCommanding: public CommandingServiceBase {
+public:
+	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService200ModeCommanding(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId);
+	virtual~ CService200ModeCommanding();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, uint32_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+
+	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
+		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
+		COMMAND_MODE_COMMAND = 1,
+		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
+		//! regardless of external control flag
+		COMMAND_MODE_COMMAND_FORCED = 2,
+		//!< [EXPORT] : [COMMAND] Read the current mode and
+		//! reply with a REPLY_MODE_REPLY
+		COMMAND_MODE_READ = 3,
+		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
+		//! This command does NOT have a reply
+		COMMAND_MODE_ANNCOUNCE = 4,
+		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
+		//! command to every child. This command does NOT have a reply.
+		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+		REPLY_MODE_REPLY = 6,
+		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
+		REPLY_CANT_REACH_MODE = 7,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
+		//! mode was commanded and a transition started but was aborted,
+		//! the parameters contain the mode that was reached
+		REPLY_WRONG_MODE_REPLY = 8
+	};
+
+	enum modeParameters {
+		MODE_OFF = 0,
+		MODE_ON = 1,
+		MODE_NORMAL = 2,
+		MODE_RAW = 3
+	};
+};
+
+#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
new file mode 100644
index 00000000..fb153e21
--- /dev/null
+++ b/pus/servicepackets/Service200Packets.h
@@ -0,0 +1,56 @@
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/modes/ModeMessage.h>
+#include <framework/serialize/SerializeIF.h>
+
+/**
+ * @brief Subservice 1, 2, 3, 4, 5
+ * @ingroup spacepackets
+ */
+class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
+public:
+	ModePacket() {
+		setLinks();
+	}
+
+	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
+	        objectId(objectId), mode(mode), submode(submode) {
+		setLinks();
+	}
+
+	Mode_t getMode() {
+		return mode.entry;
+	}
+
+	Submode_t getSubmode() {
+		return submode.entry;
+	}
+
+private:
+	// Forbid copying because of next pointer to member
+	ModePacket(const ModePacket &command);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&mode);
+		mode.setNext(&submode);
+	}
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
+	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
+	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
+};
+
+class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
+public:
+    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
+            objectId(objectId), reason(reason) {
+        setStart(&this->objectId);
+        this->objectId.setNext(&this->reason);
+    }
+
+    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
+	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index d6a4a69f..6eb852f0 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -34,6 +34,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
+// todo: Endianness flags as optional parameter?
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
 		SerializeIF *header) :
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index ec38bdee..1bd18571 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -114,16 +114,17 @@ public:
 	 * 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
+	 * @param task Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_);
+	virtual void setTaskIF(PeriodicTaskIF* task);
 
 protected:
 	/**
 	 * Check the target subservice
 	 * @param subservice[in]
-	 * @return -@c RETURN_OK on success
-     *         -@c INVALID_SUBSERVICE if service is not known
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
 	 */
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
 
@@ -136,9 +137,10 @@ protected:
 	 * @param tcDataLen
 	 * @param id MessageQueue ID is stored here
 	 * @param objectId Object ID is extracted and stored here
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED
-	 *         - @c CSB or implementation specific return codes
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
 	 */
 	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
 			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
@@ -157,6 +159,11 @@ protected:
 	 * communication
 	 * @param objectId Target object ID
 	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage* message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
@@ -181,7 +188,7 @@ protected:
 	 * @return
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
-	 * - @c INVALID_REPLY calls handleUnrequestedReply
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
 	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
 	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
 	 *   a failure verification message with the reason as the error parameter

From 7a4cc1a6b692b39c596bb88e67051af69b97f928 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 01:22:23 +0200
Subject: [PATCH 0565/1292] hk manager initialized now

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4358503e..c696e4e3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -199,14 +199,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-//	if(hkDestination == objects::NO_OBJECT) {
-//		hkDestination = defaultHkDestination;
-//	}
-//
-//	result = hkManager.initialize(commandQueue, hkDestination);
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		return result;
-//	}
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
+	result = hkManager.initialize(commandQueue, hkDestination);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
 	fillCommandAndReplyMap();
 

From f3739fd213acd0849399fa4b755ffa7a126da6ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 02:44:58 +0200
Subject: [PATCH 0566/1292] bugfix failure isolation base

---
 fdir/FailureIsolationBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 8bc88002..083f5af0 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -29,7 +29,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	if (faultTreeParent != objects::NO_OBJECT) {
+	if (ownerId != objects::NO_OBJECT) {
 		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;

From 3551a767a71635c47af18df4b5afbc393416838e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:06:18 +0200
Subject: [PATCH 0567/1292] removed old code

---
 devicehandlers/DeviceHandlerBase.cpp | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c696e4e3..06fb84cc 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -348,7 +348,7 @@ void DeviceHandlerBase::doStateMachine() {
 
 		if(powerSwitcher == nullptr) {
 		    setMode(MODE_OFF);
-		    return;
+		    break;
 		}
 
 		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
@@ -832,21 +832,6 @@ MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
 	return commandQueue->getId();
 }
 
-//ReturnValue_t DeviceHandlerBase::switchCookieChannel(object_id_t newChannelId) {
-//	DeviceCommunicationIF *newCommunication = objectManager->get<
-//			DeviceCommunicationIF>(newChannelId);
-//
-//	if (newCommunication != NULL) {
-//		ReturnValue_t result = newCommunication->reOpen(cookie, ioBoardAddress,
-//				maxDeviceReplyLen);
-//		if (result != RETURN_OK) {
-//			return result;
-//		}
-//		return RETURN_OK;
-//	}
-//	return RETURN_FAILED;
-//}
-
 void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
 	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
 	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,

From bdc6e881986e9048eac100561ac0e0159b1b0eca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:09:32 +0200
Subject: [PATCH 0568/1292] reordered includes

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 06fb84cc..af98ba44 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,10 +1,10 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/objectmanager/ObjectManager.h>
 #include <framework/storagemanager/StorageManagerIF.h>
 #include <framework/thermal/ThermalComponentIF.h>
 #include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
 
+#include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/datapoolglob/GlobalPoolVariable.h>
 #include <framework/devicehandlers/DeviceTmReportingWrapper.h>
 #include <framework/globalfunctions/CRC.h>

From 9cbc1a18b8c305c095f1c70ada691541e1df6bd1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:16:08 +0200
Subject: [PATCH 0569/1292] csrv200 improvements

---
 pus/CService200ModeCommanding.cpp | 56 ++++++++++++-------------------
 storagemanager/StorageAccessor.h  |  5 +++
 2 files changed, 26 insertions(+), 35 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index 753ec38b..fd6da67e 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -27,36 +27,26 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
 
 ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
 		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId)
-{
-	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
-}
+		MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
 
-ReturnValue_t CService200ModeCommanding::checkAndAcquireTargetID(
-		object_id_t* objectIdToSet, const uint8_t* tcData, uint32_t tcDataLen) {
-	size_t size = tcDataLen;
-	if (SerializeAdapter::deSerialize(objectIdToSet, &tcData, &size,
-	        SerializeIF::Endianness::BIG)
-			!= HasReturnvaluesIF::RETURN_OK)
-		return CommandingServiceBase::INVALID_TC;
-	else
-		return HasReturnvaluesIF::RETURN_OK;
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* MessageQueueToSet, object_id_t* objectId) {
-	HasModesIF * possibleTarget = objectManager->get<HasModesIF>(*objectId);
-	if(possibleTarget!=NULL){
-		*MessageQueueToSet = possibleTarget->getCommandQueue();
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -69,12 +59,11 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(
 	if (result != RETURN_OK) {
 		return result;
 	}
-	else {
-		ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-				ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-				modeCommandPacket.getSubmode());
-		return result;
-	}
+
+	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+	        modeCommandPacket.getSubmode());
+	return result;
 }
 
 
@@ -128,6 +117,3 @@ ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
 	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
 	        &cantReachModePacket);
 }
-
-
-
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index c5e38306..4b3f1ea9 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -25,8 +25,13 @@ public:
 	 * @param
 	 * @return
 	 */
+<<<<<<< Updated upstream
 	StorageAccessor& operator= (StorageAccessor&&);
 	StorageAccessor (StorageAccessor&&);
+=======
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+>>>>>>> Stashed changes
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From be8913efeaada850906e19f2d40b6e503b7ec270 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 03:30:52 +0200
Subject: [PATCH 0570/1292] srv8 improvements

---
 pus/Service5EventReporting.cpp     |  3 +--
 pus/Service8FunctionManagement.cpp | 42 +++++++++++++++++-------------
 pus/Service8FunctionManagement.h   |  3 +++
 storagemanager/StorageAccessor.h   | 12 +++------
 4 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index fe55059c..1dfbe229 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -59,8 +59,7 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 }
 
 ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice)
-	{
+	switch(subservice) {
 	case Subservice::ENABLE: {
 		enableEventReport = true;
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 24338464..812398b9 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,7 +1,6 @@
 #include <framework/pus/Service8FunctionManagement.h>
 #include <framework/pus/servicepackets/Service8Packets.h>
 
-#include <framework/action/ActionMessage.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/action/HasActionsIF.h>
 #include <framework/devicehandlers/DeviceHandlerIF.h>
@@ -54,12 +53,8 @@ ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t Service8FunctionManagement::prepareCommand(
 		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
 		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	if(subservice == static_cast<uint8_t>(Subservice::DIRECT_COMMANDING)) {
-		result = prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
 				tcData, tcDataLen);
-	}
-	return result;
 }
 
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
@@ -100,18 +95,7 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 		break;
 	}
 	case ActionMessage::DATA_REPLY: {
-		store_address_t storeId = ActionMessage::getStoreId(reply);
-		size_t size = 0;
-		const uint8_t * buffer = nullptr;
-		result = IPCStore->getData(storeId, &buffer, &size);
-		if(result != RETURN_OK) {
-			sif::error << "Service 8: Could not retrieve data for data reply";
-			return result;
-		}
-		DataReply dataReply(objectId,actionId,buffer,size);
-		sendTmPacket(static_cast<uint8_t>(
-				Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
-		result = IPCStore ->deleteData(storeId);
+	    result = handleDataReply(reply, objectId, actionId);
 		break;
 	}
 	case ActionMessage::STEP_FAILED:
@@ -126,4 +110,26 @@ ReturnValue_t Service8FunctionManagement::handleReply(
 	return result;
 }
 
+ReturnValue_t Service8FunctionManagement::handleDataReply(
+        const CommandMessage* reply, object_id_t objectId,
+        ActionId_t actionId) {
+    store_address_t storeId = ActionMessage::getStoreId(reply);
+    size_t size = 0;
+    const uint8_t * buffer = nullptr;
+    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
+    if(result != RETURN_OK) {
+        sif::error << "Service 8: Could not retrieve data for data reply"
+                << std::endl;
+        return result;
+    }
+    DataReply dataReply(objectId, actionId, buffer, size);
+    result = sendTmPacket(static_cast<uint8_t>(
+            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
 
+    auto deletionResult = IPCStore->deleteData(storeId);
+    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
+                << " of data in pool failed." << std::endl;
+    }
+    return result;
+}
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 54c98b97..e2c7a84f 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
+#include <framework/action/ActionMessage.h>
 #include <framework/tmtcservices/CommandingServiceBase.h>
 
 /**
@@ -59,6 +60,8 @@ private:
 	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 	ReturnValue_t prepareDirectCommand(CommandMessage* message,
 			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t handleDataReply(const CommandMessage* reply,
+	        object_id_t objectId, ActionId_t actionId);
 };
 
 #endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 4b3f1ea9..d75e06ac 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -17,21 +17,17 @@ class StorageAccessor: public ConstStorageAccessor {
 public:
 	StorageAccessor(store_address_t storeId);
 	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
 	/**
 	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 			 move-constructors-and-move-assignment-operators-cpp.md
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
 	 * @param
 	 * @return
 	 */
-<<<<<<< Updated upstream
-	StorageAccessor& operator= (StorageAccessor&&);
-	StorageAccessor (StorageAccessor&&);
-=======
 	StorageAccessor& operator=(StorageAccessor&&);
 	StorageAccessor(StorageAccessor&&);
->>>>>>> Stashed changes
 
 	ReturnValue_t write(uint8_t *data, size_t size,
 		uint16_t offset = 0);

From a7d68f8c52886f39d116a9ad0553f26463c753b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 13:31:45 +0200
Subject: [PATCH 0571/1292] deleted copy ctor

---
 pus/servicepackets/Service200Packets.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index fb153e21..1b5bf236 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -11,6 +11,7 @@
  */
 class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
 public:
+
 	ModePacket() {
 		setLinks();
 	}
@@ -28,9 +29,11 @@ public:
 		return submode.entry;
 	}
 
+	// Forbid copying, pointers are used.
+	ModePacket(const ModePacket&) = delete;
+	ModePacket& operator=(const ModePacket&) = delete;
 private:
-	// Forbid copying because of next pointer to member
-	ModePacket(const ModePacket &command);
+
 	void setLinks() {
 		setStart(&objectId);
 		objectId.setNext(&mode);
@@ -41,6 +44,10 @@ private:
 	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
 };
 
+/**
+ * @brief Subservice 7
+ * @ingroup spacepackets
+ */
 class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
 public:
     CantReachModePacket(object_id_t objectId, ReturnValue_t reason):

From e29226c9bba6587460d5db87e3ad3b3d7eab2357 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 14:28:36 +0200
Subject: [PATCH 0572/1292] srv8 improved

---
 pus/Service8FunctionManagement.cpp   |  9 +++++-
 pus/servicepackets/Service8Packets.h | 41 ++++++++++++++--------------
 2 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 812398b9..50102b04 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -59,8 +59,15 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
+                << " TC size smaller thant minimum size of direct command."
+                << std::endl;
+        return CommandingServiceBase::INVALID_TC;
+    }
+
 	// Create direct command instance by extracting data from Telecommand
-	DirectCommand command(tcData,tcDataLen);
+	DirectCommand command(tcData, tcDataLen);
 
 	// store additional parameters into the IPC Store
 	store_address_t parameterAddress;
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 5ef91280..86681c14 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -8,10 +8,7 @@
  *   3. Return Code
  *   4. Optional step number for step replies
  *
- * Data reply (subservice 132) consists of
- *   1. Target Object ID
- *   2. Action ID
- *   3. Data
+
  *
  *  \date 01.07.2019
  *  \author R. Mueller
@@ -29,23 +26,21 @@
 
 
 /**
- * \brief Subservice 128
- * \ingroup spacepackets
+ * @brief Subservice 128
+ * @ingroup spacepackets
  */
 class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
 public:
-	//typedef uint16_t typeOfMaxData;
-	//static const typeOfMaxData MAX_DATA = 256;
-	DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) {
-		size_t size = sizeof(objectId);
-		SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size,
+
+	DirectCommand(const uint8_t* tcData, size_t size) {
+		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
 		        SerializeIF::Endianness::BIG);
-		size = sizeof(actionId);
-		SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size,
+		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
 		        SerializeIF::Endianness::BIG);
-		parameterBuffer = dataBuffer_;
-		parametersSize = size_ - sizeof(objectId) - sizeof(actionId);
+		parameterBuffer = tcData;
+		parametersSize = size;
 	}
+
 	ActionId_t getActionId() const {
 		return actionId;
 	}
@@ -73,8 +68,12 @@ private:
 
 
 /**
- * \brief Subservice 130
- * \ingroup spacepackets
+ * @brief Subservice 130
+ * Data reply (subservice 130) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ * @ingroup spacepackets
  */
 class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
 public:
@@ -100,8 +99,10 @@ private:
 
 
 /**
- * \brief Subservice 132
- * \ingroup spacepackets
+ * @brief Subservice 132
+ * @details
+ * Not used yet. Telecommand Verification takes care of this.
+ * @ingroup spacepackets
  */
 class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
 public:
@@ -124,7 +125,7 @@ private:
 			returnCode.setNext(&step);
 		}
 	}
-	bool isDataReply; //!< [EXPORT] : [IGNORE]
+
 	bool isStep; //!< [EXPORT] : [IGNORE]
 	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
 	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]

From 36a7f2f9ee86b00370bee48721f470d9392bf93c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 14:32:25 +0200
Subject: [PATCH 0573/1292] removed file header comment

---
 pus/servicepackets/Service8Packets.h | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 86681c14..8ea0d108 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,19 +1,3 @@
-/**
- * \file Service8Packets.h
- *
- * \brief Structure of a Direct Command.
- * Normal reply (subservice 130) consists of
- *   1. Target object ID
- *   2. Action ID (taget device has specified functions with action IDs)
- *   3. Return Code
- *   4. Optional step number for step replies
- *
-
- *
- *  \date 01.07.2019
- *  \author R. Mueller
- */
-
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 

From 31450362106ebec643d99dd60d963e822516b0a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 19:34:18 +0200
Subject: [PATCH 0574/1292] getter functions for task handle

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 3 +++
 osal/FreeRTOS/FixedTimeslotTask.h   | 2 ++
 osal/FreeRTOS/PeriodicTask.cpp      | 4 ++++
 osal/FreeRTOS/PeriodicTask.h        | 2 ++
 osal/FreeRTOS/TaskManagement.cpp    | 5 +++--
 osal/FreeRTOS/TaskManagement.h      | 3 ++-
 6 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 57c927f9..3bd2aafb 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -157,3 +157,6 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+TaskHandle_t FixedTimeslotTask::getTaskHandle() const {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 27d08190..985b4f90 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -57,6 +57,8 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
+	TaskHandle_t getTaskHandle() const;
+
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 2ebfebf4..6d013a5b 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -126,6 +126,10 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     }
 }
 
+TaskHandle_t PeriodicTask::getTaskHandle() const {
+    return handle;
+}
+
 void PeriodicTask::handleMissedDeadline() {
 #ifdef DEBUG
     sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 09aa6bc7..679686f6 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -69,6 +69,8 @@ public:
 	uint32_t getPeriodMs() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() const;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 7871ab2e..9a1e4447 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -18,6 +18,7 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
 
-configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark() {
-	return uxTaskGetStackHighWaterMark(TaskManagement::getCurrentTaskHandle());
+configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark(
+        TaskHandle_t task) {
+	return uxTaskGetStackHighWaterMark(task);
 }
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 39c24377..cbde510c 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -57,7 +57,8 @@ public:
 	 * @return Smallest value of stack remaining since the task was started in
 	 * 		   words.
 	 */
-	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark();
+	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark(
+	        TaskHandle_t task = nullptr);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 444ee80f356a8e6b8e639c1cb847da320a21713b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 10 Jul 2020 20:31:10 +0200
Subject: [PATCH 0575/1292] removed unnecessary case and added more size checks

---
 pus/Service2DeviceAccess.cpp |  6 ++----
 tmtcservices/PusParser.cpp   | 29 ++++++++++++++---------------
 2 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 1d5f21eb..84d6693d 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -60,13 +60,11 @@ ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint32_t* state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)){
 	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+		return prepareRawCommand(message, tcData, tcDataLen);
 	}
 	break;
 	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
+		return prepareWiretappingCommand(message, tcData, tcDataLen);
 	}
 	break;
 	default:
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 4198e36e..3dd34a84 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -7,9 +7,8 @@ PusParser::PusParser(uint16_t maxExpectedPusPackets,
 
 ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		size_t frameSize) {
-	if(frame == nullptr) {
-		sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
-				<< std::endl;
+	if(frame == nullptr or frameSize < 5) {
+		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -25,15 +24,13 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 	}
 
 	size_t packetSize = lengthField + 7;
+	// sif::debug << frameSize << std::endl;
 	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize)
-	{
-		if(storeSplitPackets)
-		{
+	if(packetSize > frameSize) {
+		if(storeSplitPackets) {
 			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
 		}
-		else
-		{
+		else {
 			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
 					"larger than remaining frame," << std::endl;
 			sif::debug << "Throwing away packet. Detected packet size: "
@@ -41,8 +38,7 @@ ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
 		}
 		return SPLIT_PACKET;
 	}
-	else
-	{
+	else {
 		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
 		if(packetSize == frameSize) {
 			return HasReturnvaluesIF::RETURN_OK;
@@ -77,6 +73,11 @@ PusParser::indexSizePair PusParser::getNextFifoPair() {
 ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
 		size_t frameSize, size_t& currentIndex) {
 	// sif::debug << startIndex << std::endl;
+    if(currentIndex + 5 > frameSize) {
+        currentIndex = frameSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
 	uint16_t lengthField = frame[currentIndex + 4] << 8 |
 			frame[currentIndex + 5];
 	if(lengthField == 0) {
@@ -88,12 +89,10 @@ ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
 	size_t remainingSize = frameSize - currentIndex;
 	if(nextPacketSize > remainingSize)
 	{
-		if(storeSplitPackets)
-		{
+		if(storeSplitPackets) {
 			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
 		}
-		else
-		{
+		else {
 			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
 					"larger than remaining frame," << std::endl;
 			sif::debug << "Throwing away packet. Detected packet size: "

From 6a6395313f8dce6ec9693acddb6b93d3cda9549a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 01:06:01 +0200
Subject: [PATCH 0576/1292] added copy ctor and assignment for FIFObase

---
 container/DynamicFIFO.h |  2 +-
 container/FIFOBase.h    | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 3a5242c7..fca4c8e8 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -18,7 +18,7 @@ template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
 	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+			values(maxCapacity)  {};
 
 private:
 	std::vector<T> values;
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 8bdb333f..082c596a 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -3,6 +3,7 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <cstring>
 
 template <typename T>
 class FIFOBase {
@@ -43,6 +44,23 @@ public:
 	bool full();
 	size_t size();
 
+	FIFOBase(const FIFOBase& other): readIndex(other.readIndex),
+			writeIndex(other.writeIndex), currentSize(other.currentSize),
+			maxCapacity(other.maxCapacity) {
+		std::memcpy(values, other.values, sizeof(T) * currentSize);
+	}
+
+	FIFOBase& operator=(const FIFOBase& other) {
+		if(&other == this)
+			return *this;
+		maxCapacity = other.maxCapacity;
+		readIndex = other.readIndex;
+		writeIndex = other.writeIndex;
+		currentSize = other.currentSize;
+		std::memcpy(values, other.values, sizeof(T) * currentSize);
+		return *this;
+	}
+
 	size_t getMaxCapacity() const;
 
 private:

From 35d4267b400a950847447d2adc24e53096e4ef86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 02:36:04 +0200
Subject: [PATCH 0577/1292] dynamic fifo bug fixed

---
 container/DynamicFIFO.h  | 21 ++++++++++++++++++---
 container/FIFO.h         | 12 ++++++++++--
 container/FIFOBase.h     | 22 ++++------------------
 container/FIFOBase.tpp   |  8 +++++++-
 tmtcservices/PusParser.h |  9 +++++----
 5 files changed, 44 insertions(+), 28 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index fca4c8e8..59adfb3a 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -17,11 +17,26 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity)  {};
+	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());
+	}
+
 
 private:
-	std::vector<T> values;
+	std::vector<T> fifoVector;
 };
 
 #endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index ecb218fd..2e332dc2 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -17,10 +17,18 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(values.data(), capacity) {};
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
 
 private:
-	std::array<T, capacity> values;
+	std::array<T, capacity> fifoArray;
 };
 
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 082c596a..7f8bde96 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -44,29 +44,15 @@ public:
 	bool full();
 	size_t size();
 
-	FIFOBase(const FIFOBase& other): readIndex(other.readIndex),
-			writeIndex(other.writeIndex), currentSize(other.currentSize),
-			maxCapacity(other.maxCapacity) {
-		std::memcpy(values, other.values, sizeof(T) * currentSize);
-	}
-
-	FIFOBase& operator=(const FIFOBase& other) {
-		if(&other == this)
-			return *this;
-		maxCapacity = other.maxCapacity;
-		readIndex = other.readIndex;
-		writeIndex = other.writeIndex;
-		currentSize = other.currentSize;
-		std::memcpy(values, other.values, sizeof(T) * currentSize);
-		return *this;
-	}
 
 	size_t getMaxCapacity() const;
 
-private:
-	T* values;
+protected:
+	void setData(T* data);
 	size_t maxCapacity = 0;
 
+	T* values;
+
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
 	size_t currentSize = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 48a060ff..c73e9d59 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		values(values), maxCapacity(maxCapacity) {};
+		maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
@@ -78,4 +78,10 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 	return maxCapacity;
 }
 
+
+template<typename T>
+inline void FIFOBase<T>::setData(T *data) {
+	this->values = data;
+}
+
 #endif
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index 88570bb2..d59673f6 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -63,11 +63,12 @@ public:
 	 * @return
 	 */
 	indexSizePair getNextFifoPair();
-private:
 
-	//! A FIFO is used to store information about multiple PUS packets
-	//! inside the receive buffer. The maximum number of entries is defined
-	//! by the first constructor argument.
+private:
+	/** A FIFO is used to store information about multiple PUS packets
+	 * inside the receive buffer. The maximum number of entries is defined
+	 * by the first constructor argument.
+	 */
 	DynamicFIFO<indexSizePair> indexSizePairFIFO;
 
 	bool storeSplitPackets = false;

From 69946d5276549dce7624540df1de75c94ffc5004 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 11:52:01 +0200
Subject: [PATCH 0578/1292] FIFO hotfix

---
 container/DynamicFIFO.h | 21 ++++++++++++++++++---
 container/FIFO.h        | 12 ++++++++++--
 container/FIFOBase.h    |  8 ++++++--
 container/FIFOBase.tpp  |  8 +++++++-
 4 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 3a5242c7..59adfb3a 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -17,11 +17,26 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
-			values(maxCapacity) {};
+	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());
+	}
+
 
 private:
-	std::vector<T> values;
+	std::vector<T> fifoVector;
 };
 
 #endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index ecb218fd..2e332dc2 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -17,10 +17,18 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(values.data(), capacity) {};
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
 
 private:
-	std::array<T, capacity> values;
+	std::array<T, capacity> fifoArray;
 };
 
 #endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 8bdb333f..7f8bde96 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -3,6 +3,7 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
+#include <cstring>
 
 template <typename T>
 class FIFOBase {
@@ -43,12 +44,15 @@ public:
 	bool full();
 	size_t size();
 
+
 	size_t getMaxCapacity() const;
 
-private:
-	T* values;
+protected:
+	void setData(T* data);
 	size_t maxCapacity = 0;
 
+	T* values;
+
 	size_t readIndex = 0;
 	size_t writeIndex = 0;
 	size_t currentSize = 0;
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 48a060ff..c73e9d59 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,7 +7,7 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		values(values), maxCapacity(maxCapacity) {};
+		maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
@@ -78,4 +78,10 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 	return maxCapacity;
 }
 
+
+template<typename T>
+inline void FIFOBase<T>::setData(T *data) {
+	this->values = data;
+}
+
 #endif

From e4f795d209f36bbfaa39a1d03e46c759d4a86acd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 13:38:14 +0200
Subject: [PATCH 0579/1292] stack high watermark in bytes now

---
 osal/FreeRTOS/TaskManagement.cpp | 4 ++--
 osal/FreeRTOS/TaskManagement.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 9a1e4447..704f9d34 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -18,7 +18,7 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
 
-configSTACK_DEPTH_TYPE TaskManagement::getTaskStackHighWatermark(
+size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
-	return uxTaskGetStackHighWaterMark(task);
+	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
 }
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index cbde510c..ea363359 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -57,7 +57,7 @@ public:
 	 * @return Smallest value of stack remaining since the task was started in
 	 * 		   words.
 	 */
-	static configSTACK_DEPTH_TYPE getTaskStackHighWatermark(
+	static size_t getTaskStackHighWatermark(
 	        TaskHandle_t task = nullptr);
 };
 

From 799846d89fecc4c17dc6305d17b903217b0687ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 14:29:30 +0200
Subject: [PATCH 0580/1292] little formatting changes

---
 action/HasActionsIF.h |  2 +-
 events/Event.h        | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 9c2a9c01..008d9eaf 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -35,7 +35,7 @@
 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 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);
diff --git a/events/Event.h b/events/Event.h
index 96800f34..0a1cfcf2 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,10 +1,10 @@
-#ifndef EVENTOBJECT_EVENT_H_
-#define EVENTOBJECT_EVENT_H_
+#ifndef FRAMEWORK_EVENTS_EVENT_H_
+#define FRAMEWORK_EVENTS_EVENT_H_
 
-#include <stdint.h>
+#include <cstdint>
 #include <framework/events/fwSubsystemIdRanges.h>
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
@@ -21,6 +21,7 @@ EventSeverity_t getSeverity(Event event);
 Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
 
 }
+
 namespace SEVERITY {
 	static const EventSeverity_t INFO = 1;
 	static const EventSeverity_t LOW = 2;
@@ -41,4 +42,4 @@ namespace SEVERITY {
 //	static const EventSeverity_t HIGH = 4;
 //};
 
-#endif /* EVENTOBJECT_EVENT_H_ */
+#endif /* FRAMEWORK_EVENTS_EVENT_H_ */

From 7d794c76235c8247602b6327034f604d962b71c5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 11 Jul 2020 18:24:09 +0200
Subject: [PATCH 0581/1292] task management functions have freertos syntax now

---
 osal/FreeRTOS/TaskManagement.cpp | 6 +++---
 osal/FreeRTOS/TaskManagement.h   | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 704f9d34..ff552adb 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,6 +1,6 @@
 #include <framework/osal/FreeRTOS/TaskManagement.h>
 
-void TaskManagement::requestContextSwitchFromTask() {
+void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
 
@@ -8,9 +8,9 @@ void TaskManagement::requestContextSwitch(
 		CallContext callContext = CallContext::TASK) {
 	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
-		requestContextSwitchFromISR();
+		vRequestContextSwitchFromISR();
 	} else {
-		requestContextSwitchFromTask();
+		vRequestContextSwitchFromTask();
 	}
 }
 
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index ea363359..0ae8a6e9 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -13,7 +13,7 @@ extern "C" {
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern "C" void requestContextSwitchFromISR();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
@@ -41,7 +41,7 @@ public:
 	 * If task preemption in FreeRTOS is disabled, a context switch
 	 * can be requested manually by calling this function.
 	 */
-	static void requestContextSwitchFromTask(void);
+	static void vRequestContextSwitchFromTask(void);
 
 	/**
 	 * @return The current task handle

From 99aef0cf287fcdf23f9336927c171762e8bf4f7c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jul 2020 01:16:32 +0200
Subject: [PATCH 0582/1292] C++ linkage for yield from ISR function

---
 osal/FreeRTOS/TaskManagement.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 0ae8a6e9..62c68331 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -13,7 +13,7 @@ extern "C" {
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern "C" void vRequestContextSwitchFromISR();
+extern void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from

From b4f292f3d7fc4f606bf1b6d48618bd0cf1878e26 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 12 Jul 2020 18:01:09 +0200
Subject: [PATCH 0583/1292] new generic freertos task interface

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  2 +-
 osal/FreeRTOS/FixedTimeslotTask.h   |  5 +++--
 osal/FreeRTOS/FreeRTOSTaskIF.h      | 13 +++++++++++++
 osal/FreeRTOS/PeriodicTask.cpp      |  2 +-
 osal/FreeRTOS/PeriodicTask.h        |  6 ++++--
 returnvalues/HasReturnvaluesIF.h    | 10 +++++++++-
 6 files changed, 31 insertions(+), 7 deletions(-)
 create mode 100644 osal/FreeRTOS/FreeRTOSTaskIF.h

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 3bd2aafb..630952d2 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -157,6 +157,6 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-TaskHandle_t FixedTimeslotTask::getTaskHandle() const {
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
     return handle;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 985b4f90..b63cb775 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
+#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
 #include <framework/tasks/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
@@ -8,7 +9,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
-class FixedTimeslotTask: public FixedTimeslotTaskIF {
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
 public:
 
 	/**
@@ -57,7 +58,7 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
-	TaskHandle_t getTaskHandle() const;
+	TaskHandle_t getTaskHandle() override;
 
 protected:
 	bool started;
diff --git a/osal/FreeRTOS/FreeRTOSTaskIF.h b/osal/FreeRTOS/FreeRTOSTaskIF.h
new file mode 100644
index 00000000..06fda282
--- /dev/null
+++ b/osal/FreeRTOS/FreeRTOSTaskIF.h
@@ -0,0 +1,13 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#define FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FreeRTOSTaskIF {
+public:
+	virtual~ FreeRTOSTaskIF() {}
+	virtual TaskHandle_t getTaskHandle() = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 6d013a5b..f960d8bb 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -126,7 +126,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     }
 }
 
-TaskHandle_t PeriodicTask::getTaskHandle() const {
+TaskHandle_t PeriodicTask::getTaskHandle() {
     return handle;
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 679686f6..ca2c5324 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,10 +1,12 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 
+#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
 #include <framework/objectmanager/ObjectManagerIF.h>
 #include <framework/tasks/PeriodicTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
+
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
@@ -17,7 +19,7 @@ class ExecutableObjectIF;
  * 			periodic activities of multiple objects.
  * @ingroup task_handling
  */
-class PeriodicTask: public PeriodicTaskIF {
+class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
 public:
 	/**
 	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
@@ -70,7 +72,7 @@ public:
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
-	TaskHandle_t getTaskHandle() const;
+	TaskHandle_t getTaskHandle() override;
 protected:
 	bool started;
 	TaskHandle_t handle;
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index d231f4ee..9b9086d9 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -15,7 +15,15 @@ public:
 	static const ReturnValue_t RETURN_FAILED = 1;
 	virtual ~HasReturnvaluesIF() {}
 
-	static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
 	    return (interfaceId << 8) + number;
 	}
 };

From 6d99ab3df3e105901cf6af955a034968b7f8364d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 19:37:33 +0200
Subject: [PATCH 0584/1292] ncreased readability of DHB function

---
 devicehandlers/DeviceHandlerBase.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index af98ba44..cc97cd42 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1264,18 +1264,23 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
+		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand busy" << std::endl; //so we can track misconfigurations
+					<< ": DHB::buildInternalCommand: Busy" << std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
-	} else if (mode == MODE_RAW) {
+	}
+	else if (mode == MODE_RAW) {
 		result = buildChildRawCommand();
 		deviceCommandId = RAW_COMMAND_ID;
-	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+	}
+	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
 		result = buildTransitionDeviceCommand(&deviceCommandId);
-	} else {
+	}
+	else {
 		return;
 	}
+
 	if (result == NOTHING_TO_SEND) {
 		return;
 	}

From 15052cb33304f18d3e5ce95a4b547a2ff0826c99 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 19:54:38 +0200
Subject: [PATCH 0585/1292] singly linked list update

---
 container/SinglyLinkedList.h | 61 ++++++++++++++++++++++++------------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 85a92e6a..7d5fc4a9 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -16,13 +16,8 @@ public:
 	class Iterator {
 	public:
 		LinkedElement<T> *value = nullptr;
-		//! Creates an uninitialized iterator which points to nullptr.
 		Iterator() {}
 
-		/**
-		 * Initialize iterator at specified linked element.
-		 * @param element
-		 */
 		Iterator(LinkedElement<T> *element) :
 				value(element) {
 		}
@@ -77,11 +72,6 @@ private:
 	LinkedElement *next;
 };
 
-/**
- * @brief 	SinglyLinkedList data structure which keeps a pointer to its
- * 			first element to perform all operations.
- * @tparam T
- */
 template<typename T>
 class SinglyLinkedList {
 public:
@@ -99,12 +89,21 @@ public:
 		return ElementIterator::Iterator(start);
 	}
 
+	/** Returns iterator to nulltr */
 	ElementIterator end() const {
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			element = element->getNext();
-		}
-		return ElementIterator::Iterator(element);
+		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);
 	}
 
 	size_t getSize() const {
@@ -116,15 +115,37 @@ public:
 		}
 		return size;
 	}
-	void setStart(LinkedElement<T>* setStart) {
-		start = setStart;
+	void setStart(LinkedElement<T>* firstElement) {
+		start = firstElement;
 	}
 
-    void setEnd(LinkedElement<T>* setEnd) {
-        setEnd->setEnd();
+	void setNext(LinkedElement<T>* currentElement,
+	        LinkedElement<T>* nextElement) {
+	    currentElement->setNext(nextElement);
+	}
+
+    void setLast(LinkedElement<T>* lastElement) {
+        lastElement->setEnd();
     }
 
-    // SHOULDDO: Insertion operation ?
+    void insertElement(LinkedElement<T>* element, size_t position) {
+        LinkedElement<T> *currentElement = start;
+        for(size_t count = 0; count < position; count++) {
+            if(currentElement == nullptr) {
+                return;
+            }
+            currentElement = currentElement->getNext();
+        }
+        LinkedElement<T>* elementAfterCurrent = currentElement->next;
+        currentElement->setNext(element);
+        if(elementAfterCurrent != nullptr) {
+            element->setNext(elementAfterCurrent);
+        }
+    }
+
+    void insertBack(LinkedElement<T>* lastElement) {
+        back().value->setNext(lastElement);
+    }
 
 protected:
 	LinkedElement<T> *start = nullptr;

From e7b6999c5ea11e776848cb63a11f1e9673af0efa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 13 Jul 2020 22:13:19 +0200
Subject: [PATCH 0586/1292] added back inttypes.h for cleaner code

---
 timemanager/CCSDSTime.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 47cab911..71b2539d 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -205,9 +205,10 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	uint8_t hour;
 	uint8_t minute;
 	float second;
-	//try Code A (yyyy-mm-dd)
-	int count = sscanf((char *) from, "%4hi-%2hhi-%2hiT%2hhi:%2hhi:%fZ", &year,
-				&month, &day, &hour, &minute, &second);
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;
@@ -219,9 +220,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 		return RETURN_OK;
 	}
 
-	//try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4hi-%3hiT%2hhi:%2hhi:%fZ", &year, &day,
-			&hour, &minute, &second);
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
 		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,

From e204bd77c6cf4ac9a4229ed434674a43d72a94c3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jul 2020 02:21:11 +0200
Subject: [PATCH 0587/1292] created tpp file for fixed ordered multimap

---
 container/FixedOrderedMultimap.h   | 242 ++++++++++++++---------------
 container/FixedOrderedMultimap.tpp |  83 ++++++++++
 2 files changed, 199 insertions(+), 126 deletions(-)
 create mode 100644 container/FixedOrderedMultimap.tpp

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 3dd20a74..9a04becf 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -4,8 +4,18 @@
 #include <framework/container/ArrayList.h>
 #include <cstring>
 #include <set>
+
 /**
- * \ingroup container
+ * @brief   Map implementation which allows entries with identical keys
+ * @details
+ * Performs no dynamic memory allocation except on initialization.
+ * Uses an ArrayList as the underlying container and thus 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 exensive memory move operations (the underlying container
+ * is not node based).
+ * @ingroup container
  */
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
@@ -15,11 +25,113 @@ public:
 	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
+	/**
+	 * Initializes the ordered multimap with a fixed maximum size.
+	 * @param maxSize
+	 */
+    FixedOrderedMultimap(size_t maxSize);
+
+    virtual ~FixedOrderedMultimap() {}
+
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        /** Returns an iterator to nullptr */
+        Iterator();
+        /** Initializes iterator to given entry */
+        Iterator(std::pair<key_t, T> *pair);
+        /** Dereference operator can be used to get value */
+        T operator*();
+        /** Arrow operator can be used to get pointer to value */
+        T *operator->();
+    };
+
+    /** Iterator to start of map */
+    Iterator begin() const;
+    /** Iterator to end of map */
+    Iterator end() const;
+    /** Current (variable) size of the map */
+    size_t size() const;
+
+    /**
+     * Insert a key/value pair inside the map. An iterator to the stored
+     * value might be returned optionally.
+     * @param key
+     * @param value
+     * @param storedValue
+     * @return
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /**
+     * Insert a given std::pair<key, value>
+     * @param pair
+     * @return
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
+    /**
+     * Checks existence of key in map.
+     * @param key
+     * @return
+     * - @c KEY_DOES_NOT_EXIST if key does not exists.
+     * - @c RETURN_OK otherwise.
+     */
+    ReturnValue_t exists(key_t key) const;
+
+    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;
+    }
+
+    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;
+    }
+
+    size_t maxSize() const {
+        return theMap.maxSize();
+    }
+
 private:
 	typedef KEY_COMPARE compare;
 	compare myComp;
 	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+	size_t _size;
 
 	uint32_t findFirstIndex(key_t key, uint32_t startAt = 0) const {
 		if (startAt >= _size) {
@@ -52,130 +164,8 @@ private:
 				(_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();
-	}
-
 };
 
+#include <framework/container/FixedOrderedMultimap.tpp>
+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
new file mode 100644
index 00000000..74edbf9a
--- /dev/null
+++ b/container/FixedOrderedMultimap.tpp
@@ -0,0 +1,83 @@
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
+        std::pair<key_t, T> *pair):
+        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline T FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator*() {
+    return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
+    return Iterator(&theMap[0]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const {
+    return Iterator(&theMap[_size]);
+}
+
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
+    return _size;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline T* FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator->() {
+    return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
+        size_t maxSize): theMap(maxSize), _size(0) {}
+
+
+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;
+    }
+    uint32_t position = findNicePlace(key);
+    // Compiler might emitt warning because std::pair is not a POD type (yet..)
+    // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
+    // Should still work without issues.
+    std::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 != 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.fist, 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;
+}
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

From e5ab7ada682fb80db4daa3ba7b4f5f20b364fedd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 14 Jul 2020 15:45:03 +0200
Subject: [PATCH 0588/1292] added new interfaces for datasets

---
 datapool/DataSetIF.h                          |  22 +---
 .../{DataSetBase.cpp => PoolDataSetBase.cpp}  |  34 ++---
 datapool/{DataSetBase.h => PoolDataSetBase.h} |  15 ++-
 datapool/PoolDataSetIF.h                      |  28 ++++
 datapool/PoolVariableIF.h                     |   4 +-
 datapool/SharedDataSetIF.h                    |  15 +++
 datapoolglob/GlobalDataSet.cpp                |   8 +-
 datapoolglob/GlobalDataSet.h                  |   6 +-
 datapoollocal/LocalDataPoolManager.cpp        |   8 +-
 datapoollocal/LocalDataPoolManager.h          |   8 +-
 datapoollocal/LocalDataSet.cpp                | 113 +---------------
 datapoollocal/LocalDataSet.h                  | 112 ++--------------
 datapoollocal/LocalDataSetBase.cpp            | 107 ++++++++++++++++
 datapoollocal/LocalPoolDataSetBase.h          | 121 ++++++++++++++++++
 datapoollocal/SharedLocalDataSet.cpp          |  16 +++
 datapoollocal/SharedLocalDataSet.h            |  25 ++++
 datapoollocal/StaticLocalDataSet.cpp          |   6 -
 datapoollocal/StaticLocalDataSet.h            |  22 +++-
 18 files changed, 396 insertions(+), 274 deletions(-)
 rename datapool/{DataSetBase.cpp => PoolDataSetBase.cpp} (80%)
 rename datapool/{DataSetBase.h => PoolDataSetBase.h} (93%)
 create mode 100644 datapool/PoolDataSetIF.h
 create mode 100644 datapool/SharedDataSetIF.h
 create mode 100644 datapoollocal/LocalDataSetBase.cpp
 create mode 100644 datapoollocal/LocalPoolDataSetBase.h
 create mode 100644 datapoollocal/SharedLocalDataSet.cpp
 create mode 100644 datapoollocal/SharedLocalDataSet.h
 delete mode 100644 datapoollocal/StaticLocalDataSet.cpp

diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 437f324f..bcc1cd21 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,5 +1,5 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FRAMEWORK_DATAPOOL_DATASETIF_H_
+#define FRAMEWORK_DATAPOOL_DATASETIF_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/timemanager/Clock.h>
@@ -34,8 +34,7 @@ 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 +43,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 /* FRAMEWORK_DATAPOOL_DATASETIF_H_ */
diff --git a/datapool/DataSetBase.cpp b/datapool/PoolDataSetBase.cpp
similarity index 80%
rename from datapool/DataSetBase.cpp
rename to datapool/PoolDataSetBase.cpp
index cb7a7899..63820732 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -1,7 +1,7 @@
-#include <framework/datapool/DataSetBase.h>
+#include <framework/datapool/PoolDataSetBase.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
+PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
         registeredVariables(registeredVariablesArray),
         maxFillCount(maxFillCount) {
@@ -10,9 +10,9 @@ DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
 	}
 }
 
-DataSetBase::~DataSetBase() {}
+PoolDataSetBase::~PoolDataSetBase() {}
 
-ReturnValue_t DataSetBase::registerVariable(
+ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::DATA_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
@@ -34,7 +34,7 @@ ReturnValue_t DataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	if (state == States::DATA_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
@@ -56,11 +56,11 @@ ReturnValue_t DataSetBase::read(uint32_t lockTimeout) {
 	return result;
 }
 
-uint16_t DataSetBase::getFillCount() const {
+uint16_t PoolDataSetBase::getFillCount() const {
     return fillCount;
 }
 
-ReturnValue_t DataSetBase::readVariable(uint16_t count) {
+ReturnValue_t PoolDataSetBase::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.
@@ -77,7 +77,7 @@ ReturnValue_t DataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
 	if (state == States::DATA_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
@@ -87,7 +87,7 @@ ReturnValue_t DataSetBase::commit(uint32_t lockTimeout) {
 	}
 }
 
-void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
+void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
@@ -101,7 +101,7 @@ void DataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	lockDataPool(lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
@@ -125,15 +125,15 @@ ReturnValue_t DataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t DataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::unlockDataPool() {
+ReturnValue_t PoolDataSetBase::unlockDataPool() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
+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++) {
@@ -146,7 +146,7 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
 	return result;
 }
 
-ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
+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++) {
@@ -159,10 +159,14 @@ ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
 	return result;
 }
 
-size_t DataSetBase::getSerializedSize() const {
+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;
+}
diff --git a/datapool/DataSetBase.h b/datapool/PoolDataSetBase.h
similarity index 93%
rename from datapool/DataSetBase.h
rename to datapool/PoolDataSetBase.h
index cc16aa9e..112808dd 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#ifndef FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_
 #include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetIF.h>
 #include <framework/datapool/PoolVariableIF.h>
 #include <framework/ipc/MutexIF.h>
 
@@ -27,7 +28,7 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class DataSetBase: public DataSetIF,
+class PoolDataSetBase: public PoolDataSetIF,
 		public SerializeIF,
 		public HasReturnvaluesIF {
 public:
@@ -37,9 +38,9 @@ public:
 	 * 			supply a pointer to this dataset to PoolVariable
 	 * 			initializations to register pool variables.
 	 */
-	DataSetBase(PoolVariableIF** registeredVariablesArray,
+	PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 	        const size_t maxFillCount);
-	virtual~ DataSetBase();
+	virtual~ PoolDataSetBase();
 
 	/**
 	 * @brief	The read call initializes reading out all registered variables.
@@ -140,10 +141,12 @@ protected:
 	PoolVariableIF** registeredVariables = nullptr;
 	const size_t maxFillCount = 0;
 
+	void setContainer(PoolVariableIF** variablesContainer);
+
 private:
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_DATASETBASE_H_ */
+#endif /* FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
new file mode 100644
index 00000000..a33d4bd0
--- /dev/null
+++ b/datapool/PoolDataSetIF.h
@@ -0,0 +1,28 @@
+#ifndef FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#include <framework/datapool/DataSetIF.h>
+
+class PoolDataSetIF: public DataSetIF {
+public:
+    virtual~ PoolDataSetIF() {};
+
+    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
+    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
+
+    /**
+     * @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(dur_millis_t timeoutMs) = 0;
+    /**
+     * @brief   Unlock call corresponding to the lock call.
+     * @return Unlock operation result
+     */
+    virtual ReturnValue_t unlockDataPool() = 0;
+
+    virtual bool isValid() const = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 30b87839..6b0dd7fb 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -18,9 +18,9 @@
  * @ingroup data_pool
  */
 class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
+	friend class PoolDataSetBase;
 	friend class GlobDataSet;
-	friend class LocalDataSet;
+	friend class LocalDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
diff --git a/datapool/SharedDataSetIF.h b/datapool/SharedDataSetIF.h
new file mode 100644
index 00000000..3d9cc302
--- /dev/null
+++ b/datapool/SharedDataSetIF.h
@@ -0,0 +1,15 @@
+#ifndef FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#define FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetIF.h>
+
+class SharedDataSetIF: public PoolDataSetIF {
+public:
+    virtual ~SharedDataSetIF() {};
+
+private:
+    virtual ReturnValue_t lockDataset(dur_millis_t mutexTimeout) = 0;
+    virtual ReturnValue_t unlockDataset() = 0;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_SHAREDDATASETIF_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 883f6157..3e6e3e52 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -2,7 +2,7 @@
 #include <framework/datapoolglob/GlobalDataSet.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-GlobDataSet::GlobDataSet(): DataSetBase(
+GlobDataSet::GlobDataSet(): PoolDataSetBase(
         reinterpret_cast<PoolVariableIF**>(&registeredVariables),
         DATA_SET_MAX_SIZE) {}
 
@@ -17,7 +17,11 @@ ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
 }
 
 ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return DataSetBase::commit(lockTimeout);
+	return PoolDataSetBase::commit(lockTimeout);
+}
+
+bool GlobDataSet::isValid() const {
+    return this->valid;
 }
 
 ReturnValue_t GlobDataSet::unlockDataPool() {
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index d237cc1b..3ebe7235 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 #define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
 
-#include <framework/datapool/DataSetBase.h>
+#include <framework/datapool/PoolDataSetBase.h>
 
 /**
  * @brief	The DataSet class manages a set of locally checked out variables
@@ -17,7 +17,7 @@
  * @author	Bastian Baetz
  * @ingroup data_pool
  */
-class GlobDataSet: public DataSetBase {
+class GlobDataSet: public PoolDataSetBase {
 public:
 
 	/**
@@ -53,6 +53,8 @@ public:
 	 */
 	void setSetValid(bool valid);
 
+	bool isValid() const override;
+
 	/**
 	 * Set the valid information of all variables contained in the set which
 	 * are not read-only
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 02016abf..afce330f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,5 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/AcceptsHkPacketsIF.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
@@ -116,7 +116,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t sendTo) {
-	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+	LocalDataSetBase* dataSetToSerialize = dynamic_cast<LocalDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+    LocalDataSetBase* dataSet = dynamic_cast<LocalDataSetBase*>(
             owner->getDataSetHandle(sid));
     if(dataSet == nullptr) {
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -186,7 +186,7 @@ void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSet* dataSet) {
+        store_address_t *storeId, LocalDataSetBase* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df7b9ff4..5a840303 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-class LocalDataSet;
+class LocalDataSetBase;
 
 /**
  * @brief 	This class is the managing instance for local data pool.
@@ -38,7 +38,7 @@ class LocalDataPoolManager {
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
-	friend class LocalDataSet;
+	friend class LocalDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -135,7 +135,7 @@ private:
      * The data pool manager will keep an internal map of HK receivers.
      */
     struct HkReceiver {
-        LocalDataSet* dataSet = nullptr;
+        LocalDataSetBase* dataSet = nullptr;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingStatus = true;
@@ -202,7 +202,7 @@ private:
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSet* dataSet);
+	        LocalDataSetBase* dataSet);
 };
 
 
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2a42cd38..b6508ada 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,106 +1,7 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-#include <cmath>
-#include <cstring>
-
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::~LocalDataSet() {
-}
-
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
+#include <framework/datapoollocal/LocalDataSet.h>
+
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, const size_t maxSize):
+        LocalDataSetBase(hkOwner, nullptr, maxSize), poolVarList(maxSize) {
+    this->setContainer(poolVarList.data());
+}
+
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 2c70de82..c26d540c 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,115 +1,19 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/serialize/SerializeIF.h>
-
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <vector>
 
-class LocalDataPoolManager;
-
-/**
- * @brief	The LocalDataSet class manages a set of locally checked out variables
- * 			for local data pools
- * @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 local data pools,
- * to ensure thread-safety.
- *
- * 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.
- *
- * @ingroup data_pool
- */
-class LocalDataSet: public DataSetBase {
+class LocalDataSet: public LocalDataSetBase {
 public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(HasLocalDataPoolIF *hkOwner,
-	        const size_t maxNumberOfVariables);
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
 
-	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(object_id_t ownerId,
-	        const size_t maxNumberOfVariables);
+    virtual~ LocalDataSet() {};
 
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalDataSet();
-
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-protected:
+    //! Copying forbidden for now.
+    LocalDataSet(const LocalDataSet&) = delete;
+    LocalDataSet& operator=(const LocalDataSet&) = delete;
 private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	LocalDataPoolManager* hkManager;
-
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-
-	std::vector<PoolVariableIF*> poolVarList;
+    std::vector<PoolVariableIF*> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalDataSetBase.cpp b/datapoollocal/LocalDataSetBase.cpp
new file mode 100644
index 00000000..f490ff67
--- /dev/null
+++ b/datapoollocal/LocalDataSetBase.cpp
@@ -0,0 +1,107 @@
+#include <framework/datapoollocal/LocalDataPoolManager.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/serialize/SerializeAdapter.h>
+
+#include <cmath>
+#include <cstring>
+
+LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSetBase::~LocalDataSetBase() {
+}
+
+ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(timeoutMs);
+}
+
+ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
+ReturnValue_t LocalDataSetBase::unlockDataPool() {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
+}
+
+ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+bool LocalDataSetBase::isValid() const {
+    return this->valid;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
new file mode 100644
index 00000000..5ef8f3d4
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -0,0 +1,121 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#include <framework/datapool/DataSetIF.h>
+#include <framework/datapool/PoolDataSetBase.h>
+#include <framework/datapoollocal/HasLocalDataPoolIF.h>
+#include <framework/serialize/SerializeIF.h>
+
+#include <vector>
+
+class LocalDataPoolManager;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out
+ *          variables for local data pools
+ * @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 local data pools,
+ * to ensure thread-safety.
+ *
+ * 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.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSetBase: public PoolDataSetBase {
+public:
+	/**
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+	        PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSetBase(object_id_t ownerId,
+	        PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSetBase();
+
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	bool isValid() const override;
+
+protected:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+private:
+
+
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
new file mode 100644
index 00000000..6f355a8a
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -0,0 +1,16 @@
+#include <framework/datapoollocal/SharedLocalDataSet.h>
+
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+        const size_t maxSize): SystemObject(objectId),
+        LocalDataSetBase(owner, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
+    return datasetLock->lockMutex(mutexTimeout);
+}
+
+ReturnValue_t SharedLocalDataSet::unlockDataset() {
+    return datasetLock->unlockMutex();
+}
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
new file mode 100644
index 00000000..8fe613ba
--- /dev/null
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -0,0 +1,25 @@
+#ifndef FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#include <framework/datapool/SharedDataSetIF.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <vector>
+
+class SharedLocalDataSet: public SystemObject,
+        public LocalDataSetBase,
+        public SharedDataSetIF {
+public:
+    SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+            const size_t maxSize);
+    ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
+    ReturnValue_t unlockDataset() override;
+private:
+
+
+    MutexIF* datasetLock = nullptr;
+    std::vector<PoolVariableIF*> poolVarVector;
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
deleted file mode 100644
index 15d4251a..00000000
--- a/datapoollocal/StaticLocalDataSet.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <framework/datapoollocal/StaticLocalDataSet.h>
-
-
-
-
-
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 15a79aae..f31018af 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,11 +1,23 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-
-
-class StaticLocalDataSet: public DataSetBase {
+#include <framework/datapool/PoolDataSetBase.h>
+#include <array>
 
+/**
+ * @brief   This local dataset type is created on the stack.
+ * @details
+ * Size of data set specified as a constructor argument. It is recommended
+ * to use the default LocalDataSet of the dataset is constructed on the heap
+ * and the SharedLocalDataSet if it created on the heap and used by multiple
+ * other software objects.
+ * @tparam capacity
+ */
+template <uint8_t capacity>
+class StaticLocalDataSet: public PoolDataSetBase {
+    StaticLocalDataSet():  PoolDataSetBase(poolVarList.data(), capacity) {}
+    virtual~ StaticLocalDataSet();
+private:
+    std::array<PoolVariableIF*, capacity> poolVarList;
 };
 
-
 #endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From a0b8f8855ced699701290f643c1fab8658bd323b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 11:45:23 +0200
Subject: [PATCH 0589/1292] cotinued distir datapool

---
 datapoollocal/HasLocalDataPoolIF.h   |  1 +
 datapoollocal/LocalDataPoolManager.h | 26 +++++++++++++++++++++++---
 datapoollocal/LocalDataSet.cpp       |  4 ++++
 datapoollocal/LocalDataSet.h         |  2 +-
 datapoollocal/LocalPoolDataSetBase.h |  2 ++
 datapoollocal/LocalPoolVariable.tpp  |  2 +-
 datapoollocal/SharedLocalDataSet.h   |  8 +++++++-
 datapoollocal/StaticLocalDataSet.h   | 13 +++++++++----
 8 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 0095f894..7727c3b4 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -41,6 +41,7 @@ public:
 	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
 
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 5a840303..9c413aa4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -109,13 +109,32 @@ public:
 
     /**
      * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals
-     *  2. UPDATED: HK packets are generated if a value was updated
-     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     *  1. PERIODIC: HK packets are generated in fixed intervals and sent to
+     *     destination. Fromat will be raw.
+     *  2. UPDATED: Notification will be sent out if HK data has changed.
+     *     Question: Send Raw data directly or just the message?
+     *  3. REQUESTED: HK packets are only generated if explicitely requested.
+     *     Propably not necessary, just use multiple local data sets or
+     *     shared datasets.
+     *
+     *  TODO: This is a big architecture question. Use raw data or shared
+     *  datasets? dumb thing about shared datasets: It propably would be better
+     *  if each task who uses the data has their own copy of the pool
+     *  variables. Then the LPIDs should be hardcoded in the dataset implementations
+     *  so the users don't have to worry about it anymore.
+     *
+     *  Notifications should also be possible for single variables instead of
+     *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
+        // Periodic generation of HK packets.
         PERIODIC,
+        // Notification will be sent out as message.
+        // Data is accessed via shared data set or multiple local data sets.
         ON_UPDATE,
+        // actually, requested is propably unnecessary. If another component
+        // needs data on request, they can just use  the new SharedDataSet
+        // which is thread-safe to also have full access to the interface..
         REQUESTED
     };
 
@@ -136,6 +155,7 @@ private:
      */
     struct HkReceiver {
         LocalDataSetBase* dataSet = nullptr;
+        lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingStatus = true;
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index b6508ada..74b1376e 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,3 +5,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, const size_t maxSize):
     this->setContainer(poolVarList.data());
 }
 
+LocalDataSet::LocalDataSet(object_id_t owner, const size_t maxSize):
+        LocalDataSetBase(owner, nullptr, maxSize), poolVarList(maxSize) {
+    this->setContainer(poolVarList.data());
+}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index c26d540c..e6bd2012 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -6,7 +6,7 @@
 class LocalDataSet: public LocalDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
-
+    LocalDataSet(object_id_t owner, const size_t maxSize);
     virtual~ LocalDataSet() {};
 
     //! Copying forbidden for now.
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5ef8f3d4..f7a2cae4 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -46,6 +46,8 @@ public:
 	 * 			owner should implement the HasHkPoolParametersIF.
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
+	 * @details
+	 *
 	 */
 	LocalDataSetBase(object_id_t ownerId,
 	        PoolVariableIF** registeredVariablesArray,
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0b96bb4f..59bf78d0 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -28,7 +28,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
-		readWriteMode(readWriteMode) {
+		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
 				"NO_PARAMETER value!" << std::endl;
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 8fe613ba..acb0cd26 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -5,6 +5,13 @@
 #include <framework/objectmanager/SystemObject.h>
 #include <vector>
 
+/**
+ * Baseline question: If this dataset is shared, is there once instance
+ * shared among many objects or multiple instances? Maybe be flexible
+ * and provide both ways? Sharing one instance requires a mutex lock.
+ * If there are multiple instances, it is not shared anymore, to be fair..
+ * Then a regular local data set is sufficient.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalDataSetBase,
         public SharedDataSetIF {
@@ -15,7 +22,6 @@ public:
     ReturnValue_t unlockDataset() override;
 private:
 
-
     MutexIF* datasetLock = nullptr;
     std::vector<PoolVariableIF*> poolVarVector;
 };
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index f31018af..fbe1545f 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #include <framework/datapool/PoolDataSetBase.h>
+#include <framework/objectmanager/SystemObjectIF.h>
 #include <array>
 
 /**
@@ -12,12 +13,16 @@
  * other software objects.
  * @tparam capacity
  */
-template <uint8_t capacity>
-class StaticLocalDataSet: public PoolDataSetBase {
-    StaticLocalDataSet():  PoolDataSetBase(poolVarList.data(), capacity) {}
+template <uint8_t NUM_VARIABLES>
+class StaticLocalDataSet: public LocalDataSetBase {
+public:
+    StaticLocalDataSet(object_id_t owner):
+        LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+    }
+
     virtual~ StaticLocalDataSet();
 private:
-    std::array<PoolVariableIF*, capacity> poolVarList;
+    std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };
 
 #endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

From 47b3a428c68ff74a6019eb2c36c9fb253cc427fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:33:03 +0200
Subject: [PATCH 0590/1292] removed device switch, not necessary anymore

---
 devicehandlers/ChildHandlerBase.cpp  | 5 ++---
 devicehandlers/ChildHandlerBase.h    | 6 +++---
 devicehandlers/DeviceHandlerBase.cpp | 4 ----
 devicehandlers/DeviceHandlerBase.h   | 8 --------
 4 files changed, 5 insertions(+), 18 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 9e5019b4..bdc5fa65 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -4,15 +4,14 @@
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
-		uint8_t setDeviceSwitch, object_id_t hkDestination,
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId,
 		object_id_t parent,
 		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
 		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
 			(customFdir == nullptr? &childHandlerFdir : customFdir),
 			cmdQueueSize),
 		parentId(parent), childHandlerFdir(setObjectId) {
-	this->setDeviceSwitch(setDeviceSwitch);
 	this->setHkDestination(hkDestination);
 	this->setThermalStateRequestPoolIds(thermalStatePoolId,
 			thermalRequestPoolId);
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 5c216e86..c8ac9541 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -7,9 +7,9 @@
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
 	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, uint8_t setDeviceSwitch,
-			object_id_t hkDestination, uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId, object_id_t parent = objects::NO_OBJECT,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
 			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
 	virtual ~ChildHandlerBase();
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cc97cd42..c13611b3 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -63,10 +63,6 @@ void DeviceHandlerBase::setThermalStateRequestPoolIds(
 }
 
 
-void DeviceHandlerBase::setDeviceSwitch(uint8_t deviceSwitch) {
-	this->deviceSwitch = deviceSwitch;
-}
-
 DeviceHandlerBase::~DeviceHandlerBase() {
 	delete comCookie;
 	if (defaultFDIRUsed) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 61fb701d..034653dc 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -108,7 +108,6 @@ public:
 			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
 			size_t cmdQueueSize = 20);
 
-	void setDeviceSwitch(uint8_t deviceSwitch);
 	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
@@ -1079,13 +1078,6 @@ private:
 	 */
 	Submode_t transitionSourceSubMode;
 
-	/**
-	 * the switch of the device
-	 *
-	 * for devices using two switches override getSwitches()
-	 */
-	uint8_t deviceSwitch;
-
 	/**
 	 * read the command queue
 	 */

From aaafed7b28bc7110321f0a092a81beb8002990bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:38:21 +0200
Subject: [PATCH 0591/1292] health table init now mandatory, better

diagnostic output for uninit health table or invalid health helper owner
---
 devicehandlers/DeviceHandlerBase.cpp | 39 +++++++---------------------
 devicehandlers/DeviceHandlerBase.h   |  1 -
 health/HealthHelper.cpp              | 15 ++++++++---
 3 files changed, 21 insertions(+), 34 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c13611b3..b4ad0fda 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -164,12 +164,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	}
 
 	result = healthHelper.initialize();
-	if (result == RETURN_OK) {
-		healthHelperActive = true;
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::initialize: Health Helper "
-				"initialization failure." << std::endl;
+	if (result != RETURN_OK) {
+	    return result;
 	}
 
 	result = modeHelper.initialize();
@@ -246,11 +242,9 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	if(healthHelperActive) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			return;
-		}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == RETURN_OK) {
+	    return;
 	}
 
 	result = modeHelper.handleModeCommand(&command);
@@ -1028,9 +1022,7 @@ void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 }
 
 void DeviceHandlerBase::setToExternalControl() {
-	if(healthHelperActive) {
-		healthHelper.setHealth(EXTERNAL_CONTROL);
-	}
+	healthHelper.setHealth(EXTERNAL_CONTROL);
 }
 
 void DeviceHandlerBase::announceMode(bool recursive) {
@@ -1050,25 +1042,12 @@ void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
 }
 
 HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	if(healthHelperActive) {
-		return healthHelper.getHealth();
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
-				<< std::endl;
-		return HasHealthIF::HEALTHY;
-	}
+	return healthHelper.getHealth();
 }
 
 ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-	if(healthHelperActive) {
-		healthHelper.setHealth(health);
-	}
-	else {
-		sif::warning << "DeviceHandlerBase::getHealth: Health helper not active"
-				<< std::endl;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    healthHelper.setHealth(health);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void DeviceHandlerBase::checkSwitchState() {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 034653dc..a2906368 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -609,7 +609,6 @@ protected:
 
 	/** Health helper for HasHealthIF */
 	HealthHelper healthHelper;
-	bool healthHelperActive = false;
 	/** Mode helper for HasModesIF */
 	ModeHelper modeHelper;
 	/** Parameter helper for ReceivesParameterMessagesIF */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index e01e6fbb..a39305a3 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -39,10 +39,19 @@ void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
 ReturnValue_t HealthHelper::initialize() {
 	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-	// TODO: Better returnvalues
-	if ((healthTable == NULL) || eventSender == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
+
+	if (healthTable == nullptr) {
+	    sif::error << "HealthHelper::initialize: Health table object needs"
+	            "to be created in factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
+
+	if(eventSender == nullptr) {
+	    sif::error << "HealthHelper::initialize: Owner has to implement "
+	            "ReportingProxyIF." << std::endl;
+	    return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
 	ReturnValue_t result = healthTable->registerObject(objectId,
 			HasHealthIF::HEALTHY);
 	if (result != HasReturnvaluesIF::RETURN_OK) {

From b4d6d970bc9890c24b4abb3c671dad2104aac383 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 16 Jul 2020 12:41:05 +0200
Subject: [PATCH 0592/1292] removed HK manager virtual functions

---
 devicehandlers/DeviceHandlerBase.cpp | 12 ------------
 devicehandlers/DeviceHandlerBase.h   |  5 -----
 2 files changed, 17 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index b4ad0fda..282f20b2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1366,18 +1366,6 @@ LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
 	return &hkManager;
 }
 
-ReturnValue_t DeviceHandlerBase::addDataSet(sid_t sid) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::removeDataSet(sid_t sid) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::changeCollectionInterval(sid_t sid,
-        dur_seconds_t newInterval) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     // In this function, the task handle should be valid if the task
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index a2906368..ddbf6041 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -486,11 +486,6 @@ protected:
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
 
-	virtual ReturnValue_t addDataSet(sid_t sid) override;
-	virtual ReturnValue_t removeDataSet(sid_t sid) override;
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) override;
-
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.

From e179288c00ffedf8e160b399db15a0ec26395ea2 Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 25 Jun 2020 18:09:32 +0200
Subject: [PATCH 0593/1292] Fixed spelling mistake in HealthHelper

---
 devicehandlers/ChildHandlerBase.cpp  | 2 +-
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 devicehandlers/HealthDevice.cpp      | 2 +-
 health/HealthHelper.cpp              | 4 ++--
 health/HealthHelper.h                | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index bdc5fa65..2e4428e5 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -39,7 +39,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 		parent->registerChild(getObjectId());
 	}
 
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 
 	modeHelper.setParentQueue(parentQueue);
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 282f20b2..9f4c7baf 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1134,7 +1134,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 
 void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQeueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
 }
 
 bool DeviceHandlerBase::isAwaitingReply() {
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 0bce34ec..8367a6bc 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -38,7 +38,7 @@ MessageQueueId_t HealthDevice::getCommandQueue() const {
 }
 
 void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 }
 
 bool HealthDevice::hasHealthChanged() {
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index a39305a3..ba8504c2 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -28,11 +28,11 @@ HasHealthIF::HealthState HealthHelper::getHealth() {
 }
 
 ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQeueue(parentQueue);
+	setParentQueue(parentQueue);
 	return initialize();
 }
 
-void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
 	this->parentQueue = parentQueue;
 }
 
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index a17a69f3..e112ad2c 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -79,7 +79,7 @@ public:
 	/**
 	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
 	 */
-	void setParentQeueue(MessageQueueId_t parentQueue);
+	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *

From 6425c0dd4c43ba0fa0711d5d894ae76a1858782f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 26 Jul 2020 03:12:04 +0200
Subject: [PATCH 0594/1292] better init error output

---
 osal/FreeRTOS/Mutex.cpp | 2 +-
 osal/FreeRTOS/Mutex.h   | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 6d90c3f6..8a5c444d 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -8,7 +8,7 @@ const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
-		sif::error << "Mutex: Creation failure" << std::endl;
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
 	}
 }
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index d6e0aab9..37f1791c 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -20,6 +20,7 @@ public:
 	~Mutex();
 	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
+
 private:
 	SemaphoreHandle_t handle;
 };

From afc16ef2d72dd6662ecb19c4a08a9aedc2119aab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 12:49:18 +0200
Subject: [PATCH 0595/1292] new servicei nterface buffer /stream

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 12 ++++++------
 serviceinterface/ServiceInterfaceBuffer.h   |  2 +-
 serviceinterface/ServiceInterfaceStream.cpp |  2 +-
 serviceinterface/ServiceInterfaceStream.h   |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5c80862c..8c510eac 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -78,9 +78,9 @@ int ServiceInterfaceBuffer::sync(void) {
 	}
 
 	size_t preambleSize  = 0;
-	auto preamble = getPreamble(&preambleSize);
+	std::string* preamble = getPreamble(&preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.data(), preamble.data() + preambleSize);
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -92,7 +92,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 	return buffered;
 }
 
-std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
@@ -110,18 +110,18 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 					loggerTime.usecond /1000);
 	if(charCount < 0) {
 		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return "";
+		return &preamble;
 	}
 	if(charCount > MAX_PREAMBLE_SIZE) {
 		printf("ServiceInterfaceBuffer: Char count too large for maximum "
 				"preamble size");
-		return "";
+		return &preamble;
 	}
 	currentSize += charCount;
 	if(preambleSize != nullptr) {
 		*preambleSize = currentSize;
 	}
-	return preamble;
+	return &preamble;
 }
 
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 39ea25c2..7a2ce2ee 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -60,7 +60,7 @@ private:
 	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
-	std::string getPreamble(size_t * preambleSize = nullptr);
+	std::string* getPreamble(size_t * preambleSize = nullptr);
 };
 
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 76481ed1..31bc7c73 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -9,7 +9,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 	this->streambuf.isActive = myActive;
 }
 
-std::string ServiceInterfaceStream::getPreamble() {
+std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 9e19c228..dc111459 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -33,7 +33,7 @@ public:
 	 * the unbuffered mode.
 	 * @return Preamle consisting of log message and timestamp.
 	 */
-	std::string getPreamble();
+	std::string* getPreamble();
 
 	/**
 	 * This prints an error with a preamble. Useful if using the unbuffered

From 69f9ff02f047917c2c6a622bcb6fc6244d60564f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 17:00:51 +0200
Subject: [PATCH 0596/1292] better returnvalue for failed  comIF init

---
 devicehandlers/DeviceHandlerBase.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 9f4c7baf..1e7ebf04 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -128,7 +128,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		return result;
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);

From 9acf82cf510be6dfd0f7e94601cdf4795213e5f4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 18:12:10 +0200
Subject: [PATCH 0597/1292] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 2 ++
 devicehandlers/DeviceHandlerIF.h   | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ddbf6041..632db5e0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -379,6 +379,8 @@ protected:
 	 * @param deviceCommand	Identifier of the command to add.
 	 * @param maxDelayCycles The maximum number of delay cycles the command
 	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
 	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
 	 * by the device repeatedly without request) or not. Default is aperiodic (0)
 	 * @return	- @c RETURN_OK when the command was successfully inserted,
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index cb190344..59302080 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -98,7 +98,7 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
 	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If the command size is 0. Checked in DHB
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
 	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
 	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
 	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);

From 9fa9421ba58d4c6793aa19886ce6ee17e7f85d71 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 20:57:05 +0200
Subject: [PATCH 0598/1292] important bugfix

---
 fdir/FailureIsolationBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 083f5af0..4df56dcd 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -104,9 +104,9 @@ MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
 ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
 		MessageQueueId_t destination) {
 	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != 0) {
+	if (destination != MessageQueueIF::NO_QUEUE) {
 		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != 0) {
+	} else if (faultTreeParent != objects::NO_OBJECT) {
 		return eventQueue->sendToDefault(event);
 	}
 	return RETURN_FAILED;

From c64aa9f7f55e4afbc5f21cf149bfc71a889a06e5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 28 Jul 2020 21:00:11 +0200
Subject: [PATCH 0599/1292] another important bugfix

---
 fdir/FailureIsolationBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index dea149bd..6010baca 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -45,7 +45,7 @@ protected:
 	virtual ReturnValue_t confirmFault(EventMessage* event);
 	virtual void decrementFaultCounters() = 0;
 	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = 0);
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);
 private:

From 276c3b172e18df8b7f457e23fb43c22e9c332553 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jul 2020 15:32:36 +0200
Subject: [PATCH 0600/1292] better diagnostic warning for DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1e7ebf04..a4346afb 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -680,16 +680,24 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		switch (result) {
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
 			break;
 		case APERIODIC_REPLY: {
 			result = interpretDeviceReply(foundId, receivedData);
 			if (result != RETURN_OK) {
-				replyRawReplyIfnotWiretapped(receivedData, foundLen);
-				triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-						foundId);
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
 			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			break;
 		}
-		break;
 		case IGNORE_REPLY_DATA:
 			break;
 		case IGNORE_FULL_PACKET:

From 18899a4c828262258699d9c80beab12cd251b506 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 29 Jul 2020 20:07:24 +0200
Subject: [PATCH 0601/1292] hotfix for deadline checking

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 19 +++++++++----------
 osal/FreeRTOS/PeriodicTask.cpp      | 19 +++++++++----------
 2 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 630952d2..1dc45b1d 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -125,19 +125,18 @@ void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-    // Tick count has overflown
-    if(currentTickCount < xLastWakeTime) {
-        // Time to wake has overflown as well. If the tick count
-        // is larger than the time to wake, a deadline was missed.
-        if(timeToWake < xLastWakeTime and
-                currentTickCount > timeToWake) {
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
             handleMissedDeadline();
         }
     }
-    // No tick count overflow. If the timeToWake has not overflown
-    // and the current tick count is larger than the time to wake,
-    // a deadline was missed.
-    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
 }
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f960d8bb..817cb06f 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -109,19 +109,18 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-    // Tick count has overflown
-    if(currentTickCount < xLastWakeTime) {
-        // Time to wake has overflown as well. If the tick count
-        // is larger than the time to wake, a deadline was missed.
-        if(timeToWake < xLastWakeTime and
-                currentTickCount > timeToWake) {
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
             handleMissedDeadline();
         }
     }
-    // No tick count overflow. If the timeToWake has not overflown
-    // and the current tick count is larger than the time to wake,
-    // a deadline was missed.
-    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
 }

From 58a4f4f8a1d9608b671cd6fab087afea5d086dc1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 16:39:17 +0200
Subject: [PATCH 0602/1292] command message bugfix, CSB improvement

parameter helper diagnostic message
---
 ipc/CommandMessage.cpp                 | 1 +
 parameters/ParameterHelper.cpp         | 7 ++++---
 parameters/ParameterHelper.h           | 6 ++++++
 tmtcservices/CommandingServiceBase.cpp | 8 ++++----
 4 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 8c296abd..cc1185c7 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -88,6 +88,7 @@ void CommandMessage::setToUnknownCommand() {
 
 void CommandMessage::setReplyRejected(ReturnValue_t reason,
         Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
     setParameter(reason);
     setParameter2(initialCommand);
 }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e40ed675..53f1229f 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -26,7 +26,6 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 	}
 		break;
 	case ParameterMessage::CMD_PARAMETER_LOAD: {
-
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(message));
 		uint16_t parameterId = HasParametersIF::getMatrixId(
@@ -34,12 +33,14 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		uint8_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(message));
 
-		const uint8_t *storedStream;
-		size_t storedStreamSize;
+		const uint8_t *storedStream = nullptr;
+		size_t storedStreamSize = 0;
 		result = storage->getData(
 				ParameterMessage::getStoreId(message), &storedStream,
 				&storedStreamSize);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "ParameterHelper::handleParameterMessage: Getting"
+					" store data failed for load command." << std::endl;
 			break;
 		}
 
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 352cf0a9..538aaac6 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -5,6 +5,12 @@
 #include <framework/parameters/ParameterMessage.h>
 #include <framework/parameters/ReceivesParameterMessagesIF.h>
 
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
 class ParameterHelper {
 public:
 	ParameterHelper(ReceivesParameterMessagesIF *owner);
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4c9b5375..80a28093 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -126,11 +126,11 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 			&nextCommand, iter->objectId, &isStep);
 
 	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED is returned), a failure verification
-	 * will be generated with the reason as the return code and the initial
-	 * command as failure parameter 1 */
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
 	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
-			result == RETURN_FAILED) {
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
 	    failureParameter1 = iter->command;
 	}

From 66eac57e3bb77c73a4030d1320a64b42e5841641 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 16:54:54 +0200
Subject: [PATCH 0603/1292] csb update

---
 tmtcservices/CommandingServiceBase.cpp |  6 +++---
 tmtcservices/CommandingServiceBase.h   | 17 ++++++++---------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 80a28093..330fd00f 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -129,7 +129,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
 	 * failure verification will be generated with the reason as the
 	 * return code and the initial command as failure parameter 1 */
-	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
 			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
 	    failureParameter1 = iter->command;
@@ -230,8 +230,8 @@ void CommandingServiceBase::handleRequestQueue() {
 		address = message.getStorageId();
 		packet.setStoreAddress(address);
 
-		if (packet.getSubService() == 0
-				or isValidSubservice(packet.getSubService()) != RETURN_OK) {
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
 			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
 			continue;
 		}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 1bd18571..b3a15985 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -87,7 +87,7 @@ public:
 	 * @param opCode is unused here at the moment
 	 * @return RETURN_OK
 	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual uint16_t getIdentifier();
 
@@ -116,7 +116,7 @@ public:
 	 * 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);
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 
 protected:
 	/**
@@ -173,9 +173,7 @@ protected:
 	 * This function is implemented by child services to specify how replies
 	 * to a command from another software component are handled.
 	 * @param reply
-	 * This is the reply which can be accessed via the command message
-	 * interface. The internal message pointer can be passed to different
-	 * command message implementations (see CommandMessageIF)
+	 * This is the reply in form of a generic read-only command message.
 	 * @param previousCommand
 	 * Command_t of related command
 	 * @param state [out/in]
@@ -189,10 +187,11 @@ protected:
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
 	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
-	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
-	 *   a failure verification message with the reason as the error parameter
-	 *   and the initial command as failure parameter 1.
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage* reply,
 			Command_t previousCommand, uint32_t *state,

From ebf5d41a7880f4c866fa1eb29113ecc960bd0efc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 1 Aug 2020 19:03:03 +0200
Subject: [PATCH 0604/1292] parameters IF doc and improvement

---
 parameters/HasParametersIF.h    | 19 +++++--
 parameters/ParameterWrapper.cpp | 24 ++++-----
 parameters/ParameterWrapper.h   | 91 +++++++++++++++++++++------------
 3 files changed, 84 insertions(+), 50 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index fbb69445..02f36318 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -5,8 +5,23 @@
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <stdint.h>
 
+/** Each parameter is identified with a unique parameter ID */
 typedef uint32_t ParameterId_t;
 
+/**
+ * @brief	This interface is used by components which have modifiable
+ * 			parameters, e.g. atittude controllers
+ * @details
+ * Each parameter has a unique parameter ID. The first byte of the parameter
+ * ID is the domain ID which can be used to identify unqiue spacecraft domains
+ * (e.g. control and sensor domain in the AOCS controller).
+ *
+ * The second and third byte represent the matrix ID, which can represent
+ * a 8-bit row and column number and the last byte...
+ *
+ * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
+ * of a 8 bit number now?
+ */
 class HasParametersIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
@@ -32,13 +47,11 @@ public:
 		return (domainId << 24) + (parameterId << 8) + index;
 	}
 
-	virtual ~HasParametersIF() {
-	}
+	virtual ~HasParametersIF() {}
 
 	/**
 	 * Always set parameter before checking newValues!
 	 *
-	 *
 	 * @param domainId
 	 * @param parameterId
 	 * @param parameterWrapper
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 7daf738c..521a6644 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,20 +1,19 @@
 #include <framework/parameters/ParameterWrapper.h>
 
 ParameterWrapper::ParameterWrapper() :
-		pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data(
-		NULL), readonlyData(NULL) {
+		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 		void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-				data), readonlyData(data) {
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(data), readonlyData(data) {
 }
 
 ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
 		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns), data(
-		NULL), readonlyData(data) {
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
 }
 
 ParameterWrapper::~ParameterWrapper() {
@@ -266,15 +265,14 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 			result = UNKNOW_DATATYPE;
 			break;
 		}
-	} else {
+	}
+	else {
 		//need a type to do arithmetic
-		uint8_t *toDataWithType = (uint8_t*) data;
+		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			memcpy(
-					toDataWithType
-							+ (((startingRow + fromRow) * columns)
-									+ startingColumn) * typeSize,
-					from->readonlyData, typeSize * from->columns);
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
 		}
 	}
 
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index a00c997c..eec101f2 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,5 +1,5 @@
-#ifndef PARAMETERWRAPPER_H_
-#define PARAMETERWRAPPER_H_
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <framework/serialize/SerializeAdapter.h>
@@ -7,6 +7,10 @@
 #include <stddef.h>
 #include <framework/globalfunctions/Type.h>
 
+/**
+ * @brief
+ * @details
+ */
 class ParameterWrapper: public SerializeIF {
 	friend class DataPoolParameterWrapper;
 public:
@@ -36,32 +40,21 @@ public:
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
 
+	/**
+	 * Get a specific parameter value by supplying the row and the column.
+	 * @tparam T Type of target data
+	 * @param value [out] Pointer to storage location
+	 * @param row
+	 * @param column
+	 * @return
+	 * -@c RETURN_OK if element was retrieved successfully
+	 * -@c NOT_SET data has not been set yet
+	 * -@c DATATYPE_MISSMATCH Invalid supplied type
+	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
+	 */
 	template<typename T>
-	ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
-		if (readonlyData == NULL){
-			return NOT_SET;
-		}
-
-		if (PodTypeConversion<T>::type != type) {
-			return DATATYPE_MISSMATCH;
-		}
-
-		if ((row >= rows) || (column >= columns)) {
-			return OUT_OF_BOUNDS;
-		}
-
-		if (pointsToStream) {
-			const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
-			streamWithtype += (row * columns + column) * type.getSize();
-			int32_t size = type.getSize();
-			return SerializeAdapter::deSerialize(value, &streamWithtype,
-					&size, true);
-		} else {
-			const T *dataWithType = (const T *) readonlyData;
-			*value = dataWithType[row * columns + column];
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
+	ReturnValue_t getElement(T *value, uint8_t row = 0,
+			uint8_t column = 0) const;
 
 	template<typename T>
 	void set(T *data, uint8_t rows, uint8_t columns) {
@@ -111,21 +104,22 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
+
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
-			const uint8_t **remainingStream = NULL, size_t *remainingSize =
-					NULL);
+			const uint8_t **remainingStream = nullptr,
+			size_t *remainingSize = nullptr);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,
 			uint16_t startWritingAtIndex);
 
 private:
-	bool pointsToStream;
+	bool pointsToStream = false;
 
 	Type type;
-	uint8_t rows;
-	uint8_t columns;
-	void *data;
-	const void *readonlyData;
+	uint8_t rows = 0;
+	uint8_t columns = 0;
+	void *data = nullptr;
+	const void *readonlyData = nullptr;
 
 	template<typename T>
 	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
@@ -136,4 +130,33 @@ private:
 			const void *from, uint8_t fromRows, uint8_t fromColumns);
 };
 
+template <typename T>
+inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
+		uint8_t column) const {
+	if (readonlyData == nullptr){
+		return NOT_SET;
+	}
+
+	if (PodTypeConversion<T>::type != type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	if ((row >= rows) or (column >= columns)) {
+		return OUT_OF_BOUNDS;
+	}
+
+	if (pointsToStream) {
+		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
+		streamWithType += (row * columns + column) * type.getSize();
+		int32_t size = type.getSize();
+		return SerializeAdapter::deSerialize(value, &streamWithType,
+				&size, true);
+	}
+	else {
+		const T *dataWithType = static_cast<const T*>(readonlyData);
+		*value = dataWithType[row * columns + column];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
 #endif /* PARAMETERWRAPPER_H_ */

From f240827bbdd9ad7542e21ca5810235e6acb20c96 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 00:59:19 +0200
Subject: [PATCH 0605/1292] added getFreeElement

---
 container/SimpleRingBuffer.h | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index cf78814f..9a548815 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -16,12 +16,17 @@ class SimpleRingBuffer: public RingBufferBase<> {
 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.
+     * @param overwriteOld If the ring buffer is overflowing at a write
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * with getFreeElement.
+     *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld);
+	SimpleRingBuffer(const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
 	/**
 	 * This constructor takes an external buffer with the specified size.
 	 * @param buffer
@@ -29,8 +34,13 @@ public:
 	 * @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);
+	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+	        size_t maxExcessBytes = 0);
 
 	virtual ~SimpleRingBuffer();
 
@@ -43,6 +53,17 @@ public:
 	 */
 	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);
+
 	/**
 	 * Read from circular buffer at read pointer.
 	 * @param data
@@ -82,6 +103,8 @@ public:
 private:
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
+	const size_t maxExcessBytes;
+	size_t excessBytes = 0;
 };
 
 #endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */

From 0ead44bea976bba70676fc40ed9716f2ae6b84d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 01:07:59 +0200
Subject: [PATCH 0606/1292] getFreeElement implemented

---
 container/SimpleRingBuffer.cpp | 44 ++++++++++++++++++++++++++++++----
 container/SimpleRingBuffer.h   |  8 +++++++
 2 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 69d94143..3cc1ffdf 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,20 +1,43 @@
 #include <framework/container/SimpleRingBuffer.h>
 #include <cstring>
 
-SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld) :
-		RingBufferBase<>(0, size, overwriteOld) {
-	buffer = new uint8_t[size];
+SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
+        size_t maxExcessBytes) :
+		RingBufferBase<>(0, size, overwriteOld),
+		maxExcessBytes(maxExcessBytes) {
+	buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-        bool overwriteOld):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {}
+        bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer),
+        maxExcessBytes(maxExcessBytes) {}
 
 
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
 
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes += amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 		size_t amount) {
 	if (availableWriteSpace() >= amount or overwriteOld) {
@@ -62,6 +85,17 @@ ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 		bool deleteRemaining, size_t* trueAmount) {
 	size_t availableData = availableReadData(READ_PTR);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 9a548815..4bb3a4e8 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -64,6 +64,14 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
+	size_t getExcessBytes() const;
+	/**
+	 * Helper functions which moves any excess bytes to the start
+	 * of the ring buffer.
+	 * @return
+	 */
+	void moveExcessBytesToStart();
+
 	/**
 	 * Read from circular buffer at read pointer.
 	 * @param data

From 4e9e465360b2b4757699e79b265c12358ac5e8db Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 02:00:00 +0200
Subject: [PATCH 0607/1292] shared ring buffer continued

---
 container/SimpleRingBuffer.cpp | 20 ++++++++++++++++----
 container/SimpleRingBuffer.h   |  2 +-
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 3cc1ffdf..cad1a48e 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -2,16 +2,28 @@
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-        size_t 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):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer),
-        maxExcessBytes(maxExcessBytes) {}
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
 
 
 SimpleRingBuffer::~SimpleRingBuffer() {
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 4bb3a4e8..2627541f 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -111,7 +111,7 @@ public:
 private:
 	static const uint8_t READ_PTR = 0;
 	uint8_t* buffer = nullptr;
-	const size_t maxExcessBytes;
+	size_t maxExcessBytes;
 	size_t excessBytes = 0;
 };
 

From 6b475792a4a7c57a5006a010c554dda8b31d41b7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 02:25:10 +0200
Subject: [PATCH 0608/1292] shared ring buffer continued

---
 container/SharedRingBuffer.cpp | 19 +++++++++++++------
 container/SharedRingBuffer.h   |  9 +++++++--
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 64cbc669..86277a80 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,19 +3,26 @@
 #include <framework/ipc/MutexHelper.h>
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld),
-		mutexTimeout(mutexTimeout) {
+		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+		maxExcessBytes), mutexTimeout(mutexTimeout) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, dur_millis_t mutexTimeout):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld),
-		mutexTimeout(mutexTimeout) {
+		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();
 }
 
+ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
+		size_t amount) {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::getFreeElement(writePtr,amount);
+}
+
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
 		size_t amount) {
 	MutexHelper(mutex, mutexTimeout);
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index f7d3bc3c..7fed7b22 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -17,7 +17,8 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes,
+			dur_millis_t mutexTimeout = 10);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -28,10 +29,14 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes,
+			dur_millis_t mutexTimeout = 10);
 
 	void setMutexTimeout(dur_millis_t newTimeout);
 
+	/** 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);
 

From 4dcfa5125edf80f2bc6bde7861e1da394b4d7a4e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 11:47:47 +0200
Subject: [PATCH 0609/1292] added additional calls

---
 container/SharedRingBuffer.cpp | 10 ++++++++++
 container/SharedRingBuffer.h   |  8 ++++++++
 container/SimpleRingBuffer.cpp |  2 +-
 container/SimpleRingBuffer.h   |  4 ++--
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 86277a80..2fde2851 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -43,6 +43,16 @@ ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
 	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
 }
 
+size_t SharedRingBuffer::getExcessBytes() const {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::getExcessBytes();
+}
+
+void SharedRingBuffer::moveExcessBytesToStart() {
+	MutexHelper(mutex, mutexTimeout);
+	return SimpleRingBuffer::moveExcessBytesToStart();
+}
+
 size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
 	MutexHelper(mutex, mutexTimeout);
 	return ((write + size) - read[n]) % size;
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 7fed7b22..8d68b967 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -34,6 +34,14 @@ public:
 
 	void setMutexTimeout(dur_millis_t newTimeout);
 
+	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);
 
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index cad1a48e..36880813 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -39,7 +39,7 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
             if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
                 return HasReturnvaluesIF::RETURN_FAILED;
             }
-            excessBytes += amount - amountTillWrap;
+            excessBytes = amount - amountTillWrap;
         }
         *writePointer = &buffer[write];
         incrementWrite(amount);
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 2627541f..0784e415 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -64,13 +64,13 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	size_t getExcessBytes() const;
+	virtual size_t getExcessBytes() const;
 	/**
 	 * Helper functions which moves any excess bytes to the start
 	 * of the ring buffer.
 	 * @return
 	 */
-	void moveExcessBytesToStart();
+	virtual void moveExcessBytesToStart();
 
 	/**
 	 * Read from circular buffer at read pointer.

From 2177877625aa1543c585504505b55b49fd1c2904 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:16:09 +0200
Subject: [PATCH 0610/1292] updated framework subsystem ID ranges

---
 events/fwSubsystemIdRanges.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 4c261e57..a05652c2 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -18,6 +18,8 @@ enum {
 	SYSTEM_MANAGER = 74,
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
+	PUS_SERVICE_1 = 80,
+	FW_SUBSYSTEM_ID_RANGE
 };
 }
 

From 4d3f0875c18a69147c18f99d401175e5b64c361f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:23:37 +0200
Subject: [PATCH 0611/1292] periodic task if adapted

---
 osal/FreeRTOS/PeriodicTask.cpp   |  7 ++-----
 osal/FreeRTOS/PeriodicTask.h     |  3 +--
 osal/linux/PeriodicPosixTask.cpp | 11 +++--------
 osal/linux/PeriodicPosixTask.h   |  3 +--
 tasks/PeriodicTaskIF.h           |  3 +--
 5 files changed, 8 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 817cb06f..cc29edae 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -90,12 +90,9 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
 
-	if(setTaskIF) {
-	     newObject->setTaskIF(this);
-	}
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	return newObject->initializeAfterTaskCreation();
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index ca2c5324..2be2521c 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -65,8 +65,7 @@ public:
 	 * -@c RETURN_OK on success
 	 * -@c RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) override;
+	ReturnValue_t addComponent(object_id_t object) override;
 
 	uint32_t getPeriodMs() const override;
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 4b0c77fc..cd487531 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -22,8 +22,7 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 	return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
-		bool setTaskIF) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
@@ -32,13 +31,9 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
 
-	if(setTaskIF) {
-	    newObject->setTaskIF(this);
-	}
-
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	return newObject->initializeAfterTaskCreation();
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 9b477e36..0b2d51cd 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -39,8 +39,7 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) override;
+	ReturnValue_t addComponent(object_id_t object) override;
 
 	uint32_t getPeriodMs() const override;
 
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 6f490977..f54d6155 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -36,8 +36,7 @@ public:
 	 * to the component.
 	 * @return
 	 */
-	virtual ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) {
+	virtual ReturnValue_t addComponent(object_id_t object) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 

From 3f87537c6106feb54ab0151247be0ad300a88580 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 15:25:24 +0200
Subject: [PATCH 0612/1292] minor corrections

---
 osal/FreeRTOS/PeriodicTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index cc29edae..f2dcd093 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -81,7 +81,7 @@ void PeriodicTask::taskFunctionality() {
 	}
 }
 
-ReturnValue_t PeriodicTask::addComponent(object_id_t object, bool setTaskIF) {
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {

From c4ffb1acd5bff2a8214ddb9f4336d081b3f84636 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 18:12:15 +0200
Subject: [PATCH 0613/1292] subservice number correction

---
 pus/servicepackets/Service1Packets.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index b01942c6..4a2c7cbc 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -16,7 +16,7 @@
  * @brief 	Subservice 1, 3, 5, 7
  * @ingroup spacepackets
  */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
 public:
 	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_, uint8_t stepNumber_,
@@ -111,7 +111,7 @@ private:
  * @brief       Subservices 2, 4, 6, 8
  * @ingroup     spacepackets
  */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
 public:
 	SuccessReport(uint8_t subtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_,uint8_t stepNumber_) :

From 66039bd3feb553e913fe8440a48e09c1b8843166 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 4 Aug 2020 18:14:39 +0200
Subject: [PATCH 0614/1292] move group def down

---
 pus/servicepackets/Service1Packets.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 4a2c7cbc..4ba493d0 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,3 +1,9 @@
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -5,12 +11,6 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
 /**
  * @brief 	FailureReport class to serialize a failure report
  * @brief 	Subservice 1, 3, 5, 7

From 1a118fe215350eb321184bae30777278095cb1c7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 19:21:47 +0200
Subject: [PATCH 0615/1292] added documentation to assembly base

---
 devicehandlers/AssemblyBase.cpp |  5 +-
 devicehandlers/AssemblyBase.h   | 85 ++++++++++++++++++++++-----------
 subsystem/SubsystemBase.cpp     | 10 ++--
 3 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index bd85d1de..f5657327 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -165,9 +165,8 @@ ReturnValue_t AssemblyBase::checkChildrenState() {
 }
 
 ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (std::map<object_id_t, ChildInfo>::iterator iter = childrenMap.begin();
-			iter != childrenMap.end(); iter++) {
-		if (checkChildOff(iter->first) != RETURN_OK) {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
 			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
 		}
 	}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index ee121032..d0dc868c 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,10 +1,30 @@
-#ifndef ASSEMBLYBASE_H_
-#define ASSEMBLYBASE_H_
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
 
 #include <framework/container/FixedArrayList.h>
 #include <framework/devicehandlers/DeviceHandlerBase.h>
 #include <framework/subsystem/SubsystemBase.h>
 
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
 class AssemblyBase: public SubsystemBase {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
@@ -16,10 +36,41 @@ public:
 	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
 			MAKE_RETURN_CODE(0xa1);
 
-	AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth = 8);
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
 	virtual ~AssemblyBase();
 
 protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
 	enum InternalState {
 		STATE_NONE,
 		STATE_OVERWRITE_HEALTH,
@@ -36,6 +87,7 @@ protected:
 		RECOVERY_WAIT
 	} recoveryState; //!< Indicates if one of the children requested a recovery.
 	ChildrenMap::iterator recoveringDevice;
+
 	/**
 	 * the mode the current transition is trying to achieve.
 	 * Can be different from the modehelper.commandedMode!
@@ -61,8 +113,8 @@ protected:
 	bool handleChildrenChanged();
 
 	/**
-	 * This method is called if the children changed its mode in a way that the current
-	 * mode can't be kept.
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
 	 * Default behavior is to go to MODE_OFF.
 	 * @param result The failure code which was returned by checkChildrenState.
 	 */
@@ -75,9 +127,6 @@ protected:
 	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
 
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode) = 0;
-
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
 	virtual void doStartTransition(Mode_t mode, Submode_t submode);
@@ -90,24 +139,6 @@ protected:
 
 	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
 
-	//SHOULDDO: Change that OVERWRITE_HEALTH may be returned (or return internalState directly?)
-	/**
-	 * command children to reach mode,submode
-	 *
-	 * set #commandsOutstanding correctly, or use executeTable()
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if ok
-	 *    - @c NEED_SECOND_STEP if children need to be commanded again
-	 */
-	virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-	//SHOULDDO: Remove wantedMode, wantedSubmode, as targetMode/submode is available?
-	virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-			Submode_t wantedSubmode) = 0;
-
 	virtual ReturnValue_t checkChildrenStateOff();
 
 	ReturnValue_t checkChildrenState();
@@ -129,4 +160,4 @@ protected:
 
 };
 
-#endif /* ASSEMBLYBASE_H_ */
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 737accef..51c35f1f 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -5,9 +5,9 @@
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE), childrenChangedMode(
-		false), commandsOutstanding(0), commandQueue(NULL), healthHelper(this,
-				setObjectId), modeHelper(this), parentId(parent) {
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
 			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
@@ -23,8 +23,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
 	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
 	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == NULL) {
-		if (healthChild == NULL) {
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
 			return CHILD_DOESNT_HAVE_MODES;
 		} else {
 			info.commandQueue = healthChild->getCommandQueue();

From bfecbfbd80a9f64f84b55246b742c07bf1beccf9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 20:36:37 +0200
Subject: [PATCH 0616/1292] implemented new mutex interface

---
 datapoolglob/GlobalDataPool.cpp |  3 ++-
 datapoollocal/LocalDataSet.cpp  |  2 +-
 ipc/MutexHelper.h               |  3 ++-
 ipc/MutexIF.h                   | 37 ++++++++++++++++++---------------
 osal/FreeRTOS/Mutex.cpp         | 15 +++++++------
 osal/FreeRTOS/Mutex.h           |  3 ++-
 osal/linux/Mutex.cpp            | 12 ++++++++---
 osal/linux/Mutex.h              |  2 +-
 subsystem/SubsystemBase.cpp     |  5 +++--
 9 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 25acaab3..9dedb4b8 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -54,7 +54,8 @@ ReturnValue_t GlobalDataPool::unlockDataPool() {
 }
 
 ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(timeoutMs);
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
 	if(status != RETURN_OK) {
 		sif::error << "DataPool::DataPool: lock of mutex failed "
 				"with error code: " << status << std::endl;
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2a42cd38..8725f697 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -38,7 +38,7 @@ LocalDataSet::~LocalDataSet() {
 
 ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index c9579e9b..fc6e38bf 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -8,7 +8,8 @@ class MutexHelper {
 public:
 	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
 			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutMs);
+		ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 29e59e58..b174fe0d 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -12,20 +12,25 @@
  */
 class MutexIF {
 public:
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex.
+     * @param timeoutType
+     * @param timeoutMs
+     * This value will only be used for TimeoutType::WAIT
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
@@ -77,9 +82,7 @@ public:
 	 */
 	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
 
-	virtual ~MutexIF() {}
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs) = 0;
-	virtual ReturnValue_t unlockMutex() = 0;
+    virtual ~MutexIF() {}
 };
 
 
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 8a5c444d..764b0ae0 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -2,9 +2,6 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
-
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
@@ -19,15 +16,17 @@ Mutex::~Mutex() {
 
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
 	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = MutexIF::POLLING;
-	if(timeoutMs == MutexIF::BLOCKING) {
-		timeout = MutexIF::BLOCKING;
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 37f1791c..2a4fae26 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,8 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
 	ReturnValue_t unlockMutex() override;
 
 private:
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index bdcf3439..c99fe531 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -40,9 +40,13 @@ Mutex::~Mutex() {
 	pthread_mutex_destroy(&mutex);
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	int status = 0;
-	if (timeoutMs != MutexIF::BLOCKING) {
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	else if (timeoutType == TimeoutType::WAITING) {
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
@@ -50,9 +54,11 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 		timeOut.tv_sec = nseconds / 1000000000;
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	} else {
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
 		status = pthread_mutex_lock(&mutex);
 	}
+
 	switch (status) {
 	case EINVAL:
 		//The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority is higher than the mutex's current priority ceiling.
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 607337ae..26420c2e 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -12,7 +12,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs);
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
 	virtual ReturnValue_t unlockMutex();
 private:
 	pthread_mutex_t mutex;
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 51c35f1f..71fa81b7 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -76,14 +76,15 @@ ReturnValue_t SubsystemBase::checkStateAgainstTable(
 	return RETURN_OK;
 }
 
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
 	CommandMessage command;
 
 	std::map<object_id_t, ChildInfo>::iterator iter;
 
 	commandsOutstanding = 0;
 
-	for (; tableIter.value != NULL; ++tableIter) {
+	for (; tableIter.value != nullptr; ++tableIter) {
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table

From 37f2539d894b8f1e9b85fd29005032c9bd4ba12a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 20:44:40 +0200
Subject: [PATCH 0617/1292] empty line removed

---
 ipc/MutexIF.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index b174fe0d..0d0cb444 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -5,7 +5,6 @@
 
 /**
  * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- *
  * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
  * @ingroup osal
  * @ingroup interface

From e3d094b2dec8ddc838a0f70218b0200b8c1b1ce4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:02:23 +0200
Subject: [PATCH 0618/1292] linux: removed old static timeout values

---
 osal/linux/Mutex.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index c99fe531..03789e62 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -2,8 +2,6 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/timemanager/Clock.h>
 
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-const uint32_t MutexIF::POLLING = 0;
 uint8_t Mutex::count = 0;
 
 
@@ -61,22 +59,28 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 
 	switch (status) {
 	case EINVAL:
-		//The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority is higher than the mutex's current priority ceiling.
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
 		return WRONG_ATTRIBUTE_SETTING;
-		//The process or thread would have blocked, and the abs_timeout parameter specified a nanoseconds field value less than zero or greater than or equal to 1000 million.
-		//The value specified by mutex does not refer to an initialized mutex object.
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
 		//return MUTEX_NOT_FOUND;
 	case EBUSY:
-		//The mutex could not be acquired because it was already locked.
+		// The mutex could not be acquired because it was already locked.
 		return MUTEX_ALREADY_LOCKED;
 	case ETIMEDOUT:
-		//The mutex could not be locked before the specified timeout expired.
+		// The mutex could not be locked before the specified timeout expired.
 		return MUTEX_TIMEOUT;
 	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
 		return MUTEX_MAX_LOCKS;
 	case EDEADLK:
-		//A deadlock condition was detected or the current thread already owns the mutex.
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
 		return CURR_THREAD_ALREADY_OWNS_MUTEX;
 	case 0:
 		//Success

From 44b70b45e216600bf5cfdca4899166f6bad0fd41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:06:20 +0200
Subject: [PATCH 0619/1292] little doc correction

---
 ipc/MutexIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 0d0cb444..b0096a34 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -21,10 +21,10 @@ public:
     };
 
     /**
-     * Lock the mutex.
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
      * @param timeoutType
      * @param timeoutMs
-     * This value will only be used for TimeoutType::WAIT
      * @return
      */
     virtual ReturnValue_t lockMutex(TimeoutType timeoutType =

From 458e849f7d86ca95b0a3ae675d4d00895e26ede8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:11:13 +0200
Subject: [PATCH 0620/1292] adapting mutex helper to new interface

---
 ipc/MutexHelper.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index fc6e38bf..a8949737 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -6,9 +6,10 @@
 
 class MutexHelper {
 public:
-	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs) :
 			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "

From 979fea3400668661d817621766c64af1a62ed379 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 7 Aug 2020 22:15:03 +0200
Subject: [PATCH 0621/1292] mutex helper api change

---
 container/SharedRingBuffer.cpp      | 14 +++++++-------
 datapoollocal/LocalPoolVariable.tpp |  6 ++++--
 datapoollocal/LocalPoolVector.tpp   |  6 ++++--
 ipc/MutexHelper.h                   |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp    |  2 +-
 storagemanager/PoolManager.tpp      |  9 ++++++---
 6 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 2fde2851..a8b06b01 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -19,41 +19,41 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 
 ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
 		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::getFreeElement(writePtr,amount);
 }
 
 ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
 		size_t amount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::writeData(data,amount);
 }
 
 ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
 		bool incrementReadPtr, bool readRemaining,
 		size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
 			readRemaining, trueAmount);
 }
 
 ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
 		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
 }
 
 size_t SharedRingBuffer::getExcessBytes() const {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::getExcessBytes();
 }
 
 void SharedRingBuffer::moveExcessBytesToStart() {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return SimpleRingBuffer::moveExcessBytesToStart();
 }
 
 size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
-	MutexHelper(mutex, mutexTimeout);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
 	return ((write + size) - read[n]) % size;
 }
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 0b96bb4f..b4e09f2d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -48,7 +48,8 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return readWithoutLock();
 }
 
@@ -76,7 +77,8 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return commitWithoutLock();
 }
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index b7f2fe19..7c3d2c1e 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -44,7 +44,8 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -74,7 +75,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), lockTimeout);
+	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
+			lockTimeout);
 	return commitWithoutLock();
 }
 
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index a8949737..52ce51e3 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -7,7 +7,7 @@
 class MutexHelper {
 public:
 	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs) :
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
 			internalMutex(mutex) {
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 92fbbdfa..2cdb93f3 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -85,7 +85,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 }
 
 void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, 10);
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 4ca22b85..0656e967 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,8 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+			mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -33,7 +34,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+				mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -41,7 +43,8 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex, mutexTimeout);
+	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+				mutexTimeout);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;

From a6a1e656071342e70d2408a51289ccfe42de78e4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:17:27 +0200
Subject: [PATCH 0622/1292] local data set fix

---
 datapoollocal/LocalDataSet.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 2af01d04..d91c93e9 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -7,7 +7,7 @@
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+        LocalDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
@@ -20,7 +20,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
 
 LocalDataSet::LocalDataSet(object_id_t ownerId,
         const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+        LocalDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(

From af11c8fcf96c242447baeffbbb9731c9807a6f8e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:38:39 +0200
Subject: [PATCH 0623/1292] freeRTOS corrections

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 5 +++--
 osal/FreeRTOS/FixedTimeslotTask.h   | 2 +-
 osal/FreeRTOS/PeriodicTask.cpp      | 7 ++++---
 osal/FreeRTOS/PeriodicTask.h        | 4 ++--
 osal/FreeRTOS/TaskFactory.cpp       | 8 ++++----
 tasks/Typedef.h                     | 1 -
 6 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 1dc45b1d..2a7bff9c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -5,11 +5,12 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
-FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod overallPeriod,
 		void (*setDeadlineMissedFunc)()) :
 		started(false), handle(NULL), pst(overallPeriod * 1000) {
-	xTaskCreate(taskEntryPoint, name, setStack, this, setPriority, &handle);
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
 	// All additional attributes are applied to the object.
 	this->deadlineMissedFunc = setDeadlineMissedFunc;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index b63cb775..36950773 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -24,7 +24,7 @@ public:
 	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
 	 * @return Pointer to the newly created task.
 	 */
-	FixedTimeslotTask(const char *name, TaskPriority setPriority,
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 			TaskStackSize setStack, TaskPeriod overallPeriod,
 			void (*setDeadlineMissedFunc)());
 
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f2dcd093..c316d4fc 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -5,12 +5,13 @@
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,
-		void (*setDeadlineMissedFunc)()) :
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
 		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		setDeadlineMissedFunc)
+		deadlineMissedFunc)
 {
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			setStack, this, setPriority, &handle);
+			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 2be2521c..8030baad 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -40,9 +40,9 @@ public:
 	 * The function pointer to the deadline missed function that shall
 	 * be assigned.
 	 */
-	PeriodicTask(const char *name, TaskPriority setPriority,
+	PeriodicTask(TaskName name, TaskPriority setPriority,
 	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        void (*setDeadlineMissedFunc)());
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
 	/**
 	 * @brief	Currently, the executed object's lifetime is not coupled with
 	 * 			the task object's lifetime, so the destructor is empty.
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 663b0531..68866f39 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -18,8 +18,8 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (PeriodicTaskIF*) (new PeriodicTask(name_, taskPriority_, stackSize_,
-			period_, deadLineMissedFunction_));
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
 }
 
 /**
@@ -29,8 +29,8 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskPriority taskPriority_, TaskStackSize stackSize_,
 		TaskPeriod period_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return (FixedTimeslotTaskIF*) (new FixedTimeslotTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
 }
 
 ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
diff --git a/tasks/Typedef.h b/tasks/Typedef.h
index b393ee1e..07d96b00 100644
--- a/tasks/Typedef.h
+++ b/tasks/Typedef.h
@@ -1,7 +1,6 @@
 #ifndef FRAMEWORK_TASKS_TYPEDEF_H_
 #define FRAMEWORK_TASKS_TYPEDEF_H_
 
-//TODO more generic?
 typedef const char* TaskName;
 typedef uint8_t TaskPriority;
 typedef size_t TaskStackSize;

From f766398b20a1c148f63d10eaea70aad46bf2f3a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:49:20 +0200
Subject: [PATCH 0624/1292] some bugfixes

---
 datapoollocal/LocalDataSet.cpp                | 70 +------------------
 datapoollocal/LocalDataSet.h                  |  2 +-
 ...taSetBase.cpp => LocalPoolDataSetBase.cpp} |  2 +-
 datapoollocal/SharedLocalDataSet.cpp          |  2 +-
 datapoollocal/StaticLocalDataSet.h            |  4 +-
 5 files changed, 6 insertions(+), 74 deletions(-)
 rename datapoollocal/{LocalDataSetBase.cpp => LocalPoolDataSetBase.cpp} (98%)

diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index d91c93e9..84ed2ae2 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -33,73 +33,5 @@ LocalDataSet::LocalDataSet(object_id_t ownerId,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSet::~LocalDataSet() {
-}
+LocalDataSet::~LocalDataSet() {}
 
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index e6bd2012..820818d7 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -7,7 +7,7 @@ class LocalDataSet: public LocalDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
     LocalDataSet(object_id_t owner, const size_t maxSize);
-    virtual~ LocalDataSet() {};
+    virtual~ LocalDataSet();
 
     //! Copying forbidden for now.
     LocalDataSet(const LocalDataSet&) = delete;
diff --git a/datapoollocal/LocalDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
similarity index 98%
rename from datapoollocal/LocalDataSetBase.cpp
rename to datapoollocal/LocalPoolDataSetBase.cpp
index f490ff67..7c2c0632 100644
--- a/datapoollocal/LocalDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -36,7 +36,7 @@ LocalDataSetBase::~LocalDataSetBase() {
 
 ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(timeoutMs);
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index 6f355a8a..c2b1d21b 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -8,7 +8,7 @@ SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
 }
 
 ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(mutexTimeout);
+    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
 }
 
 ReturnValue_t SharedLocalDataSet::unlockDataset() {
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index fbe1545f..b381ed41 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,6 +1,6 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
 #define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/PoolDataSetBase.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <array>
 
@@ -20,7 +20,7 @@ public:
         LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
     }
 
-    virtual~ StaticLocalDataSet();
+    virtual~ StaticLocalDataSet() {};
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };

From fba8775f49347da75646b0c70e4adbea94cbd1b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 12:51:31 +0200
Subject: [PATCH 0625/1292] some renaming

---
 datapool/PoolVariableIF.h              |  2 +-
 datapoollocal/LocalDataPoolManager.cpp |  6 +++---
 datapoollocal/LocalDataPoolManager.h   |  8 ++++----
 datapoollocal/LocalDataSet.cpp         |  4 ++--
 datapoollocal/LocalDataSet.h           |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 18 +++++++++---------
 datapoollocal/LocalPoolDataSetBase.h   |  8 ++++----
 datapoollocal/SharedLocalDataSet.cpp   |  2 +-
 datapoollocal/SharedLocalDataSet.h     |  2 +-
 datapoollocal/StaticLocalDataSet.h     |  5 ++---
 10 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 6b0dd7fb..3c4b33e6 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -20,7 +20,7 @@
 class PoolVariableIF : public SerializeIF {
 	friend class PoolDataSetBase;
 	friend class GlobDataSet;
-	friend class LocalDataSetBase;
+	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
 	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index afce330f..ec413492 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -116,7 +116,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t sendTo) {
-	LocalDataSetBase* dataSetToSerialize = dynamic_cast<LocalDataSetBase*>(
+	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSetBase* dataSet = dynamic_cast<LocalDataSetBase*>(
+    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
             owner->getDataSetHandle(sid));
     if(dataSet == nullptr) {
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
@@ -186,7 +186,7 @@ void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSetBase* dataSet) {
+        store_address_t *storeId, LocalPoolDataSetBase* dataSet) {
     size_t hkSize = dataSet->getSerializedSize();
     uint8_t* storePtr = nullptr;
     ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9c413aa4..6912f0bc 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-class LocalDataSetBase;
+class LocalPoolDataSetBase;
 
 /**
  * @brief 	This class is the managing instance for local data pool.
@@ -38,7 +38,7 @@ class LocalDataPoolManager {
 	friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
-	friend class LocalDataSetBase;
+	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -154,7 +154,7 @@ private:
      * The data pool manager will keep an internal map of HK receivers.
      */
     struct HkReceiver {
-        LocalDataSetBase* dataSet = nullptr;
+        LocalPoolDataSetBase* dataSet = nullptr;
         lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -222,7 +222,7 @@ private:
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSetBase* dataSet);
+	        LocalPoolDataSetBase* dataSet);
 };
 
 
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 84ed2ae2..d28d089f 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -7,7 +7,7 @@
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
         const size_t maxNumberOfVariables):
-        LocalDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
+        LocalPoolDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     if(hkOwner == nullptr) {
@@ -20,7 +20,7 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
 
 LocalDataSet::LocalDataSet(object_id_t ownerId,
         const size_t maxNumberOfVariables):
-        LocalDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
+        LocalPoolDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
     poolVarList.reserve(maxNumberOfVariables);
     poolVarList.resize(maxNumberOfVariables);
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 820818d7..c3ae7eaa 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -3,7 +3,7 @@
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <vector>
 
-class LocalDataSet: public LocalDataSetBase {
+class LocalDataSet: public LocalPoolDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
     LocalDataSet(object_id_t owner, const size_t maxSize);
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 7c2c0632..f5273cfe 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -5,7 +5,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
@@ -17,7 +17,7 @@ LocalDataSetBase::LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
+LocalPoolDataSetBase::LocalPoolDataSetBase(object_id_t ownerId,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
@@ -31,15 +31,15 @@ LocalDataSetBase::LocalDataSetBase(object_id_t ownerId,
     hkManager = hkOwner->getHkManagerHandle();
 }
 
-LocalDataSetBase::~LocalDataSetBase() {
+LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
-ReturnValue_t LocalDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
-ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
+ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
         size_t *size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
@@ -72,12 +72,12 @@ ReturnValue_t LocalDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
     return result;
 }
 
-ReturnValue_t LocalDataSetBase::unlockDataPool() {
+ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
 }
 
-ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
+ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         size_t* size, size_t maxSize,
         SerializeIF::Endianness streamEndianness) const {
     for (uint16_t count = 0; count < fillCount; count++) {
@@ -93,7 +93,7 @@ ReturnValue_t LocalDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
         return;
@@ -102,6 +102,6 @@ void LocalDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
-bool LocalDataSetBase::isValid() const {
+bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index f7a2cae4..1034fc29 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,14 +30,14 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
-class LocalDataSetBase: public PoolDataSetBase {
+class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
 	 * 			The constructor simply sets the fill_count to zero and sets
 	 *  		the state to "uninitialized".
 	 */
-	LocalDataSetBase(HasLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 	        PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
@@ -49,7 +49,7 @@ public:
 	 * @details
 	 *
 	 */
-	LocalDataSetBase(object_id_t ownerId,
+	LocalPoolDataSetBase(object_id_t ownerId,
 	        PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
@@ -61,7 +61,7 @@ public:
 	 * the destructor parses all variables that are still registered to the set.
 	 * For each, the valid flag in the data pool is set to "invalid".
 	 */
-	~LocalDataSetBase();
+	~LocalPoolDataSetBase();
 
 	/**
 	 * Special version of the serilization function which appends a
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index c2b1d21b..8582d895 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -2,7 +2,7 @@
 
 SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
         const size_t maxSize): SystemObject(objectId),
-        LocalDataSetBase(owner, nullptr, maxSize) {
+        LocalPoolDataSetBase(owner, nullptr, maxSize) {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index acb0cd26..3fbb9ea1 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -13,7 +13,7 @@
  * Then a regular local data set is sufficient.
  */
 class SharedLocalDataSet: public SystemObject,
-        public LocalDataSetBase,
+        public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
     SharedLocalDataSet(object_id_t objectId, object_id_t owner,
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index b381ed41..7b6c47b6 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -14,13 +14,12 @@
  * @tparam capacity
  */
 template <uint8_t NUM_VARIABLES>
-class StaticLocalDataSet: public LocalDataSetBase {
+class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
     StaticLocalDataSet(object_id_t owner):
-        LocalDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+        LocalPoolDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
     }
 
-    virtual~ StaticLocalDataSet() {};
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };

From 5c85d03c39af4e9ec31a03e238dd1994b02ea68a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:04:31 +0200
Subject: [PATCH 0626/1292] additional check for freeRTOS

---
 osal/FreeRTOS/MessageQueue.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 8eb669ed..e9f3871e 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -123,11 +123,20 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault, CallContext callContext) {
+	BaseType_t result = pdFALSE;
+	QueueHandle_t destination = nullptr;
+
+	if(sendTo == MessageQueueIF::NO_QUEUE) {
+		return MessageQueueIF::DESTINVATION_INVALID;
+	}
+	else  {
+		destination = reinterpret_cast<QueueHandle_t>(sendTo);
+	}
     message->setSender(sentFrom);
-    BaseType_t result;
+
 
     if(callContext == CallContext::TASK) {
-        result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+        result = xQueueSendToBack(destination,
                 static_cast<const void*>(message->getBuffer()), 0);
     }
     else {

From 121e94a3854049c4a4075327034f8d492b1b3bb8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:20:02 +0200
Subject: [PATCH 0627/1292] local pool var update

---
 datapoollocal/LocalPoolVariable.h   | 3 +++
 datapoollocal/LocalPoolVariable.tpp | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 73d691d7..93ac14b0 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -116,6 +116,8 @@ public:
 	 */
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
+
+	LocalPoolVar<T> &operator=(T newValue);
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -170,4 +172,5 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
+
 #endif
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a16e1119..6e6f27aa 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -103,6 +103,13 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	return RETURN_OK;
 }
 
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
+    value = newValue;
+    return *this;
+}
+
+
 template<typename T>
 inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
 	return readWriteMode;

From 03cd5780f9b6f915566c07b07482a1b86b103eed Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 13:29:38 +0200
Subject: [PATCH 0628/1292] null initializations in header

---
 fdir/FailureIsolationBase.cpp | 4 ++--
 fdir/FailureIsolationBase.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index 4df56dcd..ad4493ff 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -7,8 +7,8 @@
 
 FailureIsolationBase::FailureIsolationBase(object_id_t owner,
 		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
-		eventQueue(NULL), ownerId(owner), owner(NULL),
-		faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
+		ownerId(owner), faultTreeParent(parent),
+		parameterDomainBase(parameterDomainBase) {
 	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
 			EventMessage::EVENT_MESSAGE_SIZE);
 }
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 6010baca..c0fe6041 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -33,9 +33,9 @@ public:
 	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0);
 protected:
-	MessageQueueIF* eventQueue;
+	MessageQueueIF* eventQueue = nullptr;
 	object_id_t ownerId;
-	HasHealthIF* owner;
+	HasHealthIF* owner = nullptr;
 	object_id_t faultTreeParent;
 	uint8_t parameterDomainBase;
 	void setOwnerHealth(HasHealthIF::HealthState health);

From e7d28d630cfe41ed859f516084b661df3b37a565 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 19:43:28 +0200
Subject: [PATCH 0629/1292] continued with implementation

---
 datapoollocal/HasLocalDataPoolIF.h     |  9 ++++
 datapoollocal/LocalDataPoolManager.cpp | 70 +++++++++++++++++++++++++-
 datapoollocal/LocalDataPoolManager.h   | 44 ++++++++++++----
 devicehandlers/DeviceHandlerBase.cpp   |  9 ++++
 devicehandlers/DeviceHandlerBase.h     |  8 ++-
 objectmanager/SystemObject.h           |  4 +-
 6 files changed, 129 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7727c3b4..1a026dd3 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -43,6 +43,8 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
 
+	virtual object_id_t getObjectId() const = 0;
+
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -53,6 +55,13 @@ public:
 	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
+	/**
+	 * Returns the minimum sampling frequency, which will usually be the
+	 * period the pool owner performs its periodic operation-
+	 * @return
+	 */
+	virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+
 	/**
 	 * This function is used by the pool manager to get a valid dataset
      * from a SID
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index ec413492..b852143e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -6,6 +6,7 @@
 #include <framework/ipc/QueueFactory.h>
 
 #include <array>
+#include <cmath>
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
@@ -25,11 +26,12 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
 	            "Could not set IPC store." << std::endl;
 	}
+
 	hkQueue = queueToUse;
 }
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination) {
+        object_id_t hkDestination, uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
@@ -51,6 +53,10 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
         sif::warning << "Make sure it exists and the object impements "
                 "AcceptsHkPacketsIF!" << std::endl;
     }
+
+    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+    diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
+    regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -182,7 +188,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     return result;
 }
 
-void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
+        uint8_t nonDiagInvlFactor) {
+    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
@@ -214,5 +222,63 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    for(auto& hkReceiversIter: hkReceiversMap) {
+        HkReceiver* receiver = &hkReceiversIter.second;
+        switch(receiver->reportingType) {
+        case(ReportingType::PERIODIC): {
+            performPeriodicHkGeneration(receiver);
+            break;
+        }
+        case(ReportingType::ON_UPDATE): {
+            // check whether data has changed and send messages in case it has.
+            break;
+        }
+        default:
+            // This should never happen.
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
+    if(receiver->reportingEnabled) {
+        if(receiver->intervalCounter >= intervalSecondsToInterval(
+                receiver->isDiagnostics,
+                receiver->hkParameter.collectionInterval)) {
+            ReturnValue_t result = generateHousekeepingPacket(
+                    receiver->dataSetSid, receiver->destinationQueue);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                // configuration error
+                sif::debug << "LocalDataPoolManager::performHkOperation:"
+                        << "0x" << std::setfill('0') << std::setw(8)
+                << owner->getObjectId() << " Error generating "
+                << "HK packet" << std::setfill(' ') << std::endl;
+            }
+            receiver->intervalCounter = 1;
+        }
+        else if(receiver->reportingEnabled){
+            receiver->intervalCounter++;
+        }
+    }
+}
+
+uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
+        float collectionIntervalSeconds) {
+    if(isDiagnostics) {
+        return  std::ceil(collectionIntervalSeconds/diagnosticMinimumInterval);
+    }
+    else {
+        return std::ceil(collectionIntervalSeconds/regularMinimumInterval);
+    }
+}
+
+float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
+        uint32_t collectionInterval) {
+    if(isDiagnostics) {
+        return  static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+    }
+    else {
+        return static_cast<float>(collectionInterval * regularMinimumInterval);
+    }
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6912f0bc..bcfee3f4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -66,10 +66,22 @@ public:
 	 * Initializes the map by calling the map initialization function of the
 	 * owner and assigns the queue to use.
 	 * @param queueToUse
+	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination);
+	        object_id_t hkDestination, uint8_t nonDiagInvlFactor = 5);
+
+	/**
+	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
+	 * than diagnostic packets.
+	 * A factor can be specified to determine the minimum sampling frequency
+	 * for non-diagnostic packets. The minimum sampling frequency of the
+	 * diagnostics packets,which is usually jusst the period of the
+	 * performOperation calls, is multiplied with that factor.
+	 * @param factor
+	 */
+	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
 	/**
 	 * This should be called in the periodic handler of the owner.
@@ -144,29 +156,36 @@ public:
 
 private:
     LocalDataPool localPoolMap;
-    /** Every housekeeping data manager has a mutex to protect access
-     * to it's data pool. */
+    //! Every housekeeping data manager has a mutex to protect access
+    //! to it's data pool.
     MutexIF* mutex = nullptr;
     /** The class which actually owns the manager (and its datapool). */
     HasLocalDataPoolIF* owner = nullptr;
 
-    /**
-     * The data pool manager will keep an internal map of HK receivers.
-     */
+    uint8_t nonDiagnosticIntervalFactor = 0;
+    dur_millis_t regularMinimumInterval = 0;
+    dur_millis_t diagnosticMinimumInterval = 0;
+
+    /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        LocalPoolDataSetBase* dataSet = nullptr;
+        sid_t dataSetSid;
+        //LocalPoolDataSetBase* dataSet = nullptr;
         lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
-        bool reportingStatus = true;
+        bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
          * type */
-        union hkParameter {
+        union HkParameter {
             /** This parameter will be used for the PERIODIC type */
             dur_seconds_t collectionInterval = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
+        HkParameter hkParameter;
+        bool isDiagnostics;
+        //! General purpose counter which is used for periodic generation.
+        uint32_t intervalCounter;
     };
 
     /** Using a multimap as the same object might request multiple datasets */
@@ -223,6 +242,13 @@ private:
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
 	        LocalPoolDataSetBase* dataSet);
+
+	uint32_t intervalSecondsToInterval(bool isDiagnostics,
+	        float collectionIntervalSeconds);
+	float intervalToIntervalSeconds(bool isDiagnostics,
+	        uint32_t collectionInterval);
+
+	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
 };
 
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a4346afb..cbbecb70 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -82,6 +82,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
+		hkManager.performHkOperation();
 		performOperationHook();
 	}
 	if (mode == MODE_OFF) {
@@ -1395,3 +1396,11 @@ DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 		return nullptr;
 	}
 }
+
+object_id_t DeviceHandlerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
+    return pstIntervalMs;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 632db5e0..302829ea 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -493,7 +493,11 @@ protected:
 	 * 			performOperation(). Default implementation is empty.
 	 */
 	virtual void performOperationHook();
+
 public:
+	/** Explicit interface implementation of getObjectId */
+	virtual object_id_t getObjectId() const override;
+
 	/**
 	 * @param parentQueueId
 	 */
@@ -653,8 +657,6 @@ protected:
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
 		DataSetIF* dataSet = nullptr;
-		float collectionInterval = 0.0;
-		uint32_t intervalCounter = 0;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1201,6 +1203,8 @@ private:
 
 	void parseReply(const uint8_t* receivedData,
 	            size_t receivedDataLen);
+
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 6a1b35b6..47e53a7f 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -51,8 +51,8 @@ public:
 	 * @brief	On destruction, the object removes itself from the list.
 	 */
 	virtual ~SystemObject();
-	object_id_t getObjectId() const;
-	virtual ReturnValue_t initialize();
+	object_id_t getObjectId() const override;
+	virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t checkObjectConnections();
 
 	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;

From b828d7c6d7b8267e9867369a557d6e0b9c4d8452 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 19:56:42 +0200
Subject: [PATCH 0630/1292] continued with local datapool manager

---
 datapoollocal/LocalDataPoolManager.cpp | 46 ++++++++++++++++----------
 datapoollocal/LocalDataPoolManager.h   | 29 ++++++++--------
 2 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b852143e..b7b203b8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -129,6 +129,12 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 				" Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
+	// do we generate hk packets for invalid datasets?
+//	if(not dataSetToSerialize->isValid()) {
+//	    return HasReturnvaluesIF::RETURN_OK;
+//	}
+
 	store_address_t storeId;
 	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
 	        dataSetToSerialize);
@@ -224,8 +230,16 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
         HkReceiver* receiver = &hkReceiversIter.second;
+        if(not receiver->reportingEnabled) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
+            if(receiver->dataId.dataSetSid == sid_t::INVALID_ADDRESS) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
             performPeriodicHkGeneration(receiver);
             break;
         }
@@ -242,24 +256,22 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->reportingEnabled) {
-        if(receiver->intervalCounter >= intervalSecondsToInterval(
-                receiver->isDiagnostics,
-                receiver->hkParameter.collectionInterval)) {
-            ReturnValue_t result = generateHousekeepingPacket(
-                    receiver->dataSetSid, receiver->destinationQueue);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                // configuration error
-                sif::debug << "LocalDataPoolManager::performHkOperation:"
-                        << "0x" << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::endl;
-            }
-            receiver->intervalCounter = 1;
-        }
-        else if(receiver->reportingEnabled){
-            receiver->intervalCounter++;
+    if(receiver->intervalCounter >= intervalSecondsToInterval(
+            receiver->isDiagnostics,
+            receiver->hkParameter.collectionInterval)) {
+        ReturnValue_t result = generateHousekeepingPacket(
+                receiver->dataId.dataSetSid, receiver->destinationQueue);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            // configuration error
+            sif::debug << "LocalDataPoolManager::performHkOperation:"
+                    << "0x" << std::setfill('0') << std::setw(8)
+            << owner->getObjectId() << " Error generating "
+            << "HK packet" << std::setfill(' ') << std::endl;
         }
+        receiver->intervalCounter = 1;
+    }
+    else {
+        receiver->intervalCounter++;
     }
 }
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index bcfee3f4..d9e84f4e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -31,7 +31,7 @@ class LocalPoolDataSetBase;
  * value is stored. The helper classes offer a read() and commit() interface
  * through the PoolVariableIF which is used to read and update values.
  * Each pool entry has a valid state too.
- *
+ * @author R. Mueller
  */
 class LocalDataPoolManager {
 	template<typename T>
@@ -129,12 +129,6 @@ public:
      *     Propably not necessary, just use multiple local data sets or
      *     shared datasets.
      *
-     *  TODO: This is a big architecture question. Use raw data or shared
-     *  datasets? dumb thing about shared datasets: It propably would be better
-     *  if each task who uses the data has their own copy of the pool
-     *  variables. Then the LPIDs should be hardcoded in the dataset implementations
-     *  so the users don't have to worry about it anymore.
-     *
      *  Notifications should also be possible for single variables instead of
      *  full dataset updates.
      */
@@ -144,10 +138,6 @@ public:
         // Notification will be sent out as message.
         // Data is accessed via shared data set or multiple local data sets.
         ON_UPDATE,
-        // actually, requested is propably unnecessary. If another component
-        // needs data on request, they can just use  the new SharedDataSet
-        // which is thread-safe to also have full access to the interface..
-        REQUESTED
     };
 
     /* Copying forbidden */
@@ -168,14 +158,21 @@ private:
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        sid_t dataSetSid;
-        //LocalPoolDataSetBase* dataSet = nullptr;
-        lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+        /** Different member of this union will be used depending on the
+        type of data the receiver is interested in (full datasets or
+        single data variables. */
+        union DataId {
+            /** Will be initialized to INVALID_ADDRESS */
+            sid_t dataSetSid;
+            lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+        };
+        DataId dataId;
+
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
         bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
-         * type */
+        type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
             dur_seconds_t collectionInterval = 0;
@@ -184,7 +181,7 @@ private:
         };
         HkParameter hkParameter;
         bool isDiagnostics;
-        //! General purpose counter which is used for periodic generation.
+        /** General purpose counter which is used for periodic generation. */
         uint32_t intervalCounter;
     };
 

From b092850dfcb0a37f3d9fd8b67933b8201d8d622b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 21:32:15 +0200
Subject: [PATCH 0631/1292] internal housekeeping packet finished

---
 datapoollocal/LocalDataPoolManager.cpp    |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp    | 79 +++++++++++++++++++++++
 datapoollocal/LocalPoolDataSetBase.h      | 16 ++++-
 housekeeping/HousekeepingMessage.h        |  4 ++
 housekeeping/InternalHousekeepingPacket.h | 73 +++++++++++++++++++++
 5 files changed, 171 insertions(+), 3 deletions(-)
 create mode 100644 housekeeping/InternalHousekeepingPacket.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b7b203b8..7c41ff2a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -236,7 +236,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid == sid_t::INVALID_ADDRESS) {
+            if(receiver->dataId.dataSetSid.notSet()) {
                 // Periodic packets shall only be generated from datasets.
                 continue;
             }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index f5273cfe..d24ffd18 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -72,6 +72,36 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     return result;
 }
 
+ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
+        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;
+        }
+    }
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    // could be made more efficient but make it work first
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
+
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
+}
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
@@ -102,6 +132,55 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
+size_t LocalPoolDataSetBase::getSerializedSize() const {
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
+}
+
+void LocalPoolDataSetBase::setValidityBufferGeneration(
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
+}
+
+ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
+}
+
+ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}
+
 bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
+
+
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 1034fc29..e9baeea3 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,6 +30,7 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
+// todo: make withValidityBuffer a member
 class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
@@ -63,6 +64,14 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	void setValidityBufferGeneration(bool withValidityBuffer);
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+	            SerializeIF::Endianness streamEndianness) const override;
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+	        SerializeIF::Endianness streamEndianness) override;
+	size_t getSerializedSize() const override;
+
 	/**
 	 * Special version of the serilization function which appends a
 	 * validity buffer at the end. Each bit of this validity buffer
@@ -78,7 +87,8 @@ public:
 	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
-
+	ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+	        size_t *size, SerializeIF::Endianness streamEndianness);
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
@@ -92,6 +102,8 @@ protected:
 	 */
 	bool valid = false;
 
+	bool withValidityBuffer = true;
+
 	/**
 	 * @brief	This is a small helper function to facilitate locking
 	 * 			the global data pool.
@@ -114,7 +126,7 @@ protected:
 	 * (most significant bit) to 7 (least significant bit)
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
-
+	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 private:
 
 
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2a69805..db6d3ab8 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -25,6 +25,10 @@ union sid_t {
 	 * Alternative access to the raw value. This is also the size of the type.
 	 */
 	uint64_t raw;
+
+	bool notSet() const {
+	    return raw == INVALID_ADDRESS;
+	}
 };
 
 
diff --git a/housekeeping/InternalHousekeepingPacket.h b/housekeeping/InternalHousekeepingPacket.h
new file mode 100644
index 00000000..2a9a5564
--- /dev/null
+++ b/housekeeping/InternalHousekeepingPacket.h
@@ -0,0 +1,73 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+#define FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+
+#include <framework/serialize/SerialBufferAdapter.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+
+/**
+ * @brief   This helper class will be used to serialize and deserialize
+ *          internal housekeeping packets into the store.
+ */
+class InternalHousekeepingPacket: public SerializeIF {
+public:
+    /**
+     * @param timeStamp
+     * @param timeStampSize
+     * @param hkData
+     * @param hkDataSize
+     */
+    InternalHousekeepingPacket(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolDataSetBase* dataSetPtr):
+            timeStamp(timeStamp), timeStampSize(timeStampSize),
+            dataSetPtr(dataSetPtr) {};
+
+    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+            size_t maxSize, Endianness streamEndianness) const {
+        if(timeStamp != nullptr) {
+            // Endianness will always be MACHINE, so we can simply use memcpy
+            // here.
+            std::memcpy(*buffer, timeStamp, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+    }
+
+    virtual size_t getSerializedSize() const {
+        if(dataSetPtr == nullptr) {
+            return 0;
+        }
+        return timeStampSize + dataSetPtr->getSerializedSize();
+    }
+
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override {
+        if(timeStamp != nullptr) {
+            // Endianness will always be MACHINE, so we can simply use memcpy
+            // here.
+            std::memcpy(timeStamp, *buffer, timeStampSize);
+            *size += timeStampSize;
+            *buffer += timeStampSize;
+        }
+
+        if(dataSetPtr == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+    }
+
+private:
+   uint8_t* timeStamp;
+   size_t timeStampSize;
+
+   LocalPoolDataSetBase* dataSetPtr = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_ */

From 6484c1a27697f1b3a8326dbae0d3fa5eb4be7b4f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:45:18 +0200
Subject: [PATCH 0632/1292] shared ring buffer simplified

---
 container/SharedRingBuffer.cpp | 46 +++++++---------------------------
 container/SharedRingBuffer.h   | 43 +++++++++++++++----------------
 2 files changed, 29 insertions(+), 60 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index a8b06b01..afcd89c7 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -5,7 +5,7 @@
 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) {
+		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -13,47 +13,19 @@ 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) {
+		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t SharedRingBuffer::getFreeElementProtected(uint8_t** writePtr,
-		size_t amount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::getFreeElement(writePtr,amount);
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
 }
 
-ReturnValue_t SharedRingBuffer::writeDataProtected(const uint8_t *data,
-		size_t amount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::writeData(data,amount);
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
 }
 
-ReturnValue_t SharedRingBuffer::readDataProtected(uint8_t *data, size_t amount,
-		bool incrementReadPtr, bool readRemaining,
-		size_t *trueAmount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::readData(data,amount, incrementReadPtr,
-			readRemaining, trueAmount);
-}
-
-ReturnValue_t SharedRingBuffer::deleteDataProtected(size_t amount,
-		bool deleteRemaining, size_t *trueAmount) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::deleteData(amount, deleteRemaining, trueAmount);
-}
-
-size_t SharedRingBuffer::getExcessBytes() const {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::getExcessBytes();
-}
-
-void SharedRingBuffer::moveExcessBytesToStart() {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return SimpleRingBuffer::moveExcessBytesToStart();
-}
-
-size_t SharedRingBuffer::getAvailableReadDataProtected(uint8_t n) const {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
-	return ((write + size) - read[n]) % size;
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 8d68b967..69a3d724 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -6,6 +6,13 @@
 #include <framework/objectmanager/SystemObject.h>
 #include <framework/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:
@@ -32,34 +39,24 @@ public:
 			bool overwriteOld, size_t maxExcessBytes,
 			dur_millis_t mutexTimeout = 10);
 
-	void setMutexTimeout(dur_millis_t newTimeout);
-
-	virtual size_t getExcessBytes() const override;
 	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
+	 * 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 void moveExcessBytesToStart() override;
+	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::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);
-
-	/** 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);
-
-	/** Performs mutex protected SimpleRingBuffer::deleteData call */
-	ReturnValue_t deleteDataProtected(size_t amount,
-			bool deleteRemaining = false, size_t* trueAmount = nullptr);
-
-	size_t getAvailableReadDataProtected (uint8_t n = 0) const;
+	MutexIF* getMutexHandle() const;
 private:
-	dur_millis_t mutexTimeout;
 	MutexIF* mutex = nullptr;
 };
 

From f9ce1d9eb9f5fcf85a339fc28b3b5806cb1c644c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:46:21 +0200
Subject: [PATCH 0633/1292] more simplifications for shared ring buffer

---
 container/SharedRingBuffer.cpp | 5 ++---
 container/SharedRingBuffer.h   | 6 ++----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index afcd89c7..001a21ed 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,15 +3,14 @@
 #include <framework/ipc/MutexHelper.h>
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes, dur_millis_t mutexTimeout):
+		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):
+		const size_t size, bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
 		maxExcessBytes) {
 	mutex = MutexFactory::instance()->createMutex();
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 69a3d724..102cc6be 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -24,8 +24,7 @@ public:
 	 * will be overwritten.
 	 */
 	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes,
-			dur_millis_t mutexTimeout = 10);
+			bool overwriteOld, size_t maxExcessBytes);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
@@ -36,8 +35,7 @@ public:
 	 * 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);
+			bool overwriteOld, size_t maxExcessBytes);
 
 	/**
 	 * Unless a read-only constant value is read, all operations on the

From 5d09ae322176247536667994806ca8aa6bb3b1e5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 8 Aug 2020 23:47:44 +0200
Subject: [PATCH 0634/1292] additional comment

---
 container/SharedRingBuffer.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 102cc6be..0b5be052 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -53,6 +53,11 @@ public:
 	 */
 	virtual ReturnValue_t unlockRingBufferMutex();
 
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
 	MutexIF* getMutexHandle() const;
 private:
 	MutexIF* mutex = nullptr;

From 9e7d92b387249a6156a889e277cefc80fd53d667 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 9 Aug 2020 19:46:37 +0200
Subject: [PATCH 0635/1292] some renaming , hk packets finished

---
 housekeeping/HousekeepingPacketDownlink.h     | 75 +++++++++++++++++++
 ...ingPacket.h => HousekeepingPacketUpdate.h} | 10 +--
 2 files changed, 80 insertions(+), 5 deletions(-)
 create mode 100644 housekeeping/HousekeepingPacketDownlink.h
 rename housekeeping/{InternalHousekeepingPacket.h => HousekeepingPacketUpdate.h} (86%)

diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
new file mode 100644
index 00000000..d386bfdf
--- /dev/null
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -0,0 +1,75 @@
+#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include <framework/housekeeping/HousekeepingMessage.h>
+#include <framework/serialize/SerialLinkedListAdapter.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+
+/**
+ * @brief   This class will be used to serialize general housekeeping packets
+ *          which are destined to be downlinked into the store.
+ * @details
+ * The housekeeping packets are stored into the IPC store and forwarded
+ * to the designated housekeeping handler.
+ */
+class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
+public:
+    HousekeepingPacketDownlink(sid_t sid, float collectionInterval, uint8_t
+            numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
+            sourceId(sid.objectId), setId(sid.ownerSetId),
+            collectionInterval(collectionInterval),
+            numberOfParameters(numberOfParameters), dataSetPtr(dataSetPtr),
+            hkData(dataSetPtr) {
+        setLinks();
+    }
+
+//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+//                size_t maxSize, Endianness streamEndianness) const override {
+//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+//                maxSize, streamEndianness);
+//        if(result != HasReturnvaluesIF::RETURN_OK) {
+//            return result;
+//        }
+//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+//   }
+//
+//   virtual size_t getSerializedSize() const override {
+//
+//   }
+
+   virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
+           store_address_t storeId, StorageManagerIF* otherStore,
+           store_address_t* newStoreId, uint8_t** buffer, size_t size) {
+       const uint8_t* dataPtr = nullptr;
+       size_t hkDataSize = 0;
+       ReturnValue_t result = formerStore->getData(storeId, &dataPtr, &hkDataSize);
+       if(result != HasReturnvaluesIF::RETURN_OK) {
+           return result;
+       }
+
+       otherStore->addData(newStoreId, dataPtrgetSerializedSize(),
+               buffer);
+       std::memcpy
+
+   }
+
+private:
+    void setLinks() {
+        setStart(&sourceId);
+        sourceId.setNext(&setId);
+        setId.setNext(&collectionInterval);
+        collectionInterval.setNext(&numberOfParameters);
+        numberOfParameters.setNext(&hkData);
+    }
+
+    SerializeElement<object_id_t> sourceId;
+    SerializeElement<uint32_t> setId;
+    SerializeElement<float> collectionInterval;
+    SerializeElement<uint8_t> numberOfParameters;
+    LinkedElement<SerializeIF> hkData;
+    LocalPoolDataSetBase* dataSetPtr;
+};
+
+
+
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
diff --git a/housekeeping/InternalHousekeepingPacket.h b/housekeeping/HousekeepingPacketUpdate.h
similarity index 86%
rename from housekeeping/InternalHousekeepingPacket.h
rename to housekeeping/HousekeepingPacketUpdate.h
index 2a9a5564..bfdcde99 100644
--- a/housekeeping/InternalHousekeepingPacket.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
-#define FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_
+#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
 #include <framework/serialize/SerialBufferAdapter.h>
 #include <framework/serialize/SerialLinkedListAdapter.h>
@@ -9,7 +9,7 @@
  * @brief   This helper class will be used to serialize and deserialize
  *          internal housekeeping packets into the store.
  */
-class InternalHousekeepingPacket: public SerializeIF {
+class HousekeepingPacketUpdate: public SerializeIF {
 public:
     /**
      * @param timeStamp
@@ -17,7 +17,7 @@ public:
      * @param hkData
      * @param hkDataSize
      */
-    InternalHousekeepingPacket(uint8_t* timeStamp, size_t timeStampSize,
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
             timeStamp(timeStamp), timeStampSize(timeStampSize),
             dataSetPtr(dataSetPtr) {};
@@ -70,4 +70,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_HOUSEKEEPING_INTERNALHOUSEKEEPINGPACKET_H_ */
+#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From 87eb31b65aa7c68c4b3ad40cfac7353349b7b968 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 9 Aug 2020 20:06:29 +0200
Subject: [PATCH 0636/1292] local data pool manager uses new packet now

---
 datapoollocal/LocalDataPoolManager.cpp    | 51 +++++++---------
 datapoollocal/LocalDataPoolManager.h      | 10 ++--
 housekeeping/HousekeepingPacketDownlink.h | 72 ++++++++++++-----------
 housekeeping/HousekeepingPacketUpdate.h   | 10 ++--
 4 files changed, 71 insertions(+), 72 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7c41ff2a..3c5f0c1b 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
 #include <framework/datapoollocal/LocalDataPoolManager.h>
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/AcceptsHkPacketsIF.h>
+#include <framework/housekeeping/HousekeepingPacketDownlink.h>
 #include <framework/ipc/MutexFactory.h>
 #include <framework/ipc/MutexHelper.h>
 #include <framework/ipc/QueueFactory.h>
@@ -121,7 +122,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        MessageQueueId_t sendTo) {
+        float collectionInterval, MessageQueueId_t sendTo) {
 	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -136,8 +137,9 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 //	}
 
 	store_address_t storeId;
-	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
-	        dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 	    return result;
 	}
@@ -166,6 +168,22 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	return result;
 }
 
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        HousekeepingPacketDownlink& hkPacket,
+        store_address_t *storeId) {
+    uint8_t* dataPtr = nullptr;
+    size_t serializedSize = hkPacket.getSerializedSize();
+    const size_t maxSize = serializedSize;
+    ReturnValue_t  result = ipcStore->getFreeElement(storeId,
+            serializedSize, &dataPtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    return hkPacket.serialize(&dataPtr, &serializedSize, maxSize,
+            SerializeIF::Endianness::MACHINE);
+}
+
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
     LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
             owner->getDataSetHandle(sid));
@@ -199,33 +217,6 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalPoolDataSetBase* dataSet) {
-    size_t hkSize = dataSet->getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-
-    if(appendValidityBuffer) {
-        result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, SerializeIF::Endianness::MACHINE);
-    }
-    else {
-        result = dataSet->serialize(&storePtr, &size, hkSize,
-                SerializeIF::Endianness::MACHINE);
-    }
-
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
-                "Serialization proccess failed!" << std::endl;
-    }
-    return result;
-}
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d9e84f4e..d0d3d805 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -8,6 +8,7 @@
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/datapool/PoolEntry.h>
 #include <framework/datapoollocal/HasLocalDataPoolIF.h>
+#include <framework/housekeeping/HousekeepingPacketDownlink.h>
 #include <framework/ipc/CommandMessage.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/ipc/MutexHelper.h>
@@ -101,8 +102,8 @@ public:
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
-	        = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, float collectionInterval,
+	        MessageQueueId_t sendTo = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -237,8 +238,9 @@ private:
 			PoolEntry<T> **poolEntry);
 
 	void setMinimalSamplingFrequency(float frequencySeconds);
-	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalPoolDataSetBase* dataSet);
+	ReturnValue_t serializeHkPacketIntoStore(
+	        HousekeepingPacketDownlink& hkPacket,
+	        store_address_t *storeId);
 
 	uint32_t intervalSecondsToInterval(bool isDiagnostics,
 	        float collectionIntervalSeconds);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index d386bfdf..feb49c59 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 #define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+
 #include <framework/datapoollocal/LocalPoolDataSetBase.h>
 #include <framework/housekeeping/HousekeepingMessage.h>
 #include <framework/serialize/SerialLinkedListAdapter.h>
@@ -18,40 +19,32 @@ public:
             numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
             sourceId(sid.objectId), setId(sid.ownerSetId),
             collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), dataSetPtr(dataSetPtr),
-            hkData(dataSetPtr) {
+            numberOfParameters(numberOfParameters), hkData(dataSetPtr) {
         setLinks();
     }
 
-//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-//                size_t maxSize, Endianness streamEndianness) const override {
-//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
-//                maxSize, streamEndianness);
-//        if(result != HasReturnvaluesIF::RETURN_OK) {
-//            return result;
-//        }
-//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
-//   }
-//
-//   virtual size_t getSerializedSize() const override {
-//
-//   }
+    /**
+     * Helper functions which can be used to move HK data from the IPC store
+     * to the telemetry store.
+     * @param formerStore
+     * @param storeId
+     * @param newStore
+     * @param newStoreId [out]
+     * @return
+     */
+    virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
+            store_address_t storeId, StorageManagerIF* newStore,
+            store_address_t* newStoreId) {
+        const uint8_t* dataPtr = nullptr;
+        size_t hkDataSize = 0;
+        ReturnValue_t result = formerStore->getData(storeId, &dataPtr,
+                &hkDataSize);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
-   virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
-           store_address_t storeId, StorageManagerIF* otherStore,
-           store_address_t* newStoreId, uint8_t** buffer, size_t size) {
-       const uint8_t* dataPtr = nullptr;
-       size_t hkDataSize = 0;
-       ReturnValue_t result = formerStore->getData(storeId, &dataPtr, &hkDataSize);
-       if(result != HasReturnvaluesIF::RETURN_OK) {
-           return result;
-       }
-
-       otherStore->addData(newStoreId, dataPtrgetSerializedSize(),
-               buffer);
-       std::memcpy
-
-   }
+        return newStore->addData(newStoreId, dataPtr, hkDataSize);
+    }
 
 private:
     void setLinks() {
@@ -67,9 +60,22 @@ private:
     SerializeElement<float> collectionInterval;
     SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
-    LocalPoolDataSetBase* dataSetPtr;
 };
 
-
-
 #endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
+
+
+
+//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+//                size_t maxSize, Endianness streamEndianness) const override {
+//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+//                maxSize, streamEndianness);
+//        if(result != HasReturnvaluesIF::RETURN_OK) {
+//            return result;
+//        }
+//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+//   }
+//
+//   virtual size_t getSerializedSize() const override {
+//
+//   }
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index bfdcde99..e7b644f5 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -7,7 +7,7 @@
 
 /**
  * @brief   This helper class will be used to serialize and deserialize
- *          internal housekeeping packets into the store.
+ *          update housekeeping packets into the store.
  */
 class HousekeepingPacketUpdate: public SerializeIF {
 public:
@@ -25,8 +25,8 @@ public:
     virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
             size_t maxSize, Endianness streamEndianness) const {
         if(timeStamp != nullptr) {
-            // Endianness will always be MACHINE, so we can simply use memcpy
-            // here.
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
             std::memcpy(*buffer, timeStamp, timeStampSize);
             *size += timeStampSize;
             *buffer += timeStampSize;
@@ -48,8 +48,8 @@ public:
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
             SerializeIF::Endianness streamEndianness) override {
         if(timeStamp != nullptr) {
-            // Endianness will always be MACHINE, so we can simply use memcpy
-            // here.
+            /* Endianness will always be MACHINE, so we can simply use memcpy
+            here. */
             std::memcpy(timeStamp, *buffer, timeStampSize);
             *size += timeStampSize;
             *buffer += timeStampSize;

From f39b8bdb419bd2832d8b1e6b44b13ece12ceb0b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 10 Aug 2020 18:33:28 +0200
Subject: [PATCH 0637/1292] several simplifications

---
 datapoollocal/LocalDataPoolManager.cpp |  9 ++-------
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 housekeeping/HousekeepingMessage.cpp   | 15 +++------------
 housekeeping/HousekeepingMessage.h     |  2 --
 osal/FreeRTOS/MessageQueue.cpp         |  1 +
 5 files changed, 7 insertions(+), 22 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 3c5f0c1b..5373edb4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -131,11 +131,6 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	// do we generate hk packets for invalid datasets?
-//	if(not dataSetToSerialize->isValid()) {
-//	    return HasReturnvaluesIF::RETURN_OK;
-//	}
-
 	store_address_t storeId;
 	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
 	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
@@ -249,7 +244,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >= intervalSecondsToInterval(
             receiver->isDiagnostics,
-            receiver->hkParameter.collectionInterval)) {
+            receiver->hkParameter.collectionIntervalSeconds)) {
         ReturnValue_t result = generateHousekeepingPacket(
                 receiver->dataId.dataSetSid, receiver->destinationQueue);
         if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -279,7 +274,7 @@ uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
 float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         uint32_t collectionInterval) {
     if(isDiagnostics) {
-        return  static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+        return static_cast<float>(collectionInterval * diagnosticMinimumInterval);
     }
     else {
         return static_cast<float>(collectionInterval * regularMinimumInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d0d3d805..068d2703 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -176,7 +176,7 @@ private:
         type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
-            dur_seconds_t collectionInterval = 0;
+            float collectionIntervalSeconds = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 2335f03d..2b1da851 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -8,7 +8,7 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	setParameter(message, storeId.raw);
+	message->setParameter3(storeId.raw);
 }
 
 void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
@@ -16,13 +16,13 @@ void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 	message->setCommand(DIAGNOSTICS_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
 	setSid(message, sid);
-	setParameter(message, storeId.raw);
+	message->setParameter3(storeId.raw);
 }
 
 sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter(message);
+	    *storeIdToSet = message->getParameter3();
 	}
 	return getSid(message);
 }
@@ -37,12 +37,3 @@ void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
 
-
-void HousekeepingMessage::setParameter(CommandMessage *message,
-		uint32_t parameter) {
-	message->setParameter3(parameter);
-}
-
-uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
-	return message->getParameter3();
-}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index db6d3ab8..f62beafa 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -112,8 +112,6 @@ public:
 
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
-	static void setParameter(CommandMessage* message, uint32_t parameter);
-	static uint32_t getParameter(const CommandMessage* message);
 };
 
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e9f3871e..398d1300 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -132,6 +132,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else  {
 		destination = reinterpret_cast<QueueHandle_t>(sendTo);
 	}
+
     message->setSender(sentFrom);
 
 

From fbecda75492905c8c8301b774d66ee777e791037 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 13:09:15 +0200
Subject: [PATCH 0638/1292] include replacements

---
 action/ActionHelper.cpp                       |  220 +-
 action/ActionHelper.h                         |  186 +-
 action/ActionMessage.cpp                      |  158 +-
 action/ActionMessage.h                        |   64 +-
 action/CommandActionHelper.cpp                |  254 +-
 action/CommandActionHelper.h                  |   72 +-
 action/CommandsActionsIF.h                    |   68 +-
 action/HasActionsIF.h                         |  120 +-
 action/SimpleActionHelper.cpp                 |  148 +-
 action/SimpleActionHelper.h                   |   48 +-
 container/ArrayList.h                         |  494 +--
 container/DynamicFIFO.h                       |   84 +-
 container/FIFO.h                              |   68 +-
 container/FIFOBase.h                          |  130 +-
 container/FixedArrayList.h                    |  114 +-
 container/FixedMap.h                          |  450 +--
 container/FixedOrderedMultimap.h              |  362 +--
 container/HybridIterator.h                    |  180 +-
 container/IndexedRingMemoryArray.h            | 1442 ++++-----
 container/PlacementFactory.h                  |   70 +-
 container/RingBufferBase.h                    |  226 +-
 container/SharedRingBuffer.cpp                |   60 +-
 container/SharedRingBuffer.h                  |  136 +-
 container/SimpleRingBuffer.cpp                |  254 +-
 container/SimpleRingBuffer.h                  |  238 +-
 controller/ControllerBase.cpp                 |  274 +-
 controller/ControllerBase.h                   |  158 +-
 coordinates/CoordinateTransformations.cpp     |  454 +--
 coordinates/CoordinateTransformations.h       |   68 +-
 coordinates/Jgm3Model.h                       |  360 +--
 coordinates/Sgp4Propagator.cpp                |  456 +--
 coordinates/Sgp4Propagator.h                  |   88 +-
 datalinklayer/BCFrame.h                       |  124 +-
 datalinklayer/CCSDSReturnValuesIF.h           |  112 +-
 datalinklayer/Clcw.cpp                        |  126 +-
 datalinklayer/Clcw.h                          |  132 +-
 datalinklayer/DataLinkLayer.cpp               |  278 +-
 datalinklayer/DataLinkLayer.h                 |  224 +-
 datalinklayer/Farm1StateIF.h                  |  108 +-
 datalinklayer/Farm1StateLockout.cpp           |   70 +-
 datalinklayer/Farm1StateLockout.h             |  118 +-
 datalinklayer/Farm1StateOpen.cpp              |   98 +-
 datalinklayer/Farm1StateOpen.h                |  124 +-
 datalinklayer/Farm1StateWait.cpp              |   86 +-
 datalinklayer/Farm1StateWait.h                |  116 +-
 datalinklayer/MapPacketExtraction.cpp         |  308 +-
 datalinklayer/MapPacketExtraction.h           |  156 +-
 datalinklayer/MapPacketExtractionIF.h         |   94 +-
 datalinklayer/TcTransferFrame.cpp             |  204 +-
 datalinklayer/TcTransferFrameLocal.cpp        |   98 +-
 datalinklayer/TcTransferFrameLocal.h          |   98 +-
 datalinklayer/VirtualChannelReception.cpp     |  242 +-
 datalinklayer/VirtualChannelReception.h       |  228 +-
 datalinklayer/VirtualChannelReceptionIF.h     |  114 +-
 datapool/ControllerSet.cpp                    |   28 +-
 datapool/ControllerSet.h                      |   30 +-
 datapool/DataSetBase.cpp                      |  336 +-
 datapool/DataSetBase.h                        |  298 +-
 datapool/DataSetIF.h                          |  124 +-
 datapool/HkSwitchHelper.cpp                   |  150 +-
 datapool/HkSwitchHelper.h                     |   92 +-
 datapool/PoolEntry.cpp                        |  174 +-
 datapool/PoolEntry.h                          |  260 +-
 datapool/PoolEntryIF.h                        |  126 +-
 datapool/PoolRawAccessHelper.cpp              |    8 +-
 datapool/PoolRawAccessHelper.h                |    6 +-
 datapool/PoolVarList.h                        |   56 +-
 datapool/PoolVariableIF.h                     |  198 +-
 datapoolglob/DataPoolAdmin.cpp                |  600 ++--
 datapoolglob/DataPoolAdmin.h                  |  118 +-
 datapoolglob/DataPoolParameterWrapper.cpp     |  358 +--
 datapoolglob/DataPoolParameterWrapper.h       |   76 +-
 datapoolglob/GlobalDataPool.cpp               |  266 +-
 datapoolglob/GlobalDataPool.h                 |  298 +-
 datapoolglob/GlobalDataSet.cpp                |   88 +-
 datapoolglob/GlobalDataSet.h                  |  192 +-
 datapoolglob/GlobalPoolVariable.h             |  426 +--
 datapoolglob/GlobalPoolVector.h               |  370 +--
 datapoolglob/PIDReader.h                      |  328 +-
 datapoolglob/PIDReaderList.h                  |   54 +-
 datapoolglob/PoolRawAccess.cpp                |  478 +--
 datapoolglob/PoolRawAccess.h                  |  440 +--
 datapoollocal/HasLocalDataPoolIF.h            |  154 +-
 datapoollocal/LocalDataPoolManager.cpp        |  436 +--
 datapoollocal/LocalDataPoolManager.h          |  458 +--
 datapoollocal/LocalDataSet.cpp                |  212 +-
 datapoollocal/LocalDataSet.h                  |  230 +-
 datapoollocal/LocalPoolVariable.h             |  346 +-
 datapoollocal/LocalPoolVector.h               |  400 +--
 datapoollocal/StaticLocalDataSet.cpp          |   12 +-
 datapoollocal/StaticLocalDataSet.h            |   22 +-
 devicehandlers/AcceptsDeviceResponsesIF.h     |   38 +-
 devicehandlers/AssemblyBase.cpp               |  546 ++--
 devicehandlers/AssemblyBase.h                 |  326 +-
 devicehandlers/ChildHandlerBase.cpp           |   94 +-
 devicehandlers/ChildHandlerBase.h             |   48 +-
 devicehandlers/ChildHandlerFDIR.cpp           |   20 +-
 devicehandlers/ChildHandlerFDIR.h             |   40 +-
 devicehandlers/CommunicationMessage.cpp       |    4 +-
 devicehandlers/CommunicationMessage.h         |    8 +-
 devicehandlers/DeviceCommunicationIF.h        |  254 +-
 devicehandlers/DeviceHandlerBase.cpp          | 2794 ++++++++---------
 devicehandlers/DeviceHandlerBase.h            | 2414 +++++++-------
 .../DeviceHandlerFailureIsolation.cpp         |  502 +--
 .../DeviceHandlerFailureIsolation.h           |  108 +-
 devicehandlers/DeviceHandlerIF.h              |  310 +-
 devicehandlers/DeviceHandlerMessage.cpp       |  202 +-
 devicehandlers/DeviceHandlerMessage.h         |  182 +-
 devicehandlers/DeviceTmReportingWrapper.cpp   |   92 +-
 devicehandlers/DeviceTmReportingWrapper.h     |   54 +-
 devicehandlers/HealthDevice.cpp               |  118 +-
 devicehandlers/HealthDevice.h                 |   80 +-
 events/Event.cpp                              |   28 +-
 events/Event.h                                |   90 +-
 events/EventManager.cpp                       |  330 +-
 events/EventManager.h                         |  122 +-
 events/EventManagerIF.h                       |  104 +-
 events/EventMessage.cpp                       |  228 +-
 events/EventMessage.h                         |  104 +-
 events/EventReportingProxyIF.h                |   38 +-
 events/eventmatching/EventIdRangeMatcher.cpp  |   24 +-
 events/eventmatching/EventIdRangeMatcher.h    |   26 +-
 events/eventmatching/EventMatchTree.cpp       |  298 +-
 events/eventmatching/EventMatchTree.h         |   72 +-
 events/eventmatching/EventRangeMatcherBase.h  |   58 +-
 events/eventmatching/ReporterRangeMatcher.cpp |   26 +-
 events/eventmatching/ReporterRangeMatcher.h   |   26 +-
 events/eventmatching/SeverityRangeMatcher.cpp |   28 +-
 events/eventmatching/SeverityRangeMatcher.h   |   26 +-
 events/eventmatching/eventmatching.h          |   20 +-
 fdir/ConfirmsFailuresIF.h                     |   40 +-
 fdir/EventCorrelation.cpp                     |   88 +-
 fdir/EventCorrelation.h                       |   46 +-
 fdir/FailureIsolationBase.cpp                 |  328 +-
 fdir/FailureIsolationBase.h                   |  112 +-
 fdir/FaultCounter.cpp                         |  172 +-
 fdir/FaultCounter.h                           |   76 +-
 globalfunctions/AsciiConverter.cpp            |  460 +--
 globalfunctions/AsciiConverter.h              |   78 +-
 globalfunctions/CRC.cpp                       |  278 +-
 globalfunctions/DleEncoder.cpp                |  246 +-
 globalfunctions/DleEncoder.h                  |  158 +-
 globalfunctions/Type.cpp                      |  362 +--
 globalfunctions/Type.h                        |  188 +-
 globalfunctions/arrayprinter.cpp              |  122 +-
 globalfunctions/matching/BinaryMatcher.h      |   82 +-
 globalfunctions/matching/DecimalMatcher.h     |  100 +-
 globalfunctions/matching/MatchTree.h          |  432 +--
 globalfunctions/matching/RangeMatcher.h       |  140 +-
 .../matching/SerializeableMatcherIF.h         |   26 +-
 globalfunctions/math/QuaternionOperations.cpp |  312 +-
 globalfunctions/timevalOperations.cpp         |  198 +-
 health/HasHealthIF.h                          |  100 +-
 health/HealthHelper.cpp                       |  210 +-
 health/HealthHelper.h                         |  242 +-
 health/HealthMessage.cpp                      |   56 +-
 health/HealthMessage.h                        |   60 +-
 health/HealthTable.cpp                        |  200 +-
 health/HealthTable.h                          |   70 +-
 health/HealthTableIF.h                        |   56 +-
 health/ManagesHealthIF.h                      |  104 +-
 housekeeping/AcceptsHkPacketsIF.h             |   22 +-
 housekeeping/HousekeepingMessage.cpp          |   96 +-
 housekeeping/HousekeepingMessage.h            |  232 +-
 internalError/InternalErrorReporter.cpp       |  250 +-
 internalError/InternalErrorReporter.h         |  100 +-
 ipc/CommandMessage.cpp                        |  222 +-
 ipc/CommandMessage.h                          |  258 +-
 ipc/CommandMessageCleaner.cpp                 |   90 +-
 ipc/CommandMessageCleaner.h                   |   32 +-
 ipc/CommandMessageIF.h                        |  146 +-
 ipc/MessageQueueIF.h                          |  284 +-
 ipc/MessageQueueMessage.cpp                   |  168 +-
 ipc/MessageQueueMessage.h                     |  300 +-
 ipc/MessageQueueSenderIF.h                    |   50 +-
 ipc/MutexFactory.h                            |   68 +-
 ipc/MutexHelper.h                             |   60 +-
 ipc/MutexIF.h                                 |  178 +-
 ipc/QueueFactory.h                            |   66 +-
 memory/AcceptsMemoryMessagesIF.h              |   42 +-
 memory/FileSystemMessage.cpp                  |   56 +-
 memory/FileSystemMessage.h                    |   60 +-
 memory/HasFileSystemIF.h                      |   72 +-
 memory/HasMemoryIF.h                          |   94 +-
 memory/MemoryHelper.cpp                       |  386 +--
 memory/MemoryHelper.h                         |   74 +-
 memory/MemoryMessage.cpp                      |  224 +-
 memory/MemoryMessage.h                        |   78 +-
 memory/MemoryProxyIF.h                        |   44 +-
 modes/HasModesIF.h                            |  114 +-
 modes/ModeHelper.cpp                          |  270 +-
 modes/ModeHelper.h                            |  106 +-
 modes/ModeMessage.cpp                         |   62 +-
 modes/ModeMessage.h                           |   80 +-
 monitoring/AbsLimitMonitor.h                  |  146 +-
 monitoring/HasMonitorsIF.h                    |   60 +-
 monitoring/LimitMonitor.h                     |  190 +-
 monitoring/LimitViolationReporter.cpp         |  120 +-
 monitoring/LimitViolationReporter.h           |   62 +-
 monitoring/MonitorBase.h                      |  124 +-
 monitoring/MonitorReporter.h                  |  356 +--
 monitoring/MonitoringIF.h                     |  134 +-
 monitoring/MonitoringMessage.cpp              |   76 +-
 monitoring/MonitoringMessage.h                |   42 +-
 monitoring/MonitoringMessageContent.h         |  154 +-
 monitoring/ReceivesMonitoringReportsIF.h      |   30 +-
 monitoring/TriplexMonitor.h                   |  310 +-
 monitoring/TwoValueLimitMonitor.h             |   88 +-
 objectmanager/ObjectManager.cpp               |  216 +-
 objectmanager/ObjectManager.h                 |  134 +-
 objectmanager/ObjectManagerIF.h               |  190 +-
 objectmanager/SystemObject.cpp                |   74 +-
 objectmanager/SystemObject.h                  |  122 +-
 objectmanager/SystemObjectIF.h                |  124 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  182 +-
 osal/FreeRTOS/BinSemaphUsingTask.h            |  150 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |   14 +-
 osal/FreeRTOS/BinarySemaphore.h               |    4 +-
 osal/FreeRTOS/Clock.cpp                       |  392 +--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  220 +-
 osal/FreeRTOS/CountingSemaphUsingTask.h       |  200 +-
 osal/FreeRTOS/CountingSemaphore.cpp           |   86 +-
 osal/FreeRTOS/CountingSemaphore.h             |   68 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  324 +-
 osal/FreeRTOS/FixedTimeslotTask.h             |  202 +-
 osal/FreeRTOS/MessageQueue.cpp                |  310 +-
 osal/FreeRTOS/MessageQueue.h                  |  424 +--
 osal/FreeRTOS/Mutex.cpp                       |  102 +-
 osal/FreeRTOS/Mutex.h                         |   58 +-
 osal/FreeRTOS/MutexFactory.cpp                |   56 +-
 osal/FreeRTOS/PeriodicTask.cpp                |  276 +-
 osal/FreeRTOS/PeriodicTask.h                  |  256 +-
 osal/FreeRTOS/QueueFactory.cpp                |   72 +-
 osal/FreeRTOS/SemaphoreFactory.cpp            |  122 +-
 osal/FreeRTOS/TaskFactory.cpp                 |  106 +-
 osal/FreeRTOS/TaskManagement.cpp              |   12 +-
 osal/FreeRTOS/TaskManagement.h                |   20 +-
 osal/FreeRTOS/Timekeeper.cpp                  |   82 +-
 osal/FreeRTOS/Timekeeper.h                    |   80 +-
 osal/InternalErrorCodes.h                     |   78 +-
 osal/host/Clock.cpp                           |  454 +--
 osal/host/FixedTimeslotTask.cpp               |  382 +--
 osal/host/FixedTimeslotTask.h                 |  260 +-
 osal/host/MessageQueue.cpp                    |  310 +-
 osal/host/MessageQueue.h                      |  460 +--
 osal/host/Mutex.cpp                           |   80 +-
 osal/host/Mutex.h                             |   56 +-
 osal/host/MutexFactory.cpp                    |   56 +-
 osal/host/PeriodicTask.cpp                    |  352 +--
 osal/host/PeriodicTask.h                      |  246 +-
 osal/host/QueueFactory.cpp                    |   82 +-
 osal/host/QueueMapManager.cpp                 |  102 +-
 osal/host/QueueMapManager.h                   |   94 +-
 osal/host/SemaphoreFactory.cpp                |   84 +-
 osal/host/TaskFactory.cpp                     |  110 +-
 osal/linux/BinarySemaphore.cpp                |    4 +-
 osal/linux/BinarySemaphore.h                  |    4 +-
 osal/linux/Clock.cpp                          |  440 +--
 osal/linux/CountingSemaphore.cpp              |  108 +-
 osal/linux/CountingSemaphore.h                |   74 +-
 osal/linux/FixedTimeslotTask.cpp              |  182 +-
 osal/linux/FixedTimeslotTask.h                |  154 +-
 osal/linux/InternalErrorCodes.cpp             |   28 +-
 osal/linux/MessageQueue.cpp                   |  738 ++---
 osal/linux/MessageQueue.h                     |  374 +--
 osal/linux/Mutex.cpp                          |  222 +-
 osal/linux/Mutex.h                            |   44 +-
 osal/linux/MutexFactory.cpp                   |   46 +-
 osal/linux/PeriodicPosixTask.cpp              |  164 +-
 osal/linux/PeriodicPosixTask.h                |  180 +-
 osal/linux/PosixThread.cpp                    |  434 +--
 osal/linux/PosixThread.h                      |  154 +-
 osal/linux/QueueFactory.cpp                   |   76 +-
 osal/linux/SemaphoreFactory.cpp               |   72 +-
 osal/linux/TaskFactory.cpp                    |   84 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |  274 +-
 osal/linux/TcUnixUdpPollingTask.h             |  134 +-
 osal/linux/Timer.cpp                          |   84 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  336 +-
 osal/linux/TmTcUnixUdpBridge.h                |   96 +-
 osal/rtems/Clock.cpp                          |  396 +--
 osal/rtems/CpuUsage.cpp                       |  366 +--
 osal/rtems/CpuUsage.h                         |  106 +-
 osal/rtems/InternalErrorCodes.cpp             |  120 +-
 osal/rtems/Interrupt.h                        |  100 +-
 osal/rtems/MessageQueue.cpp                   |  294 +-
 osal/rtems/MessageQueue.h                     |  362 +--
 osal/rtems/MultiObjectTask.cpp                |  174 +-
 osal/rtems/MultiObjectTask.h                  |  226 +-
 osal/rtems/Mutex.cpp                          |  130 +-
 osal/rtems/Mutex.h                            |   36 +-
 osal/rtems/MutexFactory.cpp                   |   48 +-
 osal/rtems/PollingTask.cpp                    |  244 +-
 osal/rtems/PollingTask.h                      |  170 +-
 osal/rtems/QueueFactory.cpp                   |  118 +-
 osal/rtems/RtemsBasic.h                       |   50 +-
 osal/rtems/TaskBase.cpp                       |  164 +-
 osal/rtems/TaskBase.h                         |   94 +-
 osal/rtems/TaskFactory.cpp                    |   82 +-
 parameters/HasParametersIF.h                  |  134 +-
 parameters/ParameterHelper.cpp                |  264 +-
 parameters/ParameterHelper.h                  |   72 +-
 parameters/ParameterMessage.cpp               |   96 +-
 parameters/ParameterMessage.h                 |   58 +-
 parameters/ParameterWrapper.cpp               |  560 ++--
 parameters/ParameterWrapper.h                 |  324 +-
 parameters/ReceivesParameterMessagesIF.h      |   38 +-
 power/Fuse.cpp                                |  520 +--
 power/Fuse.h                                  |  212 +-
 power/PowerComponent.cpp                      |  172 +-
 power/PowerComponent.h                        |   96 +-
 power/PowerComponentIF.h                      |   48 +-
 power/PowerSensor.cpp                         |  256 +-
 power/PowerSensor.h                           |  142 +-
 power/PowerSwitchIF.h                         |  160 +-
 power/PowerSwitcher.cpp                       |  254 +-
 power/PowerSwitcher.h                         |   90 +-
 pus/CService200ModeCommanding.cpp             |   12 +-
 pus/CService200ModeCommanding.h               |    2 +-
 pus/Service1TelecommandVerification.cpp       |  200 +-
 pus/Service1TelecommandVerification.h         |  188 +-
 pus/Service2DeviceAccess.cpp                  |   20 +-
 pus/Service2DeviceAccess.h                    |    6 +-
 pus/Service5EventReporting.cpp                |  182 +-
 pus/Service5EventReporting.h                  |  172 +-
 pus/Service8FunctionManagement.cpp            |   14 +-
 pus/Service8FunctionManagement.h              |    4 +-
 pus/servicepackets/Service1Packets.h          |  332 +-
 pus/servicepackets/Service200Packets.h        |    6 +-
 pus/servicepackets/Service2Packets.h          |    8 +-
 pus/servicepackets/Service5Packets.h          |  152 +-
 pus/servicepackets/Service8Packets.h          |   12 +-
 returnvalues/HasReturnvaluesIF.h              |   62 +-
 rmap/RMAP.cpp                                 |  178 +-
 rmap/RMAP.h                                   |  454 +--
 rmap/RMAPChannelIF.h                          |  232 +-
 rmap/RMAPCookie.cpp                           |  248 +-
 rmap/RMAPCookie.h                             |  118 +-
 rmap/RmapDeviceCommunicationIF.cpp            |   94 +-
 rmap/RmapDeviceCommunicationIF.h              |  178 +-
 serialize/EndianConverter.h                   |  248 +-
 serialize/SerialArrayListAdapter.h            |  182 +-
 serialize/SerialBufferAdapter.cpp             |  256 +-
 serialize/SerialBufferAdapter.h               |  156 +-
 serialize/SerialFixedArrayListAdapter.h       |  126 +-
 serialize/SerialLinkedListAdapter.h           |  266 +-
 serialize/SerializeAdapter.h                  |  350 +--
 serialize/SerializeElement.h                  |  120 +-
 serialize/SerializeIF.h                       |  116 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   |  434 +--
 serviceinterface/ServiceInterfaceBuffer.h     |  290 +-
 serviceinterface/ServiceInterfaceStream.cpp   |   64 +-
 serviceinterface/ServiceInterfaceStream.h     |  116 +-
 storagemanager/ConstStorageAccessor.cpp       |  174 +-
 storagemanager/ConstStorageAccessor.h         |  232 +-
 storagemanager/LocalPool.h                    |  378 +--
 storagemanager/PoolManager.h                  |   98 +-
 storagemanager/StorageAccessor.cpp            |  134 +-
 storagemanager/StorageAccessor.h              |   90 +-
 storagemanager/StorageManagerIF.h             |  334 +-
 subsystem/Subsystem.cpp                       | 1324 ++++----
 subsystem/Subsystem.h                         |  328 +-
 subsystem/SubsystemBase.cpp                   |  712 ++---
 subsystem/SubsystemBase.h                     |  258 +-
 subsystem/modes/HasModeSequenceIF.h           |   40 +-
 subsystem/modes/ModeDefinitions.h             |  304 +-
 subsystem/modes/ModeSequenceMessage.cpp       |  178 +-
 subsystem/modes/ModeSequenceMessage.h         |   96 +-
 subsystem/modes/ModeStore.cpp                 |  252 +-
 subsystem/modes/ModeStore.h                   |   90 +-
 subsystem/modes/ModeStoreIF.h                 |   74 +-
 tasks/ExecutableObjectIF.h                    |  106 +-
 tasks/FixedSequenceSlot.cpp                   |   32 +-
 tasks/FixedSequenceSlot.h                     |  110 +-
 tasks/FixedSlotSequence.cpp                   |  248 +-
 tasks/FixedSlotSequence.h                     |  308 +-
 tasks/FixedTimeslotTaskIF.h                   |   58 +-
 tasks/PeriodicTaskIF.h                        |   98 +-
 tasks/SemaphoreFactory.h                      |   98 +-
 tasks/SemaphoreIF.h                           |  144 +-
 tasks/TaskFactory.h                           |  146 +-
 tcdistribution/CCSDSDistributor.cpp           |  164 +-
 tcdistribution/CCSDSDistributor.h             |  138 +-
 tcdistribution/CCSDSDistributorIF.h           |   80 +-
 tcdistribution/PUSDistributor.cpp             |  184 +-
 tcdistribution/PUSDistributor.h               |  154 +-
 tcdistribution/PUSDistributorIF.h             |   52 +-
 tcdistribution/TcDistributor.cpp              |  108 +-
 tcdistribution/TcDistributor.h                |  240 +-
 tcdistribution/TcPacketCheck.cpp              |   74 +-
 tcdistribution/TcPacketCheck.h                |  118 +-
 thermal/AbstractTemperatureSensor.cpp         |  140 +-
 thermal/AbstractTemperatureSensor.h           |  128 +-
 thermal/AcceptsThermalMessagesIF.h            |    2 +-
 thermal/CoreComponent.h                       |  192 +-
 thermal/Heater.cpp                            |  700 ++---
 thermal/Heater.h                              |  180 +-
 thermal/RedundantHeater.h                     |  100 +-
 thermal/TemperatureSensor.h                   |  444 +--
 thermal/ThermalComponentIF.h                  |  228 +-
 thermal/ThermalModule.cpp                     |  576 ++--
 thermal/ThermalModule.h                       |  190 +-
 thermal/ThermalMonitor.cpp                    |  136 +-
 thermal/ThermalMonitor.h                      |   52 +-
 timemanager/CCSDSTime.cpp                     | 1204 +++----
 timemanager/CCSDSTime.h                       |  466 +--
 timemanager/Clock.h                           |  310 +-
 timemanager/Countdown.cpp                     |   90 +-
 timemanager/Countdown.h                       |   62 +-
 timemanager/ReceivesTimeInfoIF.h              |   64 +-
 timemanager/Stopwatch.cpp                     |    4 +-
 timemanager/Stopwatch.h                       |    2 +-
 timemanager/TimeMessage.cpp                   |   74 +-
 timemanager/TimeMessage.h                     |  112 +-
 timemanager/TimeStamperIF.h                   |   48 +-
 tmstorage/TmStoreBackendIF.h                  |  190 +-
 tmstorage/TmStoreFrontendIF.h                 |  126 +-
 tmstorage/TmStoreMessage.cpp                  |  330 +-
 tmstorage/TmStoreMessage.h                    |  126 +-
 tmstorage/TmStorePackets.h                    |  600 ++--
 tmtcpacket/SpacePacket.cpp                    |   54 +-
 tmtcpacket/SpacePacket.h                      |  140 +-
 tmtcpacket/SpacePacketBase.cpp                |  208 +-
 tmtcpacket/SpacePacketBase.h                  |  354 +--
 tmtcpacket/packetmatcher/ApidMatcher.h        |   80 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp  |  390 +--
 tmtcpacket/packetmatcher/PacketMatchTree.h    |   72 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h     |   78 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h  |   80 +-
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   32 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  186 +-
 tmtcpacket/pus/TcPacketBase.h                 |  408 +--
 tmtcpacket/pus/TcPacketStored.cpp             |  236 +-
 tmtcpacket/pus/TcPacketStored.h               |  220 +-
 tmtcpacket/pus/TmPacketBase.cpp               |  238 +-
 tmtcpacket/pus/TmPacketBase.h                 |  372 +--
 tmtcpacket/pus/TmPacketMinimal.cpp            |   90 +-
 tmtcpacket/pus/TmPacketMinimal.h              |  168 +-
 tmtcpacket/pus/TmPacketStored.cpp             |  290 +-
 tmtcpacket/pus/TmPacketStored.h               |  192 +-
 tmtcservices/AcceptsTelecommandsIF.h          |   86 +-
 tmtcservices/AcceptsTelemetryIF.h             |   52 +-
 tmtcservices/AcceptsVerifyMessageIF.h         |   30 +-
 tmtcservices/CommandingServiceBase.cpp        |  854 ++---
 tmtcservices/CommandingServiceBase.h          |  696 ++--
 tmtcservices/PusParser.cpp                    |  228 +-
 tmtcservices/PusParser.h                      |  164 +-
 tmtcservices/PusServiceBase.cpp               |  246 +-
 tmtcservices/PusServiceBase.h                 |  318 +-
 tmtcservices/PusVerificationReport.cpp        |  326 +-
 tmtcservices/PusVerificationReport.h          |  154 +-
 tmtcservices/SourceSequenceCounter.h          |   60 +-
 tmtcservices/TmTcBridge.cpp                   |   18 +-
 tmtcservices/TmTcBridge.h                     |   16 +-
 tmtcservices/TmTcMessage.cpp                  |   58 +-
 tmtcservices/TmTcMessage.h                    |  100 +-
 tmtcservices/VerificationReporter.cpp         |  210 +-
 tmtcservices/VerificationReporter.h           |  100 +-
 458 files changed, 43655 insertions(+), 43655 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index dc6bd498..a367af16 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,110 +1,110 @@
-#include <framework/action/ActionHelper.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
-}
-
-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;
-	}
-}
-
-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_);
-	}
-
-	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::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
-}
-
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	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;
-	}
-}
-
-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);
-
-	//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;
-}
-
-void ActionHelper::resetHelper() {
-}
+#include "../action/ActionHelper.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+}
+
+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;
+	}
+}
+
+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_);
+	}
+
+	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::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setCompletionReply(&reply, commandId, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
+	queueToUse = queue;
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+		store_address_t dataAddress) {
+	const uint8_t* dataPtr = NULL;
+	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;
+	}
+}
+
+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);
+
+	//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;
+}
+
+void ActionHelper::resetHelper() {
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 3d8351d6..f528b031 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -1,93 +1,93 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-/**
- * \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!
- */
-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);
-
-	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);
-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();
-};
-
-#endif /* ACTIONHELPER_H_ */
+#ifndef ACTIONHELPER_H_
+#define ACTIONHELPER_H_
+
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * \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!
+ */
+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);
+
+	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);
+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();
+};
+
+#endif /* ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 96ff59b6..5743cc74 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,79 +1,79 @@
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-ActionMessage::ActionMessage() {
-}
-
-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);
-}
-
-ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
-}
-
-store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	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);
-}
-
-uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
-}
-
-ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	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);
-}
-
-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);
-}
-
-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;
-	}
-}
+#include "../action/ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+ActionMessage::ActionMessage() {
+}
+
+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);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+	return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+	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);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+	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);
+}
+
+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);
+}
+
+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;
+	}
+}
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 59ad619e..aae44e16 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,32 +1,32 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-typedef uint32_t ActionId_t;
-
-class ActionMessage {
-private:
-	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);
-};
-
-#endif /* ACTIONMESSAGE_H_ */
+#ifndef ACTIONMESSAGE_H_
+#define ACTIONMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+typedef uint32_t ActionId_t;
+
+class ActionMessage {
+private:
+	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);
+};
+
+#endif /* ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index 70ffbbde..d8d506aa 100644
--- a/action/CommandActionHelper.cpp
+++ b/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>
-
-CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		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);
-}
-
-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);
-}
-
-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;
-}
-
-ReturnValue_t CommandActionHelper::initialize() {
-	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;
-}
-
-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;
-	}
-}
-
-uint8_t CommandActionHelper::getCommandCount() const {
-	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);
-}
+#include "../action/ActionMessage.h"
+#include "../action/CommandActionHelper.h"
+#include "../action/CommandsActionsIF.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
+		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);
+}
+
+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);
+}
+
+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;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+	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;
+}
+
+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;
+	}
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+	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);
+}
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index 24d0380c..edbcaadd 100644
--- a/action/CommandActionHelper.h
+++ b/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>
-
-class CommandsActionsIF;
-
-class CommandActionHelper {
-	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;
-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);
-};
-
-#endif /* COMMANDACTIONHELPER_H_ */
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_H_
+
+#include "../action/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;
+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;
+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);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index db76fb50..bead3140 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,34 +1,34 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
-
-#include <framework/action/CommandActionHelper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-/**
- * Interface to separate commanding actions of other objects.
- * In next iteration, IF should be shortened to three calls:
- * - dataReceived(data)
- * - successReceived(id, step)
- * - failureReceived(id, step, cause)
- * or even
- * - replyReceived(id, step, cause) (if cause == OK, it's a success).
- */
-class CommandsActionsIF {
-	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;
-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;
-};
-
-
-#endif /* COMMANDSACTIONSIF_H_ */
+#ifndef COMMANDSACTIONSIF_H_
+#define COMMANDSACTIONSIF_H_
+
+#include "../action/CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+	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;
+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;
+};
+
+
+#endif /* COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 008d9eaf..283664a3 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,60 +1,60 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_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
- *
- * @details
- * This interface is used to execute actions in the component. Actions, in the
- * sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed
- * to change the main mode of operation, which is handled with the HasModesIF
- * described below.
- *
- * The HasActionsIF allows components to define such actions and make them
- * available for other components to use. Implementing the interface is
- * straightforward: There’s a single executeAction call, which provides an
- * identifier for the action to execute, as well as arbitrary parameters for
- * input.
- * Aside from direct, software-based actions, it is used in device handler
- * components as an interface to forward commands to devices.
- * Implementing components of the interface are supposed to check identifier
- * (ID) and parameters and immediately start execution of the action.
- * It is, however, not required to immediately finish execution.
- * Instead, this may be deferred to a later point in time, at which the
- * component needs to inform the caller about finished or failed execution.
- *
- * @ingroup interfaces
- */
-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;
-};
-
-
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+
+#include "../action/ActionHelper.h"
+#include "../action/ActionMessage.h"
+#include "../action/SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * @brief
+ * Interface for component which uses actions
+ *
+ * @details
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
+ *
+ * @ingroup interfaces
+ */
+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;
+};
+
+
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 6861fc28..83ce3c85 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,74 +1,74 @@
-#include <framework/action/HasActionsIF.h>
-#include <framework/action/SimpleActionHelper.h>
-SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
-}
-
-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();
-	}
-}
-
-void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
-}
-
-ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
-}
-
-void SimpleActionHelper::resetHelper() {
-	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;
-	}
-
-}
+#include "../action/HasActionsIF.h"
+#include "../action/SimpleActionHelper.h"
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+		MessageQueueIF* useThisQueue) :
+		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+				0), lastAction(0), stepCount(0) {
+}
+
+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();
+	}
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+	ActionHelper::finish(lastCommander, lastAction, result);
+	resetHelper();
+}
+
+ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
+	return ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+	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;
+	}
+
+}
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 71e73c5a..05025f82 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,24 +1,24 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
-
-#include <framework/action/ActionHelper.h>
-
-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);
-
-protected:
-	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;
-};
-
-#endif /* SIMPLEACTIONHELPER_H_ */
+#ifndef SIMPLEACTIONHELPER_H_
+#define SIMPLEACTIONHELPER_H_
+
+#include "../action/ActionHelper.h"
+
+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);
+
+protected:
+	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;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */
diff --git a/container/ArrayList.h b/container/ArrayList.h
index 8138864b..436dc716 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,247 +1,247 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @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.
- *
- * @ingroup container
- */
-template<typename T, typename count_t = uint8_t>
-class ArrayList {
-	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);
-
-    /**
-     * 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;
-
-	/**
-	 * 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;
-		}
-	}
-
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
-
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
-
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
-
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
-
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
-
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
-
-        T operator*() {
-            return *value;
-        }
-
-        T *operator->() {
-            return value;
-        }
-
-        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]);
-	}
-
-	/**
-	 * 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]);
-	}
-
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
-
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
-
-	/**
-	 * 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());
-	}
-
-	const T* back() const{
-		return &entries[size-1];
-	}
-
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	uint32_t maxSize() const {
-		return this->maxSize_;
-	}
-
-	/**
-	 * 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_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
-};
-
-#endif /* ARRAYLIST_H_ */
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @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.
+ *
+ * @ingroup container
+ */
+template<typename T, typename count_t = uint8_t>
+class ArrayList {
+	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);
+
+    /**
+     * 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;
+
+	/**
+	 * 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;
+		}
+	}
+
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        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]);
+	}
+
+	/**
+	 * 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]);
+	}
+
+	T & operator[](count_t i) const {
+		return entries[i];
+	}
+
+	/**
+	 * The first element
+	 *
+	 * @return pointer to the first stored element
+	 */
+	T *front() {
+		return entries;
+	}
+
+	/**
+	 * 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());
+	}
+
+	const T* back() const{
+		return &entries[size-1];
+	}
+
+	/**
+	 * The maximum number of elements this List can contain
+	 *
+	 * @return maximum number of elements
+	 */
+	uint32_t maxSize() const {
+		return this->maxSize_;
+	}
+
+	/**
+	 * 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_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+};
+
+#endif /* ARRAYLIST_H_ */
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 59adfb3a..b63cee65 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,42 +1,42 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-
-#include <framework/container/FIFOBase.h>
-#include <vector>
-
-/**
- * @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!
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-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());
-	}
-
-
-private:
-	std::vector<T> fifoVector;
-};
-
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include "../container/FIFOBase.h"
+#include <vector>
+
+/**
+ * @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!
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+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());
+	}
+
+
+private:
+	std::vector<T> fifoVector;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 2e332dc2..a870e773 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/container/FIFOBase.h>
-#include <array>
-
-/**
- * @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.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class FIFO: public FIFOBase<T> {
-public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
-
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
-	}
-
-private:
-	std::array<T, capacity> fifoArray;
-};
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../container/FIFOBase.h"
+#include <array>
+
+/**
+ * @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.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
+public:
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
+
+private:
+	std::array<T, capacity> fifoArray;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 7f8bde96..ddccbdd4 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,65 +1,65 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_H_
-
-#include <framework/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);
-
-	/** 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();
-
-	bool empty();
-	bool full();
-	size_t size();
-
-
-	size_t getMaxCapacity() const;
-
-protected:
-	void setData(T* data);
-	size_t maxCapacity = 0;
-
-	T* values;
-
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
-
-	size_t next(size_t current);
-};
-
-#include <framework/container/FIFOBase.tpp>
-
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_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);
+
+	/** 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();
+
+	bool empty();
+	bool full();
+	size_t size();
+
+
+	size_t getMaxCapacity() const;
+
+protected:
+	void setData(T* data);
+	size_t maxCapacity = 0;
+
+	T* values;
+
+	size_t readIndex = 0;
+	size_t writeIndex = 0;
+	size_t currentSize = 0;
+
+	size_t next(size_t current);
+};
+
+#include "../container/FIFOBase.tpp"
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index a2d2fa25..70a1d5e2 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,57 +1,57 @@
-#ifndef FIXEDARRAYLIST_H_
-#define FIXEDARRAYLIST_H_
-
-#include <framework/container/ArrayList.h>
-
-/**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
- */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class FixedArrayList: public ArrayList<T, count_t> {
-private:
-	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) {
-	}
-
-	// (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;
-	}
-
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
-
-};
-
-#endif /* FIXEDARRAYLIST_H_ */
+#ifndef FIXEDARRAYLIST_H_
+#define FIXEDARRAYLIST_H_
+
+#include "../container/ArrayList.h"
+
+/**
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
+ */
+template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class FixedArrayList: public ArrayList<T, count_t> {
+private:
+	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) {
+	}
+
+	// (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;
+	}
+
+	FixedArrayList& operator=(FixedArrayList other) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+		return *this;
+	}
+
+	virtual ~FixedArrayList() {
+	}
+
+};
+
+#endif /* FIXEDARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7ef4d7ae..a3afc023 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,225 +1,225 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <utility>
-
-/**
- * @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).
- * @ingroup container
- */
-template<typename key_t, typename T>
-class FixedMap: public SerializeIF {
-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);
-
-private:
-	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;
-	}
-public:
-	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() {
-		}
-
-		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;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// 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;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			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 (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 insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.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;
-	}
-
-	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 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;
-	}
-
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
-
-	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;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
-	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;
-	}
-
-};
-
-#endif /* FIXEDMAP_H_ */
+#ifndef FIXEDMAP_H_
+#define FIXEDMAP_H_
+
+#include "../container/ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <utility>
+
+/**
+ * @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).
+ * @ingroup container
+ */
+template<typename key_t, typename T>
+class FixedMap: public SerializeIF {
+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);
+
+private:
+	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;
+	}
+public:
+	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() {
+		}
+
+		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;
+		}
+
+		// -> operator overloaded, can be used to access value
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// 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;
+		}
+
+		// Alternative to access value, similar to std::map implementation
+		T second() {
+			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 (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 insert(std::pair<key_t, T> pair) {
+		return insert(pair.first, pair.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;
+	}
+
+	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 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;
+	}
+
+	T *findValue(key_t key) const {
+		return &theMap[findIndex(key)].second;
+	}
+
+	Iterator find(key_t key) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findIndex(key)]);
+	}
+
+	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;
+	}
+
+	void clear() {
+		_size = 0;
+	}
+
+	uint32_t maxSize() const {
+		return theMap.maxSize();
+	}
+
+
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	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;
+	}
+
+};
+
+#endif /* FIXEDMAP_H_ */
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 3dd20a74..5bc007ef 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,181 +1,181 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-
-#include <framework/container/ArrayList.h>
-#include <cstring>
-#include <set>
-/**
- * \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);
-
-private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_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;
-	}
-
-	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();
-	}
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+
+#include "../container/ArrayList.h"
+#include <cstring>
+#include <set>
+/**
+ * \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);
+
+private:
+	typedef KEY_COMPARE compare;
+	compare myComp;
+	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+	uint32_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;
+	}
+
+	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();
+	}
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index f2fd6b28..11881326 100644
--- a/container/HybridIterator.h
+++ b/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>
-
-template<typename T, typename count_t = uint8_t>
-class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
-public:
-	HybridIterator() {}
-
-	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(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& 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;
-	}
-
-	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 !(*this == other);
-	}
-
-	T operator*() {
-		return *value;
-	}
-
-	T *operator->() {
-		return value;
-	}
-
-	T* value = nullptr;
-
-private:
-	bool linked = false;
-	T *end = nullptr;
-};
-
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+
+#include "../container/ArrayList.h"
+#include "../container/SinglyLinkedList.h"
+
+template<typename T, typename count_t = uint8_t>
+class HybridIterator: public LinkedElement<T>::Iterator,
+		public ArrayList<T, count_t>::Iterator {
+public:
+	HybridIterator() {}
+
+	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(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& 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;
+	}
+
+	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 !(*this == other);
+	}
+
+	T operator*() {
+		return *value;
+	}
+
+	T *operator->() {
+		return value;
+	}
+
+	T* value = nullptr;
+
+private:
+	bool linked = false;
+	T *end = nullptr;
+};
+
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index d433df62..282916e1 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,721 +1,721 @@
-#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <cmath>
-
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
-template<typename T>
-class Index: public SerializeIF{
-	/**
-	 *
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
-public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
-
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
-	}
-
-	void setBlockStartAddress(uint32_t newAddress) {
-		this->blockStartAddress = newAddress;
-	}
-
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
-
-	const T* getIndexType() const {
-		return &indexType;
-	}
-
-	T* modifyIndexType() {
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
-
-	uint32_t getSize() const {
-		return size;
-	}
-
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
-
-	void addSize(uint32_t size){
-		this->size += size;
-	}
-
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
-
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
-
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
-
-
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
-
-private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
-};
-
-
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
-template<typename T>
-class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 *
-	 */
-public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
-
-		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
-
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
-
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-
-		//Update the totalSize for calculations
-		totalSize = useableSize;
-
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
-
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
-
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
-
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
-
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
-
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
-
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
-
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
-
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
-
-	/**
-	 * Reading
-	 * @param it
-	 */
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
-
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
-
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-
-	}
-
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
-
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
-
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}
-			else {
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}
-		else {
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0) {
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
-
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
-
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
-
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
-
-
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
-
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
-
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
-
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
-
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
-
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
-
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
-		return (sizeToWrite < availableSize);
-	}
-
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
-
-
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
-
-		size_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
-
-
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
-
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
-
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
-
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
-
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
-
-		return (double)filledSize/(double)this->totalSize;
-	}
-
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
-private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
-
-	//The address of the index
-	const uint32_t indexAddress;
-
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
-
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
-
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
-
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
-
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
-
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+
+#include "../container/ArrayList.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include <cmath>
+
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
+template<typename T>
+class Index: public SerializeIF{
+	/**
+	 *
+	 */
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
+public:
+	Index():blockStartAddress(0),size(0),storedPackets(0){}
+
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
+	}
+
+	void setBlockStartAddress(uint32_t newAddress) {
+		this->blockStartAddress = newAddress;
+	}
+
+	uint32_t getBlockStartAddress() const {
+		return blockStartAddress;
+	}
+
+	const T* getIndexType() const {
+		return &indexType;
+	}
+
+	T* modifyIndexType() {
+		return &indexType;
+	}
+	/**
+	 * Updates the index Type. Uses = operator
+	 * @param indexType Type to copy from
+	 */
+	void setIndexType(T* indexType) {
+		this->indexType = *indexType;
+	}
+
+	uint32_t getSize() const {
+		return size;
+	}
+
+	void setSize(uint32_t size) {
+		this->size = size;
+	}
+
+	void addSize(uint32_t size){
+		this->size += size;
+	}
+
+	void setStoredPackets(uint32_t newStoredPackets){
+		this->storedPackets = newStoredPackets;
+	}
+
+	void addStoredPackets(uint32_t packets){
+		this->storedPackets += packets;
+	}
+
+	uint32_t getStoredPackets() const{
+		return this->storedPackets;
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+		size += indexType.getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+		return size;
+	}
+
+
+	bool operator==(const Index<T>& other){
+		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+	}
+
+private:
+	uint32_t blockStartAddress;
+	uint32_t size;
+	uint32_t storedPackets;
+	T indexType;
+};
+
+
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
+template<typename T>
+class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
+	/**
+	 *
+	 */
+public:
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
+		//Calculate the maximum number of indices needed for this blocksize
+		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+
+		//Calculate the Size needeed for the index itself
+		size_t serializedSize = 0;
+		if(additionalInfo!=NULL) {
+			serializedSize += additionalInfo->getSerializedSize();
+		}
+
+		//Size of current iterator type
+		Index<T> tempIndex;
+		serializedSize += tempIndex.getSerializedSize();
+
+		//Add Size of Array
+		serializedSize += sizeof(uint32_t); //size of array
+		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+		serializedSize += sizeof(uint16_t); //size of crc
+
+		//Calculate new size after index
+		if(serializedSize > totalSize){
+			error << "IndexedRingMemory: Store is too small for index" << std::endl;
+		}
+		uint32_t useableSize = totalSize - serializedSize;
+
+		//Update the totalSize for calculations
+		totalSize = useableSize;
+
+		//True StartAddress
+		uint32_t trueStartAddress = indexAddress + serializedSize;
+
+		//Calculate True number of Blocks and reset size of true Number of Blocks
+		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+
+		//allocate memory now
+		this->entries = new Index<T>[trueNumberOfBlocks];
+		this->size = trueNumberOfBlocks;
+		this->maxSize_ = trueNumberOfBlocks;
+		this->allocated = true;
+
+		//Check trueNumberOfBlocks
+		if(trueNumberOfBlocks<1) {
+			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+		}
+
+		//Fill address into index
+		uint32_t address = trueStartAddress;
+		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+			it->setBlockStartAddress(address);
+			it->setSize(0);
+			it->setStoredPackets(0);
+			address += bytesPerBlock;
+		}
+
+		//Initialize iterators
+		currentWriteBlock = this->begin();
+		currentReadBlock = this->begin();
+		lastBlockToRead = this->begin();
+
+		//Check last blockSize
+		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+			//remove the last Block so the second last block has more size
+			this->size -= 1;
+			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+		}
+	}
+
+	/**
+	 * Resets the whole index, the iterators and executes the given reset function on every index type
+	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
+	 */
+	void reset(void (*typeResetFnc)(T*)){
+		currentReadBlock = this->begin();
+		currentWriteBlock = this->begin();
+		lastBlockToRead = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = 0;
+		lastBlockToReadSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+			it->setSize(0);
+			it->setStoredPackets(0);
+			(*typeResetFnc)(it->modifyIndexType());
+		}
+	}
+
+	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+		it->setSize(0);
+		it->setStoredPackets(0);
+		(*typeResetFnc)(it->modifyIndexType());
+	}
+
+	/**
+	 * Reading
+	 * @param it
+	 */
+	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+		currentReadBlock = it;
+		currentReadBlockSizeCached = it->getSize();
+	}
+
+	void resetRead(){
+		currentReadBlock = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = this->begin()->getSize();
+		lastBlockToRead = currentWriteBlock;
+		lastBlockToReadSize = currentWriteBlock->getSize();
+	}
+
+	/**
+	 * Sets the last block to read to this iterator.
+	 * Can be used to dump until block x
+	 * @param it The iterator for the last read block
+	 */
+	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+		lastBlockToRead = it;
+		lastBlockToReadSize = it->getSize();
+	}
+
+	/**
+	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+	 * Can be the currentWriteBlock as well
+	 */
+	void readOldest(){
+		resetRead();
+		currentReadBlock = getNextNonEmptyBlock();
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+
+	}
+
+	/**
+	 * Sets the current read iterator to the next Block and resets the current read size
+	 * The current size of the block will be cached to avoid race condition between write and read
+	 * If the end of the ring is reached the read pointer will be set to the begin
+	 */
+	void readNext(){
+		currentReadSize = 0;
+		if((this->size != 0) && (currentReadBlock.value ==this->back())){
+			currentReadBlock = this->begin();
+		}else{
+			currentReadBlock++;
+		}
+
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+	}
+
+	/**
+	 * Returns the address which is currently read from
+	 * @return Address to read from
+	 */
+	uint32_t getCurrentReadAddress() const {
+		return getAddressOfCurrentReadBlock() + currentReadSize;
+	}
+
+	/**
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
+	 * @param readSize The size that was read
+	 * @return Returns true if the read can go on
+	 */
+	bool addReadSize(uint32_t readSize) {
+		if(currentReadBlock == lastBlockToRead) {
+			//The current read block is the last to read
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
+				//the block has more data -> return true
+				currentReadSize += readSize;
+				return true;
+			}
+			else {
+				//Reached end of read -> return false
+				currentReadSize = lastBlockToReadSize;
+				return false;
+			}
+		}
+		else {
+			//We are not in the last Block
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+				//The current Block has more data
+				currentReadSize += readSize;
+				return true;
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
+				//The current block is written completely
+				readNext();
+				if(currentReadBlockSizeCached==0) {
+					//Next block is empty
+					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+					//Search if any block between this and the last block is not empty
+					for(;it!=lastBlockToRead;++it){
+						if(it == this->end()){
+							//This is the end, next block is the begin
+							it = this->begin();
+							if(it == lastBlockToRead){
+								//Break if the begin is the lastBlockToRead
+								break;
+							}
+						}
+						if(it->getSize()!=0){
+							//This is a non empty block. Go on reading with this block
+							currentReadBlock = it;
+							currentReadBlockSizeCached = it->getSize();
+							return true;
+						}
+					}
+					//reached lastBlockToRead and every block was empty, check if the last block is also empty
+					if(lastBlockToReadSize!=0){
+						//go on with last Block
+						currentReadBlock = lastBlockToRead;
+						currentReadBlockSizeCached = lastBlockToReadSize;
+						return true;
+					}
+					//There is no non empty block left
+					return false;
+				}
+				//Size is larger than 0
+				return true;
+			}
+		}
+	}
+	uint32_t getRemainigSizeOfCurrentReadBlock() const{
+		if(currentReadBlock == lastBlockToRead){
+			return (lastBlockToReadSize - currentReadSize);
+		}else{
+			return (currentReadBlockSizeCached - currentReadSize);
+		}
+	}
+
+	uint32_t getAddressOfCurrentReadBlock() const {
+		return currentReadBlock->getBlockStartAddress();
+	}
+
+	/**
+	 * Gets the next non empty Block after the current write block,
+	 * @return Returns the iterator to the block. If there is non, the current write block is returned
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+				if(it == this->end()){
+					it = this->begin();
+					if(it == currentWriteBlock){
+						break;
+					}
+				}
+				if(it->getSize()!=0){
+					return it;
+				}
+		}
+		return currentWriteBlock;
+	}
+
+	/**
+	 * Returns a copy of the oldest Index type
+	 * @return Type of Index
+	 */
+	T* getOldest(){
+		return (getNextNonEmptyBlock()->modifyIndexType());
+	}
+
+
+	/*
+	 * Writing
+	 */
+	uint32_t getAddressOfCurrentWriteBlock() const{
+		return currentWriteBlock->getBlockStartAddress();
+	}
+
+	uint32_t getSizeOfCurrentWriteBlock() const{
+		return currentWriteBlock->getSize();
+	}
+
+	uint32_t getCurrentWriteAddress() const{
+		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+	}
+
+	void clearCurrentWriteBlock(){
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+	}
+
+	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+		currentWriteBlock->addSize(size);
+		currentWriteBlock->addStoredPackets(storedPackets);
+	}
+
+	T* modifyCurrentWriteBlockIndexType(){
+		return currentWriteBlock->modifyIndexType();
+	}
+
+	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+		it->addSize(size);
+		it->addStoredPackets(storedPackets);
+	}
+
+	/**
+	 * Checks if the block has enough space for sizeToWrite
+	 * @param sizeToWrite The data to be written in the Block
+	 * @return Returns true if size to write is smaller the remaining size of the block
+	 */
+	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+		uint32_t addressOfNextBlock = next->getBlockStartAddress();
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
+		return (sizeToWrite < availableSize);
+	}
+
+	/**
+	 * Checks if the store is full if overwrite old is false
+	 * @return Returns true if it is writeable and false if not
+	 */
+	bool isNextBlockWritable(){
+		//First check if this is the end of the list
+		typename IndexedRingMemoryArray<T>::Iterator next;
+		next = getNextWrite();
+		if((next->getSize()!=0) && (!overwriteOld)){
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Updates current write Block Index Type
+	 * @param infoOfNewBlock
+	 */
+	void updateCurrentBlock(T* infoOfNewBlock){
+		currentWriteBlock->setIndexType(infoOfNewBlock);
+	}
+
+
+	/**
+	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
+	 * @return
+	 */
+	ReturnValue_t writeNext(){
+		//Check Next Block
+		if(!isNextBlockWritable()){
+			//The Index is full and does not overwrite old
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		//Next block can be written, update Metadata
+		currentWriteBlock = getNextWrite();
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * Serializes the Index and calculates the CRC.
+	 * Parameters according to HasSerializeIF
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param streamEndianness
+	 * @return
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
+		uint8_t* crcBuffer = *buffer;
+		uint32_t oldSize = *size;
+		if(additionalInfo!=NULL){
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+		}
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+
+	/**
+	 * Get the serialized Size of the index
+	 * @return The serialized size of the index
+	 */
+	size_t getSerializedSize() const {
+
+		size_t size = 0;
+		if(additionalInfo!=NULL){
+			size += additionalInfo->getSerializedSize();
+		}
+		size += currentWriteBlock->getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += (this->entries[0].getSerializedSize()) * this->size;
+		uint16_t crc = 0;
+		size += SerializeAdapter::getSerializedSize(&crc);
+		return size;
+	}
+	/**
+	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+	 * CRC Has to be checked before!
+	 * @param buffer
+	 * @param size
+	 * @param streamEndianness
+	 * @return
+	 */
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if(additionalInfo!=NULL){
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		Index<T> tempIndex;
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		uint32_t tempSize = 0;
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		if(this->size != tempSize){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::deSerialize(
+					&this->entries[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			if(*(cmp.value) == *(it.value)){
+				currentWriteBlock = it;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		//Reached if current write block iterator is not found
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t getIndexAddress() const {
+		return indexAddress;
+	}
+
+
+	/*
+	 * Statistics
+	 */
+	uint32_t getStoredPackets() const {
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getStoredPackets();
+		}
+		return size;
+	}
+
+	uint32_t getTotalSize() const {
+		return totalSize;
+	}
+
+	uint32_t getCurrentSize() const{
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getSize();
+		}
+		return size;
+	}
+
+	bool isEmpty() const{
+		return getCurrentSize()==0;
+	}
+
+	double getPercentageFilled() const{
+		uint32_t filledSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			filledSize += it->getSize();
+		}
+
+		return (double)filledSize/(double)this->totalSize;
+	}
+
+	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+		return currentWriteBlock;
+	}
+	/**
+	 * Get the next block of the currentWriteBlock.
+	 * Returns the first one if currentWriteBlock is the last one
+	 * @return Iterator pointing to the next block after currentWriteBlock
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+		if((this->size != 0) && (currentWriteBlock.value == this->back())){
+			next = this->begin();
+		}else{
+			++next;
+		}
+		return next;
+	}
+	/**
+	 * Get the block in front of the Iterator
+	 * Returns the last block if it is the first block
+	 * @param it iterator which you want the previous block from
+	 * @return pointing to the block before it
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+		if(this->begin() == it){
+			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+			return next;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator next(it);
+		--next;
+		return next;
+	}
+private:
+	//The total size used by the blocks (without index)
+	uint32_t totalSize;
+
+	//The address of the index
+	const uint32_t indexAddress;
+
+	//The iterators for writing and reading
+	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+
+	//How much of the current read block is read already
+	uint32_t currentReadSize;
+
+	//Cached Size of current read block
+	uint32_t currentReadBlockSizeCached;
+
+	//Last block of current write (should be write block)
+	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+	//current size of last Block to read
+	uint32_t lastBlockToReadSize;
+
+	//Additional Info to be serialized with the index
+	SerializeIF* additionalInfo;
+
+	//Does it overwrite old blocks?
+	const bool overwriteOld;
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index daf4ee20..4a1b7df2 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <utility>
-
-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));
-	}
-private:
-	StorageManagerIF* dataBackend;
-};
-
-#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+
+#include "../storagemanager/StorageManagerIF.h"
+#include <utility>
+
+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));
+	}
+private:
+	StorageManagerIF* dataBackend;
+};
+
+#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index f42a4288..b6ac20c1 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,113 +1,113 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-
-#include <framework/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;
-		}
-	}
-
-	virtual ~RingBufferBase() {}
-
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(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);
-	}
-
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t maxSize() const {
-		return size - 1;
-	}
-
-	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 readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
-
-	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;
-	}
-
-	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;
-		}
-	}
-
-	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];
-	}
-
-	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;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
-};
-
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_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;
+		}
+	}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
+	}
+	bool isEmpty(uint8_t n = 0) {
+		return (availableReadData(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);
+	}
+
+	bool overwritesOld() const {
+		return overwriteOld;
+	}
+
+	size_t maxSize() const {
+		return size - 1;
+	}
+
+	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 readTillWrap(uint8_t n = 0) {
+		return (start + size) - read[n];
+	}
+
+	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;
+	}
+
+	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;
+		}
+	}
+
+	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];
+	}
+
+	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;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
+};
+
+#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 001a21ed..c41e8d30 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,30 +1,30 @@
-#include <framework/container/SharedRingBuffer.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		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):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
-        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
-    return mutex->lockMutex(timeoutType, timeout);
-}
-
-ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
-    return mutex->unlockMutex();
-}
-
-MutexIF* SharedRingBuffer::getMutexHandle() const {
-    return mutex;
-}
+#include "../container/SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		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):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
+}
+
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
+}
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 0b5be052..c6d958cc 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-
-#include <framework/container/SimpleRingBuffer.h>
-#include <framework/ipc/MutexIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/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:
-	/**
-	 * 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);
-
-	/**
-	 * 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();
-
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
-private:
-	MutexIF* mutex = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "../container/SimpleRingBuffer.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:
+	/**
+	 * 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);
+
+	/**
+	 * 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();
+
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
+	MutexIF* getMutexHandle() const;
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 36880813..8d817bb0 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,127 +1,127 @@
-#include <framework/container/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];
-}
-
-SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-}
-
-
-SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
-}
-
-
-ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
-        size_t amount) {
-    if (availableWriteSpace() >= amount or overwriteOld) {
-        size_t amountTillWrap = writeTillWrap();
-        if (amountTillWrap < amount) {
-            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            excessBytes = amount - amountTillWrap;
-        }
-        *writePointer = &buffer[write];
-        incrementWrite(amount);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-}
-
-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;
-	}
-}
-
-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);
-	}
-
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-size_t SimpleRingBuffer::getExcessBytes() const {
-    return excessBytes;
-}
-
-void SimpleRingBuffer::moveExcessBytesToStart() {
-    if(excessBytes > 0) {
-        std::memcpy(buffer, &buffer[size], excessBytes);
-        excessBytes = 0;
-    }
-}
-
-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;
-}
-
+#include "../container/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];
+}
+
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
+
+
+SimpleRingBuffer::~SimpleRingBuffer() {
+	delete[] buffer;
+}
+
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes = amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+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;
+	}
+}
+
+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);
+	}
+
+	if(incrementReadPtr) {
+		deleteData(amount, readRemaining);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
+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;
+}
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 0784e415..a2cb96ab 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,119 +1,119 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-
-#include <framework/container/RingBufferBase.h>
-#include <cstddef>
-
-/**
- * @brief 	Circular buffer implementation, useful for buffering
- *          into data streams.
- * @details
- * Note that the deleteData() has to be called to increment the read pointer.
- * This class allocated dynamically, so
- * @ingroup containers
- */
-class SimpleRingBuffer: public RingBufferBase<> {
-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
-     * operation, the oldest data will be overwritten.
-     * @param maxExcessBytes These additional bytes will be allocated in addtion
-     * to the specified size to accomodate contiguous write operations
-     * 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
-     * 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);
-
-	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);
-
-	/**
-	 * 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);
-
-	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);
-private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
-};
-
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
-
+#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+
+#include "../container/RingBufferBase.h"
+#include <cstddef>
+
+/**
+ * @brief 	Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
+ * @ingroup containers
+ */
+class SimpleRingBuffer: public RingBufferBase<> {
+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
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * 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
+     * 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);
+
+	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);
+
+	/**
+	 * 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);
+
+	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);
+private:
+	static const uint8_t READ_PTR = 0;
+	uint8_t* buffer = nullptr;
+	size_t maxExcessBytes;
+	size_t excessBytes = 0;
+};
+
+#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 674d0fc8..4ce854dc 100644
--- a/controller/ControllerBase.cpp
+++ b/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>
-
-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);
-
-}
-
-ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t ControllerBase::initialize() {
-	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();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.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;
-}
-
-MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		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);
-	}
-
-}
-
-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);
-}
-
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	hkSwitcher.performOperation();
-	performControlOperation();
-	return RETURN_OK;
-}
-
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	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;
-	}
-}
-
-HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
-}
-
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../controller/ControllerBase.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../action/HasActionsIF.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);
+
+}
+
+ControllerBase::~ControllerBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t ControllerBase::initialize() {
+	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();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.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;
+}
+
+MessageQueueId_t ControllerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void ControllerBase::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result;
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		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);
+	}
+
+}
+
+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);
+}
+
+void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void ControllerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void ControllerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
+	handleQueue();
+	hkSwitcher.performOperation();
+	performControlOperation();
+	return RETURN_OK;
+}
+
+void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
+	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;
+	}
+}
+
+HasHealthIF::HealthState ControllerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
+			executingTask = task_;
+}
+
+void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 804bc7c2..d98a6665 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,79 +1,79 @@
-#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>
-
-
-class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
-public:
-
-	static const Mode_t MODE_NORMAL = 2;
-
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
-
-	ReturnValue_t initialize();
-
-	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_);
-
-
-protected:
-	const uint32_t parentId;
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	MessageQueueIF* commandQueue;
-
-	ModeHelper modeHelper;
-
-	HealthHelper healthHelper;
-
-	HkSwitchHelper hkSwitcher;
-
-	/**
-	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask;
-
-	void handleQueue();
-
-	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);
-};
-
-#endif /* CONTROLLERBASE_H_ */
+#ifndef CONTROLLERBASE_H_
+#define 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 "../datapool/HkSwitchHelper.h"
+
+
+class ControllerBase: public HasModesIF,
+		public HasHealthIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasReturnvaluesIF {
+public:
+
+	static const Mode_t MODE_NORMAL = 2;
+
+	ControllerBase(uint32_t setObjectId, uint32_t parentId,
+			size_t commandQueueDepth = 3);
+	virtual ~ControllerBase();
+
+	ReturnValue_t initialize();
+
+	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_);
+
+
+protected:
+	const uint32_t parentId;
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	MessageQueueIF* commandQueue;
+
+	ModeHelper modeHelper;
+
+	HealthHelper healthHelper;
+
+	HkSwitchHelper hkSwitcher;
+
+	/**
+	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask;
+
+	void handleQueue();
+
+	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);
+};
+
+#endif /* CONTROLLERBASE_H_ */
diff --git a/coordinates/CoordinateTransformations.cpp b/coordinates/CoordinateTransformations.cpp
index b57519a3..df9b3cac 100644
--- a/coordinates/CoordinateTransformations.cpp
+++ b/coordinates/CoordinateTransformations.cpp
@@ -1,227 +1,227 @@
-#include <framework/coordinates/CoordinateTransformations.h>
-#include <framework/globalfunctions/constants.h>
-#include <framework/globalfunctions/math/MatrixOperations.h>
-#include <framework/globalfunctions/math/VectorOperations.h>
-#include <stddef.h>
-#include <cmath>
-
-
-void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
-		double* eciPosition, timeval *timeUTC) {
-	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
-
-}
-
-void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
-		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
-	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
-}
-
-void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
-	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
-};
-
-void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
-	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
-}
-
-double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
-
-	double jD2000UTC;
-	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
-
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-	double theta = 2 * Math::PI
-			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
-
-	//Correct theta according to IAU 2000 precession-nutation model
-	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
-			+ 6.77128219501896E-006 * TTt2000 * TTt2000
-			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
-			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
-	return theta;
-}
-
-void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
-		double matrix[][3]) {
-	double theta = getEarthRotationAngle(timeUTC);
-
-	matrix[0][0] = cos(theta);
-	matrix[0][1] = sin(theta);
-	matrix[0][2] = 0;
-	matrix[1][0] = -sin(theta);
-	matrix[1][1] = cos(theta);
-	matrix[1][2] = 0;
-	matrix[2][0] = 0;
-	matrix[2][1] = 0;
-	matrix[2][2] = 1;
-}
-
-void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
-		double* eciCoordinates,
-		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
-
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	} else {
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-	double Tif[3][3];
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
-
-	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
-			3, 3, 1);
-
-
-
-
-	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
-
-		double Tdotfi[3][3];
-		double Tdotif[3][3];
-		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-				3);
-
-		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
-
-		double velocityCorrection[3];
-
-		MatrixOperations<double>::multiply(Tdotif[0],
-				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-				1);
-
-		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
-				eciCoordinates, 3);
-	}
-}
-
-double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
-	timeval timeTT;
-	Clock::convertUTCToTT(timeUTC, &timeTT);
-	double jD2000TT;
-	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
-
-	return jD2000TT / 36525.;
-}
-
-void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
-		double* ecfCoordinates,
-		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	}else{
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
-
-	if (eciPositionIfCoordinatesAreVelocity != NULL) {
-
-			double Tdotfi[3][3];
-			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-					3);
-
-			double velocityCorrection[3];
-
-			MatrixOperations<double>::multiply(Tdotfi[0],
-					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-					1);
-
-			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
-					ecfCoordinates, 3);
-		}
-};
-
-void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Precession Matrix
-
-		double zeta = 0.0111808609 * TTt2000
-				+ 1.46355554053347E-006 * TTt2000 * TTt2000
-				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
-		double theta_p = 0.0097171735 * TTt2000
-				- 2.06845757045384E-006 * TTt2000 * TTt2000
-				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
-		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
-				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
-
-		double mPrecession[3][3];
-
-		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
-		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
-		mPrecession[2][0] = sin(theta_p) * cos(zeta);
-
-		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
-		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
-		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
-
-		mPrecession[0][2] = -cos(z) * sin(theta_p);
-		mPrecession[1][2] = -sin(z) * sin(theta_p);
-		mPrecession[2][2] = cos(theta_p);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Nutation Matrix
-
-		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
-				+ 3.61428599267159E-005 * TTt2000 * TTt2000
-				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
-
-		double deltaPsi = -0.000083388 * sin(omega_moon);
-		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
-
-		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
-				- 2.86040071854626E-009 * TTt2000 * TTt2000
-				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
-
-
-		double mNutation[3][3];
-
-		mNutation[0][0] = cos(deltaPsi);
-		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
-		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
-
-		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
-		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- sin(epsilon) * cos(epsilon + deltaEpsilon);
-
-		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
-		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- cos(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Earth rotation matrix
-		//calculate theta
-
-		double mTheta[3][3];
-		double Ttemp[3][3];
-		getEarthRotationMatrix(timeUTC, mTheta);
-
-		//polar motion is neglected
-		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
-				3, 3, 3);
-
-		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
-};
+#include "../coordinates/CoordinateTransformations.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include <stddef.h>
+#include <cmath>
+
+
+void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
+		double* eciPosition, timeval *timeUTC) {
+	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
+
+}
+
+void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
+		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
+	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
+}
+
+void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
+	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
+};
+
+void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
+	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
+}
+
+double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
+
+	double jD2000UTC;
+	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
+
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+	double theta = 2 * Math::PI
+			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
+
+	//Correct theta according to IAU 2000 precession-nutation model
+	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
+			+ 6.77128219501896E-006 * TTt2000 * TTt2000
+			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
+			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
+	return theta;
+}
+
+void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
+		double matrix[][3]) {
+	double theta = getEarthRotationAngle(timeUTC);
+
+	matrix[0][0] = cos(theta);
+	matrix[0][1] = sin(theta);
+	matrix[0][2] = 0;
+	matrix[1][0] = -sin(theta);
+	matrix[1][1] = cos(theta);
+	matrix[1][2] = 0;
+	matrix[2][0] = 0;
+	matrix[2][1] = 0;
+	matrix[2][2] = 1;
+}
+
+void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
+		double* eciCoordinates,
+		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
+
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	} else {
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+	double Tif[3][3];
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
+
+	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
+			3, 3, 1);
+
+
+
+
+	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
+
+		double Tdotfi[3][3];
+		double Tdotif[3][3];
+		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+				3);
+
+		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
+
+		double velocityCorrection[3];
+
+		MatrixOperations<double>::multiply(Tdotif[0],
+				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+				1);
+
+		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
+				eciCoordinates, 3);
+	}
+}
+
+double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
+	timeval timeTT;
+	Clock::convertUTCToTT(timeUTC, &timeTT);
+	double jD2000TT;
+	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
+
+	return jD2000TT / 36525.;
+}
+
+void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
+		double* ecfCoordinates,
+		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	}else{
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
+
+	if (eciPositionIfCoordinatesAreVelocity != NULL) {
+
+			double Tdotfi[3][3];
+			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+					3);
+
+			double velocityCorrection[3];
+
+			MatrixOperations<double>::multiply(Tdotfi[0],
+					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+					1);
+
+			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
+					ecfCoordinates, 3);
+		}
+};
+
+void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Precession Matrix
+
+		double zeta = 0.0111808609 * TTt2000
+				+ 1.46355554053347E-006 * TTt2000 * TTt2000
+				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
+		double theta_p = 0.0097171735 * TTt2000
+				- 2.06845757045384E-006 * TTt2000 * TTt2000
+				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
+		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
+				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
+
+		double mPrecession[3][3];
+
+		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
+		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
+		mPrecession[2][0] = sin(theta_p) * cos(zeta);
+
+		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
+		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
+		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
+
+		mPrecession[0][2] = -cos(z) * sin(theta_p);
+		mPrecession[1][2] = -sin(z) * sin(theta_p);
+		mPrecession[2][2] = cos(theta_p);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Nutation Matrix
+
+		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
+				+ 3.61428599267159E-005 * TTt2000 * TTt2000
+				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
+
+		double deltaPsi = -0.000083388 * sin(omega_moon);
+		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
+
+		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
+				- 2.86040071854626E-009 * TTt2000 * TTt2000
+				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
+
+
+		double mNutation[3][3];
+
+		mNutation[0][0] = cos(deltaPsi);
+		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
+		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
+
+		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
+		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- sin(epsilon) * cos(epsilon + deltaEpsilon);
+
+		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
+		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- cos(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Earth rotation matrix
+		//calculate theta
+
+		double mTheta[3][3];
+		double Ttemp[3][3];
+		getEarthRotationMatrix(timeUTC, mTheta);
+
+		//polar motion is neglected
+		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
+				3, 3, 3);
+
+		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
+};
diff --git a/coordinates/CoordinateTransformations.h b/coordinates/CoordinateTransformations.h
index b072271f..0bfb203d 100644
--- a/coordinates/CoordinateTransformations.h
+++ b/coordinates/CoordinateTransformations.h
@@ -1,34 +1,34 @@
-#ifndef COORDINATETRANSFORMATIONS_H_
-#define COORDINATETRANSFORMATIONS_H_
-
-#include <framework/timemanager/Clock.h>
-#include <cstring>
-
-class CoordinateTransformations {
-public:
-	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
-
-	static void velocityEcfToEci(const double* ecfVelocity,
-			const double* ecfPosition,
-			double* eciVelocity, timeval *timeUTC = NULL);
-
-	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
-	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
-
-	static double getEarthRotationAngle(timeval timeUTC);
-
-	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
-private:
-	CoordinateTransformations();
-	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
-			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
-	static void eciToEcf(const double* eciCoordinates,
-				double* ecfCoordinates,
-				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
-
-	static double getJuleanCenturiesTT(timeval timeUTC);
-	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
-
-};
-
-#endif /* COORDINATETRANSFORMATIONS_H_ */
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class CoordinateTransformations {
+public:
+	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
+
+	static void velocityEcfToEci(const double* ecfVelocity,
+			const double* ecfPosition,
+			double* eciVelocity, timeval *timeUTC = NULL);
+
+	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
+	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
+
+	static double getEarthRotationAngle(timeval timeUTC);
+
+	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
+private:
+	CoordinateTransformations();
+	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
+			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
+	static void eciToEcf(const double* eciCoordinates,
+				double* ecfCoordinates,
+				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
+
+	static double getJuleanCenturiesTT(timeval timeUTC);
+	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
+
+};
+
+#endif /* COORDINATETRANSFORMATIONS_H_ */
diff --git a/coordinates/Jgm3Model.h b/coordinates/Jgm3Model.h
index 8f0598f8..fd74741d 100644
--- a/coordinates/Jgm3Model.h
+++ b/coordinates/Jgm3Model.h
@@ -1,180 +1,180 @@
-#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
-#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 <memory.h>
-
-
-template<uint8_t DEGREE,uint8_t ORDER>
-class Jgm3Model {
-public:
-	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
-
-	Jgm3Model() {
-		y0[0] = 0;
-		y0[1] = 0;
-		y0[2] = 0;
-		y0[3] = 0;
-		y0[4] = 0;
-		y0[5] = 0;
-
-		lastExecutionTime.tv_sec = 0;
-		lastExecutionTime.tv_usec = 0;
-	}
-	virtual ~Jgm3Model(){};
-
-	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
-
-	double y0[6]; //position and velocity at beginning of RK step in EC
-	timeval lastExecutionTime; //Time of last execution
-
-
-	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
-		//Get radius of this position
-		double r = VectorOperations<double>::norm(pos,3);
-
-
-
-		//Initialize the V and W matrix
-		double V[DEGREE+2][ORDER+2] = {{0}};
-		double W[DEGREE+2][ORDER+2] = {{0}};
-
-		for(uint8_t m=0;m<(ORDER+2);m++){
-			for(uint8_t n=m;n<(DEGREE+2);n++){
-				if((n==0) && (m==0)){
-					//Montenbruck "Satellite Orbits Eq.3.31"
-					V[0][0] = Earth::MEAN_RADIUS / r;
-					W[0][0] = 0;
-				}else{
-					if(n==m){
-						//Montenbruck "Satellite Orbits Eq.3.29"
-						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
-						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
-					}else{
-						//Montenbruck "Satellite Orbits Eq.3.30"
-						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
-						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
-						if(n!=(m+1)){
-							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
-							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
-						}//End of if(n!=(m+1))
-					}//End of if(n==m){
-				}//End of if(n==0 and m==0)
-			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
-		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
-
-
-		//overwrite accel if not properly initialized
-		accel[0] = 0;
-		accel[1] = 0;
-		accel[2] = 0;
-
-		for(uint8_t m=0;m<(ORDER+1);m++){
-			for(uint8_t n=m;n<(DEGREE+1);n++){
-				//Use table lookup to get factorial
-				double partAccel[3] = {0};
-				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
-				if(m==0){
-					//Montenbruck "Satellite Orbits Eq.3.33"
-					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
-					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
-				}else{
-					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
-					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
-					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
-				}
-
-				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
-
-
-				accel[0] += partAccel[0];
-				accel[1] += partAccel[1];
-				accel[2] += partAccel[2];
-			}//End of for(uint8_t n=0;n<DEGREE;n++)
-		}//End of uint8_t m=0;m<ORDER;m++
-	}
-
-	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
-		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
-		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
-		lastExecutionTime = timeUTC;
-	}
-
-
-	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
-
-		//RK4 Integration for this timestamp
-		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
-
-		double y0dot[6] = {0,0,0,0,0,0};
-		double yA[6] = {0,0,0,0,0,0};
-		double yAdot[6] = {0,0,0,0,0,0};
-		double yB[6] = {0,0,0,0,0,0};
-		double yBdot[6] = {0,0,0,0,0,0};
-		double yC[6] = {0,0,0,0,0,0};
-		double yCdot[6] = {0,0,0,0,0,0};
-
-		//Step One
-		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
-
-		//Step Two
-		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
-		VectorOperations<double>::add(y0,yA,yA,6);
-		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
-
-		//Step Three
-		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
-		VectorOperations<double>::add(y0,yB,yB,6);
-		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
-
-		//Step Four
-		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
-		VectorOperations<double>::add(y0,yC,yC,6);
-		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
-
-		//Calc new State
-		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
-		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
-		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
-		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
-		VectorOperations<double>::add(y0,y0dot,y0,6);
-
-		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
-		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
-
-		lastExecutionTime = timeUTC;
-
-
-	}
-
-
-	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
-		double rECF[3] = {0,0,0};
-		double rDotECF[3] = {0,0,0};
-		double accelECF[3] = {0,0,0};
-		double accelECI[3] = {0,0,0};
-
-
-		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
-		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
-		accelDegOrd(rECF,S,C,accelECF);
-		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
-		//Tests showed that a wrong velocity does make the equation worse than neglecting it
-		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
-		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
-		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
-	}
-};
-
-
-
-
-
-
-#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include <stdint.h>
+#include "../coordinates/CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
+#include <memory.h>
+
+
+template<uint8_t DEGREE,uint8_t ORDER>
+class Jgm3Model {
+public:
+	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
+
+	Jgm3Model() {
+		y0[0] = 0;
+		y0[1] = 0;
+		y0[2] = 0;
+		y0[3] = 0;
+		y0[4] = 0;
+		y0[5] = 0;
+
+		lastExecutionTime.tv_sec = 0;
+		lastExecutionTime.tv_usec = 0;
+	}
+	virtual ~Jgm3Model(){};
+
+	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
+
+	double y0[6]; //position and velocity at beginning of RK step in EC
+	timeval lastExecutionTime; //Time of last execution
+
+
+	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
+		//Get radius of this position
+		double r = VectorOperations<double>::norm(pos,3);
+
+
+
+		//Initialize the V and W matrix
+		double V[DEGREE+2][ORDER+2] = {{0}};
+		double W[DEGREE+2][ORDER+2] = {{0}};
+
+		for(uint8_t m=0;m<(ORDER+2);m++){
+			for(uint8_t n=m;n<(DEGREE+2);n++){
+				if((n==0) && (m==0)){
+					//Montenbruck "Satellite Orbits Eq.3.31"
+					V[0][0] = Earth::MEAN_RADIUS / r;
+					W[0][0] = 0;
+				}else{
+					if(n==m){
+						//Montenbruck "Satellite Orbits Eq.3.29"
+						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
+						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
+					}else{
+						//Montenbruck "Satellite Orbits Eq.3.30"
+						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
+						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
+						if(n!=(m+1)){
+							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
+							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
+						}//End of if(n!=(m+1))
+					}//End of if(n==m){
+				}//End of if(n==0 and m==0)
+			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
+		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
+
+
+		//overwrite accel if not properly initialized
+		accel[0] = 0;
+		accel[1] = 0;
+		accel[2] = 0;
+
+		for(uint8_t m=0;m<(ORDER+1);m++){
+			for(uint8_t n=m;n<(DEGREE+1);n++){
+				//Use table lookup to get factorial
+				double partAccel[3] = {0};
+				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
+				if(m==0){
+					//Montenbruck "Satellite Orbits Eq.3.33"
+					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
+					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
+				}else{
+					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
+					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
+					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
+				}
+
+				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
+
+
+				accel[0] += partAccel[0];
+				accel[1] += partAccel[1];
+				accel[2] += partAccel[2];
+			}//End of for(uint8_t n=0;n<DEGREE;n++)
+		}//End of uint8_t m=0;m<ORDER;m++
+	}
+
+	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
+		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
+		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
+		lastExecutionTime = timeUTC;
+	}
+
+
+	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
+
+		//RK4 Integration for this timestamp
+		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
+
+		double y0dot[6] = {0,0,0,0,0,0};
+		double yA[6] = {0,0,0,0,0,0};
+		double yAdot[6] = {0,0,0,0,0,0};
+		double yB[6] = {0,0,0,0,0,0};
+		double yBdot[6] = {0,0,0,0,0,0};
+		double yC[6] = {0,0,0,0,0,0};
+		double yCdot[6] = {0,0,0,0,0,0};
+
+		//Step One
+		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
+
+		//Step Two
+		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
+		VectorOperations<double>::add(y0,yA,yA,6);
+		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
+
+		//Step Three
+		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
+		VectorOperations<double>::add(y0,yB,yB,6);
+		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
+
+		//Step Four
+		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
+		VectorOperations<double>::add(y0,yC,yC,6);
+		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
+
+		//Calc new State
+		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
+		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
+		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
+		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
+		VectorOperations<double>::add(y0,y0dot,y0,6);
+
+		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
+		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
+
+		lastExecutionTime = timeUTC;
+
+
+	}
+
+
+	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
+		double rECF[3] = {0,0,0};
+		double rDotECF[3] = {0,0,0};
+		double accelECF[3] = {0,0,0};
+		double accelECI[3] = {0,0,0};
+
+
+		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
+		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
+		accelDegOrd(rECF,S,C,accelECF);
+		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
+		//Tests showed that a wrong velocity does make the equation worse than neglecting it
+		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
+		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
+		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
+	}
+};
+
+
+
+
+
+
+#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
diff --git a/coordinates/Sgp4Propagator.cpp b/coordinates/Sgp4Propagator.cpp
index 0eb20f08..84a52799 100644
--- a/coordinates/Sgp4Propagator.cpp
+++ b/coordinates/Sgp4Propagator.cpp
@@ -1,228 +1,228 @@
-#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 <cstring>
-Sgp4Propagator::Sgp4Propagator() :
-		initialized(false), epoch({0, 0}), whichconst(wgs84) {
-
-}
-
-Sgp4Propagator::~Sgp4Propagator() {
-
-}
-
-void jday(int year, int mon, int day, int hr, int minute, double sec,
-		double& jd) {
-	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
-			+ floor(275 * mon / 9.0) + day + 1721013.5
-			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
-			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
-}
-
-void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
-		double& sec) {
-	int i, inttemp, dayofyr;
-	double temp;
-	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-	dayofyr = (int) floor(days);
-	/* ----------------- find month and day of month ---------------- */
-	if ((year % 4) == 0)
-		lmonth[1] = 29;
-
-	i = 1;
-	inttemp = 0;
-	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
-		inttemp = inttemp + lmonth[i - 1];
-		i++;
-	}
-	mon = i;
-	day = dayofyr - inttemp;
-
-	/* ----------------- find hours minutes and seconds ------------- */
-	temp = (days - dayofyr) * 24.0;
-	hr = (int) floor(temp);
-	temp = (temp - hr) * 60.0;
-	minute = (int) floor(temp);
-	sec = (temp - minute) * 60.0;
-}
-
-ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
-		const uint8_t* line2) {
-
-	char longstr1[130];
-	char longstr2[130];
-
-	//need some space for decimal points
-	memcpy(longstr1, line1, 69);
-	memcpy(longstr2, line2, 69);
-
-	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
-	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
-
-	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
-	int cardnumb, numb, j;
-	long revnum = 0, elnum = 0;
-	char classification, intldesg[11];
-	int year = 0;
-	int mon, day, hr, minute, nexp, ibexp;
-
-	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
-
-	satrec.error = 0;
-
-	// set the implied decimal points since doing a formated read
-	// fixes for bad input data values (missing, ...)
-	for (j = 10; j <= 15; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '_';
-
-	if (longstr1[44] != ' ')
-		longstr1[43] = longstr1[44];
-	longstr1[44] = '.';
-	if (longstr1[7] == ' ')
-		longstr1[7] = 'U';
-	if (longstr1[9] == ' ')
-		longstr1[9] = '.';
-	for (j = 45; j <= 49; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '0';
-	if (longstr1[51] == ' ')
-		longstr1[51] = '0';
-	if (longstr1[53] != ' ')
-		longstr1[52] = longstr1[53];
-	longstr1[53] = '.';
-	longstr2[25] = '.';
-	for (j = 26; j <= 32; j++)
-		if (longstr2[j] == ' ')
-			longstr2[j] = '0';
-	if (longstr1[62] == ' ')
-		longstr1[62] = '0';
-	if (longstr1[68] == ' ')
-		longstr1[68] = '0';
-
-	sscanf(longstr1,
-			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
-			&cardnumb, &satrec.satnum, &classification, intldesg,
-			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
-			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
-
-	if (longstr2[52] == ' ') {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	} else {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	}
-
-	// ---- find no, ndot, nddot ----
-	satrec.no = satrec.no / xpdotp; //* rad/min
-	satrec.nddot = satrec.nddot * pow(10.0, nexp);
-	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
-
-	// ---- convert to sgp4 units ----
-	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
-	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
-	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
-
-	// ---- find standard orbital elements ----
-	satrec.inclo = satrec.inclo * deg2rad;
-	satrec.nodeo = satrec.nodeo * deg2rad;
-	satrec.argpo = satrec.argpo * deg2rad;
-	satrec.mo = satrec.mo * deg2rad;
-
-	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-
-	// ----------------------------------------------------------------
-	// find sgp4epoch time of element set
-	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-	// and minutes from the epoch (time)
-	// ----------------------------------------------------------------
-
-	// ---------------- temp fix for years from 1957-2056 -------------------
-	// --------- correct fix will occur when year is 4-digit in tle ---------
-	if (satrec.epochyr < 57) {
-		year = satrec.epochyr + 2000;
-	} else {
-		year = satrec.epochyr + 1900;
-	}
-
-	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
-	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
-
-	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
-			+ 946684800;
-
-	epoch.tv_sec = unixSeconds;
-	double subseconds = unixSeconds - epoch.tv_sec;
-	epoch.tv_usec = subseconds * 1000000;
-
-	// ---------------- initialize the orbit at sgp4epoch -------------------
-	uint8_t result = sgp4init(whichconst, satrec.satnum,
-			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
-			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
-			satrec);
-
-	if (result != 00) {
-		return MAKE_RETURN_CODE(result);
-	} else {
-		initialized = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-}
-
-ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
-		timeval time, uint8_t gpsUtcOffset) {
-
-	if (!initialized) {
-		return TLE_NOT_INITIALIZED;
-	}
-
-	//Time since epoch in minutes
-	timeval timeSinceEpoch = time - epoch;
-	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
-			+ timeSinceEpoch.tv_usec / 60000000.;
-
-	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
-
-	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
-		return TLE_TOO_OLD;
-	}
-
-	double positionTEME[3];
-	double velocityTEME[3];
-
-	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
-			velocityTEME);
-
-	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
-	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
-
-	//Transform to ECF
-	double earthRotationMatrix[3][3];
-	CoordinateTransformations::getEarthRotationMatrix(time,
-			earthRotationMatrix);
-
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
-			position, 3, 3, 1);
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
-			velocity, 3, 3, 1);
-
-	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
-	double velocityCorrection[3];
-	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
-	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
-
-	if (result != 0) {
-		return MAKE_RETURN_CODE(result || 0xB0);
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
+#include "../coordinates/CoordinateTransformations.h"
+#include "../coordinates/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) {
+
+}
+
+Sgp4Propagator::~Sgp4Propagator() {
+
+}
+
+void jday(int year, int mon, int day, int hr, int minute, double sec,
+		double& jd) {
+	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
+			+ floor(275 * mon / 9.0) + day + 1721013.5
+			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
+			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
+}
+
+void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
+		double& sec) {
+	int i, inttemp, dayofyr;
+	double temp;
+	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+	dayofyr = (int) floor(days);
+	/* ----------------- find month and day of month ---------------- */
+	if ((year % 4) == 0)
+		lmonth[1] = 29;
+
+	i = 1;
+	inttemp = 0;
+	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
+		inttemp = inttemp + lmonth[i - 1];
+		i++;
+	}
+	mon = i;
+	day = dayofyr - inttemp;
+
+	/* ----------------- find hours minutes and seconds ------------- */
+	temp = (days - dayofyr) * 24.0;
+	hr = (int) floor(temp);
+	temp = (temp - hr) * 60.0;
+	minute = (int) floor(temp);
+	sec = (temp - minute) * 60.0;
+}
+
+ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
+		const uint8_t* line2) {
+
+	char longstr1[130];
+	char longstr2[130];
+
+	//need some space for decimal points
+	memcpy(longstr1, line1, 69);
+	memcpy(longstr2, line2, 69);
+
+	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
+	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
+
+	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
+	int cardnumb, numb, j;
+	long revnum = 0, elnum = 0;
+	char classification, intldesg[11];
+	int year = 0;
+	int mon, day, hr, minute, nexp, ibexp;
+
+	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
+
+	satrec.error = 0;
+
+	// set the implied decimal points since doing a formated read
+	// fixes for bad input data values (missing, ...)
+	for (j = 10; j <= 15; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '_';
+
+	if (longstr1[44] != ' ')
+		longstr1[43] = longstr1[44];
+	longstr1[44] = '.';
+	if (longstr1[7] == ' ')
+		longstr1[7] = 'U';
+	if (longstr1[9] == ' ')
+		longstr1[9] = '.';
+	for (j = 45; j <= 49; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '0';
+	if (longstr1[51] == ' ')
+		longstr1[51] = '0';
+	if (longstr1[53] != ' ')
+		longstr1[52] = longstr1[53];
+	longstr1[53] = '.';
+	longstr2[25] = '.';
+	for (j = 26; j <= 32; j++)
+		if (longstr2[j] == ' ')
+			longstr2[j] = '0';
+	if (longstr1[62] == ' ')
+		longstr1[62] = '0';
+	if (longstr1[68] == ' ')
+		longstr1[68] = '0';
+
+	sscanf(longstr1,
+			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
+			&cardnumb, &satrec.satnum, &classification, intldesg,
+			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
+			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
+
+	if (longstr2[52] == ' ') {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	} else {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	}
+
+	// ---- find no, ndot, nddot ----
+	satrec.no = satrec.no / xpdotp; //* rad/min
+	satrec.nddot = satrec.nddot * pow(10.0, nexp);
+	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
+
+	// ---- convert to sgp4 units ----
+	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
+	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
+	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
+
+	// ---- find standard orbital elements ----
+	satrec.inclo = satrec.inclo * deg2rad;
+	satrec.nodeo = satrec.nodeo * deg2rad;
+	satrec.argpo = satrec.argpo * deg2rad;
+	satrec.mo = satrec.mo * deg2rad;
+
+	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
+	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
+
+	// ----------------------------------------------------------------
+	// find sgp4epoch time of element set
+	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
+	// and minutes from the epoch (time)
+	// ----------------------------------------------------------------
+
+	// ---------------- temp fix for years from 1957-2056 -------------------
+	// --------- correct fix will occur when year is 4-digit in tle ---------
+	if (satrec.epochyr < 57) {
+		year = satrec.epochyr + 2000;
+	} else {
+		year = satrec.epochyr + 1900;
+	}
+
+	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
+	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
+
+	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
+			+ 946684800;
+
+	epoch.tv_sec = unixSeconds;
+	double subseconds = unixSeconds - epoch.tv_sec;
+	epoch.tv_usec = subseconds * 1000000;
+
+	// ---------------- initialize the orbit at sgp4epoch -------------------
+	uint8_t result = sgp4init(whichconst, satrec.satnum,
+			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
+			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
+			satrec);
+
+	if (result != 00) {
+		return MAKE_RETURN_CODE(result);
+	} else {
+		initialized = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+}
+
+ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
+		timeval time, uint8_t gpsUtcOffset) {
+
+	if (!initialized) {
+		return TLE_NOT_INITIALIZED;
+	}
+
+	//Time since epoch in minutes
+	timeval timeSinceEpoch = time - epoch;
+	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
+			+ timeSinceEpoch.tv_usec / 60000000.;
+
+	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
+
+	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
+		return TLE_TOO_OLD;
+	}
+
+	double positionTEME[3];
+	double velocityTEME[3];
+
+	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
+			velocityTEME);
+
+	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
+	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
+
+	//Transform to ECF
+	double earthRotationMatrix[3][3];
+	CoordinateTransformations::getEarthRotationMatrix(time,
+			earthRotationMatrix);
+
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
+			position, 3, 3, 1);
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
+			velocity, 3, 3, 1);
+
+	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
+	double velocityCorrection[3];
+	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
+	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
+
+	if (result != 0) {
+		return MAKE_RETURN_CODE(result || 0xB0);
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index 95739762..f041ec07 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,44 +1,44 @@
-#ifndef SGP4PROPAGATOR_H_
-#define SGP4PROPAGATOR_H_
-
-#include <sys/time.h>
-#include "../contrib/sgp4/sgp4unit.h"
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class Sgp4Propagator {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
-	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
-
-
-
-	Sgp4Propagator();
-	virtual ~Sgp4Propagator();
-
-	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
-
-	/**
-	 *
-	 * @param[out] position in ECF
-	 * @param[out] velocity in ECF
-	 * @param time to which to propagate
-	 * @return
-	 */
-	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
-
-private:
-	bool initialized;
-	timeval epoch;
-	elsetrec satrec;
-	gravconsttype whichconst;
-
-};
-
-#endif /* SGP4PROPAGATOR_H_ */
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include <sys/time.h>
+#include "../contrib/sgp4/sgp4unit.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class Sgp4Propagator {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
+	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
+
+
+
+	Sgp4Propagator();
+	virtual ~Sgp4Propagator();
+
+	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
+
+	/**
+	 *
+	 * @param[out] position in ECF
+	 * @param[out] velocity in ECF
+	 * @param time to which to propagate
+	 * @return
+	 */
+	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
+
+private:
+	bool initialized;
+	timeval epoch;
+	elsetrec satrec;
+	gravconsttype whichconst;
+
+};
+
+#endif /* SGP4PROPAGATOR_H_ */
diff --git a/datalinklayer/BCFrame.h b/datalinklayer/BCFrame.h
index bcdf5300..785cbb75 100644
--- a/datalinklayer/BCFrame.h
+++ b/datalinklayer/BCFrame.h
@@ -1,62 +1,62 @@
-/**
- * @file	BCFrame.h
- * @brief	This file defines the BCFrame class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef BCFRAME_H_
-#define BCFRAME_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-
-/**
- * Small helper class to identify a BcFrame.
- * @ingroup ccsds_handling
- */
-class BcFrame: public CCSDSReturnValuesIF {
-private:
-	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
-
-public:
-	uint8_t byte1;	//!< First content byte
-	uint8_t byte2;	//!< Second content byte
-	uint8_t vR;	//!< vR byte
-	/**
-	 * Simple default constructor.
-	 */
-	BcFrame() :
-			byte1(0), byte2(0), vR(0) {
-	}
-	/**
-	 * Main and only useful method of the class.
-	 * With the buffer and size information passed, the class passes the content
-	 * and checks if it is one of the two valid BC Command Frames.
-	 * @param inBuffer	Content of the frame to check,
-	 * @param inSize	Size of the data to check.
-	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
-	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
-	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
-	 */
-	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
-		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
-		if (inSize == 1) {
-			byte1 = inBuffer[0];
-			if (byte1 == UNLOCK_COMMAND) {
-				returnValue = BC_IS_UNLOCK_COMMAND;
-			}
-		} else if (inSize == 3) {
-			byte1 = inBuffer[0];
-			byte2 = inBuffer[1];
-			vR = inBuffer[2];
-			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
-				returnValue = BC_IS_SET_VR_COMMAND;
-			}
-		}
-		return returnValue;
-	}
-};
-
-#endif /* BCFRAME_H_ */
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+
+/**
+ * Small helper class to identify a BcFrame.
+ * @ingroup ccsds_handling
+ */
+class BcFrame: public CCSDSReturnValuesIF {
+private:
+	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
+
+public:
+	uint8_t byte1;	//!< First content byte
+	uint8_t byte2;	//!< Second content byte
+	uint8_t vR;	//!< vR byte
+	/**
+	 * Simple default constructor.
+	 */
+	BcFrame() :
+			byte1(0), byte2(0), vR(0) {
+	}
+	/**
+	 * Main and only useful method of the class.
+	 * With the buffer and size information passed, the class passes the content
+	 * and checks if it is one of the two valid BC Command Frames.
+	 * @param inBuffer	Content of the frame to check,
+	 * @param inSize	Size of the data to check.
+	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
+	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
+	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
+	 */
+	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
+		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
+		if (inSize == 1) {
+			byte1 = inBuffer[0];
+			if (byte1 == UNLOCK_COMMAND) {
+				returnValue = BC_IS_UNLOCK_COMMAND;
+			}
+		} else if (inSize == 3) {
+			byte1 = inBuffer[0];
+			byte2 = inBuffer[1];
+			vR = inBuffer[2];
+			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
+				returnValue = BC_IS_SET_VR_COMMAND;
+			}
+		}
+		return returnValue;
+	}
+};
+
+#endif /* BCFRAME_H_ */
diff --git a/datalinklayer/CCSDSReturnValuesIF.h b/datalinklayer/CCSDSReturnValuesIF.h
index 4d4f4bde..054be9e7 100644
--- a/datalinklayer/CCSDSReturnValuesIF.h
+++ b/datalinklayer/CCSDSReturnValuesIF.h
@@ -1,56 +1,56 @@
-/**
- * @file	CCSDSReturnValuesIF.h
- * @brief	This file defines the CCSDSReturnValuesIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef CCSDSRETURNVALUESIF_H_
-#define CCSDSRETURNVALUESIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- * This is a helper class to collect special return values that come up during CCSDS Handling.
- * @ingroup ccsds_handling
- */
-class CCSDSReturnValuesIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
-
-	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
-	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
-
-	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
-	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
-	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
-	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
-	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
-
-	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
-	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
-	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
-	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
-	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
-	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
-	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
-	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
-	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
-	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
-	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
-
-	virtual ~CCSDSReturnValuesIF() {
-	} //!< Empty virtual destructor
-};
-
-#endif /* CCSDSRETURNVALUESIF_H_ */
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * This is a helper class to collect special return values that come up during CCSDS Handling.
+ * @ingroup ccsds_handling
+ */
+class CCSDSReturnValuesIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
+
+	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
+	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
+
+	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
+	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
+	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
+	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
+	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
+
+	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
+	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
+	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
+	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
+	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
+	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
+	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
+	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
+	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
+	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
+	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
+
+	virtual ~CCSDSReturnValuesIF() {
+	} //!< Empty virtual destructor
+};
+
+#endif /* CCSDSRETURNVALUESIF_H_ */
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index ee497e20..53424e8a 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -1,63 +1,63 @@
-/**
- * @file	Clcw.cpp
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/Clcw.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Clcw::Clcw() {
-	content.raw = 0;
-	content.status = STATUS_FIELD_DEFAULT;
-}
-
-Clcw::~Clcw() {
-}
-
-void Clcw::setVirtualChannel(uint8_t setChannel) {
-	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
-}
-
-void Clcw::setLockoutFlag(bool lockout) {
-	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
-}
-
-void Clcw::setWaitFlag(bool waitFlag) {
-	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
-}
-
-void Clcw::setRetransmitFlag(bool retransmitFlag) {
-	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
-}
-
-void Clcw::setFarmBCount(uint8_t count) {
-	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
-}
-
-void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
-	content.vRValue = vR;
-}
-
-uint32_t Clcw::getAsWhole() {
-	return content.raw;
-}
-
-void Clcw::setRFAvailable(bool rfAvailable) {
-	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
-}
-
-void Clcw::setBitLock(bool bitLock) {
-	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
-}
-
-void Clcw::print() {
-	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
-}
-
-void Clcw::setWhole(uint32_t rawClcw) {
-	content.raw = rawClcw;
-}
+/**
+ * @file	Clcw.cpp
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/Clcw.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Clcw::Clcw() {
+	content.raw = 0;
+	content.status = STATUS_FIELD_DEFAULT;
+}
+
+Clcw::~Clcw() {
+}
+
+void Clcw::setVirtualChannel(uint8_t setChannel) {
+	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
+}
+
+void Clcw::setLockoutFlag(bool lockout) {
+	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
+}
+
+void Clcw::setWaitFlag(bool waitFlag) {
+	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
+}
+
+void Clcw::setRetransmitFlag(bool retransmitFlag) {
+	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
+}
+
+void Clcw::setFarmBCount(uint8_t count) {
+	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
+}
+
+void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
+	content.vRValue = vR;
+}
+
+uint32_t Clcw::getAsWhole() {
+	return content.raw;
+}
+
+void Clcw::setRFAvailable(bool rfAvailable) {
+	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
+}
+
+void Clcw::setBitLock(bool bitLock) {
+	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
+}
+
+void Clcw::print() {
+	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+}
+
+void Clcw::setWhole(uint32_t rawClcw) {
+	content.raw = rawClcw;
+}
diff --git a/datalinklayer/Clcw.h b/datalinklayer/Clcw.h
index f19f37b6..72ccd77a 100644
--- a/datalinklayer/Clcw.h
+++ b/datalinklayer/Clcw.h
@@ -1,66 +1,66 @@
-/**
- * @file	Clcw.h
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-#ifndef CLCW_H_
-#define CLCW_H_
-
-#include <framework/datalinklayer/ClcwIF.h>
-/**
- * Small helper method to handle the Clcw values.
- * It has a content struct that manages the register and can be set externally.
- * @ingroup ccsds_handling
- */
-class Clcw : public ClcwIF {
-private:
-	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
-	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
-	/**
-	 * This is the data structure of the CLCW register.
-	 */
-	union clcwContent {
-		uint32_t raw;
-		struct {
-			uint8_t status;
-			uint8_t virtualChannelIdSpare;
-			uint8_t flags;
-			uint8_t vRValue;
-		};
-	};
-	clcwContent content;	//!< Represents the content of the register.
-public:
-	/**
-	 * The constructor sets everything to default values.
-	 */
-	Clcw();
-	/**
-	 * Nothing happens in the destructor.
-	 */
-	~Clcw();
-	void setVirtualChannel( uint8_t setChannel );
-	void setLockoutFlag( bool lockout );
-	void setWaitFlag( bool waitFlag );
-	void setRetransmitFlag( bool retransmitFlag );
-	void setFarmBCount( uint8_t count );
-	void setReceiverFrameSequenceNumber( uint8_t vR );
-	void setRFAvailable( bool rfAvailable );
-	void setBitLock( bool bitLock );
-	uint32_t getAsWhole();
-	void setWhole( uint32_t rawClcw );
-	void print();
-};
-
-#endif /* CLCW_H_ */
+/**
+ * @file	Clcw.h
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+#ifndef CLCW_H_
+#define CLCW_H_
+
+#include "../datalinklayer/ClcwIF.h"
+/**
+ * Small helper method to handle the Clcw values.
+ * It has a content struct that manages the register and can be set externally.
+ * @ingroup ccsds_handling
+ */
+class Clcw : public ClcwIF {
+private:
+	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
+	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
+	/**
+	 * This is the data structure of the CLCW register.
+	 */
+	union clcwContent {
+		uint32_t raw;
+		struct {
+			uint8_t status;
+			uint8_t virtualChannelIdSpare;
+			uint8_t flags;
+			uint8_t vRValue;
+		};
+	};
+	clcwContent content;	//!< Represents the content of the register.
+public:
+	/**
+	 * The constructor sets everything to default values.
+	 */
+	Clcw();
+	/**
+	 * Nothing happens in the destructor.
+	 */
+	~Clcw();
+	void setVirtualChannel( uint8_t setChannel );
+	void setLockoutFlag( bool lockout );
+	void setWaitFlag( bool waitFlag );
+	void setRetransmitFlag( bool retransmitFlag );
+	void setFarmBCount( uint8_t count );
+	void setReceiverFrameSequenceNumber( uint8_t vR );
+	void setRFAvailable( bool rfAvailable );
+	void setBitLock( bool bitLock );
+	uint32_t getAsWhole();
+	void setWhole( uint32_t rawClcw );
+	void print();
+};
+
+#endif /* CLCW_H_ */
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 4ca7f270..83fe1e61 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -1,139 +1,139 @@
-#include <framework/datalinklayer/DataLinkLayer.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
-		uint8_t set_start_sequence_length, uint16_t set_scid) :
-		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
-				NULL), startSequenceLength(set_start_sequence_length) {
-	//Nothing to do except from setting the values above.
-}
-
-DataLinkLayer::~DataLinkLayer() {
-
-}
-
-ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
-	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
-		return SHORTER_THAN_HEADER;
-	}
-	//Removing start sequence.
-	//SHOULDDO: Not implemented here.
-	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
-		frameBuffer++;
-	}
-	TcTransferFrame frame_candidate(frameBuffer);
-	this->currentFrame = frame_candidate; //should work with shallow copy.
-
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameValidationCheck() {
-	//Check TF_version number
-	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
-		return WRONG_TF_VERSION;
-	}
-	//Check SpaceCraft ID
-	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
-		return WRONG_SPACECRAFT_ID;
-	}
-	//Check other header limitations:
-	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//- Spares are zero
-	if (!this->currentFrame.spareIsZero()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//Compare detected frame length with the one in the header
-	uint16_t length = currentFrame.getFullSize();
-	if (length > receivedDataLength) {
-		//Frame is too long or just right
-//		error << "frameValidationCheck: Too short.";
-//		currentFrame.print();
-		return TOO_SHORT;
-	}
-	if (USE_CRC) {
-		return this->frameCheckCRC();
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameCheckCRC() {
-	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
-			this->currentFrame.getFullSize());
-	if (checkValue == 0) {
-		return RETURN_OK;
-	} else {
-		return CRC_FAILED;
-	}
-
-}
-
-ReturnValue_t DataLinkLayer::allFramesReception() {
-	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
-	if (status != RETURN_OK) {
-		return status;
-	}
-	return this->frameValidationCheck();
-}
-
-ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
-	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
-	return virtualChannelDemultiplexing();
-}
-
-ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
-	uint8_t vcId = currentFrame.getVirtualChannelId();
-	virtualChannelIterator iter = virtualChannels.find(vcId);
-	if (iter == virtualChannels.end()) {
-		//Do not report because passive board will get this error all the time.
-		return RETURN_OK;
-	} else {
-		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
-	}
-}
-
-ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
-	receivedDataLength = length;
-	ReturnValue_t status = allFramesReception();
-	if (status != RETURN_OK) {
-		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
-		         "Error code: " << std::hex << status << std::dec << std::endl;
-//		currentFrame.print();
-		return status;
-	} else {
-		return masterChannelDemultiplexing();
-	}
-}
-
-ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
-		VirtualChannelReceptionIF* object) {
-	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
-			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DataLinkLayer::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
-	if ( virtualChannels.begin() != virtualChannels.end() ) {
-		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
-	} else {
-		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
-		return RETURN_FAILED;
-	}
-
-	for (virtualChannelIterator iterator = virtualChannels.begin();
-			iterator != virtualChannels.end(); iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-
-}
+#include "../datalinklayer/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) :
+		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
+				NULL), startSequenceLength(set_start_sequence_length) {
+	//Nothing to do except from setting the values above.
+}
+
+DataLinkLayer::~DataLinkLayer() {
+
+}
+
+ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
+	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
+		return SHORTER_THAN_HEADER;
+	}
+	//Removing start sequence.
+	//SHOULDDO: Not implemented here.
+	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
+		frameBuffer++;
+	}
+	TcTransferFrame frame_candidate(frameBuffer);
+	this->currentFrame = frame_candidate; //should work with shallow copy.
+
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameValidationCheck() {
+	//Check TF_version number
+	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
+		return WRONG_TF_VERSION;
+	}
+	//Check SpaceCraft ID
+	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
+		return WRONG_SPACECRAFT_ID;
+	}
+	//Check other header limitations:
+	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//- Spares are zero
+	if (!this->currentFrame.spareIsZero()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//Compare detected frame length with the one in the header
+	uint16_t length = currentFrame.getFullSize();
+	if (length > receivedDataLength) {
+		//Frame is too long or just right
+//		error << "frameValidationCheck: Too short.";
+//		currentFrame.print();
+		return TOO_SHORT;
+	}
+	if (USE_CRC) {
+		return this->frameCheckCRC();
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameCheckCRC() {
+	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
+			this->currentFrame.getFullSize());
+	if (checkValue == 0) {
+		return RETURN_OK;
+	} else {
+		return CRC_FAILED;
+	}
+
+}
+
+ReturnValue_t DataLinkLayer::allFramesReception() {
+	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
+	if (status != RETURN_OK) {
+		return status;
+	}
+	return this->frameValidationCheck();
+}
+
+ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
+	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
+	return virtualChannelDemultiplexing();
+}
+
+ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
+	uint8_t vcId = currentFrame.getVirtualChannelId();
+	virtualChannelIterator iter = virtualChannels.find(vcId);
+	if (iter == virtualChannels.end()) {
+		//Do not report because passive board will get this error all the time.
+		return RETURN_OK;
+	} else {
+		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
+	}
+}
+
+ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
+	receivedDataLength = length;
+	ReturnValue_t status = allFramesReception();
+	if (status != RETURN_OK) {
+		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
+		         "Error code: " << std::hex << status << std::dec << std::endl;
+//		currentFrame.print();
+		return status;
+	} else {
+		return masterChannelDemultiplexing();
+	}
+}
+
+ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
+		VirtualChannelReceptionIF* object) {
+	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
+			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DataLinkLayer::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
+	if ( virtualChannels.begin() != virtualChannels.end() ) {
+		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
+	} else {
+		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+		return RETURN_FAILED;
+	}
+
+	for (virtualChannelIterator iterator = virtualChannels.begin();
+			iterator != virtualChannels.end(); iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+
+}
diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 8a3bb8e5..cf5cf42e 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -1,112 +1,112 @@
-#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 <map>
-
-
-class VirtualChannelReception;
-/**
- * A complete representation of the CCSDS Data Link Layer.
- * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
- * document. It is configured to handle a VC Demultiplexing function. All reception
- * steps are performed.
- */
-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
-	/**
-	 * The Constructor sets the passed parameters and nothing else.
-	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
-	 * @param setClcw	The CLCW class to work on when returning CLCW information.
-	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
-	 * @param set_scid	The SCID to operate on.
-	 */
-	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
-	/**
-	 * Empty virtual destructor.
-	 */
-	~DataLinkLayer();
-	/**
-	 * This method tries to process a frame that is placed in #frameBuffer.
-	 * The procedures described in the Standard are performed.
-	 * @param length	Length of the incoming frame candidate.
-	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
-	 */
-	ReturnValue_t processFrame( uint16_t length );
-	/**
-	 * Configuration method to add a new TC Virtual Channel.
-	 * Shall only be called during initialization. As soon as the method was called, the layer can
-	 * handle Frames directed to this VC.
-	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
-	 * @param object	Reference to the object that handles the Frame.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
-	/**
-	 * The initialization method calls the @c initialize routine of all virtual channels.
-	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
-	 */
-	ReturnValue_t initialize();
-private:
-	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
-	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
-	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
-	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
-	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
-	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
-	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
-	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
-	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
-	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
-	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
-	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
-	/**
-	 * Method that performs all possible frame validity checks (as specified).
-	 * @return	Various error codes or @c RETURN_OK on success.
-	 */
-	ReturnValue_t frameValidationCheck();
-	/**
-	 * First method to call.
-	 * Removes start sequence bytes and checks if the complete frame was received.
-	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
-	 * @return @c RETURN_OK or @c TOO_SHORT.
-	 */
-	ReturnValue_t frameDelimitingAndFillRemoval();
-	/**
-	 * Small helper method to check the CRC of the Frame.
-	 * @return @c RETURN_OK or @c CRC_FAILED.
-	 */
-	ReturnValue_t frameCheckCRC();
-	/**
-	 * Method that groups the reception process of all Frames.
-	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
-	 * @return The return codes of the sub calls.
-	 */
-	ReturnValue_t allFramesReception();
-	/**
-	 * Dummy method for master channel demultiplexing.
-	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
-	 * @return	The return codes of #virtualChannelDemultiplexing.
-	 */
-	ReturnValue_t masterChannelDemultiplexing();
-	/**
-	 * Method to demultiplex the Frames to Virtual Channels (VC's).
-	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
-	 * #frameAcceptanceAndReportingMechanism method, if found.
-	 * @return The higher method codes or @c VC_NOT_FOUND.
-	 */
-	ReturnValue_t virtualChannelDemultiplexing();
-};
-
-#endif /* DATALINKLAYER_H_ */
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
+#include <map>
+
+
+class VirtualChannelReception;
+/**
+ * A complete representation of the CCSDS Data Link Layer.
+ * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
+ * document. It is configured to handle a VC Demultiplexing function. All reception
+ * steps are performed.
+ */
+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
+	/**
+	 * The Constructor sets the passed parameters and nothing else.
+	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
+	 * @param setClcw	The CLCW class to work on when returning CLCW information.
+	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
+	 * @param set_scid	The SCID to operate on.
+	 */
+	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
+	/**
+	 * Empty virtual destructor.
+	 */
+	~DataLinkLayer();
+	/**
+	 * This method tries to process a frame that is placed in #frameBuffer.
+	 * The procedures described in the Standard are performed.
+	 * @param length	Length of the incoming frame candidate.
+	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
+	 */
+	ReturnValue_t processFrame( uint16_t length );
+	/**
+	 * Configuration method to add a new TC Virtual Channel.
+	 * Shall only be called during initialization. As soon as the method was called, the layer can
+	 * handle Frames directed to this VC.
+	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
+	 * @param object	Reference to the object that handles the Frame.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
+	/**
+	 * The initialization method calls the @c initialize routine of all virtual channels.
+	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
+	 */
+	ReturnValue_t initialize();
+private:
+	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
+	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
+	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
+	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
+	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
+	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
+	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
+	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
+	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
+	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
+	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
+	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
+	/**
+	 * Method that performs all possible frame validity checks (as specified).
+	 * @return	Various error codes or @c RETURN_OK on success.
+	 */
+	ReturnValue_t frameValidationCheck();
+	/**
+	 * First method to call.
+	 * Removes start sequence bytes and checks if the complete frame was received.
+	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
+	 * @return @c RETURN_OK or @c TOO_SHORT.
+	 */
+	ReturnValue_t frameDelimitingAndFillRemoval();
+	/**
+	 * Small helper method to check the CRC of the Frame.
+	 * @return @c RETURN_OK or @c CRC_FAILED.
+	 */
+	ReturnValue_t frameCheckCRC();
+	/**
+	 * Method that groups the reception process of all Frames.
+	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
+	 * @return The return codes of the sub calls.
+	 */
+	ReturnValue_t allFramesReception();
+	/**
+	 * Dummy method for master channel demultiplexing.
+	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
+	 * @return	The return codes of #virtualChannelDemultiplexing.
+	 */
+	ReturnValue_t masterChannelDemultiplexing();
+	/**
+	 * Method to demultiplex the Frames to Virtual Channels (VC's).
+	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
+	 * #frameAcceptanceAndReportingMechanism method, if found.
+	 * @return The higher method codes or @c VC_NOT_FOUND.
+	 */
+	ReturnValue_t virtualChannelDemultiplexing();
+};
+
+#endif /* DATALINKLAYER_H_ */
diff --git a/datalinklayer/Farm1StateIF.h b/datalinklayer/Farm1StateIF.h
index 25836e6a..ef02d891 100644
--- a/datalinklayer/Farm1StateIF.h
+++ b/datalinklayer/Farm1StateIF.h
@@ -1,54 +1,54 @@
-/**
- * @file	Farm1StateIF.h
- * @brief	This file defines the Farm1StateIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEIF_H_
-#define FARM1STATEIF_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-class VirtualChannelReception;
-class TcTransferFrame;
-class ClcwIF;
-
-/**
- * This is the interface for states of the FARM-1 state machine.
- * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
- * of the state pattern.
- */
-class Farm1StateIF : public CCSDSReturnValuesIF {
-public:
-	/**
-	 * A method that shall handle an incoming frame as AD Frame.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~Farm1StateIF() {
-
-	}
-};
-
-#endif /* FARM1STATEIF_H_ */
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+class VirtualChannelReception;
+class TcTransferFrame;
+class ClcwIF;
+
+/**
+ * This is the interface for states of the FARM-1 state machine.
+ * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
+ * of the state pattern.
+ */
+class Farm1StateIF : public CCSDSReturnValuesIF {
+public:
+	/**
+	 * A method that shall handle an incoming frame as AD Frame.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~Farm1StateIF() {
+
+	}
+};
+
+#endif /* FARM1STATEIF_H_ */
diff --git a/datalinklayer/Farm1StateLockout.cpp b/datalinklayer/Farm1StateLockout.cpp
index 45ae47f9..f8dca9fd 100644
--- a/datalinklayer/Farm1StateLockout.cpp
+++ b/datalinklayer/Farm1StateLockout.cpp
@@ -1,35 +1,35 @@
-/**
- * @file	Farm1StateLockout.cpp
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateLockout.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	return FARM_IN_LOCKOUT;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setLockoutFlag( false );
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
-		uint8_t vr) {
-	myVC->farmBCounter++;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateLockout.cpp
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateLockout.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	return FARM_IN_LOCKOUT;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setLockoutFlag( false );
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
+		uint8_t vr) {
+	myVC->farmBCounter++;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateLockout.h b/datalinklayer/Farm1StateLockout.h
index aac8ed74..9e3713cc 100644
--- a/datalinklayer/Farm1StateLockout.h
+++ b/datalinklayer/Farm1StateLockout.h
@@ -1,59 +1,59 @@
-/**
- * @file	Farm1StateLockout.h
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATELOCKOUT_H_
-#define FARM1STATELOCKOUT_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Lockout" State.
- * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
- * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
- * command is required.
- */
-class Farm1StateLockout : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateLockout( VirtualChannelReception* setMyVC );
-	/**
-	 * All AD Frames are rejected with FARM_IN_LOCKOUT
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return FARM_IN_LOCKOUT
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATELOCKOUT_H_ */
+/**
+ * @file	Farm1StateLockout.h
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Lockout" State.
+ * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
+ * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
+ * command is required.
+ */
+class Farm1StateLockout : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateLockout( VirtualChannelReception* setMyVC );
+	/**
+	 * All AD Frames are rejected with FARM_IN_LOCKOUT
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return FARM_IN_LOCKOUT
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATELOCKOUT_H_ */
diff --git a/datalinklayer/Farm1StateOpen.cpp b/datalinklayer/Farm1StateOpen.cpp
index b06cff48..b7837013 100644
--- a/datalinklayer/Farm1StateOpen.cpp
+++ b/datalinklayer/Farm1StateOpen.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	Farm1StateOpen.cpp
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateOpen.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-
-Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if (diff == 0 ) {
-		myVC->vR++;
-		clcw->setRetransmitFlag(false);
-		return RETURN_OK;
-	} else if (diff < myVC->positiveWindow && diff > 0 ) {
-		clcw->setRetransmitFlag(true);
-		return NS_POSITIVE_W;
-	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
-		return NS_NEGATIVE_W;
-	} else {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-		return NS_LOCKOUT;
-	}
-}
-
-ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateOpen.cpp
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateOpen.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+
+Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if (diff == 0 ) {
+		myVC->vR++;
+		clcw->setRetransmitFlag(false);
+		return RETURN_OK;
+	} else if (diff < myVC->positiveWindow && diff > 0 ) {
+		clcw->setRetransmitFlag(true);
+		return NS_POSITIVE_W;
+	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
+		return NS_NEGATIVE_W;
+	} else {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+		return NS_LOCKOUT;
+	}
+}
+
+ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateOpen.h b/datalinklayer/Farm1StateOpen.h
index 09caacbb..ebc3b333 100644
--- a/datalinklayer/Farm1StateOpen.h
+++ b/datalinklayer/Farm1StateOpen.h
@@ -1,62 +1,62 @@
-/**
- * @file	Farm1StateOpen.h
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEOPEN_H_
-#define FARM1STATEOPEN_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Open" State.
- * The Open state is the state of normal operation. It handles all types of frames,
- * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
- * State reacts as specified.
- */
-class Farm1StateOpen : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateOpen( VirtualChannelReception* setMyVC );
-	/**
-	 * Method to check the validity of AD Frames.
-	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
-	 * change to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
-	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEOPEN_H_ */
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Open" State.
+ * The Open state is the state of normal operation. It handles all types of frames,
+ * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
+ * State reacts as specified.
+ */
+class Farm1StateOpen : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateOpen( VirtualChannelReception* setMyVC );
+	/**
+	 * Method to check the validity of AD Frames.
+	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
+	 * change to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
+	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEOPEN_H_ */
diff --git a/datalinklayer/Farm1StateWait.cpp b/datalinklayer/Farm1StateWait.cpp
index 1c72e68f..c3cc85de 100644
--- a/datalinklayer/Farm1StateWait.cpp
+++ b/datalinklayer/Farm1StateWait.cpp
@@ -1,43 +1,43 @@
-/**
- * @file	Farm1StateWait.cpp
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/Farm1StateWait.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-
-Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-	}
-	return FARM_IN_WAIT;
-}
-
-ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
-	myVC->farmBCounter++;
-	clcw->setWaitFlag( false );
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateWait.cpp
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/Farm1StateWait.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+
+Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+	}
+	return FARM_IN_WAIT;
+}
+
+ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
+	myVC->farmBCounter++;
+	clcw->setWaitFlag( false );
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateWait.h b/datalinklayer/Farm1StateWait.h
index f1201791..aa456664 100644
--- a/datalinklayer/Farm1StateWait.h
+++ b/datalinklayer/Farm1StateWait.h
@@ -1,58 +1,58 @@
-/**
- * @file	Farm1StateWait.h
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEWAIT_H_
-#define FARM1STATEWAIT_H_
-
-#include <framework/datalinklayer/Farm1StateIF.h>
-
-/**
- * This class represents the FARM-1 "Wait" State.
- * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
- * for a certain period. Currently, it is not in use.
- */
-class Farm1StateWait : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateWait( VirtualChannelReception* setMyVC );
-	/**
-	 * AD Frames are always discarded.
-	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	Always returns FARM_IN_WAIT.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEWAIT_H_ */
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "../datalinklayer/Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Wait" State.
+ * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
+ * for a certain period. Currently, it is not in use.
+ */
+class Farm1StateWait : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateWait( VirtualChannelReception* setMyVC );
+	/**
+	 * AD Frames are always discarded.
+	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	Always returns FARM_IN_WAIT.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEWAIT_H_ */
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 4ea45e89..a14bcefe 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,154 +1,154 @@
-/**
- * @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>
-
-MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
-		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
-		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-}
-
-ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
-	uint8_t segmentationFlag = frame->getSequenceFlags();
-	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
-	switch (segmentationFlag) {
-	case NO_SEGMENTATION:
-		status = unpackBlockingPackets(frame);
-		break;
-	case FIRST_PORTION:
-		packetLength = frame->getDataLength();
-		if (packetLength <= MAX_PACKET_SIZE) {
-			memcpy(packetBuffer, frame->getDataField(), packetLength);
-			bufferPosition = &packetBuffer[packetLength];
-			status = RETURN_OK;
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-					<< packetLength << std::endl;
-			clearBuffers();
-			status = CONTENT_TOO_LARGE;
-		}
-		break;
-	case CONTINUING_PORTION:
-	case LAST_PORTION:
-		if (lastSegmentationFlag == FIRST_PORTION
-				|| lastSegmentationFlag == CONTINUING_PORTION) {
-			packetLength += frame->getDataLength();
-			if (packetLength <= MAX_PACKET_SIZE) {
-				memcpy(bufferPosition, frame->getDataField(),
-						frame->getDataLength());
-				bufferPosition = &packetBuffer[packetLength];
-				if (segmentationFlag == LAST_PORTION) {
-					status = sendCompletePacket(packetBuffer, packetLength);
-					clearBuffers();
-				}
-				status = RETURN_OK;
-			} else {
-				sif::error
-						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-						<< packetLength << std::endl;
-				clearBuffers();
-				status = CONTENT_TOO_LARGE;
-			}
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
-					<< (int) lastSegmentationFlag << std::endl;
-			clearBuffers();
-			status = ILLEGAL_SEGMENTATION_FLAG;
-		}
-		break;
-	default:
-		sif::error
-				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
-				<< (int) segmentationFlag << std::endl;
-		clearBuffers();
-		status = DATA_CORRUPTED;
-		break;
-	}
-	lastSegmentationFlag = segmentationFlag;
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
-		TcTransferFrame* frame) {
-	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
-	uint32_t totalLength = frame->getDataLength();
-	if (totalLength > MAX_PACKET_SIZE)
-		return CONTENT_TOO_LARGE;
-	uint8_t* position = frame->getDataField();
-	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
-		SpacePacketBase packet(position);
-		uint32_t packetSize = packet.getFullSize();
-		if (packetSize <= totalLength) {
-			status = sendCompletePacket(packet.getWholeData(),
-					packet.getFullSize());
-			totalLength -= packet.getFullSize();
-			position += packet.getFullSize();
-			status = RETURN_OK;
-		} else {
-			status = DATA_CORRUPTED;
-			totalLength = 0;
-		}
-	}
-	if (totalLength > 0) {
-		status = RESIDUAL_DATA;
-	}
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
-		uint32_t size) {
-	store_address_t store_id;
-	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
-	if (status == RETURN_OK) {
-		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
-	}
-	return status;
-}
-
-void MapPacketExtraction::clearBuffers() {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-	bufferPosition = packetBuffer;
-	packetLength = 0;
-	lastSegmentationFlag = NO_SEGMENTATION;
-}
-
-ReturnValue_t MapPacketExtraction::initialize() {
-	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	AcceptsTelecommandsIF* distributor = objectManager->get<
-			AcceptsTelecommandsIF>(packetDestination);
-	if ((packetStore != NULL) && (distributor != NULL)) {
-		tcQueueId = distributor->getRequestQueue();
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-void MapPacketExtraction::printPacketBuffer(void) {
-	sif::debug << "DLL: packet_buffer contains: " << std::endl;
-	for (uint32_t i = 0; i < this->packetLength; ++i) {
-		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
-				<< (uint16_t) this->packetBuffer[i] << std::endl;
-	}
-}
-
-uint8_t MapPacketExtraction::getMapId() const {
-	return mapId;
-}
+/**
+ * @file	MapPacketExtraction.cpp
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/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 <string.h>
+
+MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
+		object_id_t setPacketDestination) :
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+}
+
+ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
+	uint8_t segmentationFlag = frame->getSequenceFlags();
+	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
+	switch (segmentationFlag) {
+	case NO_SEGMENTATION:
+		status = unpackBlockingPackets(frame);
+		break;
+	case FIRST_PORTION:
+		packetLength = frame->getDataLength();
+		if (packetLength <= MAX_PACKET_SIZE) {
+			memcpy(packetBuffer, frame->getDataField(), packetLength);
+			bufferPosition = &packetBuffer[packetLength];
+			status = RETURN_OK;
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+					<< packetLength << std::endl;
+			clearBuffers();
+			status = CONTENT_TOO_LARGE;
+		}
+		break;
+	case CONTINUING_PORTION:
+	case LAST_PORTION:
+		if (lastSegmentationFlag == FIRST_PORTION
+				|| lastSegmentationFlag == CONTINUING_PORTION) {
+			packetLength += frame->getDataLength();
+			if (packetLength <= MAX_PACKET_SIZE) {
+				memcpy(bufferPosition, frame->getDataField(),
+						frame->getDataLength());
+				bufferPosition = &packetBuffer[packetLength];
+				if (segmentationFlag == LAST_PORTION) {
+					status = sendCompletePacket(packetBuffer, packetLength);
+					clearBuffers();
+				}
+				status = RETURN_OK;
+			} else {
+				sif::error
+						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+						<< packetLength << std::endl;
+				clearBuffers();
+				status = CONTENT_TOO_LARGE;
+			}
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
+					<< (int) lastSegmentationFlag << std::endl;
+			clearBuffers();
+			status = ILLEGAL_SEGMENTATION_FLAG;
+		}
+		break;
+	default:
+		sif::error
+				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
+				<< (int) segmentationFlag << std::endl;
+		clearBuffers();
+		status = DATA_CORRUPTED;
+		break;
+	}
+	lastSegmentationFlag = segmentationFlag;
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
+		TcTransferFrame* frame) {
+	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
+	uint32_t totalLength = frame->getDataLength();
+	if (totalLength > MAX_PACKET_SIZE)
+		return CONTENT_TOO_LARGE;
+	uint8_t* position = frame->getDataField();
+	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
+		SpacePacketBase packet(position);
+		uint32_t packetSize = packet.getFullSize();
+		if (packetSize <= totalLength) {
+			status = sendCompletePacket(packet.getWholeData(),
+					packet.getFullSize());
+			totalLength -= packet.getFullSize();
+			position += packet.getFullSize();
+			status = RETURN_OK;
+		} else {
+			status = DATA_CORRUPTED;
+			totalLength = 0;
+		}
+	}
+	if (totalLength > 0) {
+		status = RESIDUAL_DATA;
+	}
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
+		uint32_t size) {
+	store_address_t store_id;
+	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
+	if (status == RETURN_OK) {
+		TmTcMessage message(store_id);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+	}
+	return status;
+}
+
+void MapPacketExtraction::clearBuffers() {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+	bufferPosition = packetBuffer;
+	packetLength = 0;
+	lastSegmentationFlag = NO_SEGMENTATION;
+}
+
+ReturnValue_t MapPacketExtraction::initialize() {
+	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	AcceptsTelecommandsIF* distributor = objectManager->get<
+			AcceptsTelecommandsIF>(packetDestination);
+	if ((packetStore != NULL) && (distributor != NULL)) {
+		tcQueueId = distributor->getRequestQueue();
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+void MapPacketExtraction::printPacketBuffer(void) {
+	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+	for (uint32_t i = 0; i < this->packetLength; ++i) {
+		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
+				<< (uint16_t) this->packetBuffer[i] << std::endl;
+	}
+}
+
+uint8_t MapPacketExtraction::getMapId() const {
+	return mapId;
+}
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index 5a32366c..cb09c27f 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,78 +1,78 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#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>
-
-class StorageManagerIF;
-
-/**
- * Implementation of a MAP Packet Extraction class.
- * 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.
- */
-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.
-	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.
-	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
-	/**
-	 * Debug method to print the packet Buffer's content.
-	 */
-	void printPacketBuffer();
-	/**
-	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
-	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
-	 * @param frame	The TC Transfer Frame to work on.
-	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
-	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
-	 */
-	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
-	/**
-	 * Helper method to forward a complete packet to the OBSW.
-	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
-	 * @param size	Complete total size of the packet.
-	 * @return	Return Code of the Packet Store or the Message Queue.
-	 */
-	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
-	/**
-	 * Helper method to reset the internal buffer.
-	 */
-	void clearBuffers();
-public:
-	/**
-	 * Default constructor.
-	 * Members are set to default values.
-	 * @param setMapId	The MAP ID of the instance.
-	 */
-	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
-	ReturnValue_t extractPackets(TcTransferFrame* frame);
-	/**
-	 * The #packetStore and the default destination of #tcQueue are initialized here.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter.
-	 * @return The MAP ID of this instance.
-	 */
-	uint8_t getMapId() const;
-};
-
-#endif /* MAPPACKETEXTRACTION_H_ */
+/**
+ * @file	MapPacketExtraction.h
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTION_H_
+#define MAPPACKETEXTRACTION_H_
+
+#include "../datalinklayer/MapPacketExtractionIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class StorageManagerIF;
+
+/**
+ * Implementation of a MAP Packet Extraction class.
+ * 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.
+ */
+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.
+	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.
+	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
+	/**
+	 * Debug method to print the packet Buffer's content.
+	 */
+	void printPacketBuffer();
+	/**
+	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
+	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
+	 * @param frame	The TC Transfer Frame to work on.
+	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
+	 */
+	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
+	/**
+	 * Helper method to forward a complete packet to the OBSW.
+	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
+	 * @param size	Complete total size of the packet.
+	 * @return	Return Code of the Packet Store or the Message Queue.
+	 */
+	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
+	/**
+	 * Helper method to reset the internal buffer.
+	 */
+	void clearBuffers();
+public:
+	/**
+	 * Default constructor.
+	 * Members are set to default values.
+	 * @param setMapId	The MAP ID of the instance.
+	 */
+	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
+	ReturnValue_t extractPackets(TcTransferFrame* frame);
+	/**
+	 * The #packetStore and the default destination of #tcQueue are initialized here.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter.
+	 * @return The MAP ID of this instance.
+	 */
+	uint8_t getMapId() const;
+};
+
+#endif /* MAPPACKETEXTRACTION_H_ */
diff --git a/datalinklayer/MapPacketExtractionIF.h b/datalinklayer/MapPacketExtractionIF.h
index 802a893d..d66831de 100644
--- a/datalinklayer/MapPacketExtractionIF.h
+++ b/datalinklayer/MapPacketExtractionIF.h
@@ -1,47 +1,47 @@
-/**
- * @file	MapPacketExtractionIF.h
- * @brief	This file defines the MapPacketExtractionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTIONIF_H_
-#define MAPPACKETEXTRACTIONIF_H_
-
-#include <framework/datalinklayer/CCSDSReturnValuesIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-
-/**
- * This is the interface for MAP Packet Extraction classes.
- * All classes implementing this interface shall be able to extract blocked or segmented Space
- * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
- * Protocol.
- */
-class MapPacketExtractionIF : public CCSDSReturnValuesIF {
-protected:
-	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
-	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
-	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
-	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
-public:
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~MapPacketExtractionIF() {
-	}
-	/**
-	 * Method to call to handle a single Transfer Frame.
-	 * The method tries to extract Packets from the frame as stated in the Standard.
-	 * @param frame
-	 * @return
-	 */
-	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
-	/**
-	 * Any post-instantiation initialization shall be done in this method.
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() = 0;
-};
-
-
-#endif /* MAPPACKETEXTRACTIONIF_H_ */
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+
+/**
+ * This is the interface for MAP Packet Extraction classes.
+ * All classes implementing this interface shall be able to extract blocked or segmented Space
+ * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
+ * Protocol.
+ */
+class MapPacketExtractionIF : public CCSDSReturnValuesIF {
+protected:
+	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
+	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
+	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
+	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~MapPacketExtractionIF() {
+	}
+	/**
+	 * Method to call to handle a single Transfer Frame.
+	 * The method tries to extract Packets from the frame as stated in the Standard.
+	 * @param frame
+	 * @return
+	 */
+	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
+	/**
+	 * Any post-instantiation initialization shall be done in this method.
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() = 0;
+};
+
+
+#endif /* MAPPACKETEXTRACTIONIF_H_ */
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 30398e9b..8a3e1d76 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -1,102 +1,102 @@
-/**
- * @file	TcTransferFrame.cpp
- * @brief	This file defines the TcTransferFrame class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-
-
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-TcTransferFrame::TcTransferFrame() {
-	 frame = NULL;
-}
-
-TcTransferFrame::TcTransferFrame(uint8_t* setData) {
-	 this->frame = (tc_transfer_frame*)setData;
-}
-
-uint8_t TcTransferFrame::getVersionNumber() {
-	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
-}
-
-bool TcTransferFrame::bypassFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
-}
-
-bool TcTransferFrame::controlCommandFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
-}
-
-bool TcTransferFrame::spareIsZero() {
-	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
-}
-
-uint16_t TcTransferFrame::getSpacecraftId() {
-	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
-}
-
-uint8_t TcTransferFrame::getVirtualChannelId() {
-	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
-}
-
-uint16_t TcTransferFrame::getFrameLength() {
-	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
-}
-
-uint16_t TcTransferFrame::getDataLength() {
-	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
-}
-
-uint8_t TcTransferFrame::getSequenceNumber() {
-	 return this->frame->header.sequenceNumber;
-}
-
-uint8_t TcTransferFrame::getSequenceFlags() {
-	 return (this->frame->dataField & 0b11000000)>>6;
-}
-
-uint8_t TcTransferFrame::getMAPId() {
-	 return this->frame->dataField & 0b00111111;
-}
-
-uint8_t* TcTransferFrame::getDataField() {
-	return &(this->frame->dataField) + 1;
-}
-
-uint8_t* TcTransferFrame::getFullFrame() {
-	return (uint8_t*)this->frame;
-}
-
-uint16_t TcTransferFrame::getFullSize() {
-	return this->getFrameLength() + 1;
-}
-
-uint16_t TcTransferFrame::getHeaderSize() {
-	 return sizeof(frame->header);
-}
-
-uint16_t TcTransferFrame::getFullDataLength() {
-	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
-}
-
-uint8_t* TcTransferFrame::getFullDataField() {
-	return &frame->dataField;
-}
-
-void TcTransferFrame::print() {
-	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;
-}
+/**
+ * @file	TcTransferFrame.cpp
+ * @brief	This file defines the TcTransferFrame class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+TcTransferFrame::TcTransferFrame() {
+	 frame = NULL;
+}
+
+TcTransferFrame::TcTransferFrame(uint8_t* setData) {
+	 this->frame = (tc_transfer_frame*)setData;
+}
+
+uint8_t TcTransferFrame::getVersionNumber() {
+	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
+}
+
+bool TcTransferFrame::bypassFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
+}
+
+bool TcTransferFrame::controlCommandFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
+}
+
+bool TcTransferFrame::spareIsZero() {
+	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
+}
+
+uint16_t TcTransferFrame::getSpacecraftId() {
+	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
+}
+
+uint8_t TcTransferFrame::getVirtualChannelId() {
+	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
+}
+
+uint16_t TcTransferFrame::getFrameLength() {
+	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
+}
+
+uint16_t TcTransferFrame::getDataLength() {
+	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
+}
+
+uint8_t TcTransferFrame::getSequenceNumber() {
+	 return this->frame->header.sequenceNumber;
+}
+
+uint8_t TcTransferFrame::getSequenceFlags() {
+	 return (this->frame->dataField & 0b11000000)>>6;
+}
+
+uint8_t TcTransferFrame::getMAPId() {
+	 return this->frame->dataField & 0b00111111;
+}
+
+uint8_t* TcTransferFrame::getDataField() {
+	return &(this->frame->dataField) + 1;
+}
+
+uint8_t* TcTransferFrame::getFullFrame() {
+	return (uint8_t*)this->frame;
+}
+
+uint16_t TcTransferFrame::getFullSize() {
+	return this->getFrameLength() + 1;
+}
+
+uint16_t TcTransferFrame::getHeaderSize() {
+	 return sizeof(frame->header);
+}
+
+uint16_t TcTransferFrame::getFullDataLength() {
+	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
+}
+
+uint8_t* TcTransferFrame::getFullDataField() {
+	return &frame->dataField;
+}
+
+void TcTransferFrame::print() {
+	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;
+}
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 79e14167..0bffa586 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.cpp
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/TcTransferFrameLocal.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <string.h>
-
-TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
-		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
-	this->frame = (tc_transfer_frame*)&localData;
-	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
-	frame->header.spacecraftId_l = (scid & 0x00FF);
-	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
-	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
-	frame->header.sequenceNumber = sequenceNumber;
-	frame->dataField = setSegmentHeader;
-	if (data != NULL) {
-		if (bypass && controlCommand) {
-			memcpy(&(frame->dataField), data, dataSize);
-			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
-			frame->header.length_l = (totalSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else if (dataSize <= 1016) {
-			memcpy(&(frame->dataField) +1, data, dataSize);
-			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
-			frame->header.length_l = (dataCrcSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else {
-			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
-		}
-	} else {
-		//No data in frame
-	}
-	if (forceCrc != 0 ) {
-		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
-		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
-	}
-}
+/**
+ * @file	TcTransferFrameLocal.cpp
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/TcTransferFrameLocal.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <string.h>
+
+TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
+		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
+	this->frame = (tc_transfer_frame*)&localData;
+	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
+	frame->header.spacecraftId_l = (scid & 0x00FF);
+	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
+	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
+	frame->header.sequenceNumber = sequenceNumber;
+	frame->dataField = setSegmentHeader;
+	if (data != NULL) {
+		if (bypass && controlCommand) {
+			memcpy(&(frame->dataField), data, dataSize);
+			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
+			frame->header.length_l = (totalSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else if (dataSize <= 1016) {
+			memcpy(&(frame->dataField) +1, data, dataSize);
+			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
+			frame->header.length_l = (dataCrcSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else {
+			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+		}
+	} else {
+		//No data in frame
+	}
+	if (forceCrc != 0 ) {
+		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
+		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
+	}
+}
diff --git a/datalinklayer/TcTransferFrameLocal.h b/datalinklayer/TcTransferFrameLocal.h
index f20f12ec..d98350fe 100644
--- a/datalinklayer/TcTransferFrameLocal.h
+++ b/datalinklayer/TcTransferFrameLocal.h
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.h
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#ifndef TCTRANSFERFRAMELOCAL_H_
-#define TCTRANSFERFRAMELOCAL_H_
-
-#include <framework/datalinklayer/TcTransferFrame.h>
-
-/**
- * This is a helper class to locally create TC Transfer Frames.
- * This is mainly required for testing purposes and therefore not very sophisticated.
- * @ingroup ccsds_handling
- */
-class TcTransferFrameLocal : public TcTransferFrame {
-private:
-	/**
-	 * A stuct to locally store the complete data.
-	 */
-	struct frameData {
-		TcTransferFramePrimaryHeader header;	//!< The primary header.
-		uint8_t data[1019];	//!< The data field.
-	};
-public:
-	frameData localData; //!< The local data in the Frame.
-	/**
-	 * The default Constructor.
-	 * All parameters in the Header are passed.
-	 * If a BC Frame is detected no segment header is created.
-	 * Otherwise (AD and BD), the Segment Header is set.
-	 * @param bypass			The bypass flag.
-	 * @param controlCommand	The Control Command flag.
-	 * @param scid				The SCID.
-	 * @param vcId				The VCID.
-	 * @param sequenceNumber	The Frame Sequence Number N(s)
-	 * @param setSegmentHeader	A value for the Segment Header.
-	 * @param data				Data to put into the Frame Data Field.
-	 * @param dataSize			Size of the Data.
-	 * @param forceCrc			if != 0, the value is used as CRC.
-	 */
-	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
-			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
-};
-
-
-#endif /* TCTRANSFERFRAMELOCAL_H_ */
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "../datalinklayer/TcTransferFrame.h"
+
+/**
+ * This is a helper class to locally create TC Transfer Frames.
+ * This is mainly required for testing purposes and therefore not very sophisticated.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrameLocal : public TcTransferFrame {
+private:
+	/**
+	 * A stuct to locally store the complete data.
+	 */
+	struct frameData {
+		TcTransferFramePrimaryHeader header;	//!< The primary header.
+		uint8_t data[1019];	//!< The data field.
+	};
+public:
+	frameData localData; //!< The local data in the Frame.
+	/**
+	 * The default Constructor.
+	 * All parameters in the Header are passed.
+	 * If a BC Frame is detected no segment header is created.
+	 * Otherwise (AD and BD), the Segment Header is set.
+	 * @param bypass			The bypass flag.
+	 * @param controlCommand	The Control Command flag.
+	 * @param scid				The SCID.
+	 * @param vcId				The VCID.
+	 * @param sequenceNumber	The Frame Sequence Number N(s)
+	 * @param setSegmentHeader	A value for the Segment Header.
+	 * @param data				Data to put into the Frame Data Field.
+	 * @param dataSize			Size of the Data.
+	 * @param forceCrc			if != 0, the value is used as CRC.
+	 */
+	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
+			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
+};
+
+
+#endif /* TCTRANSFERFRAMELOCAL_H_ */
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 373f6c62..55169c42 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -1,121 +1,121 @@
-/**
- * @file	VirtualChannelReception.cpp
- * @brief	This file defines the VirtualChannelReception class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include <framework/datalinklayer/BCFrame.h>
-#include <framework/datalinklayer/VirtualChannelReception.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
-		uint8_t setSlidingWindowWidth) :
-		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
-				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
-				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
-				0) {
-	internalClcw.setVirtualChannel(channelId);
-}
-
-ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
-	uint8_t mapId = frame->getMAPId();
-	mapChannelIterator iter = mapChannels.find(mapId);
-	if (iter == mapChannels.end()) {
-//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
-//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
-		return VC_NOT_FOUND;
-	} else {
-		return (iter->second)->extractPackets(frame);
-	}
-}
-
-ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
-	uint8_t bypass = frame->bypassFlagSet();
-	uint8_t controlCommand = frame->controlCommandFlagSet();
-	uint8_t typeValue = (bypass << 1) + controlCommand;
-	switch (typeValue) {
-	case AD_FRAME:
-		return currentState->handleADFrame(frame, clcw);
-	case BD_FRAME:
-		return handleBDFrame(frame, clcw);
-	case BC_FRAME:
-		return handleBCFrame(frame, clcw);
-	default:
-		return ILLEGAL_FLAG_COMBINATION;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	ReturnValue_t result = RETURN_OK;
-	result = doFARM(frame, &internalClcw);
-	internalClcw.setReceiverFrameSequenceNumber(vR);
-	internalClcw.setFarmBCount(farmBCounter);
-	clcw->setWhole(internalClcw.getAsWhole());
-	switch (result) {
-	case RETURN_OK:
-		return mapDemultiplexing(frame);
-	case BC_IS_SET_VR_COMMAND:
-	case BC_IS_UNLOCK_COMMAND:
-		//Need to catch these codes to avoid error reporting later.
-		return RETURN_OK;
-	default:
-		break;
-	}
-	return result;
-}
-
-ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
-	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
-			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	farmBCounter++;
-	return RETURN_OK;
-}
-
-ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	BcFrame content;
-	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
-			frame->getFullDataLength());
-	if (returnValue == BC_IS_UNLOCK_COMMAND) {
-		returnValue = currentState->handleBCUnlockCommand(clcw);
-	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
-		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
-	} else {
-		//Do nothing
-	}
-	return returnValue;
-}
-
-uint8_t VirtualChannelReception::getChannelId() const {
-	return channelId;
-}
-
-ReturnValue_t VirtualChannelReception::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
-				<< (int) slidingWindowWidth << std::endl;
-		return RETURN_FAILED;
-	}
-	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
-			iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-}
-
-void VirtualChannelReception::setToWaitState() {
-	internalClcw.setWaitFlag(true);
-	this->currentState = &waitState;
-}
+/**
+ * @file	VirtualChannelReception.cpp
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "../datalinklayer/BCFrame.h"
+#include "../datalinklayer/VirtualChannelReception.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
+		uint8_t setSlidingWindowWidth) :
+		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
+				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
+				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
+				0) {
+	internalClcw.setVirtualChannel(channelId);
+}
+
+ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
+	uint8_t mapId = frame->getMAPId();
+	mapChannelIterator iter = mapChannels.find(mapId);
+	if (iter == mapChannels.end()) {
+//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
+//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
+		return VC_NOT_FOUND;
+	} else {
+		return (iter->second)->extractPackets(frame);
+	}
+}
+
+ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
+	uint8_t bypass = frame->bypassFlagSet();
+	uint8_t controlCommand = frame->controlCommandFlagSet();
+	uint8_t typeValue = (bypass << 1) + controlCommand;
+	switch (typeValue) {
+	case AD_FRAME:
+		return currentState->handleADFrame(frame, clcw);
+	case BD_FRAME:
+		return handleBDFrame(frame, clcw);
+	case BC_FRAME:
+		return handleBCFrame(frame, clcw);
+	default:
+		return ILLEGAL_FLAG_COMBINATION;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	ReturnValue_t result = RETURN_OK;
+	result = doFARM(frame, &internalClcw);
+	internalClcw.setReceiverFrameSequenceNumber(vR);
+	internalClcw.setFarmBCount(farmBCounter);
+	clcw->setWhole(internalClcw.getAsWhole());
+	switch (result) {
+	case RETURN_OK:
+		return mapDemultiplexing(frame);
+	case BC_IS_SET_VR_COMMAND:
+	case BC_IS_UNLOCK_COMMAND:
+		//Need to catch these codes to avoid error reporting later.
+		return RETURN_OK;
+	default:
+		break;
+	}
+	return result;
+}
+
+ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
+	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
+			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	farmBCounter++;
+	return RETURN_OK;
+}
+
+ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	BcFrame content;
+	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
+			frame->getFullDataLength());
+	if (returnValue == BC_IS_UNLOCK_COMMAND) {
+		returnValue = currentState->handleBCUnlockCommand(clcw);
+	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
+		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
+	} else {
+		//Do nothing
+	}
+	return returnValue;
+}
+
+uint8_t VirtualChannelReception::getChannelId() const {
+	return channelId;
+}
+
+ReturnValue_t VirtualChannelReception::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
+				<< (int) slidingWindowWidth << std::endl;
+		return RETURN_FAILED;
+	}
+	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
+			iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+}
+
+void VirtualChannelReception::setToWaitState() {
+	internalClcw.setWaitFlag(true);
+	this->currentState = &waitState;
+}
diff --git a/datalinklayer/VirtualChannelReception.h b/datalinklayer/VirtualChannelReception.h
index f364c6e5..f7111e42 100644
--- a/datalinklayer/VirtualChannelReception.h
+++ b/datalinklayer/VirtualChannelReception.h
@@ -1,114 +1,114 @@
-/**
- * @file	VirtualChannelReception.h
- * @brief	This file defines the VirtualChannelReception class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#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 <map>
-/**
- * Implementation of a TC Virtual Channel.
- * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
- * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
- * Features:
- *  - any (6bit) Virtual Channel ID is assignable.
- *  - Supports an arbitrary number of MAP Channels (with a map).
- *  - Has a complete FARM-1 Machine built-in.
- *
- * The FARM-1 state machine uses the State Pattern.
- */
-class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
-	friend class Farm1StateOpen;
-	friend class Farm1StateWait;
-	friend class Farm1StateLockout;
-private:
-	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
-	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
-	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
-	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
-protected:
-	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
-	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
-	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
-	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
-	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
-	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
-	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
-	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
-	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
-	/**
-	 * This method handles demultiplexing to different map channels.
-	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
-	 * @param frame	The frame to forward.
-	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
-	 */
-	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
-	/**
-	 * A sub-method that actually does the FARM-1 handling for different Frame types.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
-	 */
-	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
-	/**
-	 * Handles incoming BD Frames.
-	 * Handling these Frames is independent of the State, so no subcall to #currentState is
-	 * required.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return Always returns @c RETURN_OK.
-	 */
-	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Handles incoming BC Frames.
-	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
-	 */
-	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
-public:
-	/**
-	 * Default constructor.
-	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
-	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
-	 */
-	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
-	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Helper method to simplify adding a mapChannel during construction.
-	 * @param mapId	The mapId of the object to add.
-	 * @param object	Pointer to the MapPacketExtraction object itself.
-	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
-	/**
-	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
-	 * channels.
-	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	uint8_t getChannelId() const;
-	/**
-	 * Small method to set the state to Farm1StateWait.
-	 */
-	void setToWaitState();
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTION_H_ */
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_H_
+
+#include "../datalinklayer/CCSDSReturnValuesIF.h"
+#include "../datalinklayer/Clcw.h"
+#include "../datalinklayer/Farm1StateIF.h"
+#include "../datalinklayer/Farm1StateLockout.h"
+#include "../datalinklayer/Farm1StateOpen.h"
+#include "../datalinklayer/Farm1StateWait.h"
+#include "../datalinklayer/MapPacketExtractionIF.h"
+#include "../datalinklayer/VirtualChannelReceptionIF.h"
+#include <map>
+/**
+ * Implementation of a TC Virtual Channel.
+ * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
+ * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
+ * Features:
+ *  - any (6bit) Virtual Channel ID is assignable.
+ *  - Supports an arbitrary number of MAP Channels (with a map).
+ *  - Has a complete FARM-1 Machine built-in.
+ *
+ * The FARM-1 state machine uses the State Pattern.
+ */
+class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
+	friend class Farm1StateOpen;
+	friend class Farm1StateWait;
+	friend class Farm1StateLockout;
+private:
+	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
+	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
+	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
+	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
+protected:
+	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
+	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
+	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
+	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
+	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
+	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
+	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
+	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
+	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
+	/**
+	 * This method handles demultiplexing to different map channels.
+	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
+	 * @param frame	The frame to forward.
+	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
+	 */
+	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
+	/**
+	 * A sub-method that actually does the FARM-1 handling for different Frame types.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
+	 */
+	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
+	/**
+	 * Handles incoming BD Frames.
+	 * Handling these Frames is independent of the State, so no subcall to #currentState is
+	 * required.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return Always returns @c RETURN_OK.
+	 */
+	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Handles incoming BC Frames.
+	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
+	 */
+	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
+public:
+	/**
+	 * Default constructor.
+	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
+	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
+	 */
+	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
+	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Helper method to simplify adding a mapChannel during construction.
+	 * @param mapId	The mapId of the object to add.
+	 * @param object	Pointer to the MapPacketExtraction object itself.
+	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
+	/**
+	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
+	 * channels.
+	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	uint8_t getChannelId() const;
+	/**
+	 * Small method to set the state to Farm1StateWait.
+	 */
+	void setToWaitState();
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTION_H_ */
diff --git a/datalinklayer/VirtualChannelReceptionIF.h b/datalinklayer/VirtualChannelReceptionIF.h
index 98a9b72c..da544081 100644
--- a/datalinklayer/VirtualChannelReceptionIF.h
+++ b/datalinklayer/VirtualChannelReceptionIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	VirtualChannelReceptionIF.h
- * @brief	This file defines the VirtualChannelReceptionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTIONIF_H_
-#define VIRTUALCHANNELRECEPTIONIF_H_
-
-#include <framework/datalinklayer/ClcwIF.h>
-#include <framework/datalinklayer/TcTransferFrame.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * This is the interface for Virtual Channel reception classes.
- * It represents a single TC Virtual Channel that operates on one IO
- */
-class VirtualChannelReceptionIF {
-public:
-	/**
-	 * Enum including all valid types of frames.
-	 * The type is made up by two flags, so 0b1111 is definitely illegal.
-	 */
-	enum frameType  {
-		AD_FRAME = 0b00,
-		BC_FRAME = 0b11,
-		BD_FRAME = 0b10,
-		ILLEGAL_FRAME = 0b1111
-	};
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~VirtualChannelReceptionIF() {
-	}
-	/**
-	 * This method shall accept frames and do all FARM-1 stuff.
-	 * Handling the Frame includes forwarding to higher-level procedures.
-	 * @param frame	The Tc Transfer Frame that was received and checked.
-	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
-	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
-	 */
-	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * If any other System Objects are required for operation they shall be initialized here.
-	 * @return	@c RETURN_OK for successful initialization.
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	virtual uint8_t getChannelId() const = 0;
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "../datalinklayer/ClcwIF.h"
+#include "../datalinklayer/TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * This is the interface for Virtual Channel reception classes.
+ * It represents a single TC Virtual Channel that operates on one IO
+ */
+class VirtualChannelReceptionIF {
+public:
+	/**
+	 * Enum including all valid types of frames.
+	 * The type is made up by two flags, so 0b1111 is definitely illegal.
+	 */
+	enum frameType  {
+		AD_FRAME = 0b00,
+		BC_FRAME = 0b11,
+		BD_FRAME = 0b10,
+		ILLEGAL_FRAME = 0b1111
+	};
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~VirtualChannelReceptionIF() {
+	}
+	/**
+	 * This method shall accept frames and do all FARM-1 stuff.
+	 * Handling the Frame includes forwarding to higher-level procedures.
+	 * @param frame	The Tc Transfer Frame that was received and checked.
+	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
+	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
+	 */
+	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * If any other System Objects are required for operation they shall be initialized here.
+	 * @return	@c RETURN_OK for successful initialization.
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	virtual uint8_t getChannelId() const = 0;
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapool/ControllerSet.cpp
index eb4f6d0f..f83b38d5 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapool/ControllerSet.cpp
@@ -1,14 +1,14 @@
-#include <framework/datapool/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
+#include "../datapool/ControllerSet.h"
+
+ControllerSet::ControllerSet() {
+
+}
+
+ControllerSet::~ControllerSet() {
+}
+
+void ControllerSet::setInvalid() {
+	read();
+	setToDefault();
+	commit(PoolVariableIF::INVALID);
+}
diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index 7625c3d1..da6a9bf4 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,15 +1,15 @@
-#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_ */
+#ifndef CONTROLLERSET_H_
+#define CONTROLLERSET_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+
+class ControllerSet :public GlobDataSet {
+public:
+	ControllerSet();
+	virtual ~ControllerSet();
+
+	virtual void setToDefault() = 0;
+	void setInvalid();
+};
+
+#endif /* CONTROLLERSET_H_ */
diff --git a/datapool/DataSetBase.cpp b/datapool/DataSetBase.cpp
index cb7a7899..b7dd2cee 100644
--- a/datapool/DataSetBase.cpp
+++ b/datapool/DataSetBase.cpp
@@ -1,168 +1,168 @@
-#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;
-}
+#include "../datapool/DataSetBase.h"
+#include "../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;
+}
diff --git a/datapool/DataSetBase.h b/datapool/DataSetBase.h
index cc16aa9e..ed7eaa28 100644
--- a/datapool/DataSetBase.h
+++ b/datapool/DataSetBase.h
@@ -1,149 +1,149 @@
-#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_ */
+#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolVariableIF.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 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_ */
diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index 437f324f..88e82e50 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,62 +1,62 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Clock.h>
-class PoolVariableIF;
-
-/**
- * @brief	This class defines a small interface to register on a DataSet.
- *
- * @details
- * Currently, the only purpose of this interface is to provide a
- * method for locally checked-out variables to register on a data set.
- * Still, it may become useful for other purposes as well.
- * @author 	Bastian Baetz
- * @ingroup data_pool
- */
-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 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 );
-
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	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
-	 * 			to this DataSet operation.
-	 */
-	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_ */
+#ifndef DATASETIF_H_
+#define DATASETIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Clock.h"
+class PoolVariableIF;
+
+/**
+ * @brief	This class defines a small interface to register on a DataSet.
+ *
+ * @details
+ * Currently, the only purpose of this interface is to provide a
+ * method for locally checked-out variables to register on a data set.
+ * Still, it may become useful for other purposes as well.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+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 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 );
+
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is proposed for C++ interfaces.
+	 */
+	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
+	 * 			to this DataSet operation.
+	 */
+	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_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index cf5114f7..5a59f94c 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,75 +1,75 @@
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/ipc/QueueFactory.h>
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
-		commandActionHelper(this), eventProxy(eventProxy) {
-	actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
-}
-
-ReturnValue_t HkSwitchHelper::initialize() {
-	ReturnValue_t result = commandActionHelper.initialize();
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage command;
-	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		actionQueue->reply(&command);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
-}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
-		uint32_t size) {
-}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
-}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-//	ActionId_t action = HKService::DISABLE_HK;
-//	if (enable) {
-//		action = HKService::ENABLE_HK;
-//	}
-//
-//	ReturnValue_t result = commandActionHelper.commandAction(
-//			objects::PUS_HK_SERVICE, action, sids);
-//
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-//	}
-//	return result;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
-	return actionQueue;
-}
+#include "../datapool/HkSwitchHelper.h"
+#include "../ipc/QueueFactory.h"
+
+HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
+		commandActionHelper(this), eventProxy(eventProxy) {
+	actionQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+HkSwitchHelper::~HkSwitchHelper() {
+	// TODO Auto-generated destructor stub
+}
+
+ReturnValue_t HkSwitchHelper::initialize() {
+	ReturnValue_t result = commandActionHelper.initialize();
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return result;
+}
+
+ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
+	CommandMessage command;
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
+}
+
+void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
+		uint32_t size) {
+}
+
+void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
+}
+
+void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
+//	ActionId_t action = HKService::DISABLE_HK;
+//	if (enable) {
+//		action = HKService::ENABLE_HK;
+//	}
+//
+//	ReturnValue_t result = commandActionHelper.commandAction(
+//			objects::PUS_HK_SERVICE, action, sids);
+//
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
+//	}
+//	return result;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
+	return actionQueue;
+}
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index 1a3b6275..de34ab23 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -1,46 +1,46 @@
-#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>
-
-//TODO this class violations separation between mission and framework
-//but it is only a transitional solution until the Datapool is
-//implemented decentrally
-
-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
-
-	HkSwitchHelper(EventReportingProxyIF *eventProxy);
-	virtual ~HkSwitchHelper();
-
-	ReturnValue_t initialize();
-
-	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
-
-	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
-
-	virtual void setTaskIF(PeriodicTaskIF* task_){};
-
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode);
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size);
-	virtual void completionSuccessfulReceived(ActionId_t actionId);
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode);
-	virtual MessageQueueIF* getCommandQueuePtr();
-
-private:
-	CommandActionHelper commandActionHelper;
-	MessageQueueIF* actionQueue;
-	EventReportingProxyIF *eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_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
+//implemented decentrally
+
+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
+
+	HkSwitchHelper(EventReportingProxyIF *eventProxy);
+	virtual ~HkSwitchHelper();
+
+	ReturnValue_t initialize();
+
+	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
+
+	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
+
+	virtual void setTaskIF(PeriodicTaskIF* task_){};
+
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode);
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size);
+	virtual void completionSuccessfulReceived(ActionId_t actionId);
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode);
+	virtual MessageQueueIF* getCommandQueuePtr();
+
+private:
+	CommandActionHelper commandActionHelper;
+	MessageQueueIF* actionQueue;
+	EventReportingProxyIF *eventProxy;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d535a72b..a21d521f 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,87 +1,87 @@
-#include <framework/datapool/PoolEntry.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
-#include <cstring>
-
-template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), 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 ) :
-		length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if (initValue != nullptr) {
-		std::memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		std::memset(this->address, 0, this->getByteSize() );
-	}
-}
-
-//As the data pool is global, this dtor is only be called on program exit.
-//Warning! Never copy pool entries!
-template <typename T>
-PoolEntry<T>::~PoolEntry() {
-	delete[] this->address;
-}
-
-template <typename T>
-uint16_t PoolEntry<T>::getByteSize() {
-	return ( sizeof(T) * this->length );
-}
-
-template <typename T>
-uint8_t PoolEntry<T>::getSize() {
-	return this->length;
-}
-
-template <typename T>
-void* PoolEntry<T>::getRawData() {
-	return this->address;
-}
-
-template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
-	this->valid = isValid;
-}
-
-template <typename T>
-bool PoolEntry<T>::getValid() {
-	return valid;
-}
-
-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;
-}
-
-template<typename T>
-Type PoolEntry<T>::getType() {
-	return PodTypeConversion<T>::type;
-}
-
-template class PoolEntry<uint8_t>;
-template class PoolEntry<uint16_t>;
-template class PoolEntry<uint32_t>;
-template class PoolEntry<int8_t>;
-template class PoolEntry<int16_t>;
-template class PoolEntry<int32_t>;
-template class PoolEntry<float>;
-template class PoolEntry<double>;
+#include "../datapool/PoolEntry.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+template <typename T>
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), 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 ) :
+		length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		std::memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+//As the data pool is global, this dtor is only be called on program exit.
+//Warning! Never copy pool entries!
+template <typename T>
+PoolEntry<T>::~PoolEntry() {
+	delete[] this->address;
+}
+
+template <typename T>
+uint16_t PoolEntry<T>::getByteSize() {
+	return ( sizeof(T) * this->length );
+}
+
+template <typename T>
+uint8_t PoolEntry<T>::getSize() {
+	return this->length;
+}
+
+template <typename T>
+void* PoolEntry<T>::getRawData() {
+	return this->address;
+}
+
+template <typename T>
+void PoolEntry<T>::setValid(bool isValid) {
+	this->valid = isValid;
+}
+
+template <typename T>
+bool PoolEntry<T>::getValid() {
+	return valid;
+}
+
+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;
+}
+
+template<typename T>
+Type PoolEntry<T>::getType() {
+	return PodTypeConversion<T>::type;
+}
+
+template class PoolEntry<uint8_t>;
+template class PoolEntry<uint16_t>;
+template class PoolEntry<uint32_t>;
+template class PoolEntry<int8_t>;
+template class PoolEntry<int16_t>;
+template class PoolEntry<int32_t>;
+template class PoolEntry<float>;
+template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 1a22bb63..67891af8 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
-
-#include <framework/datapool/PoolEntryIF.h>
-
-#include <initializer_list>
-#include <type_traits>
-#include <cstddef>
-
-/**
- * @brief	This is a small helper class that defines a single data pool entry.
- * @details
- * The helper is used to store all information together with the data as a
- * single data pool entry. The content's type is defined by the template
- * argument.
- *
- * It is prepared for use with plain old data types, but may be
- * extended to complex types if necessary. It can be initialized with a
- * certain value, size and validity flag.
- *
- * It holds a pointer to the real data and offers methods to access this data
- * and to acquire additional information (such as validity and array/byte size).
- * It is NOT intended to be used outside DataPool implementations as it performs
- * dynamic memory allocation.
- *
- * @ingroup data_pool
- */
-template <typename T>
-class PoolEntry : public PoolEntryIF {
-public:
-	static_assert(not std::is_same<T, bool>::value,
-				"Do not use boolean for the PoolEntry type, use uint8_t "
-				"instead! The ECSS standard defines a boolean as a one bit "
-				"field. Therefore it is preferred to store a boolean as an "
-				"uint8_t");
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init 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.
-	 * @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.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @param initValue
-	 * A pointer to the single value or array that holds the init value.
-	 * With the default value (nullptr), the entry is initalized with all 0.
-	 * @param setLength
-	 * Defines the array length of this entry.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
-
-	//! Explicitely deleted copy ctor, copying is not allowed!
-	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
-	PoolEntry& operator=(const PoolEntry&) = delete;
-
-	/**
-	 * @brief	The allocated memory for the variable is freed
-	 * 			in the destructor.
-	 * @details
-	 * As the data pool is global, this dtor is only called on program exit.
-	 * PoolEntries shall never be copied, as a copy might delete the variable
-	 * on the heap.
-	 */
-	~PoolEntry();
-
-	/**
-	 * @brief	This is the address pointing to the allocated memory.
-	 */
-	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;
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
-	 */
-	uint8_t getSize();
-	/**
-	 * @brief	This operation returns the size in bytes.
-	 * @details	The size is calculated by sizeof(type) * array_size.
-	 */
-	uint16_t getByteSize();
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	void* getRawData();
-	/**
-	 * @brief	This method allows to set the valid information
-	 * 			of the pool entry.
-	 */
-	void setValid( bool isValid );
-	/**
-	 * @brief	This method allows to get the valid information
-	 * 			of the pool entry.
-	 */
-	bool getValid();
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 */
-	void print();
-
-	Type getType();
-};
-
-#endif /* POOLENTRY_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+
+#include "../datapool/PoolEntryIF.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <cstddef>
+
+/**
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry. The content's type is defined by the template
+ * argument.
+ *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolEntry : public PoolEntryIF {
+public:
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init 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.
+	 * @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.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
+
+	/**
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
+	 */
+	~PoolEntry();
+
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	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;
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
+	 */
+	uint8_t getSize();
+	/**
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
+	 */
+	uint16_t getByteSize();
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	void* getRawData();
+	/**
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
+	 */
+	void setValid( bool isValid );
+	/**
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
+	 */
+	bool getValid();
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 */
+	void print();
+
+	Type getType();
+};
+
+#endif /* POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index a075436e..a9fb44ef 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-
-#include <framework/globalfunctions/Type.h>
-#include <cstdint>
-
-/**
- * @brief	This interface defines the access possibilities to a
- * 			single data pool entry.
- * @details
- * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to the
- * raw data content. It is mainly used by DataPool itself, but also as a
- * return pointer.
- *
- * @author	Bastian Baetz
- * @ingroup data_pool
- *
- */
-class PoolEntryIF {
-public:
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is required for C++ interfaces.
-	 */
-	virtual ~PoolEntryIF() {
-	}
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * 			A single variable parameter has size 1.
-	 */
-	virtual uint8_t getSize() = 0;
-	/**
-	 * @brief	This operation returns the size in bytes, which is calculated by
-	 * 			sizeof(type) * array_size.
-	 */
-	virtual uint16_t getByteSize() = 0;
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	virtual void* getRawData() = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual void setValid(bool isValid) = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual bool getValid() = 0;
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 * @details
-	 * Also displays whether the pool entry is valid or invalid.
-	 */
-	virtual void print() = 0;
-	/**
-	 * Returns the type of the entry.
-	 */
-	virtual Type getType() = 0;
-};
-
-#endif /* POOLENTRYIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+
+#include "../globalfunctions/Type.h"
+#include <cstdint>
+
+/**
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ *
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ *
+ */
+class PoolEntryIF {
+public:
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is required for C++ interfaces.
+	 */
+	virtual ~PoolEntryIF() {
+	}
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
+	 */
+	virtual uint8_t getSize() = 0;
+	/**
+	 * @brief	This operation returns the size in bytes, which is calculated by
+	 * 			sizeof(type) * array_size.
+	 */
+	virtual uint16_t getByteSize() = 0;
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	virtual void* getRawData() = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual void setValid(bool isValid) = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual bool getValid() = 0;
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
+	 */
+	virtual void print() = 0;
+	/**
+	 * Returns the type of the entry.
+	 */
+	virtual Type getType() = 0;
+};
+
+#endif /* POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 2324a56c..272bb502 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -5,10 +5,10 @@
  * @author R. Mueller
  */
 
-#include <framework/datapool/PoolRawAccessHelper.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../datapool/PoolRawAccessHelper.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 #include <cmath>
 #include <cstring>
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index 0d8f8d6d..a09f7a2f 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -7,9 +7,9 @@
 #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>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PoolRawAccess.h"
 
 /**
  * @brief 	This helper function simplifies accessing data pool entries
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 9d6bc461..10c0e074 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,28 +1,28 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-template <class T, uint8_t n_var>
-class PoolVarList {
-private:
-	GlobPoolVar<T> variables[n_var];
-public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].dataPoolId = set_id[count];
-			variables[count].readWriteMode = setReadWriteMode;
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* POOLVARLIST_H_ */
+#ifndef POOLVARLIST_H_
+#define POOLVARLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+template <class T, uint8_t n_var>
+class PoolVarList {
+private:
+	GlobPoolVar<T> variables[n_var];
+public:
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].dataPoolId = set_id[count];
+			variables[count].readWriteMode = setReadWriteMode;
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* POOLVARLIST_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 30b87839..fc59ccd9 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,99 +1,99 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief	This interface is used to control data pool
- * 			variable representations.
- * @details
- * To securely handle data pool variables, all pool entries are locally
- * managed by data pool variable access classes, which are called pool
- * variables. To ensure a common state of a set of variables needed in a
- * function, these local pool variables again are managed by other classes,
- * like the DataSet classes. This interface provides unified access to
- * local pool variables for such manager classes.
- * @author 	Bastian Baetz
- * @ingroup data_pool
- */
-class PoolVariableIF : public SerializeIF {
-	friend class DataSetBase;
-	friend class GlobDataSet;
-	friend class LocalDataSet;
-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 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
-	};
-
-	/**
-	 * @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	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;
-};
-
-using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
-
-#endif /* POOLVARIABLEIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief	This interface is used to control data pool
+ * 			variable representations.
+ * @details
+ * To securely handle data pool variables, all pool entries are locally
+ * managed by data pool variable access classes, which are called pool
+ * variables. To ensure a common state of a set of variables needed in a
+ * function, these local pool variables again are managed by other classes,
+ * like the DataSet classes. This interface provides unified access to
+ * local pool variables for such manager classes.
+ * @author 	Bastian Baetz
+ * @ingroup data_pool
+ */
+class PoolVariableIF : public SerializeIF {
+	friend class DataSetBase;
+	friend class GlobDataSet;
+	friend class LocalDataSet;
+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 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
+	};
+
+	/**
+	 * @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	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;
+};
+
+using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
+
+#endif /* POOLVARIABLEIF_H_ */
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 4d0e5530..669bcc00 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,300 +1,300 @@
-#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);
-}
+#include "../datapoolglob/DataPoolAdmin.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../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);
+}
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 653fdd8e..3d5d4d0c 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,59 +1,59 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-
-#include <framework/memory/MemoryHelper.h>
-#include <framework/action/SimpleActionHelper.h>
-#include <framework/datapoolglob/DataPoolParameterWrapper.h>
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* DATAPOOLADMIN_H_ */
+#ifndef DATAPOOLADMIN_H_
+#define DATAPOOLADMIN_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+#include "../memory/MemoryHelper.h"
+#include "../action/SimpleActionHelper.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+
+class DataPoolAdmin: public HasActionsIF,
+		public ExecutableObjectIF,
+		public AcceptsMemoryMessagesIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SystemObject {
+public:
+	static const ActionId_t SET_VALIDITY = 1;
+
+	DataPoolAdmin(object_id_t objectId);
+
+	~DataPoolAdmin();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
+			uint8_t** dataPointer, uint8_t* copyHere);
+
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
+	//not implemented as ParameterHelper is no used
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	ReturnValue_t initialize();
+private:
+	StorageManagerIF *storage;
+	MessageQueueIF* commandQueue;
+	MemoryHelper memoryHelper;
+	SimpleActionHelper actionHelper;
+	void handleCommand();
+	ReturnValue_t handleParameterCommand(CommandMessage *command);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const DataPoolParameterWrapper* wrapper);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index a292016e..597cc86b 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,179 +1,179 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/DataPoolParameterWrapper.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/parameters/HasParametersIF.h>
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../parameters/HasParametersIF.h"
+
+
+DataPoolParameterWrapper::DataPoolParameterWrapper() :
+		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
+				PoolVariableIF::NO_PARAMETER) {
+
+}
+
+DataPoolParameterWrapper::~DataPoolParameterWrapper() {
+
+}
+
+ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
+		uint16_t parameterId) {
+	poolId = (domainId << 16) + parameterId;
+
+	GlobDataSet mySet;
+	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
+	ReturnValue_t status = mySet.read();
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		//should only fail for invalid pool id
+		return HasParametersIF::INVALID_MATRIX_ID;
+	}
+
+	type = raw.getType();
+	rows = raw.getArraySize();
+	columns = 1;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size,
+			maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	for (uint8_t index = 0; index < rows; index++){
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
+		mySet.read();
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//same as ParameterWrapper
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+template<typename T>
+ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void* from, uint8_t fromRows) {
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t *) from;
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+
+		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
+
+		fromAsStream += sizeof(T);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		mySet.commit();
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
+		uint16_t startWritingAtIndex) {
+	if (poolId == PoolVariableIF::NO_PARAMETER) {
+		return ParameterWrapper::NOT_SET;
+	}
+
+	if (type != from->type) {
+		return ParameterWrapper::DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return ParameterWrapper::TOO_BIG;
+	}
+
+	ReturnValue_t result;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		default:
+			result = ParameterWrapper::UNKNOW_DATATYPE;
+			break;
+		}
+	} else {
+		//not supported
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return result;
+}
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
index a3dbdc04..0c5c65ea 100644
--- a/datapoolglob/DataPoolParameterWrapper.h
+++ b/datapoolglob/DataPoolParameterWrapper.h
@@ -1,38 +1,38 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include <framework/globalfunctions/Type.h>
-#include <framework/parameters/ParameterWrapper.h>
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
+#ifndef DATAPOOLPARAMETERWRAPPER_H_
+#define DATAPOOLPARAMETERWRAPPER_H_
+
+#include "../globalfunctions/Type.h"
+#include "../parameters/ParameterWrapper.h"
+
+class DataPoolParameterWrapper: public SerializeIF {
+public:
+	DataPoolParameterWrapper();
+	virtual ~DataPoolParameterWrapper();
+
+	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	Type type;
+	uint8_t rows;
+	uint8_t columns;
+
+	uint32_t poolId;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows);
+
+};
+
+#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index 9dedb4b8..aa6831f8 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -1,133 +1,133 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/MutexFactory.h>
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/MutexFactory.h"
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::unlockDataPool() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index b9c1436f..37a4057b 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -1,149 +1,149 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include <framework/datapool/PoolEntry.h>
-#include <framework/globalfunctions/Type.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include "../datapool/PoolEntry.h"
+#include "../globalfunctions/Type.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t unlockDataPool();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+namespace glob {
+extern GlobalDataPool dataPool;
+}
+
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalDataSet.cpp b/datapoolglob/GlobalDataSet.cpp
index 883f6157..00124fb0 100644
--- a/datapoolglob/GlobalDataSet.cpp
+++ b/datapoolglob/GlobalDataSet.cpp
@@ -1,44 +1,44 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-GlobDataSet::GlobDataSet(): DataSetBase(
-        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
-        DATA_SET_MAX_SIZE) {}
-
-// Don't do anything with your variables, they are dead already!
-// (Destructor is already called)
-GlobDataSet::~GlobDataSet() {}
-
-ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
-	setEntriesValid(valid);
-	setSetValid(valid);
-	return commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return DataSetBase::commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
-	return glob::dataPool.lockDataPool(timeoutMs);
-}
-
-void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-void GlobDataSet::setSetValid(bool valid) {
-	this->valid = valid;
-}
-
-
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+GlobDataSet::GlobDataSet(): DataSetBase(
+        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
+        DATA_SET_MAX_SIZE) {}
+
+// Don't do anything with your variables, they are dead already!
+// (Destructor is already called)
+GlobDataSet::~GlobDataSet() {}
+
+ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
+	setEntriesValid(valid);
+	setSetValid(valid);
+	return commit(lockTimeout);
+}
+
+ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
+	return DataSetBase::commit(lockTimeout);
+}
+
+ReturnValue_t GlobDataSet::unlockDataPool() {
+	return glob::dataPool.unlockDataPool();
+}
+
+ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
+	return glob::dataPool.lockDataPool(timeoutMs);
+}
+
+void GlobDataSet::setEntriesValid(bool valid) {
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if (registeredVariables[count]->getReadWriteMode()
+				!= PoolVariableIF::VAR_READ) {
+			registeredVariables[count]->setValid(valid);
+		}
+	}
+}
+
+void GlobDataSet::setSetValid(bool valid) {
+	this->valid = valid;
+}
+
+
diff --git a/datapoolglob/GlobalDataSet.h b/datapoolglob/GlobalDataSet.h
index d237cc1b..019595ce 100644
--- a/datapoolglob/GlobalDataSet.h
+++ b/datapoolglob/GlobalDataSet.h
@@ -1,96 +1,96 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-
-#include <framework/datapool/DataSetBase.h>
-
-/**
- * @brief	The DataSet class manages a set of locally checked out variables
- * 			for the global data pool.
- * @details
- * This class uses the read-commit() semantic provided by the DataSetBase class.
- * It extends the base class by using the global data pool,
- * having a valid state and implementing lock und unlock calls for the global
- * datapool.
- *
- * For more information on how this class works, see the DataSetBase
- * documentation.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobDataSet: public DataSetBase {
-public:
-
-	/**
-	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	GlobDataSet();
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~GlobDataSet();
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @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
-	 */
-	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
-
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-};
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
+
+#include "../datapool/DataSetBase.h"
+
+/**
+ * @brief	The DataSet class manages a set of locally checked out variables
+ * 			for the global data pool.
+ * @details
+ * This class uses the read-commit() semantic provided by the DataSetBase class.
+ * It extends the base class by using the global data pool,
+ * having a valid state and implementing lock und unlock calls for the global
+ * datapool.
+ *
+ * For more information on how this class works, see the DataSetBase
+ * documentation.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobDataSet: public DataSetBase {
+public:
+
+	/**
+	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
+	 * 			supply a pointer to this dataset to PoolVariable
+	 * 			initializations to register pool variables.
+	 */
+	GlobDataSet();
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~GlobDataSet();
+
+	/**
+	 * Variant of method above which sets validity of all elements of the set.
+	 * @param valid Validity information from PoolVariableIF.
+	 * @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
+	 */
+	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+	/**
+	 * Set all entries
+	 * @param valid
+	 */
+	void setSetValid(bool valid);
+
+	/**
+	 * Set the valid information of all variables contained in the set which
+	 * are not read-only
+	 *
+	 * @param valid Validity information from PoolVariableIF.
+	 */
+	void setEntriesValid(bool valid);
+
+	//!< This definition sets the maximum number of variables to
+	//! register in one DataSet.
+	static const uint8_t DATA_SET_MAX_SIZE = 63;
+
+private:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	void handleAlreadyReadDatasetCommit();
+	ReturnValue_t handleUnreadDatasetCommit();
+
+	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
+};
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index b4aa6c4c..f5fc49f8 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,213 +1,213 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include <framework/datapoolglob/GlobalPoolVariable.tpp>
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"There is no boolean type in CCSDS.");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(bool valid) override;
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
+	}
+};
+
+#include "../datapoolglob/GlobalPoolVariable.tpp"
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 0e03f77d..eb40d1f1 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,185 +1,185 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include <framework/datapoolglob/GlobalPoolVector.tpp>
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* POOLVECTOR_H_ */
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class GlobPoolVector: public PoolVariableIF {
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+	void setValid(bool valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
+
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t max_size, Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#include "../datapoolglob/GlobalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index a1116040..7d12a0fd 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -1,164 +1,164 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
+#ifndef PIDREADER_H_
+#define PIDREADER_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename U, uint8_t n_var> class PIDReaderList;
+
+template<typename T>
+class PIDReader: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PIDReaderList;
+protected:
+	uint32_t parameterId;
+	uint8_t valid;
+	ReturnValue_t readWithoutLock() {
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		if (read_out != NULL) {
+			valid = read_out->valid;
+			value = read_out->address[arrayIndex];
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			value = 0;
+			valid = false;
+			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
+					<< std::dec << " failed." << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * Never commit, is read-only.
+	 * Reason is the possibility to access a single DP vector element, but if we commit,
+	 * we set validity of the whole vector.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	PIDReader() :
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
+
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 */
+	T value;
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
+		if (dataSet != NULL) {
+			dataSet->registerVariable(this);
+		}
+	}
+
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+	PIDReader(const PIDReader &rhs) :
+			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
+	}
+
+	/**
+	 * \brief	The classes destructor is empty.
+	 */
+	~PIDReader() {
+
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
+	}
+	uint32_t getParameterId() const {
+		return parameterId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return VAR_READ;
+	}
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid)
+			return true;
+		else
+			return false;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	void setValid(bool valid) {
+		this->valid = valid;
+	}
+
+	operator T() {
+		return value;
+	}
+
+	PIDReader<T>& operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
+	}
+};
+
+#endif /* PIDREADER_H_ */
diff --git a/datapoolglob/PIDReaderList.h b/datapoolglob/PIDReaderList.h
index 0b838508..b167feaa 100644
--- a/datapoolglob/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,27 +1,27 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoolglob/PIDReader.h>
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/PIDReader.h"
+template <class T, uint8_t n_var>
+class PIDReaderList {
+private:
+	PIDReader<T> variables[n_var];
+public:
+	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].parameterId = setPid[count];
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	PIDReader<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 783418cc..09093cd6 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,239 +1,239 @@
-#include <framework/datapoolglob/GlobalDataPool.h>
-#include <framework/datapoolglob/PoolRawAccess.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/EndianConverter.h>
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/EndianConverter.h"
+
+#include <cstring>
+
+PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
+	memset(value, 0, sizeof(value));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {}
+
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
+		}
+	} else {
+		result = READ_ENTRY_NON_EXISTENT;
+	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->setValid(valid);
+		uint8_t array_position = arrayEntry * typeSize;
+		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
+		memcpy(ptr, value, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t* PoolRawAccess::getEntry() {
+	return value;
+}
+
+ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
+		size_t* writtenBytes, size_t max_size) {
+	uint8_t* data_ptr = getEntry();
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	if (typeSize == 0)
+		return DATA_POOL_ACCESS_FAILED;
+	if (typeSize > max_size)
+		return INCORRECT_SIZE;
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+        size_t maxSize, Endianness streamEndianness) const {
+    if (typeSize + *size <= maxSize) {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
+            memcpy(*buffer, value, typeSize);
+            break;
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+}
+
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+size_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+size_t PoolRawAccess::getArraySize(){
+	return arraySize;
+}
+
+uint32_t PoolRawAccess::getDataPoolId() const {
+	return dataPoolId;
+}
+
+PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
+	if (typeSize == setSize) {
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
+				<< std::endl;
+		return INCORRECT_SIZE;
+	}
+}
+
+bool PoolRawAccess::isValid() const {
+	if (valid != INVALID)
+		return true;
+	else
+		return false;
+}
+
+void PoolRawAccess::setValid(bool valid) {
+	this->valid = valid;
+}
+
+size_t PoolRawAccess::getSizeTillEnd() const {
+	return sizeTillEnd;
+}
+
+
+size_t PoolRawAccess::getSerializedSize() const {
+	return typeSize;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
+            memcpy(value, *buffer, typeSize);
+            break;
+        }
+    	*size -= typeSize;
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
+}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index 22dc312d..a1bed466 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -1,220 +1,220 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntryIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/globalfunctions/Type.h>
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntryIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
+ */
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			size_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	size_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	size_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(bool valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	size_t getSizeTillEnd() const;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
+	 *
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * @brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	size_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	size_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	size_t sizeTillEnd;
+	/**
+	 * @brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#endif /* POOLRAWACCESS_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 0095f894..8703233c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#include <framework/datapool/PoolEntryIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <map>
-
-class LocalDataPoolManager;
-class DataSetIF;
-/**
- * @brief	Type definition for local pool entries.
- */
-using lp_id_t = uint32_t;
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
-
-/**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
- * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
- *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
- */
-class HasLocalDataPoolIF {
-public:
-	virtual~ HasLocalDataPoolIF() {};
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-	/** Command queue for housekeeping messages. */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/** Is used by pool owner to initialize the pool map once */
-	virtual ReturnValue_t initializePoolEntries(
-	        LocalDataPool& localDataPoolMap) = 0;
-
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
-
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
-	virtual ReturnValue_t addDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t removeDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#include "../datapool/PoolEntryIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include <map>
+
+class LocalDataPoolManager;
+class DataSetIF;
+/**
+ * @brief	Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using LocalDataPoolMapIter = LocalDataPool::iterator;
+
+/**
+ * @brief 		This interface is implemented by classes which posses a local
+ * 				data pool (not the managing class). It defines the relationship
+ * 				between the local data pool owner and the LocalDataPoolManager.
+ * @details
+ * Any class implementing this interface shall also have a LocalDataPoolManager
+ * member class which contains the actual pool data structure
+ * and exposes the public interface for it.
+ * This is required because the pool entries are templates, which makes
+ * specifying an interface rather difficult. The local data pool can be
+ * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
+ * classes.
+ *
+ * Architectural Note:
+ * This could be circumvented by using a wrapper/accessor function or
+ * implementing the templated function in this interface..
+ * The first solution sounds better than the second but
+ * the LocalPoolVariable classes are templates as well, so this just shifts
+ * the problem somewhere else. Interfaces are nice, but the most
+ * pragmatic solution I found was to offer the client the full interface
+ * of the LocalDataPoolManager.
+ */
+class HasLocalDataPoolIF {
+public:
+	virtual~ HasLocalDataPoolIF() {};
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+	/** Command queue for housekeeping messages. */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/** Is used by pool owner to initialize the pool map once */
+	virtual ReturnValue_t initializePoolEntries(
+	        LocalDataPool& localDataPoolMap) = 0;
+
+	/** Can be used to get a handle to the local data pool manager. */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+
+	/* These function can be implemented by pool owner, as they are required
+	 * by the housekeeping message interface */
+	virtual ReturnValue_t addDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t removeDataSet(sid_t sid) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
+	        dur_seconds_t newInterval) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 02016abf..434dd6ae 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,218 +1,218 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/housekeeping/AcceptsHkPacketsIF.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/ipc/QueueFactory.h>
-
-#include <array>
-
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-        appendValidityBuffer(appendValidityBuffer) {
-	if(owner == nullptr) {
-		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		return;
-	}
-	this->owner = owner;
-	mutex = MutexFactory::instance()->createMutex();
-	if(mutex == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not create mutex." << std::endl;
-	}
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if(ipcStore == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not set IPC store." << std::endl;
-	}
-	hkQueue = queueToUse;
-}
-
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination) {
-    if(queueToUse == nullptr) {
-        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
-                "invalid!" << std::endl;
-    }
-    hkQueue = queueToUse;
-
-    if(hkDestination == objects::NO_OBJECT) {
-        return initializeHousekeepingPoolEntriesOnce();
-    }
-
-    AcceptsHkPacketsIF* hkReceiver =
-            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
-    if(hkReceiver != nullptr) {
-        setHkPacketDestination(hkReceiver->getHkQueue());
-    }
-    else {
-        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. " << std::flush;
-        sif::warning << "Make sure it exists and the object impements "
-                "AcceptsHkPacketsIF!" << std::endl;
-    }
-    return initializeHousekeepingPoolEntriesOnce();
-}
-
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t hkDestination) {
-    this->hkDestination = hkDestination;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {}
-
-ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        "once!" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
-    Command_t command = message->getCommand();
-    switch(command) {
-    // I think those are the only commands which can be handled here..
-    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
-    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
-        // We should use OwnsLocalPoolDataIF to specify those functions..
-        return HasReturnvaluesIF::RETURN_OK;
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        //return generateSetStructurePacket(message->getSid());
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        //return generateHousekeepingPacket(message->getSid());
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
-}
-
-ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
-}
-
-const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
-    return owner;
-}
-
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        MessageQueueId_t sendTo) {
-	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
-			owner->getDataSetHandle(sid));
-	if(dataSetToSerialize == nullptr) {
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
-	        dataSetToSerialize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    return result;
-	}
-
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
-
-	if(sendTo != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-	}
-	else {
-	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-	                " Destination is not set properly!" << std::endl;
-	        return QUEUE_OR_DESTINATION_NOT_SET;
-	    }
-	    else {
-	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-	    }
-	}
-
-	return result;
-}
-
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
-}
-
-void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
-}
-
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        store_address_t *storeId, LocalDataSet* dataSet) {
-    size_t hkSize = dataSet->getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-
-    if(appendValidityBuffer) {
-        result = dataSet->serializeWithValidityBuffer(&storePtr,
-                &size, hkSize, SerializeIF::Endianness::MACHINE);
-    }
-    else {
-        result = dataSet->serialize(&storePtr, &size, hkSize,
-                SerializeIF::Endianness::MACHINE);
-    }
-
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
-                "Serialization proccess failed!" << std::endl;
-    }
-    return result;
-}
-
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/LocalDataSet.h"
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+#include "../ipc/QueueFactory.h"
+
+#include <array>
+
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
+        MessageQueueIF* queueToUse, bool appendValidityBuffer):
+        appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not create mutex." << std::endl;
+	}
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+	            "Could not set IPC store." << std::endl;
+	}
+	hkQueue = queueToUse;
+}
+
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
+        object_id_t hkDestination) {
+    if(queueToUse == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
+                "invalid!" << std::endl;
+    }
+    hkQueue = queueToUse;
+
+    if(hkDestination == objects::NO_OBJECT) {
+        return initializeHousekeepingPoolEntriesOnce();
+    }
+
+    AcceptsHkPacketsIF* hkReceiver =
+            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
+    if(hkReceiver != nullptr) {
+        setHkPacketDestination(hkReceiver->getHkQueue());
+    }
+    else {
+        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
+                " queue ID from HK destination object ID. " << std::flush;
+        sif::warning << "Make sure it exists and the object impements "
+                "AcceptsHkPacketsIF!" << std::endl;
+    }
+    return initializeHousekeepingPoolEntriesOnce();
+}
+
+void LocalDataPoolManager::setHkPacketDestination(
+        MessageQueueId_t hkDestination) {
+    this->hkDestination = hkDestination;
+}
+
+LocalDataPoolManager::~LocalDataPoolManager() {}
+
+ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+	sif::warning << "HousekeepingManager: The map should only be initialized "
+	        "once!" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
+		CommandMessage* message) {
+    Command_t command = message->getCommand();
+    switch(command) {
+    // I think those are the only commands which can be handled here..
+    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
+    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
+        // We should use OwnsLocalPoolDataIF to specify those functions..
+        return HasReturnvaluesIF::RETURN_OK;
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
+        //return generateSetStructurePacket(message->getSid());
+    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
+        //return generateHousekeepingPacket(message->getSid());
+    default:
+        return CommandMessageIF::UNKNOWN_COMMAND;
+    }
+}
+
+ReturnValue_t LocalDataPoolManager::printPoolEntry(
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::debug << "HousekeepingManager::fechPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* LocalDataPoolManager::getMutexHandle() {
+	return mutex;
+}
+
+const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+    return owner;
+}
+
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        MessageQueueId_t sendTo) {
+	LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
+			owner->getDataSetHandle(sid));
+	if(dataSetToSerialize == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	store_address_t storeId;
+	ReturnValue_t result = serializeHkPacketIntoStore(&storeId,
+	        dataSetToSerialize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    return result;
+	}
+
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_OR_DESTINATION_NOT_SET;
+	}
+
+	if(sendTo != MessageQueueIF::NO_QUEUE) {
+	    result = hkQueue->sendMessage(sendTo, &hkMessage);
+	}
+	else {
+	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+	                " Destination is not set properly!" << std::endl;
+	        return QUEUE_OR_DESTINATION_NOT_SET;
+	    }
+	    else {
+	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+	    }
+	}
+
+	return result;
+}
+
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
+    LocalDataSet* dataSet = dynamic_cast<LocalDataSet*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
+
+void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
+}
+
+ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
+        store_address_t *storeId, LocalDataSet* dataSet) {
+    size_t hkSize = dataSet->getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(storeId, hkSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+
+    if(appendValidityBuffer) {
+        result = dataSet->serializeWithValidityBuffer(&storePtr,
+                &size, hkSize, SerializeIF::Endianness::MACHINE);
+    }
+    else {
+        result = dataSet->serialize(&storePtr, &size, hkSize,
+                SerializeIF::Endianness::MACHINE);
+    }
+
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::serializeHkPacketIntoStore: "
+                "Serialization proccess failed!" << std::endl;
+    }
+    return result;
+}
+
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df7b9ff4..c5f8761f 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,229 +1,229 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/ipc/MutexIF.h>
-
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MutexHelper.h>
-
-#include <map>
-
-class LocalDataSet;
-
-/**
- * @brief 	This class is the managing instance for local data pool.
- * @details
- * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this class as a member and implement
- * the HasLocalDataPoolIF.
- *
- * Users of the data pool use the helper classes LocalDataSet,
- * LocalPoolVariable and LocalPoolVector to access pool entries in
- * a thread-safe and efficient way.
- *
- * The local data pools employ a blackboard logic: Only the most recent
- * value is stored. The helper classes offer a read() and commit() interface
- * through the PoolVariableIF which is used to read and update values.
- * Each pool entry has a valid state too.
- *
- */
-class LocalDataPoolManager {
-	template<typename T>
-	friend class LocalPoolVar;
-	template<typename T, uint16_t vecSize>
-	friend class LocalPoolVector;
-	friend class LocalDataSet;
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
-
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
-    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
-
-    /**
-     * This constructor is used by a class which wants to implement
-     * a personal local data pool. The queueToUse can be supplied if it
-     * is already known.
-     *
-     * initialize() has to be called in any case before using the object!
-     * @param owner
-     * @param queueToUse
-     * @param appendValidityBuffer
-     */
-	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-	        bool appendValidityBuffer = true);
-	virtual~ LocalDataPoolManager();
-
-	/**
-	 * Initializes the map by calling the map initialization function of the
-	 * owner and assigns the queue to use.
-	 * @param queueToUse
-	 * @return
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination);
-
-	/**
-	 * This should be called in the periodic handler of the owner.
-	 * It performs all the periodic functionalities of the data pool manager.
-	 * @return
-	 */
-	ReturnValue_t performHkOperation();
-	/**
-	 * This function is used to set the default HK packet destination.
-	 * This destination will usually only be set once.
-	 * @param hkDestination
-	 */
-	void setHkPacketDestination(MessageQueueId_t hkDestination);
-
-	/**
-	 * Generate a housekeeping packet with a given SID.
-	 * @param sid
-	 * @return
-	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
-	        = MessageQueueIF::NO_QUEUE);
-	ReturnValue_t generateSetStructurePacket(sid_t sid);
-
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * This function is used to fill the local data pool map with pool
-	 * entries. It should only be called once by the pool owner.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
-	const HasLocalDataPoolIF* getOwner() const;
-
-	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
-
-    /**
-     * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals
-     *  2. UPDATED: HK packets are generated if a value was updated
-     *  3. REQUESTED: HK packets are only generated if explicitely requested
-     */
-    enum class ReportingType: uint8_t {
-        PERIODIC,
-        ON_UPDATE,
-        REQUESTED
-    };
-
-    /* Copying forbidden */
-    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
-    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-private:
-    LocalDataPool localPoolMap;
-    /** Every housekeeping data manager has a mutex to protect access
-     * to it's data pool. */
-    MutexIF* mutex = nullptr;
-    /** The class which actually owns the manager (and its datapool). */
-    HasLocalDataPoolIF* owner = nullptr;
-
-    /**
-     * The data pool manager will keep an internal map of HK receivers.
-     */
-    struct HkReceiver {
-        LocalDataSet* dataSet = nullptr;
-        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-        ReportingType reportingType = ReportingType::PERIODIC;
-        bool reportingStatus = true;
-        /** Different members of this union will be used depending on reporting
-         * type */
-        union hkParameter {
-            /** This parameter will be used for the PERIODIC type */
-            dur_seconds_t collectionInterval = 0;
-            /** This parameter will be used for the ON_UPDATE type */
-            bool hkDataChanged;
-        };
-    };
-
-    /** Using a multimap as the same object might request multiple datasets */
-    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
-
-    HkReceiversMap hkReceiversMap;
-
-    /** This is the map holding the actual data. Should only be initialized
-     * once ! */
-    bool mapInitialized = false;
-    /** This specifies whether a validity buffer is appended at the end
-     * of generated housekeeping packets. */
-    bool appendValidityBuffer = true;
-
-	/**
-	 * @brief Queue used for communication, for example commands.
-	 * Is also used to send messages. Can be set either in the constructor
-     * or in the initialize() function.
-	 */
-	MessageQueueIF* hkQueue = nullptr;
-
-	/**
-	 * HK replies will always be a reply to the commander, but HK packet
-	 * can be sent to another destination by specifying this message queue
-	 * ID, for example to a dedicated housekeeping service implementation.
-	 */
-	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
-
-	/** Global IPC store is used to store all packets. */
-	StorageManagerIF* ipcStore = nullptr;
-	/**
-	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * eternally. Use with care and don't forget to unlock locked mutexes!
-	 * For now, only friend classes can accss this function.
-	 * @return
-	 */
-	MutexIF* getMutexHandle();
-
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * For now, only friend classes like LocalPoolVar may access this
-	 * function.
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
-			PoolEntry<T> **poolEntry);
-
-	void setMinimalSamplingFrequency(float frequencySeconds);
-	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
-	        LocalDataSet* dataSet);
-};
-
-
-template<class T> inline
-ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> **poolEntry) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-
-	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(*poolEntry == nullptr) {
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../ipc/MutexIF.h"
+
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexHelper.h"
+
+#include <map>
+
+class LocalDataSet;
+
+/**
+ * @brief 	This class is the managing instance for local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this class as a member and implement
+ * the HasLocalDataPoolIF.
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ *
+ */
+class LocalDataPoolManager {
+	template<typename T>
+	friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize>
+	friend class LocalPoolVector;
+	friend class LocalDataSet;
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
+
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
+    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
+
+    /**
+     * This constructor is used by a class which wants to implement
+     * a personal local data pool. The queueToUse can be supplied if it
+     * is already known.
+     *
+     * initialize() has to be called in any case before using the object!
+     * @param owner
+     * @param queueToUse
+     * @param appendValidityBuffer
+     */
+	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+	        bool appendValidityBuffer = true);
+	virtual~ LocalDataPoolManager();
+
+	/**
+	 * Initializes the map by calling the map initialization function of the
+	 * owner and assigns the queue to use.
+	 * @param queueToUse
+	 * @return
+	 */
+	ReturnValue_t initialize(MessageQueueIF* queueToUse,
+	        object_id_t hkDestination);
+
+	/**
+	 * This should be called in the periodic handler of the owner.
+	 * It performs all the periodic functionalities of the data pool manager.
+	 * @return
+	 */
+	ReturnValue_t performHkOperation();
+	/**
+	 * This function is used to set the default HK packet destination.
+	 * This destination will usually only be set once.
+	 * @param hkDestination
+	 */
+	void setHkPacketDestination(MessageQueueId_t hkDestination);
+
+	/**
+	 * Generate a housekeeping packet with a given SID.
+	 * @param sid
+	 * @return
+	 */
+	ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
+	        = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateSetStructurePacket(sid_t sid);
+
+	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+	/**
+	 * This function is used to fill the local data pool map with pool
+	 * entries. It should only be called once by the pool owner.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
+	const HasLocalDataPoolIF* getOwner() const;
+
+	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
+
+    /**
+     * Different types of housekeeping reporting are possible.
+     *  1. PERIODIC: HK packets are generated in fixed intervals
+     *  2. UPDATED: HK packets are generated if a value was updated
+     *  3. REQUESTED: HK packets are only generated if explicitely requested
+     */
+    enum class ReportingType: uint8_t {
+        PERIODIC,
+        ON_UPDATE,
+        REQUESTED
+    };
+
+    /* Copying forbidden */
+    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
+    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
+
+private:
+    LocalDataPool localPoolMap;
+    /** Every housekeeping data manager has a mutex to protect access
+     * to it's data pool. */
+    MutexIF* mutex = nullptr;
+    /** The class which actually owns the manager (and its datapool). */
+    HasLocalDataPoolIF* owner = nullptr;
+
+    /**
+     * The data pool manager will keep an internal map of HK receivers.
+     */
+    struct HkReceiver {
+        LocalDataSet* dataSet = nullptr;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+        ReportingType reportingType = ReportingType::PERIODIC;
+        bool reportingStatus = true;
+        /** Different members of this union will be used depending on reporting
+         * type */
+        union hkParameter {
+            /** This parameter will be used for the PERIODIC type */
+            dur_seconds_t collectionInterval = 0;
+            /** This parameter will be used for the ON_UPDATE type */
+            bool hkDataChanged;
+        };
+    };
+
+    /** Using a multimap as the same object might request multiple datasets */
+    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+
+    HkReceiversMap hkReceiversMap;
+
+    /** This is the map holding the actual data. Should only be initialized
+     * once ! */
+    bool mapInitialized = false;
+    /** This specifies whether a validity buffer is appended at the end
+     * of generated housekeeping packets. */
+    bool appendValidityBuffer = true;
+
+	/**
+	 * @brief Queue used for communication, for example commands.
+	 * Is also used to send messages. Can be set either in the constructor
+     * or in the initialize() function.
+	 */
+	MessageQueueIF* hkQueue = nullptr;
+
+	/**
+	 * HK replies will always be a reply to the commander, but HK packet
+	 * can be sent to another destination by specifying this message queue
+	 * ID, for example to a dedicated housekeeping service implementation.
+	 */
+	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
+
+	/** Global IPC store is used to store all packets. */
+	StorageManagerIF* ipcStore = nullptr;
+	/**
+	 * Get the pointer to the mutex. Can be used to lock the data pool
+	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * For now, only friend classes can accss this function.
+	 * @return
+	 */
+	MutexIF* getMutexHandle();
+
+	/**
+	 * Read a variable by supplying its local pool ID and assign the pool
+	 * entry to the supplied PoolEntry pointer. The type of the pool entry
+	 * is deduced automatically. This call is not thread-safe!
+	 * For now, only friend classes like LocalPoolVar may access this
+	 * function.
+	 * @tparam T Type of the pool entry
+	 * @param localPoolId Pool ID of the variable to read
+	 * @param poolVar [out] Corresponding pool entry will be assigned to the
+	 * 						supplied pointer.
+	 * @return
+	 */
+	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
+			PoolEntry<T> **poolEntry);
+
+	void setMinimalSamplingFrequency(float frequencySeconds);
+	ReturnValue_t serializeHkPacketIntoStore(store_address_t* storeId,
+	        LocalDataSet* dataSet);
+};
+
+
+template<class T> inline
+ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
+		PoolEntry<T> **poolEntry) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found." << std::endl;
+		return POOL_ENTRY_NOT_FOUND;
+	}
+
+	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
+	if(*poolEntry == nullptr) {
+		sif::debug << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry not found." << std::endl;
+		return POOL_ENTRY_TYPE_CONFLICT;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 8725f697..163482e3 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -1,106 +1,106 @@
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/datapoollocal/LocalDataSet.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-#include <cmath>
-#include <cstring>
-
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-}
-
-LocalDataSet::~LocalDataSet() {
-}
-
-ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
-}
-
-ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
-}
-
-ReturnValue_t LocalDataSet::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
-}
-
-ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/LocalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+
+#include <cmath>
+#include <cstring>
+
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables) {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSet::LocalDataSet(object_id_t ownerId,
+        const size_t maxNumberOfVariables):
+        DataSetBase(poolVarList.data(), maxNumberOfVariables)  {
+    poolVarList.reserve(maxNumberOfVariables);
+    poolVarList.resize(maxNumberOfVariables);
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            ownerId);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
+                << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+}
+
+LocalDataSet::~LocalDataSet() {
+}
+
+ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+}
+
+ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
+}
+
+ReturnValue_t LocalDataSet::unlockDataPool() {
+	MutexIF* mutex = hkManager->getMutexHandle();
+	return mutex->unlockMutex();
+}
+
+ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
+                    " error!" << std::endl;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataSet::bitSetter(uint8_t* byte, uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 2c70de82..75111d93 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,115 +1,115 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-#include <vector>
-
-class LocalDataPoolManager;
-
-/**
- * @brief	The LocalDataSet class manages a set of locally checked out variables
- * 			for local data pools
- * @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 local data pools,
- * to ensure thread-safety.
- *
- * 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.
- *
- * @ingroup data_pool
- */
-class LocalDataSet: public DataSetBase {
-public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(HasLocalDataPoolIF *hkOwner,
-	        const size_t maxNumberOfVariables);
-
-	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
-	 */
-	LocalDataSet(object_id_t ownerId,
-	        const size_t maxNumberOfVariables);
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalDataSet();
-
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-protected:
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	LocalDataPoolManager* hkManager;
-
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-
-	std::vector<PoolVariableIF*> poolVarList;
-};
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
+#include "../datapool/DataSetBase.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../serialize/SerializeIF.h"
+
+#include <vector>
+
+class LocalDataPoolManager;
+
+/**
+ * @brief	The LocalDataSet class manages a set of locally checked out variables
+ * 			for local data pools
+ * @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 local data pools,
+ * to ensure thread-safety.
+ *
+ * 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.
+ *
+ * @ingroup data_pool
+ */
+class LocalDataSet: public DataSetBase {
+public:
+	/**
+	 * @brief	Constructor for the creator of local pool data.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet(HasLocalDataPoolIF *hkOwner,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	Constructor for users of local pool data. The passed pool
+	 * 			owner should implement the HasHkPoolParametersIF.
+	 * 			The constructor simply sets the fill_count to zero and sets
+	 *  		the state to "uninitialized".
+	 */
+	LocalDataSet(object_id_t ownerId,
+	        const size_t maxNumberOfVariables);
+
+	/**
+	 * @brief	The destructor automatically manages writing the valid
+	 * 			information of variables.
+	 * @details
+	 * In case the data set was read out, but not committed(indicated by state),
+	 * the destructor parses all variables that are still registered to the set.
+	 * For each, the valid flag in the data pool is set to "invalid".
+	 */
+	~LocalDataSet();
+
+	/**
+	 * Special version of the serilization function which appends a
+	 * validity buffer at the end. Each bit of this validity buffer
+	 * denotes whether the container data set entries are valid from left
+	 * to right, MSB first.
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param bigEndian
+	 * @param withValidityBuffer
+	 * @return
+	 */
+	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+
+	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+	        size_t* size, size_t maxSize,
+	        SerializeIF::Endianness streamEndianness) const;
+protected:
+private:
+	/**
+	 * If the valid state of a dataset is always relevant to the whole
+	 * data set we can use this flag.
+	 */
+	bool valid = false;
+
+	/**
+	 * @brief	This is a small helper function to facilitate locking
+	 * 			the global data pool.
+	 * @details
+	 * It makes use of the lockDataPool method offered by the DataPool class.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	/**
+	 * @brief	This is a small helper function to facilitate
+	 * 			unlocking the global data pool
+	 * @details
+	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
+	 */
+	ReturnValue_t unlockDataPool() override;
+
+	LocalDataPoolManager* hkManager;
+
+	/**
+	 * Set n-th bit of a byte, with n being the position from 0
+	 * (most significant bit) to 7 (least significant bit)
+	 */
+	void bitSetter(uint8_t* byte, uint8_t position) const;
+
+	std::vector<PoolVariableIF*> poolVarList;
+};
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 73d691d7..efebdaef 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,173 +1,173 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/serialize/SerializeAdapter.h>
-
-/**
- * @brief 	Local Pool Variable class which is used to access the local pools.
- * @details
- * This class is not stored in the map. Instead, it is used to access
- * the pool entries by using a pointer to the map storing the pool
- * entries. It can also be used to organize these pool entries into data sets.
- *
- * @tparam T The template parameter sets the type of the variable. Currently,
- * all plain data types are supported, but in principle  any type is possible.
- * @ingroup data_pool
- */
-template<typename T>
-class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
-
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner object ID of the pool owner.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	virtual~ LocalPoolVar() {};
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	pool_rwm_t getReadWriteMode() const override;
-
-	lp_id_t getDataPoolId() const override;
-	void setDataPoolId(lp_id_t poolId);
-
-	bool isValid() const override;
-	void setValid(bool validity) override;
-	uint8_t getValid() const;
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 *
-	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	// std::ostream is the type for object std::cout
-	template <typename U>
-	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
-
-private:
-	//! @brief 	Pool ID of pool entry inside the used local pool.
-	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
-	//! @brief 	Read-write mode of the pool variable
-	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-	//! @brief 	Specifies whether the entry is valid or invalid.
-	bool valid = false;
-
-	//! Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-};
-
-#include <framework/datapoollocal/LocalPoolVariable.tpp>
-
-template<class T>
-using lp_var_t = LocalPoolVar<T>;
-
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
-
-#endif
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/DataSetIF.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
+ */
+template<typename T>
+class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	//! Default ctor is forbidden.
+	LocalPoolVar() = delete;
+
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 *
+	 * It does not fetch the current value from the data pool, which
+	 * has to be done by calling the read() operation.
+	 * Datasets can be used to access multiple local pool entries in an
+	 * efficient way. A pointer to a dataset can be passed to register
+	 * the pool variable in that dataset directly.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner object ID of the pool owner.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	virtual~ LocalPoolVar() {};
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	pool_rwm_t getReadWriteMode() const override;
+
+	lp_id_t getDataPoolId() const override;
+	void setDataPoolId(lp_id_t poolId);
+
+	bool isValid() const override;
+	void setValid(bool validity) override;
+	uint8_t getValid() const;
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 *
+	 */
+	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	// std::ostream is the type for object std::cout
+	template <typename U>
+	friend std::ostream& operator<< (std::ostream &out,
+			const LocalPoolVar<U> &var);
+
+private:
+	//! @brief 	Pool ID of pool entry inside the used local pool.
+	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
+	//! @brief 	Read-write mode of the pool variable
+	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+	//! @brief 	Specifies whether the entry is valid or invalid.
+	bool valid = false;
+
+	//! Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+};
+
+#include "../datapoollocal/LocalPoolVariable.tpp"
+
+template<class T>
+using lp_var_t = LocalPoolVar<T>;
+
+using lp_bool_t = LocalPoolVar<uint8_t>;
+using lp_uint8_t = LocalPoolVar<uint8_t>;
+using lp_uint16_t = LocalPoolVar<uint16_t>;
+using lp_uint32_t = LocalPoolVar<uint32_t>;
+using lp_uint64_t = LocalPoolVar<uint64_t>;
+using lp_int8_t = LocalPoolVar<int8_t>;
+using lp_int16_t = LocalPoolVar<int16_t>;
+using lp_int32_t = LocalPoolVar<int32_t>;
+using lp_int64_t = LocalPoolVar<int64_t>;
+using lp_float_t = LocalPoolVar<float>;
+using lp_double_t = LocalPoolVar<double>;
+
+#endif
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 3083646f..8c3c50db 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,200 +1,200 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-
-#include <framework/datapool/DataSetIF.h>
-#include <framework/datapool/PoolEntry.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
-public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
-	T& operator [](int i);
-	const T &operator [](int i) const;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
-
-
-};
-
-#include <framework/datapoollocal/LocalPoolVector.tpp>
-
-template<typename T, uint16_t vectorSize>
-using lp_vec_t = LocalPoolVector<T, vectorSize>;
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T& operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
+
+
+};
+
+#include "../datapoollocal/LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.cpp b/datapoollocal/StaticLocalDataSet.cpp
index 15d4251a..c845a0d1 100644
--- a/datapoollocal/StaticLocalDataSet.cpp
+++ b/datapoollocal/StaticLocalDataSet.cpp
@@ -1,6 +1,6 @@
-#include <framework/datapoollocal/StaticLocalDataSet.h>
-
-
-
-
-
+#include "../datapoollocal/StaticLocalDataSet.h"
+
+
+
+
+
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 15a79aae..add9c48c 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#include <framework/datapool/DataSetBase.h>
-
-
-class StaticLocalDataSet: public DataSetBase {
-
-};
-
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#include "../datapool/DataSetBase.h"
+
+
+class StaticLocalDataSet: public DataSetBase {
+
+};
+
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index fcf5237d..d7e11714 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * This interface is used by the device handler to send a device response
- * to the queue ID, which is returned in the implemented abstract method.
- */
-class AcceptsDeviceResponsesIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~AcceptsDeviceResponsesIF() {}
-	virtual MessageQueueId_t getDeviceQueue() = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
+class AcceptsDeviceResponsesIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index f5657327..c98a9f67 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,273 +1,273 @@
-#include <framework/devicehandlers/AssemblyBase.h>
-
-AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
-		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
-		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
-		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
-		targetSubmode(SUBMODE_NONE) {
-	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
-}
-
-AssemblyBase::~AssemblyBase() {
-}
-
-ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
-	return handleHealthReply(message);
-}
-
-void AssemblyBase::performChildOperation() {
-	if (isInTransition()) {
-		handleChildrenTransition();
-	} else {
-		handleChildrenChanged();
-	}
-}
-
-void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
-	doStartTransition(mode, submode);
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, mode, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, mode, submode);
-	}
-}
-
-void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
-	targetMode = mode;
-	targetSubmode = submode;
-	internalState = STATE_SINGLE_STEP;
-	ReturnValue_t result = commandChildren(mode, submode);
-	if (result == NEED_SECOND_STEP) {
-		internalState = STATE_NEED_SECOND_STEP;
-	}
-}
-
-bool AssemblyBase::isInTransition() {
-	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
-}
-
-bool AssemblyBase::handleChildrenChanged() {
-	if (childrenChangedMode) {
-		ReturnValue_t result = checkChildrenState();
-		if (result != RETURN_OK) {
-			handleChildrenLostMode(result);
-		}
-		return true;
-	} else {
-		return handleChildrenChangedHealth();
-	}
-}
-
-void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
-	triggerEvent(CANT_KEEP_MODE, mode, submode);
-	startTransition(MODE_OFF, SUBMODE_NONE);
-}
-
-bool AssemblyBase::handleChildrenChangedHealth() {
-	auto iter = childrenMap.begin();
-	for (; iter != childrenMap.end(); iter++) {
-		if (iter->second.healthChanged) {
-			iter->second.healthChanged = false;
-			break;
-		}
-	}
-	if (iter == childrenMap.end()) {
-		return false;
-	}
-	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
-	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-		triggerEvent(TRYING_RECOVERY);
-		recoveryState = RECOVERY_STARTED;
-		recoveringDevice = iter;
-		doStartTransition(targetMode, targetSubmode);
-	} else {
-		triggerEvent(CHILD_CHANGED_HEALTH);
-		doStartTransition(mode, submode);
-	}
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
-	}
-	return true;
-}
-
-void AssemblyBase::handleChildrenTransition() {
-	if (commandsOutstanding <= 0) {
-		switch (internalState) {
-		case STATE_NEED_SECOND_STEP:
-			internalState = STATE_SECOND_STEP;
-			commandChildren(targetMode, targetSubmode);
-			return;
-		case STATE_OVERWRITE_HEALTH: {
-			internalState = STATE_SINGLE_STEP;
-			ReturnValue_t result = commandChildren(mode, submode);
-			if (result == NEED_SECOND_STEP) {
-				internalState = STATE_NEED_SECOND_STEP;
-			}
-			return;
-		}
-		case STATE_NONE:
-			//Valid state, used in recovery.
-		case STATE_SINGLE_STEP:
-		case STATE_SECOND_STEP:
-			if (checkAndHandleRecovery()) {
-				return;
-			}
-			break;
-		}
-		ReturnValue_t result = checkChildrenState();
-		if (result == RETURN_OK) {
-			handleModeReached();
-		} else {
-			handleModeTransitionFailed(result);
-		}
-	}
-}
-
-void AssemblyBase::handleModeReached() {
-	internalState = STATE_NONE;
-	setMode(targetMode, targetSubmode);
-}
-
-void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
-//always accept transition to OFF, there is nothing we can do except sending an info event
-//In theory this should never happen, but we would risk an infinite loop otherwise
-	if (targetMode == MODE_OFF) {
-		triggerEvent(CHILD_PROBLEMS, result);
-		internalState = STATE_NONE;
-		setMode(targetMode, targetSubmode);
-	} else {
-		if (handleChildrenChangedHealth()) {
-			//If any health change is pending, handle that first.
-			return;
-		}
-		triggerEvent(MODE_TRANSITION_FAILED, result);
-		startTransition(MODE_OFF, SUBMODE_NONE);
-	}
-}
-
-void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
-		HealthState health) {
-	CommandMessage command;
-	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
-			health);
-	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
-		commandsOutstanding++;
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenState() {
-	if (targetMode == MODE_OFF) {
-		return checkChildrenStateOff();
-	} else {
-		return checkChildrenStateOn(targetMode, targetSubmode);
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (const auto& childIter: childrenMap) {
-		if (checkChildOff(childIter.first) != RETURN_OK) {
-			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
-	ChildInfo childInfo = childrenMap.find(objectId)->second;
-	if (healthHelper.healthTable->isCommandable(objectId)) {
-		if (childInfo.submode != SUBMODE_NONE) {
-			return RETURN_FAILED;
-		} else {
-			if ((childInfo.mode != MODE_OFF)
-					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
-				return RETURN_FAILED;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
-
-//always accept transition to OFF
-	if (mode == MODE_OFF) {
-		if (submode != SUBMODE_NONE) {
-			return INVALID_SUBMODE;
-		}
-		return RETURN_OK;
-	}
-
-	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
-		return INVALID_MODE;
-	}
-
-	if (internalState != STATE_NONE) {
-		return IN_TRANSITION;
-	}
-
-	return isModeCombinationValid(mode, submode);
-}
-
-ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
-	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			updateChildChangedHealth(message->getSender(), true);
-		}
-		return RETURN_OK;
-	}
-	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
-			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
-					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
-		if (isInTransition()) {
-			commandsOutstanding--;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
-
-bool AssemblyBase::checkAndHandleRecovery() {
-	switch (recoveryState) {
-	case RECOVERY_STARTED:
-		recoveryState = RECOVERY_WAIT;
-		recoveryOffTimer.resetTimer();
-		return true;
-	case RECOVERY_WAIT:
-		if (recoveryOffTimer.isBusy()) {
-			return true;
-		}
-		triggerEvent(RECOVERY_STEP, 0);
-		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
-		internalState = STATE_NONE;
-		recoveryState = RECOVERY_ONGOING;
-		//Don't check state!
-		return true;
-	case RECOVERY_ONGOING:
-		triggerEvent(RECOVERY_STEP, 1);
-		recoveryState = RECOVERY_ONGOING_2;
-		recoveringDevice->second.healthChanged = false;
-		//Device should be healthy again, so restart a transition.
-		//Might be including second step, but that's already handled.
-		doStartTransition(targetMode, targetSubmode);
-		return true;
-	case RECOVERY_ONGOING_2:
-		triggerEvent(RECOVERY_DONE);
-		//Now we're through, but not sure if it was successful.
-		recoveryState = RECOVERY_IDLE;
-		return false;
-	case RECOVERY_IDLE:
-	default:
-		return false;
-	}
-}
-
-void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
-		HasHealthIF::HealthState oldHealth) {
-	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
-	internalState = STATE_OVERWRITE_HEALTH;
-	modeHelper.setForced(true);
-	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
-}
+#include "../devicehandlers/AssemblyBase.h"
+
+AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
+		uint16_t commandQueueDepth) :
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
+	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
+}
+
+AssemblyBase::~AssemblyBase() {
+}
+
+ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
+	return handleHealthReply(message);
+}
+
+void AssemblyBase::performChildOperation() {
+	if (isInTransition()) {
+		handleChildrenTransition();
+	} else {
+		handleChildrenChanged();
+	}
+}
+
+void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
+	doStartTransition(mode, submode);
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, mode, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, mode, submode);
+	}
+}
+
+void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
+	targetMode = mode;
+	targetSubmode = submode;
+	internalState = STATE_SINGLE_STEP;
+	ReturnValue_t result = commandChildren(mode, submode);
+	if (result == NEED_SECOND_STEP) {
+		internalState = STATE_NEED_SECOND_STEP;
+	}
+}
+
+bool AssemblyBase::isInTransition() {
+	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
+}
+
+bool AssemblyBase::handleChildrenChanged() {
+	if (childrenChangedMode) {
+		ReturnValue_t result = checkChildrenState();
+		if (result != RETURN_OK) {
+			handleChildrenLostMode(result);
+		}
+		return true;
+	} else {
+		return handleChildrenChangedHealth();
+	}
+}
+
+void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
+	triggerEvent(CANT_KEEP_MODE, mode, submode);
+	startTransition(MODE_OFF, SUBMODE_NONE);
+}
+
+bool AssemblyBase::handleChildrenChangedHealth() {
+	auto iter = childrenMap.begin();
+	for (; iter != childrenMap.end(); iter++) {
+		if (iter->second.healthChanged) {
+			iter->second.healthChanged = false;
+			break;
+		}
+	}
+	if (iter == childrenMap.end()) {
+		return false;
+	}
+	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
+	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
+		triggerEvent(TRYING_RECOVERY);
+		recoveryState = RECOVERY_STARTED;
+		recoveringDevice = iter;
+		doStartTransition(targetMode, targetSubmode);
+	} else {
+		triggerEvent(CHILD_CHANGED_HEALTH);
+		doStartTransition(mode, submode);
+	}
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
+	}
+	return true;
+}
+
+void AssemblyBase::handleChildrenTransition() {
+	if (commandsOutstanding <= 0) {
+		switch (internalState) {
+		case STATE_NEED_SECOND_STEP:
+			internalState = STATE_SECOND_STEP;
+			commandChildren(targetMode, targetSubmode);
+			return;
+		case STATE_OVERWRITE_HEALTH: {
+			internalState = STATE_SINGLE_STEP;
+			ReturnValue_t result = commandChildren(mode, submode);
+			if (result == NEED_SECOND_STEP) {
+				internalState = STATE_NEED_SECOND_STEP;
+			}
+			return;
+		}
+		case STATE_NONE:
+			//Valid state, used in recovery.
+		case STATE_SINGLE_STEP:
+		case STATE_SECOND_STEP:
+			if (checkAndHandleRecovery()) {
+				return;
+			}
+			break;
+		}
+		ReturnValue_t result = checkChildrenState();
+		if (result == RETURN_OK) {
+			handleModeReached();
+		} else {
+			handleModeTransitionFailed(result);
+		}
+	}
+}
+
+void AssemblyBase::handleModeReached() {
+	internalState = STATE_NONE;
+	setMode(targetMode, targetSubmode);
+}
+
+void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
+//always accept transition to OFF, there is nothing we can do except sending an info event
+//In theory this should never happen, but we would risk an infinite loop otherwise
+	if (targetMode == MODE_OFF) {
+		triggerEvent(CHILD_PROBLEMS, result);
+		internalState = STATE_NONE;
+		setMode(targetMode, targetSubmode);
+	} else {
+		if (handleChildrenChangedHealth()) {
+			//If any health change is pending, handle that first.
+			return;
+		}
+		triggerEvent(MODE_TRANSITION_FAILED, result);
+		startTransition(MODE_OFF, SUBMODE_NONE);
+	}
+}
+
+void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
+		HealthState health) {
+	CommandMessage command;
+	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
+			health);
+	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
+		commandsOutstanding++;
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenState() {
+	if (targetMode == MODE_OFF) {
+		return checkChildrenStateOff();
+	} else {
+		return checkChildrenStateOn(targetMode, targetSubmode);
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenStateOff() {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
+			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
+	ChildInfo childInfo = childrenMap.find(objectId)->second;
+	if (healthHelper.healthTable->isCommandable(objectId)) {
+		if (childInfo.submode != SUBMODE_NONE) {
+			return RETURN_FAILED;
+		} else {
+			if ((childInfo.mode != MODE_OFF)
+					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
+				return RETURN_FAILED;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t* msToReachTheMode) {
+
+//always accept transition to OFF
+	if (mode == MODE_OFF) {
+		if (submode != SUBMODE_NONE) {
+			return INVALID_SUBMODE;
+		}
+		return RETURN_OK;
+	}
+
+	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
+		return INVALID_MODE;
+	}
+
+	if (internalState != STATE_NONE) {
+		return IN_TRANSITION;
+	}
+
+	return isModeCombinationValid(mode, submode);
+}
+
+ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
+	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			updateChildChangedHealth(message->getSender(), true);
+		}
+		return RETURN_OK;
+	}
+	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
+			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
+					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
+		if (isInTransition()) {
+			commandsOutstanding--;
+		}
+		return RETURN_OK;
+	}
+	return RETURN_FAILED;
+}
+
+bool AssemblyBase::checkAndHandleRecovery() {
+	switch (recoveryState) {
+	case RECOVERY_STARTED:
+		recoveryState = RECOVERY_WAIT;
+		recoveryOffTimer.resetTimer();
+		return true;
+	case RECOVERY_WAIT:
+		if (recoveryOffTimer.isBusy()) {
+			return true;
+		}
+		triggerEvent(RECOVERY_STEP, 0);
+		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
+		internalState = STATE_NONE;
+		recoveryState = RECOVERY_ONGOING;
+		//Don't check state!
+		return true;
+	case RECOVERY_ONGOING:
+		triggerEvent(RECOVERY_STEP, 1);
+		recoveryState = RECOVERY_ONGOING_2;
+		recoveringDevice->second.healthChanged = false;
+		//Device should be healthy again, so restart a transition.
+		//Might be including second step, but that's already handled.
+		doStartTransition(targetMode, targetSubmode);
+		return true;
+	case RECOVERY_ONGOING_2:
+		triggerEvent(RECOVERY_DONE);
+		//Now we're through, but not sure if it was successful.
+		recoveryState = RECOVERY_IDLE;
+		return false;
+	case RECOVERY_IDLE:
+	default:
+		return false;
+	}
+}
+
+void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
+		HasHealthIF::HealthState oldHealth) {
+	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
+	internalState = STATE_OVERWRITE_HEALTH;
+	modeHelper.setForced(true);
+	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
+}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index d0dc868c..7c66b21d 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,163 +1,163 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-/**
- * @brief   Base class to implement reconfiguration and failure handling for
- *          redundant devices by monitoring their modes health states.
- * @details
- * Documentation: Dissertation Baetz p.156, 157.
- *
- * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices.
- *
- * The template class monitors mode and health state of its children
- * and checks availability of devices on every detected change.
- * AssemblyBase does not implement any redundancy logic by itself, but provides
- * adaptation points for implementations to do so. Since most monitoring
- * activities rely on mode and health state only and are therefore
- * generic, it is sufficient for subclasses to provide:
- *
- * 1. check logic when active-> checkChildrenStateOn
- * 2. transition logic to change the mode -> commandChildren
- *
- */
-class AssemblyBase: public SubsystemBase {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
-	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
-			MAKE_RETURN_CODE(0xa1);
-
-	AssemblyBase(object_id_t objectId, object_id_t parentId,
-	        uint16_t commandQueueDepth = 8);
-	virtual ~AssemblyBase();
-
-protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
-    /**
-     * Command children to reach [mode,submode] combination
-     * Can be done by setting #commandsOutstanding correctly,
-     * or using executeTable()
-     * @param mode
-     * @param submode
-     * @return
-     *    - @c RETURN_OK if ok
-     *    - @c NEED_SECOND_STEP if children need to be commanded again
-     */
-    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-    /**
-     * Check whether desired assembly mode was achieved by checking the modes
-     * or/and health states of child device handlers.
-     * The assembly template class will also call this function if a health
-     * or mode change of a child device handler was detected.
-     * @param wantedMode
-     * @param wantedSubmode
-     * @return
-     */
-    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-            Submode_t wantedSubmode) = 0;
-
-    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-            Submode_t submode) = 0;
-
-	enum InternalState {
-		STATE_NONE,
-		STATE_OVERWRITE_HEALTH,
-		STATE_NEED_SECOND_STEP,
-		STATE_SINGLE_STEP,
-		STATE_SECOND_STEP,
-	} internalState;
-
-	enum RecoveryState {
-		RECOVERY_IDLE,
-		RECOVERY_STARTED,
-		RECOVERY_ONGOING,
-		RECOVERY_ONGOING_2,
-		RECOVERY_WAIT
-	} recoveryState; //!< Indicates if one of the children requested a recovery.
-	ChildrenMap::iterator recoveringDevice;
-
-	/**
-	 * the mode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedMode!
-	 */
-	Mode_t targetMode;
-
-	/**
-	 * the submode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedSubmode!
-	 */
-	Submode_t targetSubmode;
-
-	Countdown recoveryOffTimer;
-
-	static const uint32_t POWER_OFF_TIME_MS = 1000;
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
-
-	virtual void performChildOperation();
-
-	bool handleChildrenChanged();
-
-	/**
-	 * This method is called if the children changed its mode in a way that
-	 * the current mode can't be kept.
-	 * Default behavior is to go to MODE_OFF.
-	 * @param result The failure code which was returned by checkChildrenState.
-	 */
-	virtual void handleChildrenLostMode(ReturnValue_t result);
-
-	bool handleChildrenChangedHealth();
-
-	virtual void handleChildrenTransition();
-
-	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	virtual void doStartTransition(Mode_t mode, Submode_t submode);
-
-	virtual bool isInTransition();
-
-	virtual void handleModeReached();
-
-	virtual void handleModeTransitionFailed(ReturnValue_t result);
-
-	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
-
-	virtual ReturnValue_t checkChildrenStateOff();
-
-	ReturnValue_t checkChildrenState();
-
-	virtual ReturnValue_t checkChildOff(uint32_t objectId);
-
-	/**
-	 * Manages recovery of a device
-	 * @return true if recovery is still ongoing, false else.
-	 */
-	bool checkAndHandleRecovery();
-
-	/**
-	 * Helper method to overwrite health state of one of the children.
-	 * Also sets state to STATE_OVERWRITE_HEATH.
-	 * @param objectId Must be a registered child.
-	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+
+#include "../container/FixedArrayList.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
+class AssemblyBase: public SubsystemBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
+	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
+			MAKE_RETURN_CODE(0xa1);
+
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
+	virtual ~AssemblyBase();
+
+protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
+	enum InternalState {
+		STATE_NONE,
+		STATE_OVERWRITE_HEALTH,
+		STATE_NEED_SECOND_STEP,
+		STATE_SINGLE_STEP,
+		STATE_SECOND_STEP,
+	} internalState;
+
+	enum RecoveryState {
+		RECOVERY_IDLE,
+		RECOVERY_STARTED,
+		RECOVERY_ONGOING,
+		RECOVERY_ONGOING_2,
+		RECOVERY_WAIT
+	} recoveryState; //!< Indicates if one of the children requested a recovery.
+	ChildrenMap::iterator recoveringDevice;
+
+	/**
+	 * the mode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedMode!
+	 */
+	Mode_t targetMode;
+
+	/**
+	 * the submode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedSubmode!
+	 */
+	Submode_t targetSubmode;
+
+	Countdown recoveryOffTimer;
+
+	static const uint32_t POWER_OFF_TIME_MS = 1000;
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
+
+	virtual void performChildOperation();
+
+	bool handleChildrenChanged();
+
+	/**
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
+	 * Default behavior is to go to MODE_OFF.
+	 * @param result The failure code which was returned by checkChildrenState.
+	 */
+	virtual void handleChildrenLostMode(ReturnValue_t result);
+
+	bool handleChildrenChangedHealth();
+
+	virtual void handleChildrenTransition();
+
+	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	virtual void doStartTransition(Mode_t mode, Submode_t submode);
+
+	virtual bool isInTransition();
+
+	virtual void handleModeReached();
+
+	virtual void handleModeTransitionFailed(ReturnValue_t result);
+
+	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
+
+	virtual ReturnValue_t checkChildrenStateOff();
+
+	ReturnValue_t checkChildrenState();
+
+	virtual ReturnValue_t checkChildOff(uint32_t objectId);
+
+	/**
+	 * Manages recovery of a device
+	 * @return true if recovery is still ongoing, false else.
+	 */
+	bool checkAndHandleRecovery();
+
+	/**
+	 * Helper method to overwrite health state of one of the children.
+	 * Also sets state to STATE_OVERWRITE_HEATH.
+	 * @param objectId Must be a registered child.
+	 */
+	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 2e4428e5..acc1b5a0 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,47 +1,47 @@
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/devicehandlers/ChildHandlerBase.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * cookie,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId,
-		object_id_t parent,
-		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			(customFdir == nullptr? &childHandlerFdir : customFdir),
-			cmdQueueSize),
-		parentId(parent), childHandlerFdir(setObjectId) {
-	this->setHkDestination(hkDestination);
-	this->setThermalStateRequestPoolIds(thermalStatePoolId,
-			thermalRequestPoolId);
-
-}
-
-ChildHandlerBase::~ChildHandlerBase() {
-}
-
-ReturnValue_t ChildHandlerBase::initialize() {
-	ReturnValue_t result = DeviceHandlerBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	healthHelper.setParentQueue(parentQueue);
-
-	modeHelper.setParentQueue(parentQueue);
-
-	return RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../devicehandlers/ChildHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId,
+		object_id_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
+}
+
+ChildHandlerBase::~ChildHandlerBase() {
+}
+
+ReturnValue_t ChildHandlerBase::initialize() {
+	ReturnValue_t result = DeviceHandlerBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	healthHelper.setParentQueue(parentQueue);
+
+	modeHelper.setParentQueue(parentQueue);
+
+	return RETURN_OK;
+}
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index c8ac9541..625955f0 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,24 +1,24 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
-
-#include <framework/devicehandlers/ChildHandlerFDIR.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-
-class ChildHandlerBase: public DeviceHandlerBase {
-public:
-	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, object_id_t hkDestination,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
-	virtual ~ChildHandlerBase();
-
-	virtual ReturnValue_t initialize();
-
-protected:
-	const uint32_t parentId;
-	ChildHandlerFDIR childHandlerFdir;
-
-};
-
-#endif /* PAYLOADHANDLERBASE_H_ */
+#ifndef PAYLOADHANDLERBASE_H_
+#define PAYLOADHANDLERBASE_H_
+
+#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+class ChildHandlerBase: public DeviceHandlerBase {
+public:
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+	virtual ~ChildHandlerBase();
+
+	virtual ReturnValue_t initialize();
+
+protected:
+	const uint32_t parentId;
+	ChildHandlerFDIR childHandlerFdir;
+
+};
+
+#endif /* PAYLOADHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index 1bba47fe..bab5a7e5 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,10 +1,10 @@
-#include <framework/devicehandlers/ChildHandlerFDIR.h>
-
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
-		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
-	recoveryCounter.setFailureThreshold(recoveryCount);
-}
-
-ChildHandlerFDIR::~ChildHandlerFDIR() {
-}
-
+#include "../devicehandlers/ChildHandlerFDIR.h"
+
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
+	recoveryCounter.setFailureThreshold(recoveryCount);
+}
+
+ChildHandlerFDIR::~ChildHandlerFDIR() {
+}
+
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 7df9d238..83f79a63 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-
-/**
- * Very simple extension to normal FDIR.
- * Does not have a default fault tree parent and
- * allows to make the recovery count settable to 0.
- */
-class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
-public:
-	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
-			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
-	virtual ~ChildHandlerFDIR();
-protected:
-	static const object_id_t NO_FAULT_TREE_PARENT = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
+/**
+ * Very simple extension to normal FDIR.
+ * Does not have a default fault tree parent and
+ * allows to make the recovery count settable to 0.
+ */
+class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
+public:
+	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
+			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
+	virtual ~ChildHandlerFDIR();
+protected:
+	static const object_id_t NO_FAULT_TREE_PARENT = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index a80e7de1..aacf5580 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -4,8 +4,8 @@
  * @date 28.02.2020
  */
 
-#include <framework/devicehandlers/CommunicationMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../devicehandlers/CommunicationMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include <cstring>
 
 CommunicationMessage::CommunicationMessage(): uninitialized(true) {
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index 95266319..a31e270c 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -6,11 +6,11 @@
 
 #ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
 #define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include <framework/devicehandlers/CommunicationMessage.h>
+#include "../devicehandlers/CommunicationMessage.h"
 
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerBase.h>
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
 
 /**
  * @brief Message type to send larger messages
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index a2662d46..cbff5411 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,127 +1,127 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- * @defgroup interfaces Interfaces
- * @brief Interfaces for flight software objects
- */
-
-/**
- * @defgroup comm Communication
- * @brief Communication software components.
- */
-
-/**
- * @brief This is an interface to decouple device communication from
- * the device handler to allow reuse of these components.
- * @details
- * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data  is polled by a component.
- * There are four generic steps of device communication:
- *
- *   1. Send data to a device
- *   2. Get acknowledgement for sending
- *   3. Request reading data from a device
- *   4. Read received data
- *
- *  To identify different connection over a single interface can return
- *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the
- *  functionality of the ComIF if a separate polling task is required.
- *  @ingroup interfaces
- *  @ingroup comm
- */
-class DeviceCommunicationIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
-
-	//! This is returned in readReceivedMessage() if no reply was reived.
-	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
-
-	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
-	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
-	// is this needed if there is no open/close call?
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
-
-	virtual ~DeviceCommunicationIF() {}
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return
-	 *  - @c RETURN_OK if initialization was successfull
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len If this is 0, nothing shall be sent.
-	 * @return
-	 *  - @c RETURN_OK for successfull send
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie,
-	        const uint8_t * sendData, size_t sendLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return - @c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with
-	 * 		     returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
-	 * and communication specific action should be taken (e.g. read nothing
-	 * or read everything).
-	 *
-	 * @param cookie
-	 * @param requestLen Size of data to read
-	 * @return - @c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param buffer [out] Set reply here (by using *buffer = ...)
-	 * @param size [out] size pointer to set (by using *size = ...).
-	 * 	           Set to 0 if no reply was received
-	 * @return - @c RETURN_OK for successfull receive
-	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
-	 * 		   	   0 has the same effect
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-	        uint8_t **buffer, size_t *size) = 0;
-};
-
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
+class DeviceCommunicationIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
+
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+
+	virtual ~DeviceCommunicationIF() {}
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len If this is 0, nothing shall be sent.
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
+	 * @param cookie
+	 * @param requestLen Size of data to read
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
+};
+
+#endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a4346afb..06b26595 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,1397 +1,1397 @@
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/globalfunctions/CRC.h>
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-#include <iomanip>
-
-object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
-
-DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * comCookie,
-		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
-		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
-		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
-		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
-		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this, nullptr),
-		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
-		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
-		switchOffWasReported(false), childTransitionDelay(5000),
-		transitionSourceMode(_MODE_POWER_DOWN),
-		transitionSourceSubMode(SUBMODE_NONE) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-	insertInCommandMap(RAW_COMMAND_ID);
-	cookieInfo.state = COOKIE_UNUSED;
-	cookieInfo.pendingCommand = deviceCommandMap.end();
-	if (comCookie == nullptr) {
-		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << this->getObjectId()
-				<< std::dec << ": Do not pass nullptr as a cookie, consider "
-				<< std::setfill(' ') << "passing a dummy cookie instead!"
-				<< std::endl;
-	}
-	if (this->fdirInstance == nullptr) {
-		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
-				defaultFdirParentId);
-	}
-}
-
-void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
-	this->hkDestination = hkDestination;
-}
-
-void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
-	this->deviceThermalRequestPoolId = thermalStatePoolId;
-	this->deviceThermalRequestPoolId = thermalRequestPoolId;
-}
-
-
-DeviceHandlerBase::~DeviceHandlerBase() {
-	delete comCookie;
-	if (defaultFDIRUsed) {
-		delete fdirInstance;
-	}
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
-	this->pstStep = counter;
-
-	if (getComAction() == SEND_WRITE) {
-		cookieInfo.state = COOKIE_UNUSED;
-		readCommandQueue();
-		doStateMachine();
-		checkSwitchState();
-		decrementDeviceReplyMap();
-		fdirInstance->checkForFailures();
-		hkSwitcher.performOperation();
-		performOperationHook();
-	}
-	if (mode == MODE_OFF) {
-		return RETURN_OK;
-	}
-	switch (getComAction()) {
-	case SEND_WRITE:
-		if ((cookieInfo.state == COOKIE_UNUSED)) {
-			buildInternalCommand();
-		}
-		doSendWrite();
-		break;
-	case GET_WRITE:
-		doGetWrite();
-		break;
-	case SEND_READ:
-		doSendRead();
-		break;
-	case GET_READ:
-		doGetRead();
-		cookieInfo.state = COOKIE_UNUSED;
-		break;
-	default:
-		break;
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DeviceHandlerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	communicationInterface = objectManager->get<DeviceCommunicationIF>(
-			deviceCommunicationId);
-	if (communicationInterface == nullptr) {
-		sif::error << "DeviceHandlerBase::initialize: Communication interface "
-				"invalid." << std::endl;
-		sif::error << "Make sure it is set up properly and implements"
-				" DeviceCommunicationIF" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	result = communicationInterface->initializeInterface(comCookie);
-	if (result != RETURN_OK) {
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-	    return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == nullptr) {
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	if(rawDataReceiverId != objects::NO_OBJECT) {
-		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(rawDataReceiverId);
-
-		if (rawReceiver == nullptr) {
-			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
-					"ID set but no valid object found." << std::endl;
-			sif::error << "Make sure the raw receiver object is set up properly"
-					" and implements AcceptsDeviceResponsesIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-		defaultRawReceiver = rawReceiver->getDeviceQueue();
-	}
-
-	if(powerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
-		if (powerSwitcher == nullptr) {
-			sif::error << "DeviceHandlerBase::initialize: Power switcher "
-					<< "object ID set but no valid object found." << std::endl;
-			sif::error << "Make sure the raw receiver object is set up properly"
-					<< " and implements PowerSwitchIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
-
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-	    return result;
-	}
-
-	result = modeHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = actionHelper.initialize(commandQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = fdirInstance->initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = hkSwitcher.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	fillCommandAndReplyMap();
-
-	//Set temperature target state to NON_OP.
-	GlobDataSet mySet;
-	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
-
-	return RETURN_OK;
-
-}
-
-void DeviceHandlerBase::decrementDeviceReplyMap() {
-	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
-		if (iter->second.delayCycles != 0) {
-			iter->second.delayCycles--;
-			if (iter->second.delayCycles == 0) {
-				if (iter->second.periodic) {
-					iter->second.delayCycles = iter->second.maxDelayCycles;
-				}
-				replyToReply(iter, TIMEOUT);
-				missedReply(iter->first);
-			}
-		}
-	}
-}
-
-void DeviceHandlerBase::readCommandQueue() {
-
-	if (dontCheckQueue()) {
-		return;
-	}
-
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != RETURN_OK) {
-		return;
-	}
-
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == RETURN_OK) {
-	    return;
-	}
-
-	result = modeHelper.handleModeCommand(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = actionHelper.handleActionMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = hkManager.handleHousekeepingMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = handleDeviceHandlerMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	result = letChildHandleMessage(&command);
-	if (result == RETURN_OK) {
-		return;
-	}
-
-	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
-
-}
-
-void DeviceHandlerBase::doStateMachine() {
-	switch (mode) {
-	case _MODE_START_UP:
-	case _MODE_SHUT_DOWN:
-	case _MODE_TO_NORMAL:
-	case _MODE_TO_ON:
-	case _MODE_TO_RAW: {
-		Mode_t currentMode = mode;
-		callChildStatemachine();
-		//Only do timeout if child did not change anything
-		if (mode != currentMode) {
-			break;
-		}
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (currentUptime - timeoutStart >= childTransitionDelay) {
-			triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
-			setMode(transitionSourceMode, transitionSourceSubMode);
-			break;
-		}
-	}
-		break;
-	case _MODE_POWER_DOWN:
-		commandSwitch(PowerSwitchIF::SWITCH_OFF);
-		setMode(_MODE_WAIT_OFF);
-		break;
-	case _MODE_POWER_ON:
-		commandSwitch(PowerSwitchIF::SWITCH_ON);
-		setMode(_MODE_WAIT_ON);
-		break;
-	case _MODE_WAIT_ON: {
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
-				powerSwitcher->getSwitchDelayMs()) {
-			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
-					0);
-			setMode(_MODE_POWER_DOWN);
-			callChildStatemachine();
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_ON)
-				|| (switchState == NO_SWITCH)) {
-			//NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_START_UP);
-			callChildStatemachine();
-		}
-	}
-		break;
-	case _MODE_WAIT_OFF: {
-		uint32_t currentUptime;
-		Clock::getUptime(&currentUptime);
-
-		if(powerSwitcher == nullptr) {
-		    setMode(MODE_OFF);
-		    break;
-		}
-
-		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
-			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
-					0);
-			setMode(MODE_ERROR_ON);
-			break;
-		}
-		ReturnValue_t switchState = getStateOfSwitches();
-		if ((switchState == PowerSwitchIF::SWITCH_OFF)
-				|| (switchState == NO_SWITCH)) {
-			setMode(_MODE_SWITCH_IS_OFF);
-		}
-	}
-		break;
-	case MODE_OFF:
-		doOffActivity();
-		break;
-	case MODE_ON:
-		doOnActivity();
-		break;
-	case MODE_RAW:
-	case MODE_NORMAL:
-	case MODE_ERROR_ON:
-		break;
-	case _MODE_SWITCH_IS_OFF:
-		setMode(MODE_OFF, SUBMODE_NONE);
-		break;
-	default:
-		triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
-		setMode(_MODE_POWER_DOWN, 0);
-		break;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
-		Submode_t submode) {
-	switch (mode) {
-	case MODE_OFF:
-	case MODE_ON:
-	case MODE_NORMAL:
-	case MODE_RAW:
-		if (submode == SUBMODE_NONE) {
-			return RETURN_OK;
-		} else {
-			return INVALID_SUBMODE;
-		}
-	default:
-		return HasModesIF::INVALID_MODE;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
-		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		size_t replyLen, bool periodic, bool hasDifferentReplyId,
-		DeviceCommandId_t replyId) {
-	//No need to check, as we may try to insert multiple times.
-	insertInCommandMap(deviceCommand);
-	if (hasDifferentReplyId) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
-	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
-	DeviceReplyInfo info;
-	info.maxDelayCycles = maxDelayCycles;
-	info.periodic = periodic;
-	info.delayCycles = 0;
-	info.replyLen = replyLen;
-	info.command = deviceCommandMap.end();
-	auto resultPair = deviceReplyMap.emplace(replyId, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::insertInCommandMap(
-		DeviceCommandId_t deviceCommand) {
-	DeviceCommandInfo info;
-	info.expectedReplies = 0;
-	info.isExecuting = false;
-	info.sendReplyTo = NO_COMMANDER;
-	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
-	if (resultPair.second) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
-		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
-		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
-		return RETURN_FAILED;
-	} else {
-		DeviceReplyInfo *info = &(iter->second);
-		if (maxDelayCycles != 0) {
-			info->maxDelayCycles = maxDelayCycles;
-		}
-		info->delayCycles = delayCycles;
-		info->periodic = periodic;
-		return RETURN_OK;
-	}
-}
-
-void DeviceHandlerBase::callChildStatemachine() {
-	if (mode == _MODE_START_UP) {
-		doStartUp();
-	} else if (mode == _MODE_SHUT_DOWN) {
-		doShutDown();
-	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		doTransition(transitionSourceMode, transitionSourceSubMode);
-	}
-}
-
-void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
-	triggerEvent(CHANGING_MODE, modeTo, submodeTo);
-	childTransitionDelay = getTransitionDelayMs(mode, modeTo);
-	transitionSourceMode = mode;
-	transitionSourceSubMode = submode;
-	childTransitionFailure = CHILD_TIMEOUT;
-
-	// transitionTargetMode is set by setMode
-	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
-}
-
-void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
-	changeHK(mode, submode, false);
-	submode = newSubmode;
-	mode = newMode;
-	modeChanged();
-	setNormalDatapoolEntriesInvalid();
-	if (!isTransitionalMode()) {
-		modeHelper.modeChanged(newMode, newSubmode);
-		announceMode(false);
-	}
-	Clock::getUptime(&timeoutStart);
-
-	if (mode == MODE_OFF) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-		}
-		mySet.commit(PoolVariableIF::VALID);
-	}
-	changeHK(mode, submode, true);
-}
-
-void DeviceHandlerBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-	//This is actually the reply protocol for raw and misc DH commands.
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
-		commandQueue->reply(&reply);
-	}
-}
-
-void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
-		uint32_t parameter) {
-//Check if we reply to a raw command.
-	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
-		if (status == NO_REPLY_EXPECTED) {
-			status = RETURN_OK;
-		}
-		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
-		IPCStore->deleteData(storedRawData);
-		return;
-	}
-//Check if we were externally commanded.
-	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
-		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
-		if (status == NO_REPLY_EXPECTED) {
-			actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
-					RETURN_OK);
-		} else {
-			actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
-					status);
-		}
-	}
-}
-
-void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
-		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
-	if (iter->second.command == deviceCommandMap.end()) {
-		//Is most likely periodic reply. Silent return.
-		return;
-	}
-//Check if more replies are expected. If so, do nothing.
-	DeviceCommandInfo* info = &(iter->second.command->second);
-	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
-		if (info->sendReplyTo != NO_COMMANDER) {
-			actionHelper.finish(info->sendReplyTo, iter->first, status);
-		}
-		info->isExecuting = false;
-	}
-}
-
-void DeviceHandlerBase::doSendWrite() {
-	if (cookieInfo.state == COOKIE_WRITE_READY) {
-
-		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
-				rawPacket, rawPacketLen);
-
-		if (result == RETURN_OK) {
-			cookieInfo.state = COOKIE_WRITE_SENT;
-		} else {
-			//always generate a failure event, so that FDIR knows what's up
-			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-					cookieInfo.pendingCommand->first);
-			replyToCommand(result);
-			cookieInfo.state = COOKIE_UNUSED;
-			cookieInfo.pendingCommand->second.isExecuting = false;
-		}
-	}
-}
-
-void DeviceHandlerBase::doGetWrite() {
-	if (cookieInfo.state != COOKIE_WRITE_SENT) {
-		return;
-	}
-	cookieInfo.state = COOKIE_UNUSED;
-	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
-	if (result == RETURN_OK) {
-		if (wiretappingMode == RAW) {
-			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
-		}
-
-		//We need to distinguish here, because a raw command never expects a reply.
-		//(Could be done in eRIRM, but then child implementations need to be careful.
-		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
-	} else {
-		//always generate a failure event, so that FDIR knows what's up
-		triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
-				cookieInfo.pendingCommand->first);
-	}
-	if (result != RETURN_OK) {
-		cookieInfo.pendingCommand->second.isExecuting = false;
-	}
-	replyToCommand(result);
-}
-
-void DeviceHandlerBase::doSendRead() {
-	ReturnValue_t result;
-
-	size_t requestLen = 0;
-	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
-		DeviceReplyIter iter = deviceReplyMap.find(
-				cookieInfo.pendingCommand->first);
-		if(iter != deviceReplyMap.end()) {
-			requestLen = iter->second.replyLen;
-		}
-	}
-
-	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
-
-	if (result == RETURN_OK) {
-		cookieInfo.state = COOKIE_READ_SENT;
-	} else {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//We can't inform anyone, because we don't know which command was sent last.
-		//So, we need to wait for a timeout.
-		//but I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		cookieInfo.state = COOKIE_UNUSED;
-	}
-}
-
-void DeviceHandlerBase::doGetRead() {
-	size_t receivedDataLen = 0;
-	uint8_t *receivedData = nullptr;
-
-	if (cookieInfo.state != COOKIE_READ_SENT) {
-		cookieInfo.state = COOKIE_UNUSED;
-		return;
-	}
-
-	cookieInfo.state = COOKIE_UNUSED;
-
-	ReturnValue_t result = communicationInterface->readReceivedMessage(
-			comCookie, &receivedData, &receivedDataLen);
-
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
-		//I think we can allow to ignore one missedReply.
-		ignoreMissedRepliesCount++;
-		return;
-	}
-
-	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
-		return;
-
-	if (wiretappingMode == RAW) {
-		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
-	}
-
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-	}
-	else {
-		parseReply(receivedData, receivedDataLen);
-	}
-}
-
-void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
-		size_t receivedDataLen) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
-	size_t foundLen = 0;
-	// The loop may not execute more often than the number of received bytes
-	// (worst case). This approach avoids infinite loops due to buggy
-	// scanForReply routines.
-	uint32_t remainingLength = receivedDataLen;
-	for (uint32_t count = 0; count < receivedDataLen; count++) {
-		result = scanForReply(receivedData, remainingLength, &foundId,
-				&foundLen);
-		switch (result) {
-		case RETURN_OK:
-			handleReply(receivedData, foundId, foundLen);
-			if(foundLen == 0) {
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-			}
-			break;
-		case APERIODIC_REPLY: {
-			result = interpretDeviceReply(foundId, receivedData);
-			if (result != RETURN_OK) {
-			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
-			            foundId);
-			}
-			if(foundLen == 0) {
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-			}
-			break;
-		}
-		case IGNORE_REPLY_DATA:
-			break;
-		case IGNORE_FULL_PACKET:
-			return;
-		default:
-			//We need to wait for timeout.. don't know what command failed and who sent it.
-			replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
-			break;
-		}
-		receivedData += foundLen;
-		if (remainingLength > foundLen) {
-			remainingLength -= foundLen;
-		} else {
-			return;
-		}
-	}
-}
-
-void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
-		DeviceCommandId_t foundId, uint32_t foundLen) {
-	ReturnValue_t result;
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
-
-	if (iter == deviceReplyMap.end()) {
-		replyRawReplyIfnotWiretapped(receivedData, foundLen);
-		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
-		return;
-	}
-
-	DeviceReplyInfo *info = &(iter->second);
-
-	if (info->delayCycles != 0) {
-
-		if (info->periodic != false) {
-			info->delayCycles = info->maxDelayCycles;
-		}
-		else {
-			info->delayCycles = 0;
-		}
-
-		result = interpretDeviceReply(foundId, receivedData);
-
-		if (result != RETURN_OK) {
-			// Report failed interpretation to FDIR.
-			replyRawReplyIfnotWiretapped(receivedData, foundLen);
-			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
-		}
-		replyToReply(iter, result);
-	}
-	else {
-		// Other completion failure messages are created by timeout.
-		// Powering down the device might take some time during which periodic
-		// replies may still come in.
-		if (mode != _MODE_WAIT_OFF) {
-			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
-		}
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
-		uint8_t** data, uint32_t * len) {
-	size_t lenTmp;
-
-	if (IPCStore == nullptr) {
-		*data = nullptr;
-		*len = 0;
-		return RETURN_FAILED;
-	}
-	ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
-	if (result == RETURN_OK) {
-		*len = lenTmp;
-		return RETURN_OK;
-	} else {
-		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
-				storageAddress.raw);
-		*data = nullptr;
-		*len = 0;
-		return result;
-	}
-}
-
-void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
-		MessageQueueId_t sendTo, bool isCommand) {
-	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
-		return;
-	}
-	store_address_t address;
-	ReturnValue_t result = IPCStore->addData(&address, data, len);
-
-	if (result != RETURN_OK) {
-		triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
-		return;
-	}
-
-	CommandMessage command;
-
-	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
-			getObjectId(), address, isCommand);
-
-	result = commandQueue->sendMessage(sendTo, &command);
-
-	if (result != RETURN_OK) {
-		IPCStore->deleteData(address);
-		// Silently discard data, this indicates heavy TM traffic which
-		// should not be increased by additional events.
-	}
-}
-
-//Default child implementations
-DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
-	switch (pstStep) {
-	case 0:
-		return SEND_WRITE;
-		break;
-	case 1:
-		return GET_WRITE;
-		break;
-	case 2:
-		return SEND_READ;
-		break;
-	case 3:
-		return GET_READ;
-		break;
-	default:
-		break;
-	}
-	return NOTHING;
-}
-
-MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
-	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
-	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
-			&rawPacketLen);
-	if (result != RETURN_OK) {
-		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
-		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
-	} else {
-		cookieInfo.pendingCommand = deviceCommandMap.find(
-				(DeviceCommandId_t) RAW_COMMAND_ID);
-		cookieInfo.pendingCommand->second.isExecuting = true;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
-}
-
-void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
-	if(powerSwitcher == nullptr) {
-		return;
-	}
-	const uint8_t *switches;
-	uint8_t numberOfSwitches = 0;
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if (result == RETURN_OK) {
-		while (numberOfSwitches > 0) {
-			powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
-					onOff);
-			numberOfSwitches--;
-		}
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
-		uint8_t *numberOfSwitches) {
-	return DeviceHandlerBase::NO_SWITCH;
-}
-
-void DeviceHandlerBase::modeChanged(void) {
-}
-
-ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
-		DeviceCommandMap::iterator command, uint8_t expectedReplies,
-		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
-	DeviceReplyMap::iterator iter;
-	if (useAlternativeId) {
-		iter = deviceReplyMap.find(alternativeReply);
-	} else {
-		iter = deviceReplyMap.find(command->first);
-	}
-	if (iter != deviceReplyMap.end()) {
-		DeviceReplyInfo *info = &(iter->second);
-		info->delayCycles = info->maxDelayCycles;
-		info->command = command;
-		command->second.expectedReplies = expectedReplies;
-		return RETURN_OK;
-	} else {
-		return NO_REPLY_EXPECTED;
-	}
-}
-
-void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-	setMode(getBaseMode(mode));
-}
-
-uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
-		Mode_t modeTo) {
-	return 0;
-}
-
-ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
-	if(powerSwitcher == nullptr) {
-		return NO_SWITCH;
-	}
-	uint8_t numberOfSwitches = 0;
-	const uint8_t *switches;
-
-	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
-	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
-		while (numberOfSwitches > 0) {
-			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
-					== PowerSwitchIF::SWITCH_OFF) {
-				return PowerSwitchIF::SWITCH_OFF;
-			}
-			numberOfSwitches--;
-		}
-		return PowerSwitchIF::SWITCH_ON;
-	}
-
-	return NO_SWITCH;
-}
-
-Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
-	if (transitionMode == _MODE_START_UP) {
-		return _MODE_TO_ON;
-	}
-	if (transitionMode == _MODE_SHUT_DOWN) {
-		return _MODE_POWER_DOWN;
-	}
-	return transitionMode
-			& ~(TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK);
-}
-
-//SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the way, throw away DHB and write a new one:
-// - Include power and thermal completely, but more modular :-)
-// - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
-// - Modularization?
-ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
-		Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
-	if (isTransitionalMode()) {
-		return IN_TRANSITION;
-	}
-	if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
-	if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
-		return TRANS_NOT_ALLOWED;
-	}
-
-	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			if (!ThermalComponentIF::isOperational(thermalState)) {
-				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalState);
-				return NON_OP_TEMPERATURE;
-			}
-		}
-	}
-
-	return isModeCombinationValid(commandedMode, commandedSubmode);
-}
-
-void DeviceHandlerBase::startTransition(Mode_t commandedMode,
-		Submode_t commandedSubmode) {
-	switch (commandedMode) {
-	case MODE_ON:
-		if (mode == MODE_OFF) {
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = SUBMODE_NONE;
-			setMode(_MODE_POWER_ON, commandedSubmode);
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-					MODE_ON);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
-					&mySet, PoolVariableIF::VAR_READ_WRITE);
-			mySet.read();
-			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-				mySet.commit(PoolVariableIF::VALID);
-			}
-		} else {
-			setTransition(MODE_ON, commandedSubmode);
-		}
-		break;
-	case MODE_OFF:
-		if (mode == MODE_OFF) {
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			setMode(_MODE_POWER_DOWN, commandedSubmode);
-		} else {
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = commandedSubmode;
-			childTransitionFailure = CHILD_TIMEOUT;
-			setMode(_MODE_SHUT_DOWN, commandedSubmode);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-		}
-		break;
-	case MODE_RAW:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_RAW, commandedSubmode);
-		} else {
-			setMode(MODE_RAW, commandedSubmode);
-		}
-		break;
-	case MODE_NORMAL:
-		if (mode != MODE_OFF) {
-			setTransition(MODE_NORMAL, commandedSubmode);
-		} else {
-			replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
-		}
-		break;
-	}
-}
-
-void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void DeviceHandlerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void DeviceHandlerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-bool DeviceHandlerBase::dontCheckQueue() {
-	return false;
-}
-
-void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
-	if (ignoreMissedRepliesCount > 0) {
-		ignoreMissedRepliesCount--;
-	} else {
-		triggerEvent(DEVICE_MISSED_REPLY, id);
-	}
-}
-
-HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
-    healthHelper.setHealth(health);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void DeviceHandlerBase::checkSwitchState() {
-	if ((mode == MODE_ON || mode == MODE_NORMAL)) {
-		//We only check in ON and NORMAL, ignore RAW and ERROR_ON.
-		ReturnValue_t result = getStateOfSwitches();
-		if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
-			triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			switchOffWasReported = true;
-		}
-	} else {
-		switchOffWasReported = false;
-	}
-}
-
-void DeviceHandlerBase::doOnActivity() {
-}
-
-ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
-	if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
-		return WRONG_MODE_FOR_COMMAND;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
-		size_t len) {
-	if ((wiretappingMode == RAW)
-			&& (defaultRawReceiver == requestedRawTraffic)) {
-		//The raw packet was already sent by the wiretapping service
-	} else {
-		replyRawData(data, len, defaultRawReceiver);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
-		CommandMessage * message) {
-	switch (message->getCommand()) {
-	case DeviceHandlerMessage::CMD_WIRETAPPING:
-		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
-		case RAW:
-			wiretappingMode = RAW;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case TM:
-			wiretappingMode = TM;
-			requestedRawTraffic = commandQueue->getLastPartner();
-			break;
-		case OFF:
-			wiretappingMode = OFF;
-			break;
-		default:
-			replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
-			wiretappingMode = OFF;
-			return RETURN_OK;
-		}
-		replyReturnvalueToCommand(RETURN_OK);
-		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
-	case DeviceHandlerMessage::CMD_RAW:
-		if ((mode != MODE_RAW)) {
-			DeviceHandlerMessage::clear(message);
-			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-		} else {
-			buildRawDeviceCommand(message);
-		}
-		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
-	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQueue(parentQueueId);
-}
-
-bool DeviceHandlerBase::isAwaitingReply() {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
-	for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
-		if (iter->second.delayCycles != 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
-ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
-		CommandMessage * message) {
-	return RETURN_FAILED;
-}
-
-void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
-		DeviceCommandId_t replyId, bool neverInDataPool, bool forceDirectTm) {
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
-	if (iter == deviceReplyMap.end()) {
-		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
-		return;
-	}
-	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
-	//replies to a command
-	if (iter->second.command != deviceCommandMap.end())
-	{
-		MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
-
-		if (queueId != NO_COMMANDER) {
-			//This may fail, but we'll ignore the fault.
-			actionHelper.reportData(queueId, replyId, data);
-		}
-
-		//This check should make sure we get any TM but don't get anything doubled.
-		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		}
-		else if (forceDirectTm and (defaultRawReceiver != queueId) and
-					(defaultRawReceiver != MessageQueueIF::NO_QUEUE))
-		{
-			// hiding of sender needed so the service will handle it as
-			// unexpected Data, no matter what state (progress or completed)
-			// it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-					true);
-		}
-	}
-	//unrequested/aperiodic replies
-	else
-	{
-		if (wiretappingMode == TM) {
-			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
-		}
-		else if (forceDirectTm and defaultRawReceiver !=
-				MessageQueueIF::NO_QUEUE)
-		{
-			// hiding of sender needed so the service will handle it as
-			// unexpected Data, no matter what state (progress or completed)
-			// it is in
-			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
-					true);
-		}
-	}
-	//Try to cast to GlobDataSet and commit data.
-	if (!neverInDataPool) {
-		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
-		if (dataSet != NULL) {
-			dataSet->commit(PoolVariableIF::VALID);
-		}
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
-		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-	ReturnValue_t result = acceptExternalDeviceCommands();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-	if (iter == deviceCommandMap.end()) {
-		result = COMMAND_NOT_SUPPORTED;
-	} else if (iter->second.isExecuting) {
-		result = COMMAND_ALREADY_SENT;
-	} else {
-		result = buildCommandFromCommand(actionId, data, size);
-	}
-	if (result == RETURN_OK) {
-		iter->second.sendReplyTo = commandedBy;
-		iter->second.isExecuting = true;
-		cookieInfo.pendingCommand = iter;
-		cookieInfo.state = COOKIE_WRITE_READY;
-	}
-	return result;
-}
-
-void DeviceHandlerBase::buildInternalCommand(void) {
-//Neither Raw nor Direct could build a command
-	ReturnValue_t result = NOTHING_TO_SEND;
-	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
-	if (mode == MODE_NORMAL) {
-		result = buildNormalDeviceCommand(&deviceCommandId);
-		if (result == BUSY) {
-		    //so we can track misconfigurations
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::endl;
-			result = NOTHING_TO_SEND; //no need to report this
-		}
-	}
-	else if (mode == MODE_RAW) {
-		result = buildChildRawCommand();
-		deviceCommandId = RAW_COMMAND_ID;
-	}
-	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
-		result = buildTransitionDeviceCommand(&deviceCommandId);
-	}
-	else {
-		return;
-	}
-
-	if (result == NOTHING_TO_SEND) {
-		return;
-	}
-	if (result == RETURN_OK) {
-		DeviceCommandMap::iterator iter = deviceCommandMap.find(
-				deviceCommandId);
-		if (iter == deviceCommandMap.end()) {
-			result = COMMAND_NOT_SUPPORTED;
-		} else if (iter->second.isExecuting) {
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
-		} else {
-			iter->second.sendReplyTo = NO_COMMANDER;
-			iter->second.isExecuting = true;
-			cookieInfo.pendingCommand = iter;
-			cookieInfo.state = COOKIE_WRITE_READY;
-		}
-	}
-	if (result != RETURN_OK) {
-		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
-	}
-}
-
-ReturnValue_t DeviceHandlerBase::buildChildRawCommand() {
-	return NOTHING_TO_SEND;
-}
-
-uint8_t DeviceHandlerBase::getReplyDelayCycles(
-		DeviceCommandId_t deviceCommand) {
-	DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
-	if (iter == deviceReplyMap.end()) {
-		return 0;
-	}
-	return iter->second.delayCycles;
-}
-
-Mode_t DeviceHandlerBase::getTransitionSourceMode() const {
-	return transitionSourceMode;
-}
-
-Submode_t DeviceHandlerBase::getTransitionSourceSubMode() const {
-	return transitionSourceSubMode;
-}
-
-void DeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
-}
-
-void DeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) const {
-	fdirInstance->triggerEvent(event, parameter1, parameter2);
-}
-
-void DeviceHandlerBase::doOffActivity() {
-}
-
-ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = fdirInstance->getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-
-}
-
-bool DeviceHandlerBase::isTransitionalMode() {
-	return ((mode
-			& (TRANSITION_MODE_BASE_ACTION_MASK
-					| TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
-}
-
-bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
-	auto iter = deviceCommandMap.find(commandId);
-	if (iter != deviceCommandMap.end()) {
-		return iter->second.isExecuting;
-	} else {
-		return false;
-	}
-
-}
-
-void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
-
-void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-	executingTask = task_;
-}
-
-// Default implementations empty.
-void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
-		object_id_t objectId, uint32_t parameter) {}
-
-void DeviceHandlerBase::performOperationHook() {
-}
-
-ReturnValue_t DeviceHandlerBase::initializePoolEntries(
-		LocalDataPool &localDataPoolMap) {
-	return RETURN_OK;
-}
-
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
-ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
-    // In this function, the task handle should be valid if the task
-    // was implemented correctly. We still check to be 1000 % sure :-)
-    if(executingTask != nullptr) {
-        pstIntervalMs = executingTask->getPeriodMs();
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
-	auto iter = deviceReplyMap.find(sid.ownerSetId);
-	if(iter != deviceReplyMap.end()) {
-		return iter->second.dataSet;
-	}
-	else {
-		return nullptr;
-	}
-}
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../globalfunctions/CRC.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+#include <iomanip>
+
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
+
+DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * comCookie,
+		FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
+		SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
+		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
+		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
+		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
+		actionHelper(this, nullptr), hkManager(this, nullptr),
+		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
+		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
+		switchOffWasReported(false), childTransitionDelay(5000),
+		transitionSourceMode(_MODE_POWER_DOWN),
+		transitionSourceSubMode(SUBMODE_NONE) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
+	insertInCommandMap(RAW_COMMAND_ID);
+	cookieInfo.state = COOKIE_UNUSED;
+	cookieInfo.pendingCommand = deviceCommandMap.end();
+	if (comCookie == nullptr) {
+		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
+				<< std::setw(8) << std::setfill('0') << this->getObjectId()
+				<< std::dec << ": Do not pass nullptr as a cookie, consider "
+				<< std::setfill(' ') << "passing a dummy cookie instead!"
+				<< std::endl;
+	}
+	if (this->fdirInstance == nullptr) {
+		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
+				defaultFdirParentId);
+	}
+}
+
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
+	this->hkDestination = hkDestination;
+}
+
+void DeviceHandlerBase::setThermalStateRequestPoolIds(
+		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+	this->deviceThermalRequestPoolId = thermalStatePoolId;
+	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+}
+
+
+DeviceHandlerBase::~DeviceHandlerBase() {
+	delete comCookie;
+	if (defaultFDIRUsed) {
+		delete fdirInstance;
+	}
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
+	this->pstStep = counter;
+
+	if (getComAction() == SEND_WRITE) {
+		cookieInfo.state = COOKIE_UNUSED;
+		readCommandQueue();
+		doStateMachine();
+		checkSwitchState();
+		decrementDeviceReplyMap();
+		fdirInstance->checkForFailures();
+		hkSwitcher.performOperation();
+		performOperationHook();
+	}
+	if (mode == MODE_OFF) {
+		return RETURN_OK;
+	}
+	switch (getComAction()) {
+	case SEND_WRITE:
+		if ((cookieInfo.state == COOKIE_UNUSED)) {
+			buildInternalCommand();
+		}
+		doSendWrite();
+		break;
+	case GET_WRITE:
+		doGetWrite();
+		break;
+	case SEND_READ:
+		doSendRead();
+		break;
+	case GET_READ:
+		doGetRead();
+		cookieInfo.state = COOKIE_UNUSED;
+		break;
+	default:
+		break;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	communicationInterface = objectManager->get<DeviceCommunicationIF>(
+			deviceCommunicationId);
+	if (communicationInterface == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: Communication interface "
+				"invalid." << std::endl;
+		sif::error << "Make sure it is set up properly and implements"
+				" DeviceCommunicationIF" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	result = communicationInterface->initializeInterface(comCookie);
+	if (result != RETURN_OK) {
+	    sif::error << "DeviceHandlerBase::initialize: Initializing "
+	            "communication interface failed!" << std::endl;
+	    return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == nullptr) {
+		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
+				"factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	if(rawDataReceiverId != objects::NO_OBJECT) {
+		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
+
+		if (rawReceiver == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
+					"ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					" and implements AcceptsDeviceResponsesIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+		defaultRawReceiver = rawReceiver->getDeviceQueue();
+	}
+
+	if(powerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+		if (powerSwitcher == nullptr) {
+			sif::error << "DeviceHandlerBase::initialize: Power switcher "
+					<< "object ID set but no valid object found." << std::endl;
+			sif::error << "Make sure the raw receiver object is set up properly"
+					<< " and implements PowerSwitchIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+	}
+
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+	    return result;
+	}
+
+	result = modeHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = actionHelper.initialize(commandQueue);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = fdirInstance->initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = hkSwitcher.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(hkDestination == objects::NO_OBJECT) {
+		hkDestination = defaultHkDestination;
+	}
+
+	result = hkManager.initialize(commandQueue, hkDestination);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	fillCommandAndReplyMap();
+
+	//Set temperature target state to NON_OP.
+	GlobDataSet mySet;
+	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+			PoolVariableIF::VAR_WRITE);
+	mySet.read();
+	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+	mySet.commit(PoolVariableIF::VALID);
+
+	return RETURN_OK;
+
+}
+
+void DeviceHandlerBase::decrementDeviceReplyMap() {
+	for (std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
+			deviceReplyMap.begin(); iter != deviceReplyMap.end(); iter++) {
+		if (iter->second.delayCycles != 0) {
+			iter->second.delayCycles--;
+			if (iter->second.delayCycles == 0) {
+				if (iter->second.periodic) {
+					iter->second.delayCycles = iter->second.maxDelayCycles;
+				}
+				replyToReply(iter, TIMEOUT);
+				missedReply(iter->first);
+			}
+		}
+	}
+}
+
+void DeviceHandlerBase::readCommandQueue() {
+
+	if (dontCheckQueue()) {
+		return;
+	}
+
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != RETURN_OK) {
+		return;
+	}
+
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == RETURN_OK) {
+	    return;
+	}
+
+	result = modeHelper.handleModeCommand(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = actionHelper.handleActionMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = hkManager.handleHousekeepingMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = handleDeviceHandlerMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	result = letChildHandleMessage(&command);
+	if (result == RETURN_OK) {
+		return;
+	}
+
+	replyReturnvalueToCommand(CommandMessage::UNKNOWN_COMMAND);
+
+}
+
+void DeviceHandlerBase::doStateMachine() {
+	switch (mode) {
+	case _MODE_START_UP:
+	case _MODE_SHUT_DOWN:
+	case _MODE_TO_NORMAL:
+	case _MODE_TO_ON:
+	case _MODE_TO_RAW: {
+		Mode_t currentMode = mode;
+		callChildStatemachine();
+		//Only do timeout if child did not change anything
+		if (mode != currentMode) {
+			break;
+		}
+		uint32_t currentUptime;
+		Clock::getUptime(&currentUptime);
+		if (currentUptime - timeoutStart >= childTransitionDelay) {
+			triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
+			setMode(transitionSourceMode, transitionSourceSubMode);
+			break;
+		}
+	}
+		break;
+	case _MODE_POWER_DOWN:
+		commandSwitch(PowerSwitchIF::SWITCH_OFF);
+		setMode(_MODE_WAIT_OFF);
+		break;
+	case _MODE_POWER_ON:
+		commandSwitch(PowerSwitchIF::SWITCH_ON);
+		setMode(_MODE_WAIT_ON);
+		break;
+	case _MODE_WAIT_ON: {
+		uint32_t currentUptime;
+		Clock::getUptime(&currentUptime);
+		if (powerSwitcher != nullptr and currentUptime - timeoutStart >=
+				powerSwitcher->getSwitchDelayMs()) {
+			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
+					0);
+			setMode(_MODE_POWER_DOWN);
+			callChildStatemachine();
+			break;
+		}
+		ReturnValue_t switchState = getStateOfSwitches();
+		if ((switchState == PowerSwitchIF::SWITCH_ON)
+				|| (switchState == NO_SWITCH)) {
+			//NOTE: TransitionSourceMode and -SubMode are set by handleCommandedModeTransition
+			childTransitionFailure = CHILD_TIMEOUT;
+			setMode(_MODE_START_UP);
+			callChildStatemachine();
+		}
+	}
+		break;
+	case _MODE_WAIT_OFF: {
+		uint32_t currentUptime;
+		Clock::getUptime(&currentUptime);
+
+		if(powerSwitcher == nullptr) {
+		    setMode(MODE_OFF);
+		    break;
+		}
+
+		if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
+			triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
+					0);
+			setMode(MODE_ERROR_ON);
+			break;
+		}
+		ReturnValue_t switchState = getStateOfSwitches();
+		if ((switchState == PowerSwitchIF::SWITCH_OFF)
+				|| (switchState == NO_SWITCH)) {
+			setMode(_MODE_SWITCH_IS_OFF);
+		}
+	}
+		break;
+	case MODE_OFF:
+		doOffActivity();
+		break;
+	case MODE_ON:
+		doOnActivity();
+		break;
+	case MODE_RAW:
+	case MODE_NORMAL:
+	case MODE_ERROR_ON:
+		break;
+	case _MODE_SWITCH_IS_OFF:
+		setMode(MODE_OFF, SUBMODE_NONE);
+		break;
+	default:
+		triggerEvent(OBJECT_IN_INVALID_MODE, mode, submode);
+		setMode(_MODE_POWER_DOWN, 0);
+		break;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
+		Submode_t submode) {
+	switch (mode) {
+	case MODE_OFF:
+	case MODE_ON:
+	case MODE_NORMAL:
+	case MODE_RAW:
+		if (submode == SUBMODE_NONE) {
+			return RETURN_OK;
+		} else {
+			return INVALID_SUBMODE;
+		}
+	default:
+		return HasModesIF::INVALID_MODE;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
+		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
+		size_t replyLen, bool periodic, bool hasDifferentReplyId,
+		DeviceCommandId_t replyId) {
+	//No need to check, as we may try to insert multiple times.
+	insertInCommandMap(deviceCommand);
+	if (hasDifferentReplyId) {
+		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+	} else {
+		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
+		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+	DeviceReplyInfo info;
+	info.maxDelayCycles = maxDelayCycles;
+	info.periodic = periodic;
+	info.delayCycles = 0;
+	info.replyLen = replyLen;
+	info.command = deviceCommandMap.end();
+	auto resultPair = deviceReplyMap.emplace(replyId, info);
+	if (resultPair.second) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::insertInCommandMap(
+		DeviceCommandId_t deviceCommand) {
+	DeviceCommandInfo info;
+	info.expectedReplies = 0;
+	info.isExecuting = false;
+	info.sendReplyTo = NO_COMMANDER;
+	auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
+	if (resultPair.second) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
+		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
+	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
+			deviceReplyMap.find(deviceReply);
+	if (iter == deviceReplyMap.end()) {
+		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
+		return RETURN_FAILED;
+	} else {
+		DeviceReplyInfo *info = &(iter->second);
+		if (maxDelayCycles != 0) {
+			info->maxDelayCycles = maxDelayCycles;
+		}
+		info->delayCycles = delayCycles;
+		info->periodic = periodic;
+		return RETURN_OK;
+	}
+}
+
+void DeviceHandlerBase::callChildStatemachine() {
+	if (mode == _MODE_START_UP) {
+		doStartUp();
+	} else if (mode == _MODE_SHUT_DOWN) {
+		doShutDown();
+	} else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+		doTransition(transitionSourceMode, transitionSourceSubMode);
+	}
+}
+
+void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
+	triggerEvent(CHANGING_MODE, modeTo, submodeTo);
+	childTransitionDelay = getTransitionDelayMs(mode, modeTo);
+	transitionSourceMode = mode;
+	transitionSourceSubMode = submode;
+	childTransitionFailure = CHILD_TIMEOUT;
+
+	// transitionTargetMode is set by setMode
+	setMode((modeTo | TRANSITION_MODE_CHILD_ACTION_MASK), submodeTo);
+}
+
+void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
+	changeHK(mode, submode, false);
+	submode = newSubmode;
+	mode = newMode;
+	modeChanged();
+	setNormalDatapoolEntriesInvalid();
+	if (!isTransitionalMode()) {
+		modeHelper.modeChanged(newMode, newSubmode);
+		announceMode(false);
+	}
+	Clock::getUptime(&timeoutStart);
+
+	if (mode == MODE_OFF) {
+		GlobDataSet mySet;
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		}
+		mySet.commit(PoolVariableIF::VALID);
+	}
+	changeHK(mode, submode, true);
+}
+
+void DeviceHandlerBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
+		uint32_t parameter) {
+	//This is actually the reply protocol for raw and misc DH commands.
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, parameter);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, parameter);
+		commandQueue->reply(&reply);
+	}
+}
+
+void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
+		uint32_t parameter) {
+//Check if we reply to a raw command.
+	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
+		if (status == NO_REPLY_EXPECTED) {
+			status = RETURN_OK;
+		}
+		replyReturnvalueToCommand(status, parameter);
+		//Always delete data from a raw command.
+		IPCStore->deleteData(storedRawData);
+		return;
+	}
+//Check if we were externally commanded.
+	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
+		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
+		if (status == NO_REPLY_EXPECTED) {
+			actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
+					RETURN_OK);
+		} else {
+			actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
+					status);
+		}
+	}
+}
+
+void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
+		ReturnValue_t status) {
+//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	if (iter->second.command == deviceCommandMap.end()) {
+		//Is most likely periodic reply. Silent return.
+		return;
+	}
+//Check if more replies are expected. If so, do nothing.
+	DeviceCommandInfo* info = &(iter->second.command->second);
+	if (--info->expectedReplies == 0) {
+		//Check if it was transition or internal command. Don't send any replies in that case.
+		if (info->sendReplyTo != NO_COMMANDER) {
+			actionHelper.finish(info->sendReplyTo, iter->first, status);
+		}
+		info->isExecuting = false;
+	}
+}
+
+void DeviceHandlerBase::doSendWrite() {
+	if (cookieInfo.state == COOKIE_WRITE_READY) {
+
+		ReturnValue_t result = communicationInterface->sendMessage(comCookie,
+				rawPacket, rawPacketLen);
+
+		if (result == RETURN_OK) {
+			cookieInfo.state = COOKIE_WRITE_SENT;
+		} else {
+			//always generate a failure event, so that FDIR knows what's up
+			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+					cookieInfo.pendingCommand->first);
+			replyToCommand(result);
+			cookieInfo.state = COOKIE_UNUSED;
+			cookieInfo.pendingCommand->second.isExecuting = false;
+		}
+	}
+}
+
+void DeviceHandlerBase::doGetWrite() {
+	if (cookieInfo.state != COOKIE_WRITE_SENT) {
+		return;
+	}
+	cookieInfo.state = COOKIE_UNUSED;
+	ReturnValue_t result = communicationInterface->getSendSuccess(comCookie);
+	if (result == RETURN_OK) {
+		if (wiretappingMode == RAW) {
+			replyRawData(rawPacket, rawPacketLen, requestedRawTraffic, true);
+		}
+
+		//We need to distinguish here, because a raw command never expects a reply.
+		//(Could be done in eRIRM, but then child implementations need to be careful.
+		result = enableReplyInReplyMap(cookieInfo.pendingCommand);
+	} else {
+		//always generate a failure event, so that FDIR knows what's up
+		triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
+				cookieInfo.pendingCommand->first);
+	}
+	if (result != RETURN_OK) {
+		cookieInfo.pendingCommand->second.isExecuting = false;
+	}
+	replyToCommand(result);
+}
+
+void DeviceHandlerBase::doSendRead() {
+	ReturnValue_t result;
+
+	size_t requestLen = 0;
+	if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+		DeviceReplyIter iter = deviceReplyMap.find(
+				cookieInfo.pendingCommand->first);
+		if(iter != deviceReplyMap.end()) {
+			requestLen = iter->second.replyLen;
+		}
+	}
+
+	result = communicationInterface->requestReceiveMessage(comCookie, requestLen);
+
+	if (result == RETURN_OK) {
+		cookieInfo.state = COOKIE_READ_SENT;
+	} else {
+		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+		//We can't inform anyone, because we don't know which command was sent last.
+		//So, we need to wait for a timeout.
+		//but I think we can allow to ignore one missedReply.
+		ignoreMissedRepliesCount++;
+		cookieInfo.state = COOKIE_UNUSED;
+	}
+}
+
+void DeviceHandlerBase::doGetRead() {
+	size_t receivedDataLen = 0;
+	uint8_t *receivedData = nullptr;
+
+	if (cookieInfo.state != COOKIE_READ_SENT) {
+		cookieInfo.state = COOKIE_UNUSED;
+		return;
+	}
+
+	cookieInfo.state = COOKIE_UNUSED;
+
+	ReturnValue_t result = communicationInterface->readReceivedMessage(
+			comCookie, &receivedData, &receivedDataLen);
+
+	if (result != RETURN_OK) {
+		triggerEvent(DEVICE_REQUESTING_REPLY_FAILED, result);
+		//I think we can allow to ignore one missedReply.
+		ignoreMissedRepliesCount++;
+		return;
+	}
+
+	if (receivedDataLen == 0 or result == DeviceCommunicationIF::NO_REPLY_RECEIVED)
+		return;
+
+	if (wiretappingMode == RAW) {
+		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
+	}
+
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	}
+	else {
+		parseReply(receivedData, receivedDataLen);
+	}
+}
+
+void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
+		size_t receivedDataLen) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	size_t foundLen = 0;
+	// The loop may not execute more often than the number of received bytes
+	// (worst case). This approach avoids infinite loops due to buggy
+	// scanForReply routines.
+	uint32_t remainingLength = receivedDataLen;
+	for (uint32_t count = 0; count < receivedDataLen; count++) {
+		result = scanForReply(receivedData, remainingLength, &foundId,
+				&foundLen);
+		switch (result) {
+		case RETURN_OK:
+			handleReply(receivedData, foundId, foundLen);
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			break;
+		case APERIODIC_REPLY: {
+			result = interpretDeviceReply(foundId, receivedData);
+			if (result != RETURN_OK) {
+			    replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			    triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result,
+			            foundId);
+			}
+			if(foundLen == 0) {
+			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
+			            " Packet parsing will be stuck." << std::endl;
+			}
+			break;
+		}
+		case IGNORE_REPLY_DATA:
+			break;
+		case IGNORE_FULL_PACKET:
+			return;
+		default:
+			//We need to wait for timeout.. don't know what command failed and who sent it.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
+			break;
+		}
+		receivedData += foundLen;
+		if (remainingLength > foundLen) {
+			remainingLength -= foundLen;
+		} else {
+			return;
+		}
+	}
+}
+
+void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
+		DeviceCommandId_t foundId, uint32_t foundLen) {
+	ReturnValue_t result;
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(foundId);
+
+	if (iter == deviceReplyMap.end()) {
+		replyRawReplyIfnotWiretapped(receivedData, foundLen);
+		triggerEvent(DEVICE_UNKNOWN_REPLY, foundId);
+		return;
+	}
+
+	DeviceReplyInfo *info = &(iter->second);
+
+	if (info->delayCycles != 0) {
+
+		if (info->periodic != false) {
+			info->delayCycles = info->maxDelayCycles;
+		}
+		else {
+			info->delayCycles = 0;
+		}
+
+		result = interpretDeviceReply(foundId, receivedData);
+
+		if (result != RETURN_OK) {
+			// Report failed interpretation to FDIR.
+			replyRawReplyIfnotWiretapped(receivedData, foundLen);
+			triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
+		}
+		replyToReply(iter, result);
+	}
+	else {
+		// Other completion failure messages are created by timeout.
+		// Powering down the device might take some time during which periodic
+		// replies may still come in.
+		if (mode != _MODE_WAIT_OFF) {
+			triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId);
+		}
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
+		uint8_t** data, uint32_t * len) {
+	size_t lenTmp;
+
+	if (IPCStore == nullptr) {
+		*data = nullptr;
+		*len = 0;
+		return RETURN_FAILED;
+	}
+	ReturnValue_t result = IPCStore->modifyData(storageAddress, data, &lenTmp);
+	if (result == RETURN_OK) {
+		*len = lenTmp;
+		return RETURN_OK;
+	} else {
+		triggerEvent(StorageManagerIF::GET_DATA_FAILED, result,
+				storageAddress.raw);
+		*data = nullptr;
+		*len = 0;
+		return result;
+	}
+}
+
+void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
+		MessageQueueId_t sendTo, bool isCommand) {
+	if (IPCStore == nullptr or len == 0 or sendTo == MessageQueueIF::NO_QUEUE) {
+		return;
+	}
+	store_address_t address;
+	ReturnValue_t result = IPCStore->addData(&address, data, len);
+
+	if (result != RETURN_OK) {
+		triggerEvent(StorageManagerIF::STORE_DATA_FAILED, result);
+		return;
+	}
+
+	CommandMessage command;
+
+	DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(&command,
+			getObjectId(), address, isCommand);
+
+	result = commandQueue->sendMessage(sendTo, &command);
+
+	if (result != RETURN_OK) {
+		IPCStore->deleteData(address);
+		// Silently discard data, this indicates heavy TM traffic which
+		// should not be increased by additional events.
+	}
+}
+
+//Default child implementations
+DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
+	switch (pstStep) {
+	case 0:
+		return SEND_WRITE;
+		break;
+	case 1:
+		return GET_WRITE;
+		break;
+	case 2:
+		return SEND_READ;
+		break;
+	case 3:
+		return GET_READ;
+		break;
+	default:
+		break;
+	}
+	return NOTHING;
+}
+
+MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void DeviceHandlerBase::buildRawDeviceCommand(CommandMessage* commandMessage) {
+	storedRawData = DeviceHandlerMessage::getStoreAddress(commandMessage);
+	ReturnValue_t result = getStorageData(storedRawData, &rawPacket,
+			&rawPacketLen);
+	if (result != RETURN_OK) {
+		replyReturnvalueToCommand(result, RAW_COMMAND_ID);
+		storedRawData.raw = StorageManagerIF::INVALID_ADDRESS;
+	} else {
+		cookieInfo.pendingCommand = deviceCommandMap.find(
+				(DeviceCommandId_t) RAW_COMMAND_ID);
+		cookieInfo.pendingCommand->second.isExecuting = true;
+		cookieInfo.state = COOKIE_WRITE_READY;
+	}
+}
+
+void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
+	if(powerSwitcher == nullptr) {
+		return;
+	}
+	const uint8_t *switches;
+	uint8_t numberOfSwitches = 0;
+	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+	if (result == RETURN_OK) {
+		while (numberOfSwitches > 0) {
+			powerSwitcher->sendSwitchCommand(switches[numberOfSwitches - 1],
+					onOff);
+			numberOfSwitches--;
+		}
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t **switches,
+		uint8_t *numberOfSwitches) {
+	return DeviceHandlerBase::NO_SWITCH;
+}
+
+void DeviceHandlerBase::modeChanged(void) {
+}
+
+ReturnValue_t DeviceHandlerBase::enableReplyInReplyMap(
+		DeviceCommandMap::iterator command, uint8_t expectedReplies,
+		bool useAlternativeId, DeviceCommandId_t alternativeReply) {
+	DeviceReplyMap::iterator iter;
+	if (useAlternativeId) {
+		iter = deviceReplyMap.find(alternativeReply);
+	} else {
+		iter = deviceReplyMap.find(command->first);
+	}
+	if (iter != deviceReplyMap.end()) {
+		DeviceReplyInfo *info = &(iter->second);
+		info->delayCycles = info->maxDelayCycles;
+		info->command = command;
+		command->second.expectedReplies = expectedReplies;
+		return RETURN_OK;
+	} else {
+		return NO_REPLY_EXPECTED;
+	}
+}
+
+void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+	setMode(getBaseMode(mode));
+}
+
+uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
+		Mode_t modeTo) {
+	return 0;
+}
+
+ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
+	if(powerSwitcher == nullptr) {
+		return NO_SWITCH;
+	}
+	uint8_t numberOfSwitches = 0;
+	const uint8_t *switches;
+
+	ReturnValue_t result = getSwitches(&switches, &numberOfSwitches);
+	if ((result == RETURN_OK) && (numberOfSwitches != 0)) {
+		while (numberOfSwitches > 0) {
+			if (powerSwitcher->getSwitchState(switches[numberOfSwitches - 1])
+					== PowerSwitchIF::SWITCH_OFF) {
+				return PowerSwitchIF::SWITCH_OFF;
+			}
+			numberOfSwitches--;
+		}
+		return PowerSwitchIF::SWITCH_ON;
+	}
+
+	return NO_SWITCH;
+}
+
+Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
+//only child action special modes are handled, as a child should never see any base action modes
+	if (transitionMode == _MODE_START_UP) {
+		return _MODE_TO_ON;
+	}
+	if (transitionMode == _MODE_SHUT_DOWN) {
+		return _MODE_POWER_DOWN;
+	}
+	return transitionMode
+			& ~(TRANSITION_MODE_BASE_ACTION_MASK
+					| TRANSITION_MODE_CHILD_ACTION_MASK);
+}
+
+//SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the way, throw away DHB and write a new one:
+// - Include power and thermal completely, but more modular :-)
+// - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
+// - Modularization?
+ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
+		Submode_t commandedSubmode, uint32_t* msToReachTheMode) {
+	if (isTransitionalMode()) {
+		return IN_TRANSITION;
+	}
+	if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
+		return TRANS_NOT_ALLOWED;
+	}
+	if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
+		return TRANS_NOT_ALLOWED;
+	}
+
+	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
+			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
+		GlobDataSet mySet;
+		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
+				PoolVariableIF::VAR_READ);
+		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+				PoolVariableIF::VAR_READ);
+		mySet.read();
+		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+			if (!ThermalComponentIF::isOperational(thermalState)) {
+				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
+						thermalState);
+				return NON_OP_TEMPERATURE;
+			}
+		}
+	}
+
+	return isModeCombinationValid(commandedMode, commandedSubmode);
+}
+
+void DeviceHandlerBase::startTransition(Mode_t commandedMode,
+		Submode_t commandedSubmode) {
+	switch (commandedMode) {
+	case MODE_ON:
+		if (mode == MODE_OFF) {
+			transitionSourceMode = _MODE_POWER_DOWN;
+			transitionSourceSubMode = SUBMODE_NONE;
+			setMode(_MODE_POWER_ON, commandedSubmode);
+			//already set the delay for the child transition so we don't need to call it twice
+			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+					MODE_ON);
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+			GlobDataSet mySet;
+			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
+					&mySet, PoolVariableIF::VAR_READ_WRITE);
+			mySet.read();
+			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
+				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+				mySet.commit(PoolVariableIF::VALID);
+			}
+		} else {
+			setTransition(MODE_ON, commandedSubmode);
+		}
+		break;
+	case MODE_OFF:
+		if (mode == MODE_OFF) {
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+			setMode(_MODE_POWER_DOWN, commandedSubmode);
+		} else {
+			//already set the delay for the child transition so we don't need to call it twice
+			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
+			transitionSourceMode = _MODE_POWER_DOWN;
+			transitionSourceSubMode = commandedSubmode;
+			childTransitionFailure = CHILD_TIMEOUT;
+			setMode(_MODE_SHUT_DOWN, commandedSubmode);
+			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+		}
+		break;
+	case MODE_RAW:
+		if (mode != MODE_OFF) {
+			setTransition(MODE_RAW, commandedSubmode);
+		} else {
+			setMode(MODE_RAW, commandedSubmode);
+		}
+		break;
+	case MODE_NORMAL:
+		if (mode != MODE_OFF) {
+			setTransition(MODE_NORMAL, commandedSubmode);
+		} else {
+			replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
+		}
+		break;
+	}
+}
+
+void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void DeviceHandlerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void DeviceHandlerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+bool DeviceHandlerBase::dontCheckQueue() {
+	return false;
+}
+
+void DeviceHandlerBase::missedReply(DeviceCommandId_t id) {
+	if (ignoreMissedRepliesCount > 0) {
+		ignoreMissedRepliesCount--;
+	} else {
+		triggerEvent(DEVICE_MISSED_REPLY, id);
+	}
+}
+
+HasHealthIF::HealthState DeviceHandlerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t DeviceHandlerBase::setHealth(HealthState health) {
+    healthHelper.setHealth(health);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void DeviceHandlerBase::checkSwitchState() {
+	if ((mode == MODE_ON || mode == MODE_NORMAL)) {
+		//We only check in ON and NORMAL, ignore RAW and ERROR_ON.
+		ReturnValue_t result = getStateOfSwitches();
+		if (result == PowerSwitchIF::SWITCH_OFF && !switchOffWasReported) {
+			triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			switchOffWasReported = true;
+		}
+	} else {
+		switchOffWasReported = false;
+	}
+}
+
+void DeviceHandlerBase::doOnActivity() {
+}
+
+ReturnValue_t DeviceHandlerBase::acceptExternalDeviceCommands() {
+	if ((mode != MODE_ON) && (mode != MODE_NORMAL)) {
+		return WRONG_MODE_FOR_COMMAND;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerBase::replyRawReplyIfnotWiretapped(const uint8_t* data,
+		size_t len) {
+	if ((wiretappingMode == RAW)
+			&& (defaultRawReceiver == requestedRawTraffic)) {
+		//The raw packet was already sent by the wiretapping service
+	} else {
+		replyRawData(data, len, defaultRawReceiver);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
+		CommandMessage * message) {
+	switch (message->getCommand()) {
+	case DeviceHandlerMessage::CMD_WIRETAPPING:
+		switch (DeviceHandlerMessage::getWiretappingMode(message)) {
+		case RAW:
+			wiretappingMode = RAW;
+			requestedRawTraffic = commandQueue->getLastPartner();
+			break;
+		case TM:
+			wiretappingMode = TM;
+			requestedRawTraffic = commandQueue->getLastPartner();
+			break;
+		case OFF:
+			wiretappingMode = OFF;
+			break;
+		default:
+			replyReturnvalueToCommand(INVALID_COMMAND_PARAMETER);
+			wiretappingMode = OFF;
+			return RETURN_OK;
+		}
+		replyReturnvalueToCommand(RETURN_OK);
+		return RETURN_OK;
+//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
+//		if (mode != MODE_OFF) {
+//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+//		} else {
+//			result = switchCookieChannel(
+//					DeviceHandlerMessage::getIoBoardObjectId(message));
+//			if (result == RETURN_OK) {
+//				replyReturnvalueToCommand(RETURN_OK);
+//			} else {
+//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
+//			}
+//		}
+//		return RETURN_OK;
+	case DeviceHandlerMessage::CMD_RAW:
+		if ((mode != MODE_RAW)) {
+			DeviceHandlerMessage::clear(message);
+			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
+		} else {
+			buildRawDeviceCommand(message);
+		}
+		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
+	modeHelper.setParentQueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
+}
+
+bool DeviceHandlerBase::isAwaitingReply() {
+	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter;
+	for (iter = deviceReplyMap.begin(); iter != deviceReplyMap.end(); ++iter) {
+		if (iter->second.delayCycles != 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+ReturnValue_t DeviceHandlerBase::letChildHandleMessage(
+		CommandMessage * message) {
+	return RETURN_FAILED;
+}
+
+void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
+		DeviceCommandId_t replyId, bool neverInDataPool, bool forceDirectTm) {
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+	if (iter == deviceReplyMap.end()) {
+		triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
+		return;
+	}
+	DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data);
+	//replies to a command
+	if (iter->second.command != deviceCommandMap.end())
+	{
+		MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
+
+		if (queueId != NO_COMMANDER) {
+			//This may fail, but we'll ignore the fault.
+			actionHelper.reportData(queueId, replyId, data);
+		}
+
+		//This check should make sure we get any TM but don't get anything doubled.
+		if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
+			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+		}
+		else if (forceDirectTm and (defaultRawReceiver != queueId) and
+					(defaultRawReceiver != MessageQueueIF::NO_QUEUE))
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+					true);
+		}
+	}
+	//unrequested/aperiodic replies
+	else
+	{
+		if (wiretappingMode == TM) {
+			actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+		}
+		else if (forceDirectTm and defaultRawReceiver !=
+				MessageQueueIF::NO_QUEUE)
+		{
+			// hiding of sender needed so the service will handle it as
+			// unexpected Data, no matter what state (progress or completed)
+			// it is in
+			actionHelper.reportData(defaultRawReceiver, replyId, &wrapper,
+					true);
+		}
+	}
+	//Try to cast to GlobDataSet and commit data.
+	if (!neverInDataPool) {
+		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
+		if (dataSet != NULL) {
+			dataSet->commit(PoolVariableIF::VALID);
+		}
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId,
+		MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+	ReturnValue_t result = acceptExternalDeviceCommands();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
+	if (iter == deviceCommandMap.end()) {
+		result = COMMAND_NOT_SUPPORTED;
+	} else if (iter->second.isExecuting) {
+		result = COMMAND_ALREADY_SENT;
+	} else {
+		result = buildCommandFromCommand(actionId, data, size);
+	}
+	if (result == RETURN_OK) {
+		iter->second.sendReplyTo = commandedBy;
+		iter->second.isExecuting = true;
+		cookieInfo.pendingCommand = iter;
+		cookieInfo.state = COOKIE_WRITE_READY;
+	}
+	return result;
+}
+
+void DeviceHandlerBase::buildInternalCommand(void) {
+//Neither Raw nor Direct could build a command
+	ReturnValue_t result = NOTHING_TO_SEND;
+	DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
+	if (mode == MODE_NORMAL) {
+		result = buildNormalDeviceCommand(&deviceCommandId);
+		if (result == BUSY) {
+		    //so we can track misconfigurations
+			sif::debug << std::hex << getObjectId()
+					<< ": DHB::buildInternalCommand: Busy" << std::endl;
+			result = NOTHING_TO_SEND; //no need to report this
+		}
+	}
+	else if (mode == MODE_RAW) {
+		result = buildChildRawCommand();
+		deviceCommandId = RAW_COMMAND_ID;
+	}
+	else if (mode & TRANSITION_MODE_CHILD_ACTION_MASK) {
+		result = buildTransitionDeviceCommand(&deviceCommandId);
+	}
+	else {
+		return;
+	}
+
+	if (result == NOTHING_TO_SEND) {
+		return;
+	}
+	if (result == RETURN_OK) {
+		DeviceCommandMap::iterator iter = deviceCommandMap.find(
+				deviceCommandId);
+		if (iter == deviceCommandMap.end()) {
+			result = COMMAND_NOT_SUPPORTED;
+		} else if (iter->second.isExecuting) {
+			sif::debug << std::hex << getObjectId()
+					<< ": DHB::buildInternalCommand: Command "
+					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
+			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+		} else {
+			iter->second.sendReplyTo = NO_COMMANDER;
+			iter->second.isExecuting = true;
+			cookieInfo.pendingCommand = iter;
+			cookieInfo.state = COOKIE_WRITE_READY;
+		}
+	}
+	if (result != RETURN_OK) {
+		triggerEvent(DEVICE_BUILDING_COMMAND_FAILED, result, deviceCommandId);
+	}
+}
+
+ReturnValue_t DeviceHandlerBase::buildChildRawCommand() {
+	return NOTHING_TO_SEND;
+}
+
+uint8_t DeviceHandlerBase::getReplyDelayCycles(
+		DeviceCommandId_t deviceCommand) {
+	DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
+	if (iter == deviceReplyMap.end()) {
+		return 0;
+	}
+	return iter->second.delayCycles;
+}
+
+Mode_t DeviceHandlerBase::getTransitionSourceMode() const {
+	return transitionSourceMode;
+}
+
+Submode_t DeviceHandlerBase::getTransitionSourceSubMode() const {
+	return transitionSourceSubMode;
+}
+
+void DeviceHandlerBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	fdirInstance->triggerEvent(event, parameter1, parameter2);
+}
+
+void DeviceHandlerBase::forwardEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) const {
+	fdirInstance->triggerEvent(event, parameter1, parameter2);
+}
+
+void DeviceHandlerBase::doOffActivity() {
+}
+
+ReturnValue_t DeviceHandlerBase::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = fdirInstance->getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+
+}
+
+bool DeviceHandlerBase::isTransitionalMode() {
+	return ((mode
+			& (TRANSITION_MODE_BASE_ACTION_MASK
+					| TRANSITION_MODE_CHILD_ACTION_MASK)) != 0);
+}
+
+bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
+	auto iter = deviceCommandMap.find(commandId);
+	if (iter != deviceCommandMap.end()) {
+		return iter->second.isExecuting;
+	} else {
+		return false;
+	}
+
+}
+
+void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
+
+void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
+	executingTask = task_;
+}
+
+// Default implementations empty.
+void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
+		object_id_t objectId, uint32_t parameter) {}
+
+void DeviceHandlerBase::performOperationHook() {
+}
+
+ReturnValue_t DeviceHandlerBase::initializePoolEntries(
+		LocalDataPool &localDataPoolMap) {
+	return RETURN_OK;
+}
+
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+	return &hkManager;
+}
+
+
+ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
+    // In this function, the task handle should be valid if the task
+    // was implemented correctly. We still check to be 1000 % sure :-)
+    if(executingTask != nullptr) {
+        pstIntervalMs = executingTask->getPeriodMs();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+	auto iter = deviceReplyMap.find(sid.ownerSetId);
+	if(iter != deviceReplyMap.end()) {
+		return iter->second.dataSet;
+	}
+	else {
+		return nullptr;
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 632db5e0..7add48e4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,1207 +1,1207 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/datapool/PoolVariableIF.h>
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-#include <framework/action/ActionHelper.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/datapool/HkSwitchHelper.h>
-#include <framework/datapoollocal/HasLocalDataPoolIF.h>
-#include <framework/datapoollocal/LocalDataPoolManager.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <map>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class StorageManagerIF;
-
-/**
- * @defgroup devices Devices
- * Contains all devices and the DeviceHandlerBase class.
- */
-
-/**
- * @brief This is the abstract base class for device handlers.
- * @details
- * Documentation: Dissertation Baetz p.138,139, p.141-149
- *
- * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
- *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * If data has been received (GET_READ), the data will be interpreted.
- * The action for each step can be defined by the child class but as most
- * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
- * a default implementation is provided.
- * NOTE: RMAP is a standard which is used for FLP.
- * RMAP communication is not mandatory for projects implementing the FSFW.
- * However, the communication principles are similar to RMAP as there are
- * two write and two send calls involved.
- *
- * Device handler instances should extend this class and implement the abstract
- * functions. Components and drivers can send so called cookies which are used
- * for communication and contain information about the communcation (e.g. slave
- * address for I2C or RMAP structs).
- * The following abstract methods must be implemented by a device handler:
- *  1. doStartUp()
- *  2. doShutDown()
- *  3. buildTransitionDeviceCommand()
- *  4. buildNormalDeviceCommand()
- *  5. buildCommandFromCommand()
- *  6. fillCommandAndReplyMap()
- *  7. scanForReply()
- *  8. interpretDeviceReply()
- *
- * Other important virtual methods with a default implementation
- * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
- * If a transition to MODE_ON is desired without commanding, override the
- * intialize() function and call setMode(_MODE_START_UP) before calling
- * DeviceHandlerBase::initialize().
- *
- * @ingroup devices
- */
-class DeviceHandlerBase: public DeviceHandlerIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasActionsIF,
-		public ReceivesParameterMessagesIF,
-		public HasLocalDataPoolIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * The constructor passes the objectId to the SystemObject().
-	 *
-	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
-	 * @param deviceCommuncation Communcation Interface object which is used
-	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
-	 * @param fdirInstance
-	 * @param cmdQueueSize
-	 */
-	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
-			size_t cmdQueueSize = 20);
-
-	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId);
-
-	/**
-	 * @brief 	This function is the device handler base core component and is
-	 * 			called periodically.
-	 * @details
-	 * General sequence, showing where abstract virtual functions are called:
-	 * If the State is SEND_WRITE:
-	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
-	 *   2. Handles Device State Modes by calling doStateMachine().
-	 *      This function calls callChildStatemachine() which calls the
-	 *      abstract functions doStartUp() and doShutDown()
-	 *   3. Check switch states by calling checkSwitchStates()
-	 *   4. Decrements counter for timeout of replies by calling
-	 *      decrementDeviceReplyMap()
-	 *   5. Performs FDIR check for failures
-	 *   6. Calls hkSwitcher.performOperation()
-	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
-     *      Otherwise, perform the Action property and performs depending
-     *      on value specified by input value counter (incremented in PST).
-     *      The child class tells base class what to do by setting this value.
-	 *     - SEND_WRITE: Send data or commands to device by calling
-	 *       doSendWrite() which calls sendMessage function
-	 *       of #communicationInterface
-	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
-	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
-	 *       which calls getSendSuccess of #communicationInterface.
-	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
-	 *     - SEND_READ: Request reading data from device by calling doSendRead()
-	 *       which calls requestReceiveMessage of #communcationInterface
-	 *     - GET_READ: Access requested reading data by calling doGetRead()
-	 *       which calls readReceivedMessage of #communicationInterface
-	 * @param counter Specifies which Action to perform
-	 * @return RETURN_OK for successful execution
-	 */
-	virtual ReturnValue_t performOperation(uint8_t counter);
-
-	/**
-	 * @brief  Initializes the device handler
-	 * @details
-	 * Initialize Device Handler as system object and
-	 * initializes all important helper classes.
-	 * Calls fillCommandAndReplyMap().
-	 * @return
-	 */
-	virtual ReturnValue_t initialize();
-	/** Destructor. */
-	virtual ~DeviceHandlerBase();
-
-protected:
-	/**
-	 * @brief 	This is used to let the child class handle the transition from
-	 * 			mode @c _MODE_START_UP to @c MODE_ON
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_START_UP.
-	 * That means, the device switch(es) are already set to on.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send
-	 * an reply accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
-	 * the base class handles rejecting the command and sends a reply.
-	 * The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device is started and ready for operation, the mode should be
-	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
-	 *    use the to on transition if available.
-	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
-	 *    which will lead to the device being powered off.
-	 *  - If the device does not change the mode, the mode will be changed
-	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doStartUp() = 0;
-
-	/**
-	 * @brief 	This is used to let the child class handle the transition
-	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
-	 * @details
-	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
-	 * Device handler commands are read and can be handled by the child class.
-	 * If the child class handles a command, it should also send an reply
-	 * accordingly.
-	 * If an Command is not handled (ie #DeviceHandlerCommand is not
-	 * @c CMD_NONE, the base class handles rejecting the command and sends a
-	 * reply. The replies for mode transitions are handled by the base class.
-	 *
-	 *  - If the device ready to be switched off,
-	 *    the mode should be set to _MODE_POWER_DOWN.
-	 *  - If the device should not be switched off, the mode can be changed to
-	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
-	 *  - If the device does not change the mode, the mode will be changed to
-	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
-	 *    has passed.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 */
-	virtual void doShutDown() = 0;
-
-	/**
-	 * Build the device command to send for normal mode.
-	 *
-	 * This is only called in @c MODE_NORMAL. If multiple submodes for
-	 * @c MODE_NORMAL are supported, different commands can built,
-	 * depending on the submode.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the
-	 * packet to be sent. If variable command frequence is required, a counter
-	 * can be used and the frequency in the reply map has to be set manually
-	 * by calling updateReplyMap().
-	 *
-	 * @param[out] id the device command id that has been built
-	 * @return
-	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
-	 *    - @c NOTHING_TO_SEND when no command is to be sent.
-	 *    - Anything else triggers an even with the returnvalue as a parameter.
-	 */
-	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * Build the device command to send for a transitional mode.
-	 *
-	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
-	 * @c _MODE_START_UP and @c _MODE_SHUT_DOWN. So it is used by doStartUp()
-	 * and doShutDown() as well as doTransition(), by setting those
-	 * modes in the respective functions.
-	 *
-	 * A good idea is to implement a flag indicating a command has to be built
-	 * and a variable containing the command number to be built
-	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
-	 * modes have to be checked here.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - @c NOTHING_TO_SEND when no command is to be sent
-	 *    - Anything else triggers an even with the returnvalue as a parameter
-	 */
-	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
-
-	/**
-	 * @brief Build a device command packet from data supplied by a direct command.
-	 *
-	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check
-	 * against 0 are done by the base class.
-	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
-	 * @param commandData pointer to the data from the direct command
-	 * @param commandDataLen length of commandData
-	 * @return
-	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
-	 *     - Anything else triggers an event with the returnvalue as a parameter
-	 */
-	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-			const uint8_t * commandData, size_t commandDataLen) = 0;
-
-	/**
-	 * @brief Scans a buffer for a valid reply.
-	 * @details
-	 * This is used by the base class to check the data received for valid packets.
-	 * It only checks if a valid packet starts at @c start.
-	 * It also only checks the structural validy of the packet,
-	 * e.g. checksums lengths and protocol data. No information check is done,
-	 * e.g. range checks etc.
-	 *
-	 * Errors should be reported directly, the base class does NOT report any
-	 * errors based on the return value of this function.
-	 *
-	 * @param start start of remaining buffer to be scanned
-	 * @param len length of remaining buffer to be scanned
-	 * @param[out] foundId the id of the data found in the buffer.
-	 * @param[out] foundLen length of the data found. Is to be set in function,
-	 *                       buffer is scanned at previous position + foundLen.
-	 * @return
-	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
-	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
-	 *    implies @c foundLen is not valid, base class will call scanForReply()
-	 *    again with ++start
-	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
-	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
-	 *    skip some bytes
-	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
-	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
-	 *    the packet
-	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
-	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
-	 *    requested by a command, but should be handled anyway
-	 *    (@see also fillCommandAndCookieMap() )
-	 */
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
-			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
-
-	/**
-	 * @brief Interpret a reply from the device.
-	 * @details
-	 * This is called after scanForReply() found a valid packet, it can be
-	 * assumed that the length and structure is valid.
-	 * This routine extracts the data from the packet into a DataSet and then
-	 * calls handleDeviceTM(), which either sends a TM packet or stores the
-	 * data in the DataPool depending on whether it was an external command.
-	 * No packet length is given, as it should be defined implicitly by the id.
-	 *
-	 * @param id the id found by scanForReply()
-	 * @param packet
-	 * @return
-	 *     - @c RETURN_OK when the reply was interpreted.
-	 *     - @c RETURN_FAILED when the reply could not be interpreted,
-	 *     e.g. logical errors or range violations occurred
-	 */
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) = 0;
-
-	/**
-	 * @brief fill the #DeviceCommandMap and #DeviceReplyMap
-	 *	 	  called by the initialize() of the base class
-	 * @details
-	 * This is used to let the base class know which replies are expected.
-	 * There are different scenarios regarding this:
-	 *
-	 *  - "Normal" commands. These are commands, that trigger a direct reply
-	 *    from the device. In this case, the id of the command should be added
-	 *    to the command map with a commandData_t where maxDelayCycles is set
-	 *    to the maximum expected number of PST cycles the reply will take.
-	 *    Then, scanForReply returns the id of the command and the base class
-	 *    can handle time-out and missing replies.
-	 *
-	 *  - Periodic, unrequested replies. These are replies that, once enabled,
-	 *    are sent by the device on its own in a defined interval.
-	 *    In this case, the id of the reply or a placeholder id should be added
-	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
-	 *    set to the maximum expected number of PST cycles between two replies
-	 *    (also a tolerance should be added, as an FDIR message will be
-	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
-	 *    From then on, the base class handles the reception.
-	 *    Then, scanForReply returns the id of the reply or the placeholder id
-	 *    and the base class will take care of checking that all replies are
-	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
-	 *
-	 *  - Aperiodic, unrequested replies. These are replies that are sent
-	 *    by the device without any preceding command and not in a defined
-	 *    interval. These are not entered in the deviceCommandMap but
-	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
-	 */
-	virtual void fillCommandAndReplyMap() = 0;
-
-	/**
-	 * This is a helper method to facilitate inserting entries in the command map.
-	 * @param deviceCommand	Identifier of the command to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the command
-	 * waits until it times out.
-	 * @param replyLen Will be supplied to the requestReceiveMessage call of
-	 * the communication interface.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
-			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
-
-	/**
-	 * @brief 	This is a helper method to insert replies in the reply map.
-	 * @param deviceCommand	Identifier of the reply to add.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out.
-	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not. Default is aperiodic (0)
-	 * @return	- @c RETURN_OK when the command was successfully inserted,
-	 *          - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
-
-	/**
-	 * @brief 	A simple command to add a command to the commandList.
-	 * @param deviceCommand The command to add
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
-	/**
-	 * @brief 	This is a helper method to facilitate updating entries
-	 *        	in the reply map.
-	 * @param deviceCommand	Identifier of the reply to update.
-	 * @param delayCycles The current number of delay cycles to wait.
-	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
-	 * this is set to zero.
-	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
-	 * until it times out. By passing 0 the entry remains untouched.
-	 * @param periodic Indicates if the command is periodic (i.e. it is sent
-	 * by the device repeatedly without request) or not.Default is aperiodic (0).
-	 * Warning: The setting always overrides the value that was entered in the map.
-	 * @return - @c RETURN_OK when the command was successfully inserted,
-	 *         - @c RETURN_FAILED else.
-	 */
-	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
-			uint16_t delayCycles, uint16_t maxDelayCycles,
-			bool periodic = false);
-
-	/**
-	 * @brief   Can be implemented by child handler to
-	 *          perform debugging
-	 * @details Example: Calling this in performOperation
-	 *          to track values like mode.
-	 * @param positionTracker Provide the child handler a way to know
-	 * where the debugInterface was called
-	 * @param objectId Provide the child handler object Id to
-	 * specify actions for spefic devices
-	 * @param parameter Supply a parameter of interest
-	 * Please delete all debugInterface calls in DHB after debugging is finished !
-	 */
-	virtual void debugInterface(uint8_t positionTracker = 0,
-			object_id_t objectId = 0, uint32_t parameter = 0);
-
-	/**
-	 * Get the time needed to transit from modeFrom to modeTo.
-	 *
-	 * Used for the following transitions:
-	 * modeFrom -> modeTo:
-	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
-	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
-	 * the base class got you covered)
-	 *
-	 * The default implementation returns 0 !
-	 * @param modeFrom
-	 * @param modeTo
-	 * @return time in ms
-	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
-
-	/**
-	 * Return the switches connected to the device.
-	 *
-	 * The default implementation returns one switch set in the ctor.
-	 *
-	 * @param[out] switches pointer to an array of switches
-	 * @param[out] numberOfSwitches length of returned array
-	 * @return
-	 *      - @c RETURN_OK if the parameters were set
-	 *      - @c RETURN_FAILED if no switches exist
-	 */
-	virtual ReturnValue_t getSwitches(const uint8_t **switches,
-			uint8_t *numberOfSwitches);
-
-	/**
-	 * This function is used to initialize the local housekeeping pool
-	 * entries. The default implementation leaves the pool empty.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	virtual ReturnValue_t initializePoolEntries(
-				LocalDataPool& localDataPoolMap) override;
-
-	/** Get the HK manager object handle */
-	virtual LocalDataPoolManager* getHkManagerHandle() override;
-
-	/**
-	 * @brief 	Hook function for child handlers which is called once per
-	 * 			performOperation(). Default implementation is empty.
-	 */
-	virtual void performOperationHook();
-public:
-	/**
-	 * @param parentQueueId
-	 */
-	virtual void setParentQueue(MessageQueueId_t parentQueueId);
-
-	/** @brief 	Implementation required for HasActionIF */
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data,
-			size_t size) override;
-
-	Mode_t getTransitionSourceMode() const;
-	Submode_t getTransitionSourceSubMode() const;
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	HealthState getHealth();
-	ReturnValue_t setHealth(HealthState health);
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
-	/**
-	 * 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_);
-	virtual MessageQueueId_t getCommandQueue(void) const;
-
-protected:
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
-
-	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
-	// Returnvalues for scanForReply()
-	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
-	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
-	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
-	// Returnvalues for command building
-	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
-	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
-	// Returnvalues for getSwitches()
-	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
-	// Mode handling error Codes
-	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
-
-	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
-	static const DeviceCommandId_t NO_COMMAND_ID = -2;
-	static const MessageQueueId_t NO_COMMANDER = 0;
-
-	/** Pointer to the raw packet that will be sent.*/
-	uint8_t *rawPacket = nullptr;
-	/** Size of the #rawPacket. */
-	uint32_t rawPacketLen = 0;
-
-	/**
-	 * The mode the device handler is currently in.
-	 * This should never be changed directly but only with setMode()
-	 */
-	Mode_t mode;
-	/**
-	 * The submode the device handler is currently in.
-	 * This should never be changed directly but only with setMode()
-	 */
-	Submode_t submode;
-
-	/** This is the counter value from performOperation(). */
-	uint8_t pstStep = 0;
-	uint32_t pstIntervalMs = 0;
-
-	/**
-	 * Wiretapping flag:
-	 *
-	 * indicates either that all raw messages to and from the device should be
-	 * sent to #defaultRawReceiver
-	 * or that all device TM should be downlinked to #defaultRawReceiver.
-	 */
-	enum WiretappingMode {
-		OFF = 0, RAW = 1, TM = 2
-	} wiretappingMode;
-	/**
-	 * @brief 	A message queue that accepts raw replies
-	 *
-	 * Statically initialized in initialize() to a configurable object.
-	 * Used when there is no method of finding a recipient, ie raw mode and
-	 * reporting erroneous replies
-	 */
-	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
-	store_address_t storedRawData;
-
-	/**
-	 * @brief 	The message queue which wants to read all raw traffic
-	 * If #isWiretappingActive all raw communication from and to the device
-	 * will be sent to this queue
-	 */
-	MessageQueueId_t requestedRawTraffic = 0;
-
-	/**
-	 * Pointer to the IPCStore.
-	 * This caches the pointer received from the objectManager in the constructor.
-	 */
-	StorageManagerIF *IPCStore = nullptr;
-	/** The comIF object ID is cached for the intialize() function */
-	object_id_t deviceCommunicationId;
-	/** Communication object used for device communication */
-	DeviceCommunicationIF * communicationInterface = nullptr;
-	/** Cookie used for communication */
-	CookieIF * comCookie;
-
-	/** Health helper for HasHealthIF */
-	HealthHelper healthHelper;
-	/** Mode helper for HasModesIF */
-	ModeHelper modeHelper;
-	/** Parameter helper for ReceivesParameterMessagesIF */
-	ParameterHelper parameterHelper;
-	/** Action helper for HasActionsIF */
-	ActionHelper actionHelper;
-	/** Housekeeping Manager */
-	LocalDataPoolManager hkManager;
-
-	/**
-	 *  @brief Information about commands
-	 */
-	struct DeviceCommandInfo {
-		//! Indicates if the command is already executing.
-		bool isExecuting;
-		//! Dynamic value to indicate how many replies are expected.
-		//! Inititated with 0.
-		uint8_t expectedReplies;
-		//! if this is != NO_COMMANDER, DHB was commanded externally and shall
-		//! report everything to commander.
-		MessageQueueId_t sendReplyTo;
-	};
-	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
-	/**
-	 * Information about commands
-	 */
-	DeviceCommandMap deviceCommandMap;
-
-	/**
-	 * @brief Information about expected replies
-	 * This is used to keep track of pending replies.
-	 */
-	struct DeviceReplyInfo {
-		//! The maximum number of cycles the handler should wait for a reply
-		//! to this command.
-		uint16_t maxDelayCycles;
-		//! The currently remaining cycles the handler should wait for a reply,
-		//! 0 means there is no reply expected
-		uint16_t delayCycles;
-		size_t replyLen = 0; //!< Expected size of the reply.
-		//! if this is !=0, the delayCycles will not be reset to 0 but to
-		//! maxDelayCycles
-		bool periodic = false;
-		//! The dataset used to access housekeeping data related to the
-		//! respective device reply. Will point to a dataset held by
-		//! the child handler (if one is specified)
-		DataSetIF* dataSet = nullptr;
-		float collectionInterval = 0.0;
-		uint32_t intervalCounter = 0;
-		//! The command that expects this reply.
-		DeviceCommandMap::iterator command;
-	};
-
-	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
-	using DeviceReplyIter = DeviceReplyMap::iterator;
-	/**
-	 * This map is used to check and track correct reception of all replies.
-	 *
-	 * It has multiple use:
-	 * - It stores the information on pending replies. If a command is sent,
-	 * 	 the DeviceCommandInfo.count is incremented.
-	 * - It is used to time-out missing replies. If a command is sent, the
-	 * 	 DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
-	 * - It is queried to check if a reply from the device can be interpreted.
-	 *   scanForReply() returns the id of the command a reply was found for.
-	 * The reply is ignored in the following cases:
-	 *     - No entry for the returned id was found
-	 *     - The deviceReplyInfo.delayCycles is == 0
-	 */
-	DeviceReplyMap deviceReplyMap;
-
-	//! The MessageQueue used to receive device handler commands
-	//! and to send replies.
-	MessageQueueIF* commandQueue = nullptr;
-
-	/**
-	 * this is the datapool variable with the thermal state of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
-
-	/**
-	 * this is the datapool variable with the thermal request of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
-
-	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
-	 */
-	ReturnValue_t childTransitionFailure;
-
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
-
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
-
-	HkSwitchHelper hkSwitcher;
-
-	bool defaultFDIRUsed; //!< To correctly delete the default instance.
-
-	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
-
-	//! Pointer to the task which executes this component, is invalid
-	//! before setTaskIF was called.
-	PeriodicTaskIF* executingTask = nullptr;
-
-	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
-
-	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
-
-	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
-	/**
-	 * Helper function to report a missed reply
-	 *
-	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
-	 *
-	 * @param id of the missed reply
-	 */
-	virtual void missedReply(DeviceCommandId_t id);
-
-	/**
-	 * Send a reply to a received device handler command.
-	 *
-	 * This also resets #DeviceHandlerCommand to 0.
-	 *
-	 * @param reply the reply type
-	 * @param parameter parameter for the reply
-	 */
-	void replyReturnvalueToCommand(ReturnValue_t status,
-			uint32_t parameter = 0);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
-
-	/**
-	 * Set the device handler mode
-	 *
-	 * Sets #timeoutStart with every call.
-	 *
-	 * Sets #transitionTargetMode if necessary so transitional states can be
-	 * entered from everywhere without breaking the state machine
-	 * (which relies on a correct #transitionTargetMode).
-	 *
-	 * The submode is left unchanged.
-	 *
-	 *
-	 * @param newMode
-	 */
-	void setMode(Mode_t newMode);
-
-	/**
-	 * @overload
-	 * @param submode
-	 */
-	void setMode(Mode_t newMode, Submode_t submode);
-
-	/**
-	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
-	 *
-	 * If the transition is complete, the mode should be set to the target mode,
-	 * which can be deduced from the current mode which is
-	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
-	 *
-	 * The intended target submode is already set.
-	 * The origin submode can be read in subModeFrom.
-	 *
-	 * If the transition can not be completed, the child class can try to reach
-	 * an working mode by setting the mode either directly
-	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW)
-	 * if the device needs to be reconfigured.
-	 *
-	 * If nothing works, the child class can wait for the timeout and the base
-	 * class will reset the mode to the mode where the transition
-	 * originated from (the child should report the reason for the failed transition).
-	 *
-	 * The intended way to send commands is to set a flag (enum) indicating
-	 * which command is to be sent here and then to check in
-	 * buildTransitionCommand() for the flag. This flag can also be used by
-	 * doStartUp() and doShutDown() to get a nice and clean implementation of
-	 * buildTransitionCommand() without switching through modes.
-	 *
-	 * When the the condition for the completion of the transition is met, the
-	 * mode can be set, for example in the scanForReply() function.
-	 *
-	 * The default implementation goes into the target mode directly.
-	 *
-	 * #transitionFailure can be set to a failure code indicating the reason
-	 * for a failed transition
-	 *
-	 * @param modeFrom
-	 * The mode the transition originated from:
-	 * [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed
-	 * from _MODE_START_UP to _MODE_TO_ON)]
-	 * @param subModeFrom the subMode of modeFrom
-	 */
-	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
-
-	/**
-	 * Is the combination of mode and submode valid?
-	 *
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if valid
-	 *    - @c RETURN_FAILED if invalid
-	 */
-	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-			Submode_t submode);
-
-	/**
-	 * Get the Rmap action for the current step.
-	 *
-	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
-	 */
-
-	virtual CommunicationAction_t getComAction();
-
-	/**
-	 * Build the device command to send for raw mode.
-	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
-	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
-	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
-	 *
-	 * @param[out] id the device command id built
-	 * @return
-	 *    - @c RETURN_OK when a command is to be sent
-	 *    - not @c NOTHING_TO_SEND when no command is to be sent
-	 */
-	virtual ReturnValue_t buildChildRawCommand();
-
-	/**
-	 * Returns the delay cycle count of a reply.
-	 * A count != 0 indicates that the command is already executed.
-	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
-	 */
-	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
-
-	/**
-	 * Construct a command reply containing a raw reply.
-	 *
-	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
-	 * containing the store address.
-	 *
-	 * This method is virtual, as the STR has a different channel to send raw replies
-	 * and overwrites it accordingly.
-	 *
-	 * @param data data to send
-	 * @param len length of @c data
-	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
-	 */
-	virtual void replyRawData(const uint8_t *data, size_t len,
-			MessageQueueId_t sendTo, bool isCommand = false);
-
-	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
-	 * does not send the Data as the wiretapping will have sent it already
-	 */
-	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
-
-	/**
-	 * notify child about mode change
-	 */
-	virtual void modeChanged(void);
-
-	/**
-	 * Enable the reply checking for a command
-	 *
-	 * Is only called, if the command was sent (ie the getWriteReply was successful).
-	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
-	 * uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
-	 * expect one reply.
-	 *
-	 * Can be overwritten by the child, if a command activates multiple replies
-	 * or replyId differs from commandId.
-	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
-	 * 	- A failure code may be returned if something went fundamentally wrong.
-	 *
-	 * @param deviceCommand
-	 * @return 	- RETURN_OK if a reply was activated.
-	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
-	 * 			  error case as many commands do not expect a reply.
-	 */
-	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
-			uint8_t expectedReplies = 1, bool useAlternateId = false,
-			DeviceCommandId_t alternateReplyID = 0);
-
-	/**
-	 * get the state of the PCDU switches in the datapool
-	 *
-	 * @return
-	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
-	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
-	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
-	 */
-	ReturnValue_t getStateOfSwitches(void);
-
-	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
-	/**
-	 * build a list of sids and pass it to the #hkSwitcher
-	 */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
-
-	/**
-	 * Children can overwrite this function to suppress checking of the command Queue
-	 *
-	 * This can be used when the child does not want to receive a command in a certain
-	 * situation. Care must be taken that checking is not permanentely disabled as this
-	 * would render the handler unusable.
-	 *
-	 * @return whether checking the queue should NOT be done
-	 */
-	virtual bool dontCheckQueue();
-
-	Mode_t getBaseMode(Mode_t transitionMode);
-
-	bool isAwaitingReply();
-
-	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t commandId,
-			bool neverInDataPool = false, bool forceDirectTm = false);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-
-	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
-
-	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
-	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
-	 * @param event	The event to be thrown
-	 * @param parameter1	Optional parameter 1
-	 * @param parameter2	Optional parameter 2
-	 */
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-	/**
-	 * Same as triggerEvent, but for forwarding if object is used as proxy.
-	 */
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0) const;
-	/**
-	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
-	 */
-	virtual void checkSwitchState();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
-	 */
-	virtual void doOffActivity();
-
-	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
-	 */
-	virtual void doOnActivity();
-
-	/**
-	 * Checks if current mode is transitional mode.
-	 * @return true if mode is transitional, false else.
-	 */
-	bool isTransitionalMode();
-
-	/**
-	 * Checks if current handler state allows reception of external device commands.
-	 * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
-	 * @return RETURN_OK if commands are accepted, anything else otherwise.
-	 */
-	virtual ReturnValue_t acceptExternalDeviceCommands();
-
-	bool commandIsExecuting(DeviceCommandId_t commandId);
-
-	/**
-	 * set all switches returned by getSwitches()
-	 *
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	void commandSwitch(ReturnValue_t onOff);
-private:
-
-	/**
-	 * State a cookie is in.
-	 *
-	 * Used to keep track of the state of the RMAP communication.
-	 */
-	enum CookieState_t {
-		COOKIE_UNUSED,    //!< The Cookie is unused
-		COOKIE_WRITE_READY, //!< There's data available to send.
-		COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
-		COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
-	};
-	/**
-	 * Information about a cookie.
-	 *
-	 * This is stored in a map for each cookie, to not only track the state, but also information
-	 * about  the sent command. Tracking this information is needed as
-	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
-	 */
-	struct CookieInfo {
-		CookieState_t state;
-		DeviceCommandMap::iterator pendingCommand;
-	};
-
-	/**
-	 * @brief   Info about the #cookie
-	 * Used to track the state of the communication
-	 */
-	CookieInfo cookieInfo;
-
-	/** the object used to set power switches */
-	PowerSwitchIF *powerSwitcher = nullptr;
-
-	/** Cached for initialize() */
-	static object_id_t defaultHkDestination;
-	/** HK destination can also be set individually */
-	object_id_t hkDestination = objects::NO_OBJECT;
-
-	/**
-	 * @brief   Used for timing out mode transitions.
-	 * Set when setMode() is called.
-	 */
-	uint32_t timeoutStart = 0;
-
-	/**
-	 * Delay for the current mode transition, used for time out
-	 */
-	uint32_t childTransitionDelay;
-
-	/**
-	 * @brief   The mode the current transition originated from
-	 *
-	 * This is private so the child can not change it and fuck up the timeouts
-	 *
-	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
-	 * (it is _MODE_POWER_DOWN during this modes)
-	 *
-	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
-	 */
-	Mode_t transitionSourceMode;
-
-	/**
-	 * the submode of the source mode during a transition
-	 */
-	Submode_t transitionSourceSubMode;
-
-	/**
-	 * read the command queue
-	 */
-	void readCommandQueue(void);
-
-	/**
-	 * Handle the device handler mode.
-	 *
-	 * - checks whether commands are valid for the current mode, rejects them accordingly
-	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
-	 */
-	void doStateMachine(void);
-
-	void buildRawDeviceCommand(CommandMessage* message);
-	void buildInternalCommand(void);
-
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
-	/**
-	 * Decrement the counter for the timout of replies.
-	 *
-	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
-	 * but not received).
-	 */
-	void decrementDeviceReplyMap(void);
-
-	/**
-	 * Convenience function to handle a reply.
-	 *
-	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
-	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
-	 *
-	 * It also resets the timeout counter for the command id.
-	 *
-	 * @param data the found packet
-	 * @param id the found id
-	 * @foundLen the length of the packet
-	 */
-	void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
-
-	void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
-	/**
-	 * Build and send a command to the device.
-	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
-	 * sends the command via RMAP.
-	 */
-	void doSendWrite(void);
-
-	/**
-	 * Check if the RMAP sendWrite action was successful.
-	 *
-	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
-	 * - if the action was successful, the reply timout counter is initialized
-	 */
-	void doGetWrite(void);
-
-	/**
-	 * Send a RMAP getRead command.
-	 *
-	 * The size of the getRead command is #maxDeviceReplyLen.
-	 * This is always executed, independently from the current mode.
-	 */
-	void doSendRead(void);
-
-	/**
-	 * Check the getRead reply and the contained data.
-	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
-	 */
-	void doGetRead(void);
-
-	/**
-	 * Retrive data from the #IPCStore.
-	 *
-	 * @param storageAddress
-	 * @param[out] data
-	 * @param[out] len
-	 * @return
-	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is NULL
-	 *   - the return value from the IPCStore if it was not @c RETURN_OK
-	 */
-	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
-			uint32_t *len);
-
-
-	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
-	 */
-	void setTransition(Mode_t modeTo, Submode_t submodeTo);
-
-	/**
-	 * calls the right child function for the transitional submodes
-	 */
-	void callChildStatemachine();
-
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
-	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
-
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-	DataSetIF* getDataSetHandle(sid_t sid) override;
-
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
-
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../action/HasActionsIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../modes/HasModesIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+#include "../action/ActionHelper.h"
+#include "../health/HealthHelper.h"
+#include "../parameters/ParameterHelper.h"
+#include "../datapool/HkSwitchHelper.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include <map>
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class StorageManagerIF;
+
+/**
+ * @defgroup devices Devices
+ * Contains all devices and the DeviceHandlerBase class.
+ */
+
+/**
+ * @brief This is the abstract base class for device handlers.
+ * @details
+ * Documentation: Dissertation Baetz p.138,139, p.141-149
+ *
+ * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
+ * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
+ * and communication with commanding objects.
+ * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ *
+ * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
+ * For each step an RMAP action is selected and executed.
+ * If data has been received (GET_READ), the data will be interpreted.
+ * The action for each step can be defined by the child class but as most
+ * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
+ * a default implementation is provided.
+ * NOTE: RMAP is a standard which is used for FLP.
+ * RMAP communication is not mandatory for projects implementing the FSFW.
+ * However, the communication principles are similar to RMAP as there are
+ * two write and two send calls involved.
+ *
+ * Device handler instances should extend this class and implement the abstract
+ * functions. Components and drivers can send so called cookies which are used
+ * for communication and contain information about the communcation (e.g. slave
+ * address for I2C or RMAP structs).
+ * The following abstract methods must be implemented by a device handler:
+ *  1. doStartUp()
+ *  2. doShutDown()
+ *  3. buildTransitionDeviceCommand()
+ *  4. buildNormalDeviceCommand()
+ *  5. buildCommandFromCommand()
+ *  6. fillCommandAndReplyMap()
+ *  7. scanForReply()
+ *  8. interpretDeviceReply()
+ *
+ * Other important virtual methods with a default implementation
+ * are the getTransitionDelayMs() function and the getSwitches() function.
+ * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
+ * power switches are not implemented yet. Otherwise, the device handler will
+ * not transition to MODE_ON, even if setMode(MODE_ON) is called.
+ * If a transition to MODE_ON is desired without commanding, override the
+ * intialize() function and call setMode(_MODE_START_UP) before calling
+ * DeviceHandlerBase::initialize().
+ *
+ * @ingroup devices
+ */
+class DeviceHandlerBase: public DeviceHandlerIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasActionsIF,
+		public ReceivesParameterMessagesIF,
+		public HasLocalDataPoolIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * The constructor passes the objectId to the SystemObject().
+	 *
+	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
+	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
+	 * @param setDeviceSwitch the switch the device is connected to,
+	 * for devices using two switches, overwrite getSwitches()
+	 * @param deviceCommuncation Communcation Interface object which is used
+	 * to implement communication functions
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 * @param fdirInstance
+	 * @param cmdQueueSize
+	 */
+	DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * comCookie, FailureIsolationBase* fdirInstance = nullptr,
+			size_t cmdQueueSize = 20);
+
+	void setHkDestination(object_id_t hkDestination);
+	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
+			uint32_t thermalRequestPoolId);
+
+	/**
+	 * @brief 	This function is the device handler base core component and is
+	 * 			called periodically.
+	 * @details
+	 * General sequence, showing where abstract virtual functions are called:
+	 * If the State is SEND_WRITE:
+	 *   1. Set the cookie state to COOKIE_UNUSED and read the command queue
+	 *   2. Handles Device State Modes by calling doStateMachine().
+	 *      This function calls callChildStatemachine() which calls the
+	 *      abstract functions doStartUp() and doShutDown()
+	 *   3. Check switch states by calling checkSwitchStates()
+	 *   4. Decrements counter for timeout of replies by calling
+	 *      decrementDeviceReplyMap()
+	 *   5. Performs FDIR check for failures
+	 *   6. Calls hkSwitcher.performOperation()
+	 *   7. If the device mode is MODE_OFF, return RETURN_OK.
+     *      Otherwise, perform the Action property and performs depending
+     *      on value specified by input value counter (incremented in PST).
+     *      The child class tells base class what to do by setting this value.
+	 *     - SEND_WRITE: Send data or commands to device by calling
+	 *       doSendWrite() which calls sendMessage function
+	 *       of #communicationInterface
+	 *     	 and calls buildInternalCommand if the cookie state is COOKIE_UNUSED
+	 *     - GET_WRITE: Get ackknowledgement for sending by calling doGetWrite()
+	 *       which calls getSendSuccess of #communicationInterface.
+	 *       Calls abstract functions scanForReply() and interpretDeviceReply().
+	 *     - SEND_READ: Request reading data from device by calling doSendRead()
+	 *       which calls requestReceiveMessage of #communcationInterface
+	 *     - GET_READ: Access requested reading data by calling doGetRead()
+	 *       which calls readReceivedMessage of #communicationInterface
+	 * @param counter Specifies which Action to perform
+	 * @return RETURN_OK for successful execution
+	 */
+	virtual ReturnValue_t performOperation(uint8_t counter);
+
+	/**
+	 * @brief  Initializes the device handler
+	 * @details
+	 * Initialize Device Handler as system object and
+	 * initializes all important helper classes.
+	 * Calls fillCommandAndReplyMap().
+	 * @return
+	 */
+	virtual ReturnValue_t initialize();
+	/** Destructor. */
+	virtual ~DeviceHandlerBase();
+
+protected:
+	/**
+	 * @brief 	This is used to let the child class handle the transition from
+	 * 			mode @c _MODE_START_UP to @c MODE_ON
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_START_UP.
+	 * That means, the device switch(es) are already set to on.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send
+	 * an reply accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not @c CMD_NONE,
+	 * the base class handles rejecting the command and sends a reply.
+	 * The replies for mode transitions are handled by the base class.
+	 *
+	 *  - If the device is started and ready for operation, the mode should be
+	 *    set to MODE_ON. It is possible to set the mode to _MODE_TO_ON to
+	 *    use the to on transition if available.
+	 *  - If the power-up fails, the mode should be set to _MODE_POWER_DOWN
+	 *    which will lead to the device being powered off.
+	 *  - If the device does not change the mode, the mode will be changed
+	 *    to _MODE_POWER_DOWN, after the timeout (from getTransitionDelay())
+	 *    has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
+	 */
+	virtual void doStartUp() = 0;
+
+	/**
+	 * @brief 	This is used to let the child class handle the transition
+	 * 			from mode @c _MODE_SHUT_DOWN to @c _MODE_POWER_DOWN
+	 * @details
+	 * It is only called when the device handler is in mode @c _MODE_SHUT_DOWN.
+	 * Device handler commands are read and can be handled by the child class.
+	 * If the child class handles a command, it should also send an reply
+	 * accordingly.
+	 * If an Command is not handled (ie #DeviceHandlerCommand is not
+	 * @c CMD_NONE, the base class handles rejecting the command and sends a
+	 * reply. The replies for mode transitions are handled by the base class.
+	 *
+	 *  - If the device ready to be switched off,
+	 *    the mode should be set to _MODE_POWER_DOWN.
+	 *  - If the device should not be switched off, the mode can be changed to
+	 *     _MODE_TO_ON (or MODE_ON if no transition is needed).
+	 *  - If the device does not change the mode, the mode will be changed to
+	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
+	 *    has passed.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
+	 */
+	virtual void doShutDown() = 0;
+
+	/**
+	 * Build the device command to send for normal mode.
+	 *
+	 * This is only called in @c MODE_NORMAL. If multiple submodes for
+	 * @c MODE_NORMAL are supported, different commands can built,
+	 * depending on the submode.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent. If variable command frequence is required, a counter
+	 * can be used and the frequency in the reply map has to be set manually
+	 * by calling updateReplyMap().
+	 *
+	 * @param[out] id the device command id that has been built
+	 * @return
+	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
+	 *    - @c NOTHING_TO_SEND when no command is to be sent.
+	 *    - Anything else triggers an even with the returnvalue as a parameter.
+	 */
+	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * Build the device command to send for a transitional mode.
+	 *
+	 * This is only called in @c _MODE_TO_NORMAL, @c _MODE_TO_ON, @c _MODE_TO_RAW,
+	 * @c _MODE_START_UP and @c _MODE_SHUT_DOWN. So it is used by doStartUp()
+	 * and doShutDown() as well as doTransition(), by setting those
+	 * modes in the respective functions.
+	 *
+	 * A good idea is to implement a flag indicating a command has to be built
+	 * and a variable containing the command number to be built
+	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
+	 * modes have to be checked here.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - @c NOTHING_TO_SEND when no command is to be sent
+	 *    - Anything else triggers an even with the returnvalue as a parameter
+	 */
+	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
+
+	/**
+	 * @brief Build a device command packet from data supplied by a direct command.
+	 *
+	 * @details
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
+	 * The existence of the command in the command map and the command size check
+	 * against 0 are done by the base class.
+	 *
+	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param commandData pointer to the data from the direct command
+	 * @param commandDataLen length of commandData
+	 * @return
+	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
+	 *     - Anything else triggers an event with the returnvalue as a parameter
+	 */
+	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t * commandData, size_t commandDataLen) = 0;
+
+	/**
+	 * @brief Scans a buffer for a valid reply.
+	 * @details
+	 * This is used by the base class to check the data received for valid packets.
+	 * It only checks if a valid packet starts at @c start.
+	 * It also only checks the structural validy of the packet,
+	 * e.g. checksums lengths and protocol data. No information check is done,
+	 * e.g. range checks etc.
+	 *
+	 * Errors should be reported directly, the base class does NOT report any
+	 * errors based on the return value of this function.
+	 *
+	 * @param start start of remaining buffer to be scanned
+	 * @param len length of remaining buffer to be scanned
+	 * @param[out] foundId the id of the data found in the buffer.
+	 * @param[out] foundLen length of the data found. Is to be set in function,
+	 *                       buffer is scanned at previous position + foundLen.
+	 * @return
+	 *  - @c RETURN_OK a valid packet was found at @c start, @c foundLen is valid
+	 *  - @c RETURN_FAILED no reply could be found starting at @c start,
+	 *    implies @c foundLen is not valid, base class will call scanForReply()
+	 *    again with ++start
+	 *  - @c DeviceHandlerIF::INVALID_DATA a packet was found but it is invalid,
+	 *    e.g. checksum error, implies @c foundLen is valid, can be used to
+	 *    skip some bytes
+	 *  - @c DeviceHandlerIF::LENGTH_MISSMATCH @c len is invalid
+	 *  - @c DeviceHandlerIF::IGNORE_REPLY_DATA Ignore this specific part of
+	 *    the packet
+	 *  - @c DeviceHandlerIF::IGNORE_FULL_PACKET Ignore the packet
+	 *  - @c APERIODIC_REPLY if a valid reply is received that has not been
+	 *    requested by a command, but should be handled anyway
+	 *    (@see also fillCommandAndCookieMap() )
+	 */
+	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) = 0;
+
+	/**
+	 * @brief Interpret a reply from the device.
+	 * @details
+	 * This is called after scanForReply() found a valid packet, it can be
+	 * assumed that the length and structure is valid.
+	 * This routine extracts the data from the packet into a DataSet and then
+	 * calls handleDeviceTM(), which either sends a TM packet or stores the
+	 * data in the DataPool depending on whether it was an external command.
+	 * No packet length is given, as it should be defined implicitly by the id.
+	 *
+	 * @param id the id found by scanForReply()
+	 * @param packet
+	 * @return
+	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c RETURN_FAILED when the reply could not be interpreted,
+	 *     e.g. logical errors or range violations occurred
+	 */
+	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+			const uint8_t *packet) = 0;
+
+	/**
+	 * @brief fill the #DeviceCommandMap and #DeviceReplyMap
+	 *	 	  called by the initialize() of the base class
+	 * @details
+	 * This is used to let the base class know which replies are expected.
+	 * There are different scenarios regarding this:
+	 *
+	 *  - "Normal" commands. These are commands, that trigger a direct reply
+	 *    from the device. In this case, the id of the command should be added
+	 *    to the command map with a commandData_t where maxDelayCycles is set
+	 *    to the maximum expected number of PST cycles the reply will take.
+	 *    Then, scanForReply returns the id of the command and the base class
+	 *    can handle time-out and missing replies.
+	 *
+	 *  - Periodic, unrequested replies. These are replies that, once enabled,
+	 *    are sent by the device on its own in a defined interval.
+	 *    In this case, the id of the reply or a placeholder id should be added
+	 *    to the deviceCommandMap with a commandData_t where maxDelayCycles is
+	 *    set to the maximum expected number of PST cycles between two replies
+	 *    (also a tolerance should be added, as an FDIR message will be
+	 *    generated if it is missed).
+	 *
+	 *    (Robin) This part confuses me. "must do as soon as" implies that
+	 *    the developer must do something somewhere else in the code. Is
+	 *    that really the case? If I understood correctly, DHB performs
+	 *    almost everything (e.g. in erirm function) as long as the commands
+	 *    are inserted correctly.
+	 *
+	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
+	 *    be set to true, DeviceCommandInfo.delayCycles to
+	 *    DeviceCommandInfo.maxDelayCycles.
+	 *    From then on, the base class handles the reception.
+	 *    Then, scanForReply returns the id of the reply or the placeholder id
+	 *    and the base class will take care of checking that all replies are
+	 *    received and the interval is correct.
+	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
+	 *    to 0, DeviceCommandInfo.delayCycles to 0;
+	 *
+	 *  - Aperiodic, unrequested replies. These are replies that are sent
+	 *    by the device without any preceding command and not in a defined
+	 *    interval. These are not entered in the deviceCommandMap but
+	 *    handled by returning @c APERIODIC_REPLY in scanForReply().
+	 */
+	virtual void fillCommandAndReplyMap() = 0;
+
+	/**
+	 * This is a helper method to facilitate inserting entries in the command map.
+	 * @param deviceCommand	Identifier of the command to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the command
+	 * waits until it times out.
+	 * @param replyLen Will be supplied to the requestReceiveMessage call of
+	 * the communication interface.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
+
+	/**
+	 * @brief 	This is a helper method to insert replies in the reply map.
+	 * @param deviceCommand	Identifier of the reply to add.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out.
+	 * @param periodic	Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not. Default is aperiodic (0)
+	 * @return	- @c RETURN_OK when the command was successfully inserted,
+	 *          - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
+			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+
+	/**
+	 * @brief 	A simple command to add a command to the commandList.
+	 * @param deviceCommand The command to add
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t insertInCommandMap(DeviceCommandId_t deviceCommand);
+	/**
+	 * @brief 	This is a helper method to facilitate updating entries
+	 *        	in the reply map.
+	 * @param deviceCommand	Identifier of the reply to update.
+	 * @param delayCycles The current number of delay cycles to wait.
+	 * As stated in #fillCommandAndCookieMap, to disable periodic commands,
+	 * this is set to zero.
+	 * @param maxDelayCycles The maximum number of delay cycles the reply waits
+	 * until it times out. By passing 0 the entry remains untouched.
+	 * @param periodic Indicates if the command is periodic (i.e. it is sent
+	 * by the device repeatedly without request) or not.Default is aperiodic (0).
+	 * Warning: The setting always overrides the value that was entered in the map.
+	 * @return - @c RETURN_OK when the command was successfully inserted,
+	 *         - @c RETURN_FAILED else.
+	 */
+	ReturnValue_t updateReplyMapEntry(DeviceCommandId_t deviceReply,
+			uint16_t delayCycles, uint16_t maxDelayCycles,
+			bool periodic = false);
+
+	/**
+	 * @brief   Can be implemented by child handler to
+	 *          perform debugging
+	 * @details Example: Calling this in performOperation
+	 *          to track values like mode.
+	 * @param positionTracker Provide the child handler a way to know
+	 * where the debugInterface was called
+	 * @param objectId Provide the child handler object Id to
+	 * specify actions for spefic devices
+	 * @param parameter Supply a parameter of interest
+	 * Please delete all debugInterface calls in DHB after debugging is finished !
+	 */
+	virtual void debugInterface(uint8_t positionTracker = 0,
+			object_id_t objectId = 0, uint32_t parameter = 0);
+
+	/**
+	 * Get the time needed to transit from modeFrom to modeTo.
+	 *
+	 * Used for the following transitions:
+	 * modeFrom -> modeTo:
+	 * MODE_ON -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_NORMAL -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * MODE_RAW -> [MODE_ON, MODE_NORMAL, MODE_RAW, _MODE_POWER_DOWN]
+	 * _MODE_START_UP -> MODE_ON (do not include time to set the switches,
+	 * the base class got you covered)
+	 *
+	 * The default implementation returns 0 !
+	 * @param modeFrom
+	 * @param modeTo
+	 * @return time in ms
+	 */
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+
+	/**
+	 * Return the switches connected to the device.
+	 *
+	 * The default implementation returns one switch set in the ctor.
+	 *
+	 * @param[out] switches pointer to an array of switches
+	 * @param[out] numberOfSwitches length of returned array
+	 * @return
+	 *      - @c RETURN_OK if the parameters were set
+	 *      - @c RETURN_FAILED if no switches exist
+	 */
+	virtual ReturnValue_t getSwitches(const uint8_t **switches,
+			uint8_t *numberOfSwitches);
+
+	/**
+	 * This function is used to initialize the local housekeeping pool
+	 * entries. The default implementation leaves the pool empty.
+	 * @param localDataPoolMap
+	 * @return
+	 */
+	virtual ReturnValue_t initializePoolEntries(
+				LocalDataPool& localDataPoolMap) override;
+
+	/** Get the HK manager object handle */
+	virtual LocalDataPoolManager* getHkManagerHandle() override;
+
+	/**
+	 * @brief 	Hook function for child handlers which is called once per
+	 * 			performOperation(). Default implementation is empty.
+	 */
+	virtual void performOperationHook();
+public:
+	/**
+	 * @param parentQueueId
+	 */
+	virtual void setParentQueue(MessageQueueId_t parentQueueId);
+
+	/** @brief 	Implementation required for HasActionIF */
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data,
+			size_t size) override;
+
+	Mode_t getTransitionSourceMode() const;
+	Submode_t getTransitionSourceSubMode() const;
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+	HealthState getHealth();
+	ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
+	/**
+	 * 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_);
+	virtual MessageQueueId_t getCommandQueue(void) const;
+
+protected:
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;
+
+	static const ReturnValue_t INVALID_CHANNEL = MAKE_RETURN_CODE(0xA0);
+	// Returnvalues for scanForReply()
+	static const ReturnValue_t APERIODIC_REPLY = MAKE_RETURN_CODE(0xB0); //!< This is used to specify for replies from a device which are not replies to requests
+	static const ReturnValue_t IGNORE_REPLY_DATA = MAKE_RETURN_CODE(0xB1); //!< Ignore parts of the received packet
+	static const ReturnValue_t IGNORE_FULL_PACKET = MAKE_RETURN_CODE(0xB2); //!< Ignore full received packet
+	// Returnvalues for command building
+	static const ReturnValue_t NOTHING_TO_SEND = MAKE_RETURN_CODE(0xC0); //!< Return this if no command sending in required
+	static const ReturnValue_t COMMAND_MAP_ERROR = MAKE_RETURN_CODE(0xC2);
+	// Returnvalues for getSwitches()
+	static const ReturnValue_t NO_SWITCH = MAKE_RETURN_CODE(0xD0);
+	// Mode handling error Codes
+	static const ReturnValue_t CHILD_TIMEOUT = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t SWITCH_FAILED = MAKE_RETURN_CODE(0xE1);
+
+	static const DeviceCommandId_t RAW_COMMAND_ID = -1;
+	static const DeviceCommandId_t NO_COMMAND_ID = -2;
+	static const MessageQueueId_t NO_COMMANDER = 0;
+
+	/** Pointer to the raw packet that will be sent.*/
+	uint8_t *rawPacket = nullptr;
+	/** Size of the #rawPacket. */
+	uint32_t rawPacketLen = 0;
+
+	/**
+	 * The mode the device handler is currently in.
+	 * This should never be changed directly but only with setMode()
+	 */
+	Mode_t mode;
+	/**
+	 * The submode the device handler is currently in.
+	 * This should never be changed directly but only with setMode()
+	 */
+	Submode_t submode;
+
+	/** This is the counter value from performOperation(). */
+	uint8_t pstStep = 0;
+	uint32_t pstIntervalMs = 0;
+
+	/**
+	 * Wiretapping flag:
+	 *
+	 * indicates either that all raw messages to and from the device should be
+	 * sent to #defaultRawReceiver
+	 * or that all device TM should be downlinked to #defaultRawReceiver.
+	 */
+	enum WiretappingMode {
+		OFF = 0, RAW = 1, TM = 2
+	} wiretappingMode;
+	/**
+	 * @brief 	A message queue that accepts raw replies
+	 *
+	 * Statically initialized in initialize() to a configurable object.
+	 * Used when there is no method of finding a recipient, ie raw mode and
+	 * reporting erroneous replies
+	 */
+	MessageQueueId_t defaultRawReceiver = MessageQueueIF::NO_QUEUE;
+	store_address_t storedRawData;
+
+	/**
+	 * @brief 	The message queue which wants to read all raw traffic
+	 * If #isWiretappingActive all raw communication from and to the device
+	 * will be sent to this queue
+	 */
+	MessageQueueId_t requestedRawTraffic = 0;
+
+	/**
+	 * Pointer to the IPCStore.
+	 * This caches the pointer received from the objectManager in the constructor.
+	 */
+	StorageManagerIF *IPCStore = nullptr;
+	/** The comIF object ID is cached for the intialize() function */
+	object_id_t deviceCommunicationId;
+	/** Communication object used for device communication */
+	DeviceCommunicationIF * communicationInterface = nullptr;
+	/** Cookie used for communication */
+	CookieIF * comCookie;
+
+	/** Health helper for HasHealthIF */
+	HealthHelper healthHelper;
+	/** Mode helper for HasModesIF */
+	ModeHelper modeHelper;
+	/** Parameter helper for ReceivesParameterMessagesIF */
+	ParameterHelper parameterHelper;
+	/** Action helper for HasActionsIF */
+	ActionHelper actionHelper;
+	/** Housekeeping Manager */
+	LocalDataPoolManager hkManager;
+
+	/**
+	 *  @brief Information about commands
+	 */
+	struct DeviceCommandInfo {
+		//! Indicates if the command is already executing.
+		bool isExecuting;
+		//! Dynamic value to indicate how many replies are expected.
+		//! Inititated with 0.
+		uint8_t expectedReplies;
+		//! if this is != NO_COMMANDER, DHB was commanded externally and shall
+		//! report everything to commander.
+		MessageQueueId_t sendReplyTo;
+	};
+	using DeviceCommandMap = std::map<DeviceCommandId_t, DeviceCommandInfo> ;
+	/**
+	 * Information about commands
+	 */
+	DeviceCommandMap deviceCommandMap;
+
+	/**
+	 * @brief Information about expected replies
+	 * This is used to keep track of pending replies.
+	 */
+	struct DeviceReplyInfo {
+		//! The maximum number of cycles the handler should wait for a reply
+		//! to this command.
+		uint16_t maxDelayCycles;
+		//! The currently remaining cycles the handler should wait for a reply,
+		//! 0 means there is no reply expected
+		uint16_t delayCycles;
+		size_t replyLen = 0; //!< Expected size of the reply.
+		//! if this is !=0, the delayCycles will not be reset to 0 but to
+		//! maxDelayCycles
+		bool periodic = false;
+		//! The dataset used to access housekeeping data related to the
+		//! respective device reply. Will point to a dataset held by
+		//! the child handler (if one is specified)
+		DataSetIF* dataSet = nullptr;
+		float collectionInterval = 0.0;
+		uint32_t intervalCounter = 0;
+		//! The command that expects this reply.
+		DeviceCommandMap::iterator command;
+	};
+
+	using DeviceReplyMap = std::map<DeviceCommandId_t, DeviceReplyInfo> ;
+	using DeviceReplyIter = DeviceReplyMap::iterator;
+	/**
+	 * This map is used to check and track correct reception of all replies.
+	 *
+	 * It has multiple use:
+	 * - It stores the information on pending replies. If a command is sent,
+	 * 	 the DeviceCommandInfo.count is incremented.
+	 * - It is used to time-out missing replies. If a command is sent, the
+	 * 	 DeviceCommandInfo.DelayCycles is set to MaxDelayCycles.
+	 * - It is queried to check if a reply from the device can be interpreted.
+	 *   scanForReply() returns the id of the command a reply was found for.
+	 * The reply is ignored in the following cases:
+	 *     - No entry for the returned id was found
+	 *     - The deviceReplyInfo.delayCycles is == 0
+	 */
+	DeviceReplyMap deviceReplyMap;
+
+	//! The MessageQueue used to receive device handler commands
+	//! and to send replies.
+	MessageQueueIF* commandQueue = nullptr;
+
+	/**
+	 * this is the datapool variable with the thermal state of the device
+	 *
+	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
+	 */
+	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
+
+	/**
+	 * this is the datapool variable with the thermal request of the device
+	 *
+	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
+	 */
+	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
+
+	/**
+	 * Optional Error code
+	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 */
+	ReturnValue_t childTransitionFailure;
+
+	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+
+	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+
+	HkSwitchHelper hkSwitcher;
+
+	bool defaultFDIRUsed; //!< To correctly delete the default instance.
+
+	bool switchOffWasReported; //!< Indicates if SWITCH_WENT_OFF was already thrown.
+
+	//! Pointer to the task which executes this component, is invalid
+	//! before setTaskIF was called.
+	PeriodicTaskIF* executingTask = nullptr;
+
+	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
+
+	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
+
+	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
+	/**
+	 * Helper function to report a missed reply
+	 *
+	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
+	 *
+	 * @param id of the missed reply
+	 */
+	virtual void missedReply(DeviceCommandId_t id);
+
+	/**
+	 * Send a reply to a received device handler command.
+	 *
+	 * This also resets #DeviceHandlerCommand to 0.
+	 *
+	 * @param reply the reply type
+	 * @param parameter parameter for the reply
+	 */
+	void replyReturnvalueToCommand(ReturnValue_t status,
+			uint32_t parameter = 0);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter = 0);
+
+	/**
+	 * Set the device handler mode
+	 *
+	 * Sets #timeoutStart with every call.
+	 *
+	 * Sets #transitionTargetMode if necessary so transitional states can be
+	 * entered from everywhere without breaking the state machine
+	 * (which relies on a correct #transitionTargetMode).
+	 *
+	 * The submode is left unchanged.
+	 *
+	 *
+	 * @param newMode
+	 */
+	void setMode(Mode_t newMode);
+
+	/**
+	 * @overload
+	 * @param submode
+	 */
+	void setMode(Mode_t newMode, Submode_t submode);
+
+	/**
+	 * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
+	 *
+	 * If the transition is complete, the mode should be set to the target mode,
+	 * which can be deduced from the current mode which is
+	 * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
+	 *
+	 * The intended target submode is already set.
+	 * The origin submode can be read in subModeFrom.
+	 *
+	 * If the transition can not be completed, the child class can try to reach
+	 * an working mode by setting the mode either directly
+	 * or setting the mode to an transitional mode (TO_ON, TO_NORMAL, TO_RAW)
+	 * if the device needs to be reconfigured.
+	 *
+	 * If nothing works, the child class can wait for the timeout and the base
+	 * class will reset the mode to the mode where the transition
+	 * originated from (the child should report the reason for the failed transition).
+	 *
+	 * The intended way to send commands is to set a flag (enum) indicating
+	 * which command is to be sent here and then to check in
+	 * buildTransitionCommand() for the flag. This flag can also be used by
+	 * doStartUp() and doShutDown() to get a nice and clean implementation of
+	 * buildTransitionCommand() without switching through modes.
+	 *
+	 * When the the condition for the completion of the transition is met, the
+	 * mode can be set, for example in the scanForReply() function.
+	 *
+	 * The default implementation goes into the target mode directly.
+	 *
+	 * #transitionFailure can be set to a failure code indicating the reason
+	 * for a failed transition
+	 *
+	 * @param modeFrom
+	 * The mode the transition originated from:
+	 * [MODE_ON, MODE_NORMAL, MODE_RAW and _MODE_POWER_DOWN (if the mode changed
+	 * from _MODE_START_UP to _MODE_TO_ON)]
+	 * @param subModeFrom the subMode of modeFrom
+	 */
+	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
+
+	/**
+	 * Is the combination of mode and submode valid?
+	 *
+	 * @param mode
+	 * @param submode
+	 * @return
+	 *    - @c RETURN_OK if valid
+	 *    - @c RETURN_FAILED if invalid
+	 */
+	virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+			Submode_t submode);
+
+	/**
+	 * Get the Rmap action for the current step.
+	 *
+	 * The step number can be read from #pstStep.
+	 *
+	 * @return The Rmap action to execute in this step
+	 */
+
+	virtual CommunicationAction_t getComAction();
+
+	/**
+	 * Build the device command to send for raw mode.
+	 *
+	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
+	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
+	 * Its only current use is in the STR handler which gets its raw packets from a different
+	 * source.
+	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 *
+	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 *
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 *
+	 * @param[out] id the device command id built
+	 * @return
+	 *    - @c RETURN_OK when a command is to be sent
+	 *    - not @c NOTHING_TO_SEND when no command is to be sent
+	 */
+	virtual ReturnValue_t buildChildRawCommand();
+
+	/**
+	 * Returns the delay cycle count of a reply.
+	 * A count != 0 indicates that the command is already executed.
+	 * @param deviceCommand	The command to look for
+	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 */
+	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
+
+	/**
+	 * Construct a command reply containing a raw reply.
+	 *
+	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
+	 * containing the store address.
+	 *
+	 * This method is virtual, as the STR has a different channel to send raw replies
+	 * and overwrites it accordingly.
+	 *
+	 * @param data data to send
+	 * @param len length of @c data
+	 * @param sendTo the messageQueueId of the one to send to
+	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
+	 */
+	virtual void replyRawData(const uint8_t *data, size_t len,
+			MessageQueueId_t sendTo, bool isCommand = false);
+
+	/**
+	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
+	 * does not send the Data as the wiretapping will have sent it already
+	 */
+	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
+
+	/**
+	 * notify child about mode change
+	 */
+	virtual void modeChanged(void);
+
+	/**
+	 * Enable the reply checking for a command
+	 *
+	 * Is only called, if the command was sent (ie the getWriteReply was successful).
+	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
+	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
+	 * uses the alternativeReplyId if flagged so.
+	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
+	 * expect one reply.
+	 *
+	 * Can be overwritten by the child, if a command activates multiple replies
+	 * or replyId differs from commandId.
+	 * Notes for child implementations:
+	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
+	 * 	- A failure code may be returned if something went fundamentally wrong.
+	 *
+	 * @param deviceCommand
+	 * @return 	- RETURN_OK if a reply was activated.
+	 * 			- NO_REPLY_EXPECTED if there was no reply found. This is not an
+	 * 			  error case as many commands do not expect a reply.
+	 */
+	virtual ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator cmd,
+			uint8_t expectedReplies = 1, bool useAlternateId = false,
+			DeviceCommandId_t alternateReplyID = 0);
+
+	/**
+	 * get the state of the PCDU switches in the datapool
+	 *
+	 * @return
+	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
+	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
+	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
+	 */
+	ReturnValue_t getStateOfSwitches(void);
+
+	/**
+	 * set all datapool variables that are update periodically in normal mode invalid
+	 *
+	 * Child classes should provide an implementation which sets all those variables invalid
+	 * which are set periodically during any normal mode.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid() = 0;
+
+	/**
+	 * build a list of sids and pass it to the #hkSwitcher
+	 */
+	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
+
+	/**
+	 * Children can overwrite this function to suppress checking of the command Queue
+	 *
+	 * This can be used when the child does not want to receive a command in a certain
+	 * situation. Care must be taken that checking is not permanentely disabled as this
+	 * would render the handler unusable.
+	 *
+	 * @return whether checking the queue should NOT be done
+	 */
+	virtual bool dontCheckQueue();
+
+	Mode_t getBaseMode(Mode_t transitionMode);
+
+	bool isAwaitingReply();
+
+	void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t commandId,
+			bool neverInDataPool = false, bool forceDirectTm = false);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+	virtual void setToExternalControl();
+	virtual void announceMode(bool recursive);
+
+	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
+
+	/**
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
+	 * @param event	The event to be thrown
+	 * @param parameter1	Optional parameter 1
+	 * @param parameter2	Optional parameter 2
+	 */
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+	/**
+	 * Same as triggerEvent, but for forwarding if object is used as proxy.
+	 */
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0) const;
+	/**
+	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
+	 */
+	virtual void checkSwitchState();
+
+	/**
+	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
+	 */
+	virtual void doOffActivity();
+
+	/**
+	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
+	 */
+	virtual void doOnActivity();
+
+	/**
+	 * Checks if current mode is transitional mode.
+	 * @return true if mode is transitional, false else.
+	 */
+	bool isTransitionalMode();
+
+	/**
+	 * Checks if current handler state allows reception of external device commands.
+	 * Default implementation allows commands only in plain MODE_ON and MODE_NORMAL.
+	 * @return RETURN_OK if commands are accepted, anything else otherwise.
+	 */
+	virtual ReturnValue_t acceptExternalDeviceCommands();
+
+	bool commandIsExecuting(DeviceCommandId_t commandId);
+
+	/**
+	 * set all switches returned by getSwitches()
+	 *
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	void commandSwitch(ReturnValue_t onOff);
+private:
+
+	/**
+	 * State a cookie is in.
+	 *
+	 * Used to keep track of the state of the RMAP communication.
+	 */
+	enum CookieState_t {
+		COOKIE_UNUSED,    //!< The Cookie is unused
+		COOKIE_WRITE_READY, //!< There's data available to send.
+		COOKIE_READ_SENT, //!< A sendRead command was sent with this cookie
+		COOKIE_WRITE_SENT //!< A sendWrite command was sent with this cookie
+	};
+	/**
+	 * Information about a cookie.
+	 *
+	 * This is stored in a map for each cookie, to not only track the state, but also information
+	 * about  the sent command. Tracking this information is needed as
+	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
+	 */
+	struct CookieInfo {
+		CookieState_t state;
+		DeviceCommandMap::iterator pendingCommand;
+	};
+
+	/**
+	 * @brief   Info about the #cookie
+	 * Used to track the state of the communication
+	 */
+	CookieInfo cookieInfo;
+
+	/** the object used to set power switches */
+	PowerSwitchIF *powerSwitcher = nullptr;
+
+	/** Cached for initialize() */
+	static object_id_t defaultHkDestination;
+	/** HK destination can also be set individually */
+	object_id_t hkDestination = objects::NO_OBJECT;
+
+	/**
+	 * @brief   Used for timing out mode transitions.
+	 * Set when setMode() is called.
+	 */
+	uint32_t timeoutStart = 0;
+
+	/**
+	 * Delay for the current mode transition, used for time out
+	 */
+	uint32_t childTransitionDelay;
+
+	/**
+	 * @brief   The mode the current transition originated from
+	 *
+	 * This is private so the child can not change it and fuck up the timeouts
+	 *
+	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
+	 * (it is _MODE_POWER_DOWN during this modes)
+	 *
+	 * is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
+	 */
+	Mode_t transitionSourceMode;
+
+	/**
+	 * the submode of the source mode during a transition
+	 */
+	Submode_t transitionSourceSubMode;
+
+	/**
+	 * read the command queue
+	 */
+	void readCommandQueue(void);
+
+	/**
+	 * Handle the device handler mode.
+	 *
+	 * - checks whether commands are valid for the current mode, rejects them accordingly
+	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
+	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 */
+	void doStateMachine(void);
+
+	void buildRawDeviceCommand(CommandMessage* message);
+	void buildInternalCommand(void);
+
+//	/**
+//	 * Send a reply with the current mode and submode.
+//	 */
+//	void announceMode(void);
+
+	/**
+	 * Decrement the counter for the timout of replies.
+	 *
+	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
+	 * but not received).
+	 */
+	void decrementDeviceReplyMap(void);
+
+	/**
+	 * Convenience function to handle a reply.
+	 *
+	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
+	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
+	 *
+	 * It also resets the timeout counter for the command id.
+	 *
+	 * @param data the found packet
+	 * @param id the found id
+	 * @foundLen the length of the packet
+	 */
+	void handleReply(const uint8_t *data, DeviceCommandId_t id, uint32_t foundLen);
+
+	void replyToReply(DeviceReplyMap::iterator iter, ReturnValue_t status);
+	/**
+	 * Build and send a command to the device.
+	 *
+	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
+	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
+	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
+	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * sends the command via RMAP.
+	 */
+	void doSendWrite(void);
+
+	/**
+	 * Check if the RMAP sendWrite action was successful.
+	 *
+	 * Depending on the result, the following is done
+	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the action was successful, the reply timout counter is initialized
+	 */
+	void doGetWrite(void);
+
+	/**
+	 * Send a RMAP getRead command.
+	 *
+	 * The size of the getRead command is #maxDeviceReplyLen.
+	 * This is always executed, independently from the current mode.
+	 */
+	void doSendRead(void);
+
+	/**
+	 * Check the getRead reply and the contained data.
+	 *
+	 * If data was received scanForReply() and, if successful, handleReply() are called.
+	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
+	 * via commandQueue.
+	 */
+	void doGetRead(void);
+
+	/**
+	 * Retrive data from the #IPCStore.
+	 *
+	 * @param storageAddress
+	 * @param[out] data
+	 * @param[out] len
+	 * @return
+	 *   - @c RETURN_OK @c data is valid
+	 *   - @c RETURN_FAILED IPCStore is NULL
+	 *   - the return value from the IPCStore if it was not @c RETURN_OK
+	 */
+	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
+			uint32_t *len);
+
+
+	/**
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 */
+	void setTransition(Mode_t modeTo, Submode_t submodeTo);
+
+	/**
+	 * calls the right child function for the transitional submodes
+	 */
+	void callChildStatemachine();
+
+	/**
+	 * Switches the channel of the cookie used for the communication
+	 *
+	 *
+	 * @param newChannel the object Id of the channel to switch to
+	 * @return
+	 *     - @c RETURN_OK when cookie was changed
+	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
+	 *     - @c returnvalues of RMAPChannelIF::isActive()
+	 */
+	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
+
+	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
+
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+	DataSetIF* getDataSetHandle(sid_t sid) override;
+
+	void parseReply(const uint8_t* receivedData,
+	            size_t receivedDataLen);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
+
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 46e73cd8..54788600 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,251 +1,251 @@
-#include <framework/devicehandlers/DeviceHandlerBase.h>
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/power/Fuse.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/thermal/ThermalComponentIF.h>
-
-object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
-
-DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
-		object_id_t parent) :
-		FailureIsolationBase(owner, parent),
-		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
-				parameterDomainBase++),
-		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
-				parameterDomainBase++),
-		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
-		fdirState(NONE), powerConfirmation(0) {
-}
-
-DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
-	if(isFdirInActionOrAreWeFaulty(event)) {
-		return RETURN_OK;
-	}
-	ReturnValue_t result = RETURN_FAILED;
-	switch (event->getEvent()) {
-	case HasModesIF::MODE_TRANSITION_FAILED:
-	case HasModesIF::OBJECT_IN_INVALID_MODE:
-		//We'll try a recovery as long as defined in MAX_REBOOT.
-		//Might cause some AssemblyBase cycles, so keep number low.
-		handleRecovery(event->getEvent());
-		break;
-	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
-	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
-	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
-		//These faults all mean that there were stupid replies from a device.
-		if (strangeReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-		//The two above should never be confirmed.
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		result = sendConfirmationRequest(event);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-		//else
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case StorageManagerIF::GET_DATA_FAILED:
-	case StorageManagerIF::STORE_DATA_FAILED:
-		//Rather strange bugs, occur in RAW mode only. Ignore.
-		break;
-	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
-		//Ignore, is bad configuration. We can't do anything in flight.
-		break;
-	case HasHealthIF::HEALTH_INFO:
-	case HasModesIF::MODE_INFO:
-	case HasModesIF::CHANGING_MODE:
-		//Do nothing, but mark as handled.
-		break;
-		//****Power*****
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		if(hasPowerConfirmation) {
-			result = sendConfirmationRequest(event, powerConfirmation);
-			if (result == RETURN_OK) {
-				setFdirState(DEVICE_MIGHT_BE_OFF);
-			}
-		}
-		break;
-	case Fuse::FUSE_WENT_OFF:
-		//Not so good, because PCDU reacted.
-	case Fuse::POWER_ABOVE_HIGH_LIMIT:
-		//Better, because software detected over-current.
-		setFaulty(event->getEvent());
-		break;
-	case Fuse::POWER_BELOW_LOW_LIMIT:
-		//Device might got stuck during boot, retry.
-		handleRecovery(event->getEvent());
-		break;
-		//****Thermal*****
-	case ThermalComponentIF::COMPONENT_TEMP_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
-		//Well, the device is not really faulty, but it is required to stay off as long as possible.
-		setFaulty(event->getEvent());
-		break;
-	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
-		//Ignore, is information only.
-		break;
-		//*******Default monitoring variables. Are currently not used.*****
-//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
-//		setFaulty(event->getEvent());
-//		break;
-//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
-//		break;
-	default:
-		//We don't know the event, someone else should handle it.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
-	switch (event->getEvent()) {
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		//This means the switch went off only for one device.
-		handleRecovery(event->getEvent());
-		break;
-	default:
-		break;
-	}
-}
-
-void DeviceHandlerFailureIsolation::decrementFaultCounters() {
-	strangeReplyCount.checkForDecrement();
-	missedReplyCount.checkForDecrement();
-	recoveryCounter.checkForDecrement();
-}
-
-void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
-	clearFaultCounters();
-	if (not recoveryCounter.incrementAndCheck()) {
-		startRecovery(reason);
-	} else {
-		setFaulty(reason);
-	}
-}
-
-void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
-	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
-	//This means, no fault message will come through until a MODE_ or
-	//HEALTH_INFO message comes through -> Is that ok?
-	//Same issue in TxFailureIsolation!
-//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
-//			&& (fdirState != RECOVERY_ONGOING)) {
-//		setFdirState(NONE);
-//	}
-}
-
-void DeviceHandlerFailureIsolation::clearFaultCounters() {
-	strangeReplyCount.clear();
-	missedReplyCount.clear();
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
-	ReturnValue_t result = FailureIsolationBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
-				" initialize FailureIsolationBase." << std::endl;
-		return result;
-	}
-	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
-			powerConfirmationId);
-	if (power != nullptr) {
-		powerConfirmation = power->getEventReceptionQueue();
-		hasPowerConfirmation = true;
-	}
-
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
-	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
-	fdirState = state;
-}
-
-void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//Do not throw error events if fdirState != none.
-	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
-		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
-	}
-}
-
-bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
-	return (fdirState != NONE);
-}
-
-void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
-	setFdirState(RECOVERY_ONGOING);
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = missedReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = recoveryCounter.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-}
-
-void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::FAULTY);
-	setFdirState(AWAIT_SHUTDOWN);
-}
-
-bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
-		EventMessage* event) {
-	if (fdirState != NONE) {
-		//Only wait for those events, ignore all others.
-		if (event->getParameter1() == HasHealthIF::HEALTHY
-				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
-			setFdirState(NONE);
-		}
-		if (event->getEvent() == HasModesIF::MODE_INFO
-				&& fdirState != RECOVERY_ONGOING) {
-			setFdirState(NONE);
-		}
-		return true;
-	}
-	if (owner->getHealth() == HasHealthIF::FAULTY
-			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
-		//Ignore all events in case device is already faulty.
-		return true;
-	}
-	return false;
-}
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "../health/HealthTableIF.h"
+#include "../power/Fuse.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../thermal/ThermalComponentIF.h"
+
+object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
+
+DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
+		object_id_t parent) :
+		FailureIsolationBase(owner, parent),
+		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
+				parameterDomainBase++),
+		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
+				parameterDomainBase++),
+		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
+		fdirState(NONE), powerConfirmation(0) {
+}
+
+DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
+	if(isFdirInActionOrAreWeFaulty(event)) {
+		return RETURN_OK;
+	}
+	ReturnValue_t result = RETURN_FAILED;
+	switch (event->getEvent()) {
+	case HasModesIF::MODE_TRANSITION_FAILED:
+	case HasModesIF::OBJECT_IN_INVALID_MODE:
+		//We'll try a recovery as long as defined in MAX_REBOOT.
+		//Might cause some AssemblyBase cycles, so keep number low.
+		handleRecovery(event->getEvent());
+		break;
+	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
+	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
+	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
+		//These faults all mean that there were stupid replies from a device.
+		if (strangeReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+		//The two above should never be confirmed.
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		result = sendConfirmationRequest(event);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+		//else
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case StorageManagerIF::GET_DATA_FAILED:
+	case StorageManagerIF::STORE_DATA_FAILED:
+		//Rather strange bugs, occur in RAW mode only. Ignore.
+		break;
+	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
+		//Ignore, is bad configuration. We can't do anything in flight.
+		break;
+	case HasHealthIF::HEALTH_INFO:
+	case HasModesIF::MODE_INFO:
+	case HasModesIF::CHANGING_MODE:
+		//Do nothing, but mark as handled.
+		break;
+		//****Power*****
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		if(hasPowerConfirmation) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
+		}
+		break;
+	case Fuse::FUSE_WENT_OFF:
+		//Not so good, because PCDU reacted.
+	case Fuse::POWER_ABOVE_HIGH_LIMIT:
+		//Better, because software detected over-current.
+		setFaulty(event->getEvent());
+		break;
+	case Fuse::POWER_BELOW_LOW_LIMIT:
+		//Device might got stuck during boot, retry.
+		handleRecovery(event->getEvent());
+		break;
+		//****Thermal*****
+	case ThermalComponentIF::COMPONENT_TEMP_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
+		//Well, the device is not really faulty, but it is required to stay off as long as possible.
+		setFaulty(event->getEvent());
+		break;
+	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
+		//Ignore, is information only.
+		break;
+		//*******Default monitoring variables. Are currently not used.*****
+//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
+//		setFaulty(event->getEvent());
+//		break;
+//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
+//		break;
+	default:
+		//We don't know the event, someone else should handle it.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
+	switch (event->getEvent()) {
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		//This means the switch went off only for one device.
+		handleRecovery(event->getEvent());
+		break;
+	default:
+		break;
+	}
+}
+
+void DeviceHandlerFailureIsolation::decrementFaultCounters() {
+	strangeReplyCount.checkForDecrement();
+	missedReplyCount.checkForDecrement();
+	recoveryCounter.checkForDecrement();
+}
+
+void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
+	clearFaultCounters();
+	if (not recoveryCounter.incrementAndCheck()) {
+		startRecovery(reason);
+	} else {
+		setFaulty(reason);
+	}
+}
+
+void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
+	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
+	//This means, no fault message will come through until a MODE_ or
+	//HEALTH_INFO message comes through -> Is that ok?
+	//Same issue in TxFailureIsolation!
+//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
+//			&& (fdirState != RECOVERY_ONGOING)) {
+//		setFdirState(NONE);
+//	}
+}
+
+void DeviceHandlerFailureIsolation::clearFaultCounters() {
+	strangeReplyCount.clear();
+	missedReplyCount.clear();
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
+	ReturnValue_t result = FailureIsolationBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
+				" initialize FailureIsolationBase." << std::endl;
+		return result;
+	}
+	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
+			powerConfirmationId);
+	if (power != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+		hasPowerConfirmation = true;
+	}
+
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
+	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
+	fdirState = state;
+}
+
+void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//Do not throw error events if fdirState != none.
+	//This will still forward MODE and HEALTH INFO events in any case.
+	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
+	}
+}
+
+bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
+	return (fdirState != NONE);
+}
+
+void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
+	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
+	setFdirState(RECOVERY_ONGOING);
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = missedReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = recoveryCounter.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+}
+
+void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::FAULTY);
+	setFdirState(AWAIT_SHUTDOWN);
+}
+
+bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
+		EventMessage* event) {
+	if (fdirState != NONE) {
+		//Only wait for those events, ignore all others.
+		if (event->getParameter1() == HasHealthIF::HEALTHY
+				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
+			setFdirState(NONE);
+		}
+		if (event->getEvent() == HasModesIF::MODE_INFO
+				&& fdirState != RECOVERY_ONGOING) {
+			setFdirState(NONE);
+		}
+		return true;
+	}
+	if (owner->getHealth() == HasHealthIF::FAULTY
+			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
+		//Ignore all events in case device is already faulty.
+		return true;
+	}
+	return false;
+}
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 4343d88b..25247a8d 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,54 +1,54 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-
-#include <framework/fdir/FaultCounter.h>
-#include <framework/fdir/FailureIsolationBase.h>
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-
-class DeviceHandlerFailureIsolation: public FailureIsolationBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	friend class Heater;
-public:
-	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
-	~DeviceHandlerFailureIsolation();
-	ReturnValue_t initialize();
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);bool isFdirActionInProgress();
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-protected:
-	FaultCounter strangeReplyCount;
-	FaultCounter missedReplyCount;
-	FaultCounter recoveryCounter;
-	enum FDIRState {
-		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
-	};
-	FDIRState fdirState;
-	bool hasPowerConfirmation = false;
-	MessageQueueId_t powerConfirmation;
-	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	static const uint32_t MAX_REBOOT = 1;
-	static const uint32_t REBOOT_TIME_MS = 180000;
-	static const uint32_t MAX_STRANGE_REPLIES = 10;
-	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
-	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
-	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
-	virtual ReturnValue_t eventReceived(EventMessage* event);
-	virtual void eventConfirmed(EventMessage* event);
-	void wasParentsFault(EventMessage* event);
-	void decrementFaultCounters();
-	void handleRecovery(Event reason);
-	virtual void clearFaultCounters();
-	void setFdirState(FDIRState state);
-	void startRecovery(Event reason);
-	void setFaulty(Event reason);
-
-	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+
+#include "../fdir/FaultCounter.h"
+#include "../fdir/FailureIsolationBase.h"
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+
+class DeviceHandlerFailureIsolation: public FailureIsolationBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+	friend class Heater;
+public:
+	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+	~DeviceHandlerFailureIsolation();
+	ReturnValue_t initialize();
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);bool isFdirActionInProgress();
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+protected:
+	FaultCounter strangeReplyCount;
+	FaultCounter missedReplyCount;
+	FaultCounter recoveryCounter;
+	enum FDIRState {
+		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
+	};
+	FDIRState fdirState;
+	bool hasPowerConfirmation = false;
+	MessageQueueId_t powerConfirmation;
+	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
+	static const uint32_t MAX_REBOOT = 1;
+	static const uint32_t REBOOT_TIME_MS = 180000;
+	static const uint32_t MAX_STRANGE_REPLIES = 10;
+	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
+	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
+	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
+	virtual ReturnValue_t eventReceived(EventMessage* event);
+	virtual void eventConfirmed(EventMessage* event);
+	void wasParentsFault(EventMessage* event);
+	void decrementFaultCounters();
+	void handleRecovery(Event reason);
+	virtual void clearFaultCounters();
+	void setFdirState(FDIRState state);
+	void startRecovery(Event reason);
+	void setFaulty(Event reason);
+
+	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 59302080..67ab37f7 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,155 +1,155 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
-
-#include <framework/action/HasActionsIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/events/Event.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * @brief 	This is the Interface used to communicate with a device handler.
- * @details Includes all expected return values, events and modes.
- *
- */
-class DeviceHandlerIF {
-public:
-
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
-
-	/**
-	 * @brief This is the mode the <strong>device handler</strong> is in.
-	 *
-	 * @details The mode of the device handler must not be confused with the mode the device is in.
-	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
-	 * MODE_ON and MODE_OFF are included in hasModesIF.h
-	 */
-
-	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//! The device is powered on and the device handler periodically sends
-	//! commands. The commands to be sent are selected by the handler
-	//! according to the submode.
-	static const Mode_t MODE_NORMAL = 2;
-	//! The device is powered on and ready to perform operations. In this mode,
-	//! raw commands can be sent. The device handler will send all replies
-	//! received from the command back to the commanding object.
-	static const Mode_t MODE_RAW = 3;
-	//! The device is shut down but the switch could not be turned off, so the
-	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
-	//! can be commanded, which tries to switch off the device again.
-	static const Mode_t MODE_ERROR_ON = 4;
-	//! This is a transitional state which can not be commanded. The device
-	//! handler performs all commands to get the device in a state ready to
-	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
-	//! This is a transitional state which can not be commanded.
-	//! The device handler performs all actions and commands to get the device
-	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
-	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-	//! transition if available.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
-	//! It is possible to set the mode to _MODE_TO_ON to use the to on
-	//! transition if available.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
-	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
-	//! transition if available.
-	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
-	//! transition if available.
-	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	//! This is a transitional state which can not be commanded.
-	//! The device is shut down and ready to be switched off.
-	//! After the command to set the switch off has been sent,
-	//! the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
-	//! This is a transitional state which can not be commanded. The device
-	//! will be switched on in this state. After the command to set the switch
-	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and the handler waits for it to be off.
-	//! When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
-	//! This is a transitional state which can not be commanded. The switch
-	//! has been commanded on and the handler waits for it to be on.
-	//! When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and is off now. This state is only to do an RMAP
-	//! cycle once more where the doSendRead() function will set the mode to
-	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-
-	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-	// Standard codes used in scanForReply
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
-
-	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
-
-	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-
-	/**
-	 * Communication action that will be executed.
-	 *
-	 * This is used by the child class to tell the base class what to do.
-	 */
-	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< Send write
-		GET_WRITE, //!< Get write
-		SEND_READ, //!< Send read
-		GET_READ,  //!< Get read
-		NOTHING    //!< Do nothing.
-	};
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerIF() {}
-
-	/**
-	 * This MessageQueue is used to command the device handler.
-	 * @return the id of the MessageQueue
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-};
-
-#endif /* DEVICEHANDLERIF_H_ */
+#ifndef DEVICEHANDLERIF_H_
+#define DEVICEHANDLERIF_H_
+
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../events/Event.h"
+#include "../modes/HasModesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
+ *
+ */
+class DeviceHandlerIF {
+public:
+
+	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+
+	/**
+	 * @brief This is the mode the <strong>device handler</strong> is in.
+	 *
+	 * @details The mode of the device handler must not be confused with the mode the device is in.
+	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
+	 */
+
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+
+	// Standard codes used when building commands.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
+
+	// Standard codes used in scanForReply
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
+
+	// Standard codes used in  interpretDeviceReply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
+
+	// Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	/**
+	 * Communication action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum CommunicationAction_t: uint8_t {
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
+		NOTHING    //!< Do nothing.
+	};
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerIF() {}
+
+	/**
+	 * This MessageQueue is used to command the device handler.
+	 * @return the id of the MessageQueue
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+};
+
+#endif /* DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 97abcac5..95e5ae0c 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,101 +1,101 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
-store_address_t DeviceHandlerMessage::getStoreAddress(
-		const CommandMessage* message) {
-	return store_address_t(message->getParameter2());
-}
-
-uint32_t DeviceHandlerMessage::getDeviceCommandId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-object_id_t DeviceHandlerMessage::getIoBoardObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-uint8_t DeviceHandlerMessage::getWiretappingMode(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
-void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
-		CommandMessage* message, store_address_t rawPacketStoreId) {
-	message->setCommand(CMD_RAW);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
-		CommandMessage* message, uint8_t wiretappingMode) {
-	message->setCommand(CMD_WIRETAPPING);
-	message->setParameter(wiretappingMode);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
-		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
-	message->setParameter(ioBoardIdentifier);
-}
-
-object_id_t DeviceHandlerMessage::getDeviceObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t rawPacketStoreId, bool isCommand) {
-	if (isCommand) {
-		message->setCommand(REPLY_RAW_COMMAND);
-	} else {
-		message->setCommand(REPLY_RAW_REPLY);
-	}
-	message->setParameter(deviceObjectid);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t commandParametersStoreId) {
-	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
-	message->setParameter(deviceObjectid);
-	message->setParameter2(commandParametersStoreId.raw);
-}
-
-void DeviceHandlerMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_RAW:
-//	case CMD_DIRECT:
-	case REPLY_RAW_COMMAND:
-	case REPLY_RAW_REPLY:
-	case REPLY_DIRECT_COMMAND_DATA: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreAddress(message));
-		}
-	}
-		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
-	case CMD_WIRETAPPING:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+DeviceHandlerMessage::DeviceHandlerMessage() {
+}
+
+store_address_t DeviceHandlerMessage::getStoreAddress(
+		const CommandMessage* message) {
+	return store_address_t(message->getParameter2());
+}
+
+uint32_t DeviceHandlerMessage::getDeviceCommandId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+object_id_t DeviceHandlerMessage::getIoBoardObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+uint8_t DeviceHandlerMessage::getWiretappingMode(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
+//		CommandMessage* message, DeviceCommandId_t deviceCommand,
+//		store_address_t commandParametersStoreId) {
+//	message->setCommand(CMD_DIRECT);
+//	message->setParameter(deviceCommand);
+//	message->setParameter2(commandParametersStoreId.raw);
+//}
+
+void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
+		CommandMessage* message, store_address_t rawPacketStoreId) {
+	message->setCommand(CMD_RAW);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
+		CommandMessage* message, uint8_t wiretappingMode) {
+	message->setCommand(CMD_WIRETAPPING);
+	message->setParameter(wiretappingMode);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
+		CommandMessage* message, uint32_t ioBoardIdentifier) {
+	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setParameter(ioBoardIdentifier);
+}
+
+object_id_t DeviceHandlerMessage::getDeviceObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t rawPacketStoreId, bool isCommand) {
+	if (isCommand) {
+		message->setCommand(REPLY_RAW_COMMAND);
+	} else {
+		message->setCommand(REPLY_RAW_REPLY);
+	}
+	message->setParameter(deviceObjectid);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t commandParametersStoreId) {
+	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
+	message->setParameter(deviceObjectid);
+	message->setParameter2(commandParametersStoreId.raw);
+}
+
+void DeviceHandlerMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_RAW:
+//	case CMD_DIRECT:
+	case REPLY_RAW_COMMAND:
+	case REPLY_RAW_REPLY:
+	case REPLY_DIRECT_COMMAND_DATA: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreAddress(message));
+		}
+	}
+		/* NO BREAK falls through*/
+	case CMD_SWITCH_ADDRESS:
+	case CMD_WIRETAPPING:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 2bdf03b2..6b54392b 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,91 +1,91 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
-
-/**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
- */
-class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
-public:
-
-	/**
-	 * These are the commands that can be sent to a DeviceHandlerBase
-	 */
-	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
-//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
-
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
-	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
-	static store_address_t getStoreAddress(const CommandMessage* message);
-	static uint32_t getDeviceCommandId(const CommandMessage* message);
-	static object_id_t getDeviceObjectId(const CommandMessage *message);
-	static object_id_t getIoBoardObjectId(const CommandMessage* message);
-	static uint8_t getWiretappingMode(const CommandMessage* message);
-
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
-			object_id_t deviceObjectid,
-			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
-			store_address_t rawPacketStoreId);
-
-	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
-			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
-			bool isCommand);
-
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
-	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
-			uint8_t wiretappingMode);
-	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
-			object_id_t ioBoardIdentifier);
-
-	static void clear(CommandMessage* message);
-};
-
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#ifndef DEVICEHANDLERMESSAGE_H_
+#define DEVICEHANDLERMESSAGE_H_
+
+#include "../action/ActionMessage.h"
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ *
+ * The values are defined in the device-specific implementations
+ */
+typedef uint32_t DeviceCommandId_t;
+
+/**
+ * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ */
+class DeviceHandlerMessage {
+private:
+	DeviceHandlerMessage();
+public:
+
+	/**
+	 * These are the commands that can be sent to a DeviceHandlerBase
+	 */
+	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
+//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+
+	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
+	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
+	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
+
+	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
+
+	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
+	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
+	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
+	 */
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerMessage() {
+	}
+
+	static store_address_t getStoreAddress(const CommandMessage* message);
+	static uint32_t getDeviceCommandId(const CommandMessage* message);
+	static object_id_t getDeviceObjectId(const CommandMessage *message);
+	static object_id_t getIoBoardObjectId(const CommandMessage* message);
+	static uint8_t getWiretappingMode(const CommandMessage* message);
+
+//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
+//			DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
+			object_id_t deviceObjectid,
+			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
+			store_address_t rawPacketStoreId);
+
+	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
+			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
+			bool isCommand);
+
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, store_address_t rawPacketStoreId);
+	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
+			uint8_t wiretappingMode);
+	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
+			object_id_t ioBoardIdentifier);
+
+	static void clear(CommandMessage* message);
+};
+
+#endif /* DEVICEHANDLERMESSAGE_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index ce5eb109..f19b02e9 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,46 +1,46 @@
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/devicehandlers/DeviceTmReportingWrapper.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
-		ActionId_t actionId, SerializeIF* data) :
-		objectId(objectId), actionId(actionId), data(data) {
-}
-
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
-
-}
-
-ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->serialize(buffer, size, maxSize, streamEndianness);
-}
-
-size_t DeviceTmReportingWrapper::getSerializedSize() const {
-	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
-}
-
-ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->deSerialize(buffer, size, streamEndianness);
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../serialize/SerializeAdapter.h"
+
+DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
+		ActionId_t actionId, SerializeIF* data) :
+		objectId(objectId), actionId(actionId), data(data) {
+}
+
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
+
+}
+
+ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&actionId, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->serialize(buffer, size, maxSize, streamEndianness);
+}
+
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
+	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
+}
+
+ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->deSerialize(buffer, size, streamEndianness);
+}
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index 4432b7f1..ecf7089a 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,27 +1,27 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
-
-#include <framework/action/HasActionsIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-class DeviceTmReportingWrapper: public SerializeIF {
-public:
-	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-			SerializeIF *data);
-	virtual ~DeviceTmReportingWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-private:
-	object_id_t objectId;
-	ActionId_t actionId;
-	SerializeIF *data;
-};
-
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#ifndef DEVICETMREPORTINGWRAPPER_H_
+#define DEVICETMREPORTINGWRAPPER_H_
+
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
+
+class DeviceTmReportingWrapper: public SerializeIF {
+public:
+	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
+			SerializeIF *data);
+	virtual ~DeviceTmReportingWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+private:
+	object_id_t objectId;
+	ActionId_t actionId;
+	SerializeIF *data;
+};
+
+#endif /* DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 8367a6bc..de7e4d8c 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,59 +1,59 @@
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/ipc/QueueFactory.h>
-
-HealthDevice::HealthDevice(object_id_t setObjectId,
-		MessageQueueId_t parentQueue) :
-		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
-				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
-}
-
-HealthDevice::~HealthDevice() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t HealthDevice::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (parentQueue != 0) {
-		return healthHelper.initialize(parentQueue);
-	} else {
-		return healthHelper.initialize();
-	}
-}
-
-MessageQueueId_t HealthDevice::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQueue(parentQueue);
-}
-
-bool HealthDevice::hasHealthChanged() {
-	bool changed;
-	HealthState currentHealth = healthHelper.getHealth();
-	changed = currentHealth != lastHealth;
-	lastHealth = currentHealth;
-	return changed;
-}
-
-ReturnValue_t HealthDevice::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState HealthDevice::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "../devicehandlers/HealthDevice.h"
+#include "../ipc/QueueFactory.h"
+
+HealthDevice::HealthDevice(object_id_t setObjectId,
+		MessageQueueId_t parentQueue) :
+		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
+				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+}
+
+HealthDevice::~HealthDevice() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		healthHelper.handleHealthCommand(&command);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HealthDevice::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (parentQueue != 0) {
+		return healthHelper.initialize(parentQueue);
+	} else {
+		return healthHelper.initialize();
+	}
+}
+
+MessageQueueId_t HealthDevice::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
+	healthHelper.setParentQueue(parentQueue);
+}
+
+bool HealthDevice::hasHealthChanged() {
+	bool changed;
+	HealthState currentHealth = healthHelper.getHealth();
+	changed = currentHealth != lastHealth;
+	lastHealth = currentHealth;
+	return changed;
+}
+
+ReturnValue_t HealthDevice::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState HealthDevice::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index ffb9e5bd..fb38584e 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,40 +1,40 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class HealthDevice: public SystemObject,
-		public ExecutableObjectIF,
-		public HasHealthIF {
-public:
-	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
-	virtual ~HealthDevice();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	bool hasHealthChanged();
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HealthState getHealth();
-
-protected:
-	HealthState lastHealth;
-
-	MessageQueueId_t parentQueue;
-	MessageQueueIF* commandQueue;
-public:
-	HealthHelper healthHelper;
-};
-
-#endif /* HEALTHDEVICE_H_ */
+#ifndef HEALTHDEVICE_H_
+#define HEALTHDEVICE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class HealthDevice: public SystemObject,
+		public ExecutableObjectIF,
+		public HasHealthIF {
+public:
+	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
+	virtual ~HealthDevice();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	bool hasHealthChanged();
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HealthState getHealth();
+
+protected:
+	HealthState lastHealth;
+
+	MessageQueueId_t parentQueue;
+	MessageQueueIF* commandQueue;
+public:
+	HealthHelper healthHelper;
+};
+
+#endif /* HEALTHDEVICE_H_ */
diff --git a/events/Event.cpp b/events/Event.cpp
index 9ea9f552..a94ae6db 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,14 +1,14 @@
-#include <framework/events/Event.h>
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
-}
-}
+#include "../events/Event.h"
+namespace EVENT {
+EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
+}
+
+EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
+}
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (eventId & 0xFFFF);
+}
+}
diff --git a/events/Event.h b/events/Event.h
index 0a1cfcf2..f613e701 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_EVENTS_EVENT_H_
-#define FRAMEWORK_EVENTS_EVENT_H_
-
-#include <cstdint>
-#include <framework/events/fwSubsystemIdRanges.h>
-//could be move to more suitable location
-#include <subsystemIdRanges.h>
-
-typedef uint16_t EventId_t;
-typedef uint8_t EventSeverity_t;
-
-#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
-
-typedef uint32_t Event;
-
-namespace EVENT {
-EventId_t getEventId(Event event);
-
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
-}
-
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
-}
-
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
-
-#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENT_H_
+#define FRAMEWORK_EVENTS_EVENT_H_
+
+#include <cstdint>
+#include "../events/fwSubsystemIdRanges.h"
+//could be move to more suitable location
+#include <subsystemIdRanges.h>
+
+typedef uint16_t EventId_t;
+typedef uint8_t EventSeverity_t;
+
+#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
+
+typedef uint32_t Event;
+
+namespace EVENT {
+EventId_t getEventId(Event event);
+
+EventSeverity_t getSeverity(Event event);
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
+
+}
+
+namespace SEVERITY {
+	static const EventSeverity_t INFO = 1;
+	static const EventSeverity_t LOW = 2;
+	static const EventSeverity_t MEDIUM = 3;
+	static const EventSeverity_t HIGH = 4;
+}
+
+//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
+//struct Event {
+//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
+//			id(domain*100+counter), severity(severity) {
+//	}
+//	EventId_t id;
+//	EventSeverity_t severity;
+//	static const EventSeverity_t INFO = 1;
+//	static const EventSeverity_t LOW = 2;
+//	static const EventSeverity_t MEDIUM = 3;
+//	static const EventSeverity_t HIGH = 4;
+//};
+
+#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 04be6f68..5848dd74 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,165 +1,165 @@
-#include <framework/events/EventManager.h>
-#include <framework/events/EventMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/ipc/MutexFactory.h>
-
-
-const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
-		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
-		sizeof(ReporterRangeMatcher) };
-// If one checks registerListener calls, there are around 40 (to max 50)
-// objects registering for certain events.
-// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
-// So a good guess is 75 to a max of 100 pools required for each, which fits well.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
-
-EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
-}
-
-ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
-			printEvent(&message);
-#endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        message->getSender());
-		}
-	}
-	unlockMutex();
-}
-
-ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
-bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
-}
-
-ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
-}
-
-ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-#ifdef DEBUG
-
-//forward declaration, should be implemented by mission
-const char* translateObject(object_id_t object);
-const char * translateEvents(Event event);
-
-void EventManager::printEvent(EventMessage* message) {
-	const char *string = 0;
-	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
-//		string = translateObject(message->getReporter());
-//		sif::info << "EVENT: ";
-//		if (string != 0) {
-//			sif::info << string;
-//		} else {
-//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-//		}
-//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-//				<< message->getParameter1() << " P2: 0x"
-//				<< message->getParameter2() << std::dec << std::endl;
-		break;
-	default:
-		string = translateObject(message->getReporter());
-		sif::debug << "EventManager: ";
-		if (string != 0) {
-			sif::debug << string;
-		}
-		else {
-			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
-		}
-		sif::debug << " reported " << translateEvents(message->getEvent())
-				<< " (" << std::dec << message->getEventId() << ") "
-				<< std::endl;
-
-		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
-				<< ", P1 Dec: " << std::dec << message->getParameter1()
-				<< std::endl;
-		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
-				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
-				<< std::endl;
-		break;
-	}
-
-}
-#endif
-
-void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-}
-
-void EventManager::unlockMutex() {
-	mutex->unlockMutex();
-}
+#include "../events/EventManager.h"
+#include "../events/EventMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/QueueFactory.h"
+#include "../ipc/MutexFactory.h"
+
+
+const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
+		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
+		sizeof(ReporterRangeMatcher) };
+// If one checks registerListener calls, there are around 40 (to max 50)
+// objects registering for certain events.
+// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
+// So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
+const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
+
+EventManager::EventManager(object_id_t setObjectId) :
+		SystemObject(setObjectId),
+		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+	mutex = MutexFactory::instance()->createMutex();
+	eventReportQueue = QueueFactory::instance()->createMessageQueue(
+			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+EventManager::~EventManager() {
+	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+MessageQueueId_t EventManager::getEventReportQueue() {
+	return eventReportQueue->getId();
+}
+
+ReturnValue_t EventManager::performOperation(uint8_t opCode) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	while (result == HasReturnvaluesIF::RETURN_OK) {
+		EventMessage message;
+		result = eventReportQueue->receiveMessage(&message);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+#ifdef DEBUG
+			printEvent(&message);
+#endif
+			notifyListeners(&message);
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void EventManager::notifyListeners(EventMessage* message) {
+	lockMutex();
+	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+		if (iter->second.match(message)) {
+			MessageQueueSenderIF::sendMessage(iter->first, message,
+			        message->getSender());
+		}
+	}
+	unlockMutex();
+}
+
+ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
+bool forwardAllButSelected) {
+	auto result = listenerList.insert(
+			std::pair<MessageQueueId_t, EventMatchTree>(listener,
+					EventMatchTree(&factoryBackend, forwardAllButSelected)));
+	if (!result.second) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
+		EventId_t event) {
+	return subscribeToEventRange(listener, event);
+}
+
+ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
+		object_id_t object) {
+	return subscribeToEventRange(listener, 0, 0, true, object);
+}
+
+ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+#ifdef DEBUG
+
+//forward declaration, should be implemented by mission
+const char* translateObject(object_id_t object);
+const char * translateEvents(Event event);
+
+void EventManager::printEvent(EventMessage* message) {
+	const char *string = 0;
+	switch (message->getSeverity()) {
+	case SEVERITY::INFO:
+//		string = translateObject(message->getReporter());
+//		sif::info << "EVENT: ";
+//		if (string != 0) {
+//			sif::info << string;
+//		} else {
+//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
+//		}
+//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
+//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
+//				<< message->getParameter1() << " P2: 0x"
+//				<< message->getParameter2() << std::dec << std::endl;
+		break;
+	default:
+		string = translateObject(message->getReporter());
+		sif::debug << "EventManager: ";
+		if (string != 0) {
+			sif::debug << string;
+		}
+		else {
+			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::debug << " reported " << translateEvents(message->getEvent())
+				<< " (" << std::dec << message->getEventId() << ") "
+				<< std::endl;
+
+		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
+				<< ", P1 Dec: " << std::dec << message->getParameter1()
+				<< std::endl;
+		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
+				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
+				<< std::endl;
+		break;
+	}
+
+}
+#endif
+
+void EventManager::lockMutex() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+}
+
+void EventManager::unlockMutex() {
+	mutex->unlockMutex();
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index 6fac8352..5323edd8 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,61 +1,61 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
-
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/EventManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-class EventManager: public EventManagerIF,
-		public ExecutableObjectIF,
-		public SystemObject {
-public:
-	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
-
-	EventManager(object_id_t setObjectId);
-	virtual ~EventManager();
-
-	MessageQueueId_t getEventReportQueue();
-
-	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
-	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object);
-	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t performOperation(uint8_t opCode);
-protected:
-
-	MessageQueueIF* eventReportQueue = nullptr;
-
-	std::map<MessageQueueId_t, EventMatchTree> listenerList;
-
-	MutexIF* mutex = nullptr;
-
-	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-
-	void notifyListeners(EventMessage *message);
-
-#ifdef DEBUG
-	void printEvent(EventMessage *message);
-#endif
-
-	void lockMutex();
-
-	void unlockMutex();
-};
-
-#endif /* EVENTMANAGER_H_ */
+#ifndef EVENTMANAGER_H_
+#define EVENTMANAGER_H_
+
+#include "../events/eventmatching/EventMatchTree.h"
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/LocalPool.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+class EventManager: public EventManagerIF,
+		public ExecutableObjectIF,
+		public SystemObject {
+public:
+	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+	EventManager(object_id_t setObjectId);
+	virtual ~EventManager();
+
+	MessageQueueId_t getEventReportQueue();
+
+	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
+	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object);
+	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t performOperation(uint8_t opCode);
+protected:
+
+	MessageQueueIF* eventReportQueue = nullptr;
+
+	std::map<MessageQueueId_t, EventMatchTree> listenerList;
+
+	MutexIF* mutex = nullptr;
+
+	static const uint8_t N_POOLS = 3;
+	LocalPool<N_POOLS> factoryBackend;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+
+	void notifyListeners(EventMessage *message);
+
+#ifdef DEBUG
+	void printEvent(EventMessage *message);
+#endif
+
+	void lockMutex();
+
+	void unlockMutex();
+};
+
+#endif /* EVENTMANAGER_H_ */
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bc0de432..bb36f0a3 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMANAGERIF_H_
-#define EVENTMANAGERIF_H_
-
-#include <framework/events/eventmatching/eventmatching.h>
-#include <framework/events/EventMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class EventManagerIF {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
-	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
-	virtual ~EventManagerIF() {
-	}
-
-	virtual MessageQueueId_t getEventReportQueue() = 0;
-
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
-	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
-			EventId_t event) = 0;
-	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object) = 0;
-	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-
-	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
-		EventMessage message(event, reportingObject, parameter1, parameter2);
-		triggerEvent(&message, sentFrom);
-	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
-			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
-					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
-			}
-		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
-	}
-
-};
-
-#endif /* EVENTMANAGERIF_H_ */
+#ifndef EVENTMANAGERIF_H_
+#define EVENTMANAGERIF_H_
+
+#include "../events/eventmatching/eventmatching.h"
+#include "../events/EventMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class EventManagerIF {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
+	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
+	virtual ~EventManagerIF() {
+	}
+
+	virtual MessageQueueId_t getEventReportQueue() = 0;
+
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
+			EventId_t event) = 0;
+	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object) = 0;
+	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+
+	static void triggerEvent(object_id_t reportingObject, Event event,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+		EventMessage message(event, reportingObject, parameter1, parameter2);
+		triggerEvent(&message, sentFrom);
+	}
+	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = 0;
+		if (eventmanagerQueue == 0) {
+			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
+					objects::EVENT_MANAGER);
+			if (eventmanager != NULL) {
+				eventmanagerQueue = eventmanager->getEventReportQueue();
+			}
+		}
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+	}
+
+};
+
+#endif /* EVENTMANAGERIF_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index f06f68c3..28538f7f 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -1,114 +1,114 @@
-#include <framework/events/EventMessage.h>
-#include <cstring>
-
-EventMessage::EventMessage() {
-	messageSize = EVENT_MESSAGE_SIZE;
-	clearEventMessage();
-}
-
-EventMessage::EventMessage(Event event, object_id_t reporter,
-		uint32_t parameter1, uint32_t parameter2) {
-	messageSize = EVENT_MESSAGE_SIZE;
-	setMessageId(EVENT_MESSAGE);
-	setEvent(event);
-	setReporter(reporter);
-	setParameter1(parameter1);
-	setParameter2(parameter2);
-}
-
-EventMessage::~EventMessage() {
-}
-
-Event EventMessage::getEvent() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFFFFFF);
-}
-
-void EventMessage::setEvent(Event event) {
-	Event tempEvent;
-	memcpy(&tempEvent, getData(), sizeof(Event));
-	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
-	memcpy(getData(), &tempEvent, sizeof(Event));
-}
-
-uint8_t EventMessage::getMessageId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFF000000) >> 24;
-}
-
-void EventMessage::setMessageId(uint8_t id) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0x00FFFFFF) + (id << 24);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventSeverity_t EventMessage::getSeverity() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
-}
-
-void EventMessage::setSeverity(EventSeverity_t severity) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFF00FFFF) + (severity << 16);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventId_t EventMessage::getEventId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
-}
-
-void EventMessage::setEventId(EventId_t eventId) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFFFF0000) + eventId;
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-object_id_t EventMessage::getReporter() {
-	object_id_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
-	return parameter;
-}
-
-void EventMessage::setReporter(object_id_t reporter) {
-	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
-}
-
-uint32_t EventMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
-	return parameter;
-}
-
-void EventMessage::setParameter1(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
-}
-
-uint32_t EventMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
-	return parameter;
-}
-
-void EventMessage::setParameter2(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
-}
-
-void EventMessage::clearEventMessage() {
-	setEvent(INVALID_EVENT);
-}
-
-bool EventMessage::isClearedEventMessage() {
-	return getEvent() == INVALID_EVENT;
-}
-
-size_t EventMessage::getMinimumMessageSize() {
-	return EVENT_MESSAGE_SIZE;
-}
+#include "../events/EventMessage.h"
+#include <cstring>
+
+EventMessage::EventMessage() {
+	messageSize = EVENT_MESSAGE_SIZE;
+	clearEventMessage();
+}
+
+EventMessage::EventMessage(Event event, object_id_t reporter,
+		uint32_t parameter1, uint32_t parameter2) {
+	messageSize = EVENT_MESSAGE_SIZE;
+	setMessageId(EVENT_MESSAGE);
+	setEvent(event);
+	setReporter(reporter);
+	setParameter1(parameter1);
+	setParameter2(parameter2);
+}
+
+EventMessage::~EventMessage() {
+}
+
+Event EventMessage::getEvent() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFFFFFF);
+}
+
+void EventMessage::setEvent(Event event) {
+	Event tempEvent;
+	memcpy(&tempEvent, getData(), sizeof(Event));
+	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
+	memcpy(getData(), &tempEvent, sizeof(Event));
+}
+
+uint8_t EventMessage::getMessageId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFF000000) >> 24;
+}
+
+void EventMessage::setMessageId(uint8_t id) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0x00FFFFFF) + (id << 24);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventSeverity_t EventMessage::getSeverity() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getSeverity(event);
+}
+
+void EventMessage::setSeverity(EventSeverity_t severity) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFF00FFFF) + (severity << 16);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventId_t EventMessage::getEventId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getEventId(event);
+}
+
+void EventMessage::setEventId(EventId_t eventId) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFFFF0000) + eventId;
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+object_id_t EventMessage::getReporter() {
+	object_id_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
+	return parameter;
+}
+
+void EventMessage::setReporter(object_id_t reporter) {
+	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
+}
+
+uint32_t EventMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
+	return parameter;
+}
+
+void EventMessage::setParameter1(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
+}
+
+uint32_t EventMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
+	return parameter;
+}
+
+void EventMessage::setParameter2(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
+}
+
+void EventMessage::clearEventMessage() {
+	setEvent(INVALID_EVENT);
+}
+
+bool EventMessage::isClearedEventMessage() {
+	return getEvent() == INVALID_EVENT;
+}
+
+size_t EventMessage::getMinimumMessageSize() {
+	return EVENT_MESSAGE_SIZE;
+}
diff --git a/events/EventMessage.h b/events/EventMessage.h
index 9cbe3336..8769333b 100644
--- a/events/EventMessage.h
+++ b/events/EventMessage.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMESSAGE_H_
-#define EVENTMESSAGE_H_
-
-#include <framework/events/Event.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-/**
- * Passing on events through IPC.
- * Event Id, severity and message type retrieval is a bit difficult.
- */
-class EventMessage: public MessageQueueMessage {
-public:
-	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
-	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
-	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
-	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
-	//Add other messageIDs here if necessary.
-	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
-			+ 3 * sizeof(uint32_t);
-
-	EventMessage();
-//	EventMessage(EventId_t event, EventSeverity_t severity,
-//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
-	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
-			uint32_t parameter2 = 0);
-	virtual ~EventMessage();
-	Event getEvent();
-	void setEvent(Event event);
-	uint8_t getMessageId();
-	void setMessageId(uint8_t id);
-	EventSeverity_t getSeverity();
-	void setSeverity(EventSeverity_t severity);
-	EventId_t getEventId();
-	void setEventId(EventId_t event);
-	object_id_t getReporter();
-	void setReporter(object_id_t reporter);
-	uint32_t getParameter1();
-	void setParameter1(uint32_t parameter);
-	uint32_t getParameter2();
-	void setParameter2(uint32_t parameter);
-
-	void clearEventMessage();
-	bool isClearedEventMessage();
-
-protected:
-	static const Event INVALID_EVENT = 0;
-	virtual size_t getMinimumMessageSize();
-
-};
-
-#endif /* EVENTMESSAGE_H_ */
+#ifndef EVENTMESSAGE_H_
+#define EVENTMESSAGE_H_
+
+#include "../events/Event.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+/**
+ * Passing on events through IPC.
+ * Event Id, severity and message type retrieval is a bit difficult.
+ */
+class EventMessage: public MessageQueueMessage {
+public:
+	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
+	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
+	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
+	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
+	//Add other messageIDs here if necessary.
+	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
+			+ 3 * sizeof(uint32_t);
+
+	EventMessage();
+//	EventMessage(EventId_t event, EventSeverity_t severity,
+//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
+	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
+			uint32_t parameter2 = 0);
+	virtual ~EventMessage();
+	Event getEvent();
+	void setEvent(Event event);
+	uint8_t getMessageId();
+	void setMessageId(uint8_t id);
+	EventSeverity_t getSeverity();
+	void setSeverity(EventSeverity_t severity);
+	EventId_t getEventId();
+	void setEventId(EventId_t event);
+	object_id_t getReporter();
+	void setReporter(object_id_t reporter);
+	uint32_t getParameter1();
+	void setParameter1(uint32_t parameter);
+	uint32_t getParameter2();
+	void setParameter2(uint32_t parameter);
+
+	void clearEventMessage();
+	bool isClearedEventMessage();
+
+protected:
+	static const Event INVALID_EVENT = 0;
+	virtual size_t getMinimumMessageSize();
+
+};
+
+#endif /* EVENTMESSAGE_H_ */
diff --git a/events/EventReportingProxyIF.h b/events/EventReportingProxyIF.h
index 8aca4e26..1b8064bd 100644
--- a/events/EventReportingProxyIF.h
+++ b/events/EventReportingProxyIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-
-#include <framework/events/Event.h>
-
-
-class EventReportingProxyIF {
-public:
-	virtual ~EventReportingProxyIF() {
-	}
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
-
-};
-
-
-
-
-#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+
+#include "../events/Event.h"
+
+
+class EventReportingProxyIF {
+public:
+	virtual ~EventReportingProxyIF() {
+	}
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
diff --git a/events/eventmatching/EventIdRangeMatcher.cpp b/events/eventmatching/EventIdRangeMatcher.cpp
index ac9156fd..40220e4b 100644
--- a/events/eventmatching/EventIdRangeMatcher.cpp
+++ b/events/eventmatching/EventIdRangeMatcher.cpp
@@ -1,12 +1,12 @@
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-
-EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
-		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
-}
-
-EventIdRangeMatcher::~EventIdRangeMatcher() {
-}
-
-bool EventIdRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getEventId());
-}
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+
+EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
+		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
+}
+
+EventIdRangeMatcher::~EventIdRangeMatcher() {
+}
+
+bool EventIdRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getEventId());
+}
diff --git a/events/eventmatching/EventIdRangeMatcher.h b/events/eventmatching/EventIdRangeMatcher.h
index 57b77cb1..ffc2ce80 100644
--- a/events/eventmatching/EventIdRangeMatcher.h
+++ b/events/eventmatching/EventIdRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
-public:
-	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
-	~EventIdRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
diff --git a/events/eventmatching/EventMatchTree.cpp b/events/eventmatching/EventMatchTree.cpp
index e1925b8f..fef1b83e 100644
--- a/events/eventmatching/EventMatchTree.cpp
+++ b/events/eventmatching/EventMatchTree.cpp
@@ -1,149 +1,149 @@
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-
-EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
-		bool invertedMatch) :
-		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
-				invertedMatch) {
-}
-
-EventMatchTree::~EventMatchTree() {
-}
-
-bool EventMatchTree::match(EventMessage* number) {
-	if (invertedMatch) {
-		return !MatchTree<EventMessage*>::match(number);
-	} else {
-		return MatchTree<EventMessage*>::match(number);
-	}
-}
-
-ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	if (idFrom == 0) {
-		//Assuming all events shall be forwarded.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	iterator lastTest;
-	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
-			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (reporterFrom == 0) {
-		//No need to add another AND branch
-		return RETURN_OK;
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
-			&lastTest);
-}
-
-ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-
-	iterator foundElement;
-
-	if (idFrom == 0) {
-		//Assuming a "forward all events" request.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
-			idFrom, idTo, idInverted);
-	if (foundElement == end()) {
-		return NO_MATCH; //Can't tell if too detailed or just not found.
-	}
-	if (reporterFrom == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	} else {
-		return removeElementAndReconnectChildren(foundElement);
-	}
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			return RETURN_OK;
-		} else {
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
-			INSERTION_T>(idFrom, idTo, inverted);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//If deletion fails, delete element anyway, nothing we can do.
-	//SHOULDO: Throw event, or write debug output.
-	return factory.destroy(position.element);
-}
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+#include "../../events/eventmatching/EventMatchTree.h"
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+
+EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
+		bool invertedMatch) :
+		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
+				invertedMatch) {
+}
+
+EventMatchTree::~EventMatchTree() {
+}
+
+bool EventMatchTree::match(EventMessage* number) {
+	if (invertedMatch) {
+		return !MatchTree<EventMessage*>::match(number);
+	} else {
+		return MatchTree<EventMessage*>::match(number);
+	}
+}
+
+ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	if (idFrom == 0) {
+		//Assuming all events shall be forwarded.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	iterator lastTest;
+	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
+			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (reporterFrom == 0) {
+		//No need to add another AND branch
+		return RETURN_OK;
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
+			&lastTest);
+}
+
+ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+
+	iterator foundElement;
+
+	if (idFrom == 0) {
+		//Assuming a "forward all events" request.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
+			idFrom, idTo, idInverted);
+	if (foundElement == end()) {
+		return NO_MATCH; //Can't tell if too detailed or just not found.
+	}
+	if (reporterFrom == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	} else {
+		return removeElementAndReconnectChildren(foundElement);
+	}
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			return RETURN_OK;
+		} else {
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
+			INSERTION_T>(idFrom, idTo, inverted);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//If deletion fails, delete element anyway, nothing we can do.
+	//SHOULDO: Throw event, or write debug output.
+	return factory.destroy(position.element);
+}
diff --git a/events/eventmatching/EventMatchTree.h b/events/eventmatching/EventMatchTree.h
index bd81e3be..ba02217a 100644
--- a/events/eventmatching/EventMatchTree.h
+++ b/events/eventmatching/EventMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-
-#include <framework/container/PlacementFactory.h>
-#include <framework/events/EventMessage.h>
-#include <framework/globalfunctions/matching/MatchTree.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class StorageManagerIF;
-
-class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
-public:
-	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
-	virtual ~EventMatchTree();
-	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	bool match(EventMessage* number);
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	PlacementFactory factory;
-	bool invertedMatch;
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
-			VALUE_T idTo, bool inverted, iterator* lastTest);
-
-	template<typename VALUE_T, typename INSERTION_T>
-	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
-			bool inverted);
-
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index 587669ba..ab42800a 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-
-#include <framework/events/EventMessage.h>
-#include <framework/globalfunctions/matching/RangeMatcher.h>
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-
-template <typename T>
-class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
-	friend class EventMatchTree;
-public:
-	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
-	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return rangeMatcher.getSerializedSize();
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
-	}
-protected:
-	RangeMatcher<T> rangeMatcher;
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/RangeMatcher.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
diff --git a/events/eventmatching/ReporterRangeMatcher.cpp b/events/eventmatching/ReporterRangeMatcher.cpp
index 76b8e788..6751b5e0 100644
--- a/events/eventmatching/ReporterRangeMatcher.cpp
+++ b/events/eventmatching/ReporterRangeMatcher.cpp
@@ -1,13 +1,13 @@
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-
-ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
-		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
-}
-
-ReporterRangeMatcher::~ReporterRangeMatcher() {
-	
-}
-
-bool ReporterRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getReporter());
-}
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+
+ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
+		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
+}
+
+ReporterRangeMatcher::~ReporterRangeMatcher() {
+	
+}
+
+bool ReporterRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getReporter());
+}
diff --git a/events/eventmatching/ReporterRangeMatcher.h b/events/eventmatching/ReporterRangeMatcher.h
index 65be2365..ee23d076 100644
--- a/events/eventmatching/ReporterRangeMatcher.h
+++ b/events/eventmatching/ReporterRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
-public:
-	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
-	~ReporterRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
diff --git a/events/eventmatching/SeverityRangeMatcher.cpp b/events/eventmatching/SeverityRangeMatcher.cpp
index 98f8d7e1..41eb9020 100644
--- a/events/eventmatching/SeverityRangeMatcher.cpp
+++ b/events/eventmatching/SeverityRangeMatcher.cpp
@@ -1,14 +1,14 @@
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-#include <framework/events/EventMessage.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
-		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
-}
-
-SeverityRangeMatcher::~SeverityRangeMatcher() {
-}
-
-bool SeverityRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getSeverity());
-}
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+#include "../../events/EventMessage.h"
+#include "../../serialize/SerializeAdapter.h"
+
+SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
+		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
+}
+
+SeverityRangeMatcher::~SeverityRangeMatcher() {
+}
+
+bool SeverityRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getSeverity());
+}
diff --git a/events/eventmatching/SeverityRangeMatcher.h b/events/eventmatching/SeverityRangeMatcher.h
index ffacff81..b3c3fbc8 100644
--- a/events/eventmatching/SeverityRangeMatcher.h
+++ b/events/eventmatching/SeverityRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-
-#include <framework/events/eventmatching/EventRangeMatcherBase.h>
-
-class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
-public:
-	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
-	~SeverityRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include "../../events/eventmatching/EventRangeMatcherBase.h"
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
diff --git a/events/eventmatching/eventmatching.h b/events/eventmatching/eventmatching.h
index 435c7457..85b852a5 100644
--- a/events/eventmatching/eventmatching.h
+++ b/events/eventmatching/eventmatching.h
@@ -1,10 +1,10 @@
-#ifndef EVENTMATCHING_H_
-#define EVENTMATCHING_H_
-
-#include <framework/events/eventmatching/EventIdRangeMatcher.h>
-#include <framework/events/eventmatching/EventMatchTree.h>
-#include <framework/events/eventmatching/ReporterRangeMatcher.h>
-#include <framework/events/eventmatching/SeverityRangeMatcher.h>
-
-
-#endif /* EVENTMATCHING_H_ */
+#ifndef EVENTMATCHING_H_
+#define EVENTMATCHING_H_
+
+#include "../../events/eventmatching/EventIdRangeMatcher.h"
+#include "../../events/eventmatching/EventMatchTree.h"
+#include "../../events/eventmatching/ReporterRangeMatcher.h"
+#include "../../events/eventmatching/SeverityRangeMatcher.h"
+
+
+#endif /* EVENTMATCHING_H_ */
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 460749ee..1896d24a 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-// TODO: Documentation.
-class ConfirmsFailuresIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
-	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
-	virtual ~ConfirmsFailuresIF() {}
-	virtual MessageQueueId_t getEventReceptionQueue() = 0;
-};
-
-
-
-#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
+#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+// TODO: Documentation.
+class ConfirmsFailuresIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
+	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
+	virtual ~ConfirmsFailuresIF() {}
+	virtual MessageQueueId_t getEventReceptionQueue() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index 32aa3cd3..dea6a569 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,44 +1,44 @@
-#include <framework/fdir/EventCorrelation.h>
-
-EventCorrelation::EventCorrelation(uint32_t timeout) :
-		eventPending(false) {
-	correlationTimer.setTimeout(timeout);
-}
-
-EventCorrelation::~EventCorrelation() {
-}
-
-EventCorrelation::State EventCorrelation::doesEventCorrelate() {
-	if (correlationTimer.isBusy()) {
-		eventPending = false;
-		return CORRELATED;
-	} else {
-		if (eventPending) {
-			return ALREADY_STARTED;
-		} else {
-			eventPending = true;
-			correlationTimer.resetTimer();
-			return CORRELATION_STARTED;
-		}
-	}
-}
-
-bool EventCorrelation::isEventPending() {
-	if (eventPending) {
-		eventPending = false;
-		return true;
-	} else {
-		correlationTimer.resetTimer();
-		return false;
-	}
-}
-
-bool EventCorrelation::hasPendingEventTimedOut() {
-	if (correlationTimer.hasTimedOut()) {
-		bool temp = eventPending;
-		eventPending = false;
-		return temp;
-	} else {
-		return false;
-	}
-}
+#include "../fdir/EventCorrelation.h"
+
+EventCorrelation::EventCorrelation(uint32_t timeout) :
+		eventPending(false) {
+	correlationTimer.setTimeout(timeout);
+}
+
+EventCorrelation::~EventCorrelation() {
+}
+
+EventCorrelation::State EventCorrelation::doesEventCorrelate() {
+	if (correlationTimer.isBusy()) {
+		eventPending = false;
+		return CORRELATED;
+	} else {
+		if (eventPending) {
+			return ALREADY_STARTED;
+		} else {
+			eventPending = true;
+			correlationTimer.resetTimer();
+			return CORRELATION_STARTED;
+		}
+	}
+}
+
+bool EventCorrelation::isEventPending() {
+	if (eventPending) {
+		eventPending = false;
+		return true;
+	} else {
+		correlationTimer.resetTimer();
+		return false;
+	}
+}
+
+bool EventCorrelation::hasPendingEventTimedOut() {
+	if (correlationTimer.hasTimedOut()) {
+		bool temp = eventPending;
+		eventPending = false;
+		return temp;
+	} else {
+		return false;
+	}
+}
diff --git a/fdir/EventCorrelation.h b/fdir/EventCorrelation.h
index 0cad6265..bbfe92c1 100644
--- a/fdir/EventCorrelation.h
+++ b/fdir/EventCorrelation.h
@@ -1,23 +1,23 @@
-#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
-#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
-
-#include <framework/timemanager/Countdown.h>
-
-class EventCorrelation {
-public:
-	enum State {
-		CORRELATION_STARTED,
-		CORRELATED,
-		ALREADY_STARTED
-	};
-	EventCorrelation(uint32_t timeout);
-	~EventCorrelation();
-	EventCorrelation::State doesEventCorrelate();
-	bool isEventPending();
-	bool hasPendingEventTimedOut();
-	Countdown correlationTimer;
-private:
-	bool eventPending;
-};
-
-#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
+#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
+#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
+
+#include "../timemanager/Countdown.h"
+
+class EventCorrelation {
+public:
+	enum State {
+		CORRELATION_STARTED,
+		CORRELATED,
+		ALREADY_STARTED
+	};
+	EventCorrelation(uint32_t timeout);
+	~EventCorrelation();
+	EventCorrelation::State doesEventCorrelate();
+	bool isEventPending();
+	bool hasPendingEventTimedOut();
+	Countdown correlationTimer;
+private:
+	bool eventPending;
+};
+
+#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index ad4493ff..b9994dc3 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,164 +1,164 @@
-#include <framework/events/EventManagerIF.h>
-#include <framework/fdir/FailureIsolationBase.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-FailureIsolationBase::FailureIsolationBase(object_id_t owner,
-		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
-		ownerId(owner), faultTreeParent(parent),
-		parameterDomainBase(parameterDomainBase) {
-	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
-			EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-FailureIsolationBase::~FailureIsolationBase() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t FailureIsolationBase::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == nullptr) {
-		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
-				" been initialized!" << std::endl;
-		return RETURN_FAILED;
-	}
-	ReturnValue_t result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (ownerId != objects::NO_OBJECT) {
-		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Owner object "
-					"invalid. Make sure it implements HasHealthIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
-	if (faultTreeParent != objects::NO_OBJECT) {
-		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
-				faultTreeParent);
-		if (parentIF == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Parent object"
-					<< "invalid." << std::endl;
-			sif::error << "Make sure it implements ConfirmsFailuresIF."
-					<< std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-			return RETURN_FAILED;
-		}
-		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
-	}
-	return RETURN_OK;
-}
-
-void FailureIsolationBase::checkForFailures() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
-		if (event.getSender() == eventQueue->getId()) {
-			//We already got this event, because we sent it.
-			continue;
-		}
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			if (isFdirDisabledForSeverity(event.getSeverity())) {
-				//We do not handle events when disabled.
-				continue;
-			}
-			eventReceived(&event);
-			break;
-		case EventMessage::CONFIRMATION_REQUEST:
-			doConfirmFault(&event);
-			break;
-		case EventMessage::YOUR_FAULT:
-			eventConfirmed(&event);
-			break;
-		case EventMessage::MY_FAULT:
-			wasParentsFault(&event);
-			break;
-		default:
-			break;
-		}
-	}
-	decrementFaultCounters();
-}
-
-void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
-	if (owner != NULL) {
-		owner->setHealth(health);
-	}
-	//else: owner has no health.
-
-}
-
-MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
-	return eventQueue->getId();
-}
-
-ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
-		MessageQueueId_t destination) {
-	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != MessageQueueIF::NO_QUEUE) {
-		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != objects::NO_OBJECT) {
-		return eventQueue->sendToDefault(event);
-	}
-	return RETURN_FAILED;
-}
-
-void FailureIsolationBase::eventConfirmed(EventMessage* event) {
-}
-
-void FailureIsolationBase::wasParentsFault(EventMessage* event) {
-}
-
-void FailureIsolationBase::doConfirmFault(EventMessage* event) {
-	ReturnValue_t result = confirmFault(event);
-	if (result == YOUR_FAULT) {
-		event->setMessageId(EventMessage::YOUR_FAULT);
-		eventQueue->reply(event);
-	} else if (result == MY_FAULT) {
-		event->setMessageId(EventMessage::MY_FAULT);
-		eventQueue->reply(event);
-	} else {
-
-	}
-}
-
-ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
-	return YOUR_FAULT;
-}
-
-void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//With this mechanism, all events are disabled for a certain device.
-	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
-		return;
-	}
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-	eventReceived(&message);
-}
-
-bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
-		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
-			//External control disables handling of fault messages.
-			return true;
-		}
-	}
-	return false;
-}
-
-void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-}
+#include "../events/EventManagerIF.h"
+#include "../fdir/FailureIsolationBase.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+FailureIsolationBase::FailureIsolationBase(object_id_t owner,
+		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
+		ownerId(owner), faultTreeParent(parent),
+		parameterDomainBase(parameterDomainBase) {
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+			EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+FailureIsolationBase::~FailureIsolationBase() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t FailureIsolationBase::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == nullptr) {
+		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
+				" been initialized!" << std::endl;
+		return RETURN_FAILED;
+	}
+	ReturnValue_t result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (ownerId != objects::NO_OBJECT) {
+		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		owner = objectManager->get<HasHealthIF>(ownerId);
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+	}
+	if (faultTreeParent != objects::NO_OBJECT) {
+		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+				faultTreeParent);
+		if (parentIF == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Parent object"
+					<< "invalid." << std::endl;
+			sif::error << "Make sure it implements ConfirmsFailuresIF."
+					<< std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+			return RETURN_FAILED;
+		}
+		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
+	}
+	return RETURN_OK;
+}
+
+void FailureIsolationBase::checkForFailures() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
+		if (event.getSender() == eventQueue->getId()) {
+			//We already got this event, because we sent it.
+			continue;
+		}
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			if (isFdirDisabledForSeverity(event.getSeverity())) {
+				//We do not handle events when disabled.
+				continue;
+			}
+			eventReceived(&event);
+			break;
+		case EventMessage::CONFIRMATION_REQUEST:
+			doConfirmFault(&event);
+			break;
+		case EventMessage::YOUR_FAULT:
+			eventConfirmed(&event);
+			break;
+		case EventMessage::MY_FAULT:
+			wasParentsFault(&event);
+			break;
+		default:
+			break;
+		}
+	}
+	decrementFaultCounters();
+}
+
+void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
+	if (owner != NULL) {
+		owner->setHealth(health);
+	}
+	//else: owner has no health.
+
+}
+
+MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
+	return eventQueue->getId();
+}
+
+ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
+		MessageQueueId_t destination) {
+	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
+	if (destination != MessageQueueIF::NO_QUEUE) {
+		return eventQueue->sendMessage(destination, event);
+	} else if (faultTreeParent != objects::NO_OBJECT) {
+		return eventQueue->sendToDefault(event);
+	}
+	return RETURN_FAILED;
+}
+
+void FailureIsolationBase::eventConfirmed(EventMessage* event) {
+}
+
+void FailureIsolationBase::wasParentsFault(EventMessage* event) {
+}
+
+void FailureIsolationBase::doConfirmFault(EventMessage* event) {
+	ReturnValue_t result = confirmFault(event);
+	if (result == YOUR_FAULT) {
+		event->setMessageId(EventMessage::YOUR_FAULT);
+		eventQueue->reply(event);
+	} else if (result == MY_FAULT) {
+		event->setMessageId(EventMessage::MY_FAULT);
+		eventQueue->reply(event);
+	} else {
+
+	}
+}
+
+ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
+	return YOUR_FAULT;
+}
+
+void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//With this mechanism, all events are disabled for a certain device.
+	//That's not so good for visibility.
+	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+		return;
+	}
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+	eventReceived(&message);
+}
+
+bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
+	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
+			//External control disables handling of fault messages.
+			return true;
+		}
+	}
+	return false;
+}
+
+void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+}
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index c0fe6041..b2735e6d 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -1,56 +1,56 @@
-#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-
-#include <framework/events/EventMessage.h>
-#include <framework/fdir/ConfirmsFailuresIF.h>
-#include <framework/fdir/FaultCounter.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class FailureIsolationBase: public HasReturnvaluesIF,
-		public ConfirmsFailuresIF,
-		public HasParametersIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
-	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
-
-	FailureIsolationBase(object_id_t owner,
-			object_id_t parent = objects::NO_OBJECT,
-			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
-
-	virtual ~FailureIsolationBase();
-	virtual ReturnValue_t initialize();
-
-	/**
-	 * This is called by the DHB in performOperation()
-	 */
-	void checkForFailures();
-	MessageQueueId_t getEventReceptionQueue() override;
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-protected:
-	MessageQueueIF* eventQueue = nullptr;
-	object_id_t ownerId;
-	HasHealthIF* owner = nullptr;
-	object_id_t faultTreeParent;
-	uint8_t parameterDomainBase;
-	void setOwnerHealth(HasHealthIF::HealthState health);
-	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
-	virtual void eventConfirmed(EventMessage* event);
-	virtual void wasParentsFault(EventMessage* event);
-	virtual ReturnValue_t confirmFault(EventMessage* event);
-	virtual void decrementFaultCounters() = 0;
-	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-private:
-	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
-			EventSeverity_t severity);
-};
-
-#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
+#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+
+#include "../events/EventMessage.h"
+#include "../fdir/ConfirmsFailuresIF.h"
+#include "../fdir/FaultCounter.h"
+#include "../health/HealthMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class FailureIsolationBase: public HasReturnvaluesIF,
+		public ConfirmsFailuresIF,
+		public HasParametersIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
+	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
+	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
+	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
+
+	FailureIsolationBase(object_id_t owner,
+			object_id_t parent = objects::NO_OBJECT,
+			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
+
+	virtual ~FailureIsolationBase();
+	virtual ReturnValue_t initialize();
+
+	/**
+	 * This is called by the DHB in performOperation()
+	 */
+	void checkForFailures();
+	MessageQueueId_t getEventReceptionQueue() override;
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+protected:
+	MessageQueueIF* eventQueue = nullptr;
+	object_id_t ownerId;
+	HasHealthIF* owner = nullptr;
+	object_id_t faultTreeParent;
+	uint8_t parameterDomainBase;
+	void setOwnerHealth(HasHealthIF::HealthState health);
+	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
+	virtual void eventConfirmed(EventMessage* event);
+	virtual void wasParentsFault(EventMessage* event);
+	virtual ReturnValue_t confirmFault(EventMessage* event);
+	virtual void decrementFaultCounters() = 0;
+	ReturnValue_t sendConfirmationRequest(EventMessage* event,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+private:
+	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
+			EventSeverity_t severity);
+};
+
+#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 3dc899c2..674d278a 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,86 +1,86 @@
-#include <framework/fdir/FaultCounter.h>
-
-FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-		uint8_t setParameterDomain) :
-		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
-				failureThreshold) {
-	timer.setTimeout(decrementAfterMs);
-}
-
-FaultCounter::~FaultCounter() {
-}
-
-void FaultCounter::increment(uint32_t amount) {
-	if (faultCount == 0) {
-		timer.resetTimer();
-	}
-	faultCount += amount;
-}
-
-bool FaultCounter::checkForDecrement() {
-	if (timer.hasTimedOut()) {
-		timer.resetTimer();
-		if (faultCount > 0) {
-			faultCount--;
-			return true;
-		}
-	}
-	return false;
-}
-
-bool FaultCounter::incrementAndCheck(uint32_t amount) {
-	increment(amount);
-	return aboveThreshold();
-}
-
-bool FaultCounter::aboveThreshold() {
-	if (faultCount > failureThreshold) {
-		faultCount = 0;
-		return true;
-	} else {
-		return false;
-	}
-}
-
-void FaultCounter::clear() {
-	faultCount = 0;
-}
-
-void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
-	this->failureThreshold = failureThreshold;
-}
-
-void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
-	timer.setTimeout(timeMs);
-}
-
-FaultCounter::FaultCounter() :
-		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
-}
-
-ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != parameterDomain) {
-		return INVALID_DOMAIN_ID;
-	}
-
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(failureThreshold);
-		break;
-	case 1:
-		parameterWrapper->set(faultCount);
-		break;
-	case 2:
-		parameterWrapper->set(timer.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FaultCounter::setParameterDomain(uint8_t domain) {
-	parameterDomain = domain;
-}
+#include "../fdir/FaultCounter.h"
+
+FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+		uint8_t setParameterDomain) :
+		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
+				failureThreshold) {
+	timer.setTimeout(decrementAfterMs);
+}
+
+FaultCounter::~FaultCounter() {
+}
+
+void FaultCounter::increment(uint32_t amount) {
+	if (faultCount == 0) {
+		timer.resetTimer();
+	}
+	faultCount += amount;
+}
+
+bool FaultCounter::checkForDecrement() {
+	if (timer.hasTimedOut()) {
+		timer.resetTimer();
+		if (faultCount > 0) {
+			faultCount--;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool FaultCounter::incrementAndCheck(uint32_t amount) {
+	increment(amount);
+	return aboveThreshold();
+}
+
+bool FaultCounter::aboveThreshold() {
+	if (faultCount > failureThreshold) {
+		faultCount = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void FaultCounter::clear() {
+	faultCount = 0;
+}
+
+void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
+	this->failureThreshold = failureThreshold;
+}
+
+void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
+	timer.setTimeout(timeMs);
+}
+
+FaultCounter::FaultCounter() :
+		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
+}
+
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != parameterDomain) {
+		return INVALID_DOMAIN_ID;
+	}
+
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(failureThreshold);
+		break;
+	case 1:
+		parameterWrapper->set(faultCount);
+		break;
+	case 2:
+		parameterWrapper->set(timer.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FaultCounter::setParameterDomain(uint8_t domain) {
+	parameterDomain = domain;
+}
diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h
index ac23853c..17e2a3df 100644
--- a/fdir/FaultCounter.h
+++ b/fdir/FaultCounter.h
@@ -1,38 +1,38 @@
-#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
-#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
-
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class FaultCounter: public HasParametersIF {
-public:
-	FaultCounter();
-	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-			uint8_t setParameterDomain = 0);
-	virtual ~FaultCounter();
-
-	bool incrementAndCheck(uint32_t amount = 1);
-
-	void increment(uint32_t amount = 1);
-
-	bool checkForDecrement();
-
-	bool aboveThreshold();
-
-	void clear();
-	void setFailureThreshold(uint32_t failureThreshold);
-	void setFaultDecrementTimeMs(uint32_t timeMs);
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	void setParameterDomain(uint8_t domain);
-private:
-	uint8_t parameterDomain;
-	Countdown timer;
-	uint32_t faultCount;
-	uint32_t failureThreshold;
-};
-
-#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
+#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
+#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
+
+#include "../parameters/HasParametersIF.h"
+#include "../timemanager/Countdown.h"
+
+class FaultCounter: public HasParametersIF {
+public:
+	FaultCounter();
+	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+			uint8_t setParameterDomain = 0);
+	virtual ~FaultCounter();
+
+	bool incrementAndCheck(uint32_t amount = 1);
+
+	void increment(uint32_t amount = 1);
+
+	bool checkForDecrement();
+
+	bool aboveThreshold();
+
+	void clear();
+	void setFailureThreshold(uint32_t failureThreshold);
+	void setFaultDecrementTimeMs(uint32_t timeMs);
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	void setParameterDomain(uint8_t domain);
+private:
+	uint8_t parameterDomain;
+	Countdown timer;
+	uint32_t faultCount;
+	uint32_t failureThreshold;
+};
+
+#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index 1459a241..f54af6a8 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,230 +1,230 @@
-#include <framework/globalfunctions/AsciiConverter.h>
-#include <limits>
-#include <cmath>
-
-template<typename T>
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
-		uint8_t len, T* value) {
-	if (len > std::numeric_limits<T>().digits10) {
-		return TOO_LONG_FOR_TARGET_TYPE;
-	}
-
-	double temp;
-
-	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
-
-	*value = temp;
-
-	return result;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
-		uint8_t* value) {
-	int8_t tmp;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp == -2) {
-		tmp = 0;
-	}
-
-	*value = tmp << 4;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp != -2) {
-		*value += tmp;
-	} else {
-		*value = *value >> 4;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
-		uint8_t len, double* value) {
-
-	uint8_t const *ptr = *dataPtr;
-	int8_t sign = 1;
-	float decimal = 0;
-	bool abort = false;
-
-	*value = 0;
-
-	//ignore leading space
-	ptr = clearSpace(ptr, len);
-
-	while ((ptr - *dataPtr < len) && !abort) {
-		switch (*ptr) {
-		case '+':
-			sign = 1;
-			break;
-		case '-':
-			sign = -1;
-			break;
-		case '.':
-			decimal = 1;
-			break;
-		case ' ':
-		case 0x0d:
-		case 0x0a:
-			//ignore trailing space
-			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
-			abort = true;
-			break;
-		default:
-			if ((*ptr < 0x30) || (*ptr > 0x39)) {
-				return INVALID_CHARACTERS;
-			}
-			*value = *value * 10 + (*ptr - 0x30);
-			if (decimal > 0) {
-				decimal *= 10;
-			}
-			break;
-		}
-		ptr++;
-	}
-
-	if (decimal == 0) {
-		decimal = 1;
-	}
-
-	*value = *value / (decimal) * sign;
-
-	*dataPtr = ptr;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
-		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
-	*printedSize = 0;
-	uint32_t streamposition = 0, integerSize;
-	bool negative = (value < 0);
-	int32_t digits = bufferLength - decimalPlaces - 1;
-	if (digits <= 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	if (negative) {
-		digits -= 1;
-		buffer[streamposition++] = '-';
-		value = -value;
-	}
-	float maximumNumber = pow(10, digits);
-	if (value >= maximumNumber) {
-		return BUFFER_TOO_SMALL;
-	}
-	//print the numbers before the decimal point;
-	ReturnValue_t result = printInteger(buffer + streamposition,
-			bufferLength - streamposition - decimalPlaces - 1, value,
-			&integerSize);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	streamposition += integerSize;
-	//The decimal Point
-	buffer[streamposition++] = '.';
-
-	//Print the decimals
-	uint32_t integerValue = value;
-	value -= integerValue;
-	value = value * pow(10, decimalPlaces);
-	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
-			&integerSize, true);
-	*printedSize = integerSize + streamposition;
-	return result;
-}
-
-ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
-		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
-		bool leadingZeros) {
-	*printedSize = 0;
-	if (bufferLength == 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	uint32_t maximumNumber = -1;
-	if (bufferLength < 10) {
-		maximumNumber = pow(10, bufferLength);
-		if (value >= maximumNumber) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber /= 10;
-	} else {
-		if (!(value <= maximumNumber)) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber = 1000000000;
-	}
-	if (!leadingZeros && (value == 0)) {
-		buffer[(*printedSize)++] = '0';
-		return RETURN_OK;
-	}
-	while (maximumNumber >= 1) {
-		uint8_t number = value / maximumNumber;
-		value = value - (number * maximumNumber);
-		if (!leadingZeros && number == 0) {
-			maximumNumber /= 10;
-		} else {
-			leadingZeros = true;
-			buffer[(*printedSize)++] = '0' + number;
-			maximumNumber /= 10;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
-		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
-	bool negative = false;
-	if ((bufferLength > 0) && (value < 0)) {
-		*buffer++ = '-';
-		bufferLength--;
-		value = -value;
-		negative = true;
-	}
-	ReturnValue_t result = printInteger(buffer, bufferLength, value,
-			printedSize);
-	if (negative) {
-		(*printedSize)++;
-	}
-	return result;
-}
-
-int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
-	if ((*character > 0x60) && (*character < 0x67)) {
-		return *character - 0x61 + 10;
-	} else if ((*character > 0x40) && (*character < 0x47)) {
-		return *character - 0x41 + 10;
-	} else if ((*character > 0x2F) && (*character < 0x3A)) {
-		return *character - 0x30;
-	} else if (*character == ' ') {
-		return -2;
-	}
-	return -1;
-}
-
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
-		const uint8_t** dataPtr, uint8_t len, float* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
-		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
-		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
-		const uint8_t** dataPtr, uint8_t len, double* value);
-
-const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
-	while (len > 0) {
-		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
-			return data;
-		}
-		data++;
-		len--;
-	}
-	return data;
-}
+#include "../globalfunctions/AsciiConverter.h"
+#include <limits>
+#include <cmath>
+
+template<typename T>
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
+		uint8_t len, T* value) {
+	if (len > std::numeric_limits<T>().digits10) {
+		return TOO_LONG_FOR_TARGET_TYPE;
+	}
+
+	double temp;
+
+	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
+
+	*value = temp;
+
+	return result;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
+		uint8_t* value) {
+	int8_t tmp;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp == -2) {
+		tmp = 0;
+	}
+
+	*value = tmp << 4;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp != -2) {
+		*value += tmp;
+	} else {
+		*value = *value >> 4;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
+		uint8_t len, double* value) {
+
+	uint8_t const *ptr = *dataPtr;
+	int8_t sign = 1;
+	float decimal = 0;
+	bool abort = false;
+
+	*value = 0;
+
+	//ignore leading space
+	ptr = clearSpace(ptr, len);
+
+	while ((ptr - *dataPtr < len) && !abort) {
+		switch (*ptr) {
+		case '+':
+			sign = 1;
+			break;
+		case '-':
+			sign = -1;
+			break;
+		case '.':
+			decimal = 1;
+			break;
+		case ' ':
+		case 0x0d:
+		case 0x0a:
+			//ignore trailing space
+			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
+			abort = true;
+			break;
+		default:
+			if ((*ptr < 0x30) || (*ptr > 0x39)) {
+				return INVALID_CHARACTERS;
+			}
+			*value = *value * 10 + (*ptr - 0x30);
+			if (decimal > 0) {
+				decimal *= 10;
+			}
+			break;
+		}
+		ptr++;
+	}
+
+	if (decimal == 0) {
+		decimal = 1;
+	}
+
+	*value = *value / (decimal) * sign;
+
+	*dataPtr = ptr;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
+		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
+	*printedSize = 0;
+	uint32_t streamposition = 0, integerSize;
+	bool negative = (value < 0);
+	int32_t digits = bufferLength - decimalPlaces - 1;
+	if (digits <= 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	if (negative) {
+		digits -= 1;
+		buffer[streamposition++] = '-';
+		value = -value;
+	}
+	float maximumNumber = pow(10, digits);
+	if (value >= maximumNumber) {
+		return BUFFER_TOO_SMALL;
+	}
+	//print the numbers before the decimal point;
+	ReturnValue_t result = printInteger(buffer + streamposition,
+			bufferLength - streamposition - decimalPlaces - 1, value,
+			&integerSize);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	streamposition += integerSize;
+	//The decimal Point
+	buffer[streamposition++] = '.';
+
+	//Print the decimals
+	uint32_t integerValue = value;
+	value -= integerValue;
+	value = value * pow(10, decimalPlaces);
+	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
+			&integerSize, true);
+	*printedSize = integerSize + streamposition;
+	return result;
+}
+
+ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
+		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
+		bool leadingZeros) {
+	*printedSize = 0;
+	if (bufferLength == 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	uint32_t maximumNumber = -1;
+	if (bufferLength < 10) {
+		maximumNumber = pow(10, bufferLength);
+		if (value >= maximumNumber) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber /= 10;
+	} else {
+		if (!(value <= maximumNumber)) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber = 1000000000;
+	}
+	if (!leadingZeros && (value == 0)) {
+		buffer[(*printedSize)++] = '0';
+		return RETURN_OK;
+	}
+	while (maximumNumber >= 1) {
+		uint8_t number = value / maximumNumber;
+		value = value - (number * maximumNumber);
+		if (!leadingZeros && number == 0) {
+			maximumNumber /= 10;
+		} else {
+			leadingZeros = true;
+			buffer[(*printedSize)++] = '0' + number;
+			maximumNumber /= 10;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
+		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
+	bool negative = false;
+	if ((bufferLength > 0) && (value < 0)) {
+		*buffer++ = '-';
+		bufferLength--;
+		value = -value;
+		negative = true;
+	}
+	ReturnValue_t result = printInteger(buffer, bufferLength, value,
+			printedSize);
+	if (negative) {
+		(*printedSize)++;
+	}
+	return result;
+}
+
+int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
+	if ((*character > 0x60) && (*character < 0x67)) {
+		return *character - 0x61 + 10;
+	} else if ((*character > 0x40) && (*character < 0x47)) {
+		return *character - 0x41 + 10;
+	} else if ((*character > 0x2F) && (*character < 0x3A)) {
+		return *character - 0x30;
+	} else if (*character == ' ') {
+		return -2;
+	}
+	return -1;
+}
+
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
+		const uint8_t** dataPtr, uint8_t len, float* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
+		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
+		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
+		const uint8_t** dataPtr, uint8_t len, double* value);
+
+const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
+	while (len > 0) {
+		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
+			return data;
+		}
+		data++;
+		len--;
+	}
+	return data;
+}
diff --git a/globalfunctions/AsciiConverter.h b/globalfunctions/AsciiConverter.h
index acd406da..27bed4e7 100644
--- a/globalfunctions/AsciiConverter.h
+++ b/globalfunctions/AsciiConverter.h
@@ -1,39 +1,39 @@
-#ifndef ASCIICONVERTER_H_
-#define ASCIICONVERTER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class AsciiConverter: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
-	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
-
-	template<typename T>
-	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
-			uint8_t len, T *value);
-
-	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
-			uint8_t *value);
-
-	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
-			float value, uint8_t decimalPlaces, uint32_t *printedSize);
-
-	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
-			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
-
-	static ReturnValue_t printSignedInteger(uint8_t *buffer,
-			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
-
-private:
-	AsciiConverter();
-	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
-			uint8_t len, double *value);
-
-	static int8_t convertHexChar(const uint8_t *character);
-
-	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
-};
-
-#endif /* ASCIICONVERTER_H_ */
+#ifndef ASCIICONVERTER_H_
+#define ASCIICONVERTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class AsciiConverter: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
+	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
+
+	template<typename T>
+	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
+			uint8_t len, T *value);
+
+	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
+			uint8_t *value);
+
+	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
+			float value, uint8_t decimalPlaces, uint32_t *printedSize);
+
+	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
+			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
+
+	static ReturnValue_t printSignedInteger(uint8_t *buffer,
+			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
+
+private:
+	AsciiConverter();
+	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
+			uint8_t len, double *value);
+
+	static int8_t convertHexChar(const uint8_t *character);
+
+	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
+};
+
+#endif /* ASCIICONVERTER_H_ */
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index ecd0b675..6156b558 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,139 +1,139 @@
-#include <framework/globalfunctions/CRC.h>
-#include <math.h>
-
-const uint16_t CRC::crc16ccitt_table[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
-
-
-// CRC implementation
-uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
-{
-	uint8_t *data = (uint8_t *)input;
-	unsigned int tbl_idx;
-
-    while (length--) {
-        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
-        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
-
-        data++;
-    }
-    return startingCrc & 0xffff;
-
-    //The part below is not used!
-//	bool temr[16];
-//	bool xor_out[16];
-//	bool r[16];
-//	bool d[8];
-//	uint16_t crc_value = 0;
-//
-//
-//	for (int i=0; i<16 ;i++) {
-//		temr[i] = false;
-//		xor_out[i] = false;
-//	}
-//
-//
-//	for (int i=0; i<16 ;i++)
-//			r[i] = true;    // initialize with 0xFFFF
-//
-//
-//
-//	for (int j=0; j<length ;j++)
-//	{
-//
-//	for (int i=0; i<8 ;i++)
-//		if ((input[j] & 1<<i) == 1<<i)
-//			d[7-i]=true;			// reverse   input data
-//		else
-//			d[7-i]=false;			// reverse input data
-//
-//
-//
-//		  temr[0] = d[4] ^ d[0];
-//		  temr[1] = d[5] ^ d[1];
-//		  temr[2] = d[6] ^ d[2];
-//		  temr[3] = d[7] ^ d[3];
-//		  temr[4] = r[12] ^ r[8];
-//		  temr[5] = r[13] ^ r[9];
-//		  temr[6] = r[14] ^ r[10];
-//		  temr[7] = r[15] ^ r[11];
-//		  temr[8] = d[4] ^ r[12];
-//		  temr[9] = d[5] ^ r[13];
-//		  temr[10] = d[6] ^ r[14];
-//		  temr[11] = d[7] ^ r[15];
-//		  temr[12] = temr[0] ^ temr[4];
-//		  temr[13] = temr[1] ^ temr[5];
-//		  temr[14] = temr[2] ^ temr[6];
-//		  temr[15] = temr[3] ^ temr[7];
-//
-//
-//		  xor_out[0] = temr[12];
-//		  xor_out[1] = temr[13];
-//		  xor_out[2] = temr[14];
-//		  xor_out[3] = temr[15];
-//		  xor_out[4] = temr[8];
-//		  xor_out[5] = temr[9] ^ temr[12];
-//		  xor_out[6] = temr[10] ^ temr[13];
-//		  xor_out[7] = temr[11] ^ temr[14];
-//		  xor_out[8] = temr[15] ^ r[0];
-//		  xor_out[9] = temr[8] ^ r[1];
-//		  xor_out[10] = temr[9] ^ r[2];
-//		  xor_out[11] = temr[10] ^ r[3];
-//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
-//		  xor_out[13] = temr[13] ^ r[5];
-//		  xor_out[14] = temr[14] ^ r[6];
-//		  xor_out[15] = temr[15] ^ r[7];
-//
-//	 for (int i=0; i<16 ;i++)
-//	 {
-//		  r[i]= xor_out[i] ;
-//	 }
-//
-//	}
-//
-//
-//
-//	for (int i=0; i<16 ;i++)
-//	{
-//		 if  (xor_out[i] == true)
-//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
-//	}
-//
-//	crc_value = 0;// for debug mode
-//	return (crc_value);
-
-}   /* Calculate_CRC() */
-
-
+#include "../globalfunctions/CRC.h"
+#include <math.h>
+
+const uint16_t CRC::crc16ccitt_table[256] = {
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+};
+
+
+// CRC implementation
+uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
+{
+	uint8_t *data = (uint8_t *)input;
+	unsigned int tbl_idx;
+
+    while (length--) {
+        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
+        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
+
+        data++;
+    }
+    return startingCrc & 0xffff;
+
+    //The part below is not used!
+//	bool temr[16];
+//	bool xor_out[16];
+//	bool r[16];
+//	bool d[8];
+//	uint16_t crc_value = 0;
+//
+//
+//	for (int i=0; i<16 ;i++) {
+//		temr[i] = false;
+//		xor_out[i] = false;
+//	}
+//
+//
+//	for (int i=0; i<16 ;i++)
+//			r[i] = true;    // initialize with 0xFFFF
+//
+//
+//
+//	for (int j=0; j<length ;j++)
+//	{
+//
+//	for (int i=0; i<8 ;i++)
+//		if ((input[j] & 1<<i) == 1<<i)
+//			d[7-i]=true;			// reverse   input data
+//		else
+//			d[7-i]=false;			// reverse input data
+//
+//
+//
+//		  temr[0] = d[4] ^ d[0];
+//		  temr[1] = d[5] ^ d[1];
+//		  temr[2] = d[6] ^ d[2];
+//		  temr[3] = d[7] ^ d[3];
+//		  temr[4] = r[12] ^ r[8];
+//		  temr[5] = r[13] ^ r[9];
+//		  temr[6] = r[14] ^ r[10];
+//		  temr[7] = r[15] ^ r[11];
+//		  temr[8] = d[4] ^ r[12];
+//		  temr[9] = d[5] ^ r[13];
+//		  temr[10] = d[6] ^ r[14];
+//		  temr[11] = d[7] ^ r[15];
+//		  temr[12] = temr[0] ^ temr[4];
+//		  temr[13] = temr[1] ^ temr[5];
+//		  temr[14] = temr[2] ^ temr[6];
+//		  temr[15] = temr[3] ^ temr[7];
+//
+//
+//		  xor_out[0] = temr[12];
+//		  xor_out[1] = temr[13];
+//		  xor_out[2] = temr[14];
+//		  xor_out[3] = temr[15];
+//		  xor_out[4] = temr[8];
+//		  xor_out[5] = temr[9] ^ temr[12];
+//		  xor_out[6] = temr[10] ^ temr[13];
+//		  xor_out[7] = temr[11] ^ temr[14];
+//		  xor_out[8] = temr[15] ^ r[0];
+//		  xor_out[9] = temr[8] ^ r[1];
+//		  xor_out[10] = temr[9] ^ r[2];
+//		  xor_out[11] = temr[10] ^ r[3];
+//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
+//		  xor_out[13] = temr[13] ^ r[5];
+//		  xor_out[14] = temr[14] ^ r[6];
+//		  xor_out[15] = temr[15] ^ r[7];
+//
+//	 for (int i=0; i<16 ;i++)
+//	 {
+//		  r[i]= xor_out[i] ;
+//	 }
+//
+//	}
+//
+//
+//
+//	for (int i=0; i<16 ;i++)
+//	{
+//		 if  (xor_out[i] == true)
+//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
+//	}
+//
+//	crc_value = 0;// for debug mode
+//	return (crc_value);
+
+}   /* Calculate_CRC() */
+
+
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index f4bd765d..8d74130f 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,123 +1,123 @@
-#include <framework/globalfunctions/DleEncoder.h>
-
-DleEncoder::DleEncoder() {}
-
-DleEncoder::~DleEncoder() {}
-
-ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
-		size_t* encodedLen, bool addStxEtx) {
-	if (maxDestLen < 2) {
-		return STREAM_TOO_SHORT;
-	}
-	size_t encodedIndex = 0, sourceIndex = 0;
-	uint8_t nextByte;
-	if (addStxEtx) {
-		destStream[0] = STX;
-		++encodedIndex;
-	}
-
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
-	{
-		nextByte = sourceStream[sourceIndex];
-		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE;
-				++encodedIndex;
-				/* Escaped byte will be actual byte + 0x40. This prevents
-				 * STX, ETX, and carriage return characters from appearing
-				 * in the encoded data stream at all, so when polling an
-				 * encoded stream, the transmission can be stopped at ETX.
-				 * 0x40 was chosen at random with special requirements:
-				 *  - Prevent going from one control char to another
-				 *  - Prevent overflow for common characters */
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
-		}
-		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE) {
-			if (encodedIndex + 1 >= maxDestLen) {
-			    return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE;
-			}
-		}
-		else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
-
-	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
-		if (addStxEtx) {
-			destStream[encodedIndex] = ETX;
-			++encodedIndex;
-		}
-		*encodedLen = encodedIndex;
-		return RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-		size_t maxDestStreamlen, size_t *decodedLen) {
-	size_t encodedIndex = 0, decodedIndex = 0;
-	uint8_t nextByte;
-	if (*sourceStream != STX) {
-		return DECODING_ERROR;
-	}
-	++encodedIndex;
-
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// The next byte is a DLE character that was escaped by another
-			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE) {
-				destStream[decodedIndex] = nextByte;
-			}
-			else {
-			    /* The next byte is a STX, DTX or 0x0D character which
-			     * was escaped by a DLE character. The actual byte was
-				 * also encoded by adding + 0x40 to preven having control chars,
-				 * in the stream at all, so we convert it back. */
-				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				}
-				else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX) {
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
+#include "../globalfunctions/DleEncoder.h"
+
+DleEncoder::DleEncoder() {}
+
+DleEncoder::~DleEncoder() {}
+
+ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
+		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+		size_t* encodedLen, bool addStxEtx) {
+	if (maxDestLen < 2) {
+		return STREAM_TOO_SHORT;
+	}
+	size_t encodedIndex = 0, sourceIndex = 0;
+	uint8_t nextByte;
+	if (addStxEtx) {
+		destStream[0] = STX;
+		++encodedIndex;
+	}
+
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+	{
+		nextByte = sourceStream[sourceIndex];
+		// STX, ETX and CR characters in the stream need to be escaped with DLE
+		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
+			if (encodedIndex + 1 >= maxDestLen) {
+				return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE;
+				++encodedIndex;
+				/* Escaped byte will be actual byte + 0x40. This prevents
+				 * STX, ETX, and carriage return characters from appearing
+				 * in the encoded data stream at all, so when polling an
+				 * encoded stream, the transmission can be stopped at ETX.
+				 * 0x40 was chosen at random with special requirements:
+				 *  - Prevent going from one control char to another
+				 *  - Prevent overflow for common characters */
+				destStream[encodedIndex] = nextByte + 0x40;
+			}
+		}
+		// DLE characters are simply escaped with DLE.
+		else if (nextByte == DLE) {
+			if (encodedIndex + 1 >= maxDestLen) {
+			    return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE;
+				++encodedIndex;
+				destStream[encodedIndex] = DLE;
+			}
+		}
+		else {
+			destStream[encodedIndex] = nextByte;
+		}
+		++encodedIndex;
+		++sourceIndex;
+	}
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
+		if (addStxEtx) {
+			destStream[encodedIndex] = ETX;
+			++encodedIndex;
+		}
+		*encodedLen = encodedIndex;
+		return RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
+		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+		size_t maxDestStreamlen, size_t *decodedLen) {
+	size_t encodedIndex = 0, decodedIndex = 0;
+	uint8_t nextByte;
+	if (*sourceStream != STX) {
+		return DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX)
+			&& (sourceStream[encodedIndex] != STX)) {
+		if (sourceStream[encodedIndex] == DLE) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// The next byte is a DLE character that was escaped by another
+			// DLE character, so we can write it to the destination stream.
+			if (nextByte == DLE) {
+				destStream[decodedIndex] = nextByte;
+			}
+			else {
+			    /* The next byte is a STX, DTX or 0x0D character which
+			     * was escaped by a DLE character. The actual byte was
+				 * also encoded by adding + 0x40 to preven having control chars,
+				 * in the stream at all, so we convert it back. */
+				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
+					destStream[decodedIndex] = nextByte - 0x40;
+				}
+				else {
+				    return DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX) {
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 29851dfe..da3bbaaf 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,79 +1,79 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-/**
- * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
- *          decode arbitrary data with ASCII control characters
- * @details
- * List of control codes:
- * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
- *
- * This encoder can be used to achieve a basic transport layer when using
- * char based transmission systems.
- * The passed source strean is converted into a encoded stream by adding
- * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
- * escaped by a DLE character. The encoder also replaces escaped control chars
- * by another char, so STX, ETX and CR should not appear anywhere in the actual
- * encoded data stream.
- *
- * When using a strictly char based reception of packets enoded with DLE,
- * STX can be used to notify a reader that actual data will start to arrive
- * while ETX can be used to notify the reader that the data has ended.
- */
-class DleEncoder: public HasReturnvaluesIF {
-private:
-	DleEncoder();
-	virtual ~DleEncoder();
-
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
-	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
-	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
-
-	//! Start Of Text character. First character is encoded stream
-	static constexpr uint8_t STX = 0x02;
-	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX = 0x03;
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
-	//! in the source stream.
-	static constexpr uint8_t DLE = 0x10;
-	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
-
-    /**
-     * Encodes the give data stream by preceding it with the STX marker
-     * and ending it with an ETX marker. STX, ETX and DLE characters inside
-     * the stream are escaped by DLE characters and also replaced by adding
-     * 0x40 (which is reverted in the decoing process).
-     * @param sourceStream
-     * @param sourceLen
-     * @param destStream
-     * @param maxDestLen
-     * @param encodedLen
-     * @param addStxEtx
-     * Adding STX and ETX can be omitted, if they are added manually.
-     * @return
-     */
-    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
-            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
-            bool addStxEtx = true);
-
-    /**
-     * Converts an encoded stream back.
-     * @param sourceStream
-     * @param sourceStreamLen
-     * @param readLen
-     * @param destStream
-     * @param maxDestStreamlen
-     * @param decodedLen
-     * @return
-     */
-	static ReturnValue_t decode(const uint8_t *sourceStream,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
+ *          decode arbitrary data with ASCII control characters
+ * @details
+ * List of control codes:
+ * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * This encoder can be used to achieve a basic transport layer when using
+ * char based transmission systems.
+ * The passed source strean is converted into a encoded stream by adding
+ * a STX marker at the start of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
+ * escaped by a DLE character. The encoder also replaces escaped control chars
+ * by another char, so STX, ETX and CR should not appear anywhere in the actual
+ * encoded data stream.
+ *
+ * When using a strictly char based reception of packets enoded with DLE,
+ * STX can be used to notify a reader that actual data will start to arrive
+ * while ETX can be used to notify the reader that the data has ended.
+ */
+class DleEncoder: public HasReturnvaluesIF {
+private:
+	DleEncoder();
+	virtual ~DleEncoder();
+
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
+	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
+	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
+
+	//! Start Of Text character. First character is encoded stream
+	static constexpr uint8_t STX = 0x02;
+	//! End Of Text character. Last character in encoded stream
+	static constexpr uint8_t ETX = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! in the source stream.
+	static constexpr uint8_t DLE = 0x10;
+	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
+
+    /**
+     * Encodes the give data stream by preceding it with the STX marker
+     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * the stream are escaped by DLE characters and also replaced by adding
+     * 0x40 (which is reverted in the decoing process).
+     * @param sourceStream
+     * @param sourceLen
+     * @param destStream
+     * @param maxDestLen
+     * @param encodedLen
+     * @param addStxEtx
+     * Adding STX and ETX can be omitted, if they are added manually.
+     * @return
+     */
+    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
+
+    /**
+     * Converts an encoded stream back.
+     * @param sourceStream
+     * @param sourceStreamLen
+     * @param readLen
+     * @param destStream
+     * @param maxDestStreamlen
+     * @param decodedLen
+     * @return
+     */
+	static ReturnValue_t decode(const uint8_t *sourceStream,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 2101074e..9589bed3 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,181 +1,181 @@
-#include <framework/globalfunctions/Type.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-Type::Type() :
-		actualType(UNKNOWN_TYPE) {
-}
-
-Type::Type(ActualType_t actualType) :
-		actualType(actualType) {
-}
-
-Type::Type(const Type& type) :
-		actualType(type.actualType) {
-}
-
-Type& Type::operator =(Type rhs) {
-	this->actualType = rhs.actualType;
-	return *this;
-}
-
-Type& Type::operator =(ActualType_t actualType) {
-	this->actualType = actualType;
-	return *this;
-}
-
-Type::operator Type::ActualType_t() const {
-	return actualType;
-}
-
-bool Type::operator ==(const Type& rhs) {
-	return this->actualType == rhs.actualType;
-}
-
-bool Type::operator !=(const Type& rhs) {
-	return !operator==(rhs);
-}
-
-uint8_t Type::getSize() const {
-	switch (actualType) {
-	case UINT8_T:
-		return sizeof(uint8_t);
-	case INT8_T:
-		return sizeof(int8_t);
-	case UINT16_T:
-		return sizeof(uint16_t);
-	case INT16_T:
-		return sizeof(int16_t);
-	case UINT32_T:
-		return sizeof(uint32_t);
-	case INT32_T:
-		return sizeof(int32_t);
-	case FLOAT:
-		return sizeof(float);
-	case DOUBLE:
-		return sizeof(double);
-	default:
-		return 0;
-	}
-}
-
-ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			streamEndianness);
-
-	return result;
-
-}
-
-size_t Type::getSerializedSize() const {
-	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
-}
-
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	actualType = getActualType(ptc, pfc);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
-	switch (actualType) {
-	case UINT8_T:
-		*ptc = 3;
-		*pfc = 4;
-		break;
-	case INT8_T:
-		*ptc = 4;
-		*pfc = 4;
-		break;
-	case UINT16_T:
-		*ptc = 3;
-		*pfc = 12;
-		break;
-	case INT16_T:
-		*ptc = 4;
-		*pfc = 12;
-		break;
-	case UINT32_T:
-		*ptc = 3;
-		*pfc = 14;
-		break;
-	case INT32_T:
-		*ptc = 4;
-		*pfc = 14;
-		break;
-	case FLOAT:
-		*ptc = 5;
-		*pfc = 1;
-		break;
-	case DOUBLE:
-		*ptc = 5;
-		*pfc = 2;
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
-	switch (ptc) {
-	case 3:
-		switch (pfc) {
-		case 4:
-			return UINT8_T;
-		case 12:
-			return UINT16_T;
-		case 14:
-			return UINT32_T;
-		}
-		break;
-	case 4:
-		switch (pfc) {
-		case 4:
-			return INT8_T;
-		case 12:
-			return INT16_T;
-		case 14:
-			return INT32_T;
-		}
-		break;
-	case 5:
-		switch (pfc) {
-		case 1:
-			return FLOAT;
-		case 2:
-			return DOUBLE;
-		}
-		break;
-	}
-	return UNKNOWN_TYPE;
-}
+#include "../globalfunctions/Type.h"
+#include "../serialize/SerializeAdapter.h"
+
+Type::Type() :
+		actualType(UNKNOWN_TYPE) {
+}
+
+Type::Type(ActualType_t actualType) :
+		actualType(actualType) {
+}
+
+Type::Type(const Type& type) :
+		actualType(type.actualType) {
+}
+
+Type& Type::operator =(Type rhs) {
+	this->actualType = rhs.actualType;
+	return *this;
+}
+
+Type& Type::operator =(ActualType_t actualType) {
+	this->actualType = actualType;
+	return *this;
+}
+
+Type::operator Type::ActualType_t() const {
+	return actualType;
+}
+
+bool Type::operator ==(const Type& rhs) {
+	return this->actualType == rhs.actualType;
+}
+
+bool Type::operator !=(const Type& rhs) {
+	return !operator==(rhs);
+}
+
+uint8_t Type::getSize() const {
+	switch (actualType) {
+	case UINT8_T:
+		return sizeof(uint8_t);
+	case INT8_T:
+		return sizeof(int8_t);
+	case UINT16_T:
+		return sizeof(uint16_t);
+	case INT16_T:
+		return sizeof(int16_t);
+	case UINT32_T:
+		return sizeof(uint32_t);
+	case INT32_T:
+		return sizeof(int32_t);
+	case FLOAT:
+		return sizeof(float);
+	case DOUBLE:
+		return sizeof(double);
+	default:
+		return 0;
+	}
+}
+
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
+
+	return result;
+
+}
+
+size_t Type::getSerializedSize() const {
+	uint8_t dontcare = 0;
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
+}
+
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	actualType = getActualType(ptc, pfc);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
+	switch (actualType) {
+	case UINT8_T:
+		*ptc = 3;
+		*pfc = 4;
+		break;
+	case INT8_T:
+		*ptc = 4;
+		*pfc = 4;
+		break;
+	case UINT16_T:
+		*ptc = 3;
+		*pfc = 12;
+		break;
+	case INT16_T:
+		*ptc = 4;
+		*pfc = 12;
+		break;
+	case UINT32_T:
+		*ptc = 3;
+		*pfc = 14;
+		break;
+	case INT32_T:
+		*ptc = 4;
+		*pfc = 14;
+		break;
+	case FLOAT:
+		*ptc = 5;
+		*pfc = 1;
+		break;
+	case DOUBLE:
+		*ptc = 5;
+		*pfc = 2;
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
+	switch (ptc) {
+	case 3:
+		switch (pfc) {
+		case 4:
+			return UINT8_T;
+		case 12:
+			return UINT16_T;
+		case 14:
+			return UINT32_T;
+		}
+		break;
+	case 4:
+		switch (pfc) {
+		case 4:
+			return INT8_T;
+		case 12:
+			return INT16_T;
+		case 14:
+			return INT32_T;
+		}
+		break;
+	case 5:
+		switch (pfc) {
+		case 1:
+			return FLOAT;
+		case 2:
+			return DOUBLE;
+		}
+		break;
+	}
+	return UNKNOWN_TYPE;
+}
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index b083a701..c10511f8 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,94 +1,94 @@
-#ifndef TYPE_H_
-#define TYPE_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief 	Type definition for CCSDS or ECSS.
- */
-class Type: public SerializeIF {
-public:
-	enum ActualType_t {
-		UINT8_T,
-		INT8_T,
-		UINT16_T,
-		INT16_T,
-		UINT32_T,
-		INT32_T,
-		FLOAT,
-		DOUBLE,
-		UNKNOWN_TYPE
-	};
-
-	Type();
-
-	Type(ActualType_t actualType);
-
-	Type(const Type &type);
-
-	Type& operator=(Type rhs);
-
-	Type& operator=(ActualType_t actualType);
-
-	operator ActualType_t() const;
-
-	bool operator==(const Type &rhs);
-	bool operator!=(const Type &rhs);
-
-	uint8_t getSize() const;
-
-	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
-
-	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override;
-
-private:
-	ActualType_t actualType;
-};
-
-template<typename T>
-struct PodTypeConversion {
-	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
-};
-template<>
-struct PodTypeConversion<uint8_t> {
-	static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
-struct PodTypeConversion<uint16_t> {
-	static const Type::ActualType_t type = Type::UINT16_T;
-};
-template<>
-struct PodTypeConversion<uint32_t> {
-	static const Type::ActualType_t type = Type::UINT32_T;
-};
-template<>
-struct PodTypeConversion<int8_t> {
-	static const Type::ActualType_t type = Type::INT8_T;
-};
-template<>
-struct PodTypeConversion<int16_t> {
-	static const Type::ActualType_t type = Type::INT16_T;
-};
-template<>
-struct PodTypeConversion<int32_t> {
-	static const Type::ActualType_t type = Type::INT32_T;
-};
-template<>
-struct PodTypeConversion<float> {
-	static const Type::ActualType_t type = Type::FLOAT;
-};
-template<>
-struct PodTypeConversion<double> {
-	static const Type::ActualType_t type = Type::DOUBLE;
-};
-
-#endif /* TYPE_H_ */
+#ifndef TYPE_H_
+#define TYPE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
+class Type: public SerializeIF {
+public:
+	enum ActualType_t {
+		UINT8_T,
+		INT8_T,
+		UINT16_T,
+		INT16_T,
+		UINT32_T,
+		INT32_T,
+		FLOAT,
+		DOUBLE,
+		UNKNOWN_TYPE
+	};
+
+	Type();
+
+	Type(ActualType_t actualType);
+
+	Type(const Type &type);
+
+	Type& operator=(Type rhs);
+
+	Type& operator=(ActualType_t actualType);
+
+	operator ActualType_t() const;
+
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
+
+	uint8_t getSize() const;
+
+	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
+
+	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override;
+
+private:
+	ActualType_t actualType;
+};
+
+template<typename T>
+struct PodTypeConversion {
+	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
+};
+template<>
+struct PodTypeConversion<uint8_t> {
+	static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
+struct PodTypeConversion<uint16_t> {
+	static const Type::ActualType_t type = Type::UINT16_T;
+};
+template<>
+struct PodTypeConversion<uint32_t> {
+	static const Type::ActualType_t type = Type::UINT32_T;
+};
+template<>
+struct PodTypeConversion<int8_t> {
+	static const Type::ActualType_t type = Type::INT8_T;
+};
+template<>
+struct PodTypeConversion<int16_t> {
+	static const Type::ActualType_t type = Type::INT16_T;
+};
+template<>
+struct PodTypeConversion<int32_t> {
+	static const Type::ActualType_t type = Type::INT32_T;
+};
+template<>
+struct PodTypeConversion<float> {
+	static const Type::ActualType_t type = Type::FLOAT;
+};
+template<>
+struct PodTypeConversion<double> {
+	static const Type::ActualType_t type = Type::DOUBLE;
+};
+
+#endif /* TYPE_H_ */
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index e8fce56c..3f02c882 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,61 +1,61 @@
-#include <framework/globalfunctions/arrayprinter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <bitset>
-
-void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
-}
-
-void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
+#include "../globalfunctions/arrayprinter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index df7325cf..60e055a1 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,41 +1,41 @@
-#ifndef BINARYMATCHER_H_
-#define BINARYMATCHER_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-
-template<typename T>
-class BinaryMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	BinaryMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	BinaryMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-
-	bool doMatch(T input, T mask, T match) {
-		match = match & mask;
-		input = input & mask;
-		if (input == match) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-};
-
-#endif /* BINARYMATCHER_H_ */
+#ifndef BINARYMATCHER_H_
+#define BINARYMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class BinaryMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	BinaryMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	BinaryMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+
+	bool doMatch(T input, T mask, T match) {
+		match = match & mask;
+		input = input & mask;
+		if (input == match) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+};
+
+#endif /* BINARYMATCHER_H_ */
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index f4722e6b..24f399ef 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,50 +1,50 @@
-#ifndef DECIMALMATCHER_H_
-#define DECIMALMATCHER_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-
-template<typename T>
-class DecimalMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	DecimalMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	DecimalMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-	bool doMatch(T input, T mask, T match) {
-		T decimal = 1, remainderMask, remainderMatch, remainderInput;
-
-		while (mask != 0) {
-			remainderMask = mask % (decimal * 10);
-			remainderMatch = match % (decimal * 10);
-			remainderInput = input % (decimal * 10);
-			if (remainderMask != 0) {
-				if (remainderMatch != remainderInput) {
-					return false;
-				}
-			}
-			mask -= remainderMask;
-			match -= remainderMatch;
-			input -= remainderInput;
-			decimal *= 10;
-		}
-		return true;
-	}
-};
-
-#endif /* DECIMALMATCHER_H_ */
+#ifndef DECIMALMATCHER_H_
+#define DECIMALMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class DecimalMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	DecimalMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	DecimalMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+	bool doMatch(T input, T mask, T match) {
+		T decimal = 1, remainderMask, remainderMatch, remainderInput;
+
+		while (mask != 0) {
+			remainderMask = mask % (decimal * 10);
+			remainderMatch = match % (decimal * 10);
+			remainderInput = input % (decimal * 10);
+			if (remainderMask != 0) {
+				if (remainderMatch != remainderInput) {
+					return false;
+				}
+			}
+			mask -= remainderMask;
+			match -= remainderMatch;
+			input -= remainderInput;
+			decimal *= 10;
+		}
+		return true;
+	}
+};
+
+#endif /* DECIMALMATCHER_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index b54f5492..2d380bbb 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -1,216 +1,216 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-
-#include <framework/container/BinaryTree.h>
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-template<typename T>
-class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
-		SerializeableMatcherIF<T>> {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
-	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
-
-	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
-	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
-	static const bool AND = true; //LEFT
-	static const bool OR = false; //RIGHT
-	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
-			uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
-	}
-	MatchTree(iterator root, uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
-					maxDepth) {
-	}
-	MatchTree() :
-			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
-	}
-	virtual ~MatchTree() {
-	}
-	virtual bool match(T number) {
-		return matchesTree(number);
-	}
-	bool matchesTree(T number) {
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter, number);
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
-		iterator iter = this->begin();
-		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (iter == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		result = iter->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, maxSize, streamEndianness);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		iter = iter.right();
-		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			if (maxDepth > 0) {
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, maxSize, streamEndianness);
-			}
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			iter = iter.right();
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const override {
-		//Analogous to serialize!
-		uint32_t size = 1; //One for count
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return size;
-		}
-		//Count object itself
-		size += iter->getSerializedSize();
-		//Handle everything below on AND side
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			size += temp.getSerializedSize();
-		}
-		//Handle everything on OR side
-		iter = iter.right();
-		//Iterate over every object on the OR branch
-		while (iter != this->end()) {
-			size += iter->getSerializedSize();
-			if (maxDepth > 0) {
-				//If we are allowed to go deeper, handle AND elements.
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				size += temp.getSerializedSize();
-			}
-			iter = iter.right();
-		}
-		return size;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-
-	bool isOnAndBranch(iterator position) {
-		if ((position == this->end()) || (position.up() == this->end())) {
-			return false;
-		}
-		if (position.up().left() == position) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
-	ReturnValue_t removeElementAndAllChildren(iterator position) {
-		auto children = this->erase(position);
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (children.first != this->end()) {
-			result = removeElementAndAllChildren(children.first);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (children.second != this->end()) {
-			result = removeElementAndAllChildren(children.second);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
-		if (position == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		//Delete everything from the AND branch.
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (position.left() != this->end()) {
-			result = removeElementAndAllChildren(position.left());
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-
-		if (position.right() != this->end()) {
-			//There's something at the OR branch, reconnect to parent.
-			if (isOnAndBranch(position)) {
-				//Either one hierarchy up AND branch...
-				this->insert(AND, position.up(), position.right().element);
-			} else {
-				//or on another OR'ed element (or install new root node).
-				this->insert(OR, position.up(), position.right().element);
-			}
-		} else {
-			if (isOnAndBranch(position)) {
-				//Recursively delete parent node as well, because it is not expected to be there anymore.
-				return removeElementAndReconnectChildren(position.up());
-			} else {
-				//simply delete self.
-				this->erase(position);
-			}
-
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	virtual ReturnValue_t cleanUpElement(iterator position) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	bool matchSubtree(iterator iter, T number) {
-		bool isMatch = iter->match(number);
-		if (isMatch) {
-			if (iter.left() == this->end()) {
-				return true;
-			}
-			isMatch = matchSubtree(iter.left(), number);
-			if (isMatch) {
-				return true;
-			}
-		}
-		if (iter.right() == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter.right(), number);
-	}
-private:
-	uint8_t maxDepth;
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+
+#include "../../container/BinaryTree.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
+		SerializeableMatcherIF<T>> {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
+	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
+
+	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
+	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
+	static const bool AND = true; //LEFT
+	static const bool OR = false; //RIGHT
+	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
+			uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
+	}
+	MatchTree(iterator root, uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
+					maxDepth) {
+	}
+	MatchTree() :
+			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
+	}
+	virtual ~MatchTree() {
+	}
+	virtual bool match(T number) {
+		return matchesTree(number);
+	}
+	bool matchesTree(T number) {
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter, number);
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
+		iterator iter = this->begin();
+		uint8_t count = this->countRight(iter);
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (iter == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		iter = iter.right();
+		while (iter != this->end()) {
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			if (maxDepth > 0) {
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
+			}
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			iter = iter.right();
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const override {
+		//Analogous to serialize!
+		uint32_t size = 1; //One for count
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return size;
+		}
+		//Count object itself
+		size += iter->getSerializedSize();
+		//Handle everything below on AND side
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			size += temp.getSerializedSize();
+		}
+		//Handle everything on OR side
+		iter = iter.right();
+		//Iterate over every object on the OR branch
+		while (iter != this->end()) {
+			size += iter->getSerializedSize();
+			if (maxDepth > 0) {
+				//If we are allowed to go deeper, handle AND elements.
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				size += temp.getSerializedSize();
+			}
+			iter = iter.right();
+		}
+		return size;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+
+	bool isOnAndBranch(iterator position) {
+		if ((position == this->end()) || (position.up() == this->end())) {
+			return false;
+		}
+		if (position.up().left() == position) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
+	ReturnValue_t removeElementAndAllChildren(iterator position) {
+		auto children = this->erase(position);
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (children.first != this->end()) {
+			result = removeElementAndAllChildren(children.first);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (children.second != this->end()) {
+			result = removeElementAndAllChildren(children.second);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
+		if (position == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		//Delete everything from the AND branch.
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (position.left() != this->end()) {
+			result = removeElementAndAllChildren(position.left());
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+
+		if (position.right() != this->end()) {
+			//There's something at the OR branch, reconnect to parent.
+			if (isOnAndBranch(position)) {
+				//Either one hierarchy up AND branch...
+				this->insert(AND, position.up(), position.right().element);
+			} else {
+				//or on another OR'ed element (or install new root node).
+				this->insert(OR, position.up(), position.right().element);
+			}
+		} else {
+			if (isOnAndBranch(position)) {
+				//Recursively delete parent node as well, because it is not expected to be there anymore.
+				return removeElementAndReconnectChildren(position.up());
+			} else {
+				//simply delete self.
+				this->erase(position);
+			}
+
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	virtual ReturnValue_t cleanUpElement(iterator position) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	bool matchSubtree(iterator iter, T number) {
+		bool isMatch = iter->match(number);
+		if (isMatch) {
+			if (iter.left() == this->end()) {
+				return true;
+			}
+			isMatch = matchSubtree(iter.left(), number);
+			if (isMatch) {
+				return true;
+			}
+		}
+		if (iter.right() == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter.right(), number);
+	}
+private:
+	uint8_t maxDepth;
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 6fee1f52..ac67e8b8 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,70 +1,70 @@
-#ifndef RANGEMATCHER_H_
-#define RANGEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-template<typename T>
-class RangeMatcher: public SerializeableMatcherIF<T> {
-public:
-	bool inverted;
-	T lowerBound;
-	T upperBound;
-
-	RangeMatcher() :
-			inverted(true), lowerBound(1), upperBound(0) {
-	}
-	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
-			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return !doMatch(input);
-		} else {
-			return doMatch(input);
-		}
-	}
-
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&inverted, buffer, size,
-				streamEndianness);
-	}
-protected:
-	bool doMatch(T input) {
-		return (input >= lowerBound) && (input <= upperBound);
-	}
-};
-
-#endif /* RANGEMATCHER_H_ */
+#ifndef RANGEMATCHER_H_
+#define RANGEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class RangeMatcher: public SerializeableMatcherIF<T> {
+public:
+	bool inverted;
+	T lowerBound;
+	T upperBound;
+
+	RangeMatcher() :
+			inverted(true), lowerBound(1), upperBound(0) {
+	}
+	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
+			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return !doMatch(input);
+		} else {
+			return doMatch(input);
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
+	}
+protected:
+	bool doMatch(T input) {
+		return (input >= lowerBound) && (input <= upperBound);
+	}
+};
+
+#endif /* RANGEMATCHER_H_ */
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index 7b00a1b3..0d2873ef 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-
-#include <framework/globalfunctions/matching/MatcherIF.h>
-#include <framework/serialize/SerializeIF.h>
-
-template<typename T>
-class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
-public:
-	virtual ~SerializeableMatcherIF() {}
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+#include "../../serialize/SerializeIF.h"
+
+template<typename T>
+class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
+public:
+	virtual ~SerializeableMatcherIF() {}
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index f8c75149..448d30f1 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,156 +1,156 @@
-#include "QuaternionOperations.h"
-#include <framework/globalfunctions/math/VectorOperations.h>
-
-#include <cmath>
-#include <cstring>
-#include <stdint.h>
-
-QuaternionOperations::~QuaternionOperations() {
-}
-
-void QuaternionOperations::multiply(const double* q1, const double* q2,
-		double* q) {
-	double out[4];
-
-	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
-	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
-	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
-	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
-
-	memcpy(q, out, 4 * sizeof(*q));
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::inverse(const double* quaternion,
-		double* inverseQuaternion) {
-	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
-	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
-			inverseQuaternion, 3);
-}
-
-QuaternionOperations::QuaternionOperations() {
-
-}
-
-void QuaternionOperations::normalize(const double* quaternion,
-		double* unitQuaternion) {
-	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
-}
-
-float QuaternionOperations::norm(const double* quaternion) {
-	return VectorOperations<double>::norm(quaternion, 4);
-}
-
-void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
-		uint8_t *index) {
-
-	double a[4];
-
-	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
-	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
-	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
-	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
-
-	uint8_t maxAIndex = 0;
-
-	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
-
-	if (index != 0) {
-		*index = maxAIndex;
-	}
-
-	switch (maxAIndex) {
-	case 0:
-		quaternion[0] = 0.5 * sqrt(a[0]);
-		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
-		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
-		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
-		break;
-	case 1:
-		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
-		quaternion[1] = 0.5 * sqrt(a[1]);
-		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
-		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
-		break;
-	case 2:
-		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
-		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
-		quaternion[2] = 0.5 * sqrt(a[2]);
-		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
-		break;
-	case 3:
-		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
-		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
-		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
-		quaternion[3] = 0.5 * sqrt(a[3]);
-		break;
-	}
-
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::normalize(double* quaternion) {
-	normalize(quaternion, quaternion);
-}
-
-double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
-	if (quaternion[3] >= 0) {
-		return 2 * acos(quaternion[3]);
-	} else {
-		if (abs) {
-			return 2 * acos(-quaternion[3]);
-		} else {
-			return -2 * acos(-quaternion[3]);
-		}
-	}
-}
+#include "QuaternionOperations.h"
+#include "../../globalfunctions/math/VectorOperations.h"
+
+#include <cmath>
+#include <cstring>
+#include <stdint.h>
+
+QuaternionOperations::~QuaternionOperations() {
+}
+
+void QuaternionOperations::multiply(const double* q1, const double* q2,
+		double* q) {
+	double out[4];
+
+	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
+	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
+	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
+	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
+
+	memcpy(q, out, 4 * sizeof(*q));
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::inverse(const double* quaternion,
+		double* inverseQuaternion) {
+	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
+	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
+			inverseQuaternion, 3);
+}
+
+QuaternionOperations::QuaternionOperations() {
+
+}
+
+void QuaternionOperations::normalize(const double* quaternion,
+		double* unitQuaternion) {
+	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
+}
+
+float QuaternionOperations::norm(const double* quaternion) {
+	return VectorOperations<double>::norm(quaternion, 4);
+}
+
+void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
+		uint8_t *index) {
+
+	double a[4];
+
+	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
+	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
+	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
+	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
+
+	uint8_t maxAIndex = 0;
+
+	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
+
+	if (index != 0) {
+		*index = maxAIndex;
+	}
+
+	switch (maxAIndex) {
+	case 0:
+		quaternion[0] = 0.5 * sqrt(a[0]);
+		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
+		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
+		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
+		break;
+	case 1:
+		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
+		quaternion[1] = 0.5 * sqrt(a[1]);
+		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
+		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
+		break;
+	case 2:
+		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
+		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
+		quaternion[2] = 0.5 * sqrt(a[2]);
+		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
+		break;
+	case 3:
+		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
+		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
+		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
+		quaternion[3] = 0.5 * sqrt(a[3]);
+		break;
+	}
+
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::normalize(double* quaternion) {
+	normalize(quaternion, quaternion);
+}
+
+double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
+	if (quaternion[3] >= 0) {
+		return 2 * acos(quaternion[3]);
+	} else {
+		if (abs) {
+			return 2 * acos(-quaternion[3]);
+		} else {
+			return -2 * acos(-quaternion[3]);
+		}
+	}
+}
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index 1da45d7b..aa921511 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,99 +1,99 @@
-#include <framework/globalfunctions/timevalOperations.h>
-
-timeval& operator+=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator+(timeval lhs, const timeval& rhs) {
-	lhs += rhs;
-	return lhs;
-}
-
-timeval& operator-=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator-(timeval lhs, const timeval& rhs) {
-	lhs -= rhs;
-	return lhs;
-}
-
-double operator/(const timeval& lhs, const timeval& rhs) {
-	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 / rhs64;
-}
-
-timeval& operator/=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product /= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator/(timeval lhs, double scalar) {
-	lhs /= scalar;
-	return lhs;
-}
-
-timeval& operator*=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product *= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator*(timeval lhs, double scalar) {
-	lhs *= scalar;
-	return lhs;
-}
-
-timeval operator*(double scalar, timeval rhs) {
-	rhs *= scalar;
-	return rhs;
-}
-
-bool operator==(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 == rhs64;
-}
-bool operator!=(const timeval& lhs, const timeval& rhs) {
-	return !operator==(lhs, rhs);
-}
-bool operator<(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 < rhs64;
-}
-bool operator>(const timeval& lhs, const timeval& rhs) {
-	return operator<(rhs, lhs);
-}
-bool operator<=(const timeval& lhs, const timeval& rhs) {
-	return !operator>(lhs, rhs);
-}
-bool operator>=(const timeval& lhs, const timeval& rhs) {
-	return !operator<(lhs, rhs);
-}
-
-double timevalOperations::toDouble(const timeval timeval) {
-	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
-	return result / 1000000.;
-}
-
-timeval timevalOperations::toTimeval(const double seconds) {
-	timeval tval;
-	tval.tv_sec = seconds;
-	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
-	return tval;
-}
+#include "../globalfunctions/timevalOperations.h"
+
+timeval& operator+=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator+(timeval lhs, const timeval& rhs) {
+	lhs += rhs;
+	return lhs;
+}
+
+timeval& operator-=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator-(timeval lhs, const timeval& rhs) {
+	lhs -= rhs;
+	return lhs;
+}
+
+double operator/(const timeval& lhs, const timeval& rhs) {
+	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 / rhs64;
+}
+
+timeval& operator/=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product /= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator/(timeval lhs, double scalar) {
+	lhs /= scalar;
+	return lhs;
+}
+
+timeval& operator*=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product *= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator*(timeval lhs, double scalar) {
+	lhs *= scalar;
+	return lhs;
+}
+
+timeval operator*(double scalar, timeval rhs) {
+	rhs *= scalar;
+	return rhs;
+}
+
+bool operator==(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 == rhs64;
+}
+bool operator!=(const timeval& lhs, const timeval& rhs) {
+	return !operator==(lhs, rhs);
+}
+bool operator<(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 < rhs64;
+}
+bool operator>(const timeval& lhs, const timeval& rhs) {
+	return operator<(rhs, lhs);
+}
+bool operator<=(const timeval& lhs, const timeval& rhs) {
+	return !operator>(lhs, rhs);
+}
+bool operator>=(const timeval& lhs, const timeval& rhs) {
+	return !operator<(lhs, rhs);
+}
+
+double timevalOperations::toDouble(const timeval timeval) {
+	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
+	return result / 1000000.;
+}
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index dd27fe39..9ef8c1e9 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,50 +1,50 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class HasHealthIF {
-public:
-
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
-
-	virtual ~HasHealthIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	virtual ReturnValue_t setHealth(HealthState health) = 0;
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	virtual HasHealthIF::HealthState getHealth() = 0;
-};
-
-#endif /* HASHEALTHIF_H_ */
+#ifndef HASHEALTHIF_H_
+#define HASHEALTHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasHealthIF {
+public:
+
+	typedef enum {
+		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
+	} HealthState;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
+	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+
+	virtual ~HasHealthIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	virtual ReturnValue_t setHealth(HealthState health) = 0;
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	virtual HasHealthIF::HealthState getHealth() = 0;
+};
+
+#endif /* HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index ba8504c2..800d6e36 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,105 +1,105 @@
-#include <framework/health/HealthHelper.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		objectId(objectId), owner(owner) {
-}
-
-HealthHelper::~HealthHelper() {
-}
-
-ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_SET:
-		handleSetHealthCommand(message);
-		return HasReturnvaluesIF::RETURN_OK;
-	case HealthMessage::HEALTH_ANNOUNCE: {
-		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
-				getHealth());
-	}
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-HasHealthIF::HealthState HealthHelper::getHealth() {
-	return healthTable->getHealth(objectId);
-}
-
-ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQueue(parentQueue);
-	return initialize();
-}
-
-void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
-	this->parentQueue = parentQueue;
-}
-
-ReturnValue_t HealthHelper::initialize() {
-	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-
-	if (healthTable == nullptr) {
-	    sif::error << "HealthHelper::initialize: Health table object needs"
-	            "to be created in factory." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	if(eventSender == nullptr) {
-	    sif::error << "HealthHelper::initialize: Owner has to implement "
-	            "ReportingProxyIF." << std::endl;
-	    return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	ReturnValue_t result = healthTable->registerObject(objectId,
-			HasHealthIF::HEALTHY);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthHelper::setHealth(HasHealthIF::HealthState health) {
-	HasHealthIF::HealthState oldHealth = getHealth();
-	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
-	if (health != oldHealth) {
-		healthTable->setHealth(objectId, health);
-		informParent(health, oldHealth);
-	}
-}
-
-void HealthHelper::informParent(HasHealthIF::HealthState health,
-		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage information;
-	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
-			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::informParent: sending health reply failed."
-				<< std::endl;
-	}
-}
-
-void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage reply;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		HealthMessage::setHealthMessage(&reply,
-				HealthMessage::REPLY_HEALTH_SET);
-	} else {
-		reply.setReplyRejected(result, command->getCommand());
-	}
-	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::handleHealthCommand: sending health "
-		        "reply failed." << std::endl;
-
-	}
-}
+#include "../health/HealthHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
+		objectId(objectId), owner(owner) {
+}
+
+HealthHelper::~HealthHelper() {
+}
+
+ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_SET:
+		handleSetHealthCommand(message);
+		return HasReturnvaluesIF::RETURN_OK;
+	case HealthMessage::HEALTH_ANNOUNCE: {
+		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
+				getHealth());
+	}
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+HasHealthIF::HealthState HealthHelper::getHealth() {
+	return healthTable->getHealth(objectId);
+}
+
+ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
+	setParentQueue(parentQueue);
+	return initialize();
+}
+
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
+	this->parentQueue = parentQueue;
+}
+
+ReturnValue_t HealthHelper::initialize() {
+	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+
+	if (healthTable == nullptr) {
+	    sif::error << "HealthHelper::initialize: Health table object needs"
+	            "to be created in factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	if(eventSender == nullptr) {
+	    sif::error << "HealthHelper::initialize: Owner has to implement "
+	            "ReportingProxyIF." << std::endl;
+	    return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	ReturnValue_t result = healthTable->registerObject(objectId,
+			HasHealthIF::HEALTHY);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthHelper::setHealth(HasHealthIF::HealthState health) {
+	HasHealthIF::HealthState oldHealth = getHealth();
+	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
+	if (health != oldHealth) {
+		healthTable->setHealth(objectId, health);
+		informParent(health, oldHealth);
+	}
+}
+
+void HealthHelper::informParent(HasHealthIF::HealthState health,
+		HasHealthIF::HealthState oldHealth) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage information;
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
+			health, oldHealth);
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::informParent: sending health reply failed."
+				<< std::endl;
+	}
+}
+
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage reply;
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		HealthMessage::setHealthMessage(&reply,
+				HealthMessage::REPLY_HEALTH_SET);
+	} else {
+		reply.setReplyRejected(result, command->getCommand());
+	}
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
+
+	}
+}
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index e112ad2c..99bb501f 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
-
-#include <framework/events/EventManagerIF.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * Helper class for Objects that implement HasHealthIF
- *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
- * changes, not for all @c HEALTH_SET commands received.
- *
- * It does NOT handle @c HEALTH_INFO messages
- */
-class HealthHelper {
-public:
-
-	/**
-	 * ctor
-	 *
-	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
-	 */
-	HealthHelper(HasHealthIF* owner, object_id_t objectId);
-
-	virtual ~HealthHelper();
-
-	/**
-	 * Pointer to the Health Table
-	 *
-	 * only valid after initialize() has been called
-	 */
-	HealthTableIF *healthTable = nullptr;
-
-	/**
-	 * Proxy to forward events.
-	 */
-	EventReportingProxyIF* eventSender = nullptr;
-
-	/**
-	 * Try to handle the message.
-	 *
-	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
-	 * it updates the Health Table and generates a reply to the sender.
-	 *
-	 * @param message
-	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
-	 */
-	ReturnValue_t handleHealthCommand(CommandMessage *message);
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	void setHealth(HasHealthIF::HealthState health);
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	HasHealthIF::HealthState getHealth();
-
-	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
-	 */
-	ReturnValue_t initialize(MessageQueueId_t parentQueue );
-
-	ReturnValue_t initialize();
-
-private:
-	/**
-	 * the object id to use when communicating with the Health Table
-	 */
-	object_id_t objectId;
-
-	/**
-	 * The Queue of the parent
-	 */
-	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
-
-	/**
-	 * The one using the healthHelper.
-	 */
-	HasHealthIF* owner;
-
-	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
-	 * @param oldHealth information of the previous health state.
-	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
-
-	void handleSetHealthCommand(CommandMessage *message);
-};
-
-#endif /* HEALTHHELPER_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../health/HealthTableIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * Helper class for Objects that implement HasHealthIF
+ *
+ * It takes care of registering with the Health Table as well as handling health commands
+ * (including replying to the sender) and updating the Health Table.
+ *
+ * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
+ * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * changes, not for all @c HEALTH_SET commands received.
+ *
+ * It does NOT handle @c HEALTH_INFO messages
+ */
+class HealthHelper {
+public:
+
+	/**
+	 * ctor
+	 *
+	 * @param owner
+	 * @param objectId the object Id to use when communication with the HealthTable
+	 */
+	HealthHelper(HasHealthIF* owner, object_id_t objectId);
+
+	virtual ~HealthHelper();
+
+	/**
+	 * Pointer to the Health Table
+	 *
+	 * only valid after initialize() has been called
+	 */
+	HealthTableIF *healthTable = nullptr;
+
+	/**
+	 * Proxy to forward events.
+	 */
+	EventReportingProxyIF* eventSender = nullptr;
+
+	/**
+	 * Try to handle the message.
+	 *
+	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
+	 * it updates the Health Table and generates a reply to the sender.
+	 *
+	 * @param message
+	 * @return
+	 * 			-@c RETURN_OK if the message was handled
+	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 */
+	ReturnValue_t handleHealthCommand(CommandMessage *message);
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	void setHealth(HasHealthIF::HealthState health);
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	HasHealthIF::HealthState getHealth();
+
+	/**
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @return
+	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
+	 * 			-@c RETURN_FAILED else
+	 */
+	ReturnValue_t initialize(MessageQueueId_t parentQueue );
+
+	ReturnValue_t initialize();
+
+private:
+	/**
+	 * the object id to use when communicating with the Health Table
+	 */
+	object_id_t objectId;
+
+	/**
+	 * The Queue of the parent
+	 */
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
+
+	/**
+	 * The one using the healthHelper.
+	 */
+	HasHealthIF* owner;
+
+	/**
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
+	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * @param oldHealth information of the previous health state.
+	 */
+	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+
+	void handleSetHealthCommand(CommandMessage *message);
+};
+
+#endif /* HEALTHHELPER_H_ */
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 768dea46..c5f5b733 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,28 +1,28 @@
-#include <framework/health/HealthMessage.h>
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
-		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
-	message->setCommand(command);
-	message->setParameter(health);
-	message->setParameter2(oldHealth);
-}
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
-	message->setCommand(command);
-}
-
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter();
-}
-
-void HealthMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-HealthMessage::HealthMessage() {
-}
-
-HasHealthIF::HealthState HealthMessage::getOldHealth(
-		const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter2();
-}
+#include "../health/HealthMessage.h"
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
+		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
+	message->setCommand(command);
+	message->setParameter(health);
+	message->setParameter2(oldHealth);
+}
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+	message->setCommand(command);
+}
+
+HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter();
+}
+
+void HealthMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+HealthMessage::HealthMessage() {
+}
+
+HasHealthIF::HealthState HealthMessage::getOldHealth(
+		const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter2();
+}
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index 13e79b88..d16c65db 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,30 +1,30 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/ipc/CommandMessage.h>
-
-class HealthMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
-	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
-	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command);
-
-	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
-
-	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	HealthMessage();
-};
-
-#endif /* HEALTHMESSAGE_H_ */
+#ifndef HEALTHMESSAGE_H_
+#define HEALTHMESSAGE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../ipc/CommandMessage.h"
+
+class HealthMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
+	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
+	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
+	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command,
+			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command);
+
+	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
+
+	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	HealthMessage();
+};
+
+#endif /* HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index e11dcd97..88db89b1 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,100 +1,100 @@
-#include <framework/health/HealthTable.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/ipc/MutexFactory.h>
-
-HealthTable::HealthTable(object_id_t objectid) :
-		SystemObject(objectid) {
-	mutex = MutexFactory::instance()->createMutex();;
-
-	mapIterator = healthMap.begin();
-}
-
-HealthTable::~HealthTable() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t HealthTable::registerObject(object_id_t object,
-		HasHealthIF::HealthState initilialState) {
-	if (healthMap.count(object) != 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthTable::setHealth(object_id_t object,
-		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		iter->second = newState;
-	}
-	mutex->unlockMutex();
-}
-
-HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
-	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		state = iter->second;
-	}
-	mutex->unlockMutex();
-	return state;
-}
-
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
-
-bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		exits = true;
-	}
-	mutex->unlockMutex();
-	return exits;
-}
-
-void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	size_t size = 0;
-	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, SerializeIF::Endianness::BIG);
-	}
-	mutex->unlockMutex();
-}
-
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	if (reset) {
-		mapIterator = healthMap.begin();
-	}
-	if (mapIterator == healthMap.end()) {
-		result = HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*value = *mapIterator;
-	mapIterator++;
-	mutex->unlockMutex();
-
-	return result;
-}
+#include "../health/HealthTable.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../ipc/MutexFactory.h"
+
+HealthTable::HealthTable(object_id_t objectid) :
+		SystemObject(objectid) {
+	mutex = MutexFactory::instance()->createMutex();;
+
+	mapIterator = healthMap.begin();
+}
+
+HealthTable::~HealthTable() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t HealthTable::registerObject(object_id_t object,
+		HasHealthIF::HealthState initilialState) {
+	if (healthMap.count(object) != 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	healthMap.insert(
+			std::pair<object_id_t, HasHealthIF::HealthState>(object,
+					initilialState));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthTable::setHealth(object_id_t object,
+		HasHealthIF::HealthState newState) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		iter->second = newState;
+	}
+	mutex->unlockMutex();
+}
+
+HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
+	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		state = iter->second;
+	}
+	mutex->unlockMutex();
+	return state;
+}
+
+uint32_t HealthTable::getPrintSize() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	uint32_t size = healthMap.size() * 5 + 2;
+	mutex->unlockMutex();
+	return size;
+}
+
+bool HealthTable::hasHealth(object_id_t object) {
+	bool exits = false;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		exits = true;
+	}
+	mutex->unlockMutex();
+	return exits;
+}
+
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	size_t size = 0;
+	uint16_t count = healthMap.size();
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+	HealthMap::iterator iter;
+	for (iter = healthMap.begin();
+			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
+			++iter) {
+		result = SerializeAdapter::serialize(&iter->first,
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+		uint8_t health = iter->second;
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
+				maxSize, SerializeIF::Endianness::BIG);
+	}
+	mutex->unlockMutex();
+}
+
+ReturnValue_t HealthTable::iterate(
+		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	if (reset) {
+		mapIterator = healthMap.begin();
+	}
+	if (mapIterator == healthMap.end()) {
+		result = HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*value = *mapIterator;
+	mapIterator++;
+	mutex->unlockMutex();
+
+	return result;
+}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 6f1ac829..5ed45041 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
-
-#include <framework/health/HealthTableIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MutexIF.h>
-#include <map>
-
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-
-class HealthTable: public HealthTableIF, public SystemObject {
-public:
-	HealthTable(object_id_t objectid);
-	virtual ~HealthTable();
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
-
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
-
-protected:
-	MutexIF* mutex;
-	HealthMap healthMap;
-
-	HealthMap::iterator mapIterator;
-
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
-};
-
-#endif /* HEALTHTABLE_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+
+#include "../health/HealthTableIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+
+class HealthTable: public HealthTableIF, public SystemObject {
+public:
+	HealthTable(object_id_t objectid);
+	virtual ~HealthTable();
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+
+	virtual bool hasHealth(object_id_t object);
+	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
+	virtual HasHealthIF::HealthState getHealth(object_id_t);
+
+	virtual uint32_t getPrintSize();
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
+
+protected:
+	MutexIF* mutex;
+	HealthMap healthMap;
+
+	HealthMap::iterator mapIterator;
+
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+};
+
+#endif /* HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index e4606286..bc4a8cfb 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-
-#include <framework/health/ManagesHealthIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <map>
-
-
-class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
-public:
-	virtual ~HealthTableIF() {
-	}
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
-
-	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
-
-protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
-};
-
-#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+
+#include "../health/ManagesHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <map>
+
+
+class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
+	friend class HealthCommandingService;
+public:
+	virtual ~HealthTableIF() {
+	}
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
+
+	virtual uint32_t getPrintSize() = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
+
+protected:
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+};
+
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index ff0c5386..57996dda 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,52 +1,52 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-class ManagesHealthIF {
-public:
-	virtual ~ManagesHealthIF() {
-	}
-	virtual bool hasHealth(object_id_t object) = 0;
-	virtual void setHealth(object_id_t object,
-			HasHealthIF::HealthState newState) = 0;
-	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
-
-	virtual bool isHealthy(object_id_t object) {
-		return (getHealth(object) == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isHealthy(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isPermanentFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::PERMANENT_FAULTY);
-	}
-
-	static bool isFaulty(HasHealthIF::HealthState health) {
-		return ((health == HasHealthIF::FAULTY)
-				|| (health == HasHealthIF::PERMANENT_FAULTY)
-				|| (health == HasHealthIF::NEEDS_RECOVERY));
-	}
-
-	virtual bool isCommandable(object_id_t object) {
-		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
-	}
-
-	virtual bool isCommandable(HasHealthIF::HealthState health) {
-		return (health != HasHealthIF::EXTERNAL_CONTROL);
-	}
-};
-
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+
+#include "../health/HasHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+class ManagesHealthIF {
+public:
+	virtual ~ManagesHealthIF() {
+	}
+	virtual bool hasHealth(object_id_t object) = 0;
+	virtual void setHealth(object_id_t object,
+			HasHealthIF::HealthState newState) = 0;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
+
+	virtual bool isHealthy(object_id_t object) {
+		return (getHealth(object) == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isHealthy(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isPermanentFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::PERMANENT_FAULTY);
+	}
+
+	static bool isFaulty(HasHealthIF::HealthState health) {
+		return ((health == HasHealthIF::FAULTY)
+				|| (health == HasHealthIF::PERMANENT_FAULTY)
+				|| (health == HasHealthIF::NEEDS_RECOVERY));
+	}
+
+	virtual bool isCommandable(object_id_t object) {
+		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
+	}
+
+	virtual bool isCommandable(HasHealthIF::HealthState health) {
+		return (health != HasHealthIF::EXTERNAL_CONTROL);
+	}
+};
+
+#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index f44e1d95..879aaf8e 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#include <framework/ipc/MessageQueueMessageIF.h>
-
-class AcceptsHkPacketsIF {
-public:
-    virtual~ AcceptsHkPacketsIF() {};
-    virtual MessageQueueId_t getHkQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include "../ipc/MessageQueueMessageIF.h"
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 2335f03d..6777c471 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,48 +1,48 @@
-#include <framework/housekeeping/HousekeepingMessage.h>
-#include <cstring>
-
-HousekeepingMessage::~HousekeepingMessage() {}
-
-void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
-		store_address_t storeId) {
-	message->setCommand(HK_REPORT);
-	message->setMessageSize(HK_MESSAGE_SIZE);
-	setSid(message, sid);
-	setParameter(message, storeId.raw);
-}
-
-void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
-		sid_t sid, store_address_t storeId) {
-	message->setCommand(DIAGNOSTICS_REPORT);
-	message->setMessageSize(HK_MESSAGE_SIZE);
-	setSid(message, sid);
-	setParameter(message, storeId.raw);
-}
-
-sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
-		store_address_t *storeIdToSet) {
-	if(storeIdToSet != nullptr) {
-		*storeIdToSet = getParameter(message);
-	}
-	return getSid(message);
-}
-
-sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
-	sid_t sid;
-	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
-	return sid;
-}
-
-void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
-	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
-}
-
-
-void HousekeepingMessage::setParameter(CommandMessage *message,
-		uint32_t parameter) {
-	message->setParameter3(parameter);
-}
-
-uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
-	return message->getParameter3();
-}
+#include "../housekeeping/HousekeepingMessage.h"
+#include <cstring>
+
+HousekeepingMessage::~HousekeepingMessage() {}
+
+void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
+		store_address_t storeId) {
+	message->setCommand(HK_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
+}
+
+void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+		sid_t sid, store_address_t storeId) {
+	message->setCommand(DIAGNOSTICS_REPORT);
+	message->setMessageSize(HK_MESSAGE_SIZE);
+	setSid(message, sid);
+	setParameter(message, storeId.raw);
+}
+
+sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+		store_address_t *storeIdToSet) {
+	if(storeIdToSet != nullptr) {
+		*storeIdToSet = getParameter(message);
+	}
+	return getSid(message);
+}
+
+sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
+	sid_t sid;
+	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
+	return sid;
+}
+
+void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
+}
+
+
+void HousekeepingMessage::setParameter(CommandMessage *message,
+		uint32_t parameter) {
+	message->setParameter3(parameter);
+}
+
+uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
+	return message->getParameter3();
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2a69805..0f50c2a4 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/FwMessageTypes.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <limits>
-
-union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS =
-			std::numeric_limits<uint64_t>::max();
-	sid_t(): raw(INVALID_ADDRESS) {}
-
-	struct {
-		object_id_t objectId ;
-		/**
-		 * A generic 32 bit ID to identify unique HK packets for a single
-		 * object. For example, the DeviceCommandId_t is used for
-		 * DeviceHandlers
-		 */
-		uint32_t ownerSetId;
-	};
-	/**
-	 * Alternative access to the raw value. This is also the size of the type.
-	 */
-	uint64_t raw;
-};
-
-
-/**
- * @brief	Special command message type for housekeeping messages
- * @details
- * This message is slightly larger than regular command messages to accomodate
- * the uint64_t structure ID (SID).
- */
-class HousekeepingMessage {
-public:
-
-	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
-	        sizeof(sid_t) + sizeof(uint32_t);
-
-	/**
-	 * The HK message is initialized with a pointer to a message which holds
-	 * the message data, see CommandMessageIF and getInternalMessage().
-	 * @param message
-	 */
-	HousekeepingMessage() = delete;
-	virtual ~HousekeepingMessage();
-
-	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
-
-	static constexpr Command_t ADD_HK_REPORT_STRUCT =
-			MAKE_COMMAND_ID(1);
-	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(2);
-
-	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
-	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(4);
-
-	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
-			MAKE_COMMAND_ID(5);
-	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
-			MAKE_COMMAND_ID(6);
-
-	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
-			MAKE_COMMAND_ID(7);
-	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
-			MAKE_COMMAND_ID(8);
-
-	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
-	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
-			MAKE_COMMAND_ID(11);
-
-	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
-	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
-
-	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
-	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
-
-	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
-			MAKE_COMMAND_ID(27);
-	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
-			MAKE_COMMAND_ID(28);
-
-	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(29);
-	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(30);
-
-	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
-			MAKE_COMMAND_ID(31);
-	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
-			MAKE_COMMAND_ID(32);
-
-	static sid_t getSid(const CommandMessage* message);
-
-	static void setHkReportMessage(CommandMessage* message, sid_t sid,
-			store_address_t storeId);
-	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
-			store_address_t storeId);
-
-	//! Get the respective SID and store ID. Command ID can be used beforehand
-	//! to distinguish between diagnostics and regular HK packets
-	static sid_t getHkReportMessage(const CommandMessage* message,
-			store_address_t * storeIdToSet);
-
-private:
-	static void setSid(CommandMessage* message, sid_t sid);
-	static void setParameter(CommandMessage* message, uint32_t parameter);
-	static uint32_t getParameter(const CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
+#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../ipc/FwMessageTypes.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include <limits>
+
+union sid_t {
+	static constexpr uint64_t INVALID_ADDRESS =
+			std::numeric_limits<uint64_t>::max();
+	sid_t(): raw(INVALID_ADDRESS) {}
+
+	struct {
+		object_id_t objectId ;
+		/**
+		 * A generic 32 bit ID to identify unique HK packets for a single
+		 * object. For example, the DeviceCommandId_t is used for
+		 * DeviceHandlers
+		 */
+		uint32_t ownerSetId;
+	};
+	/**
+	 * Alternative access to the raw value. This is also the size of the type.
+	 */
+	uint64_t raw;
+};
+
+
+/**
+ * @brief	Special command message type for housekeeping messages
+ * @details
+ * This message is slightly larger than regular command messages to accomodate
+ * the uint64_t structure ID (SID).
+ */
+class HousekeepingMessage {
+public:
+
+	static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
+	        sizeof(sid_t) + sizeof(uint32_t);
+
+	/**
+	 * The HK message is initialized with a pointer to a message which holds
+	 * the message data, see CommandMessageIF and getInternalMessage().
+	 * @param message
+	 */
+	HousekeepingMessage() = delete;
+	virtual ~HousekeepingMessage();
+
+	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
+
+	static constexpr Command_t ADD_HK_REPORT_STRUCT =
+			MAKE_COMMAND_ID(1);
+	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(2);
+
+	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
+	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
+			MAKE_COMMAND_ID(4);
+
+	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+			MAKE_COMMAND_ID(5);
+	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
+			MAKE_COMMAND_ID(6);
+
+	static constexpr Command_t ENABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(7);
+	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
+			MAKE_COMMAND_ID(8);
+
+	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
+	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
+			MAKE_COMMAND_ID(11);
+
+	static constexpr Command_t HK_DEFINITIONS_REPORT = MAKE_COMMAND_ID(10);
+	static constexpr Command_t DIAGNOSTICS_DEFINITION_REPORT = MAKE_COMMAND_ID(12);
+
+	static constexpr Command_t HK_REPORT = MAKE_COMMAND_ID(25);
+	static constexpr Command_t DIAGNOSTICS_REPORT = MAKE_COMMAND_ID(26);
+
+	static constexpr Command_t GENERATE_ONE_PARAMETER_REPORT  =
+			MAKE_COMMAND_ID(27);
+	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
+			MAKE_COMMAND_ID(28);
+
+	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(29);
+	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
+			MAKE_COMMAND_ID(30);
+
+	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(31);
+	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
+			MAKE_COMMAND_ID(32);
+
+	static sid_t getSid(const CommandMessage* message);
+
+	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+			store_address_t storeId);
+
+	//! Get the respective SID and store ID. Command ID can be used beforehand
+	//! to distinguish between diagnostics and regular HK packets
+	static sid_t getHkReportMessage(const CommandMessage* message,
+			store_address_t * storeIdToSet);
+
+private:
+	static void setSid(CommandMessage* message, sid_t sid);
+	static void setParameter(CommandMessage* message, uint32_t parameter);
+	static uint32_t getParameter(const CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 8944553d..ed064da6 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,125 +1,125 @@
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include "InternalErrorReporter.h"
-
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/ipc/MutexFactory.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-InternalErrorReporter::~InternalErrorReporter() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-
-	uint32_t newQueueHits = getAndResetQueueHits();
-	uint32_t newTmHits = getAndResetTmHits();
-	uint32_t newStoreHits = getAndResetStoreHits();
-
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
-
-	mySet.commit(PoolVariableIF::VALID);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void InternalErrorReporter::queueMessageNotSent() {
-	incrementQueueHits();
-}
-
-void InternalErrorReporter::lostTm() {
-	incrementTmHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	queueHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	queueHits++;
-	mutex->unlockMutex();
-}
-
-uint32_t InternalErrorReporter::getAndResetTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	tmHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	tmHits++;
-	mutex->unlockMutex();
-}
-
-void InternalErrorReporter::storeFull() {
-	incrementStoreHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	storeHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	storeHits++;
-	mutex->unlockMutex();
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "InternalErrorReporter.h"
+
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../ipc/MutexFactory.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
+		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+InternalErrorReporter::~InternalErrorReporter() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
+
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	mySet.read();
+
+	uint32_t newQueueHits = getAndResetQueueHits();
+	uint32_t newTmHits = getAndResetTmHits();
+	uint32_t newStoreHits = getAndResetStoreHits();
+
+	queueHitsInPool.value += newQueueHits;
+	tmHitsInPool.value += newTmHits;
+	storeHitsInPool.value += newStoreHits;
+
+	mySet.commit(PoolVariableIF::VALID);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void InternalErrorReporter::queueMessageNotSent() {
+	incrementQueueHits();
+}
+
+void InternalErrorReporter::lostTm() {
+	incrementTmHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	queueHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementQueueHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	queueHits++;
+	mutex->unlockMutex();
+}
+
+uint32_t InternalErrorReporter::getAndResetTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	tmHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementTmHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	tmHits++;
+	mutex->unlockMutex();
+}
+
+void InternalErrorReporter::storeFull() {
+	incrementStoreHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	storeHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementStoreHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	storeHits++;
+	mutex->unlockMutex();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 7c1df6a7..1fe7426d 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,50 +1,50 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
-
-#include "InternalErrorReporterIF.h"
-
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MutexIF.h>
-
-class InternalErrorReporter: public SystemObject,
-		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
-public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
-	virtual ~InternalErrorReporter();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual void queueMessageNotSent();
-
-	virtual void lostTm();
-
-	virtual void storeFull();
-protected:
-	MutexIF* mutex;
-
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
-
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
-
-	uint32_t getAndResetQueueHits();
-	uint32_t getQueueHits();
-	void incrementQueueHits();
-
-	uint32_t getAndResetTmHits();
-	uint32_t getTmHits();
-	void incrementTmHits();
-
-	uint32_t getAndResetStoreHits();
-	uint32_t getStoreHits();
-	void incrementStoreHits();
-
-};
-
-#endif /* INTERNALERRORREPORTER_H_ */
+#ifndef INTERNALERRORREPORTER_H_
+#define INTERNALERRORREPORTER_H_
+
+#include "InternalErrorReporterIF.h"
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+
+class InternalErrorReporter: public SystemObject,
+		public ExecutableObjectIF,
+		public InternalErrorReporterIF {
+public:
+	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
+			uint32_t tmPoolId, uint32_t storePoolId);
+	virtual ~InternalErrorReporter();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual void queueMessageNotSent();
+
+	virtual void lostTm();
+
+	virtual void storeFull();
+protected:
+	MutexIF* mutex;
+
+	uint32_t queuePoolId;
+	uint32_t tmPoolId;
+	uint32_t storePoolId;
+
+	uint32_t queueHits;
+	uint32_t tmHits;
+	uint32_t storeHits;
+
+	uint32_t getAndResetQueueHits();
+	uint32_t getQueueHits();
+	void incrementQueueHits();
+
+	uint32_t getAndResetTmHits();
+	uint32_t getTmHits();
+	void incrementTmHits();
+
+	uint32_t getAndResetStoreHits();
+	uint32_t getStoreHits();
+	void incrementStoreHits();
+
+};
+
+#endif /* INTERNALERRORREPORTER_H_ */
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index cc1185c7..6934e6ce 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,111 +1,111 @@
-#include <framework/ipc/CommandMessage.h>
-#include <framework/ipc/CommandMessageCleaner.h>
-#include <cstring>
-
-CommandMessage::CommandMessage() {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(CMD_NONE);
-}
-
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-        uint32_t parameter2) {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(command);
-    setParameter(parameter1);
-    setParameter2(parameter2);
-}
-
-Command_t CommandMessage::getCommand() const {
-    Command_t command;
-    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
-    return command;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessage::getMessageType() const {
-    // first byte of command ID.
-    return getCommand() >> 8 & 0xff;
-}
-
-uint32_t CommandMessage::getParameter() const {
-    uint32_t parameter1;
-    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
-    return parameter1;
-}
-
-void CommandMessage::setParameter(uint32_t parameter1) {
-    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
-}
-
-uint32_t CommandMessage::getParameter2() const {
-    uint32_t parameter2;
-    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
-            sizeof(parameter2));
-    return parameter2;
-}
-
-void CommandMessage::setParameter2(uint32_t parameter2) {
-    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
-            sizeof(parameter2));
-}
-
-uint32_t CommandMessage::getParameter3() const {
-    uint32_t parameter3;
-    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
-            sizeof(parameter3));
-    return parameter3;
-}
-
-void CommandMessage::setParameter3(uint32_t parameter3) {
-    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
-            sizeof(parameter3));
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-    return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::clearCommandMessage() {
-    clear();
-}
-
-void CommandMessage::clear() {
-    CommandMessageCleaner::clearCommandMessage(this);
-}
-
-bool CommandMessage::isClearedCommandMessage() {
-    return getCommand() == CMD_NONE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-    Command_t initialCommand = getCommand();
-    this->clear();
-    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-        Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-    setParameter(reason);
-    setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getReplyRejectedReason(
-        Command_t *initialCommand) const {
-    ReturnValue_t reason = getParameter();
-    if(initialCommand != nullptr) {
-        *initialCommand = getParameter2();
-    }
-    return reason;
-}
-
-uint8_t* CommandMessage::getData() {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
-
-const uint8_t* CommandMessage::getData() const {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
+#include "../ipc/CommandMessage.h"
+#include "../ipc/CommandMessageCleaner.h"
+#include <cstring>
+
+CommandMessage::CommandMessage() {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
+}
+
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
+}
+
+Command_t CommandMessage::getCommand() const {
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
+}
+
+uint32_t CommandMessage::getParameter() const {
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
+}
+
+void CommandMessage::setParameter(uint32_t parameter1) {
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
+}
+
+uint32_t CommandMessage::getParameter2() const {
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
+}
+
+void CommandMessage::setParameter2(uint32_t parameter2) {
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
+}
+
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
+size_t CommandMessage::getMinimumMessageSize() const {
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+    return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+        Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+    setParameter(reason);
+    setParameter2(initialCommand);
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = getParameter();
+    if(initialCommand != nullptr) {
+        *initialCommand = getParameter2();
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index d843e4c5..73b73dc9 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,129 +1,129 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
-
-#include <framework/ipc/CommandMessageIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/FwMessageTypes.h>
-
-/**
- * @brief 	Default command message used to pass command messages between tasks.
- * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
- * @details
- * It operates on an external memory which is contained inside a
- * class implementing MessageQueueMessageIF by taking its address.
- * This allows for a more flexible designs of message implementations.
- * The pointer can be passed to different message implementations without
- * the need of unnecessary copying.
- *
- * The command message is based of the generic MessageQueueMessage which
- * currently has an internal message size of 28 bytes.
- * @author	Bastian Baetz
- */
-class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
-public:
-    /**
-     * Default size can accomodate 2 4-byte parameters.
-     */
-    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
-
-	/**
-	 * @brief   Default Constructor, does not initialize anything.
-	 * @details
-	 * This constructor should be used when receiving a Message, as the
-	 * content is filled by the MessageQueue.
-	 */
-	CommandMessage();
-	/**
-	 * This constructor creates a new message with all message content
-	 * initialized
-	 *
-	 * @param command	The DeviceHandlerCommand_t that will be sent
-	 * @param parameter1	The first parameter
-	 * @param parameter2	The second parameter
-	 */
-	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
-
-	/**
-	 * @brief 	Default Destructor
-	 */
-	virtual ~CommandMessage() {}
-
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
-    virtual uint8_t* getData() override;
-    virtual const uint8_t* getData() const override;
-
-	/**
-	 * Get the first parameter of the message
-	 * @return the first Parameter of the message
-	 */
-	uint32_t getParameter() const;
-	/**
-	 * Set the first parameter of the message
-	 * @param the first parameter of the message
-	 */
-	void setParameter(uint32_t parameter1);
-	uint32_t getParameter2() const;
-	void setParameter2(uint32_t parameter2);
-	uint32_t getParameter3() const;
-	void setParameter3(uint32_t parameter3);
-
-	/**
-	 * check if a message was cleared
-	 *
-	 * @return if the command is CMD_NONE
-	 */
-	bool isClearedCommandMessage();
-
-	/**
-	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
-	 * Is needed quite often, so we better code it once only.
-	 */
-	void setToUnknownCommand() override;
-
-    /**
-     * A command message can be rejected and needs to offer a function
-     * to set a rejected reply
-     * @param reason
-     * @param initialCommand
-     */
-    void setReplyRejected(ReturnValue_t reason,
-            Command_t initialCommand) override;
-    /**
-     * Corrensonding getter function.
-     * @param initialCommand
-     * @return
-     */
-    ReturnValue_t getReplyRejectedReason(
-            Command_t* initialCommand = nullptr) const override;
-
-
-    virtual void clear() override;
-    void clearCommandMessage();
-
-    /**
-     * Extract message ID, which is the first byte of the command ID for the
-     * default implementation.
-     * @return
-     */
-    virtual uint8_t getMessageType() const override;
-
-    /** MessageQueueMessageIF functions used for minimum size check. */
-    size_t getMinimumMessageSize() const override;
-};
-
-#endif /* COMMANDMESSAGE_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
+
+#include "../ipc/CommandMessageIF.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/FwMessageTypes.h"
+
+/**
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * class implementing MessageQueueMessageIF by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
+ * @author	Bastian Baetz
+ */
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
+public:
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+
+	/**
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
+	 */
+	CommandMessage();
+	/**
+	 * This constructor creates a new message with all message content
+	 * initialized
+	 *
+	 * @param command	The DeviceHandlerCommand_t that will be sent
+	 * @param parameter1	The first parameter
+	 * @param parameter2	The second parameter
+	 */
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
+
+	/**
+	 * @brief 	Default Destructor
+	 */
+	virtual ~CommandMessage() {}
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
+
+	/**
+	 * Get the first parameter of the message
+	 * @return the first Parameter of the message
+	 */
+	uint32_t getParameter() const;
+	/**
+	 * Set the first parameter of the message
+	 * @param the first parameter of the message
+	 */
+	void setParameter(uint32_t parameter1);
+	uint32_t getParameter2() const;
+	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
+
+	/**
+	 * check if a message was cleared
+	 *
+	 * @return if the command is CMD_NONE
+	 */
+	bool isClearedCommandMessage();
+
+	/**
+	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
+	 * Is needed quite often, so we better code it once only.
+	 */
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+
+    virtual void clear() override;
+    void clearCommandMessage();
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
+};
+
+#endif /* COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 23e6e168..a4dec78d 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,45 +1,45 @@
-#include <framework/ipc/CommandMessageCleaner.h>
-
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/health/HealthMessage.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-#include <framework/parameters/ParameterMessage.h>
-
-void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
-	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(message);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(message);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(message);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(message);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(message);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(message);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(message);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(message);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(message);
-		break;
-	default:
-		messagetypes::clearMissionMessage(message);
-		break;
-	}
-}
+#include "../ipc/CommandMessageCleaner.h"
+
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../health/HealthMessage.h"
+#include "../memory/MemoryMessage.h"
+#include "../modes/ModeMessage.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../subsystem/modes/ModeSequenceMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
+#include "../parameters/ParameterMessage.h"
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(message);
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(message);
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(message);
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(message);
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(message);
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(message);
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(message);
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(message);
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(message);
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index 48aaa478..f17bf282 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include <framework/ipc/CommandMessage.h>
-
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-class CommandMessageCleaner {
-public:
-	static void clearCommandMessage(CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include "../ipc/CommandMessage.h"
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessage* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 2cb6324e..e5f962ae 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/ipc/FwMessageTypes.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
-
-class CommandMessageIF {
-public:
-    /**
-     * Header consists of sender ID and command ID.
-     */
-	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-			sizeof(Command_t);
-	/**
-	 * This minimum size is derived from the interface requirement to be able
-     * to set a rejected reply, which contains a returnvalue and the initial
-     * command.
-	 */
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-	        sizeof(Command_t);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, shall be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
-
-	virtual ~CommandMessageIF() {};
-
-	/**
-	 * A command message shall have a uint16_t command ID field.
-	 * @return
-	 */
-	virtual Command_t getCommand() const = 0;
-	/**
-	 * A command message shall have a uint8_t message type ID field.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const = 0;
-
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	virtual void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) = 0;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	virtual ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const  = 0;
-
-	virtual void setToUnknownCommand() = 0;
-
-	virtual void clear() = 0;
-
-};
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/FwMessageTypes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF {
+public:
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
+			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
+
+};
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index c0575442..6ae852ea 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,142 +1,142 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-
-// COULDDO: We could support blocking calls
-// semaphores are being implemented, which makes this idea even more iteresting.
-
-
-/**
- * @defgroup message_queue Message Queue
- * @brief Message Queue related software components
- */
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class MessageQueueIF {
-public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	//! No new messages on the queue
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	//! No space left for more messages
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	//! Returned if a reply method was called without partner
-	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
-	//! Returned if the target destination is invalid.
-	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
-
-	virtual ~MessageQueueIF() {}
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return RETURN_OK if ok
-	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
-	 */
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) = 0;
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details
-	 * If data is available it is stored in the passed message pointer.
-	 * The message's original content is overwritten and the sendFrom
-	 * information is stored in theblastPartner attribute. Else, the lastPartner
-	 * information remains untouched, the message's content is cleared and the
-	 * function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::EMPTY if queue is empty
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	virtual ReturnValue_t flush(uint32_t* count) = 0;
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	virtual MessageQueueId_t getLastPartner() const = 0;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	virtual MessageQueueId_t getId() const = 0;
-
-	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * @details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send the message to.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
-	 * @details	In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			Implementation class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	virtual MessageQueueId_t getDefaultDestination() const = 0;
-
-	virtual bool isDefaultDestinationSet() const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+
+// COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
+
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+class MessageQueueIF {
+public:
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
+	//! No new messages on the queue
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
+	//! No space left for more messages
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	//! Returned if a reply method was called without partner
+	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
+
+	virtual ~MessageQueueIF() {}
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return RETURN_OK if ok
+	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 */
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) = 0;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in theblastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	virtual ReturnValue_t flush(uint32_t* count) = 0;
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	virtual MessageQueueId_t getLastPartner() const = 0;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	virtual MessageQueueId_t getId() const = 0;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * @details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send the message to.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
+	 * @details	In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			Implementation class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	virtual MessageQueueId_t getDefaultDestination() const = 0;
+
+	virtual bool isDefaultDestinationSet() const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 0f4d861b..d0032129 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,84 +1,84 @@
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
-#include <cstring>
-
-MessageQueueMessage::MessageQueueMessage() :
-		messageSize(getMinimumMessageSize()) {
-	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-}
-
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-		this->messageSize = this->HEADER_SIZE + size;
-	}
-	else {
-		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
-				"allowed size! Setting content to 0" << std::endl;
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
-MessageQueueMessage::~MessageQueueMessage() {
-}
-
-const uint8_t* MessageQueueMessage::getBuffer() const {
-	return this->internalBuffer;
-}
-
-uint8_t* MessageQueueMessage::getBuffer() {
-	return this->internalBuffer;
-}
-
-const uint8_t* MessageQueueMessage::getData() const {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-uint8_t* MessageQueueMessage::getData() {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-MessageQueueId_t MessageQueueMessage::getSender() const {
-	MessageQueueId_t temp_id;
-	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
-	return temp_id;
-}
-
-void MessageQueueMessage::setSender(MessageQueueId_t setId) {
-	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
-}
-
-void MessageQueueMessage::print(bool printWholeMessage) {
-	sif::debug << "MessageQueueMessage content: " << std::endl;
-	if(printWholeMessage) {
-	    arrayprinter::print(getData(), getMaximumMessageSize());
-	}
-	else {
-	    arrayprinter::print(getData(), getMessageSize());
-	}
-
-}
-
-void MessageQueueMessage::clear() {
-	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
-}
-
-size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
-
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-    return this->MIN_MESSAGE_SIZE;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
-    return this->MAX_MESSAGE_SIZE;
-}
-
+#include "../ipc/MessageQueueMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+MessageQueueMessage::MessageQueueMessage() :
+		messageSize(getMinimumMessageSize()) {
+	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+}
+
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
+MessageQueueMessage::~MessageQueueMessage() {
+}
+
+const uint8_t* MessageQueueMessage::getBuffer() const {
+	return this->internalBuffer;
+}
+
+uint8_t* MessageQueueMessage::getBuffer() {
+	return this->internalBuffer;
+}
+
+const uint8_t* MessageQueueMessage::getData() const {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+uint8_t* MessageQueueMessage::getData() {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+MessageQueueId_t MessageQueueMessage::getSender() const {
+	MessageQueueId_t temp_id;
+	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
+	return temp_id;
+}
+
+void MessageQueueMessage::setSender(MessageQueueId_t setId) {
+	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
+}
+
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
+	}
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
+}
+
+void MessageQueueMessage::clear() {
+	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
+}
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
+}
+
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index 3d5d4283..cf06fde6 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,150 +1,150 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <cstddef>
-
-/**
- *	@brief		This class is the representation and data organizer
- *				for interprocess messages.
- *	@details
- *	To facilitate and standardize interprocess communication, this class was
- *	created to handle a lightweight "interprocess message protocol".
- *
- *	It adds a header with the sender's queue id to every sent message and
- *	defines the maximum total message size. Specialized messages, such as
- *	device commanding messages, can be created by inheriting from this class
- *	and filling the buffer provided by getData with additional content.
- *
- *	If larger amounts of data must be sent between processes, the data shall
- *	be stored in the IPC Store object and only the storage id is passed in a
- *	queue message.The class is used both to generate and send messages and to
- *	receive messages from other tasks.
- *	@ingroup message_queue
- */
-class MessageQueueMessage: public MessageQueueMessageIF {
-public:
-	/**
-	 * @brief	The class is initialized empty with this constructor.
-	 * @details
-	 * The messageSize attribute is set to the header's size and the whole
-	 * content is set to zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * @brief	With this constructor the class is initialized with
-	 * 			the given content.
-	 * @details
-	 * If the passed message size fits into the buffer, the passed data is
-	 * copied to the internal buffer and the messageSize information is set.
-	 * Otherwise, messageSize is set to the header's size and the whole
-	 * content is set to zero.
-	 * @param data	The data to be put in the message.
-	 * @param size	Size of the data to be copied. Must be smaller than
-	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, size_t size);
-
-	/**
-	 * @brief	As no memory is allocated in this class,
-	 * 		    the destructor is empty.
-	 */
-	virtual ~MessageQueueMessage();
-
-	/**
-	 * @brief	The size information of each message is stored in
-	 *  			this attribute.
-	 * @details
-	 * It is public to simplify usage and to allow for passing the size
-	 * address as a pointer. Care must be taken when inheriting from this class,
-	 * as every child class is responsible for managing the size information by
-	 * itself. When using the class to receive a message, the size information
-	 * is updated automatically.
-	 *
-	 * Please note that the minimum size is limited by the size of the header
-	 * while the maximum size is limited by the maximum allowed message size.
-	 */
-	size_t messageSize;
-	/**
-	 * @brief	This constant defines the maximum size of the data content,
-	 * 			excluding the header.
-	 * @details
-	 * It may be changed if necessary, but in general should be kept
-	 * as small as possible.
-	 */
-	static const size_t MAX_DATA_SIZE = 24;
-
-	/**
-	 * @brief	This constant defines the maximum total size in bytes
-	 * 			of a sent message.
-	 * @details
-	 * It is the sum of the maximum data and the header size. Be aware that
-	 * this constant is used to define the buffer sizes for every message
-	 * queue in the system. So, a change here may have significant impact on
-	 * the required resources.
-	 */
-	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
-	/**
-	 * @brief Defines the minimum size of a message where only the
-	 * 		  header is included
-	 */
-	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
-private:
-	/**
-	 * @brief	This is the internal buffer that contains the
-	 * 			actual message data.
-	 */
-	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
-public:
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	const uint8_t* getBuffer() const override;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer() override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	const uint8_t* getData() const override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	uint8_t* getData() override;
-	/**
-	 * @brief	This method is used to extract the sender's message
-	 * 			queue id information from a received message.
-	 */
-	MessageQueueId_t getSender() const override;
-	/**
-	 * @brief	With this method, the whole content
-	 * 			and the message size is set to zero.
-	 */
-	void clear() override;
-
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to ing the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId) override;
-
-	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	/**
-	 * @brief	This is a debug method that prints the content.
-	 */
-	void print(bool printWholeMessage);
-};
-
-#endif /* MESSAGEQUEUEMESSAGE_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include <cstddef>
+
+/**
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
+ */
+class MessageQueueMessage: public MessageQueueMessageIF {
+public:
+	/**
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+
+	/**
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
+	 */
+	static const size_t MAX_DATA_SIZE = 24;
+
+	/**
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
+	 */
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+private:
+	/**
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
+	 */
+	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
+public:
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	const uint8_t* getBuffer() const override;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	uint8_t* getBuffer() override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	const uint8_t* getData() const override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	uint8_t* getData() override;
+	/**
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
+	 */
+	MessageQueueId_t getSender() const override;
+	/**
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
+	 */
+	void clear() override;
+
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content.
+	 */
+	void print(bool printWholeMessage);
+};
+
+#endif /* MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index e4b9670e..80623157 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,25 +1,25 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-class MessageQueueSenderIF {
-public:
-
-	virtual ~MessageQueueSenderIF() {}
-
-	/**
-	 * Allows sending messages without actually "owning" a message queue.
-	 * Not sure whether this is actually a good idea.
-	 */
-	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault = false);
-private:
-	MessageQueueSenderIF() {}
-};
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+class MessageQueueSenderIF {
+public:
+
+	virtual ~MessageQueueSenderIF() {}
+
+	/**
+	 * Allows sending messages without actually "owning" a message queue.
+	 * Not sure whether this is actually a good idea.
+	 */
+	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			bool ignoreFault = false);
+private:
+	MessageQueueSenderIF() {}
+};
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index b2e58b6e..91e90907 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
-
-#include <framework/ipc/MutexIF.h>
-/**
- * Creates Mutex.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class MutexFactory {
-public:
-	virtual ~MutexFactory();
-	/**
-	 * Returns the single instance of MutexFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static MutexFactory* instance();
-
-	MutexIF* createMutex();
-
-	void deleteMutex(MutexIF* mutex);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	MutexFactory();
-	static MutexFactory* factoryInstance;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
+#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+
+#include "../ipc/MutexIF.h"
+/**
+ * Creates Mutex.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class MutexFactory {
+public:
+	virtual ~MutexFactory();
+	/**
+	 * Returns the single instance of MutexFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static MutexFactory* instance();
+
+	MutexIF* createMutex();
+
+	void deleteMutex(MutexIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	MutexFactory();
+	static MutexFactory* factoryInstance;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 52ce51e3..31d8d9ec 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,30 +1,30 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
-
-#include <framework/ipc/MutexFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-class MutexHelper {
-public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
-					status << std::endl;
-		}
-	}
-
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
-private:
-	MutexIF* internalMutex;
-};
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
+#define FRAMEWORK_IPC_MUTEXHELPER_H_
+
+#include "../ipc/MutexFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+class MutexHelper {
+public:
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
+			internalMutex(mutex) {
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
+		        timeoutMs);
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
+					status << std::endl;
+		}
+	}
+
+	~MutexHelper() {
+		internalMutex->unlockMutex();
+	}
+private:
+	MutexIF* internalMutex;
+};
+#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index b0096a34..7bca4c9d 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -1,89 +1,89 @@
-#ifndef FRAMEWORK_IPC_MUTEXIF_H_
-#define FRAMEWORK_IPC_MUTEXIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
- * @ingroup osal
- * @ingroup interface
- */
-class MutexIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-    /**
-     * Lock the mutex. The timeout value will only be used for
-     * TimeoutType::WAITING
-     * @param timeoutType
-     * @param timeoutMs
-     * @return
-     */
-    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-    virtual ReturnValue_t unlockMutex() = 0;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
-	/**
-	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
-	 */
-	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
-	/**
-	 * Insufficient memory to create or init Mutex
-	 */
-	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
-	/**
-	 * Caller does not have enough or right privilege
-	 */
-	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
-	/**
-	 * Wrong Attribute Setting
-	 */
-	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
-	/**
-	 * The mutex is already locked
-	 */
-	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
-	/**
-	 * Mutex object not found
-	 */
-	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
-	/**
-	 * Mutex could not be locked because max amount of recursive locks
-	 */
-	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
-	/**
-	 * The current thread already owns this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
-	/**
-	 * Current thread does not own this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
-	/**
-	 * The Mutex could not be blocked before timeout
-	 */
-	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
-	/**
-	 * Invalid Mutex ID
-	 */
-	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
-	/**
-	 * Mutex destroyed while waiting
-	 */
-	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
-
-    virtual ~MutexIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXIF_H_
+#define FRAMEWORK_IPC_MUTEXIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
+class MutexIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
+	/**
+	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
+	 */
+	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
+	/**
+	 * Insufficient memory to create or init Mutex
+	 */
+	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
+	/**
+	 * Caller does not have enough or right privilege
+	 */
+	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
+	/**
+	 * Wrong Attribute Setting
+	 */
+	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
+	/**
+	 * The mutex is already locked
+	 */
+	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
+	/**
+	 * Mutex object not found
+	 */
+	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
+	/**
+	 * Mutex could not be locked because max amount of recursive locks
+	 */
+	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
+	/**
+	 * The current thread already owns this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
+	/**
+	 * Current thread does not own this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
+	/**
+	 * The Mutex could not be blocked before timeout
+	 */
+	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
+	/**
+	 * Invalid Mutex ID
+	 */
+	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
+	/**
+	 * Mutex destroyed while waiting
+	 */
+	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
+
+    virtual ~MutexIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 09259ae3..8141a3cf 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <cstdint>
-/**
- * Creates message queues.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class QueueFactory {
-public:
-	virtual ~QueueFactory();
-	/**
-	 * Returns the single instance of QueueFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static QueueFactory* instance();
-
-	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	void deleteMessageQueue(MessageQueueIF* queue);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	QueueFactory();
-	static QueueFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
+#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include <cstdint>
+/**
+ * Creates message queues.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class QueueFactory {
+public:
+	virtual ~QueueFactory();
+	/**
+	 * Returns the single instance of QueueFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static QueueFactory* instance();
+
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	void deleteMessageQueue(MessageQueueIF* queue);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	QueueFactory();
+	static QueueFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 2b37f1af..044f2236 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,21 +1,21 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include <framework/memory/HasMemoryIF.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class AcceptsMemoryMessagesIF : public HasMemoryIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+/**
+ * @file	AcceptsMemoryMessagesIF.h
+ * @brief	This file defines the AcceptsMemoryMessagesIF class.
+ * @date	11.07.2013
+ * @author	baetz
+ */
+
+#ifndef ACCEPTSMEMORYMESSAGESIF_H_
+#define ACCEPTSMEMORYMESSAGESIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../memory/MemoryMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsMemoryMessagesIF : public HasMemoryIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index efbc8009..a1c3955f 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,28 +1,28 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include "FileSystemMessage.h"
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
-	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
-}
-
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 9f9c1496..9ef9a2f4 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,30 +1,30 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-
-class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
-
-};
-
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 8b66f88b..49a2ae54 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,36 +1,36 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class HasFileSystemIF {
-public:
-
-	virtual ~HasFileSystemIF() {}
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Function to write to a file
-	 * @param dirname Directory of the file
-	 * @param filename The filename of the file
-	 * @param data The data to write to the file
-	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
-	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
-};
-
-
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
diff --git a/memory/HasMemoryIF.h b/memory/HasMemoryIF.h
index cd6e6665..788a86b6 100644
--- a/memory/HasMemoryIF.h
+++ b/memory/HasMemoryIF.h
@@ -1,47 +1,47 @@
-#ifndef HASMEMORYIF_H_
-#define HASMEMORYIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class HasMemoryIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
-	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
-	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
-//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
-	virtual ~HasMemoryIF() {}
-	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
-	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
-	/**
-	 * Sets the address of the memory, if possible.
-	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
-	 */
-	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
-	static bool memAccessWasSuccessful(ReturnValue_t result) {
-		switch (result) {
-		case DO_IT_MYSELF:
-		case POINTS_TO_MEMORY:
-		case POINTS_TO_VARIABLE:
-		case HasReturnvaluesIF::RETURN_OK:
-		case ACTIVITY_COMPLETED:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-
-#endif /* HASMEMORYIF_H_ */
+#ifndef HASMEMORYIF_H_
+#define HASMEMORYIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasMemoryIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
+	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
+	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
+//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
+	virtual ~HasMemoryIF() {}
+	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
+	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
+	/**
+	 * Sets the address of the memory, if possible.
+	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
+	 */
+	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
+	static bool memAccessWasSuccessful(ReturnValue_t result) {
+		switch (result) {
+		case DO_IT_MYSELF:
+		case POINTS_TO_MEMORY:
+		case POINTS_TO_VARIABLE:
+		case HasReturnvaluesIF::RETURN_OK:
+		case ACTIVITY_COMPLETED:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+
+#endif /* HASMEMORYIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index b07f450c..c74b7d9f 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,193 +1,193 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/memory/MemoryHelper.h>
-#include <framework/memory/MemoryMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
-		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
-}
-
-ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
-	lastSender = message->getSender();
-	lastCommand = message->getCommand();
-	if (busy) {
-		sif::debug << "MemHelper: Busy!" << std::endl;
-	}
-	switch (lastCommand) {
-	case MemoryMessage::CMD_MEMORY_DUMP:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_LOAD:
-		handleMemoryLoad(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_CHECK:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	default:
-		lastCommand = CommandMessage::CMD_NONE;
-		return UNKNOWN_CMD;
-	}
-}
-
-void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
-	busy = false;
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasMemoryIF::POINTS_TO_MEMORY:
-		memcpy(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-	case RETURN_OK:
-		break;
-	default:
-		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-		return;
-	}
-	//Only reached on success
-	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
-	queueToUse->sendMessage(lastSender, &reply);
-	ipcStore->deleteData(ipcAddress);
-}
-
-void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
-	busy = false;
-	CommandMessage reply;
-	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasReturnvaluesIF::RETURN_OK:
-	case HasMemoryIF::POINTS_TO_MEMORY:
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		//"data" must be valid pointer!
-		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
-		} else {
-			memcpy(reservedSpaceInIPC, dataToCopy, size);
-		}
-		/* NO BREAK falls through*/
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-		switch (lastCommand) {
-		case MemoryMessage::CMD_MEMORY_DUMP: {
-			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
-			break;
-		}
-		case MemoryMessage::CMD_MEMORY_CHECK: {
-			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
-			//Delete data immediately, was temporary.
-			ipcStore->deleteData(ipcAddress);
-			MemoryMessage::setMemoryCheckReply(&reply, crc);
-			break;
-		}
-		default:
-			//This should never happen!
-			//Is it ok to send message? Otherwise: return;
-			ipcStore->deleteData(ipcAddress);
-			reply.setParameter(STATE_MISMATCH);
-			break;
-		}
-		break;
-	case HasMemoryIF::DUMP_NOT_SUPPORTED:
-		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
-			MemoryMessage::setMemoryCheckReply(&reply, 0);
-			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
-		}
-		ipcStore->deleteData(ipcAddress);
-		break;
-	default:
-		//Reply is already set to REJECTED.
-		ipcStore->deleteData(ipcAddress);
-		break;
-	}
-	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clear();
-	}
-}
-
-void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
-	if (totalSize % datatypeSize != 0){
-		return;
-	}
-
-	while (totalSize > 0){
-		EndianConverter::convertBigEndian(out,in,datatypeSize);
-		out += datatypeSize;
-		in += datatypeSize;
-		totalSize -= datatypeSize;
-	}
-}
-
-MemoryHelper::~MemoryHelper() {
-	//Nothing to destroy
-}
-
-void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	ipcAddress = MemoryMessage::getStoreID(message);
-	const uint8_t* p_data = NULL;
-	uint8_t* dataPointer = NULL;
-	size_t size = 0;
-	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
-				&dataPointer);
-		completeLoad(returnCode, p_data, size, dataPointer);
-	} else {
-		//At least inform sender.
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	uint32_t size = MemoryMessage::getLength(message);
-	uint8_t* dataPointer = NULL;
-	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
-			&reservedSpaceInIPC);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
-				reservedSpaceInIPC);
-		completeDump(returnCode, dataPointer, size);
-	} else {
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_ == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	this->queueToUse = queueToUse_;
-	return initialize();
-}
-
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != nullptr) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
+#include "../globalfunctions/CRC.h"
+#include "../memory/MemoryHelper.h"
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+}
+
+ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
+	lastSender = message->getSender();
+	lastCommand = message->getCommand();
+	if (busy) {
+		sif::debug << "MemHelper: Busy!" << std::endl;
+	}
+	switch (lastCommand) {
+	case MemoryMessage::CMD_MEMORY_DUMP:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_LOAD:
+		handleMemoryLoad(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_CHECK:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	default:
+		lastCommand = CommandMessage::CMD_NONE;
+		return UNKNOWN_CMD;
+	}
+}
+
+void MemoryHelper::completeLoad(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+	busy = false;
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasMemoryIF::POINTS_TO_MEMORY:
+		memcpy(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+	case RETURN_OK:
+		break;
+	default:
+		ipcStore->deleteData(ipcAddress);
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+		return;
+	}
+	//Only reached on success
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	queueToUse->sendMessage(lastSender, &reply);
+	ipcStore->deleteData(ipcAddress);
+}
+
+void MemoryHelper::completeDump(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size) {
+	busy = false;
+	CommandMessage reply;
+	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasReturnvaluesIF::RETURN_OK:
+	case HasMemoryIF::POINTS_TO_MEMORY:
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		//"data" must be valid pointer!
+		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
+		} else {
+			memcpy(reservedSpaceInIPC, dataToCopy, size);
+		}
+		/* NO BREAK falls through*/
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+		switch (lastCommand) {
+		case MemoryMessage::CMD_MEMORY_DUMP: {
+			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
+			break;
+		}
+		case MemoryMessage::CMD_MEMORY_CHECK: {
+			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
+			//Delete data immediately, was temporary.
+			ipcStore->deleteData(ipcAddress);
+			MemoryMessage::setMemoryCheckReply(&reply, crc);
+			break;
+		}
+		default:
+			//This should never happen!
+			//Is it ok to send message? Otherwise: return;
+			ipcStore->deleteData(ipcAddress);
+			reply.setParameter(STATE_MISMATCH);
+			break;
+		}
+		break;
+	case HasMemoryIF::DUMP_NOT_SUPPORTED:
+		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
+			MemoryMessage::setMemoryCheckReply(&reply, 0);
+			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
+		}
+		ipcStore->deleteData(ipcAddress);
+		break;
+	default:
+		//Reply is already set to REJECTED.
+		ipcStore->deleteData(ipcAddress);
+		break;
+	}
+	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
+		reply.clear();
+	}
+}
+
+void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
+		uint32_t totalSize, uint8_t datatypeSize) {
+	if (totalSize % datatypeSize != 0){
+		return;
+	}
+
+	while (totalSize > 0){
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
+		out += datatypeSize;
+		in += datatypeSize;
+		totalSize -= datatypeSize;
+	}
+}
+
+MemoryHelper::~MemoryHelper() {
+	//Nothing to destroy
+}
+
+void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	ipcAddress = MemoryMessage::getStoreID(message);
+	const uint8_t* p_data = NULL;
+	uint8_t* dataPointer = NULL;
+	size_t size = 0;
+	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
+				&dataPointer);
+		completeLoad(returnCode, p_data, size, dataPointer);
+	} else {
+		//At least inform sender.
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	uint32_t size = MemoryMessage::getLength(message);
+	uint8_t* dataPointer = NULL;
+	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
+			&reservedSpaceInIPC);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
+				reservedSpaceInIPC);
+		completeDump(returnCode, dataPointer, size);
+	} else {
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	this->queueToUse = queueToUse_;
+	return initialize();
+}
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index da6b9bdb..90dbafb4 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#include <framework/ipc/CommandMessage.h>
-#include <framework/memory/AcceptsMemoryMessagesIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class MemoryHelper : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
-	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
-private:
-	HasMemoryIF* workOnThis;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore = nullptr;
-	store_address_t ipcAddress;
-	Command_t lastCommand;
-	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
-	uint8_t* reservedSpaceInIPC = nullptr;
-	bool busy;
-	void handleMemoryLoad(CommandMessage* message);
-	void handleMemoryCheckOrDump(CommandMessage* message);
-	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
-};
-#endif /* MEMORYHELPER_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#include "../ipc/CommandMessage.h"
+#include "../memory/AcceptsMemoryMessagesIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class MemoryHelper : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
+	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+private:
+	HasMemoryIF* workOnThis;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore = nullptr;
+	store_address_t ipcAddress;
+	Command_t lastCommand;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
+	bool busy;
+	void handleMemoryLoad(CommandMessage* message);
+	void handleMemoryCheckOrDump(CommandMessage* message);
+	ReturnValue_t initialize();
+public:
+	ReturnValue_t handleMemoryCommand(CommandMessage* message);
+	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
+	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
+	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
+	~MemoryHelper();
+};
+#endif /* MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index f978ed4e..16a60502 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,112 +1,112 @@
-#include <framework/memory/MemoryMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-MemoryMessage::MemoryMessage() {
-}
-
-uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-uint32_t MemoryMessage::getLength(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_DUMP);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
-	message->setCommand(REPLY_MEMORY_DUMP);
-	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
-		uint32_t address, store_address_t storageID) {
-	message->setCommand(CMD_MEMORY_LOAD);
-	message->setParameter( address );
-	message->setParameter2( storageID.raw );
-}
-
-ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void MemoryMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_MEMORY_LOAD:
-	case REPLY_MEMORY_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreID(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case CMD_MEMORY_DUMP:
-	case CMD_MEMORY_CHECK:
-	case REPLY_MEMORY_CHECK:
-	case END_OF_MEMORY_COPY:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-		}
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_CHECK);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
-		uint16_t crc) {
-	message->setCommand(REPLY_MEMORY_CHECK);
-	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
-	message->setParameter(returnValue<<16);
-};
-
-uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
-	return (uint16_t)(message->getParameter());
-}
-
-ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
-	return (message->getParameter()>>16);
-}
-
-Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
-		ReturnValue_t errorCode, Command_t initialCommand) {
-	message->setCommand(REPLY_MEMORY_FAILED);
-	message->setParameter(errorCode);
-	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
-	message->setCommand(END_OF_MEMORY_COPY);
-	message->setParameter(0);
-	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+MemoryMessage::MemoryMessage() {
+}
+
+uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+uint32_t MemoryMessage::getLength(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_DUMP);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+	message->setCommand(REPLY_MEMORY_DUMP);
+	message->setParameter2( storageID.raw );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+		uint32_t address, store_address_t storageID) {
+	message->setCommand(CMD_MEMORY_LOAD);
+	message->setParameter( address );
+	message->setParameter2( storageID.raw );
+}
+
+ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void MemoryMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_MEMORY_LOAD:
+	case REPLY_MEMORY_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreID(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case CMD_MEMORY_DUMP:
+	case CMD_MEMORY_CHECK:
+	case REPLY_MEMORY_CHECK:
+	case END_OF_MEMORY_COPY:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+		}
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_CHECK);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+		uint16_t crc) {
+	message->setCommand(REPLY_MEMORY_CHECK);
+	message->setParameter( crc );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+	message->setParameter(returnValue<<16);
+};
+
+uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
+	return (uint16_t)(message->getParameter());
+}
+
+ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
+	return (message->getParameter()>>16);
+}
+
+Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+		ReturnValue_t errorCode, Command_t initialCommand) {
+	message->setCommand(REPLY_MEMORY_FAILED);
+	message->setParameter(errorCode);
+	message->setParameter2(initialCommand);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+	message->setCommand(END_OF_MEMORY_COPY);
+	message->setParameter(0);
+	message->setParameter2(0);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index e2c87ca3..af936c1f 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,39 +1,39 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-
-class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
-	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );
-	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
-	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
-	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
-	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
-
-	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
-	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MEMORYMESSAGE_H_ */
+#ifndef MEMORYMESSAGE_H_
+#define MEMORYMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+
+class MemoryMessage {
+private:
+	MemoryMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
+	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );
+	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
+	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
+	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
+	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
+
+	static uint32_t getAddress( const CommandMessage* message );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static uint32_t getLength( const CommandMessage* message );
+	static ReturnValue_t getErrorCode( const CommandMessage* message );
+	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
+	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
+	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
+	static uint16_t getCrc( const CommandMessage* message );
+	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+	static Command_t getInitialCommand( const CommandMessage* message );
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MEMORYMESSAGE_H_ */
diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
index d325ba4e..a30165c3 100644
--- a/memory/MemoryProxyIF.h
+++ b/memory/MemoryProxyIF.h
@@ -1,22 +1,22 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include <framework/memory/AcceptsMemoryMessagesIF.h>
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+
+#include "../memory/AcceptsMemoryMessagesIF.h"
+
+/**
+ * This was a nice idea to transparently forward incoming messages to another object.
+ * But it doesn't work like that.
+ */
+class MemoryProxyIF : public AcceptsMemoryMessagesIF {
+public:
+	virtual MessageQueueId_t getProxyQueue() const = 0;
+	MessageQueueId_t getCommandQueue() const {
+		return getProxyQueue();
+	}
+	virtual ~MemoryProxyIF() {}
+
+};
+
+
+
+#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 263b0a87..eade3613 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-
-
-class HasModesIF {
-	friend class ModeHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
-	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-
-	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
-protected:
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
-};
-
-#endif /* HASMODESIF_H_ */
+/**
+ * @file	HasModesIF.h
+ * @brief	This file defines the HasModesIF class.
+ * @date	20.06.2013
+ * @author	baetz
+ */
+
+#ifndef HASMODESIF_H_
+#define HASMODESIF_H_
+
+#include "../events/Event.h"
+#include "../modes/ModeHelper.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+
+class HasModesIF {
+	friend class ModeHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
+	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
+	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+
+	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
+	virtual ~HasModesIF() {
+	}
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+protected:
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	virtual void startTransition(Mode_t mode, Submode_t submode) {
+	}
+	virtual void setToExternalControl() {
+	}
+	virtual void announceMode(bool recursive) {
+	}
+};
+
+#endif /* HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 030f1db3..d6cbf2c9 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,135 +1,135 @@
-#include <framework/modes/HasModesIF.h>
-#include <framework/modes/ModeHelper.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-ModeHelper::ModeHelper(HasModesIF *owner) :
-		commandedMode(HasModesIF::MODE_OFF),
-		commandedSubmode(HasModesIF::SUBMODE_NONE),
-		owner(owner), forced(false) {}
-
-ModeHelper::~ModeHelper() {
-
-}
-
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	CommandMessage reply;
-	Mode_t mode;
-	Submode_t submode;
-	switch (command->getCommand()) {
-	case ModeMessage::CMD_MODE_COMMAND_FORCED:
-		forced = true;
-		/* NO BREAK falls through*/
-	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(command);
-		submode = ModeMessage::getSubmode(command);
-		uint32_t timeout;
-		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        owner->getCommandQueue());
-			break;
-		}
-		//Free to start transition
-		theOneWhoCommandedAMode = command->getSender();
-		commandedMode = mode;
-		commandedSubmode = submode;
-
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-				&& (theOneWhoCommandedAMode != parentQueueId)) {
-			owner->setToExternalControl();
-		}
-
-		countdown.setTimeout(timeout);
-		owner->startTransition(mode, submode);
-	}
-		break;
-	case ModeMessage::CMD_MODE_READ: {
-		owner->getMode(&mode, &submode);
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		       owner->getCommandQueue());
-	}
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE:
-		owner->announceMode(false);
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-		owner->announceMode(true);
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
-	setParentQueue(parentQueueId);
-	return initialize();
-}
-
-void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
-	forced = false;
-	sendModeReplyMessage(ownerMode, ownerSubmode);
-	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
-}
-
-void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
-	{
-		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
-		{
-			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
-					ownerSubmode);
-		}
-		else
-		{
-			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					ownerMode, ownerSubmode);
-		}
-		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-	{
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
-				ownerMode, ownerSubmode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::startTimer(uint32_t timeoutMs) {
-	countdown.setTimeout(timeoutMs);
-}
-
-void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
-	this->parentQueueId = parentQueueId;
-}
-
-ReturnValue_t ModeHelper::initialize(void) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-bool ModeHelper::isTimedOut() {
-	return countdown.hasTimedOut();
-}
-
-bool ModeHelper::isForced() {
-	return forced;
-}
-
-void ModeHelper::setForced(bool forced) {
-	this->forced = forced;
-}
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ModeHelper::ModeHelper(HasModesIF *owner) :
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
+
+ModeHelper::~ModeHelper() {
+
+}
+
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	CommandMessage reply;
+	Mode_t mode;
+	Submode_t submode;
+	switch (command->getCommand()) {
+	case ModeMessage::CMD_MODE_COMMAND_FORCED:
+		forced = true;
+		/* NO BREAK falls through*/
+	case ModeMessage::CMD_MODE_COMMAND: {
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
+		uint32_t timeout;
+		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			ModeMessage::cantReachMode(&reply, result);
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+			        owner->getCommandQueue());
+			break;
+		}
+		//Free to start transition
+		theOneWhoCommandedAMode = command->getSender();
+		commandedMode = mode;
+		commandedSubmode = submode;
+
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+				&& (theOneWhoCommandedAMode != parentQueueId)) {
+			owner->setToExternalControl();
+		}
+
+		countdown.setTimeout(timeout);
+		owner->startTransition(mode, submode);
+	}
+		break;
+	case ModeMessage::CMD_MODE_READ: {
+		owner->getMode(&mode, &submode);
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
+				submode);
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+		       owner->getCommandQueue());
+	}
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE:
+		owner->announceMode(false);
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+		owner->announceMode(true);
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
+	setParentQueue(parentQueueId);
+	return initialize();
+}
+
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
+	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
+			ModeMessage::setModeMessage(&reply,
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
+			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
+					ownerMode, ownerSubmode);
+		}
+		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != parentQueueId
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::startTimer(uint32_t timeoutMs) {
+	countdown.setTimeout(timeoutMs);
+}
+
+void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
+	this->parentQueueId = parentQueueId;
+}
+
+ReturnValue_t ModeHelper::initialize(void) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+bool ModeHelper::isTimedOut() {
+	return countdown.hasTimedOut();
+}
+
+bool ModeHelper::isForced() {
+	return forced;
+}
+
+void ModeHelper::setForced(bool forced) {
+	this->forced = forced;
+}
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index b7f5868d..1e51bce5 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,53 +1,53 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class HasModesIF;
-
-class ModeHelper {
-public:
-	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
-	Mode_t commandedMode;
-	Submode_t commandedSubmode;
-
-	ModeHelper(HasModesIF *owner);
-	virtual ~ModeHelper();
-
-	ReturnValue_t handleModeCommand(CommandMessage *message);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
-
-	void modeChanged(Mode_t mode, Submode_t submode);
-
-	void startTimer(uint32_t timeoutMs);
-
-	bool isTimedOut();
-
-	bool isForced();
-
-	void setForced(bool forced);
-protected:
-	HasModesIF *owner;
-	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
-
-	Countdown countdown;
-
-	bool forced;
-private:
-	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-};
-
-#endif /* MODEHELPER_H_ */
+#ifndef MODEHELPER_H_
+#define MODEHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class HasModesIF;
+
+class ModeHelper {
+public:
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
+	Mode_t commandedMode;
+	Submode_t commandedSubmode;
+
+	ModeHelper(HasModesIF *owner);
+	virtual ~ModeHelper();
+
+	ReturnValue_t handleModeCommand(CommandMessage *message);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+
+	void modeChanged(Mode_t mode, Submode_t submode);
+
+	void startTimer(uint32_t timeoutMs);
+
+	bool isTimedOut();
+
+	bool isForced();
+
+	void setForced(bool forced);
+protected:
+	HasModesIF *owner;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
+
+	Countdown countdown;
+
+	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+};
+
+#endif /* MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 1d3baad5..de3fc69c 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,31 +1,31 @@
-#include <framework/modes/ModeMessage.h>
-
-Mode_t ModeMessage::getMode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
-	message->setCommand( command );
-	message->setParameter( mode );
-	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void ModeMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
-	message->setCommand(REPLY_CANT_REACH_MODE);
-	message->setParameter(reason);
-	message->setParameter2(0);
-}
+#include "../modes/ModeMessage.h"
+
+Mode_t ModeMessage::getMode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
+		Mode_t mode, Submode_t submode) {
+	message->setCommand( command );
+	message->setParameter( mode );
+	message->setParameter2( submode );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void ModeMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+	message->setCommand(REPLY_CANT_REACH_MODE);
+	message->setParameter(reason);
+	message->setParameter2(0);
+}
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 675c614b..63624b1d 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,40 +1,40 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-
-typedef uint32_t Mode_t;
-typedef uint8_t Submode_t;
-
-class ModeMessage {
-private:
-	ModeMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
-	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
-	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
-	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
-	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
-	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
-
-	static Mode_t getMode(const CommandMessage* message);
-	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
-			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MODEMESSAGE_H_ */
+/**
+ * @file	ModeMessage.h
+ * @brief	This file defines the ModeMessage class.
+ * @date	17.07.2013
+ * @author	baetz
+ */
+
+#ifndef MODEMESSAGE_H_
+#define MODEMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+
+typedef uint32_t Mode_t;
+typedef uint8_t Submode_t;
+
+class ModeMessage {
+private:
+	ModeMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
+	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
+	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
+	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
+	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
+	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
+
+	static Mode_t getMode(const CommandMessage* message);
+	static Submode_t getSubmode(const CommandMessage* message);
+	static ReturnValue_t setModeMessage(CommandMessage* message,
+			Command_t command, Mode_t mode, Submode_t submode);
+	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MODEMESSAGE_H_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 3525ba2c..6b546bd0 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-
-#include <framework/monitoring/MonitorBase.h>
-#include <cmath>
-
-template<typename T>
-class AbsLimitMonitor: public MonitorBase<T> {
-public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
-	}
-	virtual ~AbsLimitMonitor() {
-	}
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = limit;
-		if (aboveIsViolation) {
-			if ((std::abs(sample) > limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		} else {
-			if ((std::abs(sample) < limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->limit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	void setLimit(T value) {
-		limit = value;
-	}
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T limit;
-	const Event violationEvent;
-	const bool aboveIsViolation;
-};
-
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+#include <cmath>
+
+template<typename T>
+class AbsLimitMonitor: public MonitorBase<T> {
+public:
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	}
+	virtual ~AbsLimitMonitor() {
+	}
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = limit;
+		if (aboveIsViolation) {
+			if ((std::abs(sample) > limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		} else {
+			if ((std::abs(sample) < limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->limit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	void setLimit(T value) {
+		limit = value;
+	}
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::OUT_OF_RANGE:
+			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T limit;
+	const Event violationEvent;
+	const bool aboveIsViolation;
+};
+
+#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index 6f1dc1b3..be561efd 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,30 +1,30 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
-
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class HasMonitorsIF {
-public:
-	static const uint8_t MAX_N_PARAMETER = 10;
-//	static const uint8_t MAX_N_LIMIT_ID = 10;
-	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
-			bool forOnePid = false, uint32_t parameterId = 0) = 0;
-	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
-			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
-			const uint8_t* data, const uint32_t size) = 0;
-	virtual void setAllMonitorsToUnchecked() = 0;
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~HasMonitorsIF() {
-	}
-};
-
-#endif /* HASMONITORSIF_H_ */
+/**
+ * @file	HasMonitorsIF.h
+ * @brief	This file defines the HasMonitorsIF class.
+ * @date	28.07.2014
+ * @author	baetz
+ */
+#ifndef HASMONITORSIF_H_
+#define HASMONITORSIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasMonitorsIF {
+public:
+	static const uint8_t MAX_N_PARAMETER = 10;
+//	static const uint8_t MAX_N_LIMIT_ID = 10;
+	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
+			bool forOnePid = false, uint32_t parameterId = 0) = 0;
+	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
+			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
+			const uint8_t* data, const uint32_t size) = 0;
+	virtual void setAllMonitorsToUnchecked() = 0;
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~HasMonitorsIF() {
+	}
+};
+
+#endif /* HASMONITORSIF_H_ */
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index c24629a3..465d72e8 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
-
-#include <framework/monitoring/MonitorBase.h>
-
-/**
- * Variant of a limit checking class.
- * Newer version as compared to LimitCheckMonitor.
- * Functionality is more or less the same, but does not use
- * heavy weight MonitoringIF.
- */
-template<typename T>
-class LimitMonitor: public MonitorBase<T> {
-public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
-	}
-
-	virtual ~LimitMonitor() {}
-
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = 0.0;
-		if (sample > upperLimit) {
-			*crossedLimit = upperLimit;
-			return MonitoringIF::ABOVE_HIGH_LIMIT;
-		} else if (sample < lowerLimit) {
-			*crossedLimit = lowerLimit;
-			return MonitoringIF::BELOW_LOW_LIMIT;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK; //Within limits.
-		}
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->lowerLimit);
-			break;
-		case 11:
-			parameterWrapper->set(this->upperLimit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	T getLowerLimit() const {
-		return lowerLimit;
-	}
-
-	T getUpperLimit() const {
-		return upperLimit;
-	}
-
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
-			break;
-		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T lowerLimit;
-	T upperLimit;
-	const Event belowLowEvent;
-	const Event aboveHighEvent;
-};
-
-#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+
+/**
+ * Variant of a limit checking class.
+ * Newer version as compared to LimitCheckMonitor.
+ * Functionality is more or less the same, but does not use
+ * heavy weight MonitoringIF.
+ */
+template<typename T>
+class LimitMonitor: public MonitorBase<T> {
+public:
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
+	}
+
+	virtual ~LimitMonitor() {}
+
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = 0.0;
+		if (sample > upperLimit) {
+			*crossedLimit = upperLimit;
+			return MonitoringIF::ABOVE_HIGH_LIMIT;
+		} else if (sample < lowerLimit) {
+			*crossedLimit = lowerLimit;
+			return MonitoringIF::BELOW_LOW_LIMIT;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK; //Within limits.
+		}
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->lowerLimit);
+			break;
+		case 11:
+			parameterWrapper->set(this->upperLimit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	T getLowerLimit() const {
+		return lowerLimit;
+	}
+
+	T getUpperLimit() const {
+		return upperLimit;
+	}
+
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::BELOW_LOW_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			break;
+		case MonitoringIF::ABOVE_HIGH_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T lowerLimit;
+	T upperLimit;
+	const Event belowLowEvent;
+	const Event aboveHighEvent;
+};
+
+#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 489a8f9e..7869dc2b 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -1,60 +1,60 @@
-/**
- * @file	LimitViolationReporter.cpp
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/ReceivesMonitoringReportsIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
-	ReturnValue_t result = checkClassLoaded();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	store_address_t storeId;
-	uint8_t* dataTarget = NULL;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
-		return MonitoringIF::INVALID_SIZE;
-	}
-	result = ipcStore->getFreeElement(&storeId, maxSize,
-			&dataTarget);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	CommandMessage report;
-	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
-}
-
-ReturnValue_t LimitViolationReporter::checkClassLoaded() {
-	if (reportQueue == 0) {
-		ReceivesMonitoringReportsIF* receiver = objectManager->get<
-				ReceivesMonitoringReportsIF>(reportingTarget);
-		if (receiver == NULL) {
-			return ObjectManagerIF::NOT_FOUND;
-		}
-		reportQueue = receiver->getCommandQueue();
-	}
-	if (ipcStore == NULL) {
-		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//Lazy initialization.
-MessageQueueId_t LimitViolationReporter::reportQueue = 0;
-StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
-object_id_t LimitViolationReporter::reportingTarget = 0;
+/**
+ * @file	LimitViolationReporter.cpp
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
+	ReturnValue_t result = checkClassLoaded();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	store_address_t storeId;
+	uint8_t* dataTarget = NULL;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
+		return MonitoringIF::INVALID_SIZE;
+	}
+	result = ipcStore->getFreeElement(&storeId, maxSize,
+			&dataTarget);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	CommandMessage report;
+	MonitoringMessage::setLimitViolationReport(&report, storeId);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+}
+
+ReturnValue_t LimitViolationReporter::checkClassLoaded() {
+	if (reportQueue == 0) {
+		ReceivesMonitoringReportsIF* receiver = objectManager->get<
+				ReceivesMonitoringReportsIF>(reportingTarget);
+		if (receiver == NULL) {
+			return ObjectManagerIF::NOT_FOUND;
+		}
+		reportQueue = receiver->getCommandQueue();
+	}
+	if (ipcStore == NULL) {
+		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//Lazy initialization.
+MessageQueueId_t LimitViolationReporter::reportQueue = 0;
+StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
+object_id_t LimitViolationReporter::reportingTarget = 0;
diff --git a/monitoring/LimitViolationReporter.h b/monitoring/LimitViolationReporter.h
index 3a9d04dd..53d67b9d 100644
--- a/monitoring/LimitViolationReporter.h
+++ b/monitoring/LimitViolationReporter.h
@@ -1,31 +1,31 @@
-/**
- * @file	LimitViolationReporter.h
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#ifndef LIMITVIOLATIONREPORTER_H_
-#define LIMITVIOLATIONREPORTER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class LimitViolationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
-private:
-	static object_id_t reportingTarget;
-	static MessageQueueId_t reportQueue;
-	static StorageManagerIF* ipcStore;
-	static ReturnValue_t checkClassLoaded();
-	LimitViolationReporter();
-};
-
-#endif /* LIMITVIOLATIONREPORTER_H_ */
+/**
+ * @file	LimitViolationReporter.h
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#ifndef LIMITVIOLATIONREPORTER_H_
+#define LIMITVIOLATIONREPORTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class LimitViolationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
+private:
+	static object_id_t reportingTarget;
+	static MessageQueueId_t reportQueue;
+	static StorageManagerIF* ipcStore;
+	static ReturnValue_t checkClassLoaded();
+	LimitViolationReporter();
+};
+
+#endif /* LIMITVIOLATIONREPORTER_H_ */
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index f18ca4b5..45fe22ec 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,62 +1,62 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/monitoring/MonitorReporter.h>
-
-/**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
- */
-template<typename T>
-class MonitorBase: public MonitorReporter<T> {
-public:
-	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
-	}
-	virtual ~MonitorBase() {
-	}
-	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
-		T sample = 0;
-		ReturnValue_t validity = fetchSample(&sample);
-
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
-		if (validity != HasReturnvaluesIF::RETURN_OK) {
-			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
-		} else {
-			this->oldState = doCheck(sample);
-		}
-		return this->oldState;
-	}
-	virtual ReturnValue_t doCheck(T sample) {
-		T crossedLimit = 0.0;
-		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
-		return this->monitorStateIs(currentState,sample, crossedLimit);
-	}
-	//Abstract or default.
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
-
-protected:
-	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* MONITORBASE_H_ */
+#ifndef MONITORBASE_H_
+#define MONITORBASE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../monitoring/MonitorReporter.h"
+
+/**
+ * Base class for monitoring of parameters.
+ * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and forwarding of transition
+ * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
+ * the data pool and a simple confirmation counter.
+ */
+template<typename T>
+class MonitorBase: public MonitorReporter<T> {
+public:
+	MonitorBase(object_id_t reporterId, uint8_t monitorId,
+			uint32_t parameterId, uint16_t confirmationLimit) :
+			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+	}
+	virtual ~MonitorBase() {
+	}
+	virtual ReturnValue_t check() {
+		//1. Fetch sample of type T, return validity.
+		T sample = 0;
+		ReturnValue_t validity = fetchSample(&sample);
+
+		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		if (validity != HasReturnvaluesIF::RETURN_OK) {
+			this->monitorStateIs(validity, sample, 0);
+			//3. Otherwise, check sample.
+		} else {
+			this->oldState = doCheck(sample);
+		}
+		return this->oldState;
+	}
+	virtual ReturnValue_t doCheck(T sample) {
+		T crossedLimit = 0.0;
+		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
+		return this->monitorStateIs(currentState,sample, crossedLimit);
+	}
+	//Abstract or default.
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
+
+protected:
+	virtual ReturnValue_t fetchSample(T* sample) {
+		GlobDataSet mySet;
+		PIDReader<T> parameter(this->parameterId, &mySet);
+		mySet.read();
+		if (!parameter.isValid()) {
+			return MonitoringIF::INVALID;
+		}
+		*sample = parameter.value;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 6274313f..69bb00ea 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,178 +1,178 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
-
-#include <framework/events/EventManagerIF.h>
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/parameters/HasParametersIF.h>
-
-template<typename T>
-class MonitorReporter: public HasParametersIF {
-public:
-
-	static const uint8_t ENABLED = 1;
-	static const uint8_t DISABLED = 0;
-
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
-	}
-
-	virtual ~MonitorReporter() {
-	}
-
-	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
-			T crossedLimit = 0) {
-		if (state != oldState) {
-			if (isConfirmed(state)) {
-				if (eventEnabled == ENABLED) {
-					sendTransitionEvent(parameterValue, state);
-				}
-				if (reportingEnabled == ENABLED) {
-					sendTransitionReport(parameterValue, crossedLimit, state);
-				}
-				oldState = state;
-			} else {
-				//This is to ensure confirmation works.
-				//Needs to be reset to be able to confirm against oldState again next time.
-				return oldState;
-			}
-		} else {
-			resetConfirmation();
-		}
-		return state;
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != monitorId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(this->confirmationLimit);
-			break;
-		case 1:
-			parameterWrapper->set(this->reportingEnabled);
-			break;
-		case 2:
-			parameterWrapper->set(this->eventEnabled);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t setToUnchecked() {
-		return setToState(MonitoringIF::UNCHECKED);
-	}
-	virtual ReturnValue_t setToInvalid() {
-		return setToState(MonitoringIF::INVALID);
-	}
-	object_id_t getReporterId() const {
-		return reportingId;
-	}
-
-	void setEventEnabled(uint8_t eventEnabled) {
-		this->eventEnabled = eventEnabled;
-	}
-
-	void setReportingEnabled(uint8_t reportingEnabled) {
-		this->reportingEnabled = reportingEnabled;
-	}
-
-	bool isEventEnabled() const {
-		return (eventEnabled == ENABLED);
-	}
-
-protected:
-	const uint8_t monitorId;
-	const uint32_t parameterId;
-	object_id_t reportingId;
-	ReturnValue_t oldState;
-
-	uint8_t reportingEnabled;
-
-	uint8_t eventEnabled;
-
-	uint16_t currentCounter;
-	uint16_t confirmationLimit;
-
-	bool isConfirmed(ReturnValue_t state) {
-		//Confirm INVALID and UNCHECKED immediately.
-		if (state == MonitoringIF::INVALID
-				|| state == MonitoringIF::UNCHECKED) {
-			currentCounter = 0;
-			return true;
-		}
-		return doesChildConfirm(state);
-	}
-
-	/**
-	 * This is the most simple form of confirmation.
-	 * A counter counts any violation and compares the number to maxCounter.
-	 * @param state The state, indicating the type of violation. Not used here.
-	 * @return true if counter > maxCounter, else false.
-	 */
-	virtual bool doesChildConfirm(ReturnValue_t state) {
-		currentCounter += 1;
-		if (currentCounter > confirmationLimit) {
-			currentCounter = 0;
-			return true;
-		} else {
-			return false;
-		}
-	}
-	/**
-	 * This method needs to reset the confirmation in case a valid sample was found.
-	 * Here, simply resets the current counter.
-	 */
-	virtual void resetConfirmation() {
-		currentCounter = 0;
-	}
-	/**
-	 * Default version of sending transitional events.
-	 * Should be overridden from specialized monitors.
-	 * @param currentValue The current value which was monitored.
-	 * @param state The state the monitor changed to.
-	 */
-	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch(state) {
-		case MonitoringIF::UNCHECKED:
-		case MonitoringIF::UNSELECTED:
-		case MonitoringIF::INVALID:
-		case HasReturnvaluesIF::RETURN_OK:
-			break;
-		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
-			break;
-		}
-	}
-	/**
-	 * Default implementation for sending transition report.
-	 * May be overridden, but is seldom necessary.
-	 * @param parameterValue Current value of the parameter
-	 * @param crossedLimit The limit crossed (if applicable).
-	 * @param state Current state the monitor is in.
-	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
-				parameterValue, crossedLimit, oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-	ReturnValue_t setToState(ReturnValue_t state) {
-		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
-					state);
-			LimitViolationReporter::sendLimitViolationReport(&report);
-			oldState = state;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../parameters/HasParametersIF.h"
+
+template<typename T>
+class MonitorReporter: public HasParametersIF {
+public:
+
+	static const uint8_t ENABLED = 1;
+	static const uint8_t DISABLED = 0;
+
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId), reportingId(
+					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
+			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
+					confirmationLimit) {
+	}
+
+	virtual ~MonitorReporter() {
+	}
+
+	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
+			T crossedLimit = 0) {
+		if (state != oldState) {
+			if (isConfirmed(state)) {
+				if (eventEnabled == ENABLED) {
+					sendTransitionEvent(parameterValue, state);
+				}
+				if (reportingEnabled == ENABLED) {
+					sendTransitionReport(parameterValue, crossedLimit, state);
+				}
+				oldState = state;
+			} else {
+				//This is to ensure confirmation works.
+				//Needs to be reset to be able to confirm against oldState again next time.
+				return oldState;
+			}
+		} else {
+			resetConfirmation();
+		}
+		return state;
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != monitorId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(this->confirmationLimit);
+			break;
+		case 1:
+			parameterWrapper->set(this->reportingEnabled);
+			break;
+		case 2:
+			parameterWrapper->set(this->eventEnabled);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t setToUnchecked() {
+		return setToState(MonitoringIF::UNCHECKED);
+	}
+	virtual ReturnValue_t setToInvalid() {
+		return setToState(MonitoringIF::INVALID);
+	}
+	object_id_t getReporterId() const {
+		return reportingId;
+	}
+
+	void setEventEnabled(uint8_t eventEnabled) {
+		this->eventEnabled = eventEnabled;
+	}
+
+	void setReportingEnabled(uint8_t reportingEnabled) {
+		this->reportingEnabled = reportingEnabled;
+	}
+
+	bool isEventEnabled() const {
+		return (eventEnabled == ENABLED);
+	}
+
+protected:
+	const uint8_t monitorId;
+	const uint32_t parameterId;
+	object_id_t reportingId;
+	ReturnValue_t oldState;
+
+	uint8_t reportingEnabled;
+
+	uint8_t eventEnabled;
+
+	uint16_t currentCounter;
+	uint16_t confirmationLimit;
+
+	bool isConfirmed(ReturnValue_t state) {
+		//Confirm INVALID and UNCHECKED immediately.
+		if (state == MonitoringIF::INVALID
+				|| state == MonitoringIF::UNCHECKED) {
+			currentCounter = 0;
+			return true;
+		}
+		return doesChildConfirm(state);
+	}
+
+	/**
+	 * This is the most simple form of confirmation.
+	 * A counter counts any violation and compares the number to maxCounter.
+	 * @param state The state, indicating the type of violation. Not used here.
+	 * @return true if counter > maxCounter, else false.
+	 */
+	virtual bool doesChildConfirm(ReturnValue_t state) {
+		currentCounter += 1;
+		if (currentCounter > confirmationLimit) {
+			currentCounter = 0;
+			return true;
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * This method needs to reset the confirmation in case a valid sample was found.
+	 * Here, simply resets the current counter.
+	 */
+	virtual void resetConfirmation() {
+		currentCounter = 0;
+	}
+	/**
+	 * Default version of sending transitional events.
+	 * Should be overridden from specialized monitors.
+	 * @param currentValue The current value which was monitored.
+	 * @param state The state the monitor changed to.
+	 */
+	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch(state) {
+		case MonitoringIF::UNCHECKED:
+		case MonitoringIF::UNSELECTED:
+		case MonitoringIF::INVALID:
+		case HasReturnvaluesIF::RETURN_OK:
+			break;
+		default:
+			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			break;
+		}
+	}
+	/**
+	 * Default implementation for sending transition report.
+	 * May be overridden, but is seldom necessary.
+	 * @param parameterValue Current value of the parameter
+	 * @param crossedLimit The limit crossed (if applicable).
+	 * @param state Current state the monitor is in.
+	 */
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+		MonitoringReportContent<T> report(parameterId,
+				parameterValue, crossedLimit, oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+	ReturnValue_t setToState(ReturnValue_t state) {
+		if (oldState != state && reportingEnabled) {
+			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+					state);
+			LimitViolationReporter::sendLimitViolationReport(&report);
+			oldState = state;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index d2d62f35..a4c0666c 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,67 +1,67 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
-
-#include <framework/memory/HasMemoryIF.h>
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/serialize/SerializeIF.h>
-
-class MonitoringIF : public SerializeIF {
-public:
-	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
-	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
-	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
-	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
-	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
-	static const uint8_t LIMIT_TYPE_OBJECT = 128;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
-	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
-
-
-	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
-
-	static const uint8_t REPORT_NONE = 0;
-	static const uint8_t REPORT_EVENTS_ONLY = 1;
-	static const uint8_t REPORT_REPORTS_ONLY = 2;
-	static const uint8_t REPORT_ALL = 3;
-
-//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
-//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
-//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
-//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
-//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
-//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
-//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
-	virtual ReturnValue_t check() = 0;
-	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
-	virtual ReturnValue_t setToUnchecked() = 0;
-	virtual uint8_t getLimitType() const = 0;
-	virtual uint32_t getLimitId() const = 0;
-//	virtual ReturnValue_t setEventReporting(bool active) = 0;
-	virtual ~MonitoringIF() {
-	}
-};
-
-
-
-#endif /* MONITORINGIF_H_ */
+#ifndef MONITORINGIF_H_
+#define MONITORINGIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../serialize/SerializeIF.h"
+
+class MonitoringIF : public SerializeIF {
+public:
+	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
+	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
+	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
+	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
+	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
+	static const uint8_t LIMIT_TYPE_OBJECT = 128;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
+	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
+
+
+	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
+
+	static const uint8_t REPORT_NONE = 0;
+	static const uint8_t REPORT_EVENTS_ONLY = 1;
+	static const uint8_t REPORT_REPORTS_ONLY = 2;
+	static const uint8_t REPORT_ALL = 3;
+
+//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
+//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
+//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
+//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
+//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
+//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
+//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
+	virtual ReturnValue_t check() = 0;
+	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
+	virtual ReturnValue_t setToUnchecked() = 0;
+	virtual uint8_t getLimitType() const = 0;
+	virtual uint32_t getLimitId() const = 0;
+//	virtual ReturnValue_t setEventReporting(bool active) = 0;
+	virtual ~MonitoringIF() {
+	}
+};
+
+
+
+#endif /* MONITORINGIF_H_ */
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 77919bfe..9edf16d5 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,38 +1,38 @@
-#include <framework/monitoring/MonitoringMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-MonitoringMessage::~MonitoringMessage() {
-}
-
-void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
-		store_address_t storeId) {
-	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
-}
-
-void MonitoringMessage::setTypicalMessage(CommandMessage* message,
-		Command_t type, store_address_t storeId) {
-	message->setCommand(type);
-	message->setParameter2(storeId.raw);
-}
-
-store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void MonitoringMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-	switch (message->getCommand()) {
-	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../monitoring/MonitoringMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+MonitoringMessage::~MonitoringMessage() {
+}
+
+void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
+		store_address_t storeId) {
+	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
+}
+
+void MonitoringMessage::setTypicalMessage(CommandMessage* message,
+		Command_t type, store_address_t storeId) {
+	message->setCommand(type);
+	message->setParameter2(storeId.raw);
+}
+
+store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void MonitoringMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+	switch (message->getCommand()) {
+	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index 793e1fbf..55d3ea5c 100644
--- a/monitoring/MonitoringMessage.h
+++ b/monitoring/MonitoringMessage.h
@@ -1,21 +1,21 @@
-#ifndef MONITORINGMESSAGE_H_
-#define MONITORINGMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-class MonitoringMessage: public CommandMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
-	//Object id could be useful, but we better manage that on service level (register potential reporters).
-	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
-	virtual ~MonitoringMessage();
-	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
-	static void clear(CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
-
-};
-
-
-#endif /* MONITORINGMESSAGE_H_ */
+#ifndef MONITORINGMESSAGE_H_
+#define MONITORINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class MonitoringMessage: public CommandMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
+	//Object id could be useful, but we better manage that on service level (register potential reporters).
+	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
+	virtual ~MonitoringMessage();
+	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
+	static void clear(CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
+
+};
+
+
+#endif /* MONITORINGMESSAGE_H_ */
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 7e1aca62..a0934c14 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,77 +1,77 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
-
-#include <framework/monitoring/HasMonitorsIF.h>
-#include <framework/monitoring/MonitoringIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/TimeStamperIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
-template<typename T>
-class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
-	SerializeElement<T> parameterValue;
-	SerializeElement<T> limitValue;
-	SerializeElement<ReturnValue_t> oldState;
-	SerializeElement<ReturnValue_t> newState;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-	TimeStamperIF* timeStamper;
-	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
-					sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
-			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-		if (checkAndSetStamper()) {
-			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
-		}
-	}
-private:
-
-	static object_id_t timeStamperId;
-	void setAllNext() {
-		parameterId.setNext(&parameterValue);
-		parameterValue.setNext(&limitValue);
-		limitValue.setNext(&oldState);
-		oldState.setNext(&newState);
-		newState.setNext(&timestampSerializer);
-	}
-	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
-			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
-				sif::error << "MonitoringReportContent::checkAndSetStamper: "
-				        "Stamper not found!" << std::endl;
-				return false;
-			}
-		}
-		return true;
-	}
-};
-template<typename T>
-object_id_t MonitoringReportContent<T>::timeStamperId = 0;
-
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#ifndef MONITORINGMESSAGECONTENT_H_
+#define MONITORINGMESSAGECONTENT_H_
+
+#include "../monitoring/HasMonitorsIF.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../timemanager/TimeStamperIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+template<typename T>
+class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	SerializeElement<uint8_t> monitorId;
+	SerializeElement<uint32_t> parameterId;
+	SerializeElement<T> parameterValue;
+	SerializeElement<T> limitValue;
+	SerializeElement<ReturnValue_t> oldState;
+	SerializeElement<ReturnValue_t> newState;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
+	TimeStamperIF* timeStamper;
+	MonitoringReportContent() :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					0), parameterValue(0), limitValue(0), oldState(0), newState(
+					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+					sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+	}
+	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+			ReturnValue_t oldState, ReturnValue_t newState) :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					setPID), parameterValue(value), limitValue(limitValue), oldState(
+					oldState), newState(newState), timestampSerializer(rawTimestamp,
+							sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+		if (checkAndSetStamper()) {
+			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
+		}
+	}
+private:
+
+	static object_id_t timeStamperId;
+	void setAllNext() {
+		parameterId.setNext(&parameterValue);
+		parameterValue.setNext(&limitValue);
+		limitValue.setNext(&oldState);
+		oldState.setNext(&newState);
+		newState.setNext(&timestampSerializer);
+	}
+	bool checkAndSetStamper() {
+		if (timeStamper == NULL) {
+			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
+			if ( timeStamper == NULL ) {
+				sif::error << "MonitoringReportContent::checkAndSetStamper: "
+				        "Stamper not found!" << std::endl;
+				return false;
+			}
+		}
+		return true;
+	}
+};
+template<typename T>
+object_id_t MonitoringReportContent<T>::timeStamperId = 0;
+
+#endif /* MONITORINGMESSAGECONTENT_H_ */
diff --git a/monitoring/ReceivesMonitoringReportsIF.h b/monitoring/ReceivesMonitoringReportsIF.h
index 42c365c1..16595f33 100644
--- a/monitoring/ReceivesMonitoringReportsIF.h
+++ b/monitoring/ReceivesMonitoringReportsIF.h
@@ -1,15 +1,15 @@
-#ifndef RECEIVESMONITORINGREPORTSIF_H_
-#define RECEIVESMONITORINGREPORTSIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class ReceivesMonitoringReportsIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~ReceivesMonitoringReportsIF() {
-	}
-};
-
-
-
-#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
+#ifndef RECEIVESMONITORINGREPORTSIF_H_
+#define RECEIVESMONITORINGREPORTSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesMonitoringReportsIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~ReceivesMonitoringReportsIF() {
+	}
+};
+
+
+
+#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 9a2e69c3..6f190361 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-
-#include <framework/datapool/DataSet.h>
-#include <framework/datapool/PIDReaderList.h>
-#include <framework/health/HealthTableIF.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-
-//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
-template<typename T>
-class TriplexMonitor : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
-	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
-
-	static const uint8_t THREE = 3;
-
-	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
-			Event eventTripleCheck, Event eventDualCheck) :
-			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
-					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
-					NULL), domainId(domainId) {
-
-	}
-	virtual ~TriplexMonitor() {
-	}
-	ReturnValue_t check() {
-		dataSet.read();
-		//check health and validity
-		uint8_t availableIndex[2] = { 0, 0 };
-		bool first = true;
-		uint8_t nAvailable = 0;
-		for (uint8_t count = 0; count < THREE; count++) {
-			if (values[count].isValid() && checkObjectHealthState(count)) {
-				if (first) {
-					availableIndex[0] = count;
-					first = false;
-				} else {
-					//Might be filled twice, but then it's not needed anyway.
-					availableIndex[1] = count;
-				}
-				nAvailable++;
-			}
-		}
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-		switch (nAvailable) {
-		case 3:
-			result = doTriplexMonitoring();
-			break;
-		case 2:
-			result = doDuplexMonitoring(availableIndex);
-			break;
-		default:
-			result = NOT_ENOUGH_SENSORS;
-			break;
-		}
-		dataSet.commit();
-		return result;
-	}
-	ReturnValue_t initialize() {
-		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-		if (healthTable == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != this->domainId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(limit);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-	DataSet dataSet;
-	PIDReaderList<T, THREE> values;
-	T limit;
-	Event eventTripleCheck;
-	Event eventDualCheck;
-	HealthTableIF* healthTable;
-	uint8_t domainId;
-	ReturnValue_t doTriplexMonitoring() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		//Find middle value, by ordering indices
-		uint8_t index[3] = { 0, 1, 2 };
-		if (values[index[0]].value > values[index[1]].value) {
-			std::swap(index[0], index[1]);
-		}
-		if (values[index[0]].value > values[index[2]].value) {
-			std::swap(index[0], index[2]);
-		}
-		if (values[index[1]].value > values[index[2]].value) {
-			std::swap(index[1], index[2]);
-		}
-		//Test if smallest value is out-of-limit.
-		if (values[index[0]] < (values[index[1]] - limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-					eventTripleCheck, LOWEST_VALUE_OOL, 0);
-			result = LOWEST_VALUE_OOL;
-		}
-		//Test if largest value is out-of-limit.
-		if (values[index[2]] > (values[index[1]] + limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
-					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
-			if (result == HasReturnvaluesIF::RETURN_OK) {
-				result = HIGHEST_VALUE_OOL;
-			} else {
-				result = BOTH_VALUES_OOL;
-			}
-		}
-		return result;
-	}
-
-	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
-		T mean = (values[index[0]] + values[index[1]]) / 2;
-		if (values[index[0]] > values[index[1]]) {
-			if (values[index[0]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		} else {
-			if (values[index[1]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
-	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
-};
-
-#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReaderList.h"
+#include "../health/HealthTableIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+
+//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
+template<typename T>
+class TriplexMonitor : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
+	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
+
+	static const uint8_t THREE = 3;
+
+	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
+			Event eventTripleCheck, Event eventDualCheck) :
+			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
+					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
+					NULL), domainId(domainId) {
+
+	}
+	virtual ~TriplexMonitor() {
+	}
+	ReturnValue_t check() {
+		dataSet.read();
+		//check health and validity
+		uint8_t availableIndex[2] = { 0, 0 };
+		bool first = true;
+		uint8_t nAvailable = 0;
+		for (uint8_t count = 0; count < THREE; count++) {
+			if (values[count].isValid() && checkObjectHealthState(count)) {
+				if (first) {
+					availableIndex[0] = count;
+					first = false;
+				} else {
+					//Might be filled twice, but then it's not needed anyway.
+					availableIndex[1] = count;
+				}
+				nAvailable++;
+			}
+		}
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+		switch (nAvailable) {
+		case 3:
+			result = doTriplexMonitoring();
+			break;
+		case 2:
+			result = doDuplexMonitoring(availableIndex);
+			break;
+		default:
+			result = NOT_ENOUGH_SENSORS;
+			break;
+		}
+		dataSet.commit();
+		return result;
+	}
+	ReturnValue_t initialize() {
+		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+		if (healthTable == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != this->domainId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(limit);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+	DataSet dataSet;
+	PIDReaderList<T, THREE> values;
+	T limit;
+	Event eventTripleCheck;
+	Event eventDualCheck;
+	HealthTableIF* healthTable;
+	uint8_t domainId;
+	ReturnValue_t doTriplexMonitoring() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		//Find middle value, by ordering indices
+		uint8_t index[3] = { 0, 1, 2 };
+		if (values[index[0]].value > values[index[1]].value) {
+			std::swap(index[0], index[1]);
+		}
+		if (values[index[0]].value > values[index[2]].value) {
+			std::swap(index[0], index[2]);
+		}
+		if (values[index[1]].value > values[index[2]].value) {
+			std::swap(index[1], index[2]);
+		}
+		//Test if smallest value is out-of-limit.
+		if (values[index[0]] < (values[index[1]] - limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+					eventTripleCheck, LOWEST_VALUE_OOL, 0);
+			result = LOWEST_VALUE_OOL;
+		}
+		//Test if largest value is out-of-limit.
+		if (values[index[2]] > (values[index[1]] + limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
+					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
+			if (result == HasReturnvaluesIF::RETURN_OK) {
+				result = HIGHEST_VALUE_OOL;
+			} else {
+				result = BOTH_VALUES_OOL;
+			}
+		}
+		return result;
+	}
+
+	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
+		T mean = (values[index[0]] + values[index[1]]) / 2;
+		if (values[index[0]] > values[index[1]]) {
+			if (values[index[0]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		} else {
+			if (values[index[1]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
+	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
+};
+
+#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index c17ad433..ac0ef1ee 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,44 +1,44 @@
-#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-
-#include <framework/monitoring/LimitMonitor.h>
-
-template<typename T>
-class TwoValueLimitMonitor: public LimitMonitor<T> {
-public:
-	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-			uint32_t lowParameterId, uint32_t highParameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
-					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
-					aboveHighEvent), highValueParameterId(highParameterId) {
-	}
-	virtual ~TwoValueLimitMonitor() {
-	}
-	ReturnValue_t doCheck(T lowSample, T highSample) {
-		T crossedLimit;
-		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
-		if (currentState != HasReturnvaluesIF::RETURN_OK) {
-			return this->monitorStateIs(currentState, lowSample, crossedLimit);
-		}
-		currentState = this->checkSample(highSample, &crossedLimit);
-		return this->monitorStateIs(currentState, highSample, crossedLimit);
-	}
-protected:
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
-			ReturnValue_t state) {
-		uint32_t usedParameterId = this->parameterId;
-		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			usedParameterId = this->highValueParameterId;
-		}
-		MonitoringReportContent<T> report(usedParameterId, parameterValue,
-				crossedLimit, this->oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-private:
-	const uint32_t highValueParameterId;
-};
-
-#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+
+#include "../monitoring/LimitMonitor.h"
+
+template<typename T>
+class TwoValueLimitMonitor: public LimitMonitor<T> {
+public:
+	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+			uint32_t lowParameterId, uint32_t highParameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
+					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
+					aboveHighEvent), highValueParameterId(highParameterId) {
+	}
+	virtual ~TwoValueLimitMonitor() {
+	}
+	ReturnValue_t doCheck(T lowSample, T highSample) {
+		T crossedLimit;
+		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
+		if (currentState != HasReturnvaluesIF::RETURN_OK) {
+			return this->monitorStateIs(currentState, lowSample, crossedLimit);
+		}
+		currentState = this->checkSample(highSample, &crossedLimit);
+		return this->monitorStateIs(currentState, highSample, crossedLimit);
+	}
+protected:
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+			ReturnValue_t state) {
+		uint32_t usedParameterId = this->parameterId;
+		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			usedParameterId = this->highValueParameterId;
+		}
+		MonitoringReportContent<T> report(usedParameterId, parameterValue,
+				crossedLimit, this->oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+private:
+	const uint32_t highValueParameterId;
+};
+
+#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 1c54355a..13d67559 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,108 +1,108 @@
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <iomanip>
-#include <cstdlib>
-
-ObjectManager::ObjectManager( void (*setProducer)() ):
-		produceObjects(setProducer) {
-	//There's nothing special to do in the constructor.
-}
-
-
-ObjectManager::~ObjectManager() {
-	for (auto const& iter : objectList) {
-		delete iter.second;
-	}
-}
-
-ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	auto returnPair = objectList.emplace(id, object);
-	if (returnPair.second) {
-	    // sif::debug << "ObjectManager::insert: Object " << std::hex
-	    //            << (int)id << std::dec << " inserted." << std::endl;
-		return this->RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
-		sif::error << "Terminating program." << std::endl;
-		//This is very severe and difficult to handle in other places.
-		std::exit(INSERTION_FAILED);
-	}
-}
-
-ReturnValue_t ObjectManager::remove( object_id_t id ) {
-	if ( this->getSystemObject(id) != NULL ) {
-		this->objectList.erase( id );
-		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		//           << (int)id << std::dec << " removed." << std::endl;
-		return RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::removeObject: Requested object "
-		        << std::hex << (int)id << std::dec << " not found." << std::endl;
-		return NOT_FOUND;
-	}
-}
-
-
-
-SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	auto listIter = this->objectList.find( id );
-	if (listIter == this->objectList.end() ) {
-		return nullptr;
-	} else {
-		return listIter->second;
-	}
-}
-
-ObjectManager::ObjectManager() : produceObjects(nullptr) {
-
-}
-
-void ObjectManager::initialize() {
-	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager::initialize: Passed produceObjects "
-				"functions is nullptr!" << std::endl;
-		return;
-	}
-	this->produceObjects();
-	ReturnValue_t result = RETURN_FAILED;
-	uint32_t errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->initialize();
-		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
-			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
-					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << result << std::dec <<
-					std::setfill(' ') << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed initializations." << std::endl;
-	}
-	//Init was successful. Now check successful interconnections.
-	errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->checkObjectConnections();
-		if ( result != RETURN_OK ) {
-			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
-					(int) it.first  << " connection check failed with code 0x"
-					<< result << std::dec << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed connection checks." << std::endl;
-	}
-}
-
-void ObjectManager::printList() {
-	std::map<object_id_t, SystemObjectIF*>::iterator it;
-	sif::debug << "ObjectManager: Object List contains:" << std::endl;
-	for (auto const& it : objectList) {
-		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
-	}
-}
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+#include <cstdlib>
+
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
+	//There's nothing special to do in the constructor.
+}
+
+
+ObjectManager::~ObjectManager() {
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
+}
+
+ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
+	    // sif::debug << "ObjectManager::insert: Object " << std::hex
+	    //            << (int)id << std::dec << " inserted." << std::endl;
+		return this->RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::insert: Object id " << std::hex
+		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
+	}
+}
+
+ReturnValue_t ObjectManager::remove( object_id_t id ) {
+	if ( this->getSystemObject(id) != NULL ) {
+		this->objectList.erase( id );
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
+		return RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::removeObject: Requested object "
+		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+		return NOT_FOUND;
+	}
+}
+
+
+
+SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
+	} else {
+		return listIter->second;
+	}
+}
+
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
+
+}
+
+void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
+		return;
+	}
+	this->produceObjects();
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
+			object_id_t var = it.first;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed initializations." << std::endl;
+	}
+	//Init was successful. Now check successful interconnections.
+	errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed connection checks." << std::endl;
+	}
+}
+
+void ObjectManager::printList() {
+	std::map<object_id_t, SystemObjectIF*>::iterator it;
+	sif::debug << "ObjectManager: Object List contains:" << std::endl;
+	for (auto const& it : objectList) {
+		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
+	}
+}
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index 63451071..0bc525be 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,67 +1,67 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <map>
-
-/**
- * @brief	This class implements a global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. Objects can
- * 			be inserted, removed and retrieved from the list. In addition, the
- * 			class holds a so-called factory, that creates and inserts new
- * 			objects if they are not already in the list. This feature automates
- * 			most of the system initialization.
- * 			As the system is static after initialization, no new objects are
- * 			created or inserted into the list after startup.
- * \ingroup system_objects
- */
-class ObjectManager : public ObjectManagerIF {
-private:
-	//comparison?
-	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
-	 */
-	std::map<object_id_t, SystemObjectIF*> objectList;
-protected:
-	SystemObjectIF* getSystemObject( object_id_t id );
-	/**
-	 * @brief	This attribute is initialized with the factory function
-	 * 			that creates new objects.
-	 * @details	The function is called if an object was requested with
-	 * 			getSystemObject, but not found in objectList.
-	 * @param 	The id of the object to be created.
-	 * @return	Returns a pointer to the newly created object or NULL.
-	 */
-	void (*produceObjects)();
-public:
-	/**
-	 * @brief	Apart from setting the producer function, nothing special
-	 * 			happens in the constructor.
-	 * @param setProducer	A pointer to a factory function.
-	 */
-	ObjectManager( void (*produce)() );
-	ObjectManager();
-	/**
-	 *	@brief	In the class's destructor, all objects in the list are deleted.
-	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
-	virtual ~ObjectManager( void );
-	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
-	ReturnValue_t remove( object_id_t id );
-	void initialize();
-	void printList();
-};
-
-
-
-#endif /* OBJECTMANAGER_H_ */
+/**
+ * @file	ObjectManager.h
+ * @brief	This file contains the implementation of the ObjectManager class
+ * @date	18.09.2012
+ * @author	Bastian Baetz
+ */
+
+#ifndef OBJECTMANAGER_H_
+#define OBJECTMANAGER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include <map>
+
+/**
+ * @brief	This class implements a global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. Objects can
+ * 			be inserted, removed and retrieved from the list. In addition, the
+ * 			class holds a so-called factory, that creates and inserts new
+ * 			objects if they are not already in the list. This feature automates
+ * 			most of the system initialization.
+ * 			As the system is static after initialization, no new objects are
+ * 			created or inserted into the list after startup.
+ * \ingroup system_objects
+ */
+class ObjectManager : public ObjectManagerIF {
+private:
+	//comparison?
+	/**
+	 * \brief	This is the map of all initialized objects in the manager.
+	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 */
+	std::map<object_id_t, SystemObjectIF*> objectList;
+protected:
+	SystemObjectIF* getSystemObject( object_id_t id );
+	/**
+	 * @brief	This attribute is initialized with the factory function
+	 * 			that creates new objects.
+	 * @details	The function is called if an object was requested with
+	 * 			getSystemObject, but not found in objectList.
+	 * @param 	The id of the object to be created.
+	 * @return	Returns a pointer to the newly created object or NULL.
+	 */
+	void (*produceObjects)();
+public:
+	/**
+	 * @brief	Apart from setting the producer function, nothing special
+	 * 			happens in the constructor.
+	 * @param setProducer	A pointer to a factory function.
+	 */
+	ObjectManager( void (*produce)() );
+	ObjectManager();
+	/**
+	 *	@brief	In the class's destructor, all objects in the list are deleted.
+	 */
+	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	virtual ~ObjectManager( void );
+	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
+	ReturnValue_t remove( object_id_t id );
+	void initialize();
+	void printList();
+};
+
+
+
+#endif /* OBJECTMANAGER_H_ */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 90a1ce3b..5dfe8e4e 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-
-#include <framework/objectmanager/frameworkObjects.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * @brief	This class provides an interface to the global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. They can be
- * 			inserted, removed and retrieved from the list. On getting the
- * 			object, the call checks if the object implements the requested
- * 			interface.
- * @author	Bastian Baetz
- * @ingroup system_objects
- */
-class ObjectManagerIF : public HasReturnvaluesIF {
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
-	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
-
-protected:
-	/**
-	 * @brief	This method is used to hide the template-based get call from
-	 * 			a specific implementation.
-	 * @details	So, an implementation only has to implement this call.
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing (at
-	 * 			least) the SystemObjectIF, or NULL.
-	 */
-	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
-	 */
-	virtual ~ObjectManagerIF( void ) {};
-	/**
-	 * @brief	With this call, new objects are inserted to the list.
-	 * @details	The implementation shall return an error code in case the
-	 * 			object can't be added (e.g. the id is already in use).
-	 * @param id		The new id to be added to the list.
-	 * @param object	A pointer to the object to be added.
-	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
-	 * 			@li RETURN_OK in case the object was successfully inserted
-	 */
-	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
-	/**
-	 * @brief	With the get call, interfaces of an object can be retrieved in
-	 * 			a type-safe manner.
-	 * @details With the template-based call, the object list is searched with the
-	 * 			getSystemObject method and afterwards it is checked, if the object
-	 * 			implements the requested interface (with a dynamic_cast).
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing the
-	 * 			requested interface, or NULL.
-	 */
-	template <typename T> T* get( object_id_t id );
-	/**
-	 * @brief	With this call, an object is removed from the list.
-	 * @param id	The object id of the object to be removed.
-	 * @return	\li NOT_FOUND in case the object was not found
-	 * 			\li RETURN_OK in case the object was successfully removed
-	 */
-	virtual ReturnValue_t remove( object_id_t id ) = 0;
-	virtual void initialize() = 0;
-	/**
-	 * @brief	This is a debug function, that prints the current content of the
-	 * 			object list.
-	 */
-	virtual void printList() = 0;
-};
-
-
-/**
- * @brief	This is the forward declaration of the global objectManager instance.
- */
-extern ObjectManagerIF *objectManager;
-
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	if(objectManager == nullptr) {
-		sif::error << "ObjectManagerIF: Global object manager has not "
-				"been initialized yet!" << std::endl;
-	}
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
-#endif /* OBJECTMANAGERIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This class provides an interface to the global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. They can be
+ * 			inserted, removed and retrieved from the list. On getting the
+ * 			object, the call checks if the object implements the requested
+ * 			interface.
+ * @author	Bastian Baetz
+ * @ingroup system_objects
+ */
+class ObjectManagerIF : public HasReturnvaluesIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
+protected:
+	/**
+	 * @brief	This method is used to hide the template-based get call from
+	 * 			a specific implementation.
+	 * @details	So, an implementation only has to implement this call.
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing (at
+	 * 			least) the SystemObjectIF, or NULL.
+	 */
+	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
+	 */
+	virtual ~ObjectManagerIF( void ) {};
+	/**
+	 * @brief	With this call, new objects are inserted to the list.
+	 * @details	The implementation shall return an error code in case the
+	 * 			object can't be added (e.g. the id is already in use).
+	 * @param id		The new id to be added to the list.
+	 * @param object	A pointer to the object to be added.
+	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
+	 * 			@li RETURN_OK in case the object was successfully inserted
+	 */
+	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
+	/**
+	 * @brief	With the get call, interfaces of an object can be retrieved in
+	 * 			a type-safe manner.
+	 * @details With the template-based call, the object list is searched with the
+	 * 			getSystemObject method and afterwards it is checked, if the object
+	 * 			implements the requested interface (with a dynamic_cast).
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing the
+	 * 			requested interface, or NULL.
+	 */
+	template <typename T> T* get( object_id_t id );
+	/**
+	 * @brief	With this call, an object is removed from the list.
+	 * @param id	The object id of the object to be removed.
+	 * @return	\li NOT_FOUND in case the object was not found
+	 * 			\li RETURN_OK in case the object was successfully removed
+	 */
+	virtual ReturnValue_t remove( object_id_t id ) = 0;
+	virtual void initialize() = 0;
+	/**
+	 * @brief	This is a debug function, that prints the current content of the
+	 * 			object list.
+	 */
+	virtual void printList() = 0;
+};
+
+
+/**
+ * @brief	This is the forward declaration of the global objectManager instance.
+ */
+extern ObjectManagerIF *objectManager;
+
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
+#endif /* OBJECTMANAGERIF_H_ */
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index 85daaa35..e3eb22ee 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,37 +1,37 @@
-#include <framework/events/EventManagerIF.h>
-#include <framework/objectmanager/ObjectManager.h>
-#include <framework/objectmanager/SystemObject.h>
-
-SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
-		objectId(setObjectId), registered(doRegister) {
-	if (registered) {
-		objectManager->insert(objectId, this);
-	}
-}
-
-SystemObject::~SystemObject() {
-	if (registered) {
-		objectManager->remove(objectId);
-	}
-}
-
-object_id_t SystemObject::getObjectId() const {
-	return objectId;
-}
-
-void SystemObject::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
-
-ReturnValue_t SystemObject::initialize() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SystemObject::checkObjectConnections() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../objectmanager/SystemObject.h"
+
+SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
+		objectId(setObjectId), registered(doRegister) {
+	if (registered) {
+		objectManager->insert(objectId, this);
+	}
+}
+
+SystemObject::~SystemObject() {
+	if (registered) {
+		objectManager->remove(objectId);
+	}
+}
+
+object_id_t SystemObject::getObjectId() const {
+	return objectId;
+}
+
+void SystemObject::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
+
+ReturnValue_t SystemObject::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SystemObject::checkObjectConnections() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 6a1b35b6..fa97aab4 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -1,61 +1,61 @@
-/**
- * @file	SystemObject.h
- * @brief	This file contains the definition of the SystemObject class.
- * @date	07.11.2012
- * @author	Ulrich Mohr
- */
-
-#ifndef SYSTEMOBJECT_H_
-#define SYSTEMOBJECT_H_
-
-#include <framework/events/Event.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/timemanager/Clock.h>
-
-/**
- * @brief	This class automates insertion into the ObjectManager and
- * 			management of the object id.
- * @details	This class is more a base class, which shall be inherited by any
- * 			class that is announced to ObjectManager. It automatically includes
- * 			itself (and therefore the inheriting class) in the object manager's
- * 			list.
- * \ingroup system_objects
- */
-class SystemObject: public SystemObjectIF {
-private:
-	/**
-	 * @brief	This is the id the class instant got assigned.
-	 */
-	const object_id_t objectId;
-	const bool registered;
-public:
-
-	/**
-	 * Helper function to send Event Messages to the Event Manager
-	 * @param event
-	 * @param parameter1
-	 * @param parameter2
-	 */
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	/**
-	 * @brief	The class's constructor.
-	 * @details	In the constructor, the object id is set and the class is
-	 * 			inserted in the object manager.
-	 * @param setObjectId	The id the object shall have.
-	 * @param doRegister	Determines if the object is registered in the global object manager.
-	 */
-	SystemObject(object_id_t setObjectId, bool doRegister = true);
-	/**
-	 * @brief	On destruction, the object removes itself from the list.
-	 */
-	virtual ~SystemObject();
-	object_id_t getObjectId() const;
-	virtual ReturnValue_t initialize();
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
-};
-
-#endif /* SYSTEMOBJECT_H_ */
+/**
+ * @file	SystemObject.h
+ * @brief	This file contains the definition of the SystemObject class.
+ * @date	07.11.2012
+ * @author	Ulrich Mohr
+ */
+
+#ifndef SYSTEMOBJECT_H_
+#define SYSTEMOBJECT_H_
+
+#include "../events/Event.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+
+/**
+ * @brief	This class automates insertion into the ObjectManager and
+ * 			management of the object id.
+ * @details	This class is more a base class, which shall be inherited by any
+ * 			class that is announced to ObjectManager. It automatically includes
+ * 			itself (and therefore the inheriting class) in the object manager's
+ * 			list.
+ * \ingroup system_objects
+ */
+class SystemObject: public SystemObjectIF {
+private:
+	/**
+	 * @brief	This is the id the class instant got assigned.
+	 */
+	const object_id_t objectId;
+	const bool registered;
+public:
+
+	/**
+	 * Helper function to send Event Messages to the Event Manager
+	 * @param event
+	 * @param parameter1
+	 * @param parameter2
+	 */
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	/**
+	 * @brief	The class's constructor.
+	 * @details	In the constructor, the object id is set and the class is
+	 * 			inserted in the object manager.
+	 * @param setObjectId	The id the object shall have.
+	 * @param doRegister	Determines if the object is registered in the global object manager.
+	 */
+	SystemObject(object_id_t setObjectId, bool doRegister = true);
+	/**
+	 * @brief	On destruction, the object removes itself from the list.
+	 */
+	virtual ~SystemObject();
+	object_id_t getObjectId() const;
+	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+};
+
+#endif /* SYSTEMOBJECT_H_ */
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index b7590509..54a2e866 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,62 +1,62 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-
-#include <framework/events/EventReportingProxyIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstdint>
-/**
- * @defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are
- * contained in this group. System Objects are software elements that can be
- * controlled externally. They all have a unique object identifier.
- */
-
-/**
- * This is the typedef for object identifiers.
- * @ingroup system_objects
- */
-typedef uint32_t object_id_t;
-
-/**
- * This interface allows a class to be included in the object manager
- * list.
- * It does not provide any method definitions, still it is required to
- * perform a type check with dynamic_cast.
- * @author  Bastian Baetz
- * @ingroup system_objects
- */
-class SystemObjectIF : public EventReportingProxyIF {
-public:
-	/**
-	 * This is a simple getter to return the object identifier.
-	 * @return	Returns the object id of this object.
-	 */
-	virtual object_id_t getObjectId() const = 0;
-	/**
-	 * The empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~SystemObjectIF() {}
-	/**
-	 * @brief   Initializes the object.
-	 * There are initialization steps which can also be done in the constructor.
-	 * However, there is no clean way to get a returnvalue from a constructor.
-	 * Furthermore some components require other system object to be created
-	 * which might not have been built yet.
-	 * Therefore, a two-step initialization resolves this problem and prevents
-	 * circular dependencies of not-fully initialized objects on start up.
-	 * @return	- @c RETURN_OK in case the initialization was successful
-	 * 			- @c RETURN_FAILED otherwise
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * @brief   Checks if all object-object interconnections are satisfying
-	 *          for operation.
-	 * Some objects need certain other objects (or a certain number), to be
-	 * registered as children. These checks can be done in this method.
-	 * @return	- @c RETURN_OK in case the check was successful
-	 * 			- @c any other code otherwise
-	 */
-	virtual ReturnValue_t checkObjectConnections() = 0;
-};
-
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+/**
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
+ */
+
+/**
+ * This is the typedef for object identifiers.
+ * @ingroup system_objects
+ */
+typedef uint32_t object_id_t;
+
+/**
+ * This interface allows a class to be included in the object manager
+ * list.
+ * It does not provide any method definitions, still it is required to
+ * perform a type check with dynamic_cast.
+ * @author  Bastian Baetz
+ * @ingroup system_objects
+ */
+class SystemObjectIF : public EventReportingProxyIF {
+public:
+	/**
+	 * This is a simple getter to return the object identifier.
+	 * @return	Returns the object id of this object.
+	 */
+	virtual object_id_t getObjectId() const = 0;
+	/**
+	 * The empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~SystemObjectIF() {}
+	/**
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
+	 */
+	virtual ReturnValue_t checkObjectConnections() = 0;
+};
+
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d3351888..71c0aba9 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,91 +1,91 @@
-#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
-	handle = TaskManagement::getCurrentTaskHandle();
-	if(handle == nullptr) {
-		sif::error << "Could not retrieve task handle. Please ensure the"
-				"constructor was called inside a task." << std::endl;
-	}
-	xTaskNotifyGive(handle);
-}
-
-BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
-	// Clear notification value on destruction.
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
-        TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release() {
-	return release(this->handle);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release(
-		TaskHandle_t taskHandle) {
-	if(getSemaphoreCounter(taskHandle) == 1) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	BaseType_t returncode = xTaskNotifyGive(taskHandle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		// This should never happen.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
-	return getSemaphoreCounter(this->handle);
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-// Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
-		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
-	uint32_t notificationValue = 0;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			higherPriorityTaskWoken);
-	return notificationValue;
-}
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "Could not retrieve task handle. Please ensure the"
+				"constructor was called inside a task." << std::endl;
+	}
+	xTaskNotifyGive(handle);
+}
+
+BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
+	}
+	else if(timeoutMs > SemaphoreIF::POLLING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	return acquireWithTickTimeout(timeout);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
+        TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release() {
+	return release(this->handle);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release(
+		TaskHandle_t taskHandle) {
+	if(getSemaphoreCounter(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
+	return getSemaphoreCounter(this->handle);
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 43772e5a..e6989970 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,75 +1,75 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/SemaphoreIF.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-/**
- * @brief 	Binary Semaphore implementation using the task notification value.
- * 			The notification value should therefore not be used
- * 			for other purposes.
- * @details
- * Additional information: https://www.freertos.org/RTOS-task-notifications.html
- * and general semaphore documentation.
- */
-class BinarySemaphoreUsingTask: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphoreUsingTask();
-	//! @brief Default dtor
-	virtual~ BinarySemaphoreUsingTask();
-
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::BLOCKING) override;
-	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() const override;
-	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
-			BaseType_t* higherPriorityTaskWoken);
-
-	/**
-	 * Same as acquire() with timeout in FreeRTOS ticks.
-	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::BLOCKING);
-
-	/**
-	 * Get handle to the task related to the semaphore.
-	 * @return
-	 */
-	TaskHandle_t getTaskHandle();
-
-	 /**
-	 * Wrapper function to give back semaphore from handle
-	 * @param semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t release(TaskHandle_t taskToNotify);
-
-	/**
-	 * Wrapper function to give back semaphore from handle when called from an ISR
-	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
-
-protected:
-	TaskHandle_t handle;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+/**
+ * @brief 	Binary Semaphore implementation using the task notification value.
+ * 			The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ * Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ * and general semaphore documentation.
+ */
+class BinarySemaphoreUsingTask: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphoreUsingTask();
+	//! @brief Default dtor
+	virtual~ BinarySemaphoreUsingTask();
+
+	ReturnValue_t acquire(uint32_t timeoutMs =
+	        SemaphoreIF::BLOCKING) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Same as acquire() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
+	        SemaphoreIF::BLOCKING);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	TaskHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index e6d2f92f..8e15b7a5 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,11 +1,11 @@
-#include <framework/osal/FreeRTOS/BinarySemaphore.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
-	if(handle == nullptr) {
-		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
+	if(handle == nullptr) {
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
 	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
@@ -84,7 +84,7 @@ uint8_t BinarySemaphore::getSemaphoreCounter() const {
 SemaphoreHandle_t BinarySemaphore::getSemaphore() {
 	return handle;
 }
-
+
 
 // Be careful with the stack size here. This is called from an ISR!
 ReturnValue_t BinarySemaphore::releaseFromISR(
@@ -100,4 +100,4 @@ ReturnValue_t BinarySemaphore::releaseFromISR(
 	else {
 		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
 	}
-}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 2a372cd2..4cf270de 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/SemaphoreIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index ec07b662..48d7bc07 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,196 +1,196 @@
-#include <framework/timemanager/Clock.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <framework/osal/FreeRTOS/Timekeeper.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <stdlib.h>
-#include <time.h>
-
-//TODO sanitize input?
-//TODO much of this code can be reused for tick-only systems
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
-uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-
-	timeval time_timeval;
-
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-
-	return setClock(&time_timeval);
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = *time - uptime;
-
-	Timekeeper::instance()->setOffset(offset);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = Timekeeper::instance()->getOffset();
-
-	*time = offset + uptime;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
-
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
-
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
-
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
-
-	time->usecond = time_timeval.tv_usec;
-
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
-
-		time_tm.tm_year = from->year - 1900;
-		time_tm.tm_mon = from->month - 1;
-		time_tm.tm_mday = from->day;
-
-		time_tm.tm_hour = from->hour;
-		time_tm.tm_min = from->minute;
-		time_tm.tm_sec = from->second;
-
-		time_t seconds = mktime(&time_tm);
-
-		to->tv_sec = seconds;
-		to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex() {
-	if (timeMutex == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "../../globalfunctions/timevalOperations.h"
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <stdlib.h>
+#include <time.h>
+
+//TODO sanitize input?
+//TODO much of this code can be reused for tick-only systems
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+
+uint32_t Clock::getTicksPerSecond(void) {
+	return 1000;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+
+	timeval time_timeval;
+
+	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+
+	return setClock(&time_timeval);
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = *time - uptime;
+
+	Timekeeper::instance()->setOffset(offset);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = Timekeeper::instance()->getOffset();
+
+	*time = offset + uptime;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	TickType_t ticksSinceStart = xTaskGetTickCount();
+	return Timekeeper::ticksToTimeval(ticksSinceStart);
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	struct tm time_tm;
+
+	gmtime_r(&time_timeval.tv_sec,&time_tm);
+
+	time->year = time_tm.tm_year + 1900;
+	time->month = time_tm.tm_mon + 1;
+	time->day = time_tm.tm_mday;
+
+	time->hour = time_tm.tm_hour;
+	time->minute = time_tm.tm_min;
+	time->second = time_tm.tm_sec;
+
+	time->usecond = time_timeval.tv_usec;
+
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+		time_tm.tm_year = from->year - 1900;
+		time_tm.tm_mon = from->month - 1;
+		time_tm.tm_mday = from->day;
+
+		time_tm.tm_hour = from->hour;
+		time_tm.tm_min = from->minute;
+		time_tm.tm_sec = from->second;
+
+		time_t seconds = mktime(&time_tm);
+
+		to->tv_sec = seconds;
+		to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex() {
+	if (timeMutex == NULL) {
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index f33c7a0d..333865c8 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,110 +1,110 @@
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
-		uint8_t initCount): maxCount(maxCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	handle = TaskManagement::getCurrentTaskHandle();
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
-				"handle. Please ensure the constructor was called inside a "
-				"task." << std::endl;
-	}
-
-	uint32_t oldNotificationValue;
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
-			&oldNotificationValue);
-	if(oldNotificationValue != 0) {
-		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
-				"current notification value is not 0. Please ensure the "
-				"notification value is not used for other purposes!" << std::endl;
-	}
-	for(int i = 0; i < initCount; i++) {
-		xTaskNotifyGive(handle);
-	}
-}
-
-CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
-	// Clear notification value on destruction.
-	// If this is not desired, don't call the destructor
-	// (or implement a boolean which disables the reset)
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
-
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
-		TickType_t timeoutTicks) {
-	// Decrement notfication value without resetting it.
-	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
-	if (getSemaphoreCounter() == oldCount - 1) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::release() {
-	if(getSemaphoreCounter() == maxCount) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	return release(handle);
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::release(
-		TaskHandle_t taskToNotify) {
-	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		// This should never happen.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue = 0;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
-		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
-	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
-	uint32_t notificationValue;
-	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
-			higherPriorityTaskWoken);
-	return notificationValue;
-}
-
-uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
-	return maxCount;
-}
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
+		uint8_t initCount): maxCount(maxCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
+				"handle. Please ensure the constructor was called inside a "
+				"task." << std::endl;
+	}
+
+	uint32_t oldNotificationValue;
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
+			&oldNotificationValue);
+	if(oldNotificationValue != 0) {
+		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
+				"current notification value is not 0. Please ensure the "
+				"notification value is not used for other purposes!" << std::endl;
+	}
+	for(int i = 0; i < initCount; i++) {
+		xTaskNotifyGive(handle);
+	}
+}
+
+CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	// If this is not desired, don't call the destructor
+	// (or implement a boolean which disables the reset)
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
+	}
+	else if(timeoutMs > SemaphoreIF::POLLING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	return acquireWithTickTimeout(timeout);
+
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+		TickType_t timeoutTicks) {
+	// Decrement notfication value without resetting it.
+	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (getSemaphoreCounter() == oldCount - 1) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release() {
+	if(getSemaphoreCounter() == maxCount) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return release(handle);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release(
+		TaskHandle_t taskToNotify) {
+	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
+
+uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index f1d82c1d..801e3430 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,100 +1,100 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/tasks/SemaphoreIF.h>
-
-extern "C" {
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-}
-
-/**
- * @brief 	Couting Semaphore implementation which uses the notification value
- * 			of the task. The notification value should therefore not be used
- * 			for other purposes.
- * @details
- *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
- *  and general semaphore documentation.
- */
-class CountingSemaphoreUsingTask: public SemaphoreIF {
-public:
-	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
-	virtual ~CountingSemaphoreUsingTask();
-
-	/**
-	 * Acquire the counting semaphore.
-	 * If no semaphores are available, the task will be blocked
-	 * for a maximum of #timeoutMs or until one is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
-
-	/**
-	 * Release a semaphore, increasing the number of available counting
-	 * semaphores up to the #maxCount value.
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	ReturnValue_t release() override;
-
-	uint8_t getSemaphoreCounter() const override;
-	/**
-	 * Get the semaphore counter from an ISR.
-	 * @param task
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return
-	 */
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
-			BaseType_t* higherPriorityTaskWoken);
-
-	/**
-	 * Acquire with a timeout value in ticks
-	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
-
-	/**
-	 * Get handle to the task related to the semaphore.
-	 * @return
-	 */
-	TaskHandle_t getTaskHandle();
-
-	/**
-	 * Release semaphore of task by supplying task handle
-	 * @param taskToNotify
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	static ReturnValue_t release(TaskHandle_t taskToNotify);
-	/**
-	 * Release seamphore of a task from an ISR.
-	 * @param taskToNotify
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-			BaseType_t* higherPriorityTaskWoken);
-
-	uint8_t getMaxCount() const;
-
-private:
-	TaskHandle_t handle;
-	const uint8_t maxCount;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreIF.h"
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+/**
+ * @brief 	Couting Semaphore implementation which uses the notification value
+ * 			of the task. The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ *  and general semaphore documentation.
+ */
+class CountingSemaphoreUsingTask: public SemaphoreIF {
+public:
+	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
+	virtual ~CountingSemaphoreUsingTask();
+
+	/**
+	 * Acquire the counting semaphore.
+	 * If no semaphores are available, the task will be blocked
+	 * for a maximum of #timeoutMs or until one is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
+
+	/**
+	 * Release a semaphore, increasing the number of available counting
+	 * semaphores up to the #maxCount value.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	uint8_t getSemaphoreCounter() const override;
+	/**
+	 * Get the semaphore counter from an ISR.
+	 * @param task
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return
+	 */
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Acquire with a timeout value in ticks
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	/**
+	 * Release semaphore of task by supplying task handle
+	 * @param taskToNotify
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+	/**
+	 * Release seamphore of a task from an ISR.
+	 * @param taskToNotify
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+			BaseType_t* higherPriorityTaskWoken);
+
+	uint8_t getMaxCount() const;
+
+private:
+	TaskHandle_t handle;
+	const uint8_t maxCount;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 957f6a31..0b218e54 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,43 +1,43 @@
-#include <framework/osal/FreeRTOS/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-
-#include <freertos/semphr.h>
-
-// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
-// free FreeRTOSConfig.h file.
-CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
-		maxCount(maxCount), initCount(initCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	handle = xSemaphoreCreateCounting(maxCount, initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-}
-
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
-		maxCount(other.maxCount), initCount(other.initCount) {
-	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-}
-
-CountingSemaphore& CountingSemaphore::operator =(
-		CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-	return * this;
-}
-
-
-uint8_t CountingSemaphore::getMaxCount() const {
-	return maxCount;
-}
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/semphr.h>
+
+// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
+// free FreeRTOSConfig.h file.
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = xSemaphoreCreateCounting(maxCount, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}
+
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index dca3ab0e..9432ed81 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include <framework/osal/FreeRTOS/BinarySemaphore.h>
-
-/**
- * @brief 	Counting semaphores, which can be acquire more than once.
- * @details
- * See: https://www.freertos.org/CreateCounting.html
- * API of counting semaphores is almost identical to binary semaphores,
- * so we just inherit from binary semaphore and provide the respective
- * constructors.
- */
-class CountingSemaphore: public BinarySemaphore {
-public:
-	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
-	//! @brief Copy ctor, disabled
-	CountingSemaphore(const CountingSemaphore&) = delete;
-	//! @brief Copy assignment, disabled
-	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
-	//! @brief Move ctor
-	CountingSemaphore (CountingSemaphore &&);
-	//! @brief Move assignment
-	CountingSemaphore & operator=(CountingSemaphore &&);
-
-	/* Same API as binary semaphore otherwise. acquire() can be called
-	 * until there are not semaphores left and release() can be called
-	 * until maxCount is reached. */
-	uint8_t getMaxCount() const;
-private:
-	const uint8_t maxCount;
-	uint8_t initCount = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquire more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 2a7bff9c..769f31e1 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,162 +1,162 @@
-#include "FixedTimeslotTask.h"
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
-
-FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod overallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(NULL), pst(overallPeriod * 1000) {
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-
-	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
-    // global, so it is found from any place.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the
-    // start time for the first entry.
-	auto slotListIter = pst.current;
-
-	//The start time for the first entry is read.
-	uint32_t intervalMs = slotListIter->pollingTimeMs;
-	TickType_t interval = pdMS_TO_TICKS(intervalMs);
-
-	TickType_t xLastWakeTime;
-	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to
-	 explicitly. After this assignment, xLastWakeTime is updated automatically
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-
-	// wait for first entry's start time
-	if(interval > 0) {
-	    vTaskDelayUntil(&xLastWakeTime, interval);
-	}
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		//The component for this slot is executed and the next one is chosen.
-	    this->pst.executeAndAdvance();
-	    if (not pst.slotFollowsImmediately()) {
-	        // Get the interval till execution of the next slot.
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
-
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
-	    }
-	}
-}
-
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskHandle_t FixedTimeslotTask::getTaskHandle() {
-    return handle;
-}
+#include "FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
+
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod overallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), handle(NULL), pst(overallPeriod * 1000) {
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	auto slotListIter = pst.current;
+
+	//The start time for the first entry is read.
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
+	TickType_t interval = pdMS_TO_TICKS(intervalMs);
+
+	TickType_t xLastWakeTime;
+	/* The xLastWakeTime variable needs to be initialized with the current tick
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+
+	// wait for first entry's start time
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		//The component for this slot is executed and the next one is chosen.
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
+	        checkMissedDeadline(xLastWakeTime, interval);
+
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
+	}
+}
+
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 36950773..42af14b8 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,101 +1,101 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-
-#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
-public:
-
-	/**
-	 * Keep in mind that you need to call before vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param setPriority Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param setStack	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param overallPeriod		Period in seconds.
-	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
-	 */
-	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-			TaskStackSize setStack, TaskPeriod overallPeriod,
-			void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 * @details
-	 * The destructor frees all heap memory that was allocated on thread
-	 * initialization for the PST and the device handlers. This is done by
-	 * calling the PST's destructor.
-	 */
-	virtual ~FixedTimeslotTask(void);
-
-	ReturnValue_t startTask(void);
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines
-	 * every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t checkSequence() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when
-	 *          a deadline was missed.
-	 * @details
-	 * Another function may be announced to determine the actions to perform
-	 * when a deadline was missed. Currently, only one function for missing
-	 * any deadline is allowed. If not used, it shall be declared NULL.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the entry point for a new task.
-	 * @details
-	 * This method starts the task by calling taskFunctionality(), as soon as
-	 * all requirements (task scheduler has started and startTask()
-	 * has been called) are met.
-	 */
-	static void taskEntryPoint(void* argument);
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Core function holding the main functionality of the task
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
+public:
+
+	/**
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
+	 */
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+			TaskStackSize setStack, TaskPeriod overallPeriod,
+			void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
+	 */
+	virtual ~FixedTimeslotTask(void);
+
+	ReturnValue_t startTask(void);
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t checkSequence() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
+	 */
+	static void taskEntryPoint(void* argument);
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e9f3871e..3b335ffc 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include <framework/osal/FreeRTOS/MessageQueue.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-// TODO I guess we should have a way of checking if we are in an ISR and then
-// use the "fromISR" versions of all calls
-// As a first step towards this, introduces system context variable which needs
-// to be switched manually
-// Haven't found function to find system context.
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		maxMessageSize(maxMessageSize) {
-	handle = xQueueCreate(messageDepth, maxMessageSize);
-	if (handle == NULL) {
-		sif::error << "MessageQueue: Creation failed" << std::endl;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	if (handle != NULL) {
-		vQueueDelete(handle);
-	}
-}
-
-void MessageQueue::switchSystemContext(CallContext callContext) {
-	this->callContext = callContext;
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
-	        callContext);
-}
-
-
-ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
-	if (result != pdPASS) {
-		if (not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != nullptr) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		return MessageQueueIF::FULL;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	if(status == HasReturnvaluesIF::RETURN_OK) {
-		*receivedFrom = this->lastPartner;
-	}
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
-			message->getBuffer()), 0);
-	if (result == pdPASS){
-		this->lastPartner = message->getSender();
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MessageQueueIF::EMPTY;
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	//TODO FreeRTOS does not support flushing partially
-	//Is always successful
-	xQueueReset(handle);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return reinterpret_cast<MessageQueueId_t>(handle);
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	defaultDestinationSet = true;
-	this->defaultDestination = defaultDestination;
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return defaultDestinationSet;
-}
-
-
-// static core function to send messages.
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-        bool ignoreFault, CallContext callContext) {
-	BaseType_t result = pdFALSE;
-	QueueHandle_t destination = nullptr;
-
-	if(sendTo == MessageQueueIF::NO_QUEUE) {
-		return MessageQueueIF::DESTINVATION_INVALID;
-	}
-	else  {
-		destination = reinterpret_cast<QueueHandle_t>(sendTo);
-	}
-    message->setSender(sentFrom);
-
-
-    if(callContext == CallContext::TASK) {
-        result = xQueueSendToBack(destination,
-                static_cast<const void*>(message->getBuffer()), 0);
-    }
-    else {
-        /* If the call context is from an interrupt,
-         * request a context switch if a higher priority task
-         * was blocked by the interrupt. */
-        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
-                static_cast<const void*>(message->getBuffer()),
-                &xHigherPriorityTaskWoken);
-        if(xHigherPriorityTaskWoken == pdTRUE) {
-            TaskManagement::requestContextSwitch(callContext);
-        }
-    }
-    return handleSendResult(result, ignoreFault);
-}
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+// TODO I guess we should have a way of checking if we are in an ISR and then
+// use the "fromISR" versions of all calls
+// As a first step towards this, introduces system context variable which needs
+// to be switched manually
+// Haven't found function to find system context.
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		maxMessageSize(maxMessageSize) {
+	handle = xQueueCreate(messageDepth, maxMessageSize);
+	if (handle == NULL) {
+		sif::error << "MessageQueue: Creation failed" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	if (handle != NULL) {
+		vQueueDelete(handle);
+	}
+}
+
+void MessageQueue::switchSystemContext(CallContext callContext) {
+	this->callContext = callContext;
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault,
+	        callContext);
+}
+
+
+ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
+	if (result != pdPASS) {
+		if (not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		return MessageQueueIF::FULL;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	BaseType_t result = xQueueReceive(handle,reinterpret_cast<void*>(
+			message->getBuffer()), 0);
+	if (result == pdPASS){
+		this->lastPartner = message->getSender();
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MessageQueueIF::EMPTY;
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	//TODO FreeRTOS does not support flushing partially
+	//Is always successful
+	xQueueReset(handle);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return reinterpret_cast<MessageQueueId_t>(handle);
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
+	this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return defaultDestinationSet;
+}
+
+
+// static core function to send messages.
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault, CallContext callContext) {
+	BaseType_t result = pdFALSE;
+	QueueHandle_t destination = nullptr;
+
+	if(sendTo == MessageQueueIF::NO_QUEUE) {
+		return MessageQueueIF::DESTINVATION_INVALID;
+	}
+	else  {
+		destination = reinterpret_cast<QueueHandle_t>(sendTo);
+	}
+    message->setSender(sentFrom);
+
+
+    if(callContext == CallContext::TASK) {
+        result = xQueueSendToBack(destination,
+                static_cast<const void*>(message->getBuffer()), 0);
+    }
+    else {
+        /* If the call context is from an interrupt,
+         * request a context switch if a higher priority task
+         * was blocked by the interrupt. */
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        result = xQueueSendFromISR(reinterpret_cast<QueueHandle_t>(sendTo),
+                static_cast<const void*>(message->getBuffer()),
+                &xHigherPriorityTaskWoken);
+        if(xHigherPriorityTaskWoken == pdTRUE) {
+            TaskManagement::requestContextSwitch(callContext);
+        }
+    }
+    return handleSendResult(result, ignoreFault);
+}
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b7e52bb3..48a5ab6a 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,212 +1,212 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessageIF.h>
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-
-// TODO: this class assumes that MessageQueueId_t is the same size as void*
-// (the FreeRTOS handle type), compiler will catch this but it might be nice
-// to have something checking or even an always working solution
-// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
-
-/**
- * @brief		This class manages sending and receiving of
- * 				message queue messages.
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- * For creating the queue, as well as sending and receiving messages, the class
- * makes use of the operating system calls provided.
- *
- * Please keep in mind that FreeRTOS offers different calls for message queue
- * operations if called from an ISR.
- * For now, the system context needs to be switched manually.
- * @ingroup osal
- * @ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details
-	 * By making use of the according operating system call, a message queue is created
-	 * and initialized. The message depth - the maximum number of messages to be
-	 * buffered - may be set with the help of a parameter, whereas the message size is
-	 * automatically set to the maximum message queue message size. The operating system
-	 * sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth
-	 * The number of messages to be buffered before passing an error to the
-	 * sender. Default is three.
-	 * @param max_message_size
-	 * With this parameter, the maximum message size can be adjusted.
-	 * This should be left default.
-	 */
-	MessageQueue( size_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-
-	/** Copying message queues forbidden */
-	MessageQueue(const MessageQueue&) = delete;
-	MessageQueue& operator=(const MessageQueue&) = delete;
-
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided
-	 * 			by the operating system.
-	 */
-	virtual ~MessageQueue();
-
-	/**
-	 * This function is used to switch the call context. This has to be called
-	 * if a message is sent or received from an ISR!
-	 * @param callContext
-	 */
-	void switchSystemContext(CallContext callContext);
-
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-
-	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * @details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send the message to.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	The sendToDefault method sends a queue message to the default destination.
-	 * @details	In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-protected:
-	/**
-	 * @brief 	Implementation to be called from any send Call within
-	 * 			MessageQueue and MessageQueueSenderIF.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 * The OS's return value is returned.
-	 * @param sendTo
-	 * This parameter specifies the message queue id to send the message to.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id into
-	 * the message. This variable is set to zero by default.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter  is not incremented
-	 * if queue is full.
-	 * @param context Specify whether call is made from task or from an ISR.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
-
-	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	bool defaultDestinationSet = false;
-	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-	const size_t maxMessageSize;
-	//!< Stores the current system context
-	CallContext callContext =  CallContext::TASK;
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+// TODO: this class assumes that MessageQueueId_t is the same size as void*
+// (the FreeRTOS handle type), compiler will catch this but it might be nice
+// to have something checking or even an always working solution
+// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue is created
+	 * and initialized. The message depth - the maximum number of messages to be
+	 * buffered - may be set with the help of a parameter, whereas the message size is
+	 * automatically set to the maximum message queue message size. The operating system
+	 * sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue( size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
+	void switchSystemContext(CallContext callContext);
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * @details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send the message to.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	The sendToDefault method sends a queue message to the default destination.
+	 * @details	In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * 			message's content is cleared and the function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	bool defaultDestinationSet = false;
+	QueueHandle_t handle;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
+	//!< Stores the current system context
+	CallContext callContext =  CallContext::TASK;
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 764b0ae0..8d2e43b8 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,51 +1,51 @@
-#include <framework/osal/FreeRTOS/Mutex.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Mutex::Mutex() {
-	handle = xSemaphoreCreateMutex();
-	if(handle == nullptr) {
-		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	if (handle != nullptr) {
-		vSemaphoreDelete(handle);
-	}
-
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	// If the timeout type is BLOCKING, this will be the correct value.
-	uint32_t timeout = portMAX_DELAY;
-	if(timeoutType == TimeoutType::POLLING) {
-		timeout = 0;
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::MUTEX_TIMEOUT;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	BaseType_t returncode = xSemaphoreGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-}
+#include "../../osal/FreeRTOS/Mutex.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+Mutex::Mutex() {
+	handle = xSemaphoreCreateMutex();
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	if (handle != nullptr) {
+		vSemaphoreDelete(handle);
+	}
+
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::MUTEX_TIMEOUT;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+}
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 2a4fae26..5cbc6a72 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
-#define FRAMEWORK_FREERTOS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @brief OS component to implement MUTual EXclusion
- *
- * @details
- * Mutexes are binary semaphores which include a priority inheritance mechanism.
- * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
- * @ingroup osal
- */
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(TimeoutType timeoutType,
-	        uint32_t timeoutMs) override;
-	ReturnValue_t unlockMutex() override;
-
-private:
-	SemaphoreHandle_t handle;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index a1cca54b..9dcd8536 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/FreeRTOS/Mutex.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory.
-//What's better and why? -> one is on heap the other on bss/data
-//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = nullptr;
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new MutexFactory();
-	}
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/FreeRTOS/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index c316d4fc..662ece3b 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,138 +1,138 @@
-#include "PeriodicTask.h"
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		TaskDeadlineMissedFunction deadlineMissedFunc) :
-		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		deadlineMissedFunc)
-{
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			stackSize, this, setPriority, &handle);
-	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
-		        "Status: " << status << std::endl;
-	}
-
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	// The argument is re-interpreted as PeriodicTask. The Task object is
-    // global, so it is found from any place.
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicTask::taskFunctionality() {
-	TickType_t xLastWakeTime;
-	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
-	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to
-	 explicitly. After this assignment, xLastWakeTime is updated automatically
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		for (auto const& object: objectList) {
-			object->performOperation();
-		}
-
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implement ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-TaskHandle_t PeriodicTask::getTaskHandle() {
-    return handle;
-}
-
-void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
+		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
+		deadlineMissedFunc)
+{
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			stackSize, this, setPriority, &handle);
+	if(status != pdPASS){
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
+	}
+
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	TickType_t xLastWakeTime;
+	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
+	/* The xLastWakeTime variable needs to be initialized with the current tick
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		for (auto const& object: objectList) {
+			object->performOperation();
+		}
+
+		checkMissedDeadline(xLastWakeTime, xPeriod);
+
+		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+TaskHandle_t PeriodicTask::getTaskHandle() {
+    return handle;
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 8030baad..1cdc3df7 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,128 +1,128 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-
-#include <framework/osal/FreeRTOS/FreeRTOSTaskIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @ingroup task_handling
- */
-class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
-public:
-	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * TODO: why does this need to be called before vTaskStartScheduler?
-	 * @details
-	 * The class is initialized without allocated objects.
-	 * These need to be added with #addComponent.
-	 * @param priority
-	 * Sets the priority of a task. Values depend on freeRTOS configuration,
-	 * high number means high priority.
-	 * @param stack_size
-	 * The stack size reserved by the operating system for the task.
-	 * @param setPeriod
-	 * The length of the period with which the task's
-	 * functionality will be executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall
-	 * be assigned.
-	 */
-	PeriodicTask(TaskName name, TaskPriority setPriority,
-	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        TaskDeadlineMissedFunction deadlineMissedFunc);
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with
-	 * 			the task object's lifetime, so the destructor is empty.
-	 */
-	virtual ~PeriodicTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask() override;
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return
-	 * -@c RETURN_OK on success
-	 * -@c RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	//! Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details
-	 * The period determines the frequency of the task's execution.
-	 * It is expressed in clock ticks.
-	 */
-	TaskPeriod period;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details
-	 * This pointer stores the function that is executed if the task's deadline
-	 * is missed so each may react individually on a timing failure.
-	 * The pointer may be NULL, then nothing happens on missing the deadline.
-	 * The deadline is equal to the next execution of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details
-	 * It converts the argument back to the thread object type and copies the
-	 * class instance to the task context. The taskFunctionality method is
-	 * called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-
-	static void taskEntryPoint(void* argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details
-	 * The method sets and starts the task's period, then enters a loop that is
-	 * repeated as long as the isRunning attribute is true. Within the loop,
-	 * all performOperation methods of the added objects are called.
-	 * Afterwards the checkAndRestartPeriod system call blocks the task until
-	 * the next period.
-	 * On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* PERIODICTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
+public:
+	/**
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * TODO: why does this need to be called before vTaskStartScheduler?
+	 * @details
+	 * The class is initialized without allocated objects.
+	 * These need to be added with #addComponent.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall
+	 * be assigned.
+	 */
+	PeriodicTask(TaskName name, TaskPriority setPriority,
+	        TaskStackSize setStack, TaskPeriod setPeriod,
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask() override;
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 * -@c RETURN_OK on success
+	 * -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed so each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context. The taskFunctionality method is
+	 * called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	static void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called.
+	 * Afterwards the checkAndRestartPeriod system call blocks the task until
+	 * the next period.
+	 * On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index beb4969b..05091733 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,36 +1,36 @@
-#include <framework/ipc/QueueFactory.h>
-
-#include <framework/osal/FreeRTOS/MessageQueue.h>
-
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 78427f6c..453f2226 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,61 +1,61 @@
-#include <framework/osal/FreeRTOS/BinarySemaphore.h>
-#include <framework/osal/FreeRTOS/BinSemaphUsingTask.h>
-#include <framework/osal/FreeRTOS/CountingSemaphore.h>
-#include <framework/osal/FreeRTOS/CountingSemaphUsingTask.h>
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
-
-static const uint32_t USE_REGULAR_SEMAPHORES = 0;
-static const uint32_t USE_TASK_NOTIFICATIONS = 1;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new BinarySemaphore();
-	}
-	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new BinarySemaphoreUsingTask();
-	}
-	else {
-		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
-				"binary semaphore" << std::endl;
-		return new BinarySemaphore();
-	}
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
-		uint8_t initCount, uint32_t argument) {
-	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new CountingSemaphore(maxCount, initCount);
-	}
-	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new CountingSemaphoreUsingTask(maxCount, initCount);
-	}
-	else {
-		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
-						"binary semaphore" << std::endl;
-		return new CountingSemaphore(maxCount, initCount);
-	}
-
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
+
+static const uint32_t USE_REGULAR_SEMAPHORES = 0;
+static const uint32_t USE_TASK_NOTIFICATIONS = 1;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new BinarySemaphore();
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new BinarySemaphoreUsingTask();
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+				"binary semaphore" << std::endl;
+		return new BinarySemaphore();
+	}
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
+		uint8_t initCount, uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new CountingSemaphore(maxCount, initCount);
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new CountingSemaphoreUsingTask(maxCount, initCount);
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+						"binary semaphore" << std::endl;
+		return new CountingSemaphore(maxCount, initCount);
+	}
+
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index 68866f39..b68b05b3 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -1,53 +1,53 @@
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include "PeriodicTask.h"
-#include "FixedTimeslotTask.h"
-
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
-}
-
-/**
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- */
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
-			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == nullptr) {
-		//delete self
-		vTaskDelete(nullptr);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		//TODO not implemented
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+#include "PeriodicTask.h"
+#include "FixedTimeslotTask.h"
+
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
+}
+
+/**
+ * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ */
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	if (task == nullptr) {
+		//delete self
+		vTaskDelete(nullptr);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		//TODO not implemented
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index ff552adb..16682d36 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,11 +1,11 @@
-#include <framework/osal/FreeRTOS/TaskManagement.h>
-
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
 void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
 }
-
+
 void TaskManagement::requestContextSwitch(
-		CallContext callContext = CallContext::TASK) {
+		CallContext callContext = CallContext::TASK) {
 	if(callContext == CallContext::ISR) {
 		// This function depends on the partmacro.h definition for the specific device
 		vRequestContextSwitchFromISR();
@@ -13,7 +13,7 @@ void TaskManagement::requestContextSwitch(
 		vRequestContextSwitchFromTask();
 	}
 }
-
+
 TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 	return xTaskGetCurrentTaskHandle();
 }
@@ -21,4 +21,4 @@ TaskHandle_t TaskManagement::getCurrentTaskHandle() {
 size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
 	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
-}
+}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 62c68331..43003d76 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 #define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 }
 #include <cstdint>
-
+
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
@@ -17,9 +17,9 @@ extern void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
- * within an ISR or from a regular task. This is required because FreeRTOS
+ * within an ISR or from a regular task. This is required because FreeRTOS
  * has different functions for handling semaphores and messages from within
- * an ISR and task.
+ * an ISR and task.
  */
 enum class CallContext {
 	TASK = 0x00,//!< task_context
@@ -29,19 +29,19 @@ enum class CallContext {
 
 class TaskManagement {
 public:
-	/**
+	/**
 	 * @brief	In this function, a function dependant on the portmacro.h header
 	 * 			function calls to request a context switch can be specified.
 	 * This can be used if sending to the queue from an ISR caused a task
-	 * to unblock and a context switch is required.
+	 * to unblock and a context switch is required.
 	 */
 	static void requestContextSwitch(CallContext callContext);
 
 	/**
 	 * If task preemption in FreeRTOS is disabled, a context switch
 	 * can be requested manually by calling this function.
-	 */
-	static void vRequestContextSwitchFromTask(void);
+	 */
+	static void vRequestContextSwitchFromTask(void);
 
 	/**
 	 * @return The current task handle
@@ -56,9 +56,9 @@ public:
 	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
 	 * @return Smallest value of stack remaining since the task was started in
 	 * 		   words.
-	 */
+	 */
 	static size_t getTaskStackHighWatermark(
-	        TaskHandle_t task = nullptr);
+	        TaskHandle_t task = nullptr);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 643b2747..f7a3c8f8 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,41 +1,41 @@
-#include <framework/osal/FreeRTOS/Timekeeper.h>
-
-#include "FreeRTOSConfig.h"
-
-Timekeeper * Timekeeper::myinstance = nullptr;
-
-Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
-
-Timekeeper::~Timekeeper() {}
-
-const timeval& Timekeeper::getOffset() const {
-	return offset;
-}
-
-Timekeeper* Timekeeper::instance() {
-	if (myinstance == nullptr) {
-		myinstance = new Timekeeper();
-	}
-	return myinstance;
-}
-
-void Timekeeper::setOffset(const timeval& offset) {
-	this->offset = offset;
-}
-
-timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
-	timeval uptime;
-	uptime.tv_sec = ticks / configTICK_RATE_HZ;
-
-	//TODO explain, think about overflow
-	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
-	uint64_t usecondTicks = subsecondTicks * 1000000;
-
-	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
-
-	return uptime;
-}
-
-TickType_t Timekeeper::getTicks() {
-    return xTaskGetTickCount();
-}
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include "FreeRTOSConfig.h"
+
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
+
+const timeval& Timekeeper::getOffset() const {
+	return offset;
+}
+
+Timekeeper* Timekeeper::instance() {
+	if (myinstance == nullptr) {
+		myinstance = new Timekeeper();
+	}
+	return myinstance;
+}
+
+void Timekeeper::setOffset(const timeval& offset) {
+	this->offset = offset;
+}
+
+timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
+	timeval uptime;
+	uptime.tv_sec = ticks / configTICK_RATE_HZ;
+
+	//TODO explain, think about overflow
+	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
+	uint64_t usecondTicks = subsecondTicks * 1000000;
+
+	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
+
+	return uptime;
+}
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index 7d3ca22b..fc1664e2 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-
-#include <framework/timemanager/Clock.h>
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-
-/**
- * A Class to basically store the time difference between uptime and UTC
- * so the "time-agnostic" FreeRTOS can keep an UTC Time
- *
- * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
- * can use it without having a member.
- */
-
-class Timekeeper {
-private:
-	Timekeeper();
-
-	timeval offset;
-
-	static Timekeeper * myinstance;
-public:
-	static Timekeeper * instance();
-	virtual ~Timekeeper();
-
-	static timeval ticksToTimeval(TickType_t ticks);
-    /**
-     * Get elapsed time in system ticks.
-     * @return
-     */
-    static TickType_t getTicks();
-
-	const timeval& getOffset() const;
-	void setOffset(const timeval& offset);
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+
+#include "../../timemanager/Clock.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+
+/**
+ * A Class to basically store the time difference between uptime and UTC
+ * so the "time-agnostic" FreeRTOS can keep an UTC Time
+ *
+ * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
+ * can use it without having a member.
+ */
+
+class Timekeeper {
+private:
+	Timekeeper();
+
+	timeval offset;
+
+	static Timekeeper * myinstance;
+public:
+	static Timekeeper * instance();
+	virtual ~Timekeeper();
+
+	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
+
+	const timeval& getOffset() const;
+	void setOffset(const timeval& offset);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
diff --git a/osal/InternalErrorCodes.h b/osal/InternalErrorCodes.h
index 5419fd94..d89eb230 100644
--- a/osal/InternalErrorCodes.h
+++ b/osal/InternalErrorCodes.h
@@ -1,39 +1,39 @@
-#ifndef INTERNALERRORCODES_H_
-#define INTERNALERRORCODES_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-class InternalErrorCodes {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
-
-static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
-static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
-static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
-static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
-static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
-static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
-static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
-static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
-static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
-static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
-static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
-static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
-static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
-static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
-static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
-static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
-static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
-static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
-static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
-static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
-static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
-
-	virtual ~InternalErrorCodes();
-
-	static ReturnValue_t translate(uint8_t code);
-private:
-	InternalErrorCodes();
-};
-
-#endif /* INTERNALERRORCODES_H_ */
+#ifndef INTERNALERRORCODES_H_
+#define INTERNALERRORCODES_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class InternalErrorCodes {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
+
+static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
+static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
+static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
+static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
+static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
+static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
+static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
+static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
+static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
+static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
+static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
+static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
+static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
+static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
+static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
+static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
+static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
+static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
+static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
+static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
+static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
+
+	virtual ~InternalErrorCodes();
+
+	static ReturnValue_t translate(uint8_t code);
+private:
+	InternalErrorCodes();
+};
+
+#endif /* INTERNALERRORCODES_H_ */
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 57f2572b..52d0d5f0 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -1,227 +1,227 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/Clock.h>
-
-#include <chrono>
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <fstream>
-#endif
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-using SystemClock = std::chrono::system_clock;
-
-uint32_t Clock::getTicksPerSecond(void){
-	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
-	return 0;
-	//return CLOCKS_PER_SEC;
-	//uint32_t ticks = sysconf(_SC_CLK_TCK);
-	//return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	// do some magic with chrono
-	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	// do some magic with chrono
-#if defined(WIN32)
-	return HasReturnvaluesIF::RETURN_OK;
-#elif defined(LINUX)
-	return HasReturnvaluesIF::RETURN_OK;
-#else
-
-#endif
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-#if defined(WIN32)
-	auto now  = std::chrono::system_clock::now();
-	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
-	auto epoch = now.time_since_epoch();
-	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
-	auto fraction = now - secondsChrono;
-	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
-	        fraction).count();
-	return HasReturnvaluesIF::RETURN_OK;
-#elif defined(LINUX)
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	time->tv_sec = timeUnix.tv_sec;
-	time->tv_usec = timeUnix.tv_nsec / 1000.0;
-	return HasReturnvaluesIF::RETURN_OK;
-#else
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-#endif
-
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	// do some magic with chrono
-	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval timeval;
-#if defined(WIN32)
-	auto uptime  = std::chrono::milliseconds(GetTickCount64());
-	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
-	timeval.tv_sec = secondsChrono.count();
-	auto fraction = uptime - secondsChrono;
-	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
-	            fraction).count();
-#elif defined(LINUX)
-	double uptimeSeconds;
-	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
-	{
-		// value is rounded down automatically
-		timeval.tv_sec = uptimeSeconds;
-		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
-	}
-#else
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-#endif
-	return timeval;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	// do some magic with chrono (C++20!)
-	// Right now, the library doesn't have the new features yet.
-	// so we work around that for now.
-	auto now = SystemClock::now();
-	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
-	auto fraction = now - seconds;
-	time_t tt = SystemClock::to_time_t(now);
-	struct tm* timeInfo;
-	timeInfo = gmtime(&tt);
-	time->year = timeInfo->tm_year + 1900;
-	time->month = timeInfo->tm_mon+1;
-	time->day = timeInfo->tm_mday;
-	time->hour = timeInfo->tm_hour;
-	time->minute = timeInfo->tm_min;
-	time->second = timeInfo->tm_sec;
-	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
-	time->usecond = usecond.count();
-
-	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
-
-	time_tm.tm_year = from->year - 1900;
-	time_tm.tm_mon = from->month - 1;
-	time_tm.tm_mday = from->day;
-
-	time_tm.tm_hour = from->hour;
-	time_tm.tm_min = from->minute;
-	time_tm.tm_sec = from->second;
-
-	time_t seconds = mktime(&time_tm);
-
-	to->tv_sec = seconds;
-	to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
-	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex == nullptr){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex == nullptr){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == nullptr) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == nullptr) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <chrono>
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <fstream>
+#endif
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+using SystemClock = std::chrono::system_clock;
+
+uint32_t Clock::getTicksPerSecond(void){
+	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+	return 0;
+	//return CLOCKS_PER_SEC;
+	//uint32_t ticks = sysconf(_SC_CLK_TCK);
+	//return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	// do some magic with chrono
+#if defined(WIN32)
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+
+#endif
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+#if defined(WIN32)
+	auto now  = std::chrono::system_clock::now();
+	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto epoch = now.time_since_epoch();
+	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
+	auto fraction = now - secondsChrono;
+	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	        fraction).count();
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval timeval;
+#if defined(WIN32)
+	auto uptime  = std::chrono::milliseconds(GetTickCount64());
+	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
+	timeval.tv_sec = secondsChrono.count();
+	auto fraction = uptime - secondsChrono;
+	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	            fraction).count();
+#elif defined(LINUX)
+	double uptimeSeconds;
+	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
+	{
+		// value is rounded down automatically
+		timeval.tv_sec = uptimeSeconds;
+		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
+	}
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
+	return timeval;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// do some magic with chrono (C++20!)
+	// Right now, the library doesn't have the new features yet.
+	// so we work around that for now.
+	auto now = SystemClock::now();
+	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto fraction = now - seconds;
+	time_t tt = SystemClock::to_time_t(now);
+	struct tm* timeInfo;
+	timeInfo = gmtime(&tt);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
+	time->usecond = usecond.count();
+
+	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+	time_tm.tm_year = from->year - 1900;
+	time_tm.tm_mon = from->month - 1;
+	time_tm.tm_mday = from->day;
+
+	time_tm.tm_hour = from->hour;
+	time_tm.tm_min = from->minute;
+	time_tm.tm_sec = from->second;
+
+	time_t seconds = mktime(&time_tm);
+
+	to->tv_sec = seconds;
+	to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex == nullptr){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex == nullptr){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index dac399f6..1999c9e6 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,191 +1,191 @@
-#include <framework/osal/host/FixedTimeslotTask.h>
-
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/host/Mutex.h>
-#include <framework/osal/host/FixedTimeslotTask.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-
-#include <thread>
-#include <chrono>
-
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <pthread.h>
-#endif
-
-FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
-        TaskStackSize setStack, TaskPeriod setPeriod,
-        void (*setDeadlineMissedFunc)()) :
-        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
-        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
-    // It is propably possible to set task priorities by using the native
-    // task handles for Windows / Linux
-    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
-#endif
-}
-
-FixedTimeslotTask::~FixedTimeslotTask(void) {
-    //Do not delete objects, we were responsible for ptrs only.
-    terminateThread = true;
-    if(mainThread.joinable()) {
-        mainThread.join();
-    }
-    delete this;
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-
-    if (not originalTask->started) {
-        // we have to suspend/block here until the task is started.
-        // if semaphores are implemented, use them here.
-        std::unique_lock<std::mutex> lock(initMutex);
-        initCondition.wait(lock);
-    }
-
-    this->taskFunctionality();
-    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
-            "Returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-    started = true;
-
-    // Notify task to start.
-    std::lock_guard<std::mutex> lock(initMutex);
-    initCondition.notify_one();
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-    // A local iterator for the Polling Sequence Table is created to
-    // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
-    // Get start time for first entry.
-    chron_ms interval(slotListIter->pollingTimeMs);
-    auto currentStartTime {
-            std::chrono::duration_cast<chron_ms>(
-            std::chrono::system_clock::now().time_since_epoch())
-    };
-    if(interval.count() > 0) {
-        delayForInterval(&currentStartTime, interval);
-    }
-
-    /* Enter the loop that defines the task behavior. */
-    for (;;) {
-        if(terminateThread.load()) {
-            break;
-        }
-        //The component for this slot is executed and the next one is chosen.
-        this->pollingSeqTable.executeAndAdvance();
-        if (not pollingSeqTable.slotFollowsImmediately()) {
-            // we need to wait before executing the current slot
-            //this gives us the time to wait:
-            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
-            delayForInterval(&currentStartTime, interval);
-            //TODO deadline missed check
-        }
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-        uint32_t slotTimeMs, int8_t executionStep) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    sif::error << "Component " << std::hex << componentId <<
-            " not found, not adding it to pst" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-    return pollingSeqTable.checkSequence();
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-    return period * 1000;
-}
-
-bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
-        const chron_ms interval) {
-    bool shouldDelay = false;
-    //Get current wakeup time
-    auto currentStartTime =
-            std::chrono::duration_cast<chron_ms>(
-            std::chrono::system_clock::now().time_since_epoch());
-    /* Generate the tick time at which the task wants to wake. */
-    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
-
-    if (currentStartTime < *previousWakeTimeMs) {
-        /* The tick count has overflowed since this function was
-         lasted called.  In this case the only time we should ever
-         actually delay is if the wake time has also    overflowed,
-         and the wake time is greater than the tick time.  When this
-         is the case it is as if neither time had overflowed. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                && (nextTimeToWake_ms > currentStartTime)) {
-            shouldDelay = true;
-        }
-    } else {
-        /* The tick time has not overflowed.  In this case we will
-         delay if either the wake time has overflowed, and/or the
-         tick time is less than the wake time. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                || (nextTimeToWake_ms >  currentStartTime)) {
-            shouldDelay = true;
-        }
-    }
-
-    /* Update the wake time ready for the next call. */
-
-    (*previousWakeTimeMs) =  nextTimeToWake_ms;
-
-    if (shouldDelay) {
-        auto sleepTime = std::chrono::duration_cast<chron_ms>(
-                nextTimeToWake_ms - currentStartTime);
-        std::this_thread::sleep_for(sleepTime);
-        return true;
-    }
-    //We are shifting the time in case the deadline was missed like rtems
-    (*previousWakeTimeMs) = currentStartTime;
-    return false;
-
-}
-
-
-
-
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+        TaskStackSize setStack, TaskPeriod setPeriod,
+        void (*setDeadlineMissedFunc)()) :
+        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
+        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+FixedTimeslotTask::~FixedTimeslotTask(void) {
+    //Do not delete objects, we were responsible for ptrs only.
+    terminateThread = true;
+    if(mainThread.joinable()) {
+        mainThread.join();
+    }
+    delete this;
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+
+    if (not originalTask->started) {
+        // we have to suspend/block here until the task is started.
+        // if semaphores are implemented, use them here.
+        std::unique_lock<std::mutex> lock(initMutex);
+        initCondition.wait(lock);
+    }
+
+    this->taskFunctionality();
+    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
+            "Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+    started = true;
+
+    // Notify task to start.
+    std::lock_guard<std::mutex> lock(initMutex);
+    initCondition.notify_one();
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
+    // Get start time for first entry.
+    chron_ms interval(slotListIter->pollingTimeMs);
+    auto currentStartTime {
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch())
+    };
+    if(interval.count() > 0) {
+        delayForInterval(&currentStartTime, interval);
+    }
+
+    /* Enter the loop that defines the task behavior. */
+    for (;;) {
+        if(terminateThread.load()) {
+            break;
+        }
+        //The component for this slot is executed and the next one is chosen.
+        this->pollingSeqTable.executeAndAdvance();
+        if (not pollingSeqTable.slotFollowsImmediately()) {
+            // we need to wait before executing the current slot
+            //this gives us the time to wait:
+            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
+            delayForInterval(&currentStartTime, interval);
+            //TODO deadline missed check
+        }
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+        uint32_t slotTimeMs, int8_t executionStep) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+    return pollingSeqTable.checkSequence();
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+    return period * 1000;
+}
+
+bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<chron_ms>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index b12cc6d3..bbee94a6 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-#include <vector>
-#include <thread>
-#include <condition_variable>
-#include <atomic>
-
-class ExecutableObjectIF;
-
-/**
- * @brief   This class represents a task for periodic activities with multiple
- *          steps and strict timeslot requirements for these steps.
- * @details
- * @ingroup task_handling
- */
-class FixedTimeslotTask: public FixedTimeslotTaskIF {
-public:
-    /**
-     * @brief   Standard constructor of the class.
-     * @details
-     * The class is initialized without allocated objects. These need to be
-     * added with #addComponent.
-     * @param priority
-     * @param stack_size
-     * @param setPeriod
-     * @param setDeadlineMissedFunc
-     * The function pointer to the deadline missed function that shall be
-     * assigned.
-     */
-    FixedTimeslotTask(const char *name, TaskPriority setPriority,
-            TaskStackSize setStack, TaskPeriod setPeriod,
-            void (*setDeadlineMissedFunc)());
-    /**
-     * @brief   Currently, the executed object's lifetime is not coupled with
-     *          the task object's lifetime, so the destructor is empty.
-     */
-    virtual ~FixedTimeslotTask(void);
-
-    /**
-     * @brief   The method to start the task.
-     * @details The method starts the task with the respective system call.
-     *          Entry point is the taskEntryPoint method described below.
-     *          The address of the task object is passed as an argument
-     *          to the system call.
-     */
-    ReturnValue_t startTask(void);
-
-    /**
-     * Add timeslot to the polling sequence table.
-     * @param componentId
-     * @param slotTimeMs
-     * @param executionStep
-     * @return
-     */
-    ReturnValue_t addSlot(object_id_t componentId,
-                   uint32_t slotTimeMs, int8_t executionStep);
-
-    ReturnValue_t checkSequence() const;
-
-    uint32_t getPeriodMs() const;
-
-    ReturnValue_t sleepFor(uint32_t ms);
-
-protected:
-    using chron_ms = std::chrono::milliseconds;
-
-    bool started;
-    //!< Typedef for the List of objects.
-    typedef std::vector<ExecutableObjectIF*> ObjectList;
-    std::thread mainThread;
-    std::atomic<bool> terminateThread = false;
-
-    //! Polling sequence table which contains the object to execute
-    //! and information like the timeslots and the passed execution step.
-    FixedSlotSequence pollingSeqTable;
-
-    std::condition_variable initCondition;
-    std::mutex initMutex;
-    std::string taskName;
-    /**
-     * @brief   The period of the task.
-     * @details
-     * The period determines the frequency of the task's execution.
-     * It is expressed in clock ticks.
-     */
-    TaskPeriod period;
-
-    /**
-     * @brief   The pointer to the deadline-missed function.
-     * @details
-     * This pointer stores the function that is executed if the task's deadline
-     * is missed. So, each may react individually on a timing failure.
-     * The pointer may be NULL, then nothing happens on missing the deadline.
-     * The deadline is equal to the next execution of the periodic task.
-     */
-    void (*deadlineMissedFunc)(void);
-    /**
-     * @brief   This is the function executed in the new task's context.
-     * @details
-     * It converts the argument back to the thread object type and copies the
-     * class instance to the task context.
-     * The taskFunctionality method is called afterwards.
-     * @param   A pointer to the task object itself is passed as argument.
-     */
-
-    void taskEntryPoint(void* argument);
-    /**
-     * @brief   The function containing the actual functionality of the task.
-     * @details
-     * The method sets and starts the task's period, then enters a loop that is
-     * repeated as long as the isRunning attribute is true. Within the loop,
-     * all performOperation methods of the added objects are called. Afterwards
-     * the checkAndRestartPeriod system call blocks the task until the next
-     *  period. On missing the deadline, the deadlineMissedFunction is executed.
-     */
-    void taskFunctionality(void);
-
-    bool delayForInterval(chron_ms * previousWakeTimeMs,
-            const chron_ms interval);
-};
-
-
-
-#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief   This class represents a task for periodic activities with multiple
+ *          steps and strict timeslot requirements for these steps.
+ * @details
+ * @ingroup task_handling
+ */
+class FixedTimeslotTask: public FixedTimeslotTaskIF {
+public:
+    /**
+     * @brief   Standard constructor of the class.
+     * @details
+     * The class is initialized without allocated objects. These need to be
+     * added with #addComponent.
+     * @param priority
+     * @param stack_size
+     * @param setPeriod
+     * @param setDeadlineMissedFunc
+     * The function pointer to the deadline missed function that shall be
+     * assigned.
+     */
+    FixedTimeslotTask(const char *name, TaskPriority setPriority,
+            TaskStackSize setStack, TaskPeriod setPeriod,
+            void (*setDeadlineMissedFunc)());
+    /**
+     * @brief   Currently, the executed object's lifetime is not coupled with
+     *          the task object's lifetime, so the destructor is empty.
+     */
+    virtual ~FixedTimeslotTask(void);
+
+    /**
+     * @brief   The method to start the task.
+     * @details The method starts the task with the respective system call.
+     *          Entry point is the taskEntryPoint method described below.
+     *          The address of the task object is passed as an argument
+     *          to the system call.
+     */
+    ReturnValue_t startTask(void);
+
+    /**
+     * Add timeslot to the polling sequence table.
+     * @param componentId
+     * @param slotTimeMs
+     * @param executionStep
+     * @return
+     */
+    ReturnValue_t addSlot(object_id_t componentId,
+                   uint32_t slotTimeMs, int8_t executionStep);
+
+    ReturnValue_t checkSequence() const;
+
+    uint32_t getPeriodMs() const;
+
+    ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+    using chron_ms = std::chrono::milliseconds;
+
+    bool started;
+    //!< Typedef for the List of objects.
+    typedef std::vector<ExecutableObjectIF*> ObjectList;
+    std::thread mainThread;
+    std::atomic<bool> terminateThread = false;
+
+    //! Polling sequence table which contains the object to execute
+    //! and information like the timeslots and the passed execution step.
+    FixedSlotSequence pollingSeqTable;
+
+    std::condition_variable initCondition;
+    std::mutex initMutex;
+    std::string taskName;
+    /**
+     * @brief   The period of the task.
+     * @details
+     * The period determines the frequency of the task's execution.
+     * It is expressed in clock ticks.
+     */
+    TaskPeriod period;
+
+    /**
+     * @brief   The pointer to the deadline-missed function.
+     * @details
+     * This pointer stores the function that is executed if the task's deadline
+     * is missed. So, each may react individually on a timing failure.
+     * The pointer may be NULL, then nothing happens on missing the deadline.
+     * The deadline is equal to the next execution of the periodic task.
+     */
+    void (*deadlineMissedFunc)(void);
+    /**
+     * @brief   This is the function executed in the new task's context.
+     * @details
+     * It converts the argument back to the thread object type and copies the
+     * class instance to the task context.
+     * The taskFunctionality method is called afterwards.
+     * @param   A pointer to the task object itself is passed as argument.
+     */
+
+    void taskEntryPoint(void* argument);
+    /**
+     * @brief   The function containing the actual functionality of the task.
+     * @details
+     * The method sets and starts the task's period, then enters a loop that is
+     * repeated as long as the isRunning attribute is true. Within the loop,
+     * all performOperation methods of the added objects are called. Afterwards
+     * the checkAndRestartPeriod system call blocks the task until the next
+     *  period. On missing the deadline, the deadlineMissedFunction is executed.
+     */
+    void taskFunctionality(void);
+
+    bool delayForInterval(chron_ms * previousWakeTimeMs,
+            const chron_ms interval);
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 7af5fbd9..6fd42849 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include <framework/osal/host/MessageQueue.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/host/QueueMapManager.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		messageSize(maxMessageSize), messageDepth(messageDepth) {
-	queueLock = MutexFactory::instance()->createMutex();
-	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "MessageQueue: Could not be created" << std::endl;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	MutexFactory::instance()->deleteMutex(queueLock);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return MessageQueueIF::NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
-			ignoreFault);
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	if(status == HasReturnvaluesIF::RETURN_OK) {
-		*receivedFrom = this->lastPartner;
-	}
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(messageQueue.empty()) {
-		return MessageQueueIF::EMPTY;
-	}
-	// not sure this will work..
-	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, 20);
-	MessageQueueMessage* currentMessage = &messageQueue.front();
-	std::copy(currentMessage->getBuffer(),
-			currentMessage->getBuffer() + messageSize, message->getBuffer());
-	messageQueue.pop();
-	// The last partner is the first uint32_t field in the message
-	this->lastPartner = message->getSender();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	*count = messageQueue.size();
-	// Clears the queue.
-	messageQueue = std::queue<MessageQueueMessage>();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return mqId;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	defaultDestinationSet = true;
-	this->defaultDestination = defaultDestination;
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return defaultDestinationSet;
-}
-
-
-// static core function to send messages.
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-        bool ignoreFault) {
-	if(message->getMessageSize() > message->getMaximumMessageSize()) {
-		// Actually, this should never happen or an error will be emitted
-		// in MessageQueueMessage.
-		// But I will still return a failure here.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
-			QueueMapManager::instance()->getMessageQueue(sendTo));
-	if(targetQueue == nullptr) {
-		if(not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-							objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != nullptr) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		// TODO: Better returnvalue
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock, 20);
-		// not ideal, works for now though.
-		MessageQueueMessage* mqmMessage =
-				dynamic_cast<MessageQueueMessage*>(message);
-		if(message != nullptr) {
-			targetQueue->messageQueue.push(*mqmMessage);
-		}
-		else {
-			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
-					"is not MessageQueueMessage!" << std::endl;
-		}
-
-	}
-	else {
-		return MessageQueueIF::FULL;
-	}
-    message->setSender(sentFrom);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
-}
-
-ReturnValue_t MessageQueue::unlockQueue() {
-	return queueLock->unlockMutex();
-}
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/host/QueueMapManager.h"
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		messageSize(maxMessageSize), messageDepth(messageDepth) {
+	queueLock = MutexFactory::instance()->createMutex();
+	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "MessageQueue: Could not be created" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	MutexFactory::instance()->deleteMutex(queueLock);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return MessageQueueIF::NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault);
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(messageQueue.empty()) {
+		return MessageQueueIF::EMPTY;
+	}
+	// not sure this will work..
+	//*message = std::move(messageQueue.front());
+	MutexHelper mutexLock(queueLock, 20);
+	MessageQueueMessage* currentMessage = &messageQueue.front();
+	std::copy(currentMessage->getBuffer(),
+			currentMessage->getBuffer() + messageSize, message->getBuffer());
+	messageQueue.pop();
+	// The last partner is the first uint32_t field in the message
+	this->lastPartner = message->getSender();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	*count = messageQueue.size();
+	// Clears the queue.
+	messageQueue = std::queue<MessageQueueMessage>();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return mqId;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
+	this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return defaultDestinationSet;
+}
+
+
+// static core function to send messages.
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault) {
+	if(message->getMessageSize() > message->getMaximumMessageSize()) {
+		// Actually, this should never happen or an error will be emitted
+		// in MessageQueueMessage.
+		// But I will still return a failure here.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
+			QueueMapManager::instance()->getMessageQueue(sendTo));
+	if(targetQueue == nullptr) {
+		if(not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+							objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		// TODO: Better returnvalue
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
+		MutexHelper mutexLock(targetQueue->queueLock, 20);
+		// not ideal, works for now though.
+		MessageQueueMessage* mqmMessage =
+				dynamic_cast<MessageQueueMessage*>(message);
+		if(message != nullptr) {
+			targetQueue->messageQueue.push(*mqmMessage);
+		}
+		else {
+			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
+					"is not MessageQueueMessage!" << std::endl;
+		}
+
+	}
+	else {
+		return MessageQueueIF::FULL;
+	}
+    message->setSender(sentFrom);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 7fc77f7a..d2da2402 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -1,230 +1,230 @@
-#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/ipc/MutexIF.h>
-#include <framework/timemanager/Clock.h>
-
-#include <queue>
-#include <memory>
-
-/**
- * @brief		This class manages sending and receiving of
- * 				message queue messages.
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- * For creating the queue, as well as sending and receiving messages, the class
- * makes use of the operating system calls provided.
- *
- * Please keep in mind that FreeRTOS offers different calls for message queue
- * operations if called from an ISR.
- * For now, the system context needs to be switched manually.
- * @ingroup osal
- * @ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details
-	 * By making use of the according operating system call, a message queue is
-	 * created and initialized. The message depth - the maximum number of
-	 * messages to be buffered - may be set with the help of a parameter,
-	 * whereas the message size is automatically set to the maximum message
-	 * queue message size. The operating system sets the message queue id, or
-	 * in case of failure, it is set to zero.
-	 * @param message_depth
-	 * The number of messages to be buffered before passing an error to the
-	 * sender. Default is three.
-	 * @param max_message_size
-	 * With this parameter, the maximum message size can be adjusted.
-	 * This should be left default.
-	 */
-	MessageQueue(size_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	/** Copying message queues forbidden */
-	MessageQueue(const MessageQueue&) = delete;
-	MessageQueue& operator=(const MessageQueue&) = delete;
-
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided
-	 * 			by the operating system.
-	 */
-	virtual ~MessageQueue();
-
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender
-	 * parent, but passes its queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the
-	 *  destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter
-	 * is not incremented if queue is full.
-	 */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the
-	 * sendToDefault call of the MessageQueueSender parent class and adds its
-	 * queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using
-	 * the stored lastPartner information as destination. If there was no
-	 * message received yet (i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-
-	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a
-	 * 			receiving queue.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 *  The OS's return value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send
-	 * the message to.
-	 * @param message	This is a pointer to a previously created message,
-	 * which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the
-	 * sender's queue id into the message. This variable is set to zero by
-	 * default.
-	 * @param ignoreFault If set to true, the internal software fault counter
-	 * is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	The sendToDefault method sends a queue message to the default
-	 * 			destination.
-	 * @details
-	 * In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message,
-	 * which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the
-	 * sender's queue id into the message. This variable is set to zero by
-	 * default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue
-	 * 			and returns the sender.
-	 * @details
-	 * It works identically to the other receiveMessage call, but in  addition
-	 * returns the sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details
-	 * If data is available it is stored in the passed message pointer.
-	 * The message's original content is overwritten and the sendFrom
-	 * information is stored in the lastPartner attribute. Else, the lastPartner
-	 * information remains untouched, the message's content is cleared and the
-	 * function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count) override;
-	/**
-	 * @brief	This method returns the message queue id of the last
-	 * 			communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const override;
-	/**
-	 * @brief	This method returns the message queue id of this class's
-	 * 			message queue.
-	 */
-	MessageQueueId_t getId() const override;
-
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const override;
-
-	bool isDefaultDestinationSet() const override;
-
-	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
-	ReturnValue_t unlockQueue();
-protected:
-	/**
-	 * @brief 	Implementation to be called from any send Call within
-	 * 			MessageQueue and MessageQueueSenderIF.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 * The OS's return value is returned.
-	 * @param sendTo
-	 * This parameter specifies the message queue id to send the message to.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id into
-	 * the message. This variable is set to zero by default.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter  is not incremented
-	 * if queue is full.
-	 * @param context Specify whether call is made from task or from an ISR.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-
-	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	std::queue<MessageQueueMessage> messageQueue;
-	/**
-	 * @brief	The class stores the queue id it got assigned.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t mqId = 0;
-	size_t messageSize = 0;
-	size_t messageDepth = 0;
-
-	MutexIF* queueLock;
-
-	bool defaultDestinationSet = false;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "../../ipc/MutexIF.h"
+#include "../../timemanager/Clock.h"
+
+#include <queue>
+#include <memory>
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue is
+	 * created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender
+	 * parent, but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the
+	 *  destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the
+	 * sendToDefault call of the MessageQueueSender parent class and adds its
+	 * queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using
+	 * the stored lastPartner information as destination. If there was no
+	 * message received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a
+	 * 			receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 *  The OS's return value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send
+	 * the message to.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	The sendToDefault method sends a queue message to the default
+	 * 			destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue
+	 * 			and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in  addition
+	 * returns the sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in the lastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count) override;
+	/**
+	 * @brief	This method returns the message queue id of the last
+	 * 			communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const override;
+	/**
+	 * @brief	This method returns the message queue id of this class's
+	 * 			message queue.
+	 */
+	MessageQueueId_t getId() const override;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
+	ReturnValue_t unlockQueue();
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+
+	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	std::queue<MessageQueueMessage> messageQueue;
+	/**
+	 * @brief	The class stores the queue id it got assigned.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t mqId = 0;
+	size_t messageSize = 0;
+	size_t messageDepth = 0;
+
+	MutexIF* queueLock;
+
+	bool defaultDestinationSet = false;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 03948c4c..28768507 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,40 +1,40 @@
-#include <framework/osal/host/Mutex.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::BLOCKING) {
-		mutex.lock();
-		locked = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else if(timeoutMs == MutexIF::POLLING) {
-		if(mutex.try_lock()) {
-			locked = true;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-	else if(timeoutMs > MutexIF::POLLING){
-		auto chronoMs = std::chrono::milliseconds(timeoutMs);
-		if(mutex.try_lock_for(chronoMs)) {
-			locked = true;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-	return MutexIF::MUTEX_TIMEOUT;
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if(not locked) {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-	mutex.unlock();
-	locked = false;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-std::timed_mutex* Mutex::getMutexHandle() {
-	return &mutex;
-}
+#include "../../osal/host/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::BLOCKING) {
+		mutex.lock();
+		locked = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else if(timeoutMs == MutexIF::POLLING) {
+		if(mutex.try_lock()) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else if(timeoutMs > MutexIF::POLLING){
+		auto chronoMs = std::chrono::milliseconds(timeoutMs);
+		if(mutex.try_lock_for(chronoMs)) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	return MutexIF::MUTEX_TIMEOUT;
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if(not locked) {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+	mutex.unlock();
+	locked = false;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::timed_mutex* Mutex::getMutexHandle() {
+	return &mutex;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index d882c457..4d49bac7 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-#include <mutex>
-
-/**
- * @brief OS component to implement MUTual EXclusion
- *
- * @details
- * Mutexes are binary semaphores which include a priority inheritance mechanism.
- * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
- * @ingroup osal
- */
-class Mutex : public MutexIF {
-public:
-	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
-	ReturnValue_t unlockMutex() override;
-
-	std::timed_mutex* getMutexHandle();
-private:
-	bool locked = false;
-	std::timed_mutex mutex;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <mutex>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
index 25d9fa46..284ce59f 100644
--- a/osal/host/MutexFactory.cpp
+++ b/osal/host/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/host/Mutex.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory.
-//What's better and why? -> one is on heap the other on bss/data
-//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = nullptr;
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new MutexFactory();
-	}
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 1a5024ab..c4cf9f56 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,176 +1,176 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/host/Mutex.h>
-#include <framework/osal/host/PeriodicTask.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-
-#include <thread>
-#include <chrono>
-
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <pthread.h>
-#endif
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), taskName(name), period(setPeriod),
-		deadlineMissedFunc(setDeadlineMissedFunc) {
-    // It is propably possible to set task priorities by using the native
-    // task handles for Windows / Linux
-	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
-#endif
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	terminateThread = true;
-	if(mainThread.joinable()) {
-		mainThread.join();
-	}
-	delete this;
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-
-
-	if (not originalTask->started) {
-		// we have to suspend/block here until the task is started.
-		// if semaphores are implemented, use them here.
-		std::unique_lock<std::mutex> lock(initMutex);
-		initCondition.wait(lock);
-	}
-
-	this->taskFunctionality();
-	sif::debug << "PeriodicTask::taskEntryPoint: "
-			"Returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// Notify task to start.
-	std::lock_guard<std::mutex> lock(initMutex);
-	initCondition.notify_one();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicTask::taskFunctionality() {
-	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
-	auto currentStartTime {
-	    std::chrono::duration_cast<std::chrono::milliseconds>(
-	    std::chrono::system_clock::now().time_since_epoch())
-	};
-	auto nextStartTime{ currentStartTime };
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		if(terminateThread.load()) {
-			break;
-		}
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		if(not delayForInterval(&currentStartTime, periodChrono)) {
-			sif::warning << "PeriodicTask: " << taskName <<
-					" missed deadline!\n" << std::flush;
-			if(deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
-        const chron_ms interval) {
-    bool shouldDelay = false;
-    //Get current wakeup time
-    auto currentStartTime =
-            std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now().time_since_epoch());
-    /* Generate the tick time at which the task wants to wake. */
-    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
-
-    if (currentStartTime < *previousWakeTimeMs) {
-        /* The tick count has overflowed since this function was
-         lasted called.  In this case the only time we should ever
-         actually delay is if the wake time has also    overflowed,
-         and the wake time is greater than the tick time.  When this
-         is the case it is as if neither time had overflowed. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                && (nextTimeToWake_ms > currentStartTime)) {
-            shouldDelay = true;
-        }
-    } else {
-        /* The tick time has not overflowed.  In this case we will
-         delay if either the wake time has overflowed, and/or the
-         tick time is less than the wake time. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                || (nextTimeToWake_ms >  currentStartTime)) {
-            shouldDelay = true;
-        }
-    }
-
-    /* Update the wake time ready for the next call. */
-
-    (*previousWakeTimeMs) =  nextTimeToWake_ms;
-
-    if (shouldDelay) {
-        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-                nextTimeToWake_ms - currentStartTime);
-        std::this_thread::sleep_for(sleepTime);
-        return true;
-    }
-    //We are shifting the time in case the deadline was missed like rtems
-    (*previousWakeTimeMs) = currentStartTime;
-    return false;
-
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), taskName(name), period(setPeriod),
+		deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	terminateThread = true;
+	if(mainThread.joinable()) {
+		mainThread.join();
+	}
+	delete this;
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+
+
+	if (not originalTask->started) {
+		// we have to suspend/block here until the task is started.
+		// if semaphores are implemented, use them here.
+		std::unique_lock<std::mutex> lock(initMutex);
+		initCondition.wait(lock);
+	}
+
+	this->taskFunctionality();
+	sif::debug << "PeriodicTask::taskEntryPoint: "
+			"Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// Notify task to start.
+	std::lock_guard<std::mutex> lock(initMutex);
+	initCondition.notify_one();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
+	auto currentStartTime {
+	    std::chrono::duration_cast<std::chrono::milliseconds>(
+	    std::chrono::system_clock::now().time_since_epoch())
+	};
+	auto nextStartTime{ currentStartTime };
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		if(terminateThread.load()) {
+			break;
+		}
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(not delayForInterval(&currentStartTime, periodChrono)) {
+			sif::warning << "PeriodicTask: " << taskName <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index d97bf089..7eb768cb 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -1,123 +1,123 @@
-#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-#include <vector>
-#include <thread>
-#include <condition_variable>
-#include <atomic>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @details
- *
- * @ingroup task_handling
- */
-class PeriodicTask: public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details
-	 * The class is initialized without allocated objects. These need to be
-	 * added with #addComponent.
-	 * @param priority
-	 * @param stack_size
-	 * @param setPeriod
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall be
-	 * assigned.
-	 */
-	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
-			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with
-	 * 			the task object's lifetime, so the destructor is empty.
-	 */
-	virtual ~PeriodicTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void);
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return
-	 *  -@c RETURN_OK on success
-	 *  -@c RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-
-protected:
-	using chron_ms = std::chrono::milliseconds;
-	bool started;
-	//!< Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	std::thread mainThread;
-	std::atomic<bool> terminateThread = false;
-
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	std::condition_variable initCondition;
-	std::mutex initMutex;
-	std::string taskName;
-	/**
-	 * @brief	The period of the task.
-	 * @details
-	 * The period determines the frequency of the task's execution.
-	 * It is expressed in clock ticks.
-	 */
-	TaskPeriod period;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details
-	 * This pointer stores the function that is executed if the task's deadline
-	 * is missed. So, each may react individually on a timing failure.
-	 * The pointer may be NULL, then nothing happens on missing the deadline.
-	 * The deadline is equal to the next execution of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details
-	 * It converts the argument back to the thread object type and copies the
-	 * class instance to the task context.
-	 * The taskFunctionality method is called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-
-	void taskEntryPoint(void* argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details
-	 * The method sets and starts the task's period, then enters a loop that is
-	 * repeated as long as the isRunning attribute is true. Within the loop,
-	 * all performOperation methods of the added objects are called. Afterwards
-	 * the checkAndRestartPeriod system call blocks the task until the next
-	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-
-	bool delayForInterval(chron_ms * previousWakeTimeMs,
-	        const chron_ms interval);
-};
-
-#endif /* PERIODICTASK_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
+ *
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be
+	 * added with #addComponent.
+	 * @param priority
+	 * @param stack_size
+	 * @param setPeriod
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall be
+	 * assigned.
+	 */
+	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
+			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 *  -@c RETURN_OK on success
+	 *  -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+	using chron_ms = std::chrono::milliseconds;
+	bool started;
+	//!< Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	std::thread mainThread;
+	std::atomic<bool> terminateThread = false;
+
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	std::condition_variable initCondition;
+	std::mutex initMutex;
+	std::string taskName;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed. So, each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context.
+	 * The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called. Afterwards
+	 * the checkAndRestartPeriod system call blocks the task until the next
+	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	bool delayForInterval(chron_ms * previousWakeTimeMs,
+	        const chron_ms interval);
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 225bb8c7..052671ca 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,41 +1,41 @@
-#include <framework/ipc/QueueFactory.h>
-#include <framework/osal/host/MessageQueue.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <cstring>
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	// A thread-safe queue can be implemented  by using a combination
-	// of std::queue and std::mutex. This uses dynamic memory allocation
-	// which could be alleviated by using a custom allocator, external library
-	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	// A thread-safe queue can be implemented  by using a combination
+	// of std::queue and std::mutex. This uses dynamic memory allocation
+	// which could be alleviated by using a custom allocator, external library
+	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 89b9a948..35db204e 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,51 +1,51 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/osal/host/QueueMapManager.h>
-
-QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
-
-QueueMapManager::QueueMapManager() {
-    mapLock = MutexFactory::instance()->createMutex();
-}
-
-QueueMapManager* QueueMapManager::instance() {
-	if (mqManagerInstance == nullptr){
-		mqManagerInstance = new QueueMapManager();
-	}
-	return QueueMapManager::mqManagerInstance;
-}
-
-ReturnValue_t QueueMapManager::addMessageQueue(
-		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
-	// Not thread-safe, but it is assumed all message queues are created
-	// at software initialization now. If this is to be made thread-safe in
-	// the future, it propably would be sufficient to lock the increment
-	// operation here
-	uint32_t currentId = queueCounter++;
-	auto returnPair = queueMap.emplace(currentId, queueToInsert);
-	if(not returnPair.second) {
-		// this should never happen for the atomic variable.
-		sif::error << "QueueMapManager: This ID is already inside the map!"
-				<< std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if (id != nullptr) {
-		*id = currentId;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* QueueMapManager::getMessageQueue(
-		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, 50);
-	auto queueIter = queueMap.find(messageQueueId);
-	if(queueIter != queueMap.end()) {
-		return queueIter->second;
-	}
-	else {
-		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
-				messageQueueId << " does not exists in the map" << std::endl;
-		return nullptr;
-	}
-}
-
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+#include "../../osal/host/QueueMapManager.h"
+
+QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
+
+QueueMapManager::QueueMapManager() {
+    mapLock = MutexFactory::instance()->createMutex();
+}
+
+QueueMapManager* QueueMapManager::instance() {
+	if (mqManagerInstance == nullptr){
+		mqManagerInstance = new QueueMapManager();
+	}
+	return QueueMapManager::mqManagerInstance;
+}
+
+ReturnValue_t QueueMapManager::addMessageQueue(
+		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	// Not thread-safe, but it is assumed all message queues are created
+	// at software initialization now. If this is to be made thread-safe in
+	// the future, it propably would be sufficient to lock the increment
+	// operation here
+	uint32_t currentId = queueCounter++;
+	auto returnPair = queueMap.emplace(currentId, queueToInsert);
+	if(not returnPair.second) {
+		// this should never happen for the atomic variable.
+		sif::error << "QueueMapManager: This ID is already inside the map!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if (id != nullptr) {
+		*id = currentId;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* QueueMapManager::getMessageQueue(
+		MessageQueueId_t messageQueueId) const {
+	MutexHelper(mapLock, 50);
+	auto queueIter = queueMap.find(messageQueueId);
+	if(queueIter != queueMap.end()) {
+		return queueIter->second;
+	}
+	else {
+		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index a2a1b658..acf20389 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,47 +1,47 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-#include <framework/osal/host/MessageQueue.h>
-#include <unordered_map>
-#include <atomic>
-
-using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
-
-
-/**
- * An internal map to map message queue IDs to message queues.
- * This propably should be a singleton..
- */
-class QueueMapManager {
-public:
-	//! Returns the single instance of SemaphoreFactory.
-	static QueueMapManager* instance();
-
-	/**
-	 * Insert a message queue into the map and returns a message queue ID
-	 * @param queue The message queue to insert.
-	 * @param id The passed value will be set unless a nullptr is passed
-	 * @return
-	 */
-	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
-			id = nullptr);
-	/**
-	 * Get the message queue handle by providing a message queue ID.
-	 * @param messageQueueId
-	 * @return
-	 */
-	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
-
-private:
-	//! External instantiation is forbidden.
-	QueueMapManager();
-	uint32_t queueCounter = 1;
-	MutexIF* mapLock;
-	QueueMap queueMap;
-	static QueueMapManager* mqManagerInstance;
-};
-
-
-
-#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../osal/host/MessageQueue.h"
+#include <unordered_map>
+#include <atomic>
+
+using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
+
+
+/**
+ * An internal map to map message queue IDs to message queues.
+ * This propably should be a singleton..
+ */
+class QueueMapManager {
+public:
+	//! Returns the single instance of SemaphoreFactory.
+	static QueueMapManager* instance();
+
+	/**
+	 * Insert a message queue into the map and returns a message queue ID
+	 * @param queue The message queue to insert.
+	 * @param id The passed value will be set unless a nullptr is passed
+	 * @return
+	 */
+	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
+			id = nullptr);
+	/**
+	 * Get the message queue handle by providing a message queue ID.
+	 * @param messageQueueId
+	 * @return
+	 */
+	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
+
+private:
+	//! External instantiation is forbidden.
+	QueueMapManager();
+	uint32_t queueCounter = 1;
+	MutexIF* mapLock;
+	QueueMap queueMap;
+	static QueueMapManager* mqManagerInstance;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 0c077f68..58040428 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -1,42 +1,42 @@
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	// Just gonna wait for full C++20 for now.
-	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
-			" Returning nullptr!\n" << std::flush;
-	return nullptr;
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
-		uint8_t initCount, uint32_t arguments) {
-	// Just gonna wait for full C++20 for now.
-	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
-				" Returning nullptr!\n" << std::flush;
-	return nullptr;
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
+			" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
+				" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 9db8ac4d..3f527130 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,55 +1,55 @@
-#include <framework/osal/host/FixedTimeslotTask.h>
-#include <framework/osal/host/PeriodicTask.h>
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-#include <chrono>
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-// Will propably not be used for hosted implementation
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
-
-TaskFactory::TaskFactory() {
-}
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-			deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
-	        periodInSeconds_, deadLineMissedFunction_);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	// This might block for some time!
-	delete task;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
+#include "../../osal/host/FixedTimeslotTask.h"
+#include "../../osal/host/PeriodicTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include <chrono>
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+// Will propably not be used for hosted implementation
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
+
+TaskFactory::TaskFactory() {
+}
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
+	        periodInSeconds_, deadLineMissedFunction_);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	// This might block for some time!
+	delete task;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index e2ad9b58..37947b26 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,5 +1,5 @@
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 extern "C" {
 #include <errno.h>
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 9d4ed1cd..9ac9ba7f 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 #define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/SemaphoreIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
 
 extern "C" {
 #include <semaphore.h>
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index eda5b7af..370c77f7 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,220 +1,220 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/Clock.h>
-
-#include <sys/time.h>
-#include <sys/sysinfo.h>
-#include <linux/sysinfo.h>
-#include <time.h>
-#include <unistd.h>
-
-//#include <fstream>
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	uint32_t ticks = sysconf(_SC_CLK_TCK);
-	return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	timespec timeUnix;
-	timeval timeTimeval;
-	convertTimeOfDayToTimeval(time,&timeTimeval);
-	timeUnix.tv_sec = timeTimeval.tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
-
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timespec timeUnix;
-	timeUnix.tv_sec = time->tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	time->tv_sec = timeUnix.tv_sec;
-	time->tv_usec = timeUnix.tv_nsec / 1000.0;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval timeVal;
-	ReturnValue_t result = getClock_timeval(&timeVal);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval uptime;
-	auto result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-	}
-	return uptime;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime;
-	ReturnValue_t result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status != 0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	struct tm* timeInfo;
-	timeInfo = gmtime(&timeUnix.tv_sec);
-	time->year = timeInfo->tm_year + 1900;
-	time->month = timeInfo->tm_mon+1;
-	time->day = timeInfo->tm_mday;
-	time->hour = timeInfo->tm_hour;
-	time->minute = timeInfo->tm_min;
-	time->second = timeInfo->tm_sec;
-	time->usecond = timeUnix.tv_nsec / 1000.0;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-
-	tm fromTm;
-	//Note: Fails for years before AD
-	fromTm.tm_year = from->year - 1900;
-	fromTm.tm_mon = from->month - 1;
-	fromTm.tm_mday = from->day;
-	fromTm.tm_hour = from->hour;
-	fromTm.tm_min = from->minute;
-	fromTm.tm_sec = from->second;
-
-	to->tv_sec = mktime(&fromTm);
-	to->tv_usec = from->usecond;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <sys/time.h>
+#include <sys/sysinfo.h>
+#include <linux/sysinfo.h>
+#include <time.h>
+#include <unistd.h>
+
+//#include <fstream>
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	uint32_t ticks = sysconf(_SC_CLK_TCK);
+	return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	timespec timeUnix;
+	timeval timeTimeval;
+	convertTimeOfDayToTimeval(time,&timeTimeval);
+	timeUnix.tv_sec = timeTimeval.tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
+
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timespec timeUnix;
+	timeUnix.tv_sec = time->tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval timeVal;
+	ReturnValue_t result = getClock_timeval(&timeVal);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	uptime->tv_sec = sysInfo.uptime;
+	uptime->tv_usec = 0;
+
+
+	//Linux specific file read but more precise
+//	double uptimeSeconds;
+//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+//		uptime->tv_sec = uptimeSeconds;
+//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+//	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime;
+	ReturnValue_t result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status != 0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	struct tm* timeInfo;
+	timeInfo = gmtime(&timeUnix.tv_sec);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	time->usecond = timeUnix.tv_nsec / 1000.0;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+
+	tm fromTm;
+	//Note: Fails for years before AD
+	fromTm.tm_year = from->year - 1900;
+	fromTm.tm_mon = from->month - 1;
+	fromTm.tm_mday = from->day;
+	fromTm.tm_hour = from->hour;
+	fromTm.tm_min = from->minute;
+	fromTm.tm_sec = from->second;
+
+	to->tv_sec = mktime(&fromTm);
+	to->tv_usec = from->usecond;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index dfc4d801..ef32539b 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,54 +1,54 @@
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
-		maxCount(maxCount), initCount(initCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	initSemaphore(initCount);
-}
-
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
-		maxCount(other.maxCount), initCount(other.initCount) {
-	initSemaphore(initCount);
-}
-
-CountingSemaphore& CountingSemaphore::operator =(
-		CountingSemaphore&& other) {
-	initSemaphore(other.initCount);
-	return * this;
-}
-
-ReturnValue_t CountingSemaphore::release() {
-	ReturnValue_t result = checkCount(&handle, maxCount);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return CountingSemaphore::release(&this->handle);
-}
-
-ReturnValue_t CountingSemaphore::release(sem_t* handle) {
-	int result = sem_post(handle);
-	if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	switch(errno) {
-	case(EINVAL):
-		// Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	case(EOVERFLOW):
-		// SEM_MAX_VALUE overflow. This should never happen
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CountingSemaphore::getMaxCount() const {
-	return maxCount;
-}
-
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	initSemaphore(initCount);
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	initSemaphore(initCount);
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	initSemaphore(other.initCount);
+	return * this;
+}
+
+ReturnValue_t CountingSemaphore::release() {
+	ReturnValue_t result = checkCount(&handle, maxCount);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return CountingSemaphore::release(&this->handle);
+}
+
+ReturnValue_t CountingSemaphore::release(sem_t* handle) {
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
index ba606595..afe21a61 100644
--- a/osal/linux/CountingSemaphore.h
+++ b/osal/linux/CountingSemaphore.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#include <framework/osal/linux/BinarySemaphore.h>
-
-/**
- * @brief 	Counting semaphores, which can be acquired more than once.
- * @details
- * See: https://www.freertos.org/CreateCounting.html
- * API of counting semaphores is almost identical to binary semaphores,
- * so we just inherit from binary semaphore and provide the respective
- * constructors.
- */
-class CountingSemaphore: public BinarySemaphore {
-public:
-	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
-	//! @brief Copy ctor, disabled
-	CountingSemaphore(const CountingSemaphore&) = delete;
-	//! @brief Copy assignment, disabled
-	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
-	//! @brief Move ctor
-	CountingSemaphore (CountingSemaphore &&);
-	//! @brief Move assignment
-	CountingSemaphore & operator=(CountingSemaphore &&);
-
-	ReturnValue_t release() override;
-	static ReturnValue_t release(sem_t* sem);
-	/* Same API as binary semaphore otherwise. acquire() can be called
-	 * until there are not semaphores left and release() can be called
-	 * until maxCount is reached. */
-
-	uint8_t getMaxCount() const;
-private:
-	const uint8_t maxCount;
-	uint8_t initCount = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#include "../../osal/linux/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquired more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	ReturnValue_t release() override;
+	static ReturnValue_t release(sem_t* sem);
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 9d7d08f6..60ce9a63 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,91 +1,91 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/FixedTimeslotTask.h>
-
-#include <limits.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
-
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t periodMs_):
-		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-
-}
-
-void* FixedTimeslotTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return nullptr;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-	createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::dec << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	//Like FreeRTOS pthreads are running as soon as they are created
-	if (!started) {
-		suspend();
-	}
-	//The start time for the first entry is read.
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	uint64_t interval = pst.getIntervalToNextSlotMs();
-
-
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = this->pst.getIntervalToPreviousSlotMs();
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
-				//No time left on timer -> we missed the deadline
-				missedDeadlineCounter();
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				   << " deadlines." << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/FixedTimeslotTask.h"
+
+#include <limits.h>
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
+
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+
+}
+
+void* FixedTimeslotTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return nullptr;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+	createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::dec << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	//Like FreeRTOS pthreads are running as soon as they are created
+	if (!started) {
+		suspend();
+	}
+	//The start time for the first entry is read.
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	uint64_t interval = pst.getIntervalToNextSlotMs();
+
+
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = this->pst.getIntervalToPreviousSlotMs();
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
+				//No time left on timer -> we missed the deadline
+				missedDeadlineCounter();
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
+	}
+}
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 409cd982..83bf203e 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <pthread.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t periodMs_);
-	virtual ~FixedTimeslotTask();
-
-	virtual ReturnValue_t startTask();
-
-	virtual ReturnValue_t sleepFor(uint32_t ms);
-
-	virtual uint32_t getPeriodMs() const;
-
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
-
-	virtual ReturnValue_t checkSequence() const;
-
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-protected:
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Holding the main functionality of the task, this method is most important.
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	virtual void taskFunctionality();
-
-private:
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details
-	 * This method, that is the entry point in the new thread and calls
-	 * taskFunctionality of the child class. Needs a valid pointer to the
-	 * derived class.
-	 *
-	 * The void* returnvalue is not used yet but could be used to return
-	 * arbitrary data.
-	 */
-	static void* taskEntryPoint(void* arg);
-	FixedSlotSequence pst;
-
-	bool started;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../osal/linux/PosixThread.h"
+#include <pthread.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
+	virtual ~FixedTimeslotTask();
+
+	virtual ReturnValue_t startTask();
+
+	virtual ReturnValue_t sleepFor(uint32_t ms);
+
+	virtual uint32_t getPeriodMs() const;
+
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
+	virtual ReturnValue_t checkSequence() const;
+
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+protected:
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	virtual void taskFunctionality();
+
+private:
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
+	 */
+	static void* taskEntryPoint(void* arg);
+	FixedSlotSequence pst;
+
+	bool started;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/linux/InternalErrorCodes.cpp b/osal/linux/InternalErrorCodes.cpp
index 7f83663b..724cb4bc 100644
--- a/osal/linux/InternalErrorCodes.cpp
+++ b/osal/linux/InternalErrorCodes.cpp
@@ -1,14 +1,14 @@
-#include <framework/osal/InternalErrorCodes.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	//TODO This class can be removed
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	//TODO This class can be removed
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 236e61b6..97c89552 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,369 +1,369 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/MessageQueue.h>
-
-#include <fstream>
-
-#include <fcntl.h>           /* For O_* constants */
-#include <sys/stat.h>        /* For mode constants */
-#include <cstring>
-#include <errno.h>
-
-
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
-		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE),
-		maxMessageSize(maxMessageSize) {
-	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
-	mq_attr attributes;
-	this->id = 0;
-	//Set attributes
-	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = messageDepth;
-	attributes.mq_msgsize = maxMessageSize;
-	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
-
-	// Create a nonblocking queue if the name is available (the queue is read
-	// and writable for the owner as well as the group)
-	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
-	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
-	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
-	if (tempId == -1) {
-		handleError(&attributes, messageDepth);
-	}
-	else {
-		//Successful mq_open call
-		this->id = tempId;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	int status = mq_close(this->id);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
-				   << strerror(errno) <<std::endl;
-	}
-	status = mq_unlink(name);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) << std::endl;
-	}
-}
-
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
-		uint32_t messageDepth) {
-	switch(errno) {
-	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
-				" for message size" << std::endl;
-		size_t defaultMqMaxMsg = 0;
-		// Not POSIX conformant, but should work for all UNIX systems.
-		// Just an additional helpful printout :-)
-		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
-				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			/*
-			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			This happens if the msg_max value is not large enough
-			It is ignored if the executable is run in privileged mode.
-		    Run the unlockRealtime script or grant the mode manually by using:
-			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
-
-			Persistent solution for session:
-			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
-
-			Permanent solution:
-			sudo nano /etc/sysctl.conf
-			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			Apply changes with: sudo sysctl -p
-			*/
-			sif::error << "MessageQueue::MessageQueue: Default MQ size "
-					<< defaultMqMaxMsg << " is too small for requested size "
-					<< messageDepth << std::endl;
-			sif::error << "This error can be fixed by setting the maximum "
-					"allowed message size higher!" << std::endl;
-
-		}
-		break;
-	}
-	case(EEXIST): {
-		// An error occured during open
-		// We need to distinguish if it is caused by an already created queue
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-													<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		break;
-	}
-
-	default:
-		// Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
-
-	}
-	return HasReturnvaluesIF::RETURN_FAILED;
-
-
-
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::receiveMessage: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(message->getMaximumMessageSize() < maxMessageSize) {
-		sif::error << "MessageQueue::receiveMessage: Message size "
-				<< message->getMaximumMessageSize()
-				<< " too small to receive data!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->getMaximumMessageSize(),&messagePriority);
-	if (status > 0) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->getMessageSize() < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}else if(status==0){
-		//Success but no message received
-		return MessageQueueIF::EMPTY;
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send
-		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
-		switch(errno){
-		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
-			//currently on the specified queue.
-			return MessageQueueIF::EMPTY;
-		case EBADF:
-			//mqdes doesn't represent a valid queue open for reading.
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - The pointer to the buffer for storing the received message,
-			 *   msg_ptr, is NULL.
-			 * - The number of bytes requested, msg_len is less than zero.
-			 * - msg_len is anything other than the mq_msgsize of the specified
-			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
-			 *   been set in the queue's mq_flags.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-					   << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			/*
-			 * This value indicates one of the following:
-			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
-			 *   and the given msg_len is shorter than the mq_msgsize for
-			 *   the given queue.
-			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
-			 *   given msg_len is too short for the message that would have
-			 *   been received.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINTR:
-			//The operation was interrupted by a signal.
-		default:
-
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	mq_attr attrib;
-	int status = mq_getattr(id,&attrib);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			//mq_attr is NULL
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	*count = attrib.mq_curmsgs;
-	attrib.mq_curmsgs = 0;
-	status = mq_setattr(id,&attrib,NULL);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 *  - mq_attr is NULL.
-			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
-			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
-			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 */
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
-
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-uint16_t MessageQueue::queueCounter = 0;
-
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	message->setSender(sentFrom);
-	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()),
-			message->getMessageSize(),0);
-
-	//TODO: Check if we're in ISR.
-	if (result != 0) {
-		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-						objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		switch(errno){
-		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the
-			//MQ_NONBLOCK flag was set in its attributes, and the
-			//specified queue is full.
-			return MessageQueueIF::FULL;
-		case EBADF: {
-			//mq_des doesn't represent a valid message queue descriptor,
-			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
-					<< " destination invalid."  << std::endl;
-			sif::error << strerror(errno) << " in "
-					<<"mq_send to: " << sendTo << " sent from "
-					<< sentFrom << std::endl;
-			return DESTINVATION_INVALID;
-		}
-		case EINTR:
-			//The call was interrupted by a signal.
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - msg_ptr is NULL.
-			 * - msg_len is negative.
-			 * - msg_prio is greater than MQ_PRIO_MAX.
-			 * - msg_prio is less than 0.
-			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
-			 *   msg_prio is greater than the priority of the calling process.
-			 */
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send" << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			// The msg_len is greater than the msgsize associated with
-			//the specified queue.
-			sif::error << "MessageQueue::sendMessage: Size error [" <<
-					strerror(errno) << "] in mq_send" << std::endl;
-			/*NO BREAK*/
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/MessageQueue.h"
+
+#include <fstream>
+
+#include <fcntl.h>           /* For O_* constants */
+#include <sys/stat.h>        /* For mode constants */
+#include <cstring>
+#include <errno.h>
+
+
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
+	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
+	mq_attr attributes;
+	this->id = 0;
+	//Set attributes
+	attributes.mq_curmsgs = 0;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
+	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
+	//Set the name of the queue. The slash is mandatory!
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
+
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
+	if (tempId == -1) {
+		handleError(&attributes, messageDepth);
+	}
+	else {
+		//Successful mq_open call
+		this->id = tempId;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	int status = mq_close(this->id);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
+	}
+	status = mq_unlink(name);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) << std::endl;
+	}
+}
+
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
+		}
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		break;
+	}
+
+	default:
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
+	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
+
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	unsigned int messagePriority = 0;
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->getMaximumMessageSize(),&messagePriority);
+	if (status > 0) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}else if(status==0){
+		//Success but no message received
+		return MessageQueueIF::EMPTY;
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
+		memset(message->getData(), 0, message->getMaximumMessageSize());
+		switch(errno){
+		case EAGAIN:
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
+			return MessageQueueIF::EMPTY;
+		case EBADF:
+			//mqdes doesn't represent a valid queue open for reading.
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			/*
+			 * This value indicates one of the following:
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINTR:
+			//The operation was interrupted by a signal.
+		default:
+
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	mq_attr attrib;
+	int status = mq_getattr(id,&attrib);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			//mq_attr is NULL
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	*count = attrib.mq_curmsgs;
+	attrib.mq_curmsgs = 0;
+	status = mq_setattr(id,&attrib,NULL);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
+			 */
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
+
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+uint16_t MessageQueue::queueCounter = 0;
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	message->setSender(sentFrom);
+	int result = mq_send(sendTo,
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
+
+	//TODO: Check if we're in ISR.
+	if (result != 0) {
+		if(!ignoreFault){
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+						objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		switch(errno){
+		case EAGAIN:
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
+			return MessageQueueIF::FULL;
+		case EBADF: {
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
+		case EINTR:
+			//The call was interrupted by a signal.
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 8e3a5191..35d16e25 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,187 +1,187 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-
-#include <mqueue.h>
-/**
- * @brief		This class manages sending and receiving of message queue messages.
- *
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- *
- * The creation of message queues, as well as sending and receiving messages,
- * makes use of the operating system calls provided.
- *	@ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
-	 * 			and initialized. The message depth - the maximum number of messages to be
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
-	 * 			automatically set to the maximum message queue message size. The operating system
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
-	 * 						sender. Default is three.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
-	 * 							This should be left default.
-	 */
-	MessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
-	 */
-	virtual ~MessageQueue();
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false );
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply( MessageQueueMessageIF* message );
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-protected:
-	/**
-	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
-	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * The name of the message queue, stored for unlinking
-	 */
-	char name[16];
-
-	static uint16_t queueCounter;
-	const size_t maxMessageSize;
-
-	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+
+#include <mqueue.h>
+/**
+ * @brief		This class manages sending and receiving of message queue messages.
+ *
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details	By making use of the according operating system call, a message queue is created
+	 * 			and initialized. The message depth - the maximum number of messages to be
+	 * 			buffered - may be set with the help of a parameter, whereas the message size is
+	 * 			automatically set to the maximum message queue message size. The operating system
+	 * 			sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth	The number of messages to be buffered before passing an error to the
+	 * 						sender. Default is three.
+	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
+	 * 							This should be left default.
+	 */
+	MessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 */
+	virtual ~MessageQueue();
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false );
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply( MessageQueueMessageIF* message );
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * 			message's content is cleared and the function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false );
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+protected:
+	/**
+	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
+	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * The name of the message queue, stored for unlinking
+	 */
+	char name[16];
+
+	static uint16_t queueCounter;
+	const size_t maxMessageSize;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 03789e62..20be8aee 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,111 +1,111 @@
-#include <framework/osal/linux/Mutex.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/timemanager/Clock.h>
-
-uint8_t Mutex::count = 0;
-
-
-#include <cstring>
-#include <errno.h>
-
-Mutex::Mutex() {
-	pthread_mutexattr_t mutexAttr;
-	int status = pthread_mutexattr_init(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
-	}
-	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
-				<< std::endl;
-	}
-	status = pthread_mutex_init(&mutex, &mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
-				<< ", " << " failed with " << strerror(status) << std::endl;
-	}
-	// After a mutex attributes object has been used to initialize one or more
-	// mutexes, any function affecting the attributes object
-	// (including destruction) shall not affect any previously initialized mutexes.
-	status = pthread_mutexattr_destroy(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	//No Status check yet
-	pthread_mutex_destroy(&mutex);
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	int status = 0;
-
-	if(timeoutType == TimeoutType::POLLING) {
-	    status = pthread_mutex_trylock(&mutex);
-	}
-	else if (timeoutType == TimeoutType::WAITING) {
-		timespec timeOut;
-		clock_gettime(CLOCK_REALTIME, &timeOut);
-		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
-		nseconds += timeoutMs * 1000000;
-		timeOut.tv_sec = nseconds / 1000000000;
-		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
-		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	}
-	else if(timeoutType == TimeoutType::BLOCKING) {
-		status = pthread_mutex_lock(&mutex);
-	}
-
-	switch (status) {
-	case EINVAL:
-		// The mutex was created with the protocol attribute having the value
-		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
-		// than the mutex's current priority ceiling.
-		return WRONG_ATTRIBUTE_SETTING;
-		// The process or thread would have blocked, and the abs_timeout
-		// parameter specified a nanoseconds field value less than zero or
-		// greater than or equal to 1000 million.
-		// The value specified by mutex does not refer to an initialized mutex object.
-		//return MUTEX_NOT_FOUND;
-	case EBUSY:
-		// The mutex could not be acquired because it was already locked.
-		return MUTEX_ALREADY_LOCKED;
-	case ETIMEDOUT:
-		// The mutex could not be locked before the specified timeout expired.
-		return MUTEX_TIMEOUT;
-	case EAGAIN:
-		// The mutex could not be acquired because the maximum number of
-		// recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EDEADLK:
-		// A deadlock condition was detected or the current thread
-		// already owns the mutex.
-		return CURR_THREAD_ALREADY_OWNS_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	int status = pthread_mutex_unlock(&mutex);
-	switch (status) {
-	case EINVAL:
-		//The value specified by mutex does not refer to an initialized mutex object.
-		return MUTEX_NOT_FOUND;
-	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EPERM:
-		//The current thread does not own the mutex.
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
+#include "../../osal/linux/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+uint8_t Mutex::count = 0;
+
+
+#include <cstring>
+#include <errno.h>
+
+Mutex::Mutex() {
+	pthread_mutexattr_t mutexAttr;
+	int status = pthread_mutexattr_init(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+	}
+	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+				<< std::endl;
+	}
+	status = pthread_mutex_init(&mutex, &mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
+				<< ", " << " failed with " << strerror(status) << std::endl;
+	}
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
+	status = pthread_mutexattr_destroy(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	//No Status check yet
+	pthread_mutex_destroy(&mutex);
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
+	int status = 0;
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	else if (timeoutType == TimeoutType::WAITING) {
+		timespec timeOut;
+		clock_gettime(CLOCK_REALTIME, &timeOut);
+		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+		nseconds += timeoutMs * 1000000;
+		timeOut.tv_sec = nseconds / 1000000000;
+		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+		status = pthread_mutex_timedlock(&mutex, &timeOut);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+		status = pthread_mutex_lock(&mutex);
+	}
+
+	switch (status) {
+	case EINVAL:
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
+		return WRONG_ATTRIBUTE_SETTING;
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
+		//return MUTEX_NOT_FOUND;
+	case EBUSY:
+		// The mutex could not be acquired because it was already locked.
+		return MUTEX_ALREADY_LOCKED;
+	case ETIMEDOUT:
+		// The mutex could not be locked before the specified timeout expired.
+		return MUTEX_TIMEOUT;
+	case EAGAIN:
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EDEADLK:
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
+		return CURR_THREAD_ALREADY_OWNS_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	int status = pthread_mutex_unlock(&mutex);
+	switch (status) {
+	case EINVAL:
+		//The value specified by mutex does not refer to an initialized mutex object.
+		return MUTEX_NOT_FOUND;
+	case EAGAIN:
+		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EPERM:
+		//The current thread does not own the mutex.
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 26420c2e..77a11fe4 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,22 +1,22 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-extern "C" {
-#include <pthread.h>
-}
-
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
-	virtual ReturnValue_t unlockMutex();
-private:
-	pthread_mutex_t mutex;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+extern "C" {
+#include <pthread.h>
+}
+
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	virtual ~Mutex();
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
+	virtual ReturnValue_t unlockMutex();
+private:
+	pthread_mutex_t mutex;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index d769cc33..70dc3c71 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,23 +1,23 @@
-#include <framework/ipc/MutexFactory.h>
-#include <framework/osal/linux/Mutex.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/linux/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index cd487531..9b6148c5 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,82 +1,82 @@
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/PeriodicPosixTask.h>
-
-#include <errno.h>
-
-PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
-		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
-		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
-}
-
-PeriodicPosixTask::~PeriodicPosixTask() {
-	//Not Implemented
-}
-
-void* PeriodicPosixTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return NULL;
-}
-
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implements ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-
-ReturnValue_t PeriodicPosixTask::startTask(void) {
-	started = true;
-	//sif::info << stackSize << std::endl;
-	PosixThread::createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicPosixTask::taskFunctionality(void) {
-	if(!started){
-		suspend();
-	}
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
-			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status == 0){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
-			}
-			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
-			}
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-uint32_t PeriodicPosixTask::getPeriodMs() const {
-	return periodMs;
-}
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+
+#include <errno.h>
+
+PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
+		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
+		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
+}
+
+PeriodicPosixTask::~PeriodicPosixTask() {
+	//Not Implemented
+}
+
+void* PeriodicPosixTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return NULL;
+}
+
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implements ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+
+ReturnValue_t PeriodicPosixTask::startTask(void) {
+	started = true;
+	//sif::info << stackSize << std::endl;
+	PosixThread::createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicPosixTask::taskFunctionality(void) {
+	if(!started){
+		suspend();
+	}
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+			char name[20] = {0};
+			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
+			if(status == 0){
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
+			}
+			else {
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
+			}
+			if (this->deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+uint32_t PeriodicPosixTask::getPeriodMs() const {
+	return periodMs;
+}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 0b2d51cd..59302e43 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <vector>
-
-class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t period_, void(*deadlineMissedFunc_)());
-	virtual ~PeriodicPosixTask();
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void) override;
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-private:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	/**
-	 * @brief Flag to indicate that the task was started and is allowed to run
-	 */
-	bool started;
-
-
-	/**
-	 * @brief Period of the task in milliseconds
-	 */
-	uint32_t periodMs;
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details	The method sets and starts
-	 * 			the task's period, then enters a loop that is repeated indefinitely. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the task will be blocked until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	virtual void taskFunctionality(void);
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
-	 */
-	static void* taskEntryPoint(void* arg);
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
-	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
-	 * 			of the periodic task.
-	 */
-	void (*deadlineMissedFunc)();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../osal/linux/PosixThread.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include <vector>
+
+class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
+	virtual ~PeriodicPosixTask();
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void) override;
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+private:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	/**
+	 * @brief Flag to indicate that the task was started and is allowed to run
+	 */
+	bool started;
+
+
+	/**
+	 * @brief Period of the task in milliseconds
+	 */
+	uint32_t periodMs;
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details	The method sets and starts
+	 * 			the task's period, then enters a loop that is repeated indefinitely. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the task will be blocked until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	virtual void taskFunctionality(void);
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
+	 * 			Needs a valid pointer to the derived class.
+	 */
+	static void* taskEntryPoint(void* arg);
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
+	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
+	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
+	 * 			of the periodic task.
+	 */
+	void (*deadlineMissedFunc)();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index d84c8d9d..70c63c4a 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,217 +1,217 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/osal/linux/PosixThread.h>
-#include <cstring>
-#include <errno.h>
-
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-    name[0] = '\0';
-    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
-}
-
-PosixThread::~PosixThread() {
-	//No deletion and no free of Stack Pointer
-}
-
-ReturnValue_t PosixThread::sleep(uint64_t ns) {
-	//TODO sleep might be better with timer instead of sleep()
-	timespec time;
-	time.tv_sec = ns/1000000000;
-	time.tv_nsec = ns - time.tv_sec*1e9;
-
-	//Remaining Time is not set here
-	int status = nanosleep(&time,NULL);
-	if(status != 0){
-		switch(errno){
-		case EINTR:
-			//The nanosleep() function was interrupted by a signal.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or
-			// greater than or equal to 1000 million.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PosixThread::suspend() {
-	//Wait for SIGUSR1
-	int caughtSig = 0;
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	sigwait(&waitSignal, &caughtSig);
-	if (caughtSig != SIGUSR1) {
-		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
-				caughtSig << std::endl;
-	}
-}
-
-void PosixThread::resume(){
-	/* Signal the thread to start. Makes sense to call kill to start or? ;)
-	 *
-	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
-	*	but as the call must be done from the thread itsself this is not possible here
-	*/
-	pthread_kill(thread,SIGUSR1);
-}
-
-bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
-		const uint64_t delayTime_ms) {
-	uint64_t nextTimeToWake_ms;
-	bool shouldDelay = false;
-	//Get current Time
-	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
-	/* Generate the tick time at which the task wants to wake. */
-	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
-
-	if (currentTime_ms < *prevoiusWakeTime_ms) {
-		/* The tick count has overflowed since this function was
-		 lasted called.  In this case the only time we should ever
-		 actually delay is if the wake time has also	overflowed,
-		 and the wake time is greater than the tick time.  When this
-		 is the case it is as if neither time had overflowed. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				&& (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	} else {
-		/* The tick time has not overflowed.  In this case we will
-		 delay if either the wake time has overflowed, and/or the
-		 tick time is less than the wake time. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				|| (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	}
-
-	/* Update the wake time ready for the next call. */
-
-	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
-
-	if (shouldDelay) {
-		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
-		PosixThread::sleep(sleepTime * 1000000ull);
-		return true;
-	}
-	//We are shifting the time in case the deadline was missed like rtems
-	(*prevoiusWakeTime_ms) = currentTime_ms;
-	return false;
-
-}
-
-
-uint64_t PosixThread::getCurrentMonotonicTimeMs(){
-	timespec timeNow;
-	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
-	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
-				+ timeNow.tv_nsec / 1000000;
-
-	return currentTime_ms;
-}
-
-
-void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	//sif::debug << "PosixThread::createTask" << std::endl;
-	/*
-	 * The attr argument points to a pthread_attr_t structure whose contents
-       are used at thread creation time to determine attributes for the new
-       thread; this structure is initialized using pthread_attr_init(3) and
-       related functions.  If attr is NULL, then the thread is created with
-       default attributes.
-	 */
-	pthread_attr_t attributes;
-	int status = pthread_attr_init(&attributes);
-	if(status != 0){
-		sif::error << "Posix Thread attribute init failed with: " <<
-				strerror(status) << std::endl;
-	}
-	void* stackPointer;
-	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: Stack init failed with: " <<
-				strerror(status) << std::endl;
-		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
-			sif::error << "PosixThread::createTask: Insufficient memory for"
-					" the requested " << stackMb << " MB" << std::endl;
-		}
-		else if(errno == EINVAL) {
-			sif::error << "PosixThread::createTask: Wrong alignment argument!"
-					<< std::endl;
-		}
-		return;
-	}
-
-	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: pthread_attr_setstack "
-				" failed with: " << strerror(status) <<  std::endl;
-		sif::error << "Make sure the specified stack size is valid and is "
-				"larger than the minimum allowed stack size." << std::endl;
-	}
-
-	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
-	if(status != 0){
-			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
-					strerror(status) << std::endl;
-	}
-
-	// TODO FIFO -> This needs root privileges for the process
-	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule policy failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	sched_param scheduleParams;
-	scheduleParams.__sched_priority = priority;
-	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule params failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	//Set Signal Mask for suspend until startTask is called
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
-	if(status != 0){
-		sif::error << "Posix Thread sigmask failed failed with: " <<
-				strerror(status) << " errno: " << strerror(errno) << std::endl;
-	}
-
-
-	status = pthread_create(&thread,&attributes,fnc_,arg_);
-	if(status != 0){
-		sif::error << "Posix Thread create failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	status = pthread_setname_np(thread,name);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: setname failed with: " <<
-				strerror(status) << std::endl;
-		if(status == ERANGE) {
-			sif::error << "PosixThread::createTask: Task name length longer"
-					" than 16 chars. Truncating.." << std::endl;
-			name[15] = '\0';
-			status = pthread_setname_np(thread,name);
-			if(status != 0){
-				sif::error << "PosixThread::createTask: Setting name"
-						" did not work.." << std::endl;
-			}
-		}
-	}
-
-	status = pthread_attr_destroy(&attributes);
-	if(status!=0){
-		sif::error << "Posix Thread attribute destroy failed with: " <<
-				strerror(status) << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PosixThread.h"
+#include <cstring>
+#include <errno.h>
+
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
+
+PosixThread::~PosixThread() {
+	//No deletion and no free of Stack Pointer
+}
+
+ReturnValue_t PosixThread::sleep(uint64_t ns) {
+	//TODO sleep might be better with timer instead of sleep()
+	timespec time;
+	time.tv_sec = ns/1000000000;
+	time.tv_nsec = ns - time.tv_sec*1e9;
+
+	//Remaining Time is not set here
+	int status = nanosleep(&time,NULL);
+	if(status != 0){
+		switch(errno){
+		case EINTR:
+			//The nanosleep() function was interrupted by a signal.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case EINVAL:
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PosixThread::suspend() {
+	//Wait for SIGUSR1
+	int caughtSig = 0;
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	sigwait(&waitSignal, &caughtSig);
+	if (caughtSig != SIGUSR1) {
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
+	}
+}
+
+void PosixThread::resume(){
+	/* Signal the thread to start. Makes sense to call kill to start or? ;)
+	 *
+	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
+	*	but as the call must be done from the thread itsself this is not possible here
+	*/
+	pthread_kill(thread,SIGUSR1);
+}
+
+bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
+		const uint64_t delayTime_ms) {
+	uint64_t nextTimeToWake_ms;
+	bool shouldDelay = false;
+	//Get current Time
+	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
+	/* Generate the tick time at which the task wants to wake. */
+	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
+
+	if (currentTime_ms < *prevoiusWakeTime_ms) {
+		/* The tick count has overflowed since this function was
+		 lasted called.  In this case the only time we should ever
+		 actually delay is if the wake time has also	overflowed,
+		 and the wake time is greater than the tick time.  When this
+		 is the case it is as if neither time had overflowed. */
+		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+				&& (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	} else {
+		/* The tick time has not overflowed.  In this case we will
+		 delay if either the wake time has overflowed, and/or the
+		 tick time is less than the wake time. */
+		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+				|| (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	}
+
+	/* Update the wake time ready for the next call. */
+
+	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
+
+	if (shouldDelay) {
+		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
+		PosixThread::sleep(sleepTime * 1000000ull);
+		return true;
+	}
+	//We are shifting the time in case the deadline was missed like rtems
+	(*prevoiusWakeTime_ms) = currentTime_ms;
+	return false;
+
+}
+
+
+uint64_t PosixThread::getCurrentMonotonicTimeMs(){
+	timespec timeNow;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
+	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
+				+ timeNow.tv_nsec / 1000000;
+
+	return currentTime_ms;
+}
+
+
+void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+	//sif::debug << "PosixThread::createTask" << std::endl;
+	/*
+	 * The attr argument points to a pthread_attr_t structure whose contents
+       are used at thread creation time to determine attributes for the new
+       thread; this structure is initialized using pthread_attr_init(3) and
+       related functions.  If attr is NULL, then the thread is created with
+       default attributes.
+	 */
+	pthread_attr_t attributes;
+	int status = pthread_attr_init(&attributes);
+	if(status != 0){
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
+	}
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
+				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			uint64_t stackMb = stackSize/10e6;
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
+	}
+
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
+	}
+
+	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
+	if(status != 0){
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
+	}
+
+	// TODO FIFO -> This needs root privileges for the process
+	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	sched_param scheduleParams;
+	scheduleParams.__sched_priority = priority;
+	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	//Set Signal Mask for suspend until startTask is called
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
+	if(status != 0){
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
+	}
+
+
+	status = pthread_create(&thread,&attributes,fnc_,arg_);
+	if(status != 0){
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	status = pthread_setname_np(thread,name);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: setname failed with: " <<
+				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+	}
+
+	status = pthread_attr_destroy(&attributes);
+	if(status!=0){
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
+	}
+}
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index e9d31728..9d6097f7 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <pthread.h>
-#include <signal.h>
-#include <cstdlib>
-#include <unistd.h>
-
-class PosixThread {
-public:
-	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-	PosixThread(const char* name_, int priority_, size_t stackSize_);
-	virtual ~PosixThread();
-	/**
-	 * Set the Thread to sleep state
-	 * @param ns Nanosecond sleep time
-	 * @return Returns Failed if sleep fails
-	 */
-	static ReturnValue_t sleep(uint64_t ns);
-	/**
-	 * @brief Function to suspend the task until SIGUSR1 was received
-	 *
-	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
-	 */
-	void suspend();
-
-	/**
-	 * @brief Function to allow a other thread to start the thread again from suspend state
-	 *
-	 * @details Restarts the Thread after suspend call
-	 */
-	void resume();
-
-
-	/**
-	 * Delay function similar to FreeRtos delayUntil function
-	 *
-	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
-	 * @param delayTime_ms Time period to delay
-	 *
-	 * @return False If deadline was missed; True if task was delayed
-	 */
-	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
-
-	/**
-	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
-	 *
-	 * @return current time in milliseconds from CLOCK_MONOTONIC
-	 */
-	static uint64_t getCurrentMonotonicTimeMs();
-
-protected:
-	pthread_t thread;
-
-	/**
-	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument.
-	 * @details
-	 * This function creates a pthread with the given parameters. As the
-	 * function requires a pointer to the derived object it has to be called
-	 * after the this pointer of the derived object is valid.
-	 * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param fnc_ Function which will be executed by the thread.
-	 * @param arg_
-	 * argument of the taskEntryPoint function, needs to be this pointer
-	 * of derived class
-	 */
-	void createTask(void* (*fnc_)(void*),void* arg_);
-
-private:
-	char name[PTHREAD_MAX_NAMELEN];
-	int priority;
-	size_t stackSize = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
+
+class PosixThread {
+public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
+	PosixThread(const char* name_, int priority_, size_t stackSize_);
+	virtual ~PosixThread();
+	/**
+	 * Set the Thread to sleep state
+	 * @param ns Nanosecond sleep time
+	 * @return Returns Failed if sleep fails
+	 */
+	static ReturnValue_t sleep(uint64_t ns);
+	/**
+	 * @brief Function to suspend the task until SIGUSR1 was received
+	 *
+	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
+	 */
+	void suspend();
+
+	/**
+	 * @brief Function to allow a other thread to start the thread again from suspend state
+	 *
+	 * @details Restarts the Thread after suspend call
+	 */
+	void resume();
+
+
+	/**
+	 * Delay function similar to FreeRtos delayUntil function
+	 *
+	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
+	 * @param delayTime_ms Time period to delay
+	 *
+	 * @return False If deadline was missed; True if task was delayed
+	 */
+	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
+
+	/**
+	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
+	 *
+	 * @return current time in milliseconds from CLOCK_MONOTONIC
+	 */
+	static uint64_t getCurrentMonotonicTimeMs();
+
+protected:
+	pthread_t thread;
+
+	/**
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument.
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
+	 */
+	void createTask(void* (*fnc_)(void*),void* arg_);
+
+private:
+	char name[PTHREAD_MAX_NAMELEN];
+	int priority;
+	size_t stackSize = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index 8bd9d52c..d1332504 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,38 +1,38 @@
-#include <framework/ipc/QueueFactory.h>
-#include <mqueue.h>
-#include <errno.h>
-#include <framework/osal/linux/MessageQueue.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <cstring>
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include <mqueue.h>
+#include <errno.h>
+#include "../../osal/linux/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 4fbd60d9..43b1978d 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,36 +1,36 @@
-#include <framework/tasks/SemaphoreFactory.h>
-#include <framework/osal/linux/BinarySemaphore.h>
-#include <framework/osal/linux/CountingSemaphore.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	return new BinarySemaphore();
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
-		uint8_t initCount, uint32_t arguments) {
-	return new CountingSemaphore(maxCount, initCount);
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	return new BinarySemaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	return new CountingSemaphore(maxCount, initCount);
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 219630a7..1cd0b2b1 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,42 +1,42 @@
-#include <framework/osal/linux/FixedTimeslotTask.h>
-#include <framework/osal/linux/PeriodicPosixTask.h>
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_ * 1000, deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_*1000);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	return PosixThread::sleep(delayMs*1000000ull);
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../osal/linux/FixedTimeslotTask.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	return PosixThread::sleep(delayMs*1000000ull);
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 8cf7b285..04c1d255 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,137 +1,137 @@
-#include <framework/osal/linux/TcUnixUdpPollingTask.h>
-#include <framework/globalfunctions/arrayprinter.h>
-
-TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
-		object_id_t tmtcUnixUdpBridge, size_t frameSize,
-		double timeoutSeconds): SystemObject(objectId),
-		tmtcBridgeId(tmtcUnixUdpBridge) {
-
-	if(frameSize > 0) {
-		this->frameSize = frameSize;
-	}
-	else {
-		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
-	}
-
-	// Set up reception buffer with specified frame size.
-	// For now, it is assumed that only one frame is held in the buffer!
-	receptionBuffer.reserve(this->frameSize);
-	receptionBuffer.resize(this->frameSize);
-
-	if(timeoutSeconds == -1) {
-		receptionTimeout = DEFAULT_TIMEOUT;
-	}
-	else {
-		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
-	}
-}
-
-TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
-
-ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
-	// Poll for new UDP datagrams in permanent loop.
-	while(1) {
-		//! Sender Address is cached here.
-		struct sockaddr_in senderAddress;
-		socklen_t senderSockLen = 0;
-		ssize_t bytesReceived = recvfrom(serverUdpSocket,
-				receptionBuffer.data(), frameSize, receptionFlags,
-				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
-		if(bytesReceived < 0) {
-			// handle error
-			sif::error << "TcSocketPollingTask::performOperation: Reception"
-					"error." << std::endl;
-			handleReadError();
-
-			continue;
-		}
-//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-//				<< " bytes received" << std::endl;
-
-		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
-		if(result != HasReturnvaluesIF::RETURN_FAILED) {
-
-		}
-		tmtcBridge->registerCommConnect();
-		tmtcBridge->checkAndSetClientAddress(senderAddress);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId;
-	ReturnValue_t result = tcStore->addData(&storeId,
-			receptionBuffer.data(), bytesRead);
-	// arrayprinter::print(receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-				"storage failed" << std::endl;
-		sif::error << "Packet size: " << bytesRead << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	TmTcMessage message(storeId);
-
-	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Serial Polling: Sending message to queue failed"
-				<< std::endl;
-		tcStore->deleteData(storeId);
-	}
-	return result;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == nullptr) {
-		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
-	if(tmtcBridge == nullptr) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
-				" TMTC bridge object!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	serverUdpSocket = tmtcBridge->serverSocket;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
-	// Initialize the destination after task creation. This ensures
-	// that the destination will be set in the TMTC bridge.
-	targetTcDestination = tmtcBridge->getRequestQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
-	timeval tval;
-	tval = timevalOperations::toTimeval(timeoutSeconds);
-	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-			&tval, sizeof(receptionTimeout));
-	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-				"receive timeout failed with " << strerror(errno) << std::endl;
-	}
-}
-
-void TcUnixUdpPollingTask::handleReadError() {
-	switch(errno) {
-	case(EAGAIN): {
-		// todo: When working in timeout mode, this will occur more often
-		// and is not an error.
-		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
-				<< std::endl;
-		break;
-	}
-	default: {
-		sif::error << "TcUnixUdpPollingTask::handleReadError: "
-				<< strerror(errno) << std::endl;
-	}
-	}
-}
+#include "../../osal/linux/TcUnixUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+
+TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+}
+
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
+
+ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		socklen_t senderSockLen = 0;
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				receptionBuffer.data(), frameSize, receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
+		if(bytesReceived < 0) {
+			// handle error
+			sif::error << "TcSocketPollingTask::performOperation: Reception"
+					"error." << std::endl;
+			handleReadError();
+
+			continue;
+		}
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
+		tmtcBridge->registerCommConnect();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination will be set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
+	timeval tval;
+	tval = timevalOperations::toTimeval(timeoutSeconds);
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&tval, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+void TcUnixUdpPollingTask::handleReadError() {
+	switch(errno) {
+	case(EAGAIN): {
+		// todo: When working in timeout mode, this will occur more often
+		// and is not an error.
+		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
+				<< std::endl;
+		break;
+	}
+	default: {
+		sif::error << "TcUnixUdpPollingTask::handleReadError: "
+				<< strerror(errno) << std::endl;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index d8de1458..9d678a81 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,67 +1,67 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-
-#include <sys/socket.h>
-#include <vector>
-
-/**
- * @brief 	This class can be used to implement the polling of a Unix socket,
- * 			using UDP for now.
- * @details
- * The task will be blocked while the specified number of bytes has not been
- * received, so TC reception is handled inside a separate task.
- * This class caches the IP address of the sender. It is assumed there
- * is only one sender for now.
- */
-class TcUnixUdpPollingTask: public SystemObject,
-		public ExecutableObjectIF {
-	friend class TmTcUnixUdpBridge;
-public:
-	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
-	//! 0.5  default milliseconds timeout for now.
-	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
-
-	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-			size_t frameSize = 0, double timeoutSeconds = -1);
-	virtual~ TcUnixUdpPollingTask();
-
-	/**
-	 * Turn on optional timeout for UDP polling. In the default mode,
-	 * the receive function will block until a packet is received.
-	 * @param timeoutSeconds
-	 */
-	void setTimeout(double timeoutSeconds);
-
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual ReturnValue_t initialize() override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-protected:
-	StorageManagerIF* tcStore = nullptr;
-
-private:
-	//! TMTC bridge is cached.
-	object_id_t tmtcBridgeId = objects::NO_OBJECT;
-	TmTcUnixUdpBridge* tmtcBridge = nullptr;
-	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
-	//! Reception flags: https://linux.die.net/man/2/recvfrom.
-	int receptionFlags = 0;
-
-	//! Server socket, which is member of TMTC bridge and is assigned in
-	//! constructor
-	int serverUdpSocket = 0;
-
-	std::vector<uint8_t> receptionBuffer;
-
-	size_t frameSize = 0;
-	timeval receptionTimeout;
-
-	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-	void handleReadError();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+
+#include "../../objectmanager/SystemObject.h"
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <sys/socket.h>
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcUnixUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcUnixUdpPollingTask();
+
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	int serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
+	void handleReadError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 5e27c328..e4539521 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,42 +1,42 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <errno.h>
-#include <framework/osal/linux/Timer.h>
-
-Timer::Timer() {
-	sigevent sigEvent;
-	sigEvent.sigev_notify = SIGEV_NONE;
-	sigEvent.sigev_signo = 0;
-	sigEvent.sigev_value.sival_ptr = &timerId;
-	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
-	if(status!=0){
-		sif::error << "Timer creation failed with: " << status <<
-				" errno: " << errno << std::endl;
-	}
-}
-
-Timer::~Timer() {
-	timer_delete(timerId);
-}
-
-int Timer::setTimer(uint32_t intervalMs) {
-	itimerspec timer;
-	timer.it_value.tv_sec = intervalMs / 1000;
-	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	return timer_settime(timerId, 0, &timer, NULL);
-}
-
-
-int Timer::getTimer(uint32_t* remainingTimeMs){
-	itimerspec timer;
-	timer.it_value.tv_sec = 0;
-	timer.it_value.tv_nsec = 0;
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	int status = timer_gettime(timerId, &timer);
-
-	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
-
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <errno.h>
+#include "../../osal/linux/Timer.h"
+
+Timer::Timer() {
+	sigevent sigEvent;
+	sigEvent.sigev_notify = SIGEV_NONE;
+	sigEvent.sigev_signo = 0;
+	sigEvent.sigev_value.sival_ptr = &timerId;
+	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
+	if(status!=0){
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
+	}
+}
+
+Timer::~Timer() {
+	timer_delete(timerId);
+}
+
+int Timer::setTimer(uint32_t intervalMs) {
+	itimerspec timer;
+	timer.it_value.tv_sec = intervalMs / 1000;
+	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	return timer_settime(timerId, 0, &timer, NULL);
+}
+
+
+int Timer::getTimer(uint32_t* remainingTimeMs){
+	itimerspec timer;
+	timer.it_value.tv_sec = 0;
+	timer.it_value.tv_nsec = 0;
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	int status = timer_gettime(timerId, &timer);
+
+	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
+
+	return status;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 2cdb93f3..57722b3f 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,168 +1,168 @@
-#include <framework/osal/linux/TmTcUnixUdpBridge.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/ipc/MutexHelper.h>
-
-#include <errno.h>
-#include <arpa/inet.h>
-
-TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-		uint16_t serverPort, uint16_t clientPort):
-		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-	mutex = MutexFactory::instance()->createMutex();
-
-	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
-	if(serverPort != 0xFFFF) {
-		setServerPort = serverPort;
-	}
-
-	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-	if(clientPort != 0xFFFF) {
-		setClientPort = clientPort;
-	}
-
-	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
-	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
-	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-	if(socket < 0) {
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
-				" UDP socket!" << std::endl;
-		handleSocketError();
-		return;
-	}
-
-	serverAddress.sin_family = AF_INET;
-
-	// Accept packets from any interface.
-	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
-	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	serverAddress.sin_port = htons(setServerPort);
-	serverAddressLen = sizeof(serverAddress);
-	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
-			sizeof(serverSocketOptions));
-
-	clientAddress.sin_family = AF_INET;
-	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	clientAddress.sin_port = htons(setClientPort);
-	clientAddressLen = sizeof(clientAddress);
-
-	int result = bind(serverSocket,
-			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			serverAddressLen);
-	if(result == -1) {
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-				"local port " << setServerPort << " to server socket!"
-				<< std::endl;
-		handleBindError();
-		return;
-	}
-}
-
-TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
-}
-
-ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-	int flags = 0;
-
-	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
-	clientAddressLen = sizeof(serverAddress);
-
-//	char ipAddress [15];
-//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-
-	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
-			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
-	if(bytesSent < 0) {
-		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
-				<< std::endl;
-		handleSendError();
-	}
-//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-//			" sent." << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
-
-//	char ipAddress [15];
-//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
-//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-
-	// Set new IP address if it has changed.
-	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
-		clientAddressLen = sizeof(clientAddress);
-	}
-}
-
-void TmTcUnixUdpBridge::handleSocketError() {
-
-	// See: https://man7.org/linux/man-pages/man2/socket.2.html
-	switch(errno) {
-	case(EACCES):
-	case(EINVAL):
-	case(EMFILE):
-	case(ENFILE):
-	case(EAFNOSUPPORT):
-	case(ENOBUFS):
-	case(ENOMEM):
-	case(EPROTONOSUPPORT):
-		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-		break;
-	default:
-		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
-				<< std::endl;
-		break;
-	}
-}
-
-void TmTcUnixUdpBridge::handleBindError() {
-	// See: https://man7.org/linux/man-pages/man2/bind.2.html
-	switch(errno) {
-	case(EACCES): {
-		/*
-		 Ephermeral ports can be shown with following command:
-		 sysctl -A | grep ip_local_port_range
-		 */
-		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
-				"Ports 1-1024 are reserved on UNIX systems and require root "
-				"rights while ephermeral ports should not be used as well."
-				<< std::endl;
-	}
-	break;
-	case(EADDRINUSE):
-	case(EBADF):
-	case(EINVAL):
-	case(ENOTSOCK):
-	case(EADDRNOTAVAIL):
-	case(EFAULT):
-	case(ELOOP):
-	case(ENAMETOOLONG):
-	case(ENOENT):
-	case(ENOMEM):
-	case(ENOTDIR):
-	case(EROFS): {
-		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-		break;
-	}
-	default:
-		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
-				<< std::endl;
-		break;
-	}
-}
-
-void TmTcUnixUdpBridge::handleSendError() {
-	switch(errno) {
-	default:
-		sif::error << "Error: " << strerror(errno) << std::endl;
-	}
-}
-
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../ipc/MutexHelper.h"
+
+#include <errno.h>
+#include <arpa/inet.h>
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+		uint16_t serverPort, uint16_t clientPort):
+		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+	mutex = MutexFactory::instance()->createMutex();
+
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if(socket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		handleSocketError();
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+
+	// Accept packets from any interface.
+	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(setServerPort);
+	serverAddressLen = sizeof(serverAddress);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	clientAddress.sin_family = AF_INET;
+	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	clientAddress.sin_port = htons(setClientPort);
+	clientAddressLen = sizeof(clientAddress);
+
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			serverAddressLen);
+	if(result == -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << setServerPort << " to server socket!"
+				<< std::endl;
+		handleBindError();
+		return;
+	}
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+
+	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+	clientAddressLen = sizeof(serverAddress);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
+			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	if(bytesSent < 0) {
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
+				<< std::endl;
+		handleSendError();
+	}
+//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//			" sent." << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+		clientAddressLen = sizeof(clientAddress);
+	}
+}
+
+void TmTcUnixUdpBridge::handleSocketError() {
+
+	// See: https://man7.org/linux/man-pages/man2/socket.2.html
+	switch(errno) {
+	case(EACCES):
+	case(EINVAL):
+	case(EMFILE):
+	case(ENFILE):
+	case(EAFNOSUPPORT):
+	case(ENOBUFS):
+	case(ENOMEM):
+	case(EPROTONOSUPPORT):
+		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleBindError() {
+	// See: https://man7.org/linux/man-pages/man2/bind.2.html
+	switch(errno) {
+	case(EACCES): {
+		/*
+		 Ephermeral ports can be shown with following command:
+		 sysctl -A | grep ip_local_port_range
+		 */
+		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
+				"Ports 1-1024 are reserved on UNIX systems and require root "
+				"rights while ephermeral ports should not be used as well."
+				<< std::endl;
+	}
+	break;
+	case(EADDRINUSE):
+	case(EBADF):
+	case(EINVAL):
+	case(ENOTSOCK):
+	case(EADDRNOTAVAIL):
+	case(EFAULT):
+	case(ELOOP):
+	case(ENAMETOOLONG):
+	case(ENOENT):
+	case(ENOMEM):
+	case(ENOTDIR):
+	case(EROFS): {
+		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	}
+	default:
+		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleSendError() {
+	switch(errno) {
+	default:
+		sif::error << "Error: " << strerror(errno) << std::endl;
+	}
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index dbddc6c3..e4aa8b1a 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,48 +1,48 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/TmTcBridge.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class TmTcUnixUdpBridge: public TmTcBridge {
-	friend class TcUnixUdpPollingTask;
-public:
-	// The ports chosen here should not be used by any other process.
-	// List of used ports on Linux: /etc/services
-	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
-	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
-
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-			object_id_t tmStoreId, object_id_t tcStoreId,
-			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
-	virtual~ TmTcUnixUdpBridge();
-
-	void checkAndSetClientAddress(sockaddr_in clientAddress);
-
-protected:
-	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
-
-private:
-	int serverSocket = 0;
-
-	const int serverSocketOptions = 0;
-
-	struct sockaddr_in clientAddress;
-	socklen_t clientAddressLen = 0;
-
-	struct sockaddr_in serverAddress;
-	socklen_t serverAddressLen = 0;
-
-	//! Access to the client address is mutex protected as it is set
-	//! by another task.
-	MutexIF* mutex;
-
-	void handleSocketError();
-	void handleBindError();
-	void handleSendError();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include "../../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../../tmtcservices/TmTcBridge.h"
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcUnixUdpPollingTask;
+public:
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId,
+			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	virtual~ TmTcUnixUdpBridge();
+
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+	int serverSocket = 0;
+
+	const int serverSocketOptions = 0;
+
+	struct sockaddr_in clientAddress;
+	socklen_t clientAddressLen = 0;
+
+	struct sockaddr_in serverAddress;
+	socklen_t serverAddressLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
+
+	void handleSocketError();
+	void handleBindError();
+	void handleSendError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 98198dd3..826d0b14 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,198 +1,198 @@
-#include <framework/timemanager/Clock.h>
-#include "RtemsBasic.h"
-#include <rtems/score/todimpl.h>
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-	return static_cast<uint32_t>(ticks_per_second);
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	rtems_time_of_day timeRtems;
-	timeRtems.year = time->year;
-	timeRtems.month = time->month;
-	timeRtems.day = time->day;
-	timeRtems.hour = time->hour;
-	timeRtems.minute  = time->minute;
-	timeRtems.second = time->second;
-	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-	rtems_status_code status = rtems_clock_set(&timeRtems);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_CLOCK:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
-	timespec newTime;
-	newTime.tv_sec = time->tv_sec;
-	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	//Callable from ISR
-	rtems_status_code status = rtems_clock_get_tod_timeval(time);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
-	timespec time;
-	rtems_status_code status = rtems_clock_get_uptime(&time);
-	uptime->tv_sec = time.tv_sec;
-	time.tv_nsec = time.tv_nsec / 1000;
-	uptime->tv_usec = time.tv_nsec;
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	//This counter overflows after 50 days
-	*uptimeMs = rtems_clock_get_ticks_since_boot();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval temp_time;
-	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-	switch(returnValue){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
-	rtems_status_code status = rtems_clock_get_tod(timeRtems);
-	switch (status) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		//system date and time is not set
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//time_buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	//Fails in 2038..
-	rtems_time_of_day timeRtems;
-	timeRtems.year = from->year;
-	timeRtems.month = from->month;
-	timeRtems.day = from->day;
-	timeRtems.hour = from->hour;
-	timeRtems.minute  = from->minute;
-	timeRtems.second = from->second;
-	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-	to->tv_sec = _TOD_To_seconds(&timeRtems);
-	to->tv_usec = from->usecond;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "RtemsBasic.h"
+#include <rtems/score/todimpl.h>
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+	return static_cast<uint32_t>(ticks_per_second);
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	rtems_time_of_day timeRtems;
+	timeRtems.year = time->year;
+	timeRtems.month = time->month;
+	timeRtems.day = time->day;
+	timeRtems.hour = time->hour;
+	timeRtems.minute  = time->minute;
+	timeRtems.second = time->second;
+	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+	rtems_status_code status = rtems_clock_set(&timeRtems);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_CLOCK:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	//TODO This routine uses _TOD_Set which is not
+	timespec newTime;
+	newTime.tv_sec = time->tv_sec;
+	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
+	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
+	//TODO Second parameter is ISR_lock_Context
+	_TOD_Set(&newTime,NULL);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	//Callable from ISR
+	rtems_status_code status = rtems_clock_get_tod_timeval(time);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
+	timespec time;
+	rtems_status_code status = rtems_clock_get_uptime(&time);
+	uptime->tv_sec = time.tv_sec;
+	time.tv_nsec = time.tv_nsec / 1000;
+	uptime->tv_usec = time.tv_nsec;
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	//This counter overflows after 50 days
+	*uptimeMs = rtems_clock_get_ticks_since_boot();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval temp_time;
+	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+	switch(returnValue){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
+	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	switch (status) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		//system date and time is not set
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//time_buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	//Fails in 2038..
+	rtems_time_of_day timeRtems;
+	timeRtems.year = from->year;
+	timeRtems.month = from->month;
+	timeRtems.day = from->day;
+	timeRtems.hour = from->hour;
+	timeRtems.minute  = from->minute;
+	timeRtems.second = from->second;
+	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+	to->tv_sec = _TOD_To_seconds(&timeRtems);
+	to->tv_usec = from->usecond;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index 61b66c3d..c5fac653 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -1,183 +1,183 @@
-#include "CpuUsage.h"
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <string.h>
-
-extern "C" {
-#include <rtems/cpuuse.h>
-}
-
-int handlePrint(void * token, const char *format, ...) {
-	CpuUsage *cpuUsage = (CpuUsage *) token;
-
-	if (cpuUsage->counter == 0) {
-		//header
-		cpuUsage->counter++;
-		return 0;
-	}
-
-	if (cpuUsage->counter % 2 == 1) {
-		{
-			//we can not tell when the last call is so we assume it be every uneven time
-			va_list vl;
-			va_start(vl, format);
-			float timeSinceLastReset = va_arg(vl,uint32_t);
-			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
-
-			timeSinceLastReset = timeSinceLastReset
-					+ (timeSinceLastResetDecimals / 1000.);
-
-			cpuUsage->timeSinceLastReset = timeSinceLastReset;
-
-			va_end(vl);
-		}
-		//task name and id
-		va_list vl;
-		va_start(vl, format);
-
-		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
-		const char *name = va_arg(vl,const char *);
-		memcpy(cpuUsage->cachedValue.name, name,
-				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
-
-		va_end(vl);
-
-	} else {
-		//statistics
-		va_list vl;
-		va_start(vl, format);
-		float run = va_arg(vl,uint32_t);
-		uint32_t runDecimals = va_arg(vl,uint32_t);
-		float percent = va_arg(vl,uint32_t);
-		uint32_t percent_decimals = va_arg(vl,uint32_t);
-
-		run = run + (runDecimals / 1000.);
-		percent = percent + (percent_decimals / 1000.);
-
-		cpuUsage->cachedValue.percentUsage = percent;
-		cpuUsage->cachedValue.timeRunning = run;
-
-		cpuUsage->threadData.insert(cpuUsage->cachedValue);
-
-		va_end(vl);
-	}
-	cpuUsage->counter++;
-
-	return 0;
-}
-
-CpuUsage::CpuUsage() :
-		counter(0), timeSinceLastReset(0) {
-
-}
-
-CpuUsage::~CpuUsage() {
-
-}
-
-void CpuUsage::resetCpuUsage() {
-	rtems_cpu_usage_reset();
-}
-
-void CpuUsage::read() {
-	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
-}
-
-void CpuUsage::clear() {
-	counter = 0;
-	timeSinceLastReset = 0;
-	threadData.clear();
-}
-
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, maxSize, streamEndianness);
-}
-
-uint32_t CpuUsage::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(timeSinceLastReset);
-	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, streamEndianness);
-}
-
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
-	*size += MAX_LENGTH_OF_THREAD_NAME;
-	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(id);
-	size += MAX_LENGTH_OF_THREAD_NAME;
-	size += sizeof(timeRunning);
-	size += sizeof(percentUsage);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
-		return STREAM_TOO_SHORT;
-	}
-	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
-	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "CpuUsage.h"
+#include "../../serialize/SerialArrayListAdapter.h"
+#include "../../serialize/SerializeAdapter.h"
+#include <string.h>
+
+extern "C" {
+#include <rtems/cpuuse.h>
+}
+
+int handlePrint(void * token, const char *format, ...) {
+	CpuUsage *cpuUsage = (CpuUsage *) token;
+
+	if (cpuUsage->counter == 0) {
+		//header
+		cpuUsage->counter++;
+		return 0;
+	}
+
+	if (cpuUsage->counter % 2 == 1) {
+		{
+			//we can not tell when the last call is so we assume it be every uneven time
+			va_list vl;
+			va_start(vl, format);
+			float timeSinceLastReset = va_arg(vl,uint32_t);
+			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
+
+			timeSinceLastReset = timeSinceLastReset
+					+ (timeSinceLastResetDecimals / 1000.);
+
+			cpuUsage->timeSinceLastReset = timeSinceLastReset;
+
+			va_end(vl);
+		}
+		//task name and id
+		va_list vl;
+		va_start(vl, format);
+
+		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
+		const char *name = va_arg(vl,const char *);
+		memcpy(cpuUsage->cachedValue.name, name,
+				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
+
+		va_end(vl);
+
+	} else {
+		//statistics
+		va_list vl;
+		va_start(vl, format);
+		float run = va_arg(vl,uint32_t);
+		uint32_t runDecimals = va_arg(vl,uint32_t);
+		float percent = va_arg(vl,uint32_t);
+		uint32_t percent_decimals = va_arg(vl,uint32_t);
+
+		run = run + (runDecimals / 1000.);
+		percent = percent + (percent_decimals / 1000.);
+
+		cpuUsage->cachedValue.percentUsage = percent;
+		cpuUsage->cachedValue.timeRunning = run;
+
+		cpuUsage->threadData.insert(cpuUsage->cachedValue);
+
+		va_end(vl);
+	}
+	cpuUsage->counter++;
+
+	return 0;
+}
+
+CpuUsage::CpuUsage() :
+		counter(0), timeSinceLastReset(0) {
+
+}
+
+CpuUsage::~CpuUsage() {
+
+}
+
+void CpuUsage::resetCpuUsage() {
+	rtems_cpu_usage_reset();
+}
+
+void CpuUsage::read() {
+	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
+}
+
+void CpuUsage::clear() {
+	counter = 0;
+	timeSinceLastReset = 0;
+	threadData.clear();
+}
+
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
+			size, maxSize, streamEndianness);
+}
+
+uint32_t CpuUsage::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(timeSinceLastReset);
+	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(
+			&timeSinceLastReset, buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
+			size, streamEndianness);
+}
+
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
+	*size += MAX_LENGTH_OF_THREAD_NAME;
+	*buffer += MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::serialize(&timeRunning,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&percentUsage,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t CpuUsage::ThreadData::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(id);
+	size += MAX_LENGTH_OF_THREAD_NAME;
+	size += sizeof(timeRunning);
+	size += sizeof(percentUsage);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
+		int32_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+		return STREAM_TOO_SHORT;
+	}
+	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
+	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::deSerialize(&timeRunning,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&percentUsage,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index eb03c5e3..24cbb919 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -1,53 +1,53 @@
-#ifndef CPUUSAGE_H_
-#define CPUUSAGE_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/serialize/SerializeIF.h>
-#include <stdarg.h>
-
-class CpuUsage : public SerializeIF {
-public:
-	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
-
-	class ThreadData: public SerializeIF {
-	public:
-		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
-
-		uint32_t id;
-		char name[MAX_LENGTH_OF_THREAD_NAME];
-		float timeRunning;
-		float percentUsage;
-
-		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const override;
-
-		virtual size_t getSerializedSize() const override;
-
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness) override;
-	};
-
-	CpuUsage();
-	virtual ~CpuUsage();
-
-	uint8_t counter;
-	float timeSinceLastReset;
-	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
-	ThreadData cachedValue;
-
-	static void resetCpuUsage();
-
-	void read();
-
-	void clear();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-};
-
-#endif /* CPUUSAGE_H_ */
+#ifndef CPUUSAGE_H_
+#define CPUUSAGE_H_
+
+#include "../../container/FixedArrayList.h"
+#include "../../serialize/SerializeIF.h"
+#include <stdarg.h>
+
+class CpuUsage : public SerializeIF {
+public:
+	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
+
+	class ThreadData: public SerializeIF {
+	public:
+		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
+
+		uint32_t id;
+		char name[MAX_LENGTH_OF_THREAD_NAME];
+		float timeRunning;
+		float percentUsage;
+
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override;
+
+		virtual size_t getSerializedSize() const override;
+
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override;
+	};
+
+	CpuUsage();
+	virtual ~CpuUsage();
+
+	uint8_t counter;
+	float timeSinceLastReset;
+	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
+	ThreadData cachedValue;
+
+	static void resetCpuUsage();
+
+	void read();
+
+	void clear();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+};
+
+#endif /* CPUUSAGE_H_ */
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index dbe3172e..3542ecce 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -1,60 +1,60 @@
-#include <framework/osal/InternalErrorCodes.h>
-#include <rtems/score/interr.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	switch (code) {
-	//TODO It looks like RTEMS-5 does not provide the same error codes
-//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
-//		return NO_CONFIGURATION_TABLE;
-//	case INTERNAL_ERROR_NO_CPU_TABLE:
-//		return NO_CPU_TABLE;
-//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
-//		return INVALID_WORKSPACE_ADDRESS;
-	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
-		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
-//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
-//		return INTERRUPT_STACK_TOO_SMALL;
-	case INTERNAL_ERROR_THREAD_EXITTED:
-		return THREAD_EXITTED;
-	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
-		return INCONSISTENT_MP_INFORMATION;
-	case INTERNAL_ERROR_INVALID_NODE:
-		return INVALID_NODE;
-	case INTERNAL_ERROR_NO_MPCI:
-		return NO_MPCI;
-	case INTERNAL_ERROR_BAD_PACKET:
-		return BAD_PACKET;
-	case INTERNAL_ERROR_OUT_OF_PACKETS:
-		return OUT_OF_PACKETS;
-	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
-		return OUT_OF_GLOBAL_OBJECTS;
-	case INTERNAL_ERROR_OUT_OF_PROXIES:
-		return OUT_OF_PROXIES;
-	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
-		return INVALID_GLOBAL_ID;
-	case INTERNAL_ERROR_BAD_STACK_HOOK:
-		return BAD_STACK_HOOK;
-//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
-//		return BAD_ATTRIBUTES;
-//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
-//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
-//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
-//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
-//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
-//		return MUTEX_OBTAIN_FROM_BAD_STATE;
-//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
-//		return UNLIMITED_AND_MAXIMUM_IS_0;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+#include <rtems/score/interr.h>
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	switch (code) {
+	//TODO It looks like RTEMS-5 does not provide the same error codes
+//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
+//		return NO_CONFIGURATION_TABLE;
+//	case INTERNAL_ERROR_NO_CPU_TABLE:
+//		return NO_CPU_TABLE;
+//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
+//		return INVALID_WORKSPACE_ADDRESS;
+	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
+		return TOO_LITTLE_WORKSPACE;
+	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
+//		return INTERRUPT_STACK_TOO_SMALL;
+	case INTERNAL_ERROR_THREAD_EXITTED:
+		return THREAD_EXITTED;
+	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
+		return INCONSISTENT_MP_INFORMATION;
+	case INTERNAL_ERROR_INVALID_NODE:
+		return INVALID_NODE;
+	case INTERNAL_ERROR_NO_MPCI:
+		return NO_MPCI;
+	case INTERNAL_ERROR_BAD_PACKET:
+		return BAD_PACKET;
+	case INTERNAL_ERROR_OUT_OF_PACKETS:
+		return OUT_OF_PACKETS;
+	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
+		return OUT_OF_GLOBAL_OBJECTS;
+	case INTERNAL_ERROR_OUT_OF_PROXIES:
+		return OUT_OF_PROXIES;
+	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
+		return INVALID_GLOBAL_ID;
+	case INTERNAL_ERROR_BAD_STACK_HOOK:
+		return BAD_STACK_HOOK;
+//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
+//		return BAD_ATTRIBUTES;
+//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
+//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
+//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
+//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
+//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
+//		return MUTEX_OBTAIN_FROM_BAD_STATE;
+//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
+//		return UNLIMITED_AND_MAXIMUM_IS_0;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
index c4c21911..076a6704 100644
--- a/osal/rtems/Interrupt.h
+++ b/osal/rtems/Interrupt.h
@@ -1,50 +1,50 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */
+#ifndef OS_RTEMS_INTERRUPT_H_
+#define OS_RTEMS_INTERRUPT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <cstring>
+#include <rtems.h>
+
+typedef rtems_isr_entry IsrHandler_t;
+typedef rtems_isr IsrReturn_t;
+typedef rtems_vector_number InterruptNumber_t;
+
+class Interrupt {
+public:
+	virtual ~Interrupt(){};
+
+	/**
+	 * Establishes a new interrupt service routine.
+	 * @param handler	The service routine to establish
+	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
+	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
+			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
+	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
+	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
+	/**
+	 * Enables the interrupt given.
+	 * The function tests, if the InterruptMask register was written successfully.
+	 * @param interrupt The interrupt to enable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
+	/**
+	 * Disables the interrupt given.
+	 * @param interrupt The interrupt to disable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
+
+
+	/**
+	 * Checks if the current executing context is an ISR.
+	 * @return true if handling an interrupt, false else.
+	 */
+	static bool isInterruptInProgress();
+
+};
+
+
+#endif /* OS_RTEMS_INTERRUPT_H_ */
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index de148fdc..e0752409 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,147 +1,147 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-#include <cstring>
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
-	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
-	rtems_status_code status = rtems_message_queue_create(name, message_depth,
-			max_message_size, 0, &(this->id));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status:"
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	rtems_message_queue_delete(id);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
-		return sendMessage(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
-			RTEMS_NO_WAIT, 1);
-	if (status == RTEMS_SUCCESSFUL) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
-	}
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	rtems_status_code status = rtems_message_queue_flush(id, count);
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
-
-	//TODO: Check if we're in ISR.
-	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
-			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-		}
-		if (internalErrorReporter != NULL) {
-			internalErrorReporter->queueMessageNotSent();
-		}
-	}
-
-	ReturnValue_t returnCode = convertReturnCode(result);
-	if(result == MessageQueueIF::EMPTY){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return returnCode;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
-		switch(inValue){
-		case RTEMS_SUCCESSFUL:
-			return HasReturnvaluesIF::RETURN_OK;
-		case  RTEMS_INVALID_ID:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TIMEOUT:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_OBJECT_WAS_DELETED:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_ADDRESS:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_SIZE:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TOO_MANY:
-			return MessageQueueIF::FULL;
-		case RTEMS_UNSATISFIED:
-			return MessageQueueIF::EMPTY;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-}
-
-
-
-uint16_t MessageQueue::queueCounter = 0;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+#include <cstring>
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
+	rtems_status_code status = rtems_message_queue_create(name, message_depth,
+			max_message_size, 0, &(this->id));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status:"
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	rtems_message_queue_delete(id);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+	if (this->lastPartner != 0) {
+		return sendMessage(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	rtems_status_code status = rtems_message_queue_receive(id,
+			message->getBuffer(), &(message->messageSize),
+			RTEMS_NO_WAIT, 1);
+	if (status == RTEMS_SUCCESSFUL) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->messageSize < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send something later.
+		//But still, delete packet content.
+		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+	}
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	rtems_status_code status = rtems_message_queue_flush(id, count);
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo,
+			message->getBuffer(), message->messageSize);
+
+	//TODO: Check if we're in ISR.
+	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
+		if (internalErrorReporter == NULL) {
+			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+		}
+		if (internalErrorReporter != NULL) {
+			internalErrorReporter->queueMessageNotSent();
+		}
+	}
+
+	ReturnValue_t returnCode = convertReturnCode(result);
+	if(result == MessageQueueIF::EMPTY){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return returnCode;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
+		switch(inValue){
+		case RTEMS_SUCCESSFUL:
+			return HasReturnvaluesIF::RETURN_OK;
+		case  RTEMS_INVALID_ID:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TIMEOUT:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_OBJECT_WAS_DELETED:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_ADDRESS:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_SIZE:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TOO_MANY:
+			return MessageQueueIF::FULL;
+		case RTEMS_UNSATISFIED:
+			return MessageQueueIF::EMPTY;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+}
+
+
+
+uint16_t MessageQueue::queueCounter = 0;
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index 9bdce7ca..2d1bd8db 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,181 +1,181 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
-#include "RtemsBasic.h"
-
-/**
- *	@brief		This class manages sending and receiving of message queue messages.
- *
- *	@details	Message queues are used to pass asynchronous messages between processes.
- *				They work like post boxes, where all incoming messages are stored in FIFO
- *				order. This class creates a new receiving queue and provides methods to fetch
- *				received messages. Being a child of MessageQueueSender, this class also provides
- *				methods to send a message to a user-defined or a default destination. In addition
- *				it also provides a reply method to answer to the queue it received its last message
- *				from.
- *				The MessageQueue should be used as "post box" for a single owning object. So all
- *				message queue communication is "n-to-one".
- *				For creating the queue, as well as sending and receiving messages, the class makes
- *				use of the operating system calls provided.
- *	\ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
-	 * 			and initialized. The message depth - the maximum number of messages to be
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
-	 * 			automatically set to the maximum message queue message size. The operating system
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
-	 * 						sender. Default is three.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
-	 * 							This should be left default.
-	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
-	 */
-	virtual ~MessageQueue();
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault( MessageQueueMessage* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
-	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
-	 * 			by lazy loading
-	 */
-	InternalErrorReporterIF *internalErrorReporter;
-
-	static uint16_t queueCounter;
-	/**
-	 * A method to convert an OS-specific return code to the frameworks return value concept.
-	 * @param inValue The return code coming from the OS.
-	 * @return The converted return value.
-	 */
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+/**
+ *	@file	MessageQueue.h
+ *
+ *  @date	10/02/2012
+ *	@author	Bastian Baetz
+ *
+ *	@brief	This file contains the definition of the MessageQueue class.
+ */
+
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "RtemsBasic.h"
+
+/**
+ *	@brief		This class manages sending and receiving of message queue messages.
+ *
+ *	@details	Message queues are used to pass asynchronous messages between processes.
+ *				They work like post boxes, where all incoming messages are stored in FIFO
+ *				order. This class creates a new receiving queue and provides methods to fetch
+ *				received messages. Being a child of MessageQueueSender, this class also provides
+ *				methods to send a message to a user-defined or a default destination. In addition
+ *				it also provides a reply method to answer to the queue it received its last message
+ *				from.
+ *				The MessageQueue should be used as "post box" for a single owning object. So all
+ *				message queue communication is "n-to-one".
+ *				For creating the queue, as well as sending and receiving messages, the class makes
+ *				use of the operating system calls provided.
+ *	\ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details	By making use of the according operating system call, a message queue is created
+	 * 			and initialized. The message depth - the maximum number of messages to be
+	 * 			buffered - may be set with the help of a parameter, whereas the message size is
+	 * 			automatically set to the maximum message queue message size. The operating system
+	 * 			sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth	The number of messages to be buffered before passing an error to the
+	 * 						sender. Default is three.
+	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
+	 * 							This should be left default.
+	 */
+	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 */
+	virtual ~MessageQueue();
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false );
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply( MessageQueueMessage* message );
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * 			message's content is cleared and the function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
+	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
+	 * 			by lazy loading
+	 */
+	InternalErrorReporterIF *internalErrorReporter;
+
+	static uint16_t queueCounter;
+	/**
+	 * A method to convert an OS-specific return code to the frameworks return value concept.
+	 * @param inValue The return code coming from the OS.
+	 * @return The converted return value.
+	 */
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 6b9c8c8e..8cec10f7 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -1,87 +1,87 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
+/**
+ * @file	MultiObjectTask.cpp
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "MultiObjectTask.h"
+
+MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodTicks(
+				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
+				setDeadlineMissedFunc) {
+}
+
+MultiObjectTask::~MultiObjectTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	rtems_rate_monotonic_delete(periodId);
+}
+rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
+	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
+	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
+	originalTask->taskFunctionality();
+}
+
+ReturnValue_t MultiObjectTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "ObjectTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
+	return TaskBase::sleepFor(ms);
+}
+
+void MultiObjectTask::taskFunctionality() {
+	TaskBase::setAndStartPeriod(periodTicks,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
+		if (status == RTEMS_TIMEOUT) {
+			char nameSpace[8] = { 0 };
+			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
+					nameSpace);
+			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != NULL) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
+}
+
+uint32_t MultiObjectTask::getPeriodMs() const {
+	return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 64b09c52..b3ff66c2 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,113 +1,113 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-#include "TaskBase.h"
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
- *
- * @ingroup task_handling
- */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details	The class is initialized without allocated objects. These need to be added
-	 * 			with #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
-	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
-			void (*setDeadlineMissedFunc)());
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
-	 * 			lifetime, so the destructor is empty.
-	 */
-	virtual ~MultiObjectTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void);
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
-	 */
-	rtems_interval periodTicks;
-	/**
-	 * @brief id of the associated OS period
-	 */
-	rtems_id periodId;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
-	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
-	 * 			of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details	It converts the argument back to the thread object type and copies the class instance
-	 * 			to the task context. The taskFunctionality method is called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-	static rtems_task taskEntryPoint(rtems_task_argument argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details	The method sets and starts
-	 * 			the task's period, then enters a loop that is repeated as long as the isRunning
-	 * 			attribute is true. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
-	 * 			until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-};
-
-#endif /* MULTIOBJECTTASK_H_ */
+/**
+ * @file	MultiObjectTask.h
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+#ifndef MULTIOBJECTTASK_H_
+#define MULTIOBJECTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include "TaskBase.h"
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief This class represents a specialized task for periodic activities of multiple objects.
+ *
+ * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
+ * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
+ * 			added prior to starting the task.
+ *
+ * @ingroup task_handling
+ */
+class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details	The class is initialized without allocated objects. These need to be added
+	 * 			with #addObject.
+	 * 			In the underlying TaskBase class, a new operating system task is created.
+	 * 			In addition to the TaskBase parameters, the period, the pointer to the
+	 * 			aforementioned initialization function and an optional "deadline-missed"
+	 * 			function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param setPeriod 	The length of the period with which the task's functionality will be
+	 * 						executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
+	 * 								that shall be assigned.
+	 */
+	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
+			void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
+	 * 			lifetime, so the destructor is empty.
+	 */
+	virtual ~MultiObjectTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 */
+	rtems_interval periodTicks;
+	/**
+	 * @brief id of the associated OS period
+	 */
+	rtems_id periodId;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
+	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
+	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
+	 * 			of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details	It converts the argument back to the thread object type and copies the class instance
+	 * 			to the task context. The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+	static rtems_task taskEntryPoint(rtems_task_argument argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details	The method sets and starts
+	 * 			the task's period, then enters a loop that is repeated as long as the isRunning
+	 * 			attribute is true. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
+	 * 			until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+};
+
+#endif /* MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index d094e1dc..7ead8851 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,65 +1,65 @@
-#include "Mutex.h"
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
-uint8_t Mutex::count = 0;
-
-Mutex::Mutex() :
-		mutexId(0) {
-	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
-	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
-	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
-			&mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	rtems_status_code status = rtems_semaphore_delete(mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_UNSATISFIED:
-		//semaphore not available
-		return MUTEX_NOT_FOUND;
-	case RTEMS_TIMEOUT:
-		//timed out waiting for semaphore
-		return MUTEX_TIMEOUT;
-	case RTEMS_OBJECT_WAS_DELETED:
-		//semaphore deleted while waiting
-		return MUTEX_DESTROYED_WHILE_WAITING;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	rtems_status_code status = rtems_semaphore_release(mutexId);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_OWNER_OF_RESOURCE:
-		//semaphore not available
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
+uint8_t Mutex::count = 0;
+
+Mutex::Mutex() :
+		mutexId(0) {
+	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
+	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
+	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
+			&mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	rtems_status_code status = rtems_semaphore_delete(mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: deletion for id " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_UNSATISFIED:
+		//semaphore not available
+		return MUTEX_NOT_FOUND;
+	case RTEMS_TIMEOUT:
+		//timed out waiting for semaphore
+		return MUTEX_TIMEOUT;
+	case RTEMS_OBJECT_WAS_DELETED:
+		//semaphore deleted while waiting
+		return MUTEX_DESTROYED_WHILE_WAITING;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	rtems_status_code status = rtems_semaphore_release(mutexId);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_OWNER_OF_RESOURCE:
+		//semaphore not available
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 19b34e7f..fd76b86a 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,18 +1,18 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-#include "RtemsBasic.h"
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
-private:
-	rtems_id mutexId;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_RTEMS_MUTEX_H_
+#define OS_RTEMS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+#include "RtemsBasic.h"
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+private:
+	rtems_id mutexId;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index d7bd16bc..3ffab927 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,24 +1,24 @@
-#include <framework/ipc/MutexFactory.h>
-#include "Mutex.h"
-#include "RtemsBasic.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "Mutex.h"
+#include "RtemsBasic.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index a6be7ddf..527df367 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,122 +1,122 @@
-#include <framework/tasks/FixedSequenceSlot.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/osal/rtems/PollingTask.h>
-#include <framework/osal/rtems/RtemsBasic.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <rtems/bspIo.h>
-#include <rtems/rtems/ratemon.h>
-#include <rtems/rtems/status.h>
-#include <rtems/rtems/tasks.h>
-#include <rtems/rtems/types.h>
-#include <stddef.h>
-#include <sys/_stdint.h>
-#include <iostream>
-#include <list>
-
-uint32_t PollingTask::deadlineMissedCount = 0;
-
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-PollingTask::~PollingTask() {
-}
-
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t PollingTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t PollingTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-#include <rtems/io.h>
-
-void PollingTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
-
-	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
-};
+#include "../../tasks/FixedSequenceSlot.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../osal/rtems/PollingTask.h"
+#include "../../osal/rtems/RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <rtems/bspIo.h>
+#include <rtems/rtems/ratemon.h>
+#include <rtems/rtems/status.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/rtems/types.h>
+#include <stddef.h>
+#include <sys/_stdint.h>
+#include <iostream>
+#include <list>
+
+uint32_t PollingTask::deadlineMissedCount = 0;
+
+PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, uint32_t setOverallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodId(0), pst(
+				setOverallPeriod) {
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+PollingTask::~PollingTask() {
+}
+
+rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
+
+	//The argument is re-interpreted as PollingTask.
+	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	debug << "Polling task " << originalTask->getId()
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void PollingTask::missedDeadlineCounter() {
+	PollingTask::deadlineMissedCount++;
+	if (PollingTask::deadlineMissedCount % 10 == 0) {
+		error << "PST missed " << PollingTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t PollingTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "PollingTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t PollingTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t PollingTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t PollingTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+#include <rtems/io.h>
+
+void PollingTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+
+	//The start time for the first entry is read.
+	rtems_interval interval = RtemsBasic::convertMsToTicks(
+			(*it)->pollingTimeMs);
+	TaskBase::setAndStartPeriod(interval,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
+			if (status == RTEMS_TIMEOUT) {
+				if (this->deadlineMissedFunc != NULL) {
+					this->deadlineMissedFunc();
+				}
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+ReturnValue_t PollingTask::sleepFor(uint32_t ms){
+	return TaskBase::sleepFor(ms);
+};
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 5bf8cf57..759ed43d 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,85 +1,85 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
-
-#include <framework/tasks/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include "TaskBase.h"
-
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef POLLINGTASK_H_
+#define POLLINGTASK_H_
+
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "TaskBase.h"
+
+class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
+	public:
+	/**
+	 * @brief	The standard constructor of the class.
+	 *
+	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
+	 * 			the following variables are passed:
+	 *
+	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
+	 *
+	 * @param	getPst The object id of the completely initialized polling sequence.
+	 */
+	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 *
+	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
+	 * 			the device handlers. This is done by calling the PST's destructor.
+	 */
+	virtual ~PollingTask( void );
+
+	ReturnValue_t startTask( void );
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	/**
+	* @brief id of the associated OS period
+	*/
+	rtems_id periodId;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+	 *
+	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
+	 * 			Currently, only one function for missing any deadline is allowed.
+	 * 			If not used, it shall be declared NULL.
+	 */
+	void ( *deadlineMissedFunc )( void );
+	/**
+	 * @brief	This is the entry point in a new polling thread.
+	 *
+	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
+	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
+	 * 			on success. If operation of the task is ended for some reason,
+	 * 			the destructor is called to free allocated memory.
+	 */
+	static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 *
+	 *
+	 * @details	Holding the main functionality of the task, this method is most important.
+	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
+	 * 			to keep the timing of the periods.
+	 */
+	void taskFunctionality( void );
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index 8cc9905c..a492d400 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,59 +1,59 @@
-#include <framework/ipc/QueueFactory.h>
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-
-QueueFactory* QueueFactory::factoryInstance = NULL;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	//TODO add ignoreFault functionality
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
-	switch(result){
-	case RTEMS_SUCCESSFUL:
-			//message sent successfully
-			return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ID:
-			//invalid queue id
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_SIZE:
-		// invalid message size
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		//out of message buffers
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		//queue's limit has been reached
-		return MessageQueueIF::FULL;
-
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+
+QueueFactory* QueueFactory::factoryInstance = NULL;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+	//TODO add ignoreFault functionality
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
+			message->messageSize);
+	switch(result){
+	case RTEMS_SUCCESSFUL:
+			//message sent successfully
+			return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ID:
+			//invalid queue id
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_SIZE:
+		// invalid message size
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		//out of message buffers
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		//queue's limit has been reached
+		return MessageQueueIF::FULL;
+
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == NULL) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index f7ab8614..b9aa33e8 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,25 +1,25 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <rtems.h>
-#include <rtems/libio.h>
-#include <rtems/error.h>
-#include <rtems/stackchk.h>
-#include <stddef.h>
-
-
-class RtemsBasic {
-public:
-	static rtems_interval convertMsToTicks(uint32_t msIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticks_per_second * msIn) / 1000;
-	}
-
-	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticksIn * 1000) / ticks_per_second;
-	}
-};
-
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#ifndef OS_RTEMS_RTEMSBASIC_H_
+#define OS_RTEMS_RTEMSBASIC_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <rtems.h>
+#include <rtems/libio.h>
+#include <rtems/error.h>
+#include <rtems/stackchk.h>
+#include <stddef.h>
+
+
+class RtemsBasic {
+public:
+	static rtems_interval convertMsToTicks(uint32_t msIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticks_per_second * msIn) / 1000;
+	}
+
+	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticksIn * 1000) / ticks_per_second;
+	}
+};
+
+#endif /* OS_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index ad795645..b95ab51f 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -1,82 +1,82 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include "TaskBase.h"
-
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
-
-TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
-		const char *name) {
-	rtems_name osalName = 0;
-	for (uint8_t i = 0; i < 4; i++) {
-		if (name[i] == 0) {
-			break;
-		}
-		osalName += name[i] << (8 * (3 - i));
-	}
-	//The task is created with the operating system's system call.
-	rtems_status_code status = RTEMS_UNSATISFIED;
-	if (set_priority >= 0 && set_priority <= 99) {
-		 status = rtems_task_create(osalName,
-				(0xFF - 2 * set_priority), stack_size,
-				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
-				RTEMS_FLOATING_POINT, &id);
-	}
-	ReturnValue_t result = convertReturnCode(status);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
-				<< osalName << std::dec << " failed with return code "
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-TaskBase::~TaskBase() {
-	rtems_task_delete(id);
-}
-
-rtems_id TaskBase::getId() {
-	return this->id;
-}
-
-ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
-	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
-	return convertReturnCode(status);
-}
-
-
-ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
-	switch (inValue) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_MP_NOT_CONFIGURED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_NAME:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_PRIORITY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-
-ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
-	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
-	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
-	if (status == RTEMS_SUCCESSFUL) {
-		status = restartPeriod(period,*periodId);
-	}
-	return convertReturnCode(status);
-}
-
-rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
-	//This is necessary to avoid a call with period = 0, which does not start the period.
-	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "TaskBase.h"
+
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
+
+TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
+		const char *name) {
+	rtems_name osalName = 0;
+	for (uint8_t i = 0; i < 4; i++) {
+		if (name[i] == 0) {
+			break;
+		}
+		osalName += name[i] << (8 * (3 - i));
+	}
+	//The task is created with the operating system's system call.
+	rtems_status_code status = RTEMS_UNSATISFIED;
+	if (set_priority >= 0 && set_priority <= 99) {
+		 status = rtems_task_create(osalName,
+				(0xFF - 2 * set_priority), stack_size,
+				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
+				RTEMS_FLOATING_POINT, &id);
+	}
+	ReturnValue_t result = convertReturnCode(status);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		error << "TaskBase::TaskBase: createTask with name " << std::hex
+				<< osalName << std::dec << " failed with return code "
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+TaskBase::~TaskBase() {
+	rtems_task_delete(id);
+}
+
+rtems_id TaskBase::getId() {
+	return this->id;
+}
+
+ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
+	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
+	return convertReturnCode(status);
+}
+
+
+ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
+	switch (inValue) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_MP_NOT_CONFIGURED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_NAME:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_PRIORITY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
+
+ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
+	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
+	if (status == RTEMS_SUCCESSFUL) {
+		status = restartPeriod(period,*periodId);
+	}
+	return convertReturnCode(status);
+}
+
+rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+	//This is necessary to avoid a call with period = 0, which does not start the period.
+	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
+	return status;
+}
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index b9c1192a..3010a972 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,47 +1,47 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
-
-#include "RtemsBasic.h"
-#include <framework/tasks/PeriodicTaskIF.h>
-
-/**
- * @brief	This is the basic task handling class for rtems.
- *
- * @details Task creation base class for rtems.
- */
-class TaskBase {
-protected:
-	/**
-	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the id is set to zero.
-	 */
-	rtems_id id;
-public:
-	/**
-	 * @brief	The constructor creates and initializes a task.
-	 * @details	This is accomplished by using the operating system call to create a task. The name is
-	 * 			created automatically with the help od taskCounter. Priority and stack size are
-	 * 			adjustable, all other attributes are set with default values.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
-	 */
-	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
-	/**
-	 * @brief	In the destructor, the created task is deleted.
-	 */
-	virtual ~TaskBase();
-	/**
-	 * @brief	This method returns the task id of this class.
-	 */
-	rtems_id getId();
-
-	ReturnValue_t sleepFor(uint32_t ms);
-	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
-	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
-private:
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-
-#endif /* TASKBASE_H_ */
+#ifndef TASKBASE_H_
+#define TASKBASE_H_
+
+#include "RtemsBasic.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief	This is the basic task handling class for rtems.
+ *
+ * @details Task creation base class for rtems.
+ */
+class TaskBase {
+protected:
+	/**
+	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the id is set to zero.
+	 */
+	rtems_id id;
+public:
+	/**
+	 * @brief	The constructor creates and initializes a task.
+	 * @details	This is accomplished by using the operating system call to create a task. The name is
+	 * 			created automatically with the help od taskCounter. Priority and stack size are
+	 * 			adjustable, all other attributes are set with default values.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
+	 */
+	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	/**
+	 * @brief	In the destructor, the created task is deleted.
+	 */
+	virtual ~TaskBase();
+	/**
+	 * @brief	This method returns the task id of this class.
+	 */
+	rtems_id getId();
+
+	ReturnValue_t sleepFor(uint32_t ms);
+	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
+	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
+private:
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+
+#endif /* TASKBASE_H_ */
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index 2bee19c7..f79571f0 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,41 +1,41 @@
-#include <framework/tasks/TaskFactory.h>
-#include "MultiObjectTask.h"
-#include "PollingTask.h"
-#include "InitTask.h"
-#include "RtemsBasic.h"
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
-	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "MultiObjectTask.h"
+#include "PollingTask.h"
+#include "InitTask.h"
+#include "RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+
+	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
+	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 02f36318..14446e3c 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,67 +1,67 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
-
-#include <framework/parameters/ParameterWrapper.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-
-/** Each parameter is identified with a unique parameter ID */
-typedef uint32_t ParameterId_t;
-
-/**
- * @brief	This interface is used by components which have modifiable
- * 			parameters, e.g. atittude controllers
- * @details
- * Each parameter has a unique parameter ID. The first byte of the parameter
- * ID is the domain ID which can be used to identify unqiue spacecraft domains
- * (e.g. control and sensor domain in the AOCS controller).
- *
- * The second and third byte represent the matrix ID, which can represent
- * a 8-bit row and column number and the last byte...
- *
- * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
- * of a 8 bit number now?
- */
-class HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
-
-	static uint8_t getDomain(ParameterId_t id) {
-		return id >> 24;
-	}
-
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
-	}
-
-	static uint8_t getIndex(ParameterId_t id) {
-		return id;
-	}
-
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
-	}
-
-	virtual ~HasParametersIF() {}
-
-	/**
-	 * Always set parameter before checking newValues!
-	 *
-	 * @param domainId
-	 * @param parameterId
-	 * @param parameterWrapper
-	 * @param newValues
-	 * @param startAtIndex
-	 * @return
-	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
-};
-
-#endif /* HASPARAMETERSIF_H_ */
+#ifndef HASPARAMETERSIF_H_
+#define HASPARAMETERSIF_H_
+
+#include "../parameters/ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+/** Each parameter is identified with a unique parameter ID */
+typedef uint32_t ParameterId_t;
+
+/**
+ * @brief	This interface is used by components which have modifiable
+ * 			parameters, e.g. atittude controllers
+ * @details
+ * Each parameter has a unique parameter ID. The first byte of the parameter
+ * ID is the domain ID which can be used to identify unqiue spacecraft domains
+ * (e.g. control and sensor domain in the AOCS controller).
+ *
+ * The second and third byte represent the matrix ID, which can represent
+ * a 8-bit row and column number and the last byte...
+ *
+ * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
+ * of a 8 bit number now?
+ */
+class HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
+	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
+
+	static uint8_t getDomain(ParameterId_t id) {
+		return id >> 24;
+	}
+
+	static uint16_t getMatrixId(ParameterId_t id) {
+		return id >> 8;
+	}
+
+	static uint8_t getIndex(ParameterId_t id) {
+		return id;
+	}
+
+	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
+			uint8_t index) {
+		return (domainId << 24) + (parameterId << 8) + index;
+	}
+
+	virtual ~HasParametersIF() {}
+
+	/**
+	 * Always set parameter before checking newValues!
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+};
+
+#endif /* HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 53f1229f..55633566 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,132 +1,132 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/parameters/ParameterMessage.h>
-
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
-
-ParameterHelper::~ParameterHelper() {
-}
-
-ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
-
-		const uint8_t *storedStream = nullptr;
-		size_t storedStreamSize = 0;
-		result = storage->getData(
-				ParameterMessage::getStoreId(message), &storedStream,
-				&storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					" store data failed for load command." << std::endl;
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
-				&streamWrapper, index);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->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 = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
-
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../parameters/ParameterMessage.h"
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
+		owner(owner) {}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (message->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		ParameterWrapper description;
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		result = owner->getParameter(domain, parameterId,
+				&description, &description, 0);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &description);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(message));
+
+		const uint8_t *storedStream = nullptr;
+		size_t storedStreamSize = 0;
+		result = storage->getData(
+				ParameterMessage::getStoreId(message), &storedStream,
+				&storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "ParameterHelper::handleParameterMessage: Getting"
+					" store data failed for load command." << std::endl;
+			break;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		ParameterWrapper ownerWrapper;
+		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+				&streamWrapper, index);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		result = ownerWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(message));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &ownerWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(message->getSender(), result, message->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+		const ParameterWrapper* description) {
+	size_t serializedSize = description->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 = description->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+	ownerQueueId = owner->getCommandQueue();
+
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 538aaac6..668bb081 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/parameters/ParameterMessage.h>
-#include <framework/parameters/ReceivesParameterMessagesIF.h>
-
-/**
- * @brief	Helper class to handle parameter messages
- * @details
- * This class simplfiies handling of parameter messages, which are sent
- * to a class which implements ReceivesParameterMessagesIF.
- */
-class ParameterHelper {
-public:
-	ParameterHelper(ReceivesParameterMessagesIF *owner);
-	virtual ~ParameterHelper();
-
-	ReturnValue_t handleParameterMessage(CommandMessage *message);
-
-	ReturnValue_t initialize();
-private:
-	ReceivesParameterMessagesIF *owner;
-
-	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
-
-	StorageManagerIF *storage = nullptr;
-
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const ParameterWrapper *description);
-
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* PARAMETERHELPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ParameterMessage.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
+class ParameterHelper {
+public:
+	ParameterHelper(ReceivesParameterMessagesIF *owner);
+	virtual ~ParameterHelper();
+
+	ReturnValue_t handleParameterMessage(CommandMessage *message);
+
+	ReturnValue_t initialize();
+private:
+	ReceivesParameterMessagesIF *owner;
+
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
+
+	StorageManagerIF *storage = nullptr;
+
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
+
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 1c7d6911..0cc4dd90 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -1,48 +1,48 @@
-#include <framework/parameters/ParameterMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter2();
-	return address;
-}
-
-void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
-		ParameterId_t id) {
-	message->setCommand(CMD_PARAMETER_DUMP);
-	message->setParameter(id);
-}
-
-void ParameterMessage::setParameterDumpReply(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(REPLY_PARAMETER_DUMP);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(CMD_PARAMETER_LOAD);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_PARAMETER_LOAD:
-	case REPLY_PARAMETER_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../parameters/ParameterMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_PARAMETER_LOAD:
+	case REPLY_PARAMETER_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 43283294..51321f2b 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,29 +1,29 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-
-class ParameterMessage {
-private:
-	ParameterMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
-	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
-
-	static ParameterId_t getParameterId(const CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setParameterDumpCommand(CommandMessage* message,
-			ParameterId_t id);
-	static void setParameterDumpReply(CommandMessage* message,
-			ParameterId_t id,  store_address_t storageID);
-	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
-	static void clear(CommandMessage* message);
-
-};
-
-#endif /* PARAMETERMESSAGE_H_ */
+#ifndef PARAMETERMESSAGE_H_
+#define PARAMETERMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
+	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+	static void setParameterLoadCommand(CommandMessage* message,
+			ParameterId_t id, store_address_t storageID);
+	static void clear(CommandMessage* message);
+
+};
+
+#endif /* PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 521a6644..8e6dd86c 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,280 +1,280 @@
-#include <framework/parameters/ParameterWrapper.h>
-
-ParameterWrapper::ParameterWrapper() :
-		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(data), readonlyData(data) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(nullptr), readonlyData(data) {
-}
-
-ParameterWrapper::~ParameterWrapper() {
-}
-
-ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	//serialize uses readonlyData, as it is always valid
-	if (readonlyData == NULL) {
-		return NOT_SET;
-	}
-	switch (type) {
-	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
-		break;
-	default:
-		result = UNKNOW_DATATYPE;
-		break;
-	}
-	return result;
-}
-
-size_t ParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	const T *element = (const T*) readonlyData;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	uint16_t dataSize = columns * rows;
-	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		element++;
-		dataSize--;
-	}
-	return result;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void *from, uint8_t fromRows,
-		uint8_t fromColumns) {
-
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
-	size_t streamSize = fromRows * fromColumns * sizeof(T);
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
-
-		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter::deSerialize(
-					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					SerializeIF::Endianness::BIG);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-	}
-
-	return result;
-
-}
-
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, streamEndianness, 0);
-}
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness,
-		uint16_t startWritingAtIndex) {
-	ParameterWrapper streamDescription;
-
-	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return copyFrom(&streamDescription, startWritingAtIndex);
-}
-
-ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
-		const uint8_t **remainingStream, size_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t dataSize = type.getSize() * rows * columns;
-
-	if (streamSize < dataSize) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
-
-	data = nullptr;
-	readonlyData = stream;
-	pointsToStream = true;
-
-	stream += dataSize;
-	if (remainingStream !=  nullptr) {
-		*remainingStream = stream;
-	}
-	streamSize -= dataSize;
-	if (remainingSize != nullptr) {
-		*remainingSize = streamSize;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
-		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
-		return READONLY;
-	}
-
-	if (from->readonlyData == NULL) {
-		return SOURCE_NOT_SET;
-	}
-
-	if (type != from->type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return TOO_BIG;
-	}
-
-	uint8_t typeSize = type.getSize();
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		default:
-			result = UNKNOW_DATATYPE;
-			break;
-		}
-	}
-	else {
-		//need a type to do arithmetic
-		uint8_t* typedData = static_cast<uint8_t*>(data);
-		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
-			std::memcpy(typedData +  offset, from->readonlyData,
-					typeSize * from->columns);
-		}
-	}
-
-	return result;
-}
+#include "../parameters/ParameterWrapper.h"
+
+ParameterWrapper::ParameterWrapper() :
+		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(data), readonlyData(data) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	//serialize uses readonlyData, as it is always valid
+	if (readonlyData == NULL) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
+		break;
+	default:
+		result = UNKNOW_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+size_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		//get the start element of this row in data
+		T *dataWithDataType = ((T*) data)
+				+ (((startingRow + fromRow) * columns) + startingColumn);
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					SerializeIF::Endianness::BIG);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
+			&streamSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = nullptr;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream !=  nullptr) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != nullptr) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
+		uint16_t startWritingAtIndex) {
+	if (data == NULL) {
+		return READONLY;
+	}
+
+	if (from->readonlyData == NULL) {
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOW_DATATYPE;
+			break;
+		}
+	}
+	else {
+		//need a type to do arithmetic
+		uint8_t* typedData = static_cast<uint8_t*>(data);
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
+		}
+	}
+
+	return result;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index eec101f2..1f38f691 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeIF.h>
-#include <stddef.h>
-#include <framework/globalfunctions/Type.h>
-
-/**
- * @brief
- * @details
- */
-class ParameterWrapper: public SerializeIF {
-	friend class DataPoolParameterWrapper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
-	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
-
-	ParameterWrapper();
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-			const void *data);
-	virtual ~ParameterWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
-
-	/**
-	 * Get a specific parameter value by supplying the row and the column.
-	 * @tparam T Type of target data
-	 * @param value [out] Pointer to storage location
-	 * @param row
-	 * @param column
-	 * @return
-	 * -@c RETURN_OK if element was retrieved successfully
-	 * -@c NOT_SET data has not been set yet
-	 * -@c DATATYPE_MISSMATCH Invalid supplied type
-	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
-	 */
-	template<typename T>
-	ReturnValue_t getElement(T *value, uint8_t row = 0,
-			uint8_t column = 0) const;
-
-	template<typename T>
-	void set(T *data, uint8_t rows, uint8_t columns) {
-		this->data = data;
-		this->readonlyData = data;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
-		this->readonlyData = readonlyData;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(T& member) {
-		this->set(&member, 1, 1);
-	}
-
-	template<typename T>
-	void set(const T& readonlyMember) {
-		this->set(&readonlyMember, 1, 1);
-	}
-
-	template<typename T>
-	void setVector(T& member) {
-		this->set(member, sizeof(member)/sizeof(member[0]), 1);
-	}
-
-	template<typename T>
-	void setVector(const T& member) {
-		this->set(member, 1, sizeof(member)/sizeof(member[0]));
-	}
-	template<typename T>
-	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	template<typename T>
-	void setMatrix(const T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
-			const uint8_t **remainingStream = nullptr,
-			size_t *remainingSize = nullptr);
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	bool pointsToStream = false;
-
-	Type type;
-	uint8_t rows = 0;
-	uint8_t columns = 0;
-	void *data = nullptr;
-	const void *readonlyData = nullptr;
-
-	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows, uint8_t fromColumns);
-};
-
-template <typename T>
-inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
-		uint8_t column) const {
-	if (readonlyData == nullptr){
-		return NOT_SET;
-	}
-
-	if (PodTypeConversion<T>::type != type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	if ((row >= rows) or (column >= columns)) {
-		return OUT_OF_BOUNDS;
-	}
-
-	if (pointsToStream) {
-		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
-		streamWithType += (row * columns + column) * type.getSize();
-		int32_t size = type.getSize();
-		return SerializeAdapter::deSerialize(value, &streamWithType,
-				&size, true);
-	}
-	else {
-		const T *dataWithType = static_cast<const T*>(readonlyData);
-		*value = dataWithType[row * columns + column];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-#endif /* PARAMETERWRAPPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+#include <stddef.h>
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ParameterWrapper: public SerializeIF {
+	friend class DataPoolParameterWrapper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+			const void *data);
+	virtual ~ParameterWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
+
+	/**
+	 * Get a specific parameter value by supplying the row and the column.
+	 * @tparam T Type of target data
+	 * @param value [out] Pointer to storage location
+	 * @param row
+	 * @param column
+	 * @return
+	 * -@c RETURN_OK if element was retrieved successfully
+	 * -@c NOT_SET data has not been set yet
+	 * -@c DATATYPE_MISSMATCH Invalid supplied type
+	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
+	 */
+	template<typename T>
+	ReturnValue_t getElement(T *value, uint8_t row = 0,
+			uint8_t column = 0) const;
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = NULL;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+		this->set(member, sizeof(member)/sizeof(member[0]), 1);
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	void setMatrix(const T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = nullptr,
+			size_t *remainingSize = nullptr);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	bool pointsToStream = false;
+
+	Type type;
+	uint8_t rows = 0;
+	uint8_t columns = 0;
+	void *data = nullptr;
+	const void *readonlyData = nullptr;
+
+	template<typename T>
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+template <typename T>
+inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
+		uint8_t column) const {
+	if (readonlyData == nullptr){
+		return NOT_SET;
+	}
+
+	if (PodTypeConversion<T>::type != type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	if ((row >= rows) or (column >= columns)) {
+		return OUT_OF_BOUNDS;
+	}
+
+	if (pointsToStream) {
+		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
+		streamWithType += (row * columns + column) * type.getSize();
+		int32_t size = type.getSize();
+		return SerializeAdapter::deSerialize(value, &streamWithType,
+				&size, true);
+	}
+	else {
+		const T *dataWithType = static_cast<const T*>(readonlyData);
+		*value = dataWithType[row * columns + column];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+#endif /* PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index 9bcd226d..9a280b4f 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,19 +1,19 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
-
-
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class ReceivesParameterMessagesIF : public HasParametersIF {
-public:
-
-	static const uint8_t DOMAIN_ID_BASE = 0;
-	virtual ~ReceivesParameterMessagesIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#ifndef RECEIVESPARAMETERMESSAGESIF_H_
+#define RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include "../parameters/HasParametersIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	static const uint8_t DOMAIN_ID_BASE = 0;
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index b18b5b1a..59d60491 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,260 +1,260 @@
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/power/Fuse.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/ipc/QueueFactory.h>
-
-object_id_t Fuse::powerSwitchId = 0;
-
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Fuse::~Fuse() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-void Fuse::addDevice(PowerComponentIF* switchSet) {
-	devices.push_back(switchSet);
-}
-
-ReturnValue_t Fuse::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (powerIF == NULL) {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Fuse::calculatePowerLimits(float* low, float* high) {
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			*low += (*iter)->getMin();
-			*high += (*iter)->getMax();
-		}
-	}
-}
-
-ReturnValue_t Fuse::check() {
-	set.read();
-	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
-		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
-	}
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	checkFuseState();
-	calculateFusePower();
-	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
-	set.commit();
-	return result;
-}
-
-ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-size_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		size += (*iter)->getSerializedSize();
-	}
-	return size;
-}
-
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		result = (*iter)->deSerialize(buffer, size, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-uint8_t Fuse::getFuseId() const {
-	return fuseId;
-}
-
-void Fuse::calculateFusePower() {
-	ReturnValue_t result1 = currentLimit.check();
-	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
-		power.setValid(PoolVariableIF::INVALID);
-		return;
-	}
-	//Calculate fuse power.
-	power = current * voltage;
-	power.setValid(PoolVariableIF::VALID);
-}
-
-ReturnValue_t Fuse::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Fuse::reportEvents(Event event) {
-	if (!powerMonitor.isEventEnabled()) {
-		return;
-	}
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
-		}
-	}
-}
-
-MessageQueueId_t Fuse::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void Fuse::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	powerMonitor.setToUnchecked();
-}
-
-void Fuse::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void Fuse::checkFuseState() {
-	if (!state.isValid()) {
-		oldFuseState = 0;
-		return;
-	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
-}
-
-float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
-}
-
-void Fuse::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
-
-bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
-	if (powerIF->getSwitchState((*iter)->getSwitchId1())
-			!= PowerSwitchIF::SWITCH_ON) {
-		return false;
-	}
-	if ((*iter)->hasTwoSwitches()) {
-		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
-				!= PowerSwitchIF::SWITCH_ON)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool Fuse::isPowerValid() {
-	return power.isValid();
-}
-
-ReturnValue_t Fuse::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return RETURN_OK;
-}
-
-HasHealthIF::HealthState Fuse::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
-		float upperLimit) {
-	if (sample > upperLimit) {
-		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
-				upperLimit);
-	} else if (sample < lowerLimit) {
-		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
-				lowerLimit);
-	} else {
-		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/Fuse.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t Fuse::powerSwitchId = 0;
+
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+		float maxCurrent, uint16_t confirmationCount) :
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
+		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
+				ids.pidCurrent, &set), state(ids.pidState, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
+				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Fuse::~Fuse() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+void Fuse::addDevice(PowerComponentIF* switchSet) {
+	devices.push_back(switchSet);
+}
+
+ReturnValue_t Fuse::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (powerIF == NULL) {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Fuse::calculatePowerLimits(float* low, float* high) {
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			*low += (*iter)->getMin();
+			*high += (*iter)->getMax();
+		}
+	}
+}
+
+ReturnValue_t Fuse::check() {
+	set.read();
+	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
+		setAllMonitorsToUnchecked();
+		set.commit(PoolVariableIF::INVALID);
+		return RETURN_OK;
+	}
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	checkFuseState();
+	calculateFusePower();
+	//Check if power is valid and if fuse state is off or invalid.
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
+	set.commit();
+	return result;
+}
+
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		size += (*iter)->getSerializedSize();
+	}
+	return size;
+}
+
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+uint8_t Fuse::getFuseId() const {
+	return fuseId;
+}
+
+void Fuse::calculateFusePower() {
+	ReturnValue_t result1 = currentLimit.check();
+	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
+		power.setValid(PoolVariableIF::INVALID);
+		return;
+	}
+	//Calculate fuse power.
+	power = current * voltage;
+	power.setValid(PoolVariableIF::VALID);
+}
+
+ReturnValue_t Fuse::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Fuse::reportEvents(Event event) {
+	if (!powerMonitor.isEventEnabled()) {
+		return;
+	}
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
+		}
+	}
+}
+
+MessageQueueId_t Fuse::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void Fuse::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	powerMonitor.setToUnchecked();
+}
+
+void Fuse::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void Fuse::checkFuseState() {
+	if (!state.isValid()) {
+		oldFuseState = 0;
+		return;
+	}
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state;
+}
+
+float Fuse::getPower() {
+	if (power.isValid()) {
+		return power;
+	} else {
+		return 0.0;
+	}
+}
+
+void Fuse::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
+
+bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
+	if (powerIF->getSwitchState((*iter)->getSwitchId1())
+			!= PowerSwitchIF::SWITCH_ON) {
+		return false;
+	}
+	if ((*iter)->hasTwoSwitches()) {
+		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
+				!= PowerSwitchIF::SWITCH_ON)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool Fuse::isPowerValid() {
+	return power.isValid();
+}
+
+ReturnValue_t Fuse::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return RETURN_OK;
+}
+
+HasHealthIF::HealthState Fuse::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
+		float upperLimit) {
+	if (sample > upperLimit) {
+		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	} else if (sample < lowerLimit) {
+		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	} else {
+		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
+	}
+}
diff --git a/power/Fuse.h b/power/Fuse.h
index 1608023c..e6d6929c 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,106 +1,106 @@
-#ifndef FUSE_H_
-#define FUSE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/monitoring/AbsLimitMonitor.h>
-#include <framework/power/PowerComponentIF.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <list>
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class Fuse: public SystemObject,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SerializeIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-private:
-	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
-public:
-	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
-	};
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-
-	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
-	virtual ~Fuse();
-	void addDevice(PowerComponentIF *set);
-	float getPower();
-
-	bool isPowerValid();
-
-	ReturnValue_t check();
-	uint8_t getFuseId() const;
-	ReturnValue_t initialize();
-	DeviceList devices;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override;
-	size_t getSerializedSize() const override;
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override;
-	void setAllMonitorsToUnchecked();
-	ReturnValue_t performOperation(uint8_t opCode);
-	MessageQueueId_t getCommandQueue() const;
-	void setDataPoolEntriesInvalid();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-private:
-	uint8_t oldFuseState;
-	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
-	AbsLimitMonitor<float> currentLimit;
-	class PowerMonitor: public MonitorReporter<float> {
-	public:
-		template<typename ... Args>
-		PowerMonitor(Args ... args) :
-				MonitorReporter<float>(std::forward<Args>(args)...) {
-		}
-		ReturnValue_t checkPower(float sample, float lowerLimit,
-				float upperLimit);
-		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
-		}
-
-	};
-	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float *low, float *high);
-	void calculateFusePower();
-	void checkFuseState();
-	void reportEvents(Event event);
-	void checkCommandQueue();
-
-	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
-};
-
-#endif /* FUSE_H_ */
+#ifndef FUSE_H_
+#define FUSE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/AbsLimitMonitor.h"
+#include "../power/PowerComponentIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../parameters/ParameterHelper.h"
+#include <list>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class Fuse: public SystemObject,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+private:
+	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
+public:
+	struct VariableIds {
+		uint32_t pidVoltage;
+		uint32_t pidCurrent;
+		uint32_t pidState;
+		uint32_t poolIdPower;
+	};
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+
+	typedef std::list<PowerComponentIF*> DeviceList;
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+			float maxCurrent, uint16_t confirmationCount = 2);
+	virtual ~Fuse();
+	void addDevice(PowerComponentIF *set);
+	float getPower();
+
+	bool isPowerValid();
+
+	ReturnValue_t check();
+	uint8_t getFuseId() const;
+	ReturnValue_t initialize();
+	DeviceList devices;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
+	void setAllMonitorsToUnchecked();
+	ReturnValue_t performOperation(uint8_t opCode);
+	MessageQueueId_t getCommandQueue() const;
+	void setDataPoolEntriesInvalid();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+private:
+	uint8_t oldFuseState;
+	uint8_t fuseId;
+	PowerSwitchIF *powerIF; //could be static in our case.
+	AbsLimitMonitor<float> currentLimit;
+	class PowerMonitor: public MonitorReporter<float> {
+	public:
+		template<typename ... Args>
+		PowerMonitor(Args ... args) :
+				MonitorReporter<float>(std::forward<Args>(args)...) {
+		}
+		ReturnValue_t checkPower(float sample, float lowerLimit,
+				float upperLimit);
+		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
+		}
+
+	};
+	PowerMonitor powerMonitor;
+	GlobDataSet set;
+	PIDReader<float> voltage;
+	PIDReader<float> current;
+	PIDReader<uint8_t> state;
+	gp_float_t power;
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	static object_id_t powerSwitchId;
+	void calculatePowerLimits(float *low, float *high);
+	void calculateFusePower();
+	void checkFuseState();
+	void reportEvents(Event event);
+	void checkCommandQueue();
+
+	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
+};
+
+#endif /* FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index d1acffeb..ef852e64 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,86 +1,86 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
-
-#include <framework/power/PowerComponent.h>
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
-}
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
-}
-
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			streamEndianness);
-}
-
-size_t PowerComponent::getSerializedSize() const {
-	return sizeof(min) + sizeof(max);
-}
-
-object_id_t PowerComponent::getDeviceObjectId() {
-	return deviceObjectId;
-}
-
-uint8_t PowerComponent::getSwitchId1() {
-	return switchId1;
-}
-
-uint8_t PowerComponent::getSwitchId2() {
-	return switchId2;
-}
-
-bool PowerComponent::hasTwoSwitches() {
-	return doIHaveTwoSwitches;
-}
-
-float PowerComponent::getMin() {
-	return min;
-}
-
-float PowerComponent::getMax() {
-	return max;
-}
-
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
-}
-
-ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	if (domainId != moduleId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set<>(min);
-		break;
-	case 1:
-		parameterWrapper->set<>(max);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+/**
+ * @file	PowerComponent.cpp
+ * @brief	This file defines the PowerComponent class.
+ * @date	28.08.2014
+ * @author	baetz
+ */
+
+#include "../power/PowerComponent.h"
+
+PowerComponent::PowerComponent() :
+		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
+		false), min(0.0), max(0.0), moduleId(0) {
+}
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
+				twoSwitches), min(min), max(max), moduleId(moduleId) {
+}
+
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
+}
+
+size_t PowerComponent::getSerializedSize() const {
+	return sizeof(min) + sizeof(max);
+}
+
+object_id_t PowerComponent::getDeviceObjectId() {
+	return deviceObjectId;
+}
+
+uint8_t PowerComponent::getSwitchId1() {
+	return switchId1;
+}
+
+uint8_t PowerComponent::getSwitchId2() {
+	return switchId2;
+}
+
+bool PowerComponent::hasTwoSwitches() {
+	return doIHaveTwoSwitches;
+}
+
+float PowerComponent::getMin() {
+	return min;
+}
+
+float PowerComponent::getMax() {
+	return max;
+}
+
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
+}
+
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	if (domainId != moduleId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set<>(min);
+		break;
+	case 1:
+		parameterWrapper->set<>(max);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 61ab3674..2e11fa82 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,48 +1,48 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/power/PowerComponentIF.h>
-
-class PowerComponent: public PowerComponentIF {
-public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
-
-	virtual object_id_t getDeviceObjectId();
-
-	virtual uint8_t getSwitchId1();
-	virtual uint8_t getSwitchId2();
-
-	bool hasTwoSwitches();
-
-	float getMin();
-	float getMax();
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	const object_id_t deviceObjectId;
-	const uint8_t switchId1;
-	const uint8_t switchId2;
-
-	const bool doIHaveTwoSwitches;
-
-	float min;
-	float max;
-
-	uint8_t moduleId;
-
-	PowerComponent();
-};
-
-#endif /* POWERCOMPONENT_H_ */
+#ifndef POWERCOMPONENT_H_
+#define POWERCOMPONENT_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../power/PowerComponentIF.h"
+
+class PowerComponent: public PowerComponentIF {
+public:
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
+			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+
+	virtual object_id_t getDeviceObjectId();
+
+	virtual uint8_t getSwitchId1();
+	virtual uint8_t getSwitchId2();
+
+	bool hasTwoSwitches();
+
+	float getMin();
+	float getMax();
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	const object_id_t deviceObjectId;
+	const uint8_t switchId1;
+	const uint8_t switchId2;
+
+	const bool doIHaveTwoSwitches;
+
+	float min;
+	float max;
+
+	uint8_t moduleId;
+
+	PowerComponent();
+};
+
+#endif /* POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index f2aa70ae..eeaa39fb 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,24 +1,24 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/parameters/HasParametersIF.h>
-
-class PowerComponentIF : public SerializeIF, public HasParametersIF {
-public:
-	virtual ~PowerComponentIF() {
-
-	}
-
-	virtual object_id_t getDeviceObjectId()=0;
-
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
-
-	virtual float getMin() = 0;
-	virtual float getMax() = 0;
-
-};
-
-#endif /* POWERCOMPONENTIF_H_ */
+#ifndef POWERCOMPONENTIF_H_
+#define POWERCOMPONENTIF_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../parameters/HasParametersIF.h"
+
+class PowerComponentIF : public SerializeIF, public HasParametersIF {
+public:
+	virtual ~PowerComponentIF() {
+
+	}
+
+	virtual object_id_t getDeviceObjectId()=0;
+
+	virtual uint8_t getSwitchId1()=0;
+	virtual uint8_t getSwitchId2()=0;
+	virtual bool hasTwoSwitches()=0;
+
+	virtual float getMin() = 0;
+	virtual float getMax() = 0;
+
+};
+
+#endif /* POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 5433acc9..51300db7 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,128 +1,128 @@
-#include <framework/power/PowerSensor.h>
-#include <framework/ipc/QueueFactory.h>
-
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
-		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
-				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
-				ids.pidVoltage, confirmationCount, limits.voltageMin,
-				limits.voltageMax, events.voltageLow, events.voltageHigh) {
-		commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-PowerSensor::~PowerSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
-	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
-	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
-	return result1;
-}
-
-ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PowerSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t PowerSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return result;
-}
-
-void PowerSensor::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	voltageLimit.setToUnchecked();
-}
-
-void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-float PowerSensor::getPower() {
-	if (power.isValid()) {
-		return power.value;
-	} else {
-		return 0.0;
-	}
-
-}
-
-ReturnValue_t PowerSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState PowerSensor::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
+#include "../power/PowerSensor.h"
+#include "../ipc/QueueFactory.h"
+
+PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
+		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
+				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
+				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+				limits.currentMin, limits.currentMax, events.currentLow,
+				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				ids.pidVoltage, confirmationCount, limits.voltageMin,
+				limits.voltageMax, events.voltageLow, events.voltageHigh) {
+		commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+PowerSensor::~PowerSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t PowerSensor::calculatePower() {
+	set.read();
+	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
+	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage);
+		result2 = currentLimit.doCheck(current);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power = current * voltage;
+	}
+	set.commit();
+	return result1;
+}
+
+ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PowerSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t PowerSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+void PowerSensor::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	voltageLimit.setToUnchecked();
+}
+
+void PowerSensor::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void PowerSensor::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+float PowerSensor::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+
+}
+
+ReturnValue_t PowerSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState PowerSensor::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 0fb47506..dc859ab3 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,71 +1,71 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/datapoolglob/PIDReader.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/monitoring/LimitMonitor.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-class PowerController;
-
-class PowerSensor: public SystemObject,
-		public ReceivesParameterMessagesIF,
-		public HasHealthIF {
-	friend class PowerController;
-public:
-	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
-	};
-	struct DefaultLimits {
-		float currentMin;
-		float currentMax;
-		float voltageMin;
-		float voltageMax;
-	};
-	struct SensorEvents {
-		Event currentLow;
-		Event currentHigh;
-		Event voltageLow;
-		Event voltageHigh;
-	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
-	virtual ~PowerSensor();
-	ReturnValue_t calculatePower();
-	ReturnValue_t performOperation(uint8_t opCode);
-	void setAllMonitorsToUnchecked();
-	MessageQueueId_t getCommandQueue() const;
-	ReturnValue_t initialize();
-	void setDataPoolEntriesInvalid();
-	float getPower();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	GlobDataSet set;
-	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
-	//Variables out
-	gp_float_t power;
-
-	static const uint8_t MODULE_ID_CURRENT = 1;
-	static const uint8_t MODULE_ID_VOLTAGE = 2;
-	void checkCommandQueue();
-protected:
-	LimitMonitor<float> currentLimit;
-	LimitMonitor<float> voltageLimit;
-};
-
-#endif /* POWERSENSOR_H_ */
+#ifndef POWERSENSOR_H_
+#define POWERSENSOR_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/LimitMonitor.h"
+#include "../parameters/ParameterHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MessageQueueIF.h"
+
+class PowerController;
+
+class PowerSensor: public SystemObject,
+		public ReceivesParameterMessagesIF,
+		public HasHealthIF {
+	friend class PowerController;
+public:
+	struct VariableIds {
+		uint32_t pidCurrent;
+		uint32_t pidVoltage;
+		uint32_t poolIdPower;
+	};
+	struct DefaultLimits {
+		float currentMin;
+		float currentMax;
+		float voltageMin;
+		float voltageMax;
+	};
+	struct SensorEvents {
+		Event currentLow;
+		Event currentHigh;
+		Event voltageLow;
+		Event voltageHigh;
+	};
+	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
+			SensorEvents events, uint16_t confirmationCount = 0);
+	virtual ~PowerSensor();
+	ReturnValue_t calculatePower();
+	ReturnValue_t performOperation(uint8_t opCode);
+	void setAllMonitorsToUnchecked();
+	MessageQueueId_t getCommandQueue() const;
+	ReturnValue_t initialize();
+	void setDataPoolEntriesInvalid();
+	float getPower();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	GlobDataSet set;
+	//Variables in
+	PIDReader<float> current;
+	PIDReader<float> voltage;
+	//Variables out
+	gp_float_t power;
+
+	static const uint8_t MODULE_ID_CURRENT = 1;
+	static const uint8_t MODULE_ID_VOLTAGE = 2;
+	void checkCommandQueue();
+protected:
+	LimitMonitor<float> currentLimit;
+	LimitMonitor<float> voltageLimit;
+};
+
+#endif /* POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index f25589c4..817c4ce1 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,80 +1,80 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-/**
- *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
- * @ingroup interfaces
- */
-class PowerSwitchIF : public HasReturnvaluesIF {
-public:
-	/**
-	 * Empty dtor.
-	 */
-	virtual ~PowerSwitchIF() {
-
-	}
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
-	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
-	/**
-	 * send a direct command to the Power Unit to enable/disable the specified switch.
-	 *
-	 * @param switchNr
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
-	/**
-	 * Sends a command to the Power Unit to enable a certain fuse.
-	 */
-	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
-
-	/**
-	 * get the state of the Switches.
-	 * @param switchNr
-	 * @return
-	 *     - @c SWITCH_ON if the specified switch is on.
-	 *     - @c SWITCH_OFF if the specified switch is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
-	/**
-	 * get state of a fuse.
-	 * @param fuseNr
-	 * @return
-	 *     - @c FUSE_ON if the specified fuse is on.
-	 *     - @c FUSE_OFF if the specified fuse is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
-	/**
-	 * The maximum delay that it will take to change a switch
-	 *
-	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
-	 */
-	virtual uint32_t getSwitchDelayMs(void) const = 0;
-};
-
-
-#endif /* POWERSWITCHIF_H_ */
+/**
+ * @file	PowerSwitchIF.h
+ * @brief	This file defines the PowerSwitchIF class.
+ * @date	20.03.2013
+ * @author	baetz
+ */
+
+#ifndef POWERSWITCHIF_H_
+#define POWERSWITCHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
+ */
+class PowerSwitchIF : public HasReturnvaluesIF {
+public:
+	/**
+	 * Empty dtor.
+	 */
+	virtual ~PowerSwitchIF() {
+
+	}
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
+	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	/**
+	 * send a direct command to the Power Unit to enable/disable the specified switch.
+	 *
+	 * @param switchNr
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
+	/**
+	 * Sends a command to the Power Unit to enable a certain fuse.
+	 */
+	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
+
+	/**
+	 * get the state of the Switches.
+	 * @param switchNr
+	 * @return
+	 *     - @c SWITCH_ON if the specified switch is on.
+	 *     - @c SWITCH_OFF if the specified switch is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
+	/**
+	 * get state of a fuse.
+	 * @param fuseNr
+	 * @return
+	 *     - @c FUSE_ON if the specified fuse is on.
+	 *     - @c FUSE_OFF if the specified fuse is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
+	/**
+	 * The maximum delay that it will take to change a switch
+	 *
+	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
+	 */
+	virtual uint32_t getSwitchDelayMs(void) const = 0;
+};
+
+
+#endif /* POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 6b06bf73..73d9f89b 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,127 +1,127 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/power/PowerSwitcher.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
-}
-
-ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
-	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcher::getStateOfSwitches() {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case ONE_SWITCH:
-		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
-			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
-			return PowerSwitchIF::SWITCH_OFF;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case TWO_SWITCHES:
-		power->sendSwitchCommand(secondSwitch, onOff);
-		/* NO BREAK falls through*/
-	case ONE_SWITCH:
-		power->sendSwitchCommand(firstSwitch, onOff);
-		break;
-	}
-	return;
-
-}
-
-void PowerSwitcher::turnOn() {
-	commandSwitches(PowerSwitchIF::SWITCH_ON);
-	state = WAIT_ON;
-}
-
-void PowerSwitcher::turnOff() {
-	commandSwitches(PowerSwitchIF::SWITCH_OFF);
-	state = WAIT_OFF;
-}
-
-PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
-	if (secondSwitch == NO_SWITCH) {
-		return ONE_SWITCH;
-	} else {
-		return TWO_SWITCHES;
-	}
-}
-
-void PowerSwitcher::doStateMachine() {
-	switch (state) {
-	case SWITCH_IS_OFF:
-	case SWITCH_IS_ON:
-		//Do nothing.
-		break;
-	case WAIT_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			state = SWITCH_IS_OFF;
-		}
-		break;
-	case WAIT_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			state = SWITCH_IS_ON;
-		}
-		break;
-	default:
-		//Should never happen.
-		break;
-	}
-}
-
-ReturnValue_t PowerSwitcher::checkSwitchState() {
-	switch (state) {
-	case WAIT_OFF:
-	case WAIT_ON:
-		return IN_POWER_TRANSITION;
-	case SWITCH_IS_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	case SWITCH_IS_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	}
-	return RETURN_FAILED;
-}
-
-PowerSwitcher::State_t PowerSwitcher::getState() {
-	return state;
-}
-
-uint32_t PowerSwitcher::getSwitchDelay() {
-	return power->getSwitchDelayMs();
-}
-
-uint8_t PowerSwitcher::getFirstSwitch() const {
-	return firstSwitch;
-}
-
-uint8_t PowerSwitcher::getSecondSwitch() const {
-	return secondSwitch;
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/PowerSwitcher.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+		PowerSwitcher::State_t setStartState) :
+		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (power == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcher::getStateOfSwitches() {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case ONE_SWITCH:
+		return power->getSwitchState(firstSwitch);
+	case TWO_SWITCHES:
+		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+			return PowerSwitchIF::SWITCH_ON;
+		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+			return PowerSwitchIF::SWITCH_OFF;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case TWO_SWITCHES:
+		power->sendSwitchCommand(secondSwitch, onOff);
+		/* NO BREAK falls through*/
+	case ONE_SWITCH:
+		power->sendSwitchCommand(firstSwitch, onOff);
+		break;
+	}
+	return;
+
+}
+
+void PowerSwitcher::turnOn() {
+	commandSwitches(PowerSwitchIF::SWITCH_ON);
+	state = WAIT_ON;
+}
+
+void PowerSwitcher::turnOff() {
+	commandSwitches(PowerSwitchIF::SWITCH_OFF);
+	state = WAIT_OFF;
+}
+
+PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
+	if (secondSwitch == NO_SWITCH) {
+		return ONE_SWITCH;
+	} else {
+		return TWO_SWITCHES;
+	}
+}
+
+void PowerSwitcher::doStateMachine() {
+	switch (state) {
+	case SWITCH_IS_OFF:
+	case SWITCH_IS_ON:
+		//Do nothing.
+		break;
+	case WAIT_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			state = SWITCH_IS_OFF;
+		}
+		break;
+	case WAIT_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			state = SWITCH_IS_ON;
+		}
+		break;
+	default:
+		//Should never happen.
+		break;
+	}
+}
+
+ReturnValue_t PowerSwitcher::checkSwitchState() {
+	switch (state) {
+	case WAIT_OFF:
+	case WAIT_ON:
+		return IN_POWER_TRANSITION;
+	case SWITCH_IS_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	case SWITCH_IS_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	}
+	return RETURN_FAILED;
+}
+
+PowerSwitcher::State_t PowerSwitcher::getState() {
+	return state;
+}
+
+uint32_t PowerSwitcher::getSwitchDelay() {
+	return power->getSwitchDelayMs();
+}
+
+uint8_t PowerSwitcher::getFirstSwitch() const {
+	return firstSwitch;
+}
+
+uint8_t PowerSwitcher::getSecondSwitch() const {
+	return secondSwitch;
+}
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 5b2789e9..39f44f50 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,45 +1,45 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-
-class PowerSwitcher : public HasReturnvaluesIF {
-public:
-	enum State_t {
-		WAIT_OFF,
-		WAIT_ON,
-		SWITCH_IS_OFF,
-		SWITCH_IS_ON,
-	};
-	State_t state;
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
-	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
-	ReturnValue_t initialize(object_id_t powerSwitchId);
-	void turnOn();
-	void turnOff();
-	void doStateMachine();
-	State_t getState();
-	ReturnValue_t checkSwitchState();
-	uint32_t getSwitchDelay();
-	uint8_t getFirstSwitch() const;
-	uint8_t getSecondSwitch() const;
-private:
-	uint8_t firstSwitch;
-	uint8_t secondSwitch;
-	PowerSwitchIF* power;
-	static const uint8_t NO_SWITCH = 0xFF;
-	enum SwitchReturn_t {
-		ONE_SWITCH = 1,
-		TWO_SWITCHES = 2
-	};
-	ReturnValue_t getStateOfSwitches();
-	void commandSwitches( ReturnValue_t onOff );
-	SwitchReturn_t howManySwitches();
-};
-
-
-
-#endif /* POWERSWITCHER_H_ */
+#ifndef POWERSWITCHER_H_
+#define POWERSWITCHER_H_
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class PowerSwitcher : public HasReturnvaluesIF {
+public:
+	enum State_t {
+		WAIT_OFF,
+		WAIT_ON,
+		SWITCH_IS_OFF,
+		SWITCH_IS_ON,
+	};
+	State_t state;
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
+	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	ReturnValue_t initialize(object_id_t powerSwitchId);
+	void turnOn();
+	void turnOff();
+	void doStateMachine();
+	State_t getState();
+	ReturnValue_t checkSwitchState();
+	uint32_t getSwitchDelay();
+	uint8_t getFirstSwitch() const;
+	uint8_t getSecondSwitch() const;
+private:
+	uint8_t firstSwitch;
+	uint8_t secondSwitch;
+	PowerSwitchIF* power;
+	static const uint8_t NO_SWITCH = 0xFF;
+	enum SwitchReturn_t {
+		ONE_SWITCH = 1,
+		TWO_SWITCHES = 2
+	};
+	ReturnValue_t getStateOfSwitches();
+	void commandSwitches( ReturnValue_t onOff );
+	SwitchReturn_t howManySwitches();
+};
+
+
+
+#endif /* POWERSWITCHER_H_ */
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index fd6da67e..8a51469f 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,10 +1,10 @@
-#include <framework/pus/CService200ModeCommanding.h>
-#include <framework/pus/servicepackets/Service200Packets.h>
+#include "../pus/CService200ModeCommanding.h"
+#include "../pus/servicepackets/Service200Packets.h"
 
-#include <framework/modes/HasModesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
+#include "../modes/HasModesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../modes/ModeMessage.h"
 
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
         uint16_t apid, uint8_t serviceId):
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index ede61a84..dfb4dfa6 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
 #define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
 
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief Custom PUS service to set mode of all objects implementing HasModesIF
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 4ce2ce54..f6cbf6bf 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,100 +1,100 @@
-#include <framework/pus/Service1TelecommandVerification.h>
-#include <framework/pus/servicepackets/Service1Packets.h>
-
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-
-Service1TelecommandVerification::Service1TelecommandVerification(
-        object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
-        SystemObject(objectId), apid(apid), serviceId(serviceId),
-        targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
-
-MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
-	return tmQueue->getId();
-}
-
-
-ReturnValue_t Service1TelecommandVerification::performOperation(
-		uint8_t operationCode){
-	PusVerificationMessage message;
-	ReturnValue_t status = tmQueue->receiveMessage(&message);
-	while(status == HasReturnvaluesIF::RETURN_OK) {
-		status = sendVerificationReport(&message);
-		if(status != HasReturnvaluesIF::RETURN_OK) {
-			return status;
-		}
-		status = tmQueue->receiveMessage(&message);
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return status;
-	}
-}
-
-
-ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
-		PusVerificationMessage* message) {
-	ReturnValue_t result;
-	if(message->getReportId() % 2 == 0) {
-		result = generateFailureReport(message);
-	} else {
-		result = generateSuccessReport(message);
-	}
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
-		        "Sending verification packet failed !" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateFailureReport(
-        PusVerificationMessage *message) {
-	FailureReport report(
-			message->getReportId(), message->getTcPacketId(),
-			message->getTcSequenceControl(), message->getStep(),
-			message->getErrorCode(), message->getParameter1(),
-			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
-        PusVerificationMessage *message) {
-	SuccessReport report(message->getReportId(),message->getTcPacketId(),
-			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-
-ReturnValue_t Service1TelecommandVerification::initialize() {
-	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
-			get<AcceptsTelemetryIF>(targetDestination);
-	if(funnel == nullptr){
-	    sif::error << "Service1TelecommandVerification::initialize: Specified"
-	            " TM funnel invalid. Make sure it is set up and implements"
-	            " AcceptsTelemetryIF." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
-	return SystemObject::initialize();
-}
+#include "../pus/Service1TelecommandVerification.h"
+#include "../pus/servicepackets/Service1Packets.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::initialize: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 1d4b6719..91275cfb 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,94 +1,94 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-/**
- * @brief Verify TC acceptance, start, progress and execution.
- *
- * Full Documentation: ECSS-E70-41A p.51
- *
- * The telecommand verification service provides the capability for
- * explicit verification of each distinct stage of execution of a telecommand
- * packet, from on-board acceptance through to completion of execution.
- *
- * Minimum capabilities of this service:
- *
- *  - TM[1,1]: Telecommand Acceptance Report - Success.
- *  - TM[1,2]: Telecommand Acceptance Report - Failure.
- *
- * Additional capabilities of this service:
- *
- *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
- *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
- *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
- *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
- *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
- *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
- *
- * This Service is not inherited from PUSServiceBase unlike other PUS Services
- * because all services implementing PUSServiceBase use this service to
- * generate verification reports.
- * @ingroup pus_services
- */
-class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
-
-	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
-	virtual ~Service1TelecommandVerification();
-
-	/**
-	 *
-	 * @return ID of Verification Queue
-	 */
-	virtual MessageQueueId_t getVerificationQueue();
-
-	/**
-	 * Performs the service periodically as specified in init_mission().
-	 * Triggers the handlePacket function to send TC verification messages
-	 * @param operationCode
-	 * @return
-	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-	/**
-	 * Initializes the destination for TC verification messages and initializes
-	 * Service 1 as a system object
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-private:
-	uint16_t apid = 0;
-	uint8_t serviceId = 0;
-
-	object_id_t targetDestination = objects::NO_OBJECT;
-
-	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
-	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
-	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
-
-	uint16_t packetSubCounter = 0;
-
-	MessageQueueIF* tmQueue = nullptr;
-
-	enum class Subservice: uint8_t {
-		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
-		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
-		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
-		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
-		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
-		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
-	};
-};
-
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 84d6693d..26639de6 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,14 +1,14 @@
-#include <framework/pus/Service2DeviceAccess.h>
-#include <framework/pus/servicepackets/Service2Packets.h>
+#include "../pus/Service2DeviceAccess.h"
+#include "../pus/servicepackets/Service2Packets.h"
 
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../serialize/EndianConverter.h"
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
         uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 1a0bede0..3fb9e830 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
 #define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
 
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief   Raw Commanding and Wiretapping of devices.
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 1dfbe229..5343b318 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,91 +1,91 @@
-#include <framework/pus/Service5EventReporting.h>
-#include <framework/pus/servicepackets/Service5Packets.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/events/EventManagerIF.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-
-
-Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
-		PusServiceBase(objectId, apid, serviceId),
-		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service5EventReporting::~Service5EventReporting(){}
-
-ReturnValue_t Service5EventReporting::performService() {
-	EventMessage message;
-	ReturnValue_t status = RETURN_OK;
-	for(uint8_t counter = 0;
-	        counter < maxNumberReportsPerCycle;
-	        counter++)
-	{
-	    // Receive messages even if reporting is disabled for now.
-	    status = eventQueue->receiveMessage(&message);
-	    if(status == MessageQueueIF::EMPTY) {
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
-
-	    if(enableEventReport) {
-	       status = generateEventReport(message);
-	       if(status != HasReturnvaluesIF::RETURN_OK) {
-	           return status;
-	       }
-	    }
-	}
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
-	        " Too many events" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service5EventReporting::generateEventReport(
-		EventMessage message)
-{
-	EventReport report(message.getEventId(),message.getReporter(),
-			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-			message.getSeverity(), packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(
-	        requestQueue->getDefaultDestination(),requestQueue->getId());
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "Service5EventReporting::generateEventReport:"
-		        " Could not send TM packet" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice) {
-	case Subservice::ENABLE: {
-		enableEventReport = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case Subservice::DISABLE: {
-		enableEventReport = false;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-// In addition to the default PUSServiceBase initialization, this service needs
-// to be registered to the event manager to listen for events.
-ReturnValue_t Service5EventReporting::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-				objects::EVENT_MANAGER);
-	if (manager == NULL) {
-			return RETURN_FAILED;
-	}
-	// register Service 5 as listener for events
-	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	     return result;
-	}
-	return PusServiceBase::initialize();
-}
+#include "../pus/Service5EventReporting.h"
+#include "../pus/servicepackets/Service5Packets.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../events/EventManagerIF.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice) {
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 79b7c5e7..3f0c8cdf 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,86 +1,86 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-
-#include <framework/tmtcservices/PusServiceBase.h>
-#include <framework/events/EventMessage.h>
-
-/**
- * @brief Report on-board events like information or errors
- * @details
- * Full Documentation: ECSS-E70-41A p.79
- * Implements the PusServiceBase template class.
- * Documentation: Dissertation Baetz p.135,136
- *
- * This service provides for the reporting to the service user of information of
- * operational significance.
- *   1. reporting of failures or anomalies detected on-board;
- *   2. reporting of autonomous on-board actions;
- *   3. reporting of normal progress of operations and activities, e.g.
- *   detection of events which are not anomalous (such as payload events),
- *   reaching of predefined steps in an operation. Some reports can combine
- *   more than one of these events.
- *
- * Minimum capabilities of this service:
- *
- * - TM[5,1]: Normal/Progress Report
- * - TM[5,2]: Error/Anomaly Report - Low Severity
- * - TM[5,3]: Error/Anomaly Report - Medium Severity
- * - TM[5,4]: Error/Anomaly Report - High Severity
- *
- * Events can be translated by using translator files located in
- * /config/objects/ and /config/events/. Description to events can be added by
- * adding a comment behind the event definition with [//!<] as leading string
- *
- * Additional capabilities of this service:
- *
- *  - TC[5,5]: Enable Event Report Generation (Req. 6)
- *  - TC[5,6]: Disable Event Report Generation (Req. 5)
- * @author 	R. Mueller
- * @ingroup pus_services
- */
-class Service5EventReporting: public PusServiceBase {
-public:
-
-	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
-	virtual ~Service5EventReporting();
-
-	/***
-	* Check for events and generate event reports if required.
-	* @return
-	*/
-	ReturnValue_t performService() override;
-
-	/***
-	 * Turn event generation on or off.
-	 * @return
-	 */
-	ReturnValue_t handleRequest(uint8_t subservice) override;
-
-	/**
-	 * The default PusServiceBase initialize has been overridden but is still
-	 * executed. Registers this service as a listener for events at the
-	 * EventManager.
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-
-	enum Subservice: uint8_t {
-		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
-		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
-		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
-		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
-		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
-		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
-	};
-
-private:
-	uint16_t packetSubCounter = 0;
-	MessageQueueIF* eventQueue = nullptr;
-	bool enableEventReport = true;
-	const uint8_t maxNumberReportsPerCycle;
-
-	ReturnValue_t generateEventReport(EventMessage message);
-};
-
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../events/EventMessage.h"
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 50102b04..7174566a 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,11 +1,11 @@
-#include <framework/pus/Service8FunctionManagement.h>
-#include <framework/pus/servicepackets/Service8Packets.h>
+#include "../pus/Service8FunctionManagement.h"
+#include "../pus/servicepackets/Service8Packets.h"
 
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index e2c7a84f..16523533 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
+#include "../action/ActionMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief Functional commanding.
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 4ba493d0..f4acbb61 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,166 +1,166 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-/**
- * @defgroup spacepackets PUS Packet Definitions
- *  This group contains all implemented TM or TM packages that are sent to
- *  or sent by the OBC.They are exported later to display
- *  packet structures in Mission Information Base (MIB).
- */
-
-/**
- * @brief 	FailureReport class to serialize a failure report
- * @brief 	Subservice 1, 3, 5, 7
- * @ingroup spacepackets
- */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
-public:
-	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_, uint8_t stepNumber_,
-			ReturnValue_t errorCode_, uint32_t errorParameter1_,
-			uint32_t errorParameter2_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), errorCode(errorCode_),
-			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
-			failureSubtype(failureSubtype_) {}
-
-	/**
-	 * This function is called by the FSFW when calling the tm packet send
-	 * function and supplying the SerializeIF* as parameter
-	 * @param buffer Object content is serialized into the buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-	        size_t maxSize, SerializeIF::Endianness streamEndianness
-	        ) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-			        maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		result = SerializeAdapter::serialize(&errorCode, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
-		        maxSize, streamEndianness);
-		return result;
-	}
-
-
-	virtual size_t getSerializedSize() const {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		size += SerializeAdapter::getSerializedSize(&errorCode);
-		size += SerializeAdapter::getSerializedSize(&errorParameter1);
-		size += SerializeAdapter::getSerializedSize(&errorParameter2);
-		return size;
-	}
-
-	/**
-	 * Deserialization is not allowed for a report.
-	 * @param buffer
-	 * @param size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
-	uint32_t errorParameter1;
-	uint32_t errorParameter2;
-	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
-};
-
-/**
- * @brief       Subservices 2, 4, 6, 8
- * @ingroup     spacepackets
- */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
-public:
-	SuccessReport(uint8_t subtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), subtype(subtype_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness
-			) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		return size;
-
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
-};
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index 1b5bf236..6a700b50 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/serialize/SerializeIF.h>
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../modes/ModeMessage.h"
+#include "../../serialize/SerializeIF.h"
 
 /**
  * @brief Subservice 1, 2, 3, 4, 5
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index f292611e..a0b1305d 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,10 +1,10 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 /**
  * @brief Subservice 128
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 14219c93..0b52be3c 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,76 +1,76 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-
-/**
- * @brief Subservice 1, 2, 3, 4
- * Structure of Event Report.
- * It consists of:
- *      1. Report ID(RID). This is the Event ID in the FSFW
- *      2. Object ID of the reporter (e.g. subsystem)
- *      2. Parameter 1
- *      3. Parameter 2
- *
- * @ingroup spacepackets
- */
-class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
-public:
-
-	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-			uint32_t parameter2_):
-			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
-			parameter2(parameter2_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override
-	{
-		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&objectId, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter1, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter2, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&reportId);
-		size += SerializeAdapter::getSerializedSize(&objectId);
-		size += SerializeAdapter::getSerializedSize(&parameter1);
-		size += SerializeAdapter::getSerializedSize(&parameter2);
-		return size;
-
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	EventId_t reportId;
-	object_id_t objectId;
-	uint32_t parameter1;
-	uint32_t parameter2;
-};
-
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+
+/**
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 8ea0d108..d16309ec 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,12 +1,12 @@
 #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
 
 
 /**
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9b9086d9..893ad1db 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,31 +1,31 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-
-#include <framework/returnvalues/FwClassIds.h>
-#include <config/returnvalues/classIds.h>
-#include <cstdint>
-
-#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
-typedef uint16_t ReturnValue_t;
-
-
-class HasReturnvaluesIF {
-public:
-	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {}
-
-	/**
-	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
-	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
-	 * @param interfaceId
-	 * @param number
-	 * @return
-	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
-			uint8_t number) {
-	    return (interfaceId << 8) + number;
-	}
-};
-
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+
+#include "../returnvalues/FwClassIds.h"
+#include <config/returnvalues/classIds.h>
+#include <cstdint>
+
+#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
+typedef uint16_t ReturnValue_t;
+
+
+class HasReturnvaluesIF {
+public:
+	static const ReturnValue_t RETURN_OK = 0;
+	static const ReturnValue_t RETURN_FAILED = 1;
+	virtual ~HasReturnvaluesIF() {}
+
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
+};
+
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 927fe746..8bc91bb5 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,89 +1,89 @@
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-#include <framework/rmap/rmapStructs.h>
-#include <framework/rmap/RMAP.h>
-#include <framework/rmap/RMAPChannelIF.h>
-#include <stddef.h>
-
-ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
-	return cookie->getChannel()->reset();
-}
-
-RMAP::RMAP(){
-
-}
-
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-		size_t length) {
-	uint8_t instruction;
-
-	if ((buffer == NULL) && (length != 0)) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
-	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
-			length);
-
-}
-
-ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return cookie->getChannel()->getReply(cookie, NULL, NULL);
-	} else {
-		return REPLY_MISSMATCH;
-	}
-}
-
-ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
-			NULL, NULL, timeout_us);
-
-}
-ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
-	uint8_t command;
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	command =  RMAPIds::RMAP_COMMAND_READ
-			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
-
-	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
-
-}
-
-ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		size_t *size) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return REPLY_MISSMATCH;
-	} else {
-		return cookie->getChannel()->getReply(cookie, buffer, size);
-	}
-
-}
-
-ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
-		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
-			buffer, size, timeout_us);
-}
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../rmap/rmapStructs.h"
+#include "../rmap/RMAP.h"
+#include "../rmap/RMAPChannelIF.h"
+#include <stddef.h>
+
+ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
+	return cookie->getChannel()->reset();
+}
+
+RMAP::RMAP(){
+
+}
+
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
+	uint8_t instruction;
+
+	if ((buffer == NULL) && (length != 0)) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
+	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
+			length);
+
+}
+
+ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return cookie->getChannel()->getReply(cookie, NULL, NULL);
+	} else {
+		return REPLY_MISSMATCH;
+	}
+}
+
+ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+		uint32_t length, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
+			NULL, NULL, timeout_us);
+
+}
+ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
+	uint8_t command;
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	command =  RMAPIds::RMAP_COMMAND_READ
+			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
+
+	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
+
+}
+
+ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+		size_t *size) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return REPLY_MISSMATCH;
+	} else {
+		return cookie->getChannel()->getReply(cookie, buffer, size);
+	}
+
+}
+
+ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
+		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
+			buffer, size, timeout_us);
+}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 91aa123e..9ab6b87d 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,227 +1,227 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/rmap/RMAPCookie.h>
-
-//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
-
-/**
- * API for a Cookie/Channel based RMAP implementation.
- *
- * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
- * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
- * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
- * the calls.
- *
- * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
- * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
- * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
- * previously is returned.
- * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
- * call, but this should not be assumed generally.
- * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
- * and a Command Mask used for specifying which RMAP capabilities are used.
- * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
- * will initialize all fields which are not set by the cookie's constructor.
- *
- * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
- * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
- * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
- * a SPaceWire transport layer.
- *
- * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
- * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
- * channel to use is contained within the cookie.
- */
-class RMAP: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
-
-	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
-	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
-			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
-	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
-	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE3); //The cookie points to an invalid channel; command was not sent
-//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
-	//command was not sent
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
-			0xE6);	//the channel has no port set
-	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE7);	//The specified port is not valid
-	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
-	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
-	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
-	//return values for both get_write_reply and get_read_reply
-	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
-	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
-	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
-	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
-	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
-	//return values for get_reply
-	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
-			0xC0);//Interface is busy (transmission buffer still being processed)
-	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
-			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
-	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
-			0xC2);	//Invalid data (amount / value)
-	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
-			0xC3);
-
-	//return values for reset
-	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
-	//Other SpW codes:
-	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
-	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
-	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
-	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
-	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
-	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
-	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
-	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
-
-
-	//RMAP standard replies
-	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
-	// error cases or the node does not support
-	// further distinction between the errors
-	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
-			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
-	// the packet type is reserved or the command
-	// is not used by the RMAP protocol.
-	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
-	// the device key did not match that expected
-	// by the target user application
-	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
-	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
-	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
-	// command has been received
-	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
-	// header CRC or during the transfer of data
-	// and Data CRC or immediately thereafter.
-	// Indicates that there was a communication
-	// failure of some sort on the network
-	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
-	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
-			9);	// The verify before write bit of the command
-	// was set so that the data field was buffered in
-	// order to verify the Data CRC before
-	// transferring the data to target memory. The
-	// data field was longer than able to fit inside
-	// the verify buffer resulting in a buffer overrun
-	// Note that the command is not executed in
-	// this case
-	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
-			MAKE_RETURN_CODE(10);// The target user application did not authorise
-	// the requested operation. This may be because
-	// the command requested has not been
-	// implemented
-	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
-			11);	// The amount of data in a RMW command is
-	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
-	// than 0x08)
-	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
-			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
-	// the Target Logical Address was not the value
-	// expected by the target
-
-	/**
-	 * Resets the underlying channel.
-	 *
-	 * @param cookie The cookie which points to the channel to reset
-	 * @return
-	 */
-	static ReturnValue_t reset(RMAPCookie *cookie);
-
-	/**
-	 * send an RMAP write command
-	 *
-	 * datalen is only 24bit wide, rest will be ignored
-	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
-	 * write a CRC sum at data[datalen]
-	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
-	 *
-	 * @param cookie The cookie to write to
-	 * @param buffer the data to write
-	 * @param length length of data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-			size_t length);
-
-	/**
-	 * get the reply to a write command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @return
-	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
-
-	/**
-	 * @see sendWriteCommand()
-	 * @see getWriteReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendWriteCommand()
-	 *       - All of getWriteReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length, uint32_t timeout_us);
-
-	/**
-	 * send an RMAP read command
-	 *
-	 * @param cookie to cookie to read from
-	 * @param expLength the expected maximum length of the reply
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
-			uint32_t expLength);
-
-	/**
-	 * get a reply to an RMAP read command
-	 *
-	 * @param cookie the cookie that was read from
-	 * @param[out] buffer the location of the data
-	 * @param[out] size size of the data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
-	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			size_t *size);
-
-	/**
-	 * @see sendReadCommand()
-	 * @see getReadReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendReadCommand()
-	 *       - All of getReadReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
-			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
-
-protected:
-	RMAP();
-};
-
-#endif /* RMAPpp_H_ */
+#ifndef RMAPpp_H_
+#define RMAPpp_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../rmap/RMAPCookie.h"
+
+//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
+
+/**
+ * API for a Cookie/Channel based RMAP implementation.
+ *
+ * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
+ * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
+ * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
+ * the calls.
+ *
+ * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
+ * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
+ * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
+ * previously is returned.
+ * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
+ * call, but this should not be assumed generally.
+ * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
+ * and a Command Mask used for specifying which RMAP capabilities are used.
+ * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
+ * will initialize all fields which are not set by the cookie's constructor.
+ *
+ * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
+ * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
+ * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
+ * a SPaceWire transport layer.
+ *
+ * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
+ * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
+ * channel to use is contained within the cookie.
+ */
+class RMAP: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
+
+	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
+	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
+			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
+	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
+	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE3); //The cookie points to an invalid channel; command was not sent
+//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
+	//command was not sent
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
+			0xE6);	//the channel has no port set
+	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE7);	//The specified port is not valid
+	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
+	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
+	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
+	//return values for both get_write_reply and get_read_reply
+	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
+	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
+	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
+	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
+	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
+	//return values for get_reply
+	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
+			0xC0);//Interface is busy (transmission buffer still being processed)
+	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
+			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
+	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
+			0xC2);	//Invalid data (amount / value)
+	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
+			0xC3);
+
+	//return values for reset
+	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
+	//Other SpW codes:
+	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
+	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
+	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
+	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
+	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
+	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
+	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
+	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
+
+
+	//RMAP standard replies
+	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
+	// error cases or the node does not support
+	// further distinction between the errors
+	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
+			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
+	// the packet type is reserved or the command
+	// is not used by the RMAP protocol.
+	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
+	// the device key did not match that expected
+	// by the target user application
+	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
+	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
+	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
+	// command has been received
+	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
+	// header CRC or during the transfer of data
+	// and Data CRC or immediately thereafter.
+	// Indicates that there was a communication
+	// failure of some sort on the network
+	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
+	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
+			9);	// The verify before write bit of the command
+	// was set so that the data field was buffered in
+	// order to verify the Data CRC before
+	// transferring the data to target memory. The
+	// data field was longer than able to fit inside
+	// the verify buffer resulting in a buffer overrun
+	// Note that the command is not executed in
+	// this case
+	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
+			MAKE_RETURN_CODE(10);// The target user application did not authorise
+	// the requested operation. This may be because
+	// the command requested has not been
+	// implemented
+	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
+			11);	// The amount of data in a RMW command is
+	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
+	// than 0x08)
+	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
+			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
+	// the Target Logical Address was not the value
+	// expected by the target
+
+	/**
+	 * Resets the underlying channel.
+	 *
+	 * @param cookie The cookie which points to the channel to reset
+	 * @return
+	 */
+	static ReturnValue_t reset(RMAPCookie *cookie);
+
+	/**
+	 * send an RMAP write command
+	 *
+	 * datalen is only 24bit wide, rest will be ignored
+	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
+	 * write a CRC sum at data[datalen]
+	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
+	 *
+	 * @param cookie The cookie to write to
+	 * @param buffer the data to write
+	 * @param length length of data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
+
+	/**
+	 * get the reply to a write command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @return
+	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
+
+	/**
+	 * @see sendWriteCommand()
+	 * @see getWriteReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendWriteCommand()
+	 *       - All of getWriteReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+			uint32_t length, uint32_t timeout_us);
+
+	/**
+	 * send an RMAP read command
+	 *
+	 * @param cookie to cookie to read from
+	 * @param expLength the expected maximum length of the reply
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
+			uint32_t expLength);
+
+	/**
+	 * get a reply to an RMAP read command
+	 *
+	 * @param cookie the cookie that was read from
+	 * @param[out] buffer the location of the data
+	 * @param[out] size size of the data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
+	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+			size_t *size);
+
+	/**
+	 * @see sendReadCommand()
+	 * @see getReadReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendReadCommand()
+	 *       - All of getReadReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
+			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
+
+protected:
+	RMAP();
+};
+
+#endif /* RMAPpp_H_ */
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 34623bb3..037d6d27 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,116 +1,116 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
-
-#include <framework/rmap/RMAPCookie.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-class RMAPChannelIF {
-public:
-	virtual ~RMAPChannelIF(){};
-	/**
-	 * Reset an RMAP channel
-	 *
-	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
-	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
-	 *
-	 * @param channel to reset
-	 *
-	 * @return
-	 *      - @c LINK_DOWN	when the link is down and all replies were missed
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
-	 *      - @c RETURN_OK else
-	 */
-	virtual ReturnValue_t reset()=0;
-
-	/**
-	 * Check if a channel is active (ie has a port)
-	 *
-	 * @param channel_nr
-	 * @return
-	 *      - @c COMMAND_OK if channel is active
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
-	 */
-	virtual ReturnValue_t isActive()=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @param dest_addr	the destination address used by all packets sent from this channel
-	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
-			uint8_t src_addr)=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port)=0;
-
-	/**
-	 * Send an RMAP command
-	 *
-	 * @param cookie the cookie used with this call
-	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
-	 * @param data data to be sent
-	 * @param datalen length of data
-	 * @return
-	 *      - @c RETURN_OK
-	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
-	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
-	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
-	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
-	 */
-	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			const uint8_t *data, size_t datalen)=0;
-
-	/**
-	 * get the reply to an rmap command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @param databuffer a pointer to a pointer the location of the reply will be written to
-	 * @param len a pointer to the variable the length of the reply will be written to
-	 * @return
-	 *      - @c REPLY_NO_REPLY				no reply was received
-	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
-	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
-	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
-	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
-	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
-	 *      - @c WRITE_REPLY_NOT_SUPPORTED
-	 *      - all RMAP standard replies
-	 */
-	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			size_t *len)=0;
-
-	/**
-	 *
-	 * @param cookie
-	 * @param data
-	 * @param datalen
-	 * @param databuffer
-	 * @param len
-	 * @param timeout_us
-	 * @return
-	 *       - all replies of sendCommand() and getReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
-			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
-			uint32_t timeout_us)=0;
-
-};
-
-#endif /* RMAPCHANNELIF_H_ */
+#ifndef RMAPCHANNELIF_H_
+#define RMAPCHANNELIF_H_
+
+#include "../rmap/RMAPCookie.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class RMAPChannelIF {
+public:
+	virtual ~RMAPChannelIF(){};
+	/**
+	 * Reset an RMAP channel
+	 *
+	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
+	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
+	 *
+	 * @param channel to reset
+	 *
+	 * @return
+	 *      - @c LINK_DOWN	when the link is down and all replies were missed
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
+	 *      - @c RETURN_OK else
+	 */
+	virtual ReturnValue_t reset()=0;
+
+	/**
+	 * Check if a channel is active (ie has a port)
+	 *
+	 * @param channel_nr
+	 * @return
+	 *      - @c COMMAND_OK if channel is active
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
+	 */
+	virtual ReturnValue_t isActive()=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @param dest_addr	the destination address used by all packets sent from this channel
+	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
+			uint8_t src_addr)=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port)=0;
+
+	/**
+	 * Send an RMAP command
+	 *
+	 * @param cookie the cookie used with this call
+	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
+	 * @param data data to be sent
+	 * @param datalen length of data
+	 * @return
+	 *      - @c RETURN_OK
+	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
+	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
+	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
+	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
+	 */
+	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
+			const uint8_t *data, size_t datalen)=0;
+
+	/**
+	 * get the reply to an rmap command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @param databuffer a pointer to a pointer the location of the reply will be written to
+	 * @param len a pointer to the variable the length of the reply will be written to
+	 * @return
+	 *      - @c REPLY_NO_REPLY				no reply was received
+	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
+	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
+	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
+	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
+	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
+	 *      - @c WRITE_REPLY_NOT_SUPPORTED
+	 *      - all RMAP standard replies
+	 */
+	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
+			size_t *len)=0;
+
+	/**
+	 *
+	 * @param cookie
+	 * @param data
+	 * @param datalen
+	 * @param databuffer
+	 * @param len
+	 * @param timeout_us
+	 * @return
+	 *       - all replies of sendCommand() and getReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
+			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
+			uint32_t timeout_us)=0;
+
+};
+
+#endif /* RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 223b5165..74101ffa 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,124 +1,124 @@
-#include <framework/rmap/RMAPChannelIF.h>
-#include <framework/rmap/RMAPCookie.h>
-#include <stddef.h>
-
-
-RMAPCookie::RMAPCookie() {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = 0;
-	this->header.address_hh = 0;
-	this->header.address_h = 0;
-	this->header.address_l = 0;
-	this->header.address_ll = 0;
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = NULL;
-	this->command_mask = 0;
-
-	this->dataCRC = 0;
-
-	this->maxReplyLen = 0;
-}
-
-
-
-RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = set_extended_address;
-	setAddress(set_address);
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = set_channel;
-	this->command_mask = set_command_mask;
-	this->dataCRC = 0;
-
-	this->maxReplyLen = maxReplyLen;
-}
-
-
-void RMAPCookie::setAddress(uint32_t address) {
-	this->header.address_hh = (address & 0xFF000000) >> 24;
-	this->header.address_h = (address & 0x00FF0000) >> 16;
-	this->header.address_l = (address & 0x0000FF00) >> 8;
-	this->header.address_ll = address & 0x000000FF;
-}
-
-void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
-	this->header.extended_address = extendedAddress;
-}
-
-void RMAPCookie::setChannel(RMAPChannelIF *channel) {
-	this->channel = channel;
-}
-
-void RMAPCookie::setCommandMask(uint8_t commandMask) {
-	this->command_mask = commandMask;
-}
-
-uint32_t RMAPCookie::getAddress() {
-	return (header.address_hh << 24) + (header.address_h << 16)
-			+ (header.address_l << 8) + (header.address_ll);
-}
-
-uint8_t RMAPCookie::getExtendedAddress() {
-	return header.extended_address;
-}
-
-RMAPChannelIF *RMAPCookie::getChannel() {
-	return channel;
-}
-
-uint8_t RMAPCookie::getCommandMask() {
-	return command_mask;
-}
-
-RMAPCookie::~RMAPCookie() {
-
-}
-
-size_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
-	this->maxReplyLen = maxReplyLen;
-}
-
-RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
-	return &this->header;
-}
-
-uint16_t RMAPCookie::getTransactionIdentifier() const {
-	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
-}
-
-void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
-	header.tid_l  = id_ & 0xFF;
-	header.tid_h = (id_ >> 8 ) & 0xFF;
-}
-
-uint32_t RMAPCookie::getDataLength() const {
-	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
-}
-void RMAPCookie::setDataLength(uint32_t length_) {
-	header.datalen_l = length_ & 0xff;
-	header.datalen_m = (length_ >> 8) & 0xff;
-	header.datalen_h = (length_ >> 16) & 0xff;
-}
+#include "../rmap/RMAPChannelIF.h"
+#include "../rmap/RMAPCookie.h"
+#include <stddef.h>
+
+
+RMAPCookie::RMAPCookie() {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = 0;
+	this->header.address_hh = 0;
+	this->header.address_h = 0;
+	this->header.address_l = 0;
+	this->header.address_ll = 0;
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = NULL;
+	this->command_mask = 0;
+
+	this->dataCRC = 0;
+
+	this->maxReplyLen = 0;
+}
+
+
+
+RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = set_extended_address;
+	setAddress(set_address);
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = set_channel;
+	this->command_mask = set_command_mask;
+	this->dataCRC = 0;
+
+	this->maxReplyLen = maxReplyLen;
+}
+
+
+void RMAPCookie::setAddress(uint32_t address) {
+	this->header.address_hh = (address & 0xFF000000) >> 24;
+	this->header.address_h = (address & 0x00FF0000) >> 16;
+	this->header.address_l = (address & 0x0000FF00) >> 8;
+	this->header.address_ll = address & 0x000000FF;
+}
+
+void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
+	this->header.extended_address = extendedAddress;
+}
+
+void RMAPCookie::setChannel(RMAPChannelIF *channel) {
+	this->channel = channel;
+}
+
+void RMAPCookie::setCommandMask(uint8_t commandMask) {
+	this->command_mask = commandMask;
+}
+
+uint32_t RMAPCookie::getAddress() {
+	return (header.address_hh << 24) + (header.address_h << 16)
+			+ (header.address_l << 8) + (header.address_ll);
+}
+
+uint8_t RMAPCookie::getExtendedAddress() {
+	return header.extended_address;
+}
+
+RMAPChannelIF *RMAPCookie::getChannel() {
+	return channel;
+}
+
+uint8_t RMAPCookie::getCommandMask() {
+	return command_mask;
+}
+
+RMAPCookie::~RMAPCookie() {
+
+}
+
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
+	this->maxReplyLen = maxReplyLen;
+}
+
+RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
+	return &this->header;
+}
+
+uint16_t RMAPCookie::getTransactionIdentifier() const {
+	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
+}
+
+void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
+	header.tid_l  = id_ & 0xFF;
+	header.tid_h = (id_ >> 8 ) & 0xFF;
+}
+
+uint32_t RMAPCookie::getDataLength() const {
+	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
+}
+void RMAPCookie::setDataLength(uint32_t length_) {
+	header.datalen_l = length_ & 0xff;
+	header.datalen_m = (length_ >> 8) & 0xff;
+	header.datalen_h = (length_ >> 16) & 0xff;
+}
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 99ebd6a2..0da03e30 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,59 +1,59 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
-
-#include <framework/devicehandlers/CookieIF.h>
-#include <framework/rmap/rmapStructs.h>
-#include <cstddef>
-
-class RMAPChannelIF;
-
-class RMAPCookie : public CookieIF {
-public:
-	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
-	RMAPCookie();
-
-	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
-	virtual ~RMAPCookie();
-
-
-	void setAddress(uint32_t address);
-	uint32_t getAddress();
-
-	void setExtendedAddress(uint8_t);
-	uint8_t getExtendedAddress();
-
-	void setChannel(RMAPChannelIF *channel);
-	RMAPChannelIF *getChannel();
-
-	void setCommandMask(uint8_t commandMask);
-	uint8_t getCommandMask();
-
-	size_t getMaxReplyLen() const;
-	void setMaxReplyLen(size_t maxReplyLen);
-
-	uint16_t getTransactionIdentifier() const;
-	void setTransactionIdentifier(uint16_t id_);
-
-	RMAPStructs::rmap_cmd_header* getHeader();
-
-	uint32_t getDataLength() const;
-	void setDataLength(uint32_t lenght_);
-
-	uint8_t getDataCrc() const {
-		return dataCRC;
-	}
-
-	void setDataCrc(uint8_t dataCrc) {
-		dataCRC = dataCrc;
-	}
-
-protected:
-	RMAPStructs::rmap_cmd_header header;
-	RMAPChannelIF *channel;
-	uint8_t command_mask;
-	uint32_t maxReplyLen;
-	uint8_t dataCRC;
-};
-
-#endif /* RMAPCOOKIE_H_ */
+#ifndef RMAPCOOKIE_H_
+#define RMAPCOOKIE_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../rmap/rmapStructs.h"
+#include <cstddef>
+
+class RMAPChannelIF;
+
+class RMAPCookie : public CookieIF {
+public:
+	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
+	RMAPCookie();
+
+	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+	virtual ~RMAPCookie();
+
+
+	void setAddress(uint32_t address);
+	uint32_t getAddress();
+
+	void setExtendedAddress(uint8_t);
+	uint8_t getExtendedAddress();
+
+	void setChannel(RMAPChannelIF *channel);
+	RMAPChannelIF *getChannel();
+
+	void setCommandMask(uint8_t commandMask);
+	uint8_t getCommandMask();
+
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
+
+	uint16_t getTransactionIdentifier() const;
+	void setTransactionIdentifier(uint16_t id_);
+
+	RMAPStructs::rmap_cmd_header* getHeader();
+
+	uint32_t getDataLength() const;
+	void setDataLength(uint32_t lenght_);
+
+	uint8_t getDataCrc() const {
+		return dataCRC;
+	}
+
+	void setDataCrc(uint8_t dataCrc) {
+		dataCRC = dataCrc;
+	}
+
+protected:
+	RMAPStructs::rmap_cmd_header header;
+	RMAPChannelIF *channel;
+	uint8_t command_mask;
+	uint32_t maxReplyLen;
+	uint8_t dataCRC;
+};
+
+#endif /* RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 6dc91339..36247ce6 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,47 +1,47 @@
-#include <framework/rmap/RmapDeviceCommunicationIF.h>
-#include <framework/rmap/RMAP.h>
-
-//TODO Cast here are all potential bugs
-RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
-		const uint8_t * sendData, size_t sendLen) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
-	return RMAP::getWriteReply((RMAPCookie *) cookie);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		CookieIF *cookie, size_t requestLen) {
-	return RMAP::sendReadCommand((RMAPCookie *) cookie,
-				((RMAPCookie *) cookie)->getMaxReplyLen());
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
-		uint8_t** buffer, size_t * size) {
-	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
-		uint32_t address) {
-
-	((RMAPCookie *) cookie)->setAddress(address);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
-	return ((RMAPCookie *) cookie)->getAddress();
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
-		uint32_t parameter) {
-	//TODO Empty?
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
-	return 0;
-}
+#include "../rmap/RmapDeviceCommunicationIF.h"
+#include "../rmap/RMAP.h"
+
+//TODO Cast here are all potential bugs
+RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
+	return RMAP::getWriteReply((RMAPCookie *) cookie);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
+		CookieIF *cookie, size_t requestLen) {
+	return RMAP::sendReadCommand((RMAPCookie *) cookie,
+				((RMAPCookie *) cookie)->getMaxReplyLen());
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
+	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
+		uint32_t address) {
+
+	((RMAPCookie *) cookie)->setAddress(address);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
+	return ((RMAPCookie *) cookie)->getAddress();
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
+		uint32_t parameter) {
+	//TODO Empty?
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
+	return 0;
+}
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 12bac57a..b0564193 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,89 +1,89 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-
-#include <framework/devicehandlers/DeviceCommunicationIF.h>
-
-/**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
- *          It expects RMAPCookies or a derived class of RMAPCookies
- *
- * @details	The open, close and reOpen calls are mission specific
- * 			The open call might return any child of RMAPCookies
- *
- * \ingroup rmap
- */
-class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
-
-public:
-	virtual ~RmapDeviceCommunicationIF();
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device.
-	 *
-	 * @param cookie
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size);
-
-	ReturnValue_t setAddress(CookieIF* cookie,
-			uint32_t address);
-	uint32_t getAddress(CookieIF* cookie);
-	ReturnValue_t setParameter(CookieIF* cookie,
-			uint32_t parameter);
-	uint32_t getParameter(CookieIF* cookie);
-};
-
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+
+#include "../devicehandlers/DeviceCommunicationIF.h"
+
+/**
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
+ *
+ * @details	The open, close and reOpen calls are mission specific
+ * 			The open call might return any child of RMAPCookies
+ *
+ * \ingroup rmap
+ */
+class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
+
+public:
+	virtual ~RmapDeviceCommunicationIF();
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
+	 *
+	 * @param cookie
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
+
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
+};
+
+#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 81117a5e..fae10bca 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -1,124 +1,124 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include <framework/osal/Endiness.h>
-#include <cstring>
-#include <iostream>
-
-/**
- * Helper class to convert variables or bitstreams between machine
- * endian and either big or little endian.
- * Machine endian is the endianness used by the machine running the
- * program and is one of big or little endian. As this is portable
- * code, it is not known at coding time which it is. At compile time
- * it is however, which is why this is implemented using compiler
- * macros and translates to a copy operation at runtime.
- *
- * This changes the layout of multi-byte variables in the machine's
- * memory. In most cases, you should not need to use this class.
- * Probably what you are looking for is the SerializeAdapter.
- * If you still decide you need this class, please read and understand
- * the code first.
- *
- * The order of the individual bytes of the multi-byte variable is
- * reversed, the byte at the highest address is moved to the lowest
- * address and vice versa, same for the bytes in between.
- *
- * Note that the conversion is also its inversion, that is converting
- * from machine to a specified endianness is the same operation as
- * converting from specified to machine (I looked it up, mathematicians
- * would call it an involution):
- *
- * X == convertBigEndian(convertBigEndian(X))
- *
- * Thus, there is only one function supplied to do the conversion.
- */
-class EndianConverter {
-private:
-	EndianConverter() {};
-public:
-	/**
-	 * Convert a typed variable between big endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertBigEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t*) &tmp;
-		uint8_t *pointerIn = (uint8_t*) &in;
-		for (size_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-
-	/**
-	 * convert a bytestream representing a single variable between big endian
-	 * and machine endian.
-	 */
-	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (size_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-
-	/**
-	 * Convert a typed variable between little endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertLittleEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			T tmp;
-			uint8_t *pointerOut = (uint8_t *) &tmp;
-			uint8_t *pointerIn = (uint8_t *) &in;
-			for (size_t count = 0; count < sizeof(T); count++) {
-				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-			}
-			return tmp;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		return in;
-#else
-	#error Unknown Byte Order
-	#endif
-	}
-	/**
-	 * convert a bytestream representing a single variable between little endian
-	 * and machine endian.
-	 */
-	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (size_t count = 0; count < size; count++) {
-				out[size - count - 1] = in[count];
-			}
-			return;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include "../osal/Endiness.h"
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 17a4558f..19190abd 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,91 +1,91 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
-
-#include <framework/container/ArrayList.h>
-#include <framework/serialize/SerializeIF.h>
-#include <utility>
-
-/**
- * Also serializes length field !
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialArrayListAdapter : public SerializeIF {
-public:
-	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-				buffer, size, maxSize, streamEndianness);
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return getSerializedSize(adaptee);
-	}
-
-	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
-		uint32_t printSize = sizeof(count_t);
-		count_t i = 0;
-
-		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, streamEndianness);
-		if (tempSize > list->maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		list->size = tempSize;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::deSerialize(
-					&list->front()[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
-private:
-	ArrayList<T, count_t> *adaptee;
-};
-
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+/**
+ * @file	SerialArrayListAdapter.h
+ * @brief	This file defines the SerialArrayListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALARRAYLISTADAPTER_H_
+#define SERIALARRAYLISTADAPTER_H_
+
+#include "../container/ArrayList.h"
+#include "../serialize/SerializeIF.h"
+#include <utility>
+
+/**
+ * Also serializes length field !
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialArrayListAdapter : public SerializeIF {
+public:
+	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
+				buffer, size, maxSize, streamEndianness);
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		return getSerializedSize(adaptee);
+	}
+
+	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
+		uint32_t printSize = sizeof(count_t);
+		count_t i = 0;
+
+		for (i = 0; i < list->size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		count_t tempSize = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
+				buffer, size, streamEndianness);
+		if (tempSize > list->maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		list->size = tempSize;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::deSerialize(
+					&list->front()[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		list->swapArrayListEndianness();
+	}
+private:
+	ArrayList<T, count_t> *adaptee;
+};
+
+
+
+#endif /* SERIALARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1224bba1..b1e0856a 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,128 +1,128 @@
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <cstring>
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength),
-		constBuffer(buffer), buffer(nullptr),
-		bufferLength(bufferLength) {}
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
-		bufferLength(bufferLength) {}
-
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint32_t serializedLength = bufferLength;
-	if (serializeLength) {
-		serializedLength += SerializeAdapter::getSerializedSize(
-				&bufferLength);
-	}
-	if (*size + serializedLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	} else {
-		if (serializeLength) {
-			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					maxSize, streamEndianness);
-		}
-		if (constBuffer != nullptr) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		}
-		else if (buffer != nullptr) {
-			// This will propably be never reached, constBuffer should always be
-			// set if non-const buffer is set.
-			memcpy(*buffer, this->buffer, bufferLength);
-		}
-		else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-template<typename T>
-size_t SerialBufferAdapter<T>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			T serializedSize = SerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if(bufferLength + serializedSize <= *size) {
-				*buffer +=  serializedSize;
-				*size -= serializedSize;
-			}
-			else {
-				return STREAM_TOO_SHORT;
-			}
-		}
-		//No Else If, go on with buffer
-		if (bufferLength <= *size) {
-			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		else {
-			return STREAM_TOO_SHORT;
-		}
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename count_t>
-uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(buffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getConstBuffer()." << std::endl;
-		return nullptr;
-	}
-	return buffer;
-}
-
-template<typename count_t>
-const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
-		return nullptr;
-	}
-	return constBuffer;
-}
-
-template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t bufferLength) {
-	this->buffer = buffer;
-	this->constBuffer = buffer;
-	this->bufferLength = bufferLength;
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename T>
+ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	uint32_t serializedLength = bufferLength;
+	if (serializeLength) {
+		serializedLength += SerializeAdapter::getSerializedSize(
+				&bufferLength);
+	}
+	if (*size + serializedLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	} else {
+		if (serializeLength) {
+			SerializeAdapter::serialize(&bufferLength, buffer, size,
+					maxSize, streamEndianness);
+		}
+		if (constBuffer != nullptr) {
+			memcpy(*buffer, this->constBuffer, bufferLength);
+		}
+		else if (buffer != nullptr) {
+			// This will propably be never reached, constBuffer should always be
+			// set if non-const buffer is set.
+			memcpy(*buffer, this->buffer, bufferLength);
+		}
+		else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		*size += bufferLength;
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+template<typename T>
+size_t SerialBufferAdapter<T>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename T>
+ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	//TODO Ignores Endian flag!
+	if (buffer != NULL) {
+		if(serializeLength){
+			T serializedSize = SerializeAdapter::getSerializedSize(
+					&bufferLength);
+			if(bufferLength + serializedSize <= *size) {
+				*buffer +=  serializedSize;
+				*size -= serializedSize;
+			}
+			else {
+				return STREAM_TOO_SHORT;
+			}
+		}
+		//No Else If, go on with buffer
+		if (bufferLength <= *size) {
+			*size -= bufferLength;
+			memcpy(this->buffer, *buffer, bufferLength);
+			(*buffer) += bufferLength;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		else {
+			return STREAM_TOO_SHORT;
+		}
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 2c47e0f1..c3dfcd8f 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-
-/**
- * This adapter provides an interface for SerializeIF to serialize or deserialize
- * buffers with no length header but a known size.
- *
- * Additionally, the buffer length can be serialized too and will be put in
- * front of the serialized buffer.
- *
- * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
- * Right now, the SerialBufferAdapter must always
- * be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename count_t>
-class SerialBufferAdapter: public SerializeIF {
-public:
-
-    /**
-     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength
-     */
-    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    /**
-     * Constructor for non-constant uint8_t buffer.
-     * Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength Length field will be serialized with size count_t
-     */
-    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    virtual ~SerialBufferAdapter();
-
-    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const override;
-
-    virtual size_t getSerializedSize() const override;
-
-    /**
-     * @brief This function deserializes a buffer into the member buffer.
-     * @details
-     * If a length field is present, it is ignored, as the size should have
-     * been set in the constructor. If the size is not known beforehand,
-     * consider using SerialFixedArrayListAdapter instead.
-     * @param buffer [out] Resulting buffer
-     * @param size remaining size to deserialize, should be larger than buffer
-     *        + size field size
-     * @param bigEndian
-     * @return
-     */
-    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) override;
-
-    uint8_t * getBuffer();
-    const uint8_t * getConstBuffer();
-    void setBuffer(uint8_t* buffer, count_t bufferLength);
-private:
-	bool serializeLength = false;
-	const uint8_t *constBuffer = nullptr;
-	uint8_t *buffer = nullptr;
-	count_t bufferLength = 0;
-};
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 196af67c..7968b420 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,63 +1,63 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-
-/**
- * @brief 	This adapter provides an interface for SerializeIF to serialize and
- * 			deserialize buffers with a header containing the buffer length.
- * @details
- * Can be used by SerialLinkedListAdapter by declaring
- * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
- * The sequence of objects is defined in the constructor by
- * using the setStart and setNext functions.
- *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
- * @ingroup serialize
- */
-template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter :
-		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
-		public SerializeIF {
-public:
-	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor.
-	 * Refer to the fixed array list constructors for different options.
-	 * @param args
-	 */
-	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) :
-	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
-	        std::forward<Args>(args)...){}
-
-    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
-                buffer, size, maxSize, streamEndianness);
-    }
-
-    size_t getSerializedSize() const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
-    }
-
-    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
-                buffer, size, streamEndianness);
-    }
-
-};
-
-#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
+#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
+#define SERIALFIXEDARRAYLISTADAPTER_H_
+
+#include "../container/FixedArrayList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+
+/**
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
+ * @details
+ * Can be used by SerialLinkedListAdapter by declaring
+ * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
+ *
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
+ *
+ * @ingroup serialize
+ */
+template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
+public:
+	/**
+	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
+	 * @param args
+	 */
+	template<typename... Args>
+	SerialFixedArrayListAdapter(Args... args) :
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+                buffer, size, maxSize, streamEndianness);
+    }
+
+    size_t getSerializedSize() const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+    }
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
+
+};
+
+#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index c822bd1b..a4652028 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,133 +1,133 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
-
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerializeIF.h>
-//This is where we need the SerializeAdapter!
-
- /**
- * @brief  	Implement the conversion of object data to data streams
- * 		   	or vice-versa, using linked lists.
- * @details
- * An alternative to the AutoSerializeAdapter functions
- *   - All object members with a datatype are declared as
- *     SerializeElement<element_type> members inside the class
- *     implementing this adapter.
- *   - The element type can also be a SerialBufferAdapter to
- *     de-/serialize buffers with a known size
- *   - The element type can also be a SerialFixedArrayListAdapter to
- *     de-/serialize buffers with a size header, which is scanned automatically.
- *
- * The sequence of objects is defined in the constructor by using
- * the setStart and setNext functions.
- *
- * 1. The serialization process is done by instantiating the class and
- *    calling serialize after all SerializeElement entries have been set by
- *    using the constructor or setter functions. An additional size variable
- *    can be supplied which is calculated/incremented automatically.
- * 2. The deserialization process is done by instantiating the class and
- *    supplying a buffer with the data which is converted into an object.
- *    The size of data to serialize can be supplied and is
- *    decremented in the function. Range checking is done internally.
- *
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
-public:
-	/**
-	 * Copying is forbidden by deleting the copy constructor and the copy
-	 * assignment operator because of the pointers to the linked list members.
-	 * Unless the child class implements an own copy constructor or
-	 * copy assignment operator, these operation will throw a compiler error.
-	 * @param
-	 */
-	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
-	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
-
-	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
-			bool printCount = false) :
-			SinglyLinkedList<T>(start), printCount(printCount) {
-	}
-
-	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
-			SinglyLinkedList<T>(first), printCount(printCount) {
-
-	}
-
-	SerialLinkedListAdapter(bool printCount = false) :
-			SinglyLinkedList<T>(), printCount(printCount) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		if (printCount) {
-			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, size_t* size, size_t maxSize,
-			Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, maxSize,
-					streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		if (printCount) {
-			return SerialLinkedListAdapter<T>::getSerializedSize()
-					+ sizeof(count_t);
-		} else {
-			return getSerializedSize(SinglyLinkedList<T>::start);
-		}
-	}
-
-	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		size_t size = 0;
-		while (element != NULL) {
-			size += element->value->getSerializedSize();
-			element = element->getNext();
-		}
-		return size;
-	}
-
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	bool printCount;
-};
-
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+/**
+ * @file	SerialLinkedListAdapter.h
+ * @brief	This file defines the SerialLinkedListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALLINKEDLISTADAPTER_H_
+#define SERIALLINKEDLISTADAPTER_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerializeIF.h"
+//This is where we need the SerializeAdapter!
+
+ /**
+ * @brief  	Implement the conversion of object data to data streams
+ * 		   	or vice-versa, using linked lists.
+ * @details
+ * An alternative to the AutoSerializeAdapter functions
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers with a known size
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
+ *
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
+ *
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
+ *
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
+public:
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
+
+	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
+			bool printCount = false) :
+			SinglyLinkedList<T>(start), printCount(printCount) {
+	}
+
+	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
+			SinglyLinkedList<T>(first), printCount(printCount) {
+
+	}
+
+	SerialLinkedListAdapter(bool printCount = false) :
+			SinglyLinkedList<T>(), printCount(printCount) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		if (printCount) {
+			count_t mySize = SinglyLinkedList<T>::getSize();
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const LinkedElement<T>* element,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			result = element->value->serialize(buffer, size, maxSize,
+					streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		if (printCount) {
+			return SerialLinkedListAdapter<T>::getSerializedSize()
+					+ sizeof(count_t);
+		} else {
+			return getSerializedSize(SinglyLinkedList<T>::start);
+		}
+	}
+
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
+		while (element != NULL) {
+			size += element->value->getSerializedSize();
+			element = element->getNext();
+		}
+		return size;
+	}
+
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(LinkedElement<T>* element,
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			result = element->value->deSerialize(buffer, size, streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	bool printCount;
+};
+
+#endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 4534ffb8..bcddb71a 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,175 +1,175 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
-
-#include <framework/container/IsDerivedFrom.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/serialize/SerializeIF.h>
-#include <type_traits>
-
- /**
- * @brief These adapters provides an interface to use the SerializeIF functions
- * 		  with arbitrary template objects to facilitate and simplify the
- * 		  serialization of classes with different multiple different data types
- * 		  into buffers and vice-versa.
- * @details
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-
-class SerializeAdapter {
-public:
-	template<typename T>
-	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, maxSize,
-				streamEndianness);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	template<typename T>
-	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			size_t *size, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, streamEndianness);
-	}
-private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
-	public:
-		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
-				T tmp;
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					tmp = EndianConverter::convertBigEndian<T>(*object);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					tmp = EndianConverter::convertLittleEndian<T>(*object);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					tmp = *object;
-					break;
-				}
-				memcpy(*buffer, &tmp, sizeof(T));
-				*size += sizeof(T);
-				(*buffer) += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::BUFFER_TOO_SHORT;
-			}
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			T tmp;
-			if (*size >= sizeof(T)) {
-				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					*object = EndianConverter::convertBigEndian<T>(tmp);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					*object = EndianConverter::convertLittleEndian<T>(tmp);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					*object = tmp;
-					break;
-				}
-
-				*buffer += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::STREAM_TOO_SHORT;
-			}
-		}
-
-		uint32_t getSerializedSize(const T *object) {
-			return sizeof(T);
-		}
-
-	};
-
-	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
-	public:
-		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size,
-				SerializeIF::Endianness streamEndianness) const {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			return object->serialize(buffer, size, max_size, streamEndianness);
-		}
-		uint32_t getSerializedSize(const T *object) const {
-			return object->getSerializedSize();
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			return object->deSerialize(buffer, size, streamEndianness);
-		}
-	};
-};
-
-#endif /* SERIALIZEADAPTER_H_ */
+#ifndef SERIALIZEADAPTER_H_
+#define SERIALIZEADAPTER_H_
+
+#include "../container/IsDerivedFrom.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serialize/SerializeIF.h"
+#include <type_traits>
+
+ /**
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
+ * @details
+ *
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
+ *
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data. Examples:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
+ *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
+ *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
+ *
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+
+class SerializeAdapter {
+public:
+	template<typename T>
+	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	template<typename T>
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	template<typename T>
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) const {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
+};
+
+#endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 5ad0e4b2..e33192ca 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,60 +1,60 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
-
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <utility>
-
-/**
- * @brief This class is used to mark datatypes for serialization with the
- *        SerialLinkedListAdapter
- * @details
- * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
- * inside a SerialLinkedListAdapter implementation and setting the sequence
- * of objects with setNext() and setStart().
- * Serilization and Deserialization is then performed automatically in
- * specified sequence order.
- * @ingroup serialize
- */
-template<typename T>
-class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
-public:
-	template<typename ... Args>
-	SerializeElement(Args ... args) :
-			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
-
-	}
-	SerializeElement() :
-			LinkedElement<SerializeIF>(this) {
-	}
-	T entry;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&entry);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&entry, buffer, size,
-				streamEndianness);
-	}
-
-	operator T() {
-		return entry;
-	}
-
-	SerializeElement<T>& operator=(T newValue) {
-		entry = newValue;
-		return *this;
-	}
-	T* operator->() {
-		return &entry;
-	}
-};
-
-#endif /* SERIALIZEELEMENT_H_ */
+#ifndef SERIALIZEELEMENT_H_
+#define SERIALIZEELEMENT_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include <utility>
+
+/**
+ * @brief This class is used to mark datatypes for serialization with the
+ *        SerialLinkedListAdapter
+ * @details
+ * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
+ * inside a SerialLinkedListAdapter implementation and setting the sequence
+ * of objects with setNext() and setStart().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
+ */
+template<typename T>
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
+public:
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+
+	}
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
+	}
+	T entry;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
+	}
+
+	operator T() {
+		return entry;
+	}
+
+	SerializeElement<T>& operator=(T newValue) {
+		entry = newValue;
+		return *this;
+	}
+	T* operator->() {
+		return &entry;
+	}
+};
+
+#endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 14eef927..8dc4894a 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,58 +1,58 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-/**
- * @defgroup serialize Serialization
- * Contains serialisation services.
- */
-
-/**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
- * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-class SerializeIF {
-public:
-	enum class Endianness : uint8_t {
-		BIG, LITTLE, MACHINE
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
-	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
-
-	virtual ~SerializeIF() {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const = 0;
-
-	virtual size_t getSerializedSize() const = 0;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) = 0;
-
-};
-
-#endif /* SERIALIZEIF_H_ */
+#ifndef SERIALIZEIF_H_
+#define SERIALIZEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @defgroup serialize Serialization
+ * Contains serialisation services.
+ */
+
+/**
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
+ *
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+class SerializeIF {
+public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
+	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
+
+	virtual ~SerializeIF() {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const = 0;
+
+	virtual size_t getSerializedSize() const = 0;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
+
+};
+
+#endif /* SERIALIZEIF_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 8c510eac..e7b2a43e 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,217 +1,217 @@
-#include <framework/timemanager/Clock.h>
-#include <framework/serviceinterface/ServiceInterfaceBuffer.h>
-#include <cstring>
-#include <inttypes.h>
-
-// to be implemented by bsp
-extern "C" void printChar(const char*, bool errStream);
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
-		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), buffered(buffered),
-		errStream(errStream) {
-	if(buffered) {
-		// Set pointers if the stream is buffered.
-		setp( buf, buf + BUF_SIZE );
-	}
-	preamble.reserve(MAX_PREAMBLE_SIZE);
-	preamble.resize(MAX_PREAMBLE_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		if(errStream) {
-			printChar(begin, true);
-		}
-		else {
-			printChar(begin, false);
-		}
-	}
-}
-
-#endif
-
-int ServiceInterfaceBuffer::overflow(int c) {
-	if(not buffered and this->isActive) {
-		if (c != Traits::eof()) {
-			if(errStream) {
-				printChar(reinterpret_cast<const char*>(&c), true);
-			}
-			else {
-				printChar(reinterpret_cast<const char*>(&c), false);
-			}
-		}
-		return 0;
-	}
-	// Handle output
-	putChars(pbase(), pptr());
-	if (c != Traits::eof()) {
-		char c2 = c;
-		// Handle the one character that didn't fit to buffer
-		putChars(&c2, &c2 + 1);
-	}
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	// I'm not sure about this return value!
-	return 0;
-}
-
-int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive and not buffered) {
-		if(not buffered) {
-			setp(buf, buf + BUF_SIZE - 1);
-		}
-		return 0;
-	}
-	if(not buffered) {
-		return 0;
-	}
-
-	size_t preambleSize  = 0;
-	std::string* preamble = getPreamble(&preambleSize);
-	// Write logMessage and time
-	this->putChars(preamble->data(), preamble->data() + preambleSize);
-	// Handle output
-	this->putChars(pbase(), pptr());
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	return 0;
-}
-
-bool ServiceInterfaceBuffer::isBuffered() const {
-	return buffered;
-}
-
-std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
-	Clock::getDateAndTime(&loggerTime);
-	size_t currentSize = 0;
-	char* parsePosition = &preamble[0];
-	if(addCrToPreamble) {
-		preamble[0] = '\r';
-		currentSize += 1;
-		parsePosition += 1;
-	}
-	int32_t charCount = sprintf(parsePosition,
-			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
-					this->logMessage.c_str(), loggerTime.hour,
-					loggerTime.minute,
-					loggerTime.second,
-					loggerTime.usecond /1000);
-	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return &preamble;
-	}
-	if(charCount > MAX_PREAMBLE_SIZE) {
-		printf("ServiceInterfaceBuffer: Char count too large for maximum "
-				"preamble size");
-		return &preamble;
-	}
-	currentSize += charCount;
-	if(preambleSize != nullptr) {
-		*preambleSize = currentSize;
-	}
-	return &preamble;
-}
-
-
-
-#ifdef UT699
-#include <framework/osal/rtems/Interrupt.h>
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) {
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (!Interrupt::isInterruptInProgress()) {
-		std::cout << array;
-	} else {
-		//Uncomment the following line if you need ISR debug output.
-//		printk(array);
-	}
-}
-#endif //UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) :
-		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
-				sizeof(remoteAddress)) {
-	setp(buf, buf + BUF_SIZE);
-	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
-	remoteAddress.sin_family = AF_INET;
-	remoteAddress.sin_port = htons(port);
-	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (udpSocket <= 0) {
-		initSocket();
-	}
-
-	if (udpSocket > 0) {
-		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
-				sizeof(remoteAddress));
-	}
-
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-	sockaddr_in address;
-	memset((uint8_t*) &address, 0, sizeof(address));
-	address.sin_family = AF_INET;
-	address.sin_port = htons(0);
-	address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-	if (socket < 0) {
-		printf("Error opening socket!\n");
-		return;
-	}
-	timeval timeout = { 0, 20 };
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_RCVTIMEO socket options!\n");
-		return;
-	}
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_SNDTIMEO socket options!\n");
-		return;
-	}
-	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
-		printf("Error binding socket!\n");
-	}
-}
-
-#endif //ML505
+#include "../timemanager/Clock.h"
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <cstring>
+#include <inttypes.h>
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+	}
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+	if(not buffered and this->isActive) {
+		if (c != Traits::eof()) {
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
+		}
+		return 0;
+	}
+	// Handle output
+	putChars(pbase(), pptr());
+	if (c != Traits::eof()) {
+		char c2 = c;
+		// Handle the one character that didn't fit to buffer
+		putChars(&c2, &c2 + 1);
+	}
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	// I'm not sure about this return value!
+	return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+	if(not this->isActive and not buffered) {
+		if(not buffered) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
+		return 0;
+	}
+	if(not buffered) {
+		return 0;
+	}
+
+	size_t preambleSize  = 0;
+	std::string* preamble = getPreamble(&preambleSize);
+	// Write logMessage and time
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
+	// Handle output
+	this->putChars(pbase(), pptr());
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
+	if(addCrToPreamble) {
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return &preamble;
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
+		return &preamble;
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return &preamble;
+}
+
+
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
+	this->log_message = set_message;
+	this->isActive = true;
+	setp( buf, buf + BUF_SIZE );
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (!Interrupt::isInterruptInProgress()) {
+		std::cout << array;
+	} else {
+		//Uncomment the following line if you need ISR debug output.
+//		printk(array);
+	}
+}
+#endif //UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) :
+		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
+				sizeof(remoteAddress)) {
+	setp(buf, buf + BUF_SIZE);
+	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
+	remoteAddress.sin_family = AF_INET;
+	remoteAddress.sin_port = htons(port);
+	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (udpSocket <= 0) {
+		initSocket();
+	}
+
+	if (udpSocket > 0) {
+		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
+				sizeof(remoteAddress));
+	}
+
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+	sockaddr_in address;
+	memset((uint8_t*) &address, 0, sizeof(address));
+	address.sin_family = AF_INET;
+	address.sin_port = htons(0);
+	address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+	if (socket < 0) {
+		printf("Error opening socket!\n");
+		return;
+	}
+	timeval timeout = { 0, 20 };
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_RCVTIMEO socket options!\n");
+		return;
+	}
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_SNDTIMEO socket options!\n");
+		return;
+	}
+	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
+		printf("Error binding socket!\n");
+	}
+}
+
+#endif //ML505
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 7a2ce2ee..a5c135b6 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,145 +1,145 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-#ifndef UT699
-
-/**
- * @brief 	This is the underlying stream buffer which implements the
- * 			streambuf class and overloads the overflow() and sync() methods
- * @details
- * This class is used to modify the output of the stream, for example by adding.
- * It also calls the char printing function which is implemented in the
- * board supply package (BSP).
- */
-class ServiceInterfaceBuffer:
-        public std::streambuf {
-	friend class ServiceInterfaceStream;
-public:
-	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
-
-	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
-			bool buffered, bool errStream, uint16_t port);
-
-protected:
-	bool isActive;
-	//! This is called when buffer becomes full. If
-	//! buffer is not used, then this is called every
-	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
-
-	//! This function is called when stream is flushed,
-	//! for example when std::endl is put to stream.
-	int sync(void) override;
-
-	bool isBuffered() const;
-private:
-	//! For additional message information
-	std::string logMessage;
-	std::string preamble;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	//! This is useful for some terminal programs which do not have
-	//! implicit carriage return with newline characters.
-	bool addCrToPreamble;
-
-	//! Specifies whether the stream operates in buffered or unbuffered mode.
-	bool buffered;
-	//! This specifies to print to stderr and work in unbuffered mode.
-	bool errStream;
-
-	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	//! In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	std::string* getPreamble(size_t * preambleSize = nullptr);
-};
-
-#endif
-
-
-#ifdef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-};
-#endif //UT699
-
-#ifdef ML505
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	int udpSocket;
-	sockaddr_in remoteAddress;
-	socklen_t remoteAddressLength;
-	void initSocket();
-};
-#endif //ML505
-
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer:
+        public std::streambuf {
+	friend class ServiceInterfaceStream;
+public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
+
+protected:
+	bool isActive;
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
+	int overflow(int c = Traits::eof()) override;
+
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
+	int sync(void) override;
+
+	bool isBuffered() const;
+private:
+	//! For additional message information
+	std::string logMessage;
+	std::string preamble;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
+	bool addCrToPreamble;
+
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
+
+	//! Needed for buffered mode.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	//! In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	std::string* getPreamble(size_t * preambleSize = nullptr);
+};
+
+#endif
+
+
+#ifdef UT699
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+};
+#endif //UT699
+
+#ifdef ML505
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	int udpSocket;
+	sockaddr_in remoteAddress;
+	socklen_t remoteAddressLength;
+	void initSocket();
+};
+#endif //ML505
+
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 31bc7c73..7c6676dd 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,32 +1,32 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&streambuf),
-		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
-
-void ServiceInterfaceStream::setActive( bool myActive) {
-	this->streambuf.isActive = myActive;
-}
-
-std::string* ServiceInterfaceStream::getPreamble() {
-	return streambuf.getPreamble();
-}
-
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive( bool myActive) {
+	this->streambuf.isActive = myActive;
+}
+
+std::string* ServiceInterfaceStream::getPreamble() {
+	return streambuf.getPreamble();
+}
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not streambuf.isBuffered() and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and streambuf.isBuffered()) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index dc111459..b1786a38 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,58 +1,58 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-
-#include <framework/serviceinterface/ServiceInterfaceBuffer.h>
-#include <iostream>
-#include <cstdio>
-
-/**
- * Generic service interface stream which can be used like std::cout or
- * std::cerr but has additional capability. Add preamble and timestamp
- * to output. Can be run in buffered or unbuffered mode.
- */
-class ServiceInterfaceStream : public std::ostream {
-public:
-	/**
-	 * This constructor is used by specifying the preamble message.
-	 * Optionally, the output can be directed to stderr and a CR character
-	 * can be prepended to the preamble.
-	 * @param setMessage message of preamble.
-	 * @param addCrToPreamble Useful for applications like Puttty.
-	 * @param buffered specify whether to use buffered mode.
-	 * @param errStream specify which output stream to use (stderr or stdout).
-	 */
-	ServiceInterfaceStream(std::string setMessage,
-			bool addCrToPreamble = false, bool buffered = true,
-			bool errStream = false, uint16_t port = 1234);
-
-	//! An inactive stream will not print anything.
-	void setActive( bool );
-
-	/**
-	 * This can be used to retrieve the preamble in case it should be printed in
-	 * the unbuffered mode.
-	 * @return Preamle consisting of log message and timestamp.
-	 */
-	std::string* getPreamble();
-
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
-protected:
-	ServiceInterfaceBuffer streambuf;
-};
-
-// Forward declaration of interface streams. These should be instantiated in
-// main. They can then be used like std::cout or std::cerr.
-namespace sif {
-extern ServiceInterfaceStream debug;
-extern ServiceInterfaceStream info;
-extern ServiceInterfaceStream warning;
-extern ServiceInterfaceStream error;
-}
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <iostream>
+#include <cstdio>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+public:
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
+
+	//! An inactive stream will not print anything.
+	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string* getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+protected:
+	ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 0bfde58c..ea9f2e44 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,87 +1,87 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/ConstStorageAccessor.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/globalfunctions/arrayprinter.h>
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	arrayprinter::print(constDataPointer, size_);
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/ConstStorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../globalfunctions/arrayprinter.h"
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	arrayprinter::print(constDataPointer, size_);
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 020030a9..ec2da8ce 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-
-#include <framework/storagemanager/storeAddress.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstddef>
-
-class StorageManagerIF;
-
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor(ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include "../storagemanager/storeAddress.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 7e349dcd..5ead7981 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,189 +1,189 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/storagemanager/StorageAccessor.h>
-#include <cstring>
-
-/**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
- */
-template<uint8_t NUMBER_OF_POOLS = 5>
-class LocalPool: public SystemObject, public StorageManagerIF {
-public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Documentation: See StorageManagerIF.h
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
-
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size) override;
-
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
-	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
-	void clearStore() override;
-	ReturnValue_t initialize() override;
-protected:
-	/**
-	 * With this helper method, a free element of @c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
-			store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
-	/**
-	 * @brief	In this array, the element sizes of each pool is stored.
-	 * @details	The sizes are maintained for internal pool management. The sizes
-	 * 			must be set in ascending order on construction.
-	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
-	/**
-	 * @brief	n_elements stores the number of elements per pool.
-	 * @details	These numbers are maintained for internal pool management.
-	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
-	/**
-	 * @brief	store represents the actual memory pool.
-	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a @c new call on construction.
-	 */
-	uint8_t* store[NUMBER_OF_POOLS];
-	/**
-	 * @brief	The size_list attribute stores the size values of every pool element.
-	 * @details	As the number of elements is determined on construction, the size list
-	 * 			is also dynamically allocated there.
-	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
-	//! A variable to determine whether higher n pools are used if
-	//! the store is full.
-	bool spillsToHigherPools;
-	/**
-	 * @brief	This method safely stores the given data in the given packet_id.
-	 * @details	It also sets the size in size_list. The method does not perform
-	 * 			any range checks, these are done in advance.
-	 * @param packet_id	The storage identifier in which the data shall be stored.
-	 * @param data		The data to be stored.
-	 * @param size		The size of the data to be stored.
-	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
-	/**
-	 * @brief	A helper method to read the element size of a certain pool.
-	 * @param pool_index	The pool in which to look.
-	 * @return	Returns the size of an element or 0.
-	 */
-	uint32_t getPageSize(uint16_t pool_index);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size		The size of the data to be stored.
-	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
-	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
-			uint16_t startAtIndex = 0);
-	/**
-	 * @brief	This helper method calculates the true array position in store
-	 * 			of a given packet id.
-	 * @details	The method does not perform any range checks, these are done in
-	 * 			advance.
-	 * @param packet_id	The packet id to look up.
-	 * @return	Returns the position of the data in store.
-	 */
-	uint32_t getRawPosition(store_address_t packet_id);
-	/**
-	 * @brief	This is a helper method to find an empty element in a given pool.
-	 * @details	The method searches size_list for the first empty element, so
-	 * 			duration grows with the fill level of the pool.
-	 * @param pool_index	The pool in which the search is performed.
-	 * @param[out] element	The first found element in the pool.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_STORAGE_FULL if the store is full
-	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-};
-
-#include <framework/storagemanager/LocalPool.tpp>
-
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../internalError/InternalErrorReporterIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include <cstring>
+
+/**
+ * @brief	The LocalPool class provides an intermediate data storage with
+ * 			a fixed pool size policy.
+ * @details	The class implements the StorageManagerIF interface. While the
+ * 			total number of pools is fixed, the element sizes in one pool and
+ * 			the number of pool elements per pool are set on construction.
+ * 			The full amount of memory is allocated on construction.
+ * 			The overhead is 4 byte per pool element to store the size
+ * 			information of each stored element.
+ * 			To maintain an "empty" information, the pool size is limited to
+ * 			0xFFFF-1 bytes.
+ * 			It is possible to store empty packets in the pool.
+ * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
+ */
+template<uint8_t NUMBER_OF_POOLS = 5>
+class LocalPool: public SystemObject, public StorageManagerIF {
+public:
+	/**
+	 * @brief	This definition generally sets the number of different sized pools.
+	 * @details This must be less than the maximum number of pools (currently 0xff).
+	 */
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with @c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Documentation: See StorageManagerIF.h
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			size_t * size) override;
+
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
+protected:
+	/**
+	 * With this helper method, a free element of @c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
+private:
+	/**
+	 * Indicates that this element is free.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
+	 */
+	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+	/**
+	 * @brief	In this array, the element sizes of each pool is stored.
+	 * @details	The sizes are maintained for internal pool management. The sizes
+	 * 			must be set in ascending order on construction.
+	 */
+	uint32_t element_sizes[NUMBER_OF_POOLS];
+	/**
+	 * @brief	n_elements stores the number of elements per pool.
+	 * @details	These numbers are maintained for internal pool management.
+	 */
+	uint16_t n_elements[NUMBER_OF_POOLS];
+	/**
+	 * @brief	store represents the actual memory pool.
+	 * @details	It is an array of pointers to memory, which was allocated with
+	 * 			a @c new call on construction.
+	 */
+	uint8_t* store[NUMBER_OF_POOLS];
+	/**
+	 * @brief	The size_list attribute stores the size values of every pool element.
+	 * @details	As the number of elements is determined on construction, the size list
+	 * 			is also dynamically allocated there.
+	 */
+	uint32_t* size_list[NUMBER_OF_POOLS];
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
+	/**
+	 * @brief	This method safely stores the given data in the given packet_id.
+	 * @details	It also sets the size in size_list. The method does not perform
+	 * 			any range checks, these are done in advance.
+	 * @param packet_id	The storage identifier in which the data shall be stored.
+	 * @param data		The data to be stored.
+	 * @param size		The size of the data to be stored.
+	 */
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	/**
+	 * @brief	A helper method to read the element size of a certain pool.
+	 * @param pool_index	The pool in which to look.
+	 * @return	Returns the size of an element or 0.
+	 */
+	uint32_t getPageSize(uint16_t pool_index);
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size	The size of the data to be stored.
+	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
+	 */
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size		The size of the data to be stored.
+	 * @param[out] poolIndex	The fitting pool index found.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_TOO_LARGE otherwise.
+	 */
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
+	/**
+	 * @brief	This helper method calculates the true array position in store
+	 * 			of a given packet id.
+	 * @details	The method does not perform any range checks, these are done in
+	 * 			advance.
+	 * @param packet_id	The packet id to look up.
+	 * @return	Returns the position of the data in store.
+	 */
+	uint32_t getRawPosition(store_address_t packet_id);
+	/**
+	 * @brief	This is a helper method to find an empty element in a given pool.
+	 * @details	The method searches size_list for the first empty element, so
+	 * 			duration grows with the fill level of the pool.
+	 * @param pool_index	The pool in which the search is performed.
+	 * @param[out] element	The first found element in the pool.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_STORAGE_FULL if the store is full
+	 */
+	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+};
+
+#include "../storagemanager/LocalPool.tpp"
+
+#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 3c1c1217..2dc3266a 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/ipc/MutexHelper.h>
-#include <framework/storagemanager/StorageAccessor.h>
-
-/**
- * @brief	The PoolManager class provides an intermediate data storage with
- * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
- * @author 	Bastian Baetz
- */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
-
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
-	virtual ~PoolManager();
-
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
-	ReturnValue_t deleteData(store_address_t) override;
-	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) override;
-
-protected:
-	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
-
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
-			bool ignoreFault) override;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking is done during searching for free slots
-	 * 			and deleting existing slots.
-	 */
-	MutexIF* mutex;
-};
-
-#include "PoolManager.tpp"
-
-#endif /* POOLMANAGER_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+
+#include "../storagemanager/LocalPool.h"
+#include "../ipc/MutexHelper.h"
+#include "../storagemanager/StorageAccessor.h"
+
+/**
+ * @brief	The PoolManager class provides an intermediate data storage with
+ * 			a fixed pool size policy for inter-process communication.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
+ * @author 	Bastian Baetz
+ */
+template <uint8_t NUMBER_OF_POOLS = 5>
+class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+public:
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	virtual ~PoolManager();
+
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) override;
+
+protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
+	 */
+	MutexIF* mutex;
+};
+
+#include "PoolManager.tpp"
+
+#endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index b827b9c0..d4d2a54d 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,67 +1,67 @@
-#include <framework/storagemanager/StorageAccessor.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large "
-				"enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(dataPointer, dataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool "
-				"entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer + offset);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer + offset);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index d75e06ac..1ca5f7dd 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-
-#include <framework/storagemanager/ConstStorageAccessor.h>
-
-class StorageManagerIF;
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being freed prematurely.
-	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 		move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator=(StorageAccessor&&);
-	StorageAccessor(StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset = 0);
-	uint8_t* data();
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+
+#include "../storagemanager/ConstStorageAccessor.h"
+
+class StorageManagerIF;
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset = 0);
+	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index f8aee819..85341f2e 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,167 +1,167 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
-
-#include <framework/events/Event.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageAccessor.h>
-#include <framework/storagemanager/storeAddress.h>
-#include <utility>
-#include <cstddef>
-
-using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
-using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
-
-/**
- * @brief	This class provides an interface for intermediate data storage.
- * @details	The Storage manager classes shall be used to store larger chunks of
- * 			data in RAM for exchange between tasks. This interface expects the
- * 			data to be stored in one consecutive block of memory, so tasks can
- * 			write directly to the destination pointer.
- * 			For interprocess communication, the stores must be locked during
- * 			insertion and deletion. If the receiving storage identifier is
- * 			passed token-like between tasks, a lock during read and write
- * 			operations is not necessary.
- * @author	Bastian Baetz
- * @date	18.09.2012
- */
-class StorageManagerIF : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
-	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
-	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
-	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
-	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
-	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
-	/**
-	 * @brief This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~StorageManagerIF() {
-	}
-	;
-	/**
-	 * @brief	With addData, a free storage position is allocated and data
-	 * 			stored there.
-	 * @details	During the allocation, the StorageManager is blocked.
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param data	The data to be stored in the StorageManager.
-	 * @param size	The amount of data to be stored.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t addData(store_address_t* storageId,
-			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
-	/**
-	 * @brief	With deleteData, the storageManager frees the memory region
-	 * 			identified by packet_id.
-	 * @param packet_id	The identifier of the memory region to be freed.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if deletion did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
-	/**
-	 * @brief	Another deleteData which uses the pointer and size of the
-	 * 			stored data to delete the content.
-	 * @param buffer	Pointer to the data.
-	 * @param size		Size of data to be stored.
-	 * @param storeId	Store id of the deleted element (optional)
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	failure code if deletion did not work
-	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) = 0;
-
-
-	/**
-	 * @brief 	Access the data by supplying a store ID.
-	 * @details
-	 * A pair consisting of the retrieval result and an instance of a
-	 * ConstStorageAccessor class is returned
-	 * @param storeId
-	 * @return Pair of return value and a ConstStorageAccessor instance
-	 */
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-
-	/**
-	 * @brief 	Access the data by supplying a store ID and a helper
-	 * 			instance
-	 * @param storeId
-	 * @param constAccessor Wrapper function to access store data.
-	 * @return
-	 */
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor& constAccessor) = 0;
-
-
-	/**
-	 * @brief	getData returns an address to data and the size of the data
-	 * 			for a given packet_id.
-	 * @param packet_id		The id of the data to be returned
-	 * @param packet_ptr	The passed pointer address is set to the the memory
-	 * 						position
-	 * @param size			The exact size of the stored data is returned here.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if fetching data did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t* size) = 0;
-
-
-	/**
-	 * Modify data by supplying a store ID
-	 * @param storeId
-	 * @return Pair of return value and StorageAccessor helper
-	 */
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-
-	/**
-	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
-	 * @param storeId
-	 * @param accessor Helper class to access the modifiable data.
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-				StorageAccessor& accessor) = 0;
-
-	/**
-	 * Get pointer and size of modifiable data by supplying the storeId
-	 * @param packet_id
-	 * @param packet_ptr [out] Pointer to pointer of data to set
-	 * @param size [out] Pointer to size to set
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t* size) = 0;
-	/**
-	 * This method reserves an element of \c size.
-	 *
-	 * It returns the packet id of this element as well as a direct pointer to the
-	 * data of the element. It must be assured that exactly \c size data is
-	 * written to p_data!
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param size		The size of the space to be reserved.
-	 * @param p_data	A pointer to the element data is returned here.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
-
-	/**
-	 * Clears the whole store.
-	 * Use with care!
-	 */
-	virtual void clearStore() = 0;
-};
-
-#endif /* STORAGEMANAGERIF_H_ */
+#ifndef STORAGEMANAGERIF_H_H
+#define STORAGEMANAGERIF_H_H
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/storeAddress.h"
+#include <utility>
+#include <cstddef>
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
+
+/**
+ * @brief	This class provides an interface for intermediate data storage.
+ * @details	The Storage manager classes shall be used to store larger chunks of
+ * 			data in RAM for exchange between tasks. This interface expects the
+ * 			data to be stored in one consecutive block of memory, so tasks can
+ * 			write directly to the destination pointer.
+ * 			For interprocess communication, the stores must be locked during
+ * 			insertion and deletion. If the receiving storage identifier is
+ * 			passed token-like between tasks, a lock during read and write
+ * 			operations is not necessary.
+ * @author	Bastian Baetz
+ * @date	18.09.2012
+ */
+class StorageManagerIF : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
+	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
+	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
+	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
+	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
+	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	/**
+	 * @brief This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~StorageManagerIF() {
+	}
+	;
+	/**
+	 * @brief	With addData, a free storage position is allocated and data
+	 * 			stored there.
+	 * @details	During the allocation, the StorageManager is blocked.
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param data	The data to be stored in the StorageManager.
+	 * @param size	The amount of data to be stored.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
+	/**
+	 * @brief	With deleteData, the storageManager frees the memory region
+	 * 			identified by packet_id.
+	 * @param packet_id	The identifier of the memory region to be freed.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if deletion did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
+	/**
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
+	 * @param buffer	Pointer to the data.
+	 * @param size		Size of data to be stored.
+	 * @param storeId	Store id of the deleted element (optional)
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	failure code if deletion did not work
+	 */
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
+
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
+
+	/**
+	 * @brief	getData returns an address to data and the size of the data
+	 * 			for a given packet_id.
+	 * @param packet_id		The id of the data to be returned
+	 * @param packet_ptr	The passed pointer address is set to the the memory
+	 * 						position
+	 * @param size			The exact size of the stored data is returned here.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if fetching data did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t getData(store_address_t packet_id,
+			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
+	/**
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t packet_id,
+			uint8_t** packet_ptr, size_t* size) = 0;
+	/**
+	 * This method reserves an element of \c size.
+	 *
+	 * It returns the packet id of this element as well as a direct pointer to the
+	 * data of the element. It must be assured that exactly \c size data is
+	 * written to p_data!
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param size		The size of the space to be reserved.
+	 * @param p_data	A pointer to the element data is returned here.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	/**
+	 * Clears the whole store.
+	 * Use with care!
+	 */
+	virtual void clearStore() = 0;
+};
+
+#endif /* STORAGEMANAGERIF_H_ */
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index fcf2e189..a4869eba 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,662 +1,662 @@
-#include <framework/health/HealthMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/subsystem/Subsystem.h>
-#include <string>
-
-Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
-		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
-		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
-				false), uptimeStartTable(0), currentTargetTable(), targetMode(
-				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
-				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-		NULL)
-#ifdef USE_MODESTORE
-,modeStore(NULL)
-#endif
-{
-
-}
-
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
-
-ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
-		Mode_t fallbackSequence) {
-
-	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
-	//the fallback sequence will be checked when it is needed.
-	if (!existsModeSequence(fallbackSequence)) {
-		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
-	}
-
-	if (iter.value == NULL) {
-		return NO_TARGET_TABLE;
-	}
-
-	for (; iter.value != NULL; ++iter) {
-		if (!existsModeTable(iter->getTableId())) {
-			return TABLE_DOES_NOT_EXIST;
-		} else {
-			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
-			if (result != RETURN_OK) {
-				return result;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
-	if (!existsModeSequence(sequence)) {
-		return SEQUENCE_DOES_NOT_EXIST;
-	}
-	HybridIterator<ModeListEntry> iter = getSequence(sequence);
-	return checkSequence(iter, getFallbackSequence(sequence));
-}
-
-bool Subsystem::existsModeSequence(Mode_t id) {
-	return modeSequences.exists(id) == RETURN_OK;
-}
-
-bool Subsystem::existsModeTable(Mode_t id) {
-	return modeTables.exists(id) == RETURN_OK;
-}
-
-HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
-	return getTable(currentSequenceIterator->getTableId());
-}
-
-void Subsystem::performChildOperation() {
-	if (isInTransition) {
-		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
-			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
-						== RETURN_OK) {
-					setMode(targetMode, targetSubmode);
-					isInTransition = false;
-					return;
-				} else {
-					transitionFailed(TARGET_TABLE_NOT_REACHED,
-							getSequence(targetMode)->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
-						!= RETURN_OK) {
-					transitionFailed(TABLE_CHECK_FAILED,
-							currentSequenceIterator->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->getWaitSeconds() != 0) {
-				if (uptimeStartTable == 0) {
-					Clock::getUptime(&uptimeStartTable);
-					return;
-				} else {
-					uint32_t uptimeNow;
-					Clock::getUptime(&uptimeNow);
-					if ((uptimeNow - uptimeStartTable)
-							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
-						return;
-					}
-				}
-			}
-			uptimeStartTable = 0;
-			//next Table, but only if there is one
-			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
-				executeTable(getCurrentTable(), targetSubmode);
-			}
-		}
-	} else {
-		if (childrenChangedHealth) {
-			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
-			childrenChangedHealth = false;
-			startTransition(mode, submode);
-		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode)
-					!= RETURN_OK) {
-				triggerEvent(CANT_KEEP_MODE, mode, submode);
-				cantKeepMode();
-			}
-		}
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
-	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
-	if (sequenceInfo->entries.islinked) {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.array->front(),
-				sequenceInfo->entries.array->back());
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
-	EntryPointer *entry = modeTables.findValue(id);
-	if (entry->islinked) {
-		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(entry->array->front(),
-				entry->array->back());
-	}
-}
-
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
-	ReturnValue_t result;
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_INFO: {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			//Ignore external control, as it has an effect only if the mode changes,
-			//which is communicated with an additional mode info event.
-			childrenChangedHealth = true;
-		}
-	}
-		break;
-	case ModeSequenceMessage::ADD_SEQUENCE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			Mode_t fallbackId;
-			size_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size,
-						SerializeIF::Endianness::BIG);
-				if (result == RETURN_OK) {
-					result = addSequence(&sequence,
-							ModeSequenceMessage::getSequenceId(message),
-							fallbackId);
-				}
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-	}
-		break;
-	case ModeSequenceMessage::ADD_TABLE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			size_t size = sizeRead;
-			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = addTable(&table,
-						ModeSequenceMessage::getSequenceId(message));
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-
-	}
-		break;
-	case ModeSequenceMessage::DELETE_SEQUENCE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::DELETE_TABLE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteTable(ModeSequenceMessage::getTableId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::LIST_SEQUENCES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
-		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
-		for (iter = modeSequences.begin(); iter != modeSequences.end();
-				++iter) {
-			sequences.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &sequences;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::LIST_TABLES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
-		FixedMap<Mode_t, EntryPointer>::Iterator iter;
-		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
-			tables.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &tables;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::READ_SEQUENCE: {
-		ReturnValue_t result;
-		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
-		SequenceInfo *sequenceInfo = NULL;
-		result = modeSequences.find(sequence, &sequenceInfo);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[3];
-		SerializeElement<Mode_t> sequenceId(sequence);
-		SerializeElement<Mode_t> fallbackSequenceId(
-				getFallbackSequence(sequence));
-
-		elements[0] = &sequenceId;
-		elements[1] = &fallbackSequenceId;
-
-		if (sequenceInfo->entries.islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					sequenceInfo->entries.firstLinkedElement, true);
-			elements[2] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					sequenceInfo->entries.array);
-
-			elements[2] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_TABLE: {
-		ReturnValue_t result;
-		Mode_t table = ModeSequenceMessage::getSequenceId(message);
-		EntryPointer *entry = NULL;
-		result = modeTables.find(table, &entry);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[2];
-		SerializeElement<Mode_t> tableId(table);
-
-		elements[0] = &tableId;
-
-		if (entry->islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					entry->firstLinkedElement, true);
-			elements[1] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					entry->array);
-			elements[1] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
-		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
-		commandQueue->reply(&reply);
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
-		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
-		commandQueue->reply(&reply);
-	}
-		break;
-	default:
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
-		commandQueue->reply(&reply);
-	}
-}
-
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
-		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Sequences added before are checked by initialize()
-	if (!preInit) {
-		result = checkSequence(
-				HybridIterator<ModeListEntry>(sequence->front(),
-						sequence->back()), fallbackSequence);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	SequenceInfo info;
-
-	info.fallbackSequence = fallbackSequence;
-
-	info.entries.islinked = inStore;
-	info.entries.array = sequence;
-
-	result = modeSequences.insert(id, info);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(sequence,
-				&(modeSequences.find(id)->entries.firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeSequences.erase(id);
-		}
-#else
-		modeSequences.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-
-	return result;
-
-}
-
-ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-		bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
-	if (!preInit) {
-		result = checkTable(
-				HybridIterator<ModeListEntry>(table->front(), table->back()));
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	EntryPointer pointer;
-
-	pointer.islinked = inStore;
-	pointer.array = table;
-
-	result = modeTables.insert(id, pointer);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(table,
-				&(modeTables.find(id)->firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeTables.erase(id);
-		}
-#else
-		modeTables.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-	return result;
-}
-
-ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
-
-	if (isFallbackSequence(id)) {
-		return IS_FALLBACK_SEQUENCE;
-	}
-
-	SequenceInfo *sequenceInfo;
-	ReturnValue_t result;
-	result = modeSequences.find(id, &sequenceInfo);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!sequenceInfo->entries.islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::deleteTable(Mode_t id) {
-
-	if (isTableUsed(id)) {
-		return TABLE_IN_USE;
-	}
-
-	EntryPointer *pointer;
-	ReturnValue_t result;
-	result = modeTables.find(id, &pointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!pointer->islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(pointer->firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::initialize() {
-	ReturnValue_t result = SubsystemBase::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
-
-	if (modeStore == NULL) {
-		return RETURN_FAILED;
-	}
-#endif
-
-	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
-			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
-		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
-	}
-
-	mode = initialMode;
-
-	return RETURN_OK;
-}
-
-MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
-	return SubsystemBase::getCommandQueue();
-}
-
-ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t *msToReachTheMode) {
-	//Need to accept all submodes to be able to inherit submodes
-//	if (submode != SUBMODE_NONE) {
-//		return INVALID_SUBMODE;
-//	}
-
-	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
-		return HasModesIF::IN_TRANSITION;
-	} else {
-		return checkSequence(mode);
-	}
-}
-
-void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, sequence, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, sequence, submode);
-	}
-	targetMode = sequence;
-	targetSubmode = submode;
-	isInTransition = true;
-	commandsOutstanding = 0;
-	currentSequenceIterator = getSequence(sequence);
-
-	currentTargetTable = getTable(currentSequenceIterator->getTableId());
-
-	++currentSequenceIterator;
-
-	if (currentSequenceIterator.value != NULL) {
-		executeTable(getCurrentTable(), targetSubmode);
-	}
-}
-
-Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); ++iter) {
-		if (iter.value->first == sequence) {
-			return iter->fallbackSequence;
-		}
-	}
-	return -1;
-}
-
-bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool Subsystem::isTableUsed(Mode_t tableId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
-			modeSequences.begin(); sequence != modeSequences.end();
-			sequence++) {
-		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
-				sequence.value->first);
-		while (sequenceIterator.value != NULL) {
-			if (sequenceIterator->getTableId() == tableId) {
-				return true;
-			}
-			++sequenceIterator;
-		}
-	}
-	return false;
-}
-
-void Subsystem::transitionFailed(ReturnValue_t failureCode,
-		uint32_t parameter) {
-	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
-	if (mode == targetMode) {
-		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
-		modeHelper.setForced(true);
-		ReturnValue_t result;
-		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
-			return;
-		}
-		mode = getFallbackSequence(mode);
-		startTransition(mode, submode);
-	} else {
-		//try to go back to the current mode
-		startTransition(mode, submode);
-	}
-}
-
-void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF **elements, uint8_t count) {
-	ReturnValue_t result;
-	size_t maxSize = 0;
-	for (uint8_t i = 0; i < count; i++) {
-		maxSize += elements[i]->getSerializedSize();
-	}
-	uint8_t *storeBuffer;
-	store_address_t address;
-	size_t size = 0;
-
-	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		replyToCommand(result, 0);
-		return;
-	}
-	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize,
-				SerializeIF::Endianness::BIG);
-	}
-	CommandMessage reply;
-	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
-	if (commandQueue->reply(&reply) != RETURN_OK) {
-		IPCStore->deleteData(address);
-	}
-}
-
-ReturnValue_t Subsystem::checkObjectConnections() {
-	ReturnValue_t result = RETURN_OK;
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		result = checkSequence(iter.value->first);
-		if (result != RETURN_OK) {
-			return result;
-		}
-
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::setInitialMode(Mode_t mode) {
-	initialMode = mode;
-}
-
-void Subsystem::cantKeepMode() {
-	ReturnValue_t result;
-	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-		return;
-	}
-
-	modeHelper.setForced(true);
-
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
-	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
-	startTransition(mode, SUBMODE_NONE);
-}
+#include "../health/HealthMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../subsystem/Subsystem.h"
+#include <string>
+
+Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
+		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
+		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
+				false), uptimeStartTable(0), currentTargetTable(), targetMode(
+				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
+				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
+		NULL)
+#ifdef USE_MODESTORE
+,modeStore(NULL)
+#endif
+{
+
+}
+
+Subsystem::~Subsystem() {
+	//Auto-generated destructor stub
+}
+
+ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
+		Mode_t fallbackSequence) {
+
+	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
+	//the fallback sequence will be checked when it is needed.
+	if (!existsModeSequence(fallbackSequence)) {
+		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
+	}
+
+	if (iter.value == NULL) {
+		return NO_TARGET_TABLE;
+	}
+
+	for (; iter.value != NULL; ++iter) {
+		if (!existsModeTable(iter->getTableId())) {
+			return TABLE_DOES_NOT_EXIST;
+		} else {
+			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
+			if (result != RETURN_OK) {
+				return result;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
+	if (!existsModeSequence(sequence)) {
+		return SEQUENCE_DOES_NOT_EXIST;
+	}
+	HybridIterator<ModeListEntry> iter = getSequence(sequence);
+	return checkSequence(iter, getFallbackSequence(sequence));
+}
+
+bool Subsystem::existsModeSequence(Mode_t id) {
+	return modeSequences.exists(id) == RETURN_OK;
+}
+
+bool Subsystem::existsModeTable(Mode_t id) {
+	return modeTables.exists(id) == RETURN_OK;
+}
+
+HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
+	return getTable(currentSequenceIterator->getTableId());
+}
+
+void Subsystem::performChildOperation() {
+	if (isInTransition) {
+		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
+			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
+					setMode(targetMode, targetSubmode);
+					isInTransition = false;
+					return;
+				} else {
+					transitionFailed(TARGET_TABLE_NOT_REACHED,
+							getSequence(targetMode)->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->checkSuccess()) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
+					transitionFailed(TABLE_CHECK_FAILED,
+							currentSequenceIterator->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->getWaitSeconds() != 0) {
+				if (uptimeStartTable == 0) {
+					Clock::getUptime(&uptimeStartTable);
+					return;
+				} else {
+					uint32_t uptimeNow;
+					Clock::getUptime(&uptimeNow);
+					if ((uptimeNow - uptimeStartTable)
+							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
+						return;
+					}
+				}
+			}
+			uptimeStartTable = 0;
+			//next Table, but only if there is one
+			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
+				executeTable(getCurrentTable(), targetSubmode);
+			}
+		}
+	} else {
+		if (childrenChangedHealth) {
+			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
+			childrenChangedHealth = false;
+			startTransition(mode, submode);
+		} else if (childrenChangedMode) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
+				triggerEvent(CANT_KEEP_MODE, mode, submode);
+				cantKeepMode();
+			}
+		}
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
+	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
+	if (sequenceInfo->entries.islinked) {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.array->front(),
+				sequenceInfo->entries.array->back());
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
+	EntryPointer *entry = modeTables.findValue(id);
+	if (entry->islinked) {
+		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(entry->array->front(),
+				entry->array->back());
+	}
+}
+
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
+	ReturnValue_t result;
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_INFO: {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			//Ignore external control, as it has an effect only if the mode changes,
+			//which is communicated with an additional mode info event.
+			childrenChangedHealth = true;
+		}
+	}
+		break;
+	case ModeSequenceMessage::ADD_SEQUENCE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			Mode_t fallbackId;
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
+				if (result == RETURN_OK) {
+					result = addSequence(&sequence,
+							ModeSequenceMessage::getSequenceId(message),
+							fallbackId);
+				}
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::ADD_TABLE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			size_t size = sizeRead;
+			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
+					&pointer, &size, SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = addTable(&table,
+						ModeSequenceMessage::getSequenceId(message));
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+
+	}
+		break;
+	case ModeSequenceMessage::DELETE_SEQUENCE:
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
+		replyToCommand(result, 0);
+		break;
+	case ModeSequenceMessage::DELETE_TABLE:
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		result = deleteTable(ModeSequenceMessage::getTableId(message));
+		replyToCommand(result, 0);
+		break;
+	case ModeSequenceMessage::LIST_SEQUENCES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
+		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
+		for (iter = modeSequences.begin(); iter != modeSequences.end();
+				++iter) {
+			sequences.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &sequences;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::LIST_TABLES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
+		FixedMap<Mode_t, EntryPointer>::Iterator iter;
+		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
+			tables.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &tables;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::READ_SEQUENCE: {
+		ReturnValue_t result;
+		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
+		SequenceInfo *sequenceInfo = NULL;
+		result = modeSequences.find(sequence, &sequenceInfo);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[3];
+		SerializeElement<Mode_t> sequenceId(sequence);
+		SerializeElement<Mode_t> fallbackSequenceId(
+				getFallbackSequence(sequence));
+
+		elements[0] = &sequenceId;
+		elements[1] = &fallbackSequenceId;
+
+		if (sequenceInfo->entries.islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					sequenceInfo->entries.firstLinkedElement, true);
+			elements[2] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					sequenceInfo->entries.array);
+
+			elements[2] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_TABLE: {
+		ReturnValue_t result;
+		Mode_t table = ModeSequenceMessage::getSequenceId(message);
+		EntryPointer *entry = NULL;
+		result = modeTables.find(table, &entry);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[2];
+		SerializeElement<Mode_t> tableId(table);
+
+		elements[0] = &tableId;
+
+		if (entry->islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					entry->firstLinkedElement, true);
+			elements[1] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					entry->array);
+			elements[1] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
+		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
+		commandQueue->reply(&reply);
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
+		uint32_t free = modeTables.maxSize() - modeTables.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
+		commandQueue->reply(&reply);
+	}
+		break;
+	default:
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		commandQueue->reply(&reply);
+	}
+}
+
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
+		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Sequences added before are checked by initialize()
+	if (!preInit) {
+		result = checkSequence(
+				HybridIterator<ModeListEntry>(sequence->front(),
+						sequence->back()), fallbackSequence);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	SequenceInfo info;
+
+	info.fallbackSequence = fallbackSequence;
+
+	info.entries.islinked = inStore;
+	info.entries.array = sequence;
+
+	result = modeSequences.insert(id, info);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(sequence,
+				&(modeSequences.find(id)->entries.firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeSequences.erase(id);
+		}
+#else
+		modeSequences.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+
+	return result;
+
+}
+
+ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+		bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Tables added before are checked by initialize()
+	if (!preInit) {
+		result = checkTable(
+				HybridIterator<ModeListEntry>(table->front(), table->back()));
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	EntryPointer pointer;
+
+	pointer.islinked = inStore;
+	pointer.array = table;
+
+	result = modeTables.insert(id, pointer);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(table,
+				&(modeTables.find(id)->firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeTables.erase(id);
+		}
+#else
+		modeTables.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+	return result;
+}
+
+ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
+
+	if (isFallbackSequence(id)) {
+		return IS_FALLBACK_SEQUENCE;
+	}
+
+	SequenceInfo *sequenceInfo;
+	ReturnValue_t result;
+	result = modeSequences.find(id, &sequenceInfo);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!sequenceInfo->entries.islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::deleteTable(Mode_t id) {
+
+	if (isTableUsed(id)) {
+		return TABLE_IN_USE;
+	}
+
+	EntryPointer *pointer;
+	ReturnValue_t result;
+	result = modeTables.find(id, &pointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!pointer->islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(pointer->firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::initialize() {
+	ReturnValue_t result = SubsystemBase::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
+
+	if (modeStore == NULL) {
+		return RETURN_FAILED;
+	}
+#endif
+
+	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
+			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
+		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
+	}
+
+	mode = initialMode;
+
+	return RETURN_OK;
+}
+
+MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
+	return SubsystemBase::getCommandQueue();
+}
+
+ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t *msToReachTheMode) {
+	//Need to accept all submodes to be able to inherit submodes
+//	if (submode != SUBMODE_NONE) {
+//		return INVALID_SUBMODE;
+//	}
+
+	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
+		return HasModesIF::IN_TRANSITION;
+	} else {
+		return checkSequence(mode);
+	}
+}
+
+void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, sequence, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, sequence, submode);
+	}
+	targetMode = sequence;
+	targetSubmode = submode;
+	isInTransition = true;
+	commandsOutstanding = 0;
+	currentSequenceIterator = getSequence(sequence);
+
+	currentTargetTable = getTable(currentSequenceIterator->getTableId());
+
+	++currentSequenceIterator;
+
+	if (currentSequenceIterator.value != NULL) {
+		executeTable(getCurrentTable(), targetSubmode);
+	}
+}
+
+Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); ++iter) {
+		if (iter.value->first == sequence) {
+			return iter->fallbackSequence;
+		}
+	}
+	return -1;
+}
+
+bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		if (iter->fallbackSequence == SequenceId) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Subsystem::isTableUsed(Mode_t tableId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
+			modeSequences.begin(); sequence != modeSequences.end();
+			sequence++) {
+		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
+				sequence.value->first);
+		while (sequenceIterator.value != NULL) {
+			if (sequenceIterator->getTableId() == tableId) {
+				return true;
+			}
+			++sequenceIterator;
+		}
+	}
+	return false;
+}
+
+void Subsystem::transitionFailed(ReturnValue_t failureCode,
+		uint32_t parameter) {
+	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
+	if (mode == targetMode) {
+		//already tried going back to the current mode
+		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		modeHelper.setForced(true);
+		ReturnValue_t result;
+		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			return;
+		}
+		mode = getFallbackSequence(mode);
+		startTransition(mode, submode);
+	} else {
+		//try to go back to the current mode
+		startTransition(mode, submode);
+	}
+}
+
+void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
+		SerializeIF **elements, uint8_t count) {
+	ReturnValue_t result;
+	size_t maxSize = 0;
+	for (uint8_t i = 0; i < count; i++) {
+		maxSize += elements[i]->getSerializedSize();
+	}
+	uint8_t *storeBuffer;
+	store_address_t address;
+	size_t size = 0;
+
+	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		replyToCommand(result, 0);
+		return;
+	}
+	for (uint8_t i = 0; i < count; i++) {
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	CommandMessage reply;
+	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
+	if (commandQueue->reply(&reply) != RETURN_OK) {
+		IPCStore->deleteData(address);
+	}
+}
+
+ReturnValue_t Subsystem::checkObjectConnections() {
+	ReturnValue_t result = RETURN_OK;
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		result = checkSequence(iter.value->first);
+		if (result != RETURN_OK) {
+			return result;
+		}
+
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::setInitialMode(Mode_t mode) {
+	initialMode = mode;
+}
+
+void Subsystem::cantKeepMode() {
+	ReturnValue_t result;
+	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+		return;
+	}
+
+	modeHelper.setForced(true);
+
+	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	mode = getFallbackSequence(mode);
+	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	startTransition(mode, SUBMODE_NONE);
+}
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index ca1020b9..b296a2e8 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,164 +1,164 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
-
-#include <framework/container/FixedArrayList.h>
-#include <framework/container/FixedMap.h>
-#include <framework/container/HybridIterator.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/serialize/SerialArrayListAdapter.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-#include <framework/subsystem/SubsystemBase.h>
-
-class Subsystem: public SubsystemBase, public HasModeSequenceIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
-	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
-			MAKE_RETURN_CODE(0x07);
-	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
-	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
-	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
-	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
-	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
-
-	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
-
-
-
-	Subsystem(object_id_t setObjectId, object_id_t parent,
-			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
-	virtual ~Subsystem();
-
-	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
-			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
-
-	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-			bool inStore = true, bool preInit = true);
-
-	void setInitialMode(Mode_t mode);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
-protected:
-
-	struct EntryPointer {
-		bool islinked;
-		union {
-			ModeListEntry *firstLinkedElement;
-			ArrayList<ModeListEntry> *array;
-		};
-	};
-
-	struct SequenceInfo {
-		Mode_t fallbackSequence;
-		EntryPointer entries;
-	};
-
-	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
-
-	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
-
-	bool isInTransition;
-
-	bool childrenChangedHealth;
-
-	uint32_t uptimeStartTable;
-
-	HybridIterator<ModeListEntry> currentTargetTable;
-
-	Mode_t targetMode;
-
-	Submode_t targetSubmode;
-
-	Mode_t initialMode;
-
-	HybridIterator<ModeListEntry> currentSequenceIterator;
-
-	FixedMap<Mode_t, EntryPointer> modeTables;
-
-	FixedMap<Mode_t, SequenceInfo> modeSequences;
-
-	StorageManagerIF *IPCStore;
-
-#ifdef USE_MODESTORE
-	ModeStoreIF *modeStore;
-#endif
-
-	bool existsModeSequence(Mode_t id);
-
-	HybridIterator<ModeListEntry> getSequence(Mode_t id);
-
-	bool existsModeTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getCurrentTable();
-
-//	void startSequence(Mode_t sequence);
-
-	/**
-	 * DO NOT USE ON NON EXISTING SEQUENCE
-	 *
-	 * @param a sequence
-	 * @return the fallback sequence's Id
-	 */
-	Mode_t getFallbackSequence(Mode_t sequence);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter);
-
-	ReturnValue_t deleteSequence(Mode_t id);
-
-	ReturnValue_t deleteTable(Mode_t id);
-
-	virtual void performChildOperation();
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	bool isFallbackSequence(Mode_t SequenceId);
-
-	bool isTableUsed(Mode_t tableId);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
-
-	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
-
-	void cantKeepMode();
-
-};
-
-#endif /* SUBSYSTEM_H_ */
+#ifndef SUBSYSTEM_H_
+#define SUBSYSTEM_H_
+
+#include "../container/FixedArrayList.h"
+#include "../container/FixedMap.h"
+#include "../container/HybridIterator.h"
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../subsystem/modes/ModeDefinitions.h"
+#include "../subsystem/SubsystemBase.h"
+
+class Subsystem: public SubsystemBase, public HasModeSequenceIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
+	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
+			MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
+	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
+	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
+	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
+	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
+
+	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
+
+
+
+	Subsystem(object_id_t setObjectId, object_id_t parent,
+			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+	virtual ~Subsystem();
+
+	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
+			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
+
+	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+			bool inStore = true, bool preInit = true);
+
+	void setInitialMode(Mode_t mode);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const;
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+protected:
+
+	struct EntryPointer {
+		bool islinked;
+		union {
+			ModeListEntry *firstLinkedElement;
+			ArrayList<ModeListEntry> *array;
+		};
+	};
+
+	struct SequenceInfo {
+		Mode_t fallbackSequence;
+		EntryPointer entries;
+	};
+
+	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
+
+	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
+
+	bool isInTransition;
+
+	bool childrenChangedHealth;
+
+	uint32_t uptimeStartTable;
+
+	HybridIterator<ModeListEntry> currentTargetTable;
+
+	Mode_t targetMode;
+
+	Submode_t targetSubmode;
+
+	Mode_t initialMode;
+
+	HybridIterator<ModeListEntry> currentSequenceIterator;
+
+	FixedMap<Mode_t, EntryPointer> modeTables;
+
+	FixedMap<Mode_t, SequenceInfo> modeSequences;
+
+	StorageManagerIF *IPCStore;
+
+#ifdef USE_MODESTORE
+	ModeStoreIF *modeStore;
+#endif
+
+	bool existsModeSequence(Mode_t id);
+
+	HybridIterator<ModeListEntry> getSequence(Mode_t id);
+
+	bool existsModeTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getCurrentTable();
+
+//	void startSequence(Mode_t sequence);
+
+	/**
+	 * DO NOT USE ON NON EXISTING SEQUENCE
+	 *
+	 * @param a sequence
+	 * @return the fallback sequence's Id
+	 */
+	Mode_t getFallbackSequence(Mode_t sequence);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter);
+
+	ReturnValue_t deleteSequence(Mode_t id);
+
+	ReturnValue_t deleteTable(Mode_t id);
+
+	virtual void performChildOperation();
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	bool isFallbackSequence(Mode_t SequenceId);
+
+	bool isTableUsed(Mode_t tableId);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+
+	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
+
+	void cantKeepMode();
+
+};
+
+#endif /* SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 71fa81b7..2bd6c1ad 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,356 +1,356 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/subsystem/SubsystemBase.h>
-#include <framework/ipc/QueueFactory.h>
-
-SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
-		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
-		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-}
-
-SubsystemBase::~SubsystemBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-
-}
-
-ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
-	ChildInfo info;
-
-	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
-	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == nullptr) {
-		if (healthChild == nullptr) {
-			return CHILD_DOESNT_HAVE_MODES;
-		} else {
-			info.commandQueue = healthChild->getCommandQueue();
-			info.mode = MODE_OFF;
-		}
-	} else {
-		info.commandQueue = child->getCommandQueue();
-		info.mode = -1;	//intentional to force an initial command during system startup
-	}
-
-	info.submode = SUBMODE_NONE;
-	info.healthChanged = false;
-
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
-		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkStateAgainstTable(
-		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	std::map<object_id_t, ChildInfo>::iterator childIter;
-
-	for (; tableIter.value != NULL; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-
-		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
-			return RETURN_FAILED;
-		}
-
-		if (childIter->second.mode != tableIter.value->getMode()) {
-			return RETURN_FAILED;
-		}
-
-		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCheckAgainst = targetSubmode;
-		}
-
-		if (childIter->second.submode != submodeToCheckAgainst) {
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
-        Submode_t targetSubmode) {
-	CommandMessage command;
-
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	commandsOutstanding = 0;
-
-	for (; tableIter.value != nullptr; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
-			//illegal table entry, should only happen due to misconfigured mode table
-			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
-					<< std::endl;
-			continue;
-		}
-
-		Submode_t submodeToCommand = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCommand = targetSubmode;
-		}
-
-		if (healthHelper.healthTable->hasHealth(object)) {
-			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&command,
-						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
-						SUBMODE_NONE);
-			} else {
-				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&command,
-							ModeMessage::CMD_MODE_COMMAND_FORCED,
-							tableIter.value->getMode(), submodeToCommand);
-				} else {
-					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&command,
-								ModeMessage::CMD_MODE_COMMAND,
-								tableIter.value->getMode(), submodeToCommand);
-					} else {
-						continue;
-					}
-				}
-			}
-		} else {
-			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
-					tableIter.value->getMode(), submodeToCommand);
-		}
-
-		if ((iter->second.mode == ModeMessage::getMode(&command))
-				&& (iter->second.submode == ModeMessage::getSubmode(&command))
-				&& !modeHelper.isForced()) {
-			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
-		}
-		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &command);
-		if (result == RETURN_OK) {
-			++commandsOutstanding;
-		}
-	}
-
-}
-
-ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
-		Mode_t mode, Submode_t submode) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.mode = mode;
-			iter->second.submode = submode;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
-bool changedHealth) {
-	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.healthChanged = changedHealth;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-MessageQueueId_t SubsystemBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
-	ReturnValue_t result = SystemObject::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
-
-	childrenChangedMode = false;
-
-	checkCommandQueue();
-
-	performChildOperation();
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case ModeMessage::REPLY_MODE_INFO:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		return RETURN_OK;
-	case ModeMessage::REPLY_MODE_REPLY:
-	case ModeMessage::REPLY_WRONG_MODE_REPLY:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		commandsOutstanding--;
-		return RETURN_OK;
-	case ModeMessage::REPLY_CANT_REACH_MODE:
-		commandsOutstanding--;
-		{
-			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
-					iter++) {
-				if (iter->second.commandQueue == message->getSender()) {
-					triggerEvent(MODE_CMD_REJECTED, iter->first,
-							message->getParameter());
-				}
-			}
-		}
-		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_COMMAND:
-//		handleCommandedMode(message);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		commandAllChildren(message);
-//		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkTable(
-		HybridIterator<ModeListEntry> tableIter) {
-	for (; tableIter.value != NULL; ++tableIter) {
-		if (childrenMap.find(tableIter.value->getObject())
-				== childrenMap.end()) {
-			return TABLE_CONTAINS_INVALID_OBJECT_ID;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::replyToCommand(CommandMessage* message) {
-	commandQueue->reply(message);
-}
-
-void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
-	modeHelper.modeChanged(newMode, newSubmode);
-	mode = newMode;
-	submode = newSubmode;
-	modeChanged();
-	announceMode(false);
-}
-
-void SubsystemBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void SubsystemBase::commandAllChildren(CommandMessage* message) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
-		commandQueue->sendMessage(iter->second.commandQueue, message);
-	}
-}
-
-void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void SubsystemBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void SubsystemBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-	if (recursive) {
-		CommandMessage command;
-		ModeMessage::setModeMessage(&command,
-				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
-		commandAllChildren(&command);
-	}
-}
-
-void SubsystemBase::checkCommandQueue() {
-	ReturnValue_t result;
-	CommandMessage command;
-
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleModeReply(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleCommandMessage(&command);
-		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
-					command.getCommand());
-			replyToCommand(&reply);
-		}
-	}
-}
-
-ReturnValue_t SubsystemBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState SubsystemBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-void SubsystemBase::modeChanged() {
-}
-
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+
+SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
+		Mode_t initialMode, uint16_t commandQueueDepth) :
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
+}
+
+SubsystemBase::~SubsystemBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+
+}
+
+ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
+	ChildInfo info;
+
+	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
+	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
+			return CHILD_DOESNT_HAVE_MODES;
+		} else {
+			info.commandQueue = healthChild->getCommandQueue();
+			info.mode = MODE_OFF;
+		}
+	} else {
+		info.commandQueue = child->getCommandQueue();
+		info.mode = -1;	//intentional to force an initial command during system startup
+	}
+
+	info.submode = SUBMODE_NONE;
+	info.healthChanged = false;
+
+	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
+			childrenMap.insert(
+					std::pair<object_id_t, ChildInfo>(objectId, info));
+	if (!(returnValue.second)) {
+		return COULD_NOT_INSERT_CHILD;
+	} else {
+		return RETURN_OK;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkStateAgainstTable(
+		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+
+	std::map<object_id_t, ChildInfo>::iterator childIter;
+
+	for (; tableIter.value != NULL; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+
+		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
+			return RETURN_FAILED;
+		}
+
+		if (childIter->second.mode != tableIter.value->getMode()) {
+			return RETURN_FAILED;
+		}
+
+		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCheckAgainst = targetSubmode;
+		}
+
+		if (childIter->second.submode != submodeToCheckAgainst) {
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
+	CommandMessage command;
+
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	commandsOutstanding = 0;
+
+	for (; tableIter.value != nullptr; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
+			//illegal table entry, should only happen due to misconfigured mode table
+			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
+					<< std::endl;
+			continue;
+		}
+
+		Submode_t submodeToCommand = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCommand = targetSubmode;
+		}
+
+		if (healthHelper.healthTable->hasHealth(object)) {
+			if (healthHelper.healthTable->isFaulty(object)) {
+				ModeMessage::setModeMessage(&command,
+						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
+						SUBMODE_NONE);
+			} else {
+				if (modeHelper.isForced()) {
+					ModeMessage::setModeMessage(&command,
+							ModeMessage::CMD_MODE_COMMAND_FORCED,
+							tableIter.value->getMode(), submodeToCommand);
+				} else {
+					if (healthHelper.healthTable->isCommandable(object)) {
+						ModeMessage::setModeMessage(&command,
+								ModeMessage::CMD_MODE_COMMAND,
+								tableIter.value->getMode(), submodeToCommand);
+					} else {
+						continue;
+					}
+				}
+			}
+		} else {
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
+					tableIter.value->getMode(), submodeToCommand);
+		}
+
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
+				&& !modeHelper.isForced()) {
+			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
+		}
+		ReturnValue_t result = commandQueue->sendMessage(
+				iter->second.commandQueue, &command);
+		if (result == RETURN_OK) {
+			++commandsOutstanding;
+		}
+	}
+
+}
+
+ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
+		Mode_t mode, Submode_t submode) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.mode = mode;
+			iter->second.submode = submode;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
+bool changedHealth) {
+	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.healthChanged = changedHealth;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+MessageQueueId_t SubsystemBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t SubsystemBase::initialize() {
+	MessageQueueId_t parentQueue = 0;
+	ReturnValue_t result = SystemObject::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (parentId != 0) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
+
+	childrenChangedMode = false;
+
+	checkCommandQueue();
+
+	performChildOperation();
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case ModeMessage::REPLY_MODE_INFO:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		return RETURN_OK;
+	case ModeMessage::REPLY_MODE_REPLY:
+	case ModeMessage::REPLY_WRONG_MODE_REPLY:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		commandsOutstanding--;
+		return RETURN_OK;
+	case ModeMessage::REPLY_CANT_REACH_MODE:
+		commandsOutstanding--;
+		{
+			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
+					iter++) {
+				if (iter->second.commandQueue == message->getSender()) {
+					triggerEvent(MODE_CMD_REJECTED, iter->first,
+							message->getParameter());
+				}
+			}
+		}
+		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_COMMAND:
+//		handleCommandedMode(message);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		commandAllChildren(message);
+//		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkTable(
+		HybridIterator<ModeListEntry> tableIter) {
+	for (; tableIter.value != NULL; ++tableIter) {
+		if (childrenMap.find(tableIter.value->getObject())
+				== childrenMap.end()) {
+			return TABLE_CONTAINS_INVALID_OBJECT_ID;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::replyToCommand(CommandMessage* message) {
+	commandQueue->reply(message);
+}
+
+void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
+	modeHelper.modeChanged(newMode, newSubmode);
+	mode = newMode;
+	submode = newSubmode;
+	modeChanged();
+	announceMode(false);
+}
+
+void SubsystemBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void SubsystemBase::commandAllChildren(CommandMessage* message) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
+		commandQueue->sendMessage(iter->second.commandQueue, message);
+	}
+}
+
+void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void SubsystemBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void SubsystemBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+	if (recursive) {
+		CommandMessage command;
+		ModeMessage::setModeMessage(&command,
+				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
+		commandAllChildren(&command);
+	}
+}
+
+void SubsystemBase::checkCommandQueue() {
+	ReturnValue_t result;
+	CommandMessage command;
+
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleModeReply(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleCommandMessage(&command);
+		if (result != RETURN_OK) {
+			CommandMessage reply;
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
+			replyToCommand(&reply);
+		}
+	}
+}
+
+ReturnValue_t SubsystemBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState SubsystemBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+void SubsystemBase::modeChanged() {
+}
+
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 1a050a9a..c0abbe40 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,129 +1,129 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
-
-#include <framework/container/HybridIterator.h>
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/subsystem/modes/HasModeSequenceIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <map>
-
-/**
- * @defgroup subsystems Subsystem Objects
- * Contains all Subsystem and Assemblies
- */
-class SubsystemBase: public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
-	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x05);
-
-	SubsystemBase(object_id_t setObjectId, object_id_t parent,
-			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
-	virtual ~SubsystemBase();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t registerChild(object_id_t objectId);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-protected:
-	struct ChildInfo {
-		MessageQueueId_t commandQueue;
-		Mode_t mode;
-		Submode_t submode;bool healthChanged;
-	};
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	bool childrenChangedMode;
-
-	/**
-	 * Always check this against <=0, so you are robust against too many replies
-	 */
-	int32_t commandsOutstanding;
-
-	MessageQueueIF* commandQueue;
-
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	const object_id_t parentId;
-
-	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
-	ChildrenMap childrenMap;
-
-	void checkCommandQueue();
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 */
-	ReturnValue_t checkStateAgainstTable(
-			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 * Still, we have a default for all child implementations which do not use submode inheritance
-	 */
-	void executeTable(HybridIterator<ModeListEntry> tableIter,
-			Submode_t targetSubmode = SUBMODE_NONE);
-
-	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
-			Submode_t submode);
-
-	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
-			bool changedHealth = true);
-
-	virtual ReturnValue_t handleModeReply(CommandMessage *message);
-
-	void commandAllChildren(CommandMessage *message);
-
-	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
-
-	void replyToCommand(CommandMessage *message);
-
-	void setMode(Mode_t newMode, Submode_t newSubmode);
-
-	void setMode(Mode_t newMode);
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-	virtual void performChildOperation() = 0;
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-
-	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
-
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-
-	virtual void setToExternalControl();
-
-	virtual void announceMode(bool recursive);
-
-	virtual void modeChanged();
-};
-
-#endif /* SUBSYSTEMBASE_H_ */
+#ifndef SUBSYSTEMBASE_H_
+#define SUBSYSTEMBASE_H_
+
+#include "../container/HybridIterator.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../subsystem/modes/HasModeSequenceIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
+class SubsystemBase: public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
+	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x05);
+
+	SubsystemBase(object_id_t setObjectId, object_id_t parent,
+			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
+	virtual ~SubsystemBase();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t registerChild(object_id_t objectId);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HasHealthIF::HealthState getHealth();
+
+protected:
+	struct ChildInfo {
+		MessageQueueId_t commandQueue;
+		Mode_t mode;
+		Submode_t submode;bool healthChanged;
+	};
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	bool childrenChangedMode;
+
+	/**
+	 * Always check this against <=0, so you are robust against too many replies
+	 */
+	int32_t commandsOutstanding;
+
+	MessageQueueIF* commandQueue;
+
+	HealthHelper healthHelper;
+
+	ModeHelper modeHelper;
+
+	const object_id_t parentId;
+
+	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
+	ChildrenMap childrenMap;
+
+	void checkCommandQueue();
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 */
+	ReturnValue_t checkStateAgainstTable(
+			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 * Still, we have a default for all child implementations which do not use submode inheritance
+	 */
+	void executeTable(HybridIterator<ModeListEntry> tableIter,
+			Submode_t targetSubmode = SUBMODE_NONE);
+
+	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
+			Submode_t submode);
+
+	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
+			bool changedHealth = true);
+
+	virtual ReturnValue_t handleModeReply(CommandMessage *message);
+
+	void commandAllChildren(CommandMessage *message);
+
+	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
+
+	void replyToCommand(CommandMessage *message);
+
+	void setMode(Mode_t newMode, Submode_t newSubmode);
+
+	void setMode(Mode_t newMode);
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+	virtual void performChildOperation() = 0;
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) = 0;
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
+
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+
+	virtual void setToExternalControl();
+
+	virtual void announceMode(bool recursive);
+
+	virtual void modeChanged();
+};
+
+#endif /* SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index e03de410..90007d80 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,20 +1,20 @@
-#ifndef HASMODESEQUENCEIF_H_
-#define HASMODESEQUENCEIF_H_
-
-#include <framework/subsystem/modes/ModeDefinitions.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-#include <framework/subsystem/modes/ModeStoreIF.h>
-
-
-class HasModeSequenceIF {
-public:
-	virtual ~HasModeSequenceIF() {
-
-	}
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
-
-};
-
-
-#endif /* HASMODESEQUENCEIF_H_ */
+#ifndef HASMODESEQUENCEIF_H_
+#define HASMODESEQUENCEIF_H_
+
+#include "../../subsystem/modes/ModeDefinitions.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+
+class HasModeSequenceIF {
+public:
+	virtual ~HasModeSequenceIF() {
+
+	}
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
+
+};
+
+
+#endif /* HASMODESEQUENCEIF_H_ */
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 153710af..0514b357 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,152 +1,152 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
-
-#include <framework/modes/HasModesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerializeIF.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
-public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
-
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-
-		ReturnValue_t result;
-
-		result = SerializeAdapter::serialize(&value1, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value2, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value3, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&value4, buffer, size,
-				maxSize, streamEndianness);
-
-		return result;
-
-	}
-
-	virtual size_t getSerializedSize() const {
-		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	Endianness streamEndianness) {
-		ReturnValue_t result;
-
-		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				streamEndianness);
-
-		return result;
-	}
-
-	//for Sequences
-	Mode_t getTableId() const {
-		return value1;
-	}
-
-	void setTableId(Mode_t tableId) {
-		this->value1 = tableId;
-	}
-
-	uint8_t getWaitSeconds() const {
-		return value2;
-	}
-
-	void setWaitSeconds(uint8_t waitSeconds) {
-		this->value2 = waitSeconds;
-	}
-
-	bool checkSuccess() const {
-		return value3 == 1;
-	}
-
-	void setCheckSuccess(bool checkSuccess) {
-		this->value3 = checkSuccess;
-	}
-
-	//for Tables
-	object_id_t getObject() const {
-		return value1;
-	}
-
-	void setObject(object_id_t object) {
-		this->value1 = object;
-	}
-
-	Mode_t getMode() const {
-		return value2;
-	}
-
-	void setMode(Mode_t mode) {
-		this->value2 = mode;
-	}
-
-	Submode_t getSubmode() const {
-		return value3;
-	}
-
-	void setSubmode(Submode_t submode) {
-		this->value3 = submode;
-	}
-
-	bool inheritSubmode() const {
-		return value4 == 1;
-	}
-
-	void setInheritSubmode(bool inherit){
-		if (inherit){
-			value4 = 1;
-		} else {
-			value4 = 0;
-		}
-	}
-
-	bool operator==(ModeListEntry other) {
-		return ((value1 == other.value1) && (value2 == other.value2)
-				&& (value3 == other.value3));
-	}
-};
-
-#endif //MODEDEFINITIONS_H_
+#ifndef MODEDEFINITIONS_H_
+#define MODEDEFINITIONS_H_
+
+#include "../../modes/HasModesIF.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
+public:
+	ModeListEntry() :
+			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
+					0) {
+
+	}
+
+	uint32_t value1;
+	uint32_t value2;
+	uint8_t value3;
+	uint8_t value4;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+
+		ReturnValue_t result;
+
+		result = SerializeAdapter::serialize(&value1, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value2, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value3, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&value4, buffer, size,
+				maxSize, streamEndianness);
+
+		return result;
+
+	}
+
+	virtual size_t getSerializedSize() const {
+		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
+		ReturnValue_t result;
+
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
+				streamEndianness);
+
+		return result;
+	}
+
+	//for Sequences
+	Mode_t getTableId() const {
+		return value1;
+	}
+
+	void setTableId(Mode_t tableId) {
+		this->value1 = tableId;
+	}
+
+	uint8_t getWaitSeconds() const {
+		return value2;
+	}
+
+	void setWaitSeconds(uint8_t waitSeconds) {
+		this->value2 = waitSeconds;
+	}
+
+	bool checkSuccess() const {
+		return value3 == 1;
+	}
+
+	void setCheckSuccess(bool checkSuccess) {
+		this->value3 = checkSuccess;
+	}
+
+	//for Tables
+	object_id_t getObject() const {
+		return value1;
+	}
+
+	void setObject(object_id_t object) {
+		this->value1 = object;
+	}
+
+	Mode_t getMode() const {
+		return value2;
+	}
+
+	void setMode(Mode_t mode) {
+		this->value2 = mode;
+	}
+
+	Submode_t getSubmode() const {
+		return value3;
+	}
+
+	void setSubmode(Submode_t submode) {
+		this->value3 = submode;
+	}
+
+	bool inheritSubmode() const {
+		return value4 == 1;
+	}
+
+	void setInheritSubmode(bool inherit){
+		if (inherit){
+			value4 = 1;
+		} else {
+			value4 = 0;
+		}
+	}
+
+	bool operator==(ModeListEntry other) {
+		return ((value1 == other.value1) && (value2 == other.value2)
+				&& (value3 == other.value3));
+	}
+};
+
+#endif //MODEDEFINITIONS_H_
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index 31661739..3eb4ebe8 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,89 +1,89 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/modes/ModeSequenceMessage.h>
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence) {
-	message->setCommand(command);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-}
-
-store_address_t ModeSequenceMessage::getStoreAddress(
-		const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter();
-	return address;
-}
-
-Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-
-uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-void ModeSequenceMessage::clear(CommandMessage *message) {
-	switch (message->getCommand()) {
-	case ADD_SEQUENCE:
-	case ADD_TABLE:
-	case SEQUENCE_LIST:
-	case TABLE_LIST:
-	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
-			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_SEQUENCE:
-	case DELETE_TABLE:
-	case READ_SEQUENCE:
-	case READ_TABLE:
-	case LIST_SEQUENCES:
-	case LIST_TABLES:
-	case READ_FREE_SEQUENCE_SLOTS:
-	case FREE_SEQUENCE_SLOTS:
-	case READ_FREE_TABLE_SLOTS:
-	case FREE_TABLE_SLOTS:
-	default:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
+//	message->setCommand(command);
+//	message->setParameter(storeAddress.raw);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence) {
+	message->setCommand(command);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table) {
+//	message->setCommand(command);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+}
+
+store_address_t ModeSequenceMessage::getStoreAddress(
+		const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter();
+	return address;
+}
+
+Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+
+uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+void ModeSequenceMessage::clear(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case ADD_SEQUENCE:
+	case ADD_TABLE:
+	case SEQUENCE_LIST:
+	case TABLE_LIST:
+	case TABLE:
+	case SEQUENCE:{
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL){
+			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_SEQUENCE:
+	case DELETE_TABLE:
+	case READ_SEQUENCE:
+	case READ_TABLE:
+	case LIST_SEQUENCES:
+	case LIST_TABLES:
+	case READ_FREE_SEQUENCE_SLOTS:
+	case FREE_SEQUENCE_SLOTS:
+	case READ_FREE_TABLE_SLOTS:
+	case FREE_TABLE_SLOTS:
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 61d1b628..fcb5b2e7 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,48 +1,48 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-
-class ModeSequenceMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
-
-	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
-	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
-	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
-	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
-	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
-	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
-	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
-	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
-	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
-	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
-	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
-	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
-	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
-	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
-	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
-	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
-
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable,
-			store_address_t storeAddress);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, store_address_t storeAddress);
-
-	static store_address_t getStoreAddress(const CommandMessage *message);
-	static Mode_t getSequenceId(const CommandMessage *message);
-	static Mode_t getTableId(const CommandMessage *message);
-	static uint32_t getNumber(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	ModeSequenceMessage();
-};
-
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#ifndef MODESEQUENCEMESSAGE_H_
+#define MODESEQUENCEMESSAGE_H_
+
+#include "../../ipc/CommandMessage.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeSequenceMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
+
+	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
+	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
+	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
+	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
+	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
+	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
+	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
+	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
+	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
+	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
+	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
+	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
+	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
+	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
+	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
+	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
+
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable,
+			store_address_t storeAddress);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, store_address_t storeAddress);
+
+	static store_address_t getStoreAddress(const CommandMessage *message);
+	static Mode_t getSequenceId(const CommandMessage *message);
+	static Mode_t getTableId(const CommandMessage *message);
+	static uint32_t getNumber(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	ModeSequenceMessage();
+};
+
+#endif /* MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 2aa02087..409a5f0f 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,126 +1,126 @@
-#include <framework/subsystem/modes/ModeStore.h>
-
-#ifdef USE_MODESTORE
-
-ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
-		SystemObject(objectId), store(slots), emptySlot(store.front()) {
-	mutex = MutexFactory::instance()->createMutex();;
-	OSAL::createMutex(objectId + 1, mutex);
-	clear();
-}
-
-ModeStore::~ModeStore() {
-	delete mutex;
-}
-
-uint32_t ModeStore::getFreeSlots() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	uint32_t count = 0;
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		if (iter->getNext() == emptySlot) {
-			++count;
-		}
-	}
-	OSAL::unlockMutex(mutex);
-	return count;
-}
-
-ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
-		ModeListEntry** storedFirstEntry) {
-	if (sequence->size == 0) {
-		return CANT_STORE_EMPTY;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	*storedFirstEntry = findEmptySlotNoLock(store.front());
-
-	ModeListEntry* pointer =
-			*storedFirstEntry;
-	pointer->setNext(pointer);
-
-	ArrayList<ModeListEntry>::Iterator iter;
-	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
-		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
-		pointer = pointer->getNext()->value;
-		if (pointer == NULL) {
-			deleteListNoLock(*storedFirstEntry);
-			OSAL::unlockMutex(mutex);
-			return TOO_MANY_ELEMENTS;
-		}
-		pointer->value->value1 = iter->value1;
-		pointer->value->value2 = iter->value2;
-		pointer->value->value3 = iter->value3;
-		pointer->setNext(findEmptySlotNoLock(pointer + 1));
-	}
-	pointer->setNext(NULL);
-	OSAL::unlockMutex(mutex);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
-	ReturnValue_t result = isValidEntry(sequence);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-		deleteListNoLock(sequence);
-		OSAL::unlockMutex(mutex);
-		return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
-		ArrayList<ModeListEntry>* into) {
-	ReturnValue_t result = isValidEntry(sequence);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	result = into->insert(*sequence->value);
-	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
-		result = into->insert(*sequence->value);
-		sequence = sequence->getNext()->value;
-	}
-	OSAL::unlockMutex(mutex);
-	return result;
-}
-
-void ModeStore::clear() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	store.size = store.maxSize();
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		iter->setNext(emptySlot);
-	}
-	OSAL::unlockMutex(mutex);
-}
-
-ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
-			startFrom);
-	for (; iter != store.end(); ++iter) {
-		if (iter.value->getNext() == emptySlot) {
-			OSAL::unlockMutex(mutex);
-			return iter.value;
-		}
-	}
-	return NULL;
-}
-
-void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
-	ModeListEntry* next = sequence;
-	while (next != NULL) {
-		next = sequence->getNext()->value;
-		sequence->setNext(emptySlot);
-		sequence = next;
-	}
-}
-
-ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
-	if ((sequence < store.front()) || (sequence > store.back())
-			|| sequence->getNext() == emptySlot) {
-		return INVALID_ENTRY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
+#include "../../subsystem/modes/ModeStore.h"
+
+#ifdef USE_MODESTORE
+
+ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
+		SystemObject(objectId), store(slots), emptySlot(store.front()) {
+	mutex = MutexFactory::instance()->createMutex();;
+	OSAL::createMutex(objectId + 1, mutex);
+	clear();
+}
+
+ModeStore::~ModeStore() {
+	delete mutex;
+}
+
+uint32_t ModeStore::getFreeSlots() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	uint32_t count = 0;
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		if (iter->getNext() == emptySlot) {
+			++count;
+		}
+	}
+	OSAL::unlockMutex(mutex);
+	return count;
+}
+
+ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
+		ModeListEntry** storedFirstEntry) {
+	if (sequence->size == 0) {
+		return CANT_STORE_EMPTY;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	*storedFirstEntry = findEmptySlotNoLock(store.front());
+
+	ModeListEntry* pointer =
+			*storedFirstEntry;
+	pointer->setNext(pointer);
+
+	ArrayList<ModeListEntry>::Iterator iter;
+	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
+		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
+		pointer = pointer->getNext()->value;
+		if (pointer == NULL) {
+			deleteListNoLock(*storedFirstEntry);
+			OSAL::unlockMutex(mutex);
+			return TOO_MANY_ELEMENTS;
+		}
+		pointer->value->value1 = iter->value1;
+		pointer->value->value2 = iter->value2;
+		pointer->value->value3 = iter->value3;
+		pointer->setNext(findEmptySlotNoLock(pointer + 1));
+	}
+	pointer->setNext(NULL);
+	OSAL::unlockMutex(mutex);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
+	ReturnValue_t result = isValidEntry(sequence);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+		deleteListNoLock(sequence);
+		OSAL::unlockMutex(mutex);
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
+		ArrayList<ModeListEntry>* into) {
+	ReturnValue_t result = isValidEntry(sequence);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	result = into->insert(*sequence->value);
+	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
+		result = into->insert(*sequence->value);
+		sequence = sequence->getNext()->value;
+	}
+	OSAL::unlockMutex(mutex);
+	return result;
+}
+
+void ModeStore::clear() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	store.size = store.maxSize();
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		iter->setNext(emptySlot);
+	}
+	OSAL::unlockMutex(mutex);
+}
+
+ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
+			startFrom);
+	for (; iter != store.end(); ++iter) {
+		if (iter.value->getNext() == emptySlot) {
+			OSAL::unlockMutex(mutex);
+			return iter.value;
+		}
+	}
+	return NULL;
+}
+
+void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
+	ModeListEntry* next = sequence;
+	while (next != NULL) {
+		next = sequence->getNext()->value;
+		sequence->setNext(emptySlot);
+		sequence = next;
+	}
+}
+
+ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
+	if ((sequence < store.front()) || (sequence > store.back())
+			|| sequence->getNext() == emptySlot) {
+		return INVALID_ENTRY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index cbc45b5a..cb340443 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,45 +1,45 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
-
-#ifdef USE_MODESTORE
-
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/subsystem/modes/ModeStoreIF.h>
-
-class ModeStore: public ModeStoreIF, public SystemObject {
-public:
-	ModeStore(object_id_t objectId, uint32_t slots);
-	virtual ~ModeStore();
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry);
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence);
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into);
-
-	virtual uint32_t getFreeSlots();
-
-private:
-	MutexId_t* mutex;
-	ArrayList<ModeListEntry, uint32_t> store;
-	ModeListEntry *emptySlot;
-
-	void clear();
-	ModeListEntry* findEmptySlotNoLock(
-			ModeListEntry* startFrom);
-	void deleteListNoLock(
-			ModeListEntry *sequence);
-
-	ReturnValue_t isValidEntry(ModeListEntry *sequence);
-};
-
-#endif
-
-#endif /* MODESTORE_H_ */
-
+#ifndef MODESTORE_H_
+#define MODESTORE_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+class ModeStore: public ModeStoreIF, public SystemObject {
+public:
+	ModeStore(object_id_t objectId, uint32_t slots);
+	virtual ~ModeStore();
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry);
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence);
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into);
+
+	virtual uint32_t getFreeSlots();
+
+private:
+	MutexId_t* mutex;
+	ArrayList<ModeListEntry, uint32_t> store;
+	ModeListEntry *emptySlot;
+
+	void clear();
+	ModeListEntry* findEmptySlotNoLock(
+			ModeListEntry* startFrom);
+	void deleteListNoLock(
+			ModeListEntry *sequence);
+
+	ReturnValue_t isValidEntry(ModeListEntry *sequence);
+};
+
+#endif
+
+#endif /* MODESTORE_H_ */
+
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 7be7a5a7..b9f2df70 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,37 +1,37 @@
-#ifndef MODESTOREIF_H_
-#define MODESTOREIF_H_
-
-#ifdef USE_MODESTORE
-
-#include <framework/container/ArrayList.h>
-#include <framework/container/SinglyLinkedList.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/subsystem/modes/ModeDefinitions.h>
-
-class ModeStoreIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
-	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
-
-	virtual ~ModeStoreIF() {
-
-	}
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry) = 0;
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence) = 0;
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into) = 0;
-
-	virtual uint32_t getFreeSlots() = 0;
-};
-
-#endif
-
-#endif /* MODESTOREIF_H_ */
+#ifndef MODESTOREIF_H_
+#define MODESTOREIF_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeStoreIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
+	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
+
+	virtual ~ModeStoreIF() {
+
+	}
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry) = 0;
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence) = 0;
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into) = 0;
+
+	virtual uint32_t getFreeSlots() = 0;
+};
+
+#endif
+
+#endif /* MODESTOREIF_H_ */
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index d716cdfb..902b2e3c 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,53 +1,53 @@
-#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-
-class PeriodicTaskIF;
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-#include <cstring>
-/**
- * @brief	The interface provides a method to execute objects within a task.
- * @details	The performOperation method, that is required by the interface is
- * 			executed cyclically within a task context.
- * @author  Bastian Baetz
- */
-class ExecutableObjectIF {
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~ExecutableObjectIF() { }
-	/**
-	 * @brief	The performOperation method is executed in a task.
-	 * @details	There are no restrictions for calls within this method, so any
-	 * 			other member of the class can be used.
-	 * @return	Currently, the return value is ignored.
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
-
-	/**
-	 * @brief Function called during setup assignment of object to task
-	 * @details
-	 * Has to be called from the function that assigns the object to a task and
-	 * enables the object implementation to overwrite this function and get
-	 * a reference to the executing task
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {};
-
-	/**
-	 * This function should be called after the object was assigned to a
-	 * specific task.
-	 *
-	 * Example: Can be used to get task execution frequency.
-	 * The task is created after initialize() and the object ctors have been
-	 * called so the execution frequency can't be cached in initialize()
-	 * @return
-	 */
-	virtual ReturnValue_t initializeAfterTaskCreation() {
-	    return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+
+class PeriodicTaskIF;
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstring>
+/**
+ * @brief	The interface provides a method to execute objects within a task.
+ * @details	The performOperation method, that is required by the interface is
+ * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
+ */
+class ExecutableObjectIF {
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~ExecutableObjectIF() { }
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
+
+	/**
+	 * @brief Function called during setup assignment of object to task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
+
+	/**
+	 * This function should be called after the object was assigned to a
+	 * specific task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 4331aada..cccc6371 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,16 +1,16 @@
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/tasks/FixedSequenceSlot.h>
-#include <cstddef>
-
-FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
-		pollingTimeMs(setTime), opcode(setSequenceId) {
-	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	if(executingTask != nullptr) {
-	    handler->setTaskIF(executingTask);
-	}
-	handler->initializeAfterTaskCreation();
-}
-
-FixedSequenceSlot::~FixedSequenceSlot() {}
-
+#include "../objectmanager/SystemObjectIF.h"
+#include "../tasks/FixedSequenceSlot.h"
+#include <cstddef>
+
+FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
+		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
+		pollingTimeMs(setTime), opcode(setSequenceId) {
+	handler = objectManager->get<ExecutableObjectIF>(handlerId);
+	if(executingTask != nullptr) {
+	    handler->setTaskIF(executingTask);
+	}
+	handler->initializeAfterTaskCreation();
+}
+
+FixedSequenceSlot::~FixedSequenceSlot() {}
+
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 72a35c74..e33134de 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,55 +1,55 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-class PeriodicTaskIF;
-
-/**
- * @brief	This class is the representation of a single polling sequence
- *          table entry.
- * @details
- * The PollingSlot class is the representation of a single polling
- * sequence table entry.
- * @author  baetz
- */
-class FixedSequenceSlot {
-public:
-	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, PeriodicTaskIF* executingTask );
-	virtual ~FixedSequenceSlot();
-
-	/**
-	 * @brief	Handler identifies which device handler object is executed in this slot.
-	 */
-	ExecutableObjectIF*	handler = nullptr;
-
-	/**
-	 * @brief	This attribute defines when a device handler object is executed.
-	 *
-	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
-	 * 			It must be smaller than the period length of the polling sequence.
-	 */
-	uint32_t	pollingTimeMs;
-
-	/**
-	 * @brief	This value defines the type of device communication.
-	 *
-	 * @details	The state of this value decides what communication routine is
-	 * 			called in the PST executable or the device handler object.
-	 */
-	uint8_t	opcode;
-
-	/**
-	 * @brief 	Operator overload for the comparison operator to
-	 * 			allow sorting by polling time.
-	 * @param fixedSequenceSlot
-	 * @return
-	 */
-	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
-		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
-	}
-};
-
-
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+class PeriodicTaskIF;
+
+/**
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
+ */
+class FixedSequenceSlot {
+public:
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, PeriodicTaskIF* executingTask );
+	virtual ~FixedSequenceSlot();
+
+	/**
+	 * @brief	Handler identifies which device handler object is executed in this slot.
+	 */
+	ExecutableObjectIF*	handler = nullptr;
+
+	/**
+	 * @brief	This attribute defines when a device handler object is executed.
+	 *
+	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
+	 * 			It must be smaller than the period length of the polling sequence.
+	 */
+	uint32_t	pollingTimeMs;
+
+	/**
+	 * @brief	This value defines the type of device communication.
+	 *
+	 * @details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
+	 */
+	uint8_t	opcode;
+
+	/**
+	 * @brief 	Operator overload for the comparison operator to
+	 * 			allow sorting by polling time.
+	 * @param fixedSequenceSlot
+	 * @return
+	 */
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
+};
+
+
+#endif /* FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 3e542bfc..27dfff2b 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,124 +1,124 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/FixedSlotSequence.h>
-#include <cstdlib>
-
-FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
-	current = slotList.begin();
-}
-
-FixedSlotSequence::~FixedSlotSequence() {
-	// Call the destructor on each list entry.
-	slotList.clear();
-}
-
-void FixedSlotSequence::executeAndAdvance() {
-	current->handler->performOperation(current->opcode);
-//	if (returnValue != RETURN_OK) {
-//		this->sendErrorMessage( returnValue );
-//	}
-	//Increment the polling Sequence iterator
-	this->current++;
-	//Set it to the beginning, if the list's end is reached.
-	if (this->current == this->slotList.end()) {
-		this->current = this->slotList.begin();
-	}
-}
-
-uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
-	uint32_t oldTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	oldTime = slotListIter->pollingTimeMs;
-	// Advance to the next object.
-	slotListIter++;
-	// Find the next interval which is not 0.
-	while (slotListIter != slotList.end()) {
-		if (oldTime != slotListIter->pollingTimeMs) {
-			return slotListIter->pollingTimeMs - oldTime;
-		} else {
-			slotListIter++;
-		}
-	}
-	// If the list end is reached (this is definitely an interval != 0),
-	// the interval is calculated by subtracting the remaining time of the PST
-	// and adding the start time of the first handler in the list.
-	slotListIter = slotList.begin();
-	return lengthMs - oldTime + slotListIter->pollingTimeMs;
-}
-
-uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
-	uint32_t currentTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	currentTime = slotListIter->pollingTimeMs;
-
-	//if it is the first slot, calculate difference to last slot
-	if (slotListIter == slotList.begin()){
-		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
-	}
-	// get previous slot
-	slotListIter--;
-
-	return currentTime - slotListIter->pollingTimeMs;
-}
-
-bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = current->pollingTimeMs;
-	SlotListIter fixedSequenceIter = this->current;
-	// Get the pollingTimeMs of the current slot object.
-	if (fixedSequenceIter == slotList.begin())
-		return false;
-	fixedSequenceIter--;
-	if (fixedSequenceIter->pollingTimeMs == currentTime) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
-}
-
-ReturnValue_t FixedSlotSequence::checkSequence() const {
-	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	auto slotIt = slotList.begin();
-	uint32_t count = 0;
-	uint32_t time = 0;
-	while (slotIt != slotList.end()) {
-		if (slotIt->handler == nullptr) {
-			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
-					<< std::endl;
-			count++;
-		} else if (slotIt->pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slotIt->pollingTimeMs
-					<< " is smaller than previous with " << time << std::endl;
-			count++;
-		} else {
-			// All ok, print slot.
-			//info << "Current slot polling time: " << std::endl;
-			//info << std::dec << slotIt->pollingTimeMs << std::endl;
-		}
-		time = slotIt->pollingTimeMs;
-		slotIt++;
-	}
-	//info << "Number of elements in slot list: "
-	//	   << slotList.size() << std::endl;
-	if (count > 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-			executingTask));
-	this->current = slotList.begin();
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tasks/FixedSlotSequence.h"
+#include <cstdlib>
+
+FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
+		lengthMs(setLengthMs) {
+	current = slotList.begin();
+}
+
+FixedSlotSequence::~FixedSlotSequence() {
+	// Call the destructor on each list entry.
+	slotList.clear();
+}
+
+void FixedSlotSequence::executeAndAdvance() {
+	current->handler->performOperation(current->opcode);
+//	if (returnValue != RETURN_OK) {
+//		this->sendErrorMessage( returnValue );
+//	}
+	//Increment the polling Sequence iterator
+	this->current++;
+	//Set it to the beginning, if the list's end is reached.
+	if (this->current == this->slotList.end()) {
+		this->current = this->slotList.begin();
+	}
+}
+
+uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
+	uint32_t oldTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	oldTime = slotListIter->pollingTimeMs;
+	// Advance to the next object.
+	slotListIter++;
+	// Find the next interval which is not 0.
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
+		} else {
+			slotListIter++;
+		}
+	}
+	// If the list end is reached (this is definitely an interval != 0),
+	// the interval is calculated by subtracting the remaining time of the PST
+	// and adding the start time of the first handler in the list.
+	slotListIter = slotList.begin();
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
+}
+
+uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
+	uint32_t currentTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	currentTime = slotListIter->pollingTimeMs;
+
+	//if it is the first slot, calculate difference to last slot
+	if (slotListIter == slotList.begin()){
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+	}
+	// get previous slot
+	slotListIter--;
+
+	return currentTime - slotListIter->pollingTimeMs;
+}
+
+bool FixedSlotSequence::slotFollowsImmediately() {
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
+	// Get the pollingTimeMs of the current slot object.
+	if (fixedSequenceIter == slotList.begin())
+		return false;
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+uint32_t FixedSlotSequence::getLengthMs() const {
+	return this->lengthMs;
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
+	if(slotList.empty()) {
+		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	auto slotIt = slotList.begin();
+	uint32_t count = 0;
+	uint32_t time = 0;
+	while (slotIt != slotList.end()) {
+		if (slotIt->handler == nullptr) {
+			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
+					<< std::endl;
+			count++;
+		} else if (slotIt->pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slotIt->pollingTimeMs
+					<< " is smaller than previous with " << time << std::endl;
+			count++;
+		} else {
+			// All ok, print slot.
+			//info << "Current slot polling time: " << std::endl;
+			//info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slotIt->pollingTimeMs;
+		slotIt++;
+	}
+	//info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
+	if (count > 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+		int8_t executionStep, PeriodicTaskIF* executingTask) {
+	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
+			executingTask));
+	this->current = slotList.begin();
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 61883658..67ce0094 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,154 +1,154 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/FixedSequenceSlot.h>
-
-#include <set>
-
-/**
- * @brief	This class is the representation of a Polling Sequence Table in software.
- * @details
- * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
- *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
- *
- * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
- */
-class FixedSlotSequence {
-public:
-	using SlotList = std::multiset<FixedSequenceSlot>;
-	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
-	/**
-	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
-	 * @param	setLength	The period length, expressed in ms.
-	 */
-	FixedSlotSequence(uint32_t setLengthMs);
-
-	/**
-	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
-	 */
-	virtual ~FixedSlotSequence();
-
-	/**
-	 * @brief	This is a method to add an PollingSlot object to slotList.
-	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
-	 * 	@param
-	 * 	@param
-	 */
-	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			PeriodicTaskIF* executingTask);
-
-	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
-	 * @return 	- @c true if the slot has the same polling time as the previous
-	 * 			- @c false else
-	 */
-	bool slotFollowsImmediately();
-
-	/**
-	 * @brief	This method returns the time until the next software
-	 * 			component is invoked.
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the
-	 * next one (or the first one, if the list end is reached)
-	 * it calculates and returns the interval in milliseconds within
-	 * which the handler execution shall take place.
-	 * If the next slot has the same time as the current one, it is ignored
-	 * until a slot with different time or the end of the PST is found.
-	 */
-	uint32_t getIntervalToNextSlotMs();
-
-	/**
-	 * @brief	This method returns the time difference between the current
-	 * 			slot and the previous slot
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the previous
-	 * one (or the last one, if the slot is the first one) it calculates and
-	 * returns the interval in milliseconds that the handler execution shall
-	 * be delayed.
-	 */
-	uint32_t getIntervalToPreviousSlotMs();
-
-	/**
-	 * @brief	This method returns the length of this FixedSlotSequence instance.
-	 */
-	uint32_t getLengthMs() const;
-
-	/**
-	 * @brief	The method to execute the device handler entered in the current
-	 * 			PollingSlot object.
-	 *
-	 * @details
-	 * Within this method the device handler object to be executed is chosen by
-	 * looking up the handler address of the current slot in the handlerMap.
-	 * Either the device handler's talkToInterface or its listenToInterface
-	 * method is invoked, depending on the isTalking flag of the polling slot.
-	 * After execution the iterator current is increased or, by reaching the
-	 * end of slotList, reset to the beginning.
-	 */
-	void executeAndAdvance();
-
-	/**
-	 * @brief	An iterator that indicates the current polling slot to execute.
-	 *
-	 * @details	This is an iterator for slotList and always points to the
-	 * 			polling slot which is executed next.
-	 */
-	SlotListIter current;
-
-	/**
-	 * Iterate through slotList and check successful creation.
-	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * @return
-	 */
-	ReturnValue_t checkSequence() const;
-
-protected:
-
-	/**
-	 * @brief	This list contains all PollingSlot objects, defining order and
-	 * 			execution time of the device handler objects.
-	 *
-	 * @details
-	 * The slot list is a std:list object that contains all created
-	 * PollingSlot instances. They are NOT ordered automatically, so by
-	 * adding entries, the correct order needs to be ensured. By iterating
-	 * through this list the polling sequence is executed. Two entries with
-	 * identical polling times are executed immediately one after another.
-	 */
-	SlotList slotList;
-
-	uint32_t lengthMs;
-
-	bool isEmpty = false;
-};
-
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/FixedSequenceSlot.h"
+
+#include <set>
+
+/**
+ * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @details
+ * The FixedSlotSequence object maintains the dynamic execution of
+ * device handler objects.
+ *
+ * The main idea is to create a list of device handlers, to announce all
+ * handlers to thepolling sequence and to maintain a list of
+ * polling slot objects. This slot list represents the Polling Sequence Table
+ * in software.
+ *
+ * Each polling slot contains information to indicate when and
+ * which device handler shall be executed within a given polling period.
+ * The sequence is then executed by iterating through this slot list.
+ * Handlers are invoking by calling a certain function stored in the handler list.
+ */
+class FixedSlotSequence {
+public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
+
+	/**
+	 * @brief	The constructor of the FixedSlotSequence object.
+	 *
+	 * @details	The constructor takes two arguments, the period length and the init function.
+	 *
+	 * @param	setLength	The period length, expressed in ms.
+	 */
+	FixedSlotSequence(uint32_t setLengthMs);
+
+	/**
+	 * @brief	The destructor of the FixedSlotSequence object.
+	 *
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
+	 *  		and deleting all allocated resources.
+	 */
+	virtual ~FixedSlotSequence();
+
+	/**
+	 * @brief	This is a method to add an PollingSlot object to slotList.
+	 *
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
+	 * 			to the end of the list. The list is currently NOT reordered.
+	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
+	 */
+	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
+			PeriodicTaskIF* executingTask);
+
+	/**
+	 * Checks if the current slot shall be executed immediately after the one before.
+	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @return 	- @c true if the slot has the same polling time as the previous
+	 * 			- @c false else
+	 */
+	bool slotFollowsImmediately();
+
+	/**
+	 * @brief	This method returns the time until the next software
+	 * 			component is invoked.
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
+	 */
+	uint32_t getIntervalToNextSlotMs();
+
+	/**
+	 * @brief	This method returns the time difference between the current
+	 * 			slot and the previous slot
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the previous
+	 * one (or the last one, if the slot is the first one) it calculates and
+	 * returns the interval in milliseconds that the handler execution shall
+	 * be delayed.
+	 */
+	uint32_t getIntervalToPreviousSlotMs();
+
+	/**
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
+	 */
+	uint32_t getLengthMs() const;
+
+	/**
+	 * @brief	The method to execute the device handler entered in the current
+	 * 			PollingSlot object.
+	 *
+	 * @details
+	 * Within this method the device handler object to be executed is chosen by
+	 * looking up the handler address of the current slot in the handlerMap.
+	 * Either the device handler's talkToInterface or its listenToInterface
+	 * method is invoked, depending on the isTalking flag of the polling slot.
+	 * After execution the iterator current is increased or, by reaching the
+	 * end of slotList, reset to the beginning.
+	 */
+	void executeAndAdvance();
+
+	/**
+	 * @brief	An iterator that indicates the current polling slot to execute.
+	 *
+	 * @details	This is an iterator for slotList and always points to the
+	 * 			polling slot which is executed next.
+	 */
+	SlotListIter current;
+
+	/**
+	 * Iterate through slotList and check successful creation.
+	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * @return
+	 */
+	ReturnValue_t checkSequence() const;
+
+protected:
+
+	/**
+	 * @brief	This list contains all PollingSlot objects, defining order and
+	 * 			execution time of the device handler objects.
+	 *
+	 * @details
+	 * The slot list is a std:list object that contains all created
+	 * PollingSlot instances. They are NOT ordered automatically, so by
+	 * adding entries, the correct order needs to be ensured. By iterating
+	 * through this list the polling sequence is executed. Two entries with
+	 * identical polling times are executed immediately one after another.
+	 */
+	SlotList slotList;
+
+	uint32_t lengthMs;
+
+	bool isEmpty = false;
+};
+
+#endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 023b5ee0..3456dae7 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-
-/**
- * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
- */
-class FixedTimeslotTaskIF : public PeriodicTaskIF {
-public:
-	virtual ~FixedTimeslotTaskIF() {}
-
-	/**
-	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
-	 * @param componentId
-	 * @param slotTimeMs
-	 * @param executionStep
-	 * @return
-	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-	/** Check whether the sequence is valid */
-	virtual ReturnValue_t checkSequence() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
+ */
+class FixedTimeslotTaskIF : public PeriodicTaskIF {
+public:
+	virtual ~FixedTimeslotTaskIF() {}
+
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
+	/** Check whether the sequence is valid */
+	virtual ReturnValue_t checkSequence() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index f54d6155..38cf201b 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
-#define FRAMEWORK_TASK_PERIODICTASKIF_H_
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/timemanager/Clock.h>
-#include <cstddef>
-class ExecutableObjectIF;
-
-/**
- * New version of TaskIF
- * Follows RAII principles, i.e. there's no create or delete method.
- * Minimalistic.
-*/
-class PeriodicTaskIF {
-public:
-	static const size_t MINIMUM_STACK_SIZE;
-	/**
-	 * @brief	A virtual destructor as it is mandatory for interfaces.
-	 */
-	virtual ~PeriodicTaskIF() { }
-	/**
-	 * @brief	With the startTask method, a created task can be started
-	 *          for the first time.
-	 */
-	virtual ReturnValue_t startTask() = 0;
-
-	/**
-	 * Add a component (object) to a periodic task. The pointer to the
-	 * task can be set optionally
-	 * @param object
-	 * Add an object to the task. The most important case is to add an
-	 * executable object with a function which will be called regularly
-	 * (see ExecutableObjectIF)
-	 * @param setTaskIF
-	 * Can be used to specify whether the task object pointer is passed
-	 * to the component.
-	 * @return
-	 */
-	virtual ReturnValue_t addComponent(object_id_t object) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-
-	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
-
-	virtual uint32_t getPeriodMs() const = 0;
-};
-
-
-#endif /* PERIODICTASKIF_H_ */
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+#include <cstddef>
+class ExecutableObjectIF;
+
+/**
+ * New version of TaskIF
+ * Follows RAII principles, i.e. there's no create or delete method.
+ * Minimalistic.
+*/
+class PeriodicTaskIF {
+public:
+	static const size_t MINIMUM_STACK_SIZE;
+	/**
+	 * @brief	A virtual destructor as it is mandatory for interfaces.
+	 */
+	virtual ~PeriodicTaskIF() { }
+	/**
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
+	 */
+	virtual ReturnValue_t startTask() = 0;
+
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+
+	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
+
+	virtual uint32_t getPeriodMs() const = 0;
+};
+
+
+#endif /* PERIODICTASKIF_H_ */
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 7f8edaf1..b2f34788 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#include <framework/tasks/SemaphoreIF.h>
-
-/**
- * Creates Semaphore.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class SemaphoreFactory {
-public:
-	virtual ~SemaphoreFactory();
-	/**
-	 * Returns the single instance of SemaphoreFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static SemaphoreFactory* instance();
-
-	/**
-	 * Create a binary semaphore.
-	 * Creator function for a binary semaphore which may only be acquired once
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return Pointer to newly created semaphore class instance.
-	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
-	/**
-	 * Create a counting semaphore.
-	 * Creator functons for a counting semaphore which may be acquired multiple
-	 * times.
-	 * @param count Semaphore can be taken count times.
-	 * @param initCount Initial count value.
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return
-	 */
-	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
-			uint8_t initCount, uint32_t arguments = 0);
-
-	void deleteSemaphore(SemaphoreIF* semaphore);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	SemaphoreFactory();
-	static SemaphoreFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#include "../tasks/SemaphoreIF.h"
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
+
+	void deleteSemaphore(SemaphoreIF* semaphore);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 4fc92ebd..3fed4511 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,72 +1,72 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#include <framework/returnvalues/FwClassIds.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <cstdint>
-
-/**
- * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization. This is a generic interface which can be
- * 			used for both binary semaphores and counting semaphores.
- * @details
- * A semaphore is a synchronization primitive.
- * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
- * A semaphore can be used to achieve task synchonization and track the
- * availability of resources by using either the binary or the counting
- * semaphore types.
- *
- * If mutual exlcusion of a resource is desired, a mutex should be used,
- * which is a special form of a semaphore and has an own interface.
- */
-class SemaphoreIF {
-public:
-	virtual~ SemaphoreIF() {};
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-	//! Semaphore timeout
-	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
-	//! The current semaphore can not be given, because it is not owned
-	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
-
-	/**
-	 * Generic call to acquire a semaphore.
-	 * If there are no more semaphores to be taken (for a counting semaphore,
-	 * a semaphore may be taken more than once), the taks will block
-	 * for a maximum of timeoutMs while trying to acquire the semaphore.
-	 * This can be used to achieve task synchrnization.
-	 * @param timeoutMs
-	 * @return - c RETURN_OK for successfull acquisition
-	 */
-	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
-
-	/**
-	 * Corrensponding call to release a semaphore.
-	 * @return -@c RETURN_OK for successfull release
-	 */
-	virtual ReturnValue_t release() = 0;
-
-	/**
-	 * If the semaphore is a counting semaphore then the semaphores current
-	 * count value is returned. If the semaphore is a binary semaphore then 1
-	 * is returned if the semaphore is available, and 0 is returned if the
-	 * semaphore is not available.
-	 */
-	virtual uint8_t getSemaphoreCounter() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include "../returnvalues/FwClassIds.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
+ */
+class SemaphoreIF {
+public:
+	virtual~ SemaphoreIF() {};
+	/**
+	 * @brief 	Timeout value used for polling lock attempt.
+	 * @details
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return - c RETURN_OK for successfull acquisition
+	 */
+	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return -@c RETURN_OK for successfull release
+	 */
+	virtual ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 */
+	virtual uint8_t getSemaphoreCounter() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index e1e2f5e2..56b3083e 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
-
-#include <cstdlib>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
-
-/**
- * Singleton Class that produces Tasks.
- */
-class TaskFactory {
-public:
-	virtual ~TaskFactory();
-	/**
-	 * Returns the single instance of TaskFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static TaskFactory* instance();
-
-	/**
-	 * Generic interface to create a periodic task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	PeriodicTaskIF* createPeriodicTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Generic interface to create a fixed timeslot task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	TaskFactory();
-	static TaskFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
+#define FRAMEWORK_TASKS_TASKFACTORY_H_
+
+#include <cstdlib>
+#include "../tasks/FixedTimeslotTaskIF.h"
+#include "../tasks/Typedef.h"
+
+/**
+ * Singleton Class that produces Tasks.
+ */
+class TaskFactory {
+public:
+	virtual ~TaskFactory();
+	/**
+	 * Returns the single instance of TaskFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static TaskFactory* instance();
+
+	/**
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	PeriodicTaskIF* createPeriodicTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Function to be called to delete a task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	TaskFactory();
+	static TaskFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 24c93730..68f26d2c 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,82 +1,82 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/CCSDSDistributor.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
-		object_id_t setObjectId):
-		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
-}
-
-CCSDSDistributor::~CCSDSDistributor() {}
-
-TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-//			this->currentMessage.getStorageId().pool_index << ", " <<
-//			this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* packet = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
-			&packet, &size );
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
-	}
-	SpacePacketBase currentPacket(packet);
-
-//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
-//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
-	if ( position != this->queueMap.end() ) {
-		return position;
-	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to
-		// create acceptance failure report.
-		return this->queueMap.find( this->defaultApid );
-	}
-}
-
-MessageQueueId_t CCSDSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(
-		AcceptsTelecommandsIF* application) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
-		MessageQueueId_t id) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-
-}
-
-uint16_t CCSDSDistributor::getIdentifier() {
-	return 0;
-}
-
-ReturnValue_t CCSDSDistributor::initialize() {
-	ReturnValue_t status = this->TcDistributor::initialize();
-	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
-	return status;
-}
-
-ReturnValue_t CCSDSDistributor::callbackAfterSending(
-		ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStore->deleteData(currentMessage.getStorageId());
-	}
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributor.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {}
+
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
+	if ( position != this->queueMap.end() ) {
+		return position;
+	} else {
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
+	}
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+
+}
+
+uint16_t CCSDSDistributor::getIdentifier() {
+	return 0;
+}
+
+ReturnValue_t CCSDSDistributor::initialize() {
+	ReturnValue_t status = this->TcDistributor::initialize();
+	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	if (this->tcStore == NULL) status = RETURN_FAILED;
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 60877753..e54b9fe4 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,69 +1,69 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tcdistribution/CCSDSDistributorIF.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-
-/**
- * @brief 	An instantiation of the CCSDSDistributorIF.
- * @details
- * It receives Space Packets, and selects a destination depending on the
- * APID of the telecommands.
- * The Secondary Header (with Service/Subservice) is ignored.
- * @ingroup tc_distribution
- */
-class CCSDSDistributor : public TcDistributor,
-		public CCSDSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * @brief	The constructor sets the default APID and calls the
-	 * 			TcDistributor ctor with a certain object id.
-	 * @details
-	 * @c tcStore is set in the @c initialize method.
-	 * @param setDefaultApid The default APID, where packets with unknown
-	 * destination are sent to.
-	 */
-	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~CCSDSDistributor();
-
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t registerApplication( uint16_t apid,
-			MessageQueueId_t id) override;
-	ReturnValue_t registerApplication(
-			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
-	ReturnValue_t initialize() override;
-
-protected:
-	/**
-	 * This implementation checks if an application with fitting APID has
-	 * registered and forwards the packet to the according message queue.
-	 * If the packet is not found, it returns the queue to @c defaultApid,
-	 * where a Acceptance Failure message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t defaultApid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles
-	 * pure Space Packets and there exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+/**
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
+ * The Secondary Header (with Service/Subservice) is ignored.
+ * @ingroup tc_distribution
+ */
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
+	 */
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~CCSDSDistributor();
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index dc1263a9..32198120 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,40 +1,40 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
- */
-class CCSDSDistributorIF {
-public:
-	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
-	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
-	/**
-	 * With this call, other Applications can register to the CCSDS distributor.
-	 * This is done by passing an APID and a MessageQueueId to the method.
-	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~CCSDSDistributorIF() {
-	}
-};
-
-
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#ifndef CCSDSDISTRIBUTORIF_H_
+#define CCSDSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This is the Interface to a CCSDS Distributor.
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributorIF {
+public:
+	/**
+	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * distributor.
+	 * @param application A pointer to the Application to register.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	/**
+	 * With this call, other Applications can register to the CCSDS distributor.
+	 * This is done by passing an APID and a MessageQueueId to the method.
+	 * @param apid	The APID to register.
+	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~CCSDSDistributorIF() {
+	}
+};
+
+
+#endif /* CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 5eb50103..fee16f11 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,92 +1,92 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/CCSDSDistributorIF.h>
-#include <framework/tcdistribution/PUSDistributor.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
-
-PUSDistributor::~PUSDistributor() {}
-
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
-
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
-
-}
-
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
-
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
-	MessageQueueId_t queue = service->getRequestQueue();
-	auto returnPair = queueMap.emplace(serviceId, queue);
-	if (not returnPair.second) {
-		//TODO Return Code
-		sif::error << "PUSDistributor::registerService: Service ID already"
-				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PUSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStatus = queueStatus;
-	}
-	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
-		return RETURN_FAILED;
-	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
-		return RETURN_OK;
-	}
-}
-
-uint16_t PUSDistributor::getIdentifier() {
-	return checker.getApid();
-}
-
-ReturnValue_t PUSDistributor::initialize() {
-	CCSDSDistributorIF* ccsdsDistributor =
-			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
-		return ccsdsDistributor->registerApplication(this);
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/PUSDistributor.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+	TcMqMapIter queueMapIt = this->queueMap.end();
+	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
+	if (currentPacket.getWholeData() != NULL) {
+		tcStatus = checker.checkPacket(&currentPacket);
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
+		uint32_t queue_id = currentPacket.getService();
+		queueMapIt = this->queueMap.find(queue_id);
+	} else {
+		tcStatus = PACKET_LOST;
+	}
+	if (queueMapIt == this->queueMap.end()) {
+		tcStatus = DESTINATION_NOT_FOUND;
+	}
+
+	if (tcStatus != RETURN_OK) {
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
+		return this->queueMap.end();
+	} else {
+		return queueMapIt;
+	}
+
+}
+
+//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
+//	return ( service_id << 8 ) + subservice_id;
+//}
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
+	MessageQueueId_t queue = service->getRequestQueue();
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
+		//TODO Return Code
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				" exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStatus = queueStatus;
+	}
+	if (tcStatus != RETURN_OK) {
+		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+				&currentPacket, tcStatus);
+		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		currentPacket.deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+				&currentPacket);
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+	CCSDSDistributorIF* ccsdsDistributor =
+			objectManager->get<CCSDSDistributorIF>(packetSource);
+	if (ccsdsDistributor == NULL) {
+		return RETURN_FAILED;
+	} else {
+		return ccsdsDistributor->registerApplication(this);
+	}
+}
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index 4a22f936..be84de1b 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tcdistribution/TcPacketCheck.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/VerificationReporter.h>
-
-/**
- * This class accepts PUS Telecommands and forwards them to Application
- * services. In addition, the class performs a formal packet check and
- * sends acceptance success or failure messages.
- * @ingroup tc_distribution
- */
-class PUSDistributor: public TcDistributor,
-		public PUSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * The ctor passes @c set_apid to the checker class and calls the
-	 * TcDistribution ctor with a certain object id.
-	 * @param setApid The APID of this receiving Application.
-	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets.
-	 * Must implement CCSDSDistributorIF.
-	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-			object_id_t setPacketSource);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t initialize() override;
-	uint16_t getIdentifier() override;
-
-protected:
-	/**
-	 * This attribute contains the class, that performs a formal packet check.
-	 */
-	TcPacketCheck checker;
-	/**
-	 * With this class, verification messages are sent to the
-	 * TC Verification service.
-	 */
-	VerificationReporter verifyChannel;
-	/**
-	 * The currently handled packet is stored here.
-	 */
-	TcPacketStored currentPacket;
-	/**
-	 * With this variable, the current check status is stored to generate
-	 * acceptance messages later.
-	 */
-	ReturnValue_t tcStatus;
-
-	const object_id_t packetSource;
-	/**
-	 * This method reads the packet service, checks if such a service is
-	 * registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification
-	 * messages.
-	 * @return Iterator to map entry of found service id
-	 * or iterator to @c map.end().
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationReporter.h"
+
+/**
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
+ */
+class PUSDistributor: public TcDistributor,
+		public PUSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
+	 * @param setApid The APID of this receiving Application.
+	 * @param setObjectId Object ID of the distributor itself
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
+	 */
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
+protected:
+	/**
+	 * This attribute contains the class, that performs a formal packet check.
+	 */
+	TcPacketCheck checker;
+	/**
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
+	 */
+	VerificationReporter verifyChannel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored currentPacket;
+	/**
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
+	 */
+	ReturnValue_t tcStatus;
+
+	const object_id_t packetSource;
+	/**
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index bb101137..7967a74e 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,26 +1,26 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
-
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
- */
-class PUSDistributorIF {
-public:
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~PUSDistributorIF() {
-	}
-/**
- * With this method, Services can register themselves at the PUS Distributor.
- * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
- */
-	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
-};
-
-#endif /* PUSDISTRIBUTORIF_H_ */
+#ifndef PUSDISTRIBUTORIF_H_
+#define PUSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This interface allows PUS Services to register themselves at a PUS Distributor.
+ * \ingroup tc_distribution
+ */
+class PUSDistributorIF {
+public:
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~PUSDistributorIF() {
+	}
+/**
+ * With this method, Services can register themselves at the PUS Distributor.
+ * @param service A pointer to the registering Service.
+ * @return	- \c RETURN_OK on success,
+ * 			- \c RETURN_FAILED on failure.
+ */
+	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
+};
+
+#endif /* PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 0190cc97..45a20fd9 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,54 +1,54 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/TcDistributor.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
-}
-
-TcDistributor::~TcDistributor() {
-	QueueFactory::instance()->deleteMessageQueue(tcQueue);
-}
-
-ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
-	ReturnValue_t status = RETURN_OK;
-	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
-			status = tcQueue->receiveMessage(&currentMessage)) {
-		status = handlePacket();
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return RETURN_OK;
-	} else {
-		return status;
-	}
-}
-
-ReturnValue_t TcDistributor::handlePacket() {
-
-	TcMqMapIter queueMapIt = this->selectDestination();
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if (queueMapIt != this->queueMap.end()) {
-		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
-				&this->currentMessage);
-	}
-	return this->callbackAfterSending(returnValue);
-}
-
-void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
-	}
-	sif::debug << std::dec;
-
-}
-
-ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+TcDistributor::TcDistributor(object_id_t set_object_id) :
+		SystemObject(set_object_id), tcQueue(NULL) {
+	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+}
+
+TcDistributor::~TcDistributor() {
+	QueueFactory::instance()->deleteMessageQueue(tcQueue);
+}
+
+ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
+	ReturnValue_t status = RETURN_OK;
+	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue->receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	TcMqMapIter queueMapIt = this->selectDestination();
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if (queueMapIt != this->queueMap.end()) {
+		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
+				&this->currentMessage);
+	}
+	return this->callbackAfterSending(returnValue);
+}
+
+void TcDistributor::print() {
+	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+			<< std::endl;
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+			it++) {
+		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+				<< std::endl;
+	}
+	sif::debug << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 73425302..987f2eaa 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,120 +1,120 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <map>
-
-/**
- * @defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands
- * belong to this group.
- */
-
-
-/**
- * This is the base class to implement distributors for Space Packets.
- * Typically, the distribution is required to forward Telecommand packets
- * over the satellite applications and services. The class receives
- * Space Packets over a message queue and holds a map that links other
- * message queue ids to some identifier. The process of unpacking the
- * destination information from the packet is handled by the child class
- * implementations.
- * @ingroup tc_distribution
- */
-class TcDistributor : public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	/**
-	 * Within the default constructor, the SystemObject id is set and the
-	 * message queue is initialized.
-	 * Filling the map is under control of the child classes.
-	 * @param set_object_id	This id is assigned to the distributor
-	 * 		implementation.
-	 */
-	TcDistributor( object_id_t set_object_id );
-	/**
-	 * The destructor is empty, the message queues are not in the vicinity of
-	 * this class.
-	 */
-	virtual ~TcDistributor();
-	/**
-	 * The method is called cyclically and fetches new incoming packets from
-	 * the message queue.
-	 * In case a new packet is found, it calls the handlePacket method to deal
-	 * with distribution.
-	 * @return The error code of the message queue call.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	/**
-	 * A simple debug print, that prints all distribution information stored in
-	 * queueMap.
-	 */
-	void print();
-
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	TcMessageQueueMap queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual TcMqMapIter selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-};
-
-
-#endif /* TCDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
+ */
+
+
+/**
+ * This is the base class to implement distributors for Space Packets.
+ * Typically, the distribution is required to forward Telecommand packets
+ * over the satellite applications and services. The class receives
+ * Space Packets over a message queue and holds a map that links other
+ * message queue ids to some identifier. The process of unpacking the
+ * destination information from the packet is handled by the child class
+ * implementations.
+ * @ingroup tc_distribution
+ */
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	/**
+	 * Within the default constructor, the SystemObject id is set and the
+	 * message queue is initialized.
+	 * Filling the map is under control of the child classes.
+	 * @param set_object_id	This id is assigned to the distributor
+	 * 		implementation.
+	 */
+	TcDistributor( object_id_t set_object_id );
+	/**
+	 * The destructor is empty, the message queues are not in the vicinity of
+	 * this class.
+	 */
+	virtual ~TcDistributor();
+	/**
+	 * The method is called cyclically and fetches new incoming packets from
+	 * the message queue.
+	 * In case a new packet is found, it calls the handlePacket method to deal
+	 * with distribution.
+	 * @return The error code of the message queue call.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode);
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMqMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+};
+
+
+#endif /* TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 90a1167f..98dfaeb8 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,37 +1,37 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tcdistribution/TcPacketCheck.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
-}
-
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
-	if ( calculated_crc != 0 ) {
-		return INCORRECT_CHECKSUM;
-	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
-	if ( condition ) {
-		return INCORRECT_PRIMARY_HEADER;
-	}
-	if ( current_packet->getAPID() != this->apid )
-		return ILLEGAL_APID;
-
-	if ( !current_packet->isSizeCorrect() ) {
-		return INCOMPLETE_PACKET;
-	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
-	if ( condition ) {
-		return INCORRECT_SECONDARY_HEADER;
-	}
-	return RETURN_OK;
-}
-
-uint16_t TcPacketCheck::getApid() const {
-	return apid;
-}
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = !(current_packet->hasSecondaryHeader()) ||
+			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			!(current_packet->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( current_packet->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( !current_packet->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 88810ed7..9fe1db72 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,59 +1,59 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
- */
-class TcPacketCheck : public HasReturnvaluesIF {
-protected:
-	/**
-	 * Describes the version number a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
-	/**
-	 * Describes the secondary header a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-	/**
-	 * Describes the TC Packet PUS Version Number a packet must have to pass.
-	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
-	/**
-	 * The packet id each correct packet should have.
-	 * It is composed of the APID and some static fields.
-	 */
-	uint16_t apid;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
-	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
-	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
-	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
-	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
-	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
-	/**
-	 * The constructor only sets the APID attribute.
-	 * @param set_apid The APID to set.
-	 */
-	TcPacketCheck( uint16_t set_apid );
-	/**
-	 * This is the actual method to formally check a certain Telecommand Packet.
-	 * The packet's Application Data can not be checked here.
-	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
-	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
-
-	uint16_t getApid() const;
-};
-
-
-#endif /* TCPACKETCHECK_H_ */
+#ifndef TCPACKETCHECK_H_
+#define TCPACKETCHECK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * \ingroup tc_distribution
+ */
+class TcPacketCheck : public HasReturnvaluesIF {
+protected:
+	/**
+	 * Describes the version number a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static const uint8_t PUS_VERSION_NUMBER = 1;
+	/**
+	 * The packet id each correct packet should have.
+	 * It is composed of the APID and some static fields.
+	 */
+	uint16_t apid;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t set_apid );
+	/**
+	 * This is the actual method to formally check a certain Telecommand Packet.
+	 * The packet's Application Data can not be checked here.
+	 * @param current_packet The packt to check
+	 * @return	- \c RETURN_OK on success.
+	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- \c ILLEGAL_APID if APID does not match.
+	 */
+	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* TCPACKETCHECK_H_ */
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 41230f59..5d821367 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -1,70 +1,70 @@
-#include "AbstractTemperatureSensor.h"
-#include <framework/ipc/QueueFactory.h>
-
-AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
-		ThermalModuleIF *thermalModule) :
-		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
-				setObjectid), parameterHelper(this) {
-	if (thermalModule != NULL) {
-		thermalModule->registerSensor(this);
-	}
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-AbstractTemperatureSensor::~AbstractTemperatureSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t AbstractTemperatureSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	return result;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	doChildOperation();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
-	handleCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		result = parameterHelper.handleParameterMessage(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "AbstractTemperatureSensor.h"
+#include "../ipc/QueueFactory.h"
+
+AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
+		ThermalModuleIF *thermalModule) :
+		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
+				setObjectid), parameterHelper(this) {
+	if (thermalModule != NULL) {
+		thermalModule->registerSensor(this);
+	}
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+AbstractTemperatureSensor::~AbstractTemperatureSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t AbstractTemperatureSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	return result;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	doChildOperation();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
+	handleCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void AbstractTemperatureSensor::handleCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		result = parameterHelper.handleParameterMessage(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 4b869365..462b41f2 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -1,64 +1,64 @@
-#ifndef ABSTRACTSENSOR_H_
-#define ABSTRACTSENSOR_H_
-
-#include <framework/health/HasHealthIF.h>
-#include <framework/health/HealthHelper.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include "ThermalModuleIF.h"
-#include "tcsDefinitions.h"
-
-/**
- * @defgroup thermal Thermal Components
- * @brief Contains all components related to thermal tasks (sensors, heaters)
- */
-
-/**
- * @brief Base class for Temperature Sensor, implements all important interfaces.
- *        Please use the TemperatureSensor class to implement the actual sensors.
- * @ingroup thermal
- */
-class AbstractTemperatureSensor: public HasHealthIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public ReceivesParameterMessagesIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
-
-	static constexpr float ZERO_KELVIN_C = -273.15;
-	AbstractTemperatureSensor(object_id_t setObjectid,
-			ThermalModuleIF *thermalModule);
-	virtual ~AbstractTemperatureSensor();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t performHealthOp();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual float getTemperature() = 0;
-	virtual bool isValid() = 0;
-
-	virtual void resetOldState() = 0;
-
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-protected:
-	MessageQueueIF* commandQueue;
-	HealthHelper healthHelper;
-	ParameterHelper parameterHelper;
-
-	virtual void doChildOperation() = 0;
-
-	void handleCommandQueue();
-};
-
-#endif /* ABSTRACTSENSOR_H_ */
+#ifndef ABSTRACTSENSOR_H_
+#define ABSTRACTSENSOR_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../ipc/MessageQueueIF.h"
+#include "ThermalModuleIF.h"
+#include "tcsDefinitions.h"
+
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
+class AbstractTemperatureSensor: public HasHealthIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public ReceivesParameterMessagesIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+
+	static constexpr float ZERO_KELVIN_C = -273.15;
+	AbstractTemperatureSensor(object_id_t setObjectid,
+			ThermalModuleIF *thermalModule);
+	virtual ~AbstractTemperatureSensor();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t performHealthOp();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual float getTemperature() = 0;
+	virtual bool isValid() = 0;
+
+	virtual void resetOldState() = 0;
+
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+protected:
+	MessageQueueIF* commandQueue;
+	HealthHelper healthHelper;
+	ParameterHelper parameterHelper;
+
+	virtual void doChildOperation() = 0;
+
+	void handleCommandQueue();
+};
+
+#endif /* ABSTRACTSENSOR_H_ */
diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index 28c62af6..9fe03499 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -6,7 +6,7 @@
 
 #ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
 #define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
+#include "../ipc/MessageQueueSenderIF.h"
 
 class AcceptsThermalMessagesIF {
 public:
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index a0736c71..87a6972e 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,96 +1,96 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/thermal/ThermalModule.h>
-#include <framework/thermal/ThermalMonitor.h>
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
+#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../thermal/ThermalModule.h"
+#include "../thermal/ThermalMonitor.h"
+
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
+class CoreComponent: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
+			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
+			AbstractTemperatureSensor *sensor,
+			AbstractTemperatureSensor *firstRedundantSensor,
+			AbstractTemperatureSensor *secondRedundantSensor,
+			ThermalModuleIF *thermalModule, Parameters parameters,
+			Priority priority, StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	virtual ~CoreComponent();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor;
+	AbstractTemperatureSensor *firstRedundantSensor;
+	AbstractTemperatureSensor *secondRedundantSensor;
+	ThermalModuleIF *thermalModule;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating;
+
+	bool isSafeComponent;
+
+	float minTemp;
+
+	float maxTemp;
+
+	Parameters parameters;
+
+	ThermalMonitor temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index b1cf38f2..94dd91b5 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -1,350 +1,350 @@
-#include <framework/devicehandlers/DeviceHandlerFailureIsolation.h>
-#include "Heater.h"
-
-#include <framework/power/Fuse.h>
-#include <framework/ipc/QueueFactory.h>
-
-Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Heater::~Heater() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t Heater::set() {
-	passive = false;
-	//wait for clear before doing anything
-	if (internalState == STATE_WAIT) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(SET);
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	} else {
-		if (healthHelper.healthTable->isFaulty(getObjectId())) {
-			if (!reactedToBeingFaulty) {
-				reactedToBeingFaulty = true;
-				doAction(CLEAR);
-			}
-		}
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void Heater::clear(bool passive) {
-	this->passive = passive;
-	//Force switching off
-	if (internalState == STATE_WAIT) {
-		internalState = STATE_ON;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(CLEAR);
-	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
-		if (!reactedToBeingFaulty) {
-			reactedToBeingFaulty = true;
-			doAction(CLEAR);
-		}
-	}
-}
-
-void Heater::doAction(Action action) {
-	//only act if we are not in the right state or in a transition
-	if (action == SET) {
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			internalState = STATE_WAIT_FOR_SWITCHES_ON;
-			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
-			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
-		}
-	} else { //clear
-		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			powerSwitcher->sendSwitchCommand(switch0,
-					PowerSwitchIF::SWITCH_OFF);
-			powerSwitcher->sendSwitchCommand(switch1,
-					PowerSwitchIF::SWITCH_OFF);
-		}
-	}
-}
-
-void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
-	this->powerSwitcher = powerSwitch;
-}
-
-ReturnValue_t Heater::performOperation(uint8_t opCode) {
-	handleQueue();
-	handleEventQueue();
-
-	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
-		reactedToBeingFaulty = false;
-	}
-
-	switch (internalState) {
-	case STATE_ON:
-		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
-				|| (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_OFF)) {
-			//switch went off on its own
-			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_OFF:
-		//check if heater is on, ie both switches are on
-		//if so, just command it to off, to resolve the situation or force a switch stayed on event
-		//But, only do anything if not already faulty (state off is the stable point for being faulty)
-		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
-				&& (powerSwitcher->getSwitchState(switch0)
-						== PowerSwitchIF::SWITCH_ON)
-				&& (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_ON)) {
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-				powerSwitcher->sendSwitchCommand(switch0,
-						PowerSwitchIF::SWITCH_OFF);
-				powerSwitcher->sendSwitchCommand(switch1,
-						PowerSwitchIF::SWITCH_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_PASSIVE:
-		break;
-	case STATE_WAIT_FOR_SWITCHES_ON:
-		if (switchCountdown.hasTimedOut()) {
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_OFF)
-					|| (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_OFF)) {
-				triggerEvent(HEATER_STAYED_OFF);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_ON);
-				internalState = STATE_ON;
-			}
-		}
-		break;
-	case STATE_WAIT_FOR_SWITCHES_OFF:
-		if (switchCountdown.hasTimedOut()) {
-			//only check for both being on (ie heater still on)
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_ON)
-					&& (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_ON)) {
-				if (healthHelper.healthTable->isFaulty(getObjectId())) {
-					if (passive) {
-						internalState = STATE_PASSIVE;
-					} else {
-						internalState = STATE_OFF; //just accept it
-					}
-					triggerEvent(HEATER_ON); //but throw an event to make it more visible
-					break;
-				}
-				triggerEvent(HEATER_STAYED_ON);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_OFF);
-				if (passive) {
-					internalState = STATE_PASSIVE;
-				} else {
-					internalState = STATE_OFF;
-				}
-			}
-		}
-		break;
-	default:
-		break;
-	}
-
-	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
-			&& (powerSwitcher->getSwitchState(switch1)
-					== PowerSwitchIF::SWITCH_ON)) {
-		if (wasOn) {
-			if (heaterOnCountdown.hasTimedOut()) {
-				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
-				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
-				//it will be ok. whatcouldpossiblygowrongâ„¢
-				if (!timedOut) {
-					triggerEvent(HEATER_TIMEOUT);
-					timedOut = true;
-				}
-			}
-		} else {
-			wasOn = true;
-			heaterOnCountdown.resetTimer();
-			timedOut = false;
-		}
-	} else {
-		wasOn = false;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::setSwitch(uint8_t number, ReturnValue_t state,
-		uint32_t* uptimeOfSwitching) {
-	if (powerSwitcher == NULL) {
-		return;
-	}
-	if (powerSwitcher->getSwitchState(number) == state) {
-		*uptimeOfSwitching = INVALID_UPTIME;
-	} else {
-		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
-			powerSwitcher->sendSwitchCommand(number, state);
-			Clock::getUptime(uptimeOfSwitching);
-		} else {
-			uint32_t currentUptime;
-			Clock::getUptime(&currentUptime);
-			if (currentUptime - *uptimeOfSwitching
-					> powerSwitcher->getSwitchDelayMs()) {
-				*uptimeOfSwitching = INVALID_UPTIME;
-				if (healthHelper.healthTable->isHealthy(getObjectId())) {
-					if (state == PowerSwitchIF::SWITCH_ON) {
-						triggerEvent(HEATER_STAYED_OFF);
-					} else {
-						triggerEvent(HEATER_STAYED_ON);
-					}
-				}
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
-			}
-		}
-	}
-}
-
-MessageQueueId_t Heater::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t Heater::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
-			DeviceHandlerFailureIsolation::powerConfirmationId);
-	if (pcdu == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	pcduQueueId = pcdu->getEventReceptionQueue();
-
-	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
-			getObjectId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		parameterHelper.handleParameterMessage(&command);
-	}
-}
-
-ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != DOMAIN_ID_BASE) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(heaterOnCountdown.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleEventQueue() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == HasReturnvaluesIF::RETURN_OK;
-			result = eventQueue->receiveMessage(&event)) {
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			switch (event.getEvent()) {
-			case Fuse::FUSE_WENT_OFF:
-			case HEATER_STAYED_OFF:
-			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
-				if (healthHelper.healthTable->isCommandable(getObjectId())) {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			case PowerSwitchIF::SWITCH_WENT_OFF:
-				internalState = STATE_WAIT;
-				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
-				if (pcduQueueId != 0) {
-					eventQueue->sendMessage(pcduQueueId, &event);
-				} else {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			default:
-				return;
-			}
-			break;
-		case EventMessage::YOUR_FAULT:
-			healthHelper.setHealth(HasHealthIF::FAULTY);
-			internalState = STATE_FAULTY;
-			break;
-		case EventMessage::MY_FAULT:
-			//do nothing, we are already in STATE_WAIT and wait for a clear()
-			break;
-		default:
-			return;
-		}
-	}
-}
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "Heater.h"
+
+#include "../power/Fuse.h"
+#include "../ipc/QueueFactory.h"
+
+Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
+		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
+				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
+				false), timedOut(false), reactedToBeingFaulty(false), passive(
+				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
+				this), lastAction(CLEAR) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Heater::~Heater() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t Heater::set() {
+	passive = false;
+	//wait for clear before doing anything
+	if (internalState == STATE_WAIT) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(SET);
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	} else {
+		if (healthHelper.healthTable->isFaulty(getObjectId())) {
+			if (!reactedToBeingFaulty) {
+				reactedToBeingFaulty = true;
+				doAction(CLEAR);
+			}
+		}
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void Heater::clear(bool passive) {
+	this->passive = passive;
+	//Force switching off
+	if (internalState == STATE_WAIT) {
+		internalState = STATE_ON;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(CLEAR);
+	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
+		if (!reactedToBeingFaulty) {
+			reactedToBeingFaulty = true;
+			doAction(CLEAR);
+		}
+	}
+}
+
+void Heater::doAction(Action action) {
+	//only act if we are not in the right state or in a transition
+	if (action == SET) {
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			internalState = STATE_WAIT_FOR_SWITCHES_ON;
+			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
+			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
+		}
+	} else { //clear
+		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			powerSwitcher->sendSwitchCommand(switch0,
+					PowerSwitchIF::SWITCH_OFF);
+			powerSwitcher->sendSwitchCommand(switch1,
+					PowerSwitchIF::SWITCH_OFF);
+		}
+	}
+}
+
+void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
+	this->powerSwitcher = powerSwitch;
+}
+
+ReturnValue_t Heater::performOperation(uint8_t opCode) {
+	handleQueue();
+	handleEventQueue();
+
+	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
+		reactedToBeingFaulty = false;
+	}
+
+	switch (internalState) {
+	case STATE_ON:
+		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
+				|| (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_OFF)) {
+			//switch went off on its own
+			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_OFF:
+		//check if heater is on, ie both switches are on
+		//if so, just command it to off, to resolve the situation or force a switch stayed on event
+		//But, only do anything if not already faulty (state off is the stable point for being faulty)
+		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
+				&& (powerSwitcher->getSwitchState(switch0)
+						== PowerSwitchIF::SWITCH_ON)
+				&& (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_ON)) {
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+				powerSwitcher->sendSwitchCommand(switch0,
+						PowerSwitchIF::SWITCH_OFF);
+				powerSwitcher->sendSwitchCommand(switch1,
+						PowerSwitchIF::SWITCH_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_PASSIVE:
+		break;
+	case STATE_WAIT_FOR_SWITCHES_ON:
+		if (switchCountdown.hasTimedOut()) {
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_OFF)
+					|| (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_OFF)) {
+				triggerEvent(HEATER_STAYED_OFF);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_ON);
+				internalState = STATE_ON;
+			}
+		}
+		break;
+	case STATE_WAIT_FOR_SWITCHES_OFF:
+		if (switchCountdown.hasTimedOut()) {
+			//only check for both being on (ie heater still on)
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_ON)
+					&& (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_ON)) {
+				if (healthHelper.healthTable->isFaulty(getObjectId())) {
+					if (passive) {
+						internalState = STATE_PASSIVE;
+					} else {
+						internalState = STATE_OFF; //just accept it
+					}
+					triggerEvent(HEATER_ON); //but throw an event to make it more visible
+					break;
+				}
+				triggerEvent(HEATER_STAYED_ON);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_OFF);
+				if (passive) {
+					internalState = STATE_PASSIVE;
+				} else {
+					internalState = STATE_OFF;
+				}
+			}
+		}
+		break;
+	default:
+		break;
+	}
+
+	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
+			&& (powerSwitcher->getSwitchState(switch1)
+					== PowerSwitchIF::SWITCH_ON)) {
+		if (wasOn) {
+			if (heaterOnCountdown.hasTimedOut()) {
+				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
+				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
+				//it will be ok. whatcouldpossiblygowrongâ„¢
+				if (!timedOut) {
+					triggerEvent(HEATER_TIMEOUT);
+					timedOut = true;
+				}
+			}
+		} else {
+			wasOn = true;
+			heaterOnCountdown.resetTimer();
+			timedOut = false;
+		}
+	} else {
+		wasOn = false;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::setSwitch(uint8_t number, ReturnValue_t state,
+		uint32_t* uptimeOfSwitching) {
+	if (powerSwitcher == NULL) {
+		return;
+	}
+	if (powerSwitcher->getSwitchState(number) == state) {
+		*uptimeOfSwitching = INVALID_UPTIME;
+	} else {
+		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+			powerSwitcher->sendSwitchCommand(number, state);
+			Clock::getUptime(uptimeOfSwitching);
+		} else {
+			uint32_t currentUptime;
+			Clock::getUptime(&currentUptime);
+			if (currentUptime - *uptimeOfSwitching
+					> powerSwitcher->getSwitchDelayMs()) {
+				*uptimeOfSwitching = INVALID_UPTIME;
+				if (healthHelper.healthTable->isHealthy(getObjectId())) {
+					if (state == PowerSwitchIF::SWITCH_ON) {
+						triggerEvent(HEATER_STAYED_OFF);
+					} else {
+						triggerEvent(HEATER_STAYED_ON);
+					}
+				}
+				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
+			}
+		}
+	}
+}
+
+MessageQueueId_t Heater::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Heater::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+			DeviceHandlerFailureIsolation::powerConfirmationId);
+	if (pcdu == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	pcduQueueId = pcdu->getEventReceptionQueue();
+
+	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
+			getObjectId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		parameterHelper.handleParameterMessage(&command);
+	}
+}
+
+ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != DOMAIN_ID_BASE) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(heaterOnCountdown.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleEventQueue() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == HasReturnvaluesIF::RETURN_OK;
+			result = eventQueue->receiveMessage(&event)) {
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			switch (event.getEvent()) {
+			case Fuse::FUSE_WENT_OFF:
+			case HEATER_STAYED_OFF:
+			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
+				if (healthHelper.healthTable->isCommandable(getObjectId())) {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			case PowerSwitchIF::SWITCH_WENT_OFF:
+				internalState = STATE_WAIT;
+				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
+				if (pcduQueueId != 0) {
+					eventQueue->sendMessage(pcduQueueId, &event);
+				} else {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			default:
+				return;
+			}
+			break;
+		case EventMessage::YOUR_FAULT:
+			healthHelper.setHealth(HasHealthIF::FAULTY);
+			internalState = STATE_FAULTY;
+			break;
+		case EventMessage::MY_FAULT:
+			//do nothing, we are already in STATE_WAIT and wait for a clear()
+			break;
+		default:
+			return;
+		}
+	}
+}
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 41004e03..8121a774 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
-
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/parameters/ParameterHelper.h>
-#include <framework/power/PowerSwitchIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/timemanager/Countdown.h>
-#include <stdint.h>
-//class RedundantHeater;
-
-class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
-	friend class RedundantHeater;
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
-
-	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
-	virtual ~Heater();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t set();
-	void clear(bool passive);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-	static const uint32_t INVALID_UPTIME = 0;
-
-	enum InternalState {
-		STATE_ON,
-		STATE_OFF,
-		STATE_PASSIVE,
-		STATE_WAIT_FOR_SWITCHES_ON,
-		STATE_WAIT_FOR_SWITCHES_OFF,
-		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
-		STATE_FAULTY,
-		STATE_WAIT, //used when waiting for system to recover from miniops
-		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
-	} internalState;
-
-	PowerSwitchIF *powerSwitcher;
-	MessageQueueId_t pcduQueueId;
-
-	uint8_t switch0;
-	uint8_t switch1;
-
-	bool wasOn;
-
-	bool timedOut;
-
-	bool reactedToBeingFaulty;
-
-	bool passive;
-
-	MessageQueueIF* eventQueue;
-	Countdown heaterOnCountdown;
-	Countdown switchCountdown;
-	ParameterHelper parameterHelper;
-
-	enum Action {
-		SET, CLEAR
-	} lastAction;
-
-	void doAction(Action action);
-
-	void setSwitch(uint8_t number, ReturnValue_t state,
-			uint32_t *upTimeOfSwitching);
-
-	void handleQueue();
-
-	void handleEventQueue();
-};
-
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#ifndef FRAMEWORK_THERMAL_HEATER_H_
+#define FRAMEWORK_THERMAL_HEATER_H_
+
+#include "../devicehandlers/HealthDevice.h"
+#include "../parameters/ParameterHelper.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+#include <stdint.h>
+//class RedundantHeater;
+
+class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
+	friend class RedundantHeater;
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
+	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+
+	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
+	virtual ~Heater();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t set();
+	void clear(bool passive);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+	static const uint32_t INVALID_UPTIME = 0;
+
+	enum InternalState {
+		STATE_ON,
+		STATE_OFF,
+		STATE_PASSIVE,
+		STATE_WAIT_FOR_SWITCHES_ON,
+		STATE_WAIT_FOR_SWITCHES_OFF,
+		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
+		STATE_FAULTY,
+		STATE_WAIT, //used when waiting for system to recover from miniops
+		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
+							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
+	} internalState;
+
+	PowerSwitchIF *powerSwitcher;
+	MessageQueueId_t pcduQueueId;
+
+	uint8_t switch0;
+	uint8_t switch1;
+
+	bool wasOn;
+
+	bool timedOut;
+
+	bool reactedToBeingFaulty;
+
+	bool passive;
+
+	MessageQueueIF* eventQueue;
+	Countdown heaterOnCountdown;
+	Countdown switchCountdown;
+	ParameterHelper parameterHelper;
+
+	enum Action {
+		SET, CLEAR
+	} lastAction;
+
+	void doAction(Action action);
+
+	void setSwitch(uint8_t number, ReturnValue_t state,
+			uint32_t *upTimeOfSwitching);
+
+	void handleQueue();
+
+	void handleEventQueue();
+};
+
+#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 55d402d7..4a82de07 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -1,50 +1,50 @@
-#ifndef REDUNDANTHEATER_H_
-#define REDUNDANTHEATER_H_
-
-#include <framework/thermal/Heater.h>
-
-class RedundantHeater {
-public:
-
-	struct Parameters {
-		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
-				uint8_t switch0Heater0, uint8_t switch1Heater0,
-				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
-				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
-				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
-		}
-
-		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
-				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
-		}
-
-		uint32_t objectIdHeater0;
-		uint32_t objectIdHeater1;
-		uint8_t switch0Heater0;
-		uint8_t switch1Heater0;
-		uint8_t switch0Heater1;
-		uint8_t switch1Heater1;
-	};
-
-	RedundantHeater(Parameters parameters);
-	virtual ~RedundantHeater();
-
-	void performOperation(uint8_t opCode);
-
-	void triggerHeaterEvent(Event event);
-
-	void set(bool on, bool both, bool passive = false);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-protected:
-
-	Heater heater0;
-	Heater heater1;
-
-};
-
-#endif /* REDUNDANTHEATER_H_ */
-
+#ifndef REDUNDANTHEATER_H_
+#define REDUNDANTHEATER_H_
+
+#include "../thermal/Heater.h"
+
+class RedundantHeater {
+public:
+
+	struct Parameters {
+		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
+				uint8_t switch0Heater0, uint8_t switch1Heater0,
+				uint8_t switch0Heater1, uint8_t switch1Heater1) :
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
+		}
+
+		Parameters() :
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
+		}
+
+		uint32_t objectIdHeater0;
+		uint32_t objectIdHeater1;
+		uint8_t switch0Heater0;
+		uint8_t switch1Heater0;
+		uint8_t switch0Heater1;
+		uint8_t switch1Heater1;
+	};
+
+	RedundantHeater(Parameters parameters);
+	virtual ~RedundantHeater();
+
+	void performOperation(uint8_t opCode);
+
+	void triggerHeaterEvent(Event event);
+
+	void set(bool on, bool both, bool passive = false);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+protected:
+
+	Heater heater0;
+	Heater heater1;
+
+};
+
+#endif /* REDUNDANTHEATER_H_ */
+
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 27885b8b..cf2dffd4 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,222 +1,222 @@
-#ifndef TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
-
-#include <framework/thermal/AbstractTemperatureSensor.h>
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/monitoring/LimitMonitor.h>
-
-/**
- * @brief 	This building block handles non-linear value conversion and
- * 			range checks for analog temperature sensors.
- * @details This class can be used to perform all necessary tasks for temperature sensors.
- *          A sensor can be instantiated by calling the constructor.
- *          The temperature is calculated from an input value with
- *			the calculateOutputTemperature() function. Range checking and
- *			limit monitoring is performed automatically.
- *			The inputType specifies the type of the raw input while the
- *			limitType specifies the type of the upper and lower limit to check against.
- * @ingroup thermal
- */
-
-template<typename inputType, typename limitType = inputType>
-class TemperatureSensor: public AbstractTemperatureSensor {
-public:
-	/**
-	 * This structure contains parameters required for range checking
-	 * and the conversion from the input value to the output temperature.
-	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, depending on the formula used.
-	 *
-	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
-	 *
-	 * The lower and upper limits can be specified in any type, for example float for C values
-	 * or any other type for raw values.
-	 */
-	struct Parameters {
-		float a;
-		float b;
-		float c;
-		limitType lowerLimit;
-		limitType upperLimit;
-		float maxGradient;
-	};
-
-	/**
-	 * Forward declaration for explicit instantiation of used parameters.
-	 */
-	struct UsedParameters {
-		UsedParameters(Parameters parameters) :
-			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.maxGradient) {}
-		float a;
-		float b;
-		float c;
-		float gradient;
-	};
-
-	/**
-	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid objectId of the sensor object
-	 * @param inputValue Input value which is converted to a temperature
-	 * @param poolVariable Pool Variable to store the temperature value
-	 * @param vectorIndex Vector Index for the sensor monitor
-	 * @param parameters Calculation parameters, temperature limits, gradient limit
-	 * @param datapoolId Datapool ID of the output temperature
-	 * @param outputSet Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(poolVariable),
-			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
-
-protected:
-	/**
-	 * This formula is used to calculate the temperature from an input value
-	 * with an arbitrary type.
-	 * A default implementation is provided but can be replaced depending
-	 * on the required calculation.
-	 * @param inputTemperature
-	 * @return
-	 */
-	virtual float calculateOutputTemperature(inputType inputValue) {
-		return parameters.a * inputValue * inputValue
-				+ parameters.b * inputValue + parameters.c;
-	}
-
-
-private:
-	void setInvalid() {
-		outputTemperature = INVALID_TEMPERATURE;
-		outputTemperature.setValid(false);
-		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
-	}
-protected:
-	static const int32_t INVALID_UPTIME = 0;
-
-	UsedParameters parameters;
-
-	inputType * inputValue;
-
-	PoolVariableIF *poolVariable;
-
-	gp_float_t outputTemperature;
-
-	LimitMonitor<limitType> sensorMonitor;
-
-	float oldTemperature;
-	timeval uptimeOfOldTemperature;
-
-	void doChildOperation() {
-		if (!poolVariable->isValid()
-				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
-			setInvalid();
-			return;
-		}
-
-		outputTemperature = calculateOutputTemperature(*inputValue);
-		outputTemperature.setValid(PoolVariableIF::VALID);
-
-		timeval uptime;
-		Clock::getUptime(&uptime);
-
-		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
-			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient in DP and quite some overhead.
-			//The concept of delta limits is a bit strange anyway.
-			float deltaTime;
-			float deltaTemp;
-
-			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
-					- (uptimeOfOldTemperature.tv_sec
-							+ uptimeOfOldTemperature.tv_usec / 1000000.);
-			deltaTemp = oldTemperature - outputTemperature;
-			if (deltaTemp < 0) {
-				deltaTemp = -deltaTemp;
-			}
-			if (parameters.gradient < deltaTemp / deltaTime) {
-				triggerEvent(TEMP_SENSOR_GRADIENT);
-				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
-			}
-		}
-
-		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
-		sensorMonitor.doCheck(outputTemperature.value);
-
-		if (sensorMonitor.isOutOfLimits()) {
-			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-			outputTemperature.setValid(PoolVariableIF::INVALID);
-			outputTemperature = INVALID_TEMPERATURE;
-		} else {
-			oldTemperature = outputTemperature;
-			uptimeOfOldTemperature = uptime;
-		}
-	}
-
-public:
-	float getTemperature() {
-		return outputTemperature;
-	}
-
-	bool isValid() {
-		return outputTemperature.isValid();
-	}
-
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
-
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
-
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
-				parameterWrapper, newValues, startAtIndex);
-		if (result != INVALID_DOMAIN_ID) {
-			return result;
-		}
-		if (domainId != this->DOMAIN_ID_BASE) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case ADDRESS_A:
-			parameterWrapper->set(parameters.a);
-			break;
-		case ADDRESS_B:
-			parameterWrapper->set(parameters.b);
-			break;
-		case ADDRESS_C:
-			parameterWrapper->set(parameters.c);
-			break;
-		case ADDRESS_GRADIENT:
-			parameterWrapper->set(parameters.gradient);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
-	}
-
-};
-
-#endif /* TEMPERATURESENSOR_H_ */
+#ifndef TEMPERATURESENSOR_H_
+#define TEMPERATURESENSOR_H_
+
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../monitoring/LimitMonitor.h"
+
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
+class TemperatureSensor: public AbstractTemperatureSensor {
+public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
+	struct Parameters {
+		float a;
+		float b;
+		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
+		float maxGradient;
+	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
+	struct UsedParameters {
+		UsedParameters(Parameters parameters) :
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.maxGradient) {}
+		float a;
+		float b;
+		float c;
+		float gradient;
+	};
+
+	/**
+	 * Instantiate Temperature Sensor Object.
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
+
+
+private:
+	void setInvalid() {
+		outputTemperature = INVALID_TEMPERATURE;
+		outputTemperature.setValid(false);
+		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+		sensorMonitor.setToInvalid();
+	}
+protected:
+	static const int32_t INVALID_UPTIME = 0;
+
+	UsedParameters parameters;
+
+	inputType * inputValue;
+
+	PoolVariableIF *poolVariable;
+
+	gp_float_t outputTemperature;
+
+	LimitMonitor<limitType> sensorMonitor;
+
+	float oldTemperature;
+	timeval uptimeOfOldTemperature;
+
+	void doChildOperation() {
+		if (!poolVariable->isValid()
+				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
+			setInvalid();
+			return;
+		}
+
+		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature.setValid(PoolVariableIF::VALID);
+
+		timeval uptime;
+		Clock::getUptime(&uptime);
+
+		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
+			//In theory, we could use an AbsValueMonitor to monitor the gradient.
+			//But this would require storing the maxGradient in DP and quite some overhead.
+			//The concept of delta limits is a bit strange anyway.
+			float deltaTime;
+			float deltaTemp;
+
+			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
+					- (uptimeOfOldTemperature.tv_sec
+							+ uptimeOfOldTemperature.tv_usec / 1000000.);
+			deltaTemp = oldTemperature - outputTemperature;
+			if (deltaTemp < 0) {
+				deltaTemp = -deltaTemp;
+			}
+			if (parameters.gradient < deltaTemp / deltaTime) {
+				triggerEvent(TEMP_SENSOR_GRADIENT);
+				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+			}
+		}
+
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		sensorMonitor.doCheck(outputTemperature.value);
+
+		if (sensorMonitor.isOutOfLimits()) {
+			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+			outputTemperature.setValid(PoolVariableIF::INVALID);
+			outputTemperature = INVALID_TEMPERATURE;
+		} else {
+			oldTemperature = outputTemperature;
+			uptimeOfOldTemperature = uptime;
+		}
+	}
+
+public:
+	float getTemperature() {
+		return outputTemperature;
+	}
+
+	bool isValid() {
+		return outputTemperature.isValid();
+	}
+
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+				parameterWrapper, newValues, startAtIndex);
+		if (result != INVALID_DOMAIN_ID) {
+			return result;
+		}
+		if (domainId != this->DOMAIN_ID_BASE) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case ADDRESS_A:
+			parameterWrapper->set(parameters.a);
+			break;
+		case ADDRESS_B:
+			parameterWrapper->set(parameters.b);
+			break;
+		case ADDRESS_C:
+			parameterWrapper->set(parameters.c);
+			break;
+		case ADDRESS_GRADIENT:
+			parameterWrapper->set(parameters.gradient);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	virtual void resetOldState() {
+		sensorMonitor.setToUnchecked();
+	}
+
+};
+
+#endif /* TEMPERATURESENSOR_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index ad8dbd0a..f5f49ba1 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -1,114 +1,114 @@
-#ifndef THERMALCOMPONENTIF_H_
-#define THERMALCOMPONENTIF_H_
-
-#include <framework/events/Event.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-
-class ThermalComponentIF : public HasParametersIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
-	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
-
-	enum State {
-		OUT_OF_RANGE_LOW = -2,
-		NON_OPERATIONAL_LOW = -1,
-		OPERATIONAL = 0,
-		NON_OPERATIONAL_HIGH = 1,
-		OUT_OF_RANGE_HIGH = 2,
-		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
-		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
-		OPERATIONAL_IGNORED = OPERATIONAL + 10,
-		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
-		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
-		UNKNOWN = 20
-	};
-
-	enum StateRequest {
-		STATE_REQUEST_HEATING = 4,
-		STATE_REQUEST_IGNORE = 3,
-		STATE_REQUEST_OPERATIONAL = 1,
-		STATE_REQUEST_NON_OPERATIONAL = 0
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum Priority {
-		SAFE = 0,             //!< SAFE
-		IDLE,                 //!< IDLE
-		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
-	};
-
-	virtual ~ThermalComponentIF() {
-
-	}
-
-	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
-
-	virtual object_id_t getObjectId() = 0;
-
-	virtual uint8_t getDomainId() const = 0;
-
-	virtual void markStateIgnored() = 0;
-
-	virtual float getLowerOpLimit() = 0;
-
-	virtual ReturnValue_t setTargetState(int8_t state) = 0;
-
-	virtual void setOutputInvalid() = 0;
-
-	static bool isOperational(int8_t state) {
-		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
-	}
-
-	static bool isOutOfRange(State state) {
-		return ((state == OUT_OF_RANGE_HIGH)
-				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
-				|| (state == OUT_OF_RANGE_LOW)
-				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
-	}
-
-	static bool isNonOperational(State state) {
-		return !isOutOfRange(state);
-	}
-
-	static bool isIgnoredState(State state) {
-		switch (state) {
-		case OUT_OF_RANGE_LOW_IGNORED:
-		case OUT_OF_RANGE_HIGH_IGNORED:
-		case NON_OPERATIONAL_LOW_IGNORED:
-		case NON_OPERATIONAL_HIGH_IGNORED:
-		case OPERATIONAL_IGNORED:
-		case UNKNOWN:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-#endif /* THERMALCOMPONENTIF_H_ */
+#ifndef THERMALCOMPONENTIF_H_
+#define THERMALCOMPONENTIF_H_
+
+#include "../events/Event.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+
+class ThermalComponentIF : public HasParametersIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
+	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
+
+	enum State {
+		OUT_OF_RANGE_LOW = -2,
+		NON_OPERATIONAL_LOW = -1,
+		OPERATIONAL = 0,
+		NON_OPERATIONAL_HIGH = 1,
+		OUT_OF_RANGE_HIGH = 2,
+		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
+		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
+		OPERATIONAL_IGNORED = OPERATIONAL + 10,
+		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
+		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
+		UNKNOWN = 20
+	};
+
+	enum StateRequest {
+		STATE_REQUEST_HEATING = 4,
+		STATE_REQUEST_IGNORE = 3,
+		STATE_REQUEST_OPERATIONAL = 1,
+		STATE_REQUEST_NON_OPERATIONAL = 0
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum Priority {
+		SAFE = 0,             //!< SAFE
+		IDLE,                 //!< IDLE
+		PAYLOAD,              //!< PAYLOAD
+		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum HeaterRequest {
+		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
+		HEATER_REQUEST_ON,           //!< REQUEST_ON
+		HEATER_DONT_CARE             //!< DONT_CARE
+	};
+
+	virtual ~ThermalComponentIF() {
+
+	}
+
+	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
+
+	virtual object_id_t getObjectId() = 0;
+
+	virtual uint8_t getDomainId() const = 0;
+
+	virtual void markStateIgnored() = 0;
+
+	virtual float getLowerOpLimit() = 0;
+
+	virtual ReturnValue_t setTargetState(int8_t state) = 0;
+
+	virtual void setOutputInvalid() = 0;
+
+	static bool isOperational(int8_t state) {
+		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
+	}
+
+	static bool isOutOfRange(State state) {
+		return ((state == OUT_OF_RANGE_HIGH)
+				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
+				|| (state == OUT_OF_RANGE_LOW)
+				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
+	}
+
+	static bool isNonOperational(State state) {
+		return !isOutOfRange(state);
+	}
+
+	static bool isIgnoredState(State state) {
+		switch (state) {
+		case OUT_OF_RANGE_LOW_IGNORED:
+		case OUT_OF_RANGE_HIGH_IGNORED:
+		case NON_OPERATIONAL_LOW_IGNORED:
+		case NON_OPERATIONAL_HIGH_IGNORED:
+		case OPERATIONAL_IGNORED:
+		case UNKNOWN:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+#endif /* THERMALCOMPONENTIF_H_ */
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 9dc1f237..7ee6b96b 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,288 +1,288 @@
-#include <framework/monitoring/LimitViolationReporter.h>
-#include <framework/monitoring/MonitoringMessageContent.h>
-#include "ThermalModule.h"
-
-#include "AbstractTemperatureSensor.h"
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
-		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
-	heater = new RedundantHeater(heaterParameters);
-}
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
-}
-
-ThermalModule::~ThermalModule() {
-	delete heater;
-}
-
-void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
-		heater->performOperation(0);
-	}
-}
-
-void ThermalModule::performMode(Strategy strategy) {
-	calculateTemperature();
-
-	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
-	ThermalComponentIF::HeaterRequest componentHeaterRequest =
-			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
-
-	if (heater == NULL) {
-		informComponentsAboutHeaterState(false, NONE);
-		return;
-	}
-
-	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
-
-	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
-		//Components overwrite the module request.
-		heating = ((componentHeaterRequest
-				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
-	}
-
-	bool dual = (strategy == ACTIVE_DUAL);
-
-	if (strategy == PASSIVE) {
-		informComponentsAboutHeaterState(false, NONE);
-		if (oldStrategy != PASSIVE) {
-			heater->set(false, false, true);
-		}
-	} else {
-		if (safeOnly) {
-			informComponentsAboutHeaterState(heating, SAFE);
-		} else {
-			informComponentsAboutHeaterState(heating, ALL);
-		}
-		heater->set(heating, dual);
-	}
-	oldStrategy = strategy;
-}
-
-float ThermalModule::getTemperature() {
-	return moduleTemperature;
-}
-
-void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
-	sensors.push_back(sensor);
-}
-
-void ThermalModule::registerComponent(ThermalComponentIF* component,
-		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
-}
-
-void ThermalModule::calculateTemperature() {
-	uint32_t numberOfValidSensors = 0;
-	moduleTemperature = 0;
-	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
-	for (; iter != sensors.end(); iter++) {
-		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
-			numberOfValidSensors++;
-		}
-	}
-	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
-		moduleTemperature.setValid(PoolVariableIF::VALID);
-	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
-		moduleTemperature.setValid(PoolVariableIF::INVALID);
-	}
-}
-
-ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		if (iter->component->getObjectId() == objectId) {
-			return iter->component;
-		}
-	}
-	return NULL;
-}
-
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
-
-	survivalTargetTemp = -999;
-	targetTemp = -999;
-
-	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
-		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		updateTargetTemperatures(iter->component,
-				iter->priority == ThermalComponentIF::SAFE);
-		ThermalComponentIF::HeaterRequest request =
-				iter->component->performOperation(0);
-		iter->request = request;
-		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
-			if (request < heaterRequests[iter->priority]) {
-				heaterRequests[iter->priority] = request;
-			}
-		}
-	}
-
-	if (!safeOnly) {
-		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
-				i--) {
-			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
-				heaterRequests[i - 1] = heaterRequests[i];
-			}
-		}
-	}
-	return heaterRequests[0];
-}
-
-void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
-		Informee whomToInform) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		switch (whomToInform) {
-		case ALL:
-			break;
-		case SAFE:
-			if (!(iter->priority == ThermalComponentIF::SAFE)) {
-				iter->component->markStateIgnored();
-				continue;
-			}
-			break;
-		case NONE:
-			iter->component->markStateIgnored();
-			continue;
-		}
-
-		if (heaterIsOn) {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
-				iter->component->markStateIgnored();
-			}
-		} else {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
-				iter->component->markStateIgnored();
-			}
-		}
-	}
-}
-
-void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
-	if (heater != NULL) {
-		heater->setPowerSwitcher(powerSwitch);
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		float componentLowerOpLimit = iter->component->getLowerOpLimit();
-		if (iter->priority == ThermalComponentIF::SAFE) {
-			if (componentLowerOpLimit > survivalTargetTemp) {
-				survivalTargetTemp = componentLowerOpLimit;
-			}
-		} else {
-			if (componentLowerOpLimit > targetTemp) {
-				targetTemp = componentLowerOpLimit;
-			}
-		}
-	}
-	if (survivalTargetTemp > targetTemp) {
-		targetTemp = survivalTargetTemp;
-	}
-}
-
-bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
-		Strategy strategy) {
-	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
-		currentState = UNKNOWN;
-		return false;
-	}
-
-	float limit = targetTemp;
-	bool heaterRequest = false;
-	if (strategy == ACTIVE_SURVIVAL) {
-		limit = survivalTargetTemp;
-	}
-
-	if (moduleTemperature >= limit) {
-		currentState = OPERATIONAL;
-	} else {
-		currentState = NON_OPERATIONAL;
-	}
-
-	limit += parameters.heaterOn;
-
-	if (heating) {
-		limit += parameters.hysteresis;
-	}
-
-	if (targetState == STATE_REQUEST_HEATING) {
-		if (moduleTemperature < limit) {
-			heaterRequest = true;
-		} else {
-			heaterRequest = false;
-		}
-	}
-
-	heating = heaterRequest;
-
-	return heaterRequest;
-}
-
-void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
-}
-
-void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
-		bool isSafe) {
-	if (isSafe) {
-		if (component->getLowerOpLimit() > survivalTargetTemp) {
-			survivalTargetTemp = component->getLowerOpLimit();
-		}
-	} else {
-		if (component->getLowerOpLimit() > targetTemp) {
-			targetTemp = component->getLowerOpLimit();
-		}
-	}
-}
-
-void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
-	moduleTemperature.setValid(PoolVariableIF::INVALID);
-	currentState.setValid(PoolVariableIF::INVALID);
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		iter->component->setOutputInvalid();
-	}
-	if (heater != NULL) {
-		heater->set(false,true);
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "ThermalModule.h"
+
+#include "AbstractTemperatureSensor.h"
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
+		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
+		GlobDataSet *dataSet, Parameters parameters,
+		RedundantHeater::Parameters heaterParameters) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters(parameters), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
+				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
+				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+	heater = new RedundantHeater(heaterParameters);
+}
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters( { 0, 0 }), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
+				NULL), currentState(PoolVariableIF::INVALID, dataSet,
+				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
+				dataSet, PoolVariableIF::VAR_READ) {
+}
+
+ThermalModule::~ThermalModule() {
+	delete heater;
+}
+
+void ThermalModule::performOperation(uint8_t opCode) {
+	if (heater != NULL) {
+		heater->performOperation(0);
+	}
+}
+
+void ThermalModule::performMode(Strategy strategy) {
+	calculateTemperature();
+
+	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
+	ThermalComponentIF::HeaterRequest componentHeaterRequest =
+			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
+
+	if (heater == NULL) {
+		informComponentsAboutHeaterState(false, NONE);
+		return;
+	}
+
+	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
+
+	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
+		//Components overwrite the module request.
+		heating = ((componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_ON)
+				|| (componentHeaterRequest
+						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+	}
+
+	bool dual = (strategy == ACTIVE_DUAL);
+
+	if (strategy == PASSIVE) {
+		informComponentsAboutHeaterState(false, NONE);
+		if (oldStrategy != PASSIVE) {
+			heater->set(false, false, true);
+		}
+	} else {
+		if (safeOnly) {
+			informComponentsAboutHeaterState(heating, SAFE);
+		} else {
+			informComponentsAboutHeaterState(heating, ALL);
+		}
+		heater->set(heating, dual);
+	}
+	oldStrategy = strategy;
+}
+
+float ThermalModule::getTemperature() {
+	return moduleTemperature;
+}
+
+void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
+	sensors.push_back(sensor);
+}
+
+void ThermalModule::registerComponent(ThermalComponentIF* component,
+		ThermalComponentIF::Priority priority) {
+	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+}
+
+void ThermalModule::calculateTemperature() {
+	uint32_t numberOfValidSensors = 0;
+	moduleTemperature = 0;
+	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
+	for (; iter != sensors.end(); iter++) {
+		if ((*iter)->isValid()) {
+			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			numberOfValidSensors++;
+		}
+	}
+	if (numberOfValidSensors != 0) {
+		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature.setValid(PoolVariableIF::VALID);
+	} else {
+		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.setValid(PoolVariableIF::INVALID);
+	}
+}
+
+ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		if (iter->component->getObjectId() == objectId) {
+			return iter->component;
+		}
+	}
+	return NULL;
+}
+
+ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
+		bool safeOnly) {
+	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+
+	survivalTargetTemp = -999;
+	targetTemp = -999;
+
+	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
+		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		updateTargetTemperatures(iter->component,
+				iter->priority == ThermalComponentIF::SAFE);
+		ThermalComponentIF::HeaterRequest request =
+				iter->component->performOperation(0);
+		iter->request = request;
+		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
+			if (request < heaterRequests[iter->priority]) {
+				heaterRequests[iter->priority] = request;
+			}
+		}
+	}
+
+	if (!safeOnly) {
+		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
+				i--) {
+			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
+				heaterRequests[i - 1] = heaterRequests[i];
+			}
+		}
+	}
+	return heaterRequests[0];
+}
+
+void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
+		Informee whomToInform) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		switch (whomToInform) {
+		case ALL:
+			break;
+		case SAFE:
+			if (!(iter->priority == ThermalComponentIF::SAFE)) {
+				iter->component->markStateIgnored();
+				continue;
+			}
+			break;
+		case NONE:
+			iter->component->markStateIgnored();
+			continue;
+		}
+
+		if (heaterIsOn) {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
+				iter->component->markStateIgnored();
+			}
+		} else {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
+				iter->component->markStateIgnored();
+			}
+		}
+	}
+}
+
+void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
+	if (heater != NULL) {
+		heater->setPowerSwitcher(powerSwitch);
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		float componentLowerOpLimit = iter->component->getLowerOpLimit();
+		if (iter->priority == ThermalComponentIF::SAFE) {
+			if (componentLowerOpLimit > survivalTargetTemp) {
+				survivalTargetTemp = componentLowerOpLimit;
+			}
+		} else {
+			if (componentLowerOpLimit > targetTemp) {
+				targetTemp = componentLowerOpLimit;
+			}
+		}
+	}
+	if (survivalTargetTemp > targetTemp) {
+		targetTemp = survivalTargetTemp;
+	}
+}
+
+bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
+		Strategy strategy) {
+	currentState.setValid(PoolVariableIF::VALID);
+	if (moduleTemperature == INVALID_TEMPERATURE) {
+		currentState = UNKNOWN;
+		return false;
+	}
+
+	float limit = targetTemp;
+	bool heaterRequest = false;
+	if (strategy == ACTIVE_SURVIVAL) {
+		limit = survivalTargetTemp;
+	}
+
+	if (moduleTemperature >= limit) {
+		currentState = OPERATIONAL;
+	} else {
+		currentState = NON_OPERATIONAL;
+	}
+
+	limit += parameters.heaterOn;
+
+	if (heating) {
+		limit += parameters.hysteresis;
+	}
+
+	if (targetState == STATE_REQUEST_HEATING) {
+		if (moduleTemperature < limit) {
+			heaterRequest = true;
+		} else {
+			heaterRequest = false;
+		}
+	}
+
+	heating = heaterRequest;
+
+	return heaterRequest;
+}
+
+void ThermalModule::setHeating(bool on) {
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+			&mySet, PoolVariableIF::VAR_WRITE);
+	if (on) {
+		writableTargetState = STATE_REQUEST_HEATING;
+	} else {
+		writableTargetState = STATE_REQUEST_PASSIVE;
+	}
+	mySet.commit(PoolVariableIF::VALID);
+}
+
+void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
+		bool isSafe) {
+	if (isSafe) {
+		if (component->getLowerOpLimit() > survivalTargetTemp) {
+			survivalTargetTemp = component->getLowerOpLimit();
+		}
+	} else {
+		if (component->getLowerOpLimit() > targetTemp) {
+			targetTemp = component->getLowerOpLimit();
+		}
+	}
+}
+
+void ThermalModule::setOutputInvalid() {
+	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		iter->component->setOutputInvalid();
+	}
+	if (heater != NULL) {
+		heater->set(false,true);
+	}
+}
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 21414f15..46692640 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,95 +1,95 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
-
-#include <framework/datapoolglob/GlobalDataSet.h>
-#include <framework/datapoolglob/GlobalPoolVariable.h>
-#include <framework/devicehandlers/HealthDevice.h>
-#include <framework/events/EventReportingProxyIF.h>
-#include "ThermalModuleIF.h"
-#include <list>
-#include "tcsDefinitions.h"
-#include "RedundantHeater.h"
-class PowerSwitchIF;
-
-/**
- * @brief Allows creation of different thermal control domains within a system.
- */
-class ThermalModule: public ThermalModuleIF {
-	friend class ThermalController;
-public:
-	struct Parameters {
-		float heaterOn;
-		float hysteresis;
-	};
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
-
-	virtual ~ThermalModule();
-
-	void performOperation(uint8_t opCode);
-
-	void performMode(Strategy strategy);
-
-	float getTemperature();
-
-	void registerSensor(AbstractTemperatureSensor *sensor);
-
-	void registerComponent(ThermalComponentIF *component,
-			ThermalComponentIF::Priority priority);
-
-	ThermalComponentIF *findComponent(object_id_t objectId);
-
-	void initialize(PowerSwitchIF* powerSwitch);
-
-	void setHeating(bool on);
-
-	virtual void setOutputInvalid();
-
-protected:
-	enum Informee {
-		ALL, SAFE, NONE
-	};
-
-	struct ComponentData {
-		ThermalComponentIF *component;
-		ThermalComponentIF::Priority priority;
-		ThermalComponentIF::HeaterRequest request;
-	};
-
-	Strategy oldStrategy;
-
-	float survivalTargetTemp;
-
-	float targetTemp;
-
-	bool heating;
-
-	Parameters parameters;
-
-	gp_float_t moduleTemperature;
-
-	RedundantHeater *heater;
-
-	gp_int8_t currentState;
-	gp_int8_t targetState;
-
-	std::list<AbstractTemperatureSensor *> sensors;
-	std::list<ComponentData> components;
-
-	void calculateTemperature();
-
-	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
-
-	void informComponentsAboutHeaterState(bool heaterIsOn,
-			Informee whomToInform);
-
-	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
-
-	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
-};
-
-#endif /* THERMALMODULE_H_ */
+#ifndef THERMALMODULE_H_
+#define THERMALMODULE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+#include "ThermalModuleIF.h"
+#include <list>
+#include "tcsDefinitions.h"
+#include "RedundantHeater.h"
+class PowerSwitchIF;
+
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
+class ThermalModule: public ThermalModuleIF {
+	friend class ThermalController;
+public:
+	struct Parameters {
+		float heaterOn;
+		float hysteresis;
+	};
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
+			RedundantHeater::Parameters heaterParameters);
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+
+	virtual ~ThermalModule();
+
+	void performOperation(uint8_t opCode);
+
+	void performMode(Strategy strategy);
+
+	float getTemperature();
+
+	void registerSensor(AbstractTemperatureSensor *sensor);
+
+	void registerComponent(ThermalComponentIF *component,
+			ThermalComponentIF::Priority priority);
+
+	ThermalComponentIF *findComponent(object_id_t objectId);
+
+	void initialize(PowerSwitchIF* powerSwitch);
+
+	void setHeating(bool on);
+
+	virtual void setOutputInvalid();
+
+protected:
+	enum Informee {
+		ALL, SAFE, NONE
+	};
+
+	struct ComponentData {
+		ThermalComponentIF *component;
+		ThermalComponentIF::Priority priority;
+		ThermalComponentIF::HeaterRequest request;
+	};
+
+	Strategy oldStrategy;
+
+	float survivalTargetTemp;
+
+	float targetTemp;
+
+	bool heating;
+
+	Parameters parameters;
+
+	gp_float_t moduleTemperature;
+
+	RedundantHeater *heater;
+
+	gp_int8_t currentState;
+	gp_int8_t targetState;
+
+	std::list<AbstractTemperatureSensor *> sensors;
+	std::list<ComponentData> components;
+
+	void calculateTemperature();
+
+	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
+
+	void informComponentsAboutHeaterState(bool heaterIsOn,
+			Informee whomToInform);
+
+	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
+
+	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
+};
+
+#endif /* THERMALMODULE_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp
index 773fa084..af0413bf 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitor.cpp
@@ -1,68 +1,68 @@
-#include <framework/thermal/ThermalMonitor.h>
-#include <framework/thermal/ThermalComponentIF.h>
-#include <framework/monitoring/MonitoringIF.h>
-ThermalMonitor::~ThermalMonitor() {
-}
-
-void ThermalMonitor::sendTransitionEvent(float currentValue,
-		ReturnValue_t state) {
-	switch (state) {
-	case MonitoringIF::BELOW_LOW_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
-		break;
-	case MonitoringIF::ABOVE_HIGH_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
-		break;
-	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
-		break;
-	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
-		break;
-	default:
-		break;
-	}
-}
-
-bool ThermalMonitor::isAboveHighLimit() {
-	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
-		float upperLimit, bool componentIsOperational) {
-	if (ThermalComponentIF::isIgnoredState(state)) {
-		setToUnchecked();
-		return MonitoringIF::UNCHECKED;
-	}
-	switch (state) {
-	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
-	case ThermalComponentIF::NON_OPERATIONAL_LOW:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OPERATIONAL:
-		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
-	default:
-		//Never reached, all states covered.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "../thermal/ThermalMonitor.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../monitoring/MonitoringIF.h"
+ThermalMonitor::~ThermalMonitor() {
+}
+
+void ThermalMonitor::sendTransitionEvent(float currentValue,
+		ReturnValue_t state) {
+	switch (state) {
+	case MonitoringIF::BELOW_LOW_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
+		break;
+	case MonitoringIF::ABOVE_HIGH_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
+		break;
+	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
+		break;
+	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
+		break;
+	default:
+		break;
+	}
+}
+
+bool ThermalMonitor::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+		float upperLimit, bool componentIsOperational) {
+	if (ThermalComponentIF::isIgnoredState(state)) {
+		setToUnchecked();
+		return MonitoringIF::UNCHECKED;
+	}
+	switch (state) {
+	case ThermalComponentIF::OUT_OF_RANGE_LOW:
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+	case ThermalComponentIF::NON_OPERATIONAL_LOW:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OPERATIONAL:
+		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+	default:
+		//Never reached, all states covered.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index a38889d0..69528600 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -1,26 +1,26 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include <framework/monitoring/MonitorReporter.h>
-#include <framework/thermal/ThermalComponentIF.h>
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
+#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
+#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
+
+#include "../monitoring/MonitorReporter.h"
+#include "../thermal/ThermalComponentIF.h"
+
+/**
+ * What does it do. How to use it.
+ */
+class ThermalMonitor: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitor(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitor();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit, bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 71b2539d..e073ad86 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,602 +1,602 @@
-#include <framework/timemanager/CCSDSTime.h>
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
-
-CCSDSTime::CCSDSTime() {
-}
-
-CCSDSTime::~CCSDSTime() {
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4);
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4) + 2;
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
-
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		uint32_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
-
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
-
-	*foundLength = totalLength;
-
-	ReturnValue_t result = checkCcs(from, maxLength);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
-
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
-
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	to->month = temp->month;
-	to->day = temp->day;
-
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
-
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
-#else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-    //try Code A (yyyy-mm-dd)
-    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
-            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
-            &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-    //try Code B (yyyy-ddd)
-    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
-            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-#endif
-
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
-
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	uint8_t *additionalByte = &time_struct->secondEminus2;
-
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
-
-		if (*month == 8) {
-			continue;
-		}
-
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
-}
-
-bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
-
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
-
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
-
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
-}
-
-uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
-
-}
+#include "../timemanager/CCSDSTime.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <math.h>
+
+CCSDSTime::CCSDSTime() {
+}
+
+CCSDSTime::~CCSDSTime() {
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4);
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4) + 2;
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+	to->secondEminus2 = from->usecond / 10000;
+	to->secondEminus4 = (from->usecond % 10000) / 100;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t length) {
+	ReturnValue_t result;
+	if (length > 0xFF) {
+		return LENGTH_MISMATCH;
+	}
+	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+	if (result == RETURN_OK) {
+		return RETURN_OK;
+	}
+
+	//Seems to be no ascii, try the other formats
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+		return convertFromCUC(to, from, length);
+	case CDS:
+		return convertFromCDS(to, from, length);
+	case CCS: {
+		uint32_t temp = 0;
+		return convertFromCCS(to, from, &temp, length);
+	}
+
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	timeval time;
+	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return convertTimevalToTimeOfDay(to, &time);
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t subsecondsLength = *from & 0b111;
+	uint32_t totalLength = subsecondsLength + 8;
+	if (maxLength < totalLength) {
+		return LENGTH_MISMATCH;
+	}
+
+	*foundLength = totalLength;
+
+	ReturnValue_t result = checkCcs(from, maxLength);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+
+	to->year = (temp->yearMSB << 8) + temp->yearLSB;
+	to->hour = temp->hour;
+	to->minute = temp->minute;
+	to->second = temp->second;
+
+	if (temp->pField & (1 << 3)) { //day of year variation
+		uint16_t tempDay = (temp->month << 8) + temp->day;
+		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
+				&(temp->month), &(temp->day));
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	to->month = temp->month;
+	to->day = temp->day;
+
+	to->usecond = 0;
+	if (subsecondsLength > 0) {
+		*foundLength += 1;
+		if (temp->secondEminus2 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond = temp->secondEminus2 * 10000;
+	}
+
+	if (subsecondsLength > 1) {
+		*foundLength += 1;
+		if (temp->secondEminus4 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond += temp->secondEminus4 * 100;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	if (length < 19) {
+		return RETURN_FAILED;
+	}
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
+
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
+	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+
+	uint8_t additionalBytes = time_struct->pField & 0b111;
+	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time_struct->pField & (1 << 3)) { //day of year variation
+		uint16_t day = (time_struct->month << 8) + time_struct->day;
+		if (day > 366) {
+			return INVALID_TIME_FORMAT;
+		}
+	} else {
+		if (time_struct->month > 12) {
+			return INVALID_TIME_FORMAT;
+		}
+		if (time_struct->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	if (time_struct->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	uint8_t *additionalByte = &time_struct->secondEminus2;
+
+	for (; additionalBytes != 0; additionalBytes--) {
+		if (*additionalByte++ > 99) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+		uint8_t* month, uint8_t* day) {
+	if (isLeapYear(year)) {
+		if (dayofYear > 366) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	} else {
+		if (dayofYear > 365) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	}
+	*month = 1;
+	if (dayofYear <= 31) {
+		*day = dayofYear;
+		return RETURN_OK;
+	}
+	*month += 1;
+	dayofYear -= 31;
+	if (isLeapYear(year)) {
+		if (dayofYear <= 29) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 29;
+	} else {
+		if (dayofYear <= 28) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 28;
+	}
+	while (*month <= 12) {
+		if (dayofYear <= 31) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 31;
+
+		if (*month == 8) {
+			continue;
+		}
+
+		if (dayofYear <= 30) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 30;
+	}
+	return INVALID_DAY_OF_YEAR;
+}
+
+bool CCSDSTime::isLeapYear(uint32_t year) {
+	if ((year % 400) == 0) {
+		return true;
+	}
+	if ((year % 100) == 0) {
+		return false;
+	}
+	if ((year % 4) == 0) {
+		return true;
+	}
+	return false;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
+	to->pField = (CDS << 4) + 0;
+	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			+ DAYS_CCSDS_TO_UNIX_EPOCH;
+	if (days > (1 << 16)) {
+		//Date is beyond year 2137
+		return TIME_DOES_NOT_FIT_FORMAT;
+	}
+	to->dayMSB = (days & 0xFF00) >> 8;
+	to->dayLSB = (days & 0xFF);
+	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			+ (from->tv_usec / 1000);
+	to->msDay_hh = (msDay & 0xFF000000) >> 24;
+	to->msDay_h = (msDay & 0xFF0000) >> 16;
+	to->msDay_l = (msDay & 0xFF00) >> 8;
+	to->msDay_ll = (msDay & 0xFF);
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
+	to->pFiled = (AGENCY_DEFINED << 4) + 5;
+	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+	to->seconds_h = (from->tv_sec >> 16) & 0xff;
+	to->seconds_l = (from->tv_sec >> 8) & 0xff;
+	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+
+	//convert the µs to 2E-16 seconds
+	uint64_t temp = from->tv_usec;
+	temp = temp << 16;
+	temp = temp / 1E6;
+
+	to->subsecondsMSB = (temp >> 8) & 0xff;
+	to->subsecondsLSB = temp & 0xff;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	//We don't expect ascii here. SHOULDDO
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	//unsupported, as Leap second correction would have to be applied
+//	case CUC_LEVEL1:
+//		return convertFromCUC(to, from, foundLength, maxLength);
+	case CDS:
+		return convertFromCDS(to, from, foundLength, maxLength);
+	case CCS:
+		return convertFromCCS(to, from, foundLength, maxLength);
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	if (maxLength < 1) {
+		return INVALID_TIME_FORMAT;
+	}
+	uint8_t pField = *from;
+	from++;
+	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+			maxLength - 1);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		if (foundLength != NULL) {
+			*foundLength += 1;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+	if ((time->month > 12) || (time->month == 0)) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->day == 0) {
+		return INVALID_TIME_FORMAT;
+	}
+	switch (time->month) {
+	case 2:
+		if (isLeapYear(time->year)) {
+			if (time->day > 29) {
+				return INVALID_TIME_FORMAT;
+			}
+		} else {
+			if (time->day > 28) {
+				return INVALID_TIME_FORMAT;
+			}
+		}
+		break;
+	case 4:
+	case 6:
+	case 9:
+	case 11:
+		if (time->day > 30) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	default:
+		if (time->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	}
+
+	if (time->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->usecond > 999999) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+		timeval* from) {
+//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t pField = *from;
+	from++;
+//Check epoch
+	if (pField & 0b1000) {
+		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+	}
+//Check length
+	uint8_t expectedLength = 7; //Including p-Field.
+	bool extendedDays = pField & 0b100;
+	if (extendedDays) {
+		expectedLength += 1;
+	}
+	if ((pField & 0b11) == 0b01) {
+		expectedLength += 2;
+	} else if ((pField & 0b11) == 0b10) {
+		expectedLength += 4;
+	}
+	if (foundLength != NULL) {
+		*foundLength = expectedLength;
+	}
+	if (expectedLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+//Check and count days
+	uint32_t days = 0;
+	if (extendedDays) {
+		days = (from[0] << 16) + (from[1] << 8) + from[2];
+		from += 3;
+	} else {
+		days = (from[0] << 8) + from[1];
+		from += 2;
+	}
+//Move to POSIX epoch.
+	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+		return INVALID_TIME_FORMAT;
+	}
+	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+	to->tv_sec = days * SECONDS_PER_DAY;
+	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			+ from[3];
+	from += 4;
+	to->tv_sec += (msDay / 1000);
+	to->tv_usec = (msDay % 1000) * 1000;
+	if ((pField & 0b11) == 0b01) {
+		uint16_t usecs = (from[0] << 16) + from[1];
+		from += 2;
+		if (usecs > 999) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->tv_usec += usecs;
+	} else if ((pField & 0b11) == 0b10) {
+		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				+ from[3];
+		from += 4;
+		if (picosecs > 999999) {
+			return INVALID_TIME_FORMAT;
+		}
+		//Not very useful.
+		to->tv_usec += (picosecs / 1000);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
+		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+	uint32_t secs = 0;
+	uint32_t subSeconds = 0;
+	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+	uint8_t nFine = (pField & 0b11);
+	uint32_t totalLength = nCoarse + nFine;
+	if (foundLength != NULL) {
+		*foundLength = totalLength;
+	}
+	if (totalLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	for (int count = 0; count < nCoarse; count++) {
+		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+		from++;
+	}
+	for (int count = 0; count < nFine; count++) {
+		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+		from++;
+	}
+	//Move to POSIX epoch.
+	to->tv_sec = secs;
+	if (pField & 0b10000) {
+		//CCSDS-Epoch
+		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+	}
+	to->tv_usec = subsecondsToMicroseconds(subSeconds);
+	return RETURN_OK;
+}
+
+uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
+	uint64_t temp = (uint64_t) subseconds * 1000000
+			/ (1 << (sizeof(subseconds) * 8));
+	return temp;
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	Clock::TimeOfDay_t tempTime;
+	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+			maxLength);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+
+}
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 92060d5d..6bb3a75c 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,233 +1,233 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
-
-// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
-
-#include <framework/timemanager/Clock.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <stdint.h>
-
-bool operator<(const timeval& lhs, const timeval& rhs);
-bool operator<=(const timeval& lhs, const timeval& rhs);
-bool operator==(const timeval& lhs, const timeval& rhs);
-/**
- * static helper class for CCSDS Time Code Formats
- *
- * as described in CCSDS 301.0-B-3
- *
- * Still work in progress
- */
-class CCSDSTime: public HasReturnvaluesIF {
-public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
-
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
-
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
-
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
-
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
-
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
-
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
-
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
-private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
-
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
-
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
-
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
-};
-
-#endif /* CCSDSTIME_H_ */
+#ifndef CCSDSTIME_H_
+#define CCSDSTIME_H_
+
+// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
+
+#include "../timemanager/Clock.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+bool operator<(const timeval& lhs, const timeval& rhs);
+bool operator<=(const timeval& lhs, const timeval& rhs);
+bool operator==(const timeval& lhs, const timeval& rhs);
+/**
+ * static helper class for CCSDS Time Code Formats
+ *
+ * as described in CCSDS 301.0-B-3
+ *
+ * Still work in progress
+ */
+class CCSDSTime: public HasReturnvaluesIF {
+public:
+	/**
+	 * The Time code identifications, bits 4-6 in the P-Field
+	 */
+	enum TimeCodeIdentification {
+		CCS = 0b101,
+		CUC_LEVEL1 = 0b001,
+		CUC_LEVEL2 = 0b010,
+		CDS = 0b100,
+		AGENCY_DEFINED = 0b110
+	};
+	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+	/**
+	 * Struct for CDS day-segmented format.
+	 */
+	struct CDS_short {
+		uint8_t pField;
+		uint8_t dayMSB;
+		uint8_t dayLSB;
+		uint8_t msDay_hh;
+		uint8_t msDay_h;
+		uint8_t msDay_l;
+		uint8_t msDay_ll;
+	};
+	/**
+	 * Struct for the CCS fromat in day of month variation with max resolution
+	 */
+	struct Ccs_seconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+	};
+
+	/**
+	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+	 */
+	struct Ccs_mseconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+		uint8_t secondEminus2;
+		uint8_t secondEminus4;
+	};
+
+	struct OBT_FLP {
+		uint8_t pFiled;
+		uint8_t seconds_hh;
+		uint8_t seconds_h;
+		uint8_t seconds_l;
+		uint8_t seconds_ll;
+		uint8_t subsecondsMSB;
+		uint8_t subsecondsLSB;
+	};
+
+	struct TimevalLess {
+		bool operator()(const timeval& lhs, const timeval& rhs) const {
+			return (lhs < rhs);
+		}
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+			MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+
+	/**
+	 * convert a TimeofDay struct to ccs with seconds resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * Converts to CDS format from timeval.
+	 * @param to pointer to the CDS struct to generate
+	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid timeval.
+	 */
+	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+
+	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+
+	/**
+	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+	 *
+	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * SHOULDDO: can this be modified to recognize padding?
+	 * Tries to interpret a Level 1 CCSDS time code
+	 *
+	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+	 * by the lack of one.
+	 *
+	 * @param to an empty TimeOfDay struct
+	 * @param from pointer to an CCSDS Time code
+	 * @param length length of the Time code
+	 * @return
+	 * 		- @c RETURN_OK if successful
+	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+	 */
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t length);
+
+	/**
+	 * not implemented yet
+	 *
+	 * @param to
+	 * @param from
+	 * @return
+	 */
+	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+private:
+	CCSDSTime();
+	virtual ~CCSDSTime();
+	/**
+	 * checks a ccs time stream for validity
+	 *
+	 * Stream may be longer than the actual timecode
+	 *
+	 * @param time pointer to an Ccs stream
+	 * @param length length of stream
+	 * @return
+	 */
+	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+
+	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+			* SECONDS_PER_DAY;
+	/**
+	 * @param dayofYear
+	 * @param year
+	 * @param month
+	 * @param day
+	 */
+	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+			uint8_t *month, uint8_t *day);
+
+	static bool isLeapYear(uint32_t year);
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+			timeval* from);
+};
+
+#endif /* CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 65e152bf..c7436252 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/ipc/MutexFactory.h>
-#include <framework/globalfunctions/timevalOperations.h>
-
-#include <cstdint>
-#include <sys/time.h>
-
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
-
-class Clock {
-public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
-
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
-
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
-
-	static timeval getUptime();
-
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
-
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
-
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
-
-	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
-
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
-
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
-
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
-
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
-
-private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
-};
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../globalfunctions/timevalOperations.h"
+
+#include <cstdint>
+#include <sys/time.h>
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
+
+class Clock {
+public:
+	typedef struct {
+	  uint32_t year; //!< Year, A.D.
+	  uint32_t month; //!< Month, 1 .. 12.
+	  uint32_t day; //!< Day, 1 .. 31.
+	  uint32_t hour; //!< Hour, 0 .. 23.
+	  uint32_t minute; //!< Minute, 0 .. 59.
+	  uint32_t second; //!< Second, 0 .. 59.
+	  uint32_t usecond; //!< Microseconds, 0 .. 999999
+	}   TimeOfDay_t;
+
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
+
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
+
+	static timeval getUptime();
+
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
+
+	/**
+	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return \c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
+
+private:
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
+};
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index e6565914..5b019f2b 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,45 +1,45 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-
-#include <framework/timemanager/Countdown.h>
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
-}
-
-Countdown::~Countdown() {
-}
-
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
-	timeout = miliseconds;
-	return return_value;
-}
-
-bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-bool Countdown::isBusy() const {
-	return !hasTimedOut();
-}
-
-ReturnValue_t Countdown::resetTimer() {
-	return setTimeout(timeout);
-}
-
-void Countdown::timeOut() {
-	uint32_t current_time;
-		Clock::getUptime( &current_time );
-	startTime= current_time - timeout;
-}
+/**
+ * @file	Countdown.cpp
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+
+#include "../timemanager/Countdown.h"
+
+Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+}
+
+Countdown::~Countdown() {
+}
+
+ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+	ReturnValue_t return_value = Clock::getUptime( &startTime );
+	timeout = miliseconds;
+	return return_value;
+}
+
+bool Countdown::hasTimedOut() const {
+	uint32_t current_time;
+	Clock::getUptime( &current_time );
+	if ( uint32_t(current_time - startTime) >= timeout) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Countdown::isBusy() const {
+	return !hasTimedOut();
+}
+
+ReturnValue_t Countdown::resetTimer() {
+	return setTimeout(timeout);
+}
+
+void Countdown::timeOut() {
+	uint32_t current_time;
+		Clock::getUptime( &current_time );
+	startTime= current_time - timeout;
+}
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 57a11f91..741ab0f8 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,31 +1,31 @@
-/**
- * @file	Countdown.h
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include <framework/timemanager/Clock.h>
-
-class Countdown {
-private:
-	uint32_t startTime;
-public:
-	uint32_t timeout;
-	Countdown(uint32_t initialTimeout = 0);
-	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
-
-	bool hasTimedOut() const;
-
-	bool isBusy() const;
-
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
-
-	void timeOut(); //!< Make hasTimedOut() return true
-};
-
-#endif /* COUNTDOWN_H_ */
+/**
+ * @file	Countdown.h
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+#ifndef COUNTDOWN_H_
+#define COUNTDOWN_H_
+
+#include "../timemanager/Clock.h"
+
+class Countdown {
+private:
+	uint32_t startTime;
+public:
+	uint32_t timeout;
+	Countdown(uint32_t initialTimeout = 0);
+	~Countdown();
+	ReturnValue_t setTimeout(uint32_t miliseconds);
+
+	bool hasTimedOut() const;
+
+	bool isBusy() const;
+
+	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+
+	void timeOut(); //!< Make hasTimedOut() return true
+};
+
+#endif /* COUNTDOWN_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index f65f9dad..09915e83 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,32 +1,32 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * This is a Interface for classes that receive timing information
- * with the help of a dedicated message queue.
- */
-class ReceivesTimeInfoIF {
-public:
-	/**
-	 * Returns the id of the queue which receives the timing information.
-	 * @return Queue id of the timing queue.
-	 */
-	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~ReceivesTimeInfoIF() {
-	}
-
-};
-
-
-#endif /* RECEIVESTIMEINFOIF_H_ */
+/**
+ * @file	ReceivesTimeInfoIF.h
+ * @brief	This file defines the ReceivesTimeInfoIF class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef RECEIVESTIMEINFOIF_H_
+#define RECEIVESTIMEINFOIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This is a Interface for classes that receive timing information
+ * with the help of a dedicated message queue.
+ */
+class ReceivesTimeInfoIF {
+public:
+	/**
+	 * Returns the id of the queue which receives the timing information.
+	 * @return Queue id of the timing queue.
+	 */
+	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ReceivesTimeInfoIF() {
+	}
+
+};
+
+
+#endif /* RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 52118d58..bf69d3ce 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,5 +1,5 @@
-#include <framework/timemanager/Stopwatch.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../timemanager/Stopwatch.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 
 Stopwatch::Stopwatch(bool displayOnDestruction,
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 630202cc..30735b2c 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,6 +1,6 @@
 #ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
 #define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include <framework/timemanager/Clock.h>
+#include "../timemanager/Clock.h"
 
 enum class StopwatchDisplayMode {
     MILLIS,
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index bf514317..a60718a4 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,37 +1,37 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include <framework/timemanager/TimeMessage.h>
-
-TimeMessage::TimeMessage() {
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-}
-
-TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
-	memcpy (this->getData(), &setTime, sizeof(timeval));
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
-}
-
-TimeMessage::~TimeMessage() {
-}
-
-timeval TimeMessage::getTime() {
-	timeval temp;
-	memcpy( &temp, this->getData(), sizeof(timeval));
-	return temp;
-}
-
-uint32_t TimeMessage::getCounterValue() {
-	uint32_t temp;
-	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
-	return temp;
-}
-
-size_t TimeMessage::getMinimumMessageSize() {
-	return this->MAX_SIZE;
-}
+/**
+ * @file	TimeMessage.cpp
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#include "../timemanager/TimeMessage.h"
+
+TimeMessage::TimeMessage() {
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+}
+
+TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
+	memcpy (this->getData(), &setTime, sizeof(timeval));
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
+}
+
+TimeMessage::~TimeMessage() {
+}
+
+timeval TimeMessage::getTime() {
+	timeval temp;
+	memcpy( &temp, this->getData(), sizeof(timeval));
+	return temp;
+}
+
+uint32_t TimeMessage::getCounterValue() {
+	uint32_t temp;
+	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
+	return temp;
+}
+
+size_t TimeMessage::getMinimumMessageSize() {
+	return this->MAX_SIZE;
+}
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index 95685fec..1e440e5d 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,56 +1,56 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/timemanager/Clock.h>
-#include <cstring>
-
-class TimeMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-
-	/**
-	 * @ brief the size of a TimeMessage
-	 */
-	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
-
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TimeMessage();
-	/**
-	 * @brief	With this constructor, the passed time information is directly put
-	 * 			into the message.
-	 * @param 	setTime The time information to put into the message.
-	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
-	 */
-	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TimeMessage();
-	/**
-	 * @brief	This getter returns the time information in timeval format.
-	 * @return	Returns the time stored in this packet.
-	 */
-	timeval getTime();
-	/**
-	 * @brief 	This getter returns the CounterValue in uint32_t format.
-	 * @return 	Returns the CounterValue stored in this packet.
-	 */
-	uint32_t getCounterValue();
-};
-
-#endif /* TIMEMESSAGE_H_ */
+/**
+ * @file	TimeMessage.h
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef TIMEMESSAGE_H_
+#define TIMEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class TimeMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+
+	/**
+	 * @ brief the size of a TimeMessage
+	 */
+	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
+
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TimeMessage();
+	/**
+	 * @brief	With this constructor, the passed time information is directly put
+	 * 			into the message.
+	 * @param 	setTime The time information to put into the message.
+	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
+	 */
+	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TimeMessage();
+	/**
+	 * @brief	This getter returns the time information in timeval format.
+	 * @return	Returns the time stored in this packet.
+	 */
+	timeval getTime();
+	/**
+	 * @brief 	This getter returns the CounterValue in uint32_t format.
+	 * @return 	Returns the CounterValue stored in this packet.
+	 */
+	uint32_t getCounterValue();
+};
+
+#endif /* TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 7ed45371..49e0ec18 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,24 +1,24 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
-	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
-
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
-	virtual ~TimeStamperIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeStamperIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
+	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
+
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	virtual ~TimeStamperIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 9b913b35..0e20a314 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,95 +1,95 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/parameters/HasParametersIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/timemanager/Clock.h>
-class TmPacketInformation;
-class TmPacketMinimal;
-class SpacePacketBase;
-class ApidSsc;
-
-class TmStoreBackendIF : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
-	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
-	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
-	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
-
-	virtual ~TmStoreBackendIF() {}
-
-	/**
-	 * What do I need to implement here ?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	virtual ReturnValue_t initialize() = 0;
-
-	/**
-	 * Implement the storage of TM packets to mass memory
-	 * @param tmPacket
-	 * @return
-	 */
-	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
-	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
-	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
-	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
-	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
-
-	/**
-	 * TODO: Adapt for file management system?
-	 * @param startAddress
-	 * @param endAddress
-	 * @return
-	 */
-	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
-				uint32_t* deletedPackets) = 0;
-	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
-	virtual bool isReady() = 0;
-	virtual uint32_t availableData() = 0;
-	virtual float getPercentageFilled() const = 0;
-	virtual uint32_t getStoredPacketsCount() const = 0;
-	virtual TmPacketInformation* getOldestPacket() = 0;
-	virtual TmPacketInformation* getYoungestPacket() = 0;
-	virtual float getDataRate() = 0;
-
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../timemanager/Clock.h"
+class TmPacketInformation;
+class TmPacketMinimal;
+class SpacePacketBase;
+class ApidSsc;
+
+class TmStoreBackendIF : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
+	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
+	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
+	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+
+	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
+	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
+	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
+	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
+	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
+	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
+	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
+				uint32_t* deletedPackets) = 0;
+	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
+	virtual bool isReady() = 0;
+	virtual uint32_t availableData() = 0;
+	virtual float getPercentageFilled() const = 0;
+	virtual uint32_t getStoredPacketsCount() const = 0;
+	virtual TmPacketInformation* getOldestPacket() = 0;
+	virtual TmPacketInformation* getYoungestPacket() = 0;
+	virtual float getDataRate() = 0;
+
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 7d38cfc6..7a2b3c9e 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,63 +1,63 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tmstorage/TmStorePackets.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-class TmPacketMinimal;
-class SpacePacketBase;
-class TmStoreBackendIF;
-
-class TmStoreFrontendIF {
-public:
-	virtual TmStoreBackendIF* getBackend() const = 0;
-
-	/**
-	 * What do I need to implement here?
-	 * This is propably used by PUS Service 15 so we should propably check for messages..
-	 * Provide base implementation?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	/**
-	 * Callback from the back-end to indicate a certain packet was received.
-	 * front-end takes care of discarding/downloading the packet.
-	 * @param packet	Pointer to the newly received Space Packet.
-	 * @param address	Start address of the packet found
-	 * @param isLastPacket	Indicates if no more packets can be fetched.
-	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
-	 * 			Any other code stops fetching packets.
-	 */
-	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
-	virtual void noMorePacketsInStore() = 0;
-	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
-	/**
-	 * To get the queue where commands shall be sent.
-	 * @return	Id of command queue.
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
-	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
-	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
-	virtual bool isEnabled() const = 0;
-	virtual void setEnabled(bool enabled) = 0;
-	virtual void resetDownlinkedPacketCount() = 0;
-	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
-	virtual ~TmStoreFrontendIF() {
-	}
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../ipc/MessageQueueSenderIF.h"
+class TmPacketMinimal;
+class SpacePacketBase;
+class TmStoreBackendIF;
+
+class TmStoreFrontendIF {
+public:
+	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	/**
+	 * Callback from the back-end to indicate a certain packet was received.
+	 * front-end takes care of discarding/downloading the packet.
+	 * @param packet	Pointer to the newly received Space Packet.
+	 * @param address	Start address of the packet found
+	 * @param isLastPacket	Indicates if no more packets can be fetched.
+	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
+	 * 			Any other code stops fetching packets.
+	 */
+	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
+	virtual void noMorePacketsInStore() = 0;
+	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
+	/**
+	 * To get the queue where commands shall be sent.
+	 * @return	Id of command queue.
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
+	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
+	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
+	virtual bool isEnabled() const = 0;
+	virtual void setEnabled(bool enabled) = 0;
+	virtual void resetDownlinkedPacketCount() = 0;
+	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
+	virtual ~TmStoreFrontendIF() {
+	}
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 669ecc0e..0436442b 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,165 +1,165 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tmstorage/TmStoreMessage.h>
-
-TmStoreMessage::~TmStoreMessage() {
-	
-}
-
-TmStoreMessage::TmStoreMessage() {
-}
-
-ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
-		bool setEnabled) {
-	cmd->setCommand(ENABLE_STORING);
-	cmd->setParameter(setEnabled);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
-		ApidSsc upTo) {
-	cmd->setCommand(DELETE_STORE_CONTENT);
-	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
-		ApidSsc fromPacket,
-		ApidSsc toPacket) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT);
-	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
-	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter() & 0xFFFF;
-	return temp;
-}
-
-ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter2() & 0xFFFF;
-	return temp;
-}
-
-bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-void TmStoreMessage::setChangeSelectionDefinitionMessage(
-		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
-	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
-	cmd->setParameter(addDefinition);
-	cmd->setParameter2(store_id.raw);
-}
-
-void TmStoreMessage::clear(CommandMessage* cmd) {
-	switch(cmd->getCommand()) {
-	case SELECTION_DEFINITION_REPORT:
-	case STORE_CATALOGUE_REPORT:
-	case CHANGE_SELECTION_DEFINITION:
-	case INDEX_REPORT:
-	case DELETE_STORE_CONTENT_TIME:
-	case DOWNLINK_STORE_CONTENT_TIME: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(cmd));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_STORE_CONTENT_BLOCKS:
-	case DOWNLINK_STORE_CONTENT_BLOCKS:
-	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
-		cmd->setParameter(0);
-		cmd->setParameter2(0);
-		break;
-	default:
-		break;
-	}
-}
-
-store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
-	store_address_t temp;
-	temp.raw = cmd->getParameter2();
-	return temp;
-}
-
-bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_SELECTION_DEFINITION);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setSelectionDefinitionReportMessage(
-		CommandMessage* cmd, store_address_t storeId) {
-	cmd->setCommand(SELECTION_DEFINITION_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_STORE_CATALOGUE);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-		store_address_t storeId) {
-	cmd->setCommand(STORE_CATALOGUE_REPORT);
-	cmd->setParameter(objectId);
-	cmd->setParameter2(storeId.raw);
-}
-
-object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
-	return cmd->getParameter();
-}
-
-void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
-	return cmd->getParameter();
-}
-uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
-	return cmd->getParameter2();
-}
-
-void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
-	cmd->setCommand(REPORT_INDEX_REQUEST);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
-	cmd->setCommand(INDEX_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmstorage/TmStoreMessage.h"
+
+TmStoreMessage::~TmStoreMessage() {
+	
+}
+
+TmStoreMessage::TmStoreMessage() {
+}
+
+ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
+		bool setEnabled) {
+	cmd->setCommand(ENABLE_STORING);
+	cmd->setParameter(setEnabled);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
+		ApidSsc upTo) {
+	cmd->setCommand(DELETE_STORE_CONTENT);
+	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
+		ApidSsc fromPacket,
+		ApidSsc toPacket) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT);
+	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
+	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter() & 0xFFFF;
+	return temp;
+}
+
+ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter2() & 0xFFFF;
+	return temp;
+}
+
+bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+void TmStoreMessage::setChangeSelectionDefinitionMessage(
+		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
+	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
+	cmd->setParameter(addDefinition);
+	cmd->setParameter2(store_id.raw);
+}
+
+void TmStoreMessage::clear(CommandMessage* cmd) {
+	switch(cmd->getCommand()) {
+	case SELECTION_DEFINITION_REPORT:
+	case STORE_CATALOGUE_REPORT:
+	case CHANGE_SELECTION_DEFINITION:
+	case INDEX_REPORT:
+	case DELETE_STORE_CONTENT_TIME:
+	case DOWNLINK_STORE_CONTENT_TIME: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(cmd));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_STORE_CONTENT_BLOCKS:
+	case DOWNLINK_STORE_CONTENT_BLOCKS:
+	case REPORT_INDEX_REQUEST:
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
+		cmd->setParameter(0);
+		cmd->setParameter2(0);
+		break;
+	default:
+		break;
+	}
+}
+
+store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
+	store_address_t temp;
+	temp.raw = cmd->getParameter2();
+	return temp;
+}
+
+bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_SELECTION_DEFINITION);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setSelectionDefinitionReportMessage(
+		CommandMessage* cmd, store_address_t storeId) {
+	cmd->setCommand(SELECTION_DEFINITION_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_STORE_CATALOGUE);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+		store_address_t storeId) {
+	cmd->setCommand(STORE_CATALOGUE_REPORT);
+	cmd->setParameter(objectId);
+	cmd->setParameter2(storeId.raw);
+}
+
+object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
+	return cmd->getParameter();
+}
+
+void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
+	return cmd->getParameter();
+}
+uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
+	return cmd->getParameter2();
+}
+
+void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
+	cmd->setCommand(REPORT_INDEX_REQUEST);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
+	cmd->setCommand(INDEX_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 93c23e40..ce10519b 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmstorage/TmStorePackets.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-class TmStoreMessage  {
-public:
-	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
-			bool setEnabled);
-	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
-			ApidSsc upTo);
-	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
-			ApidSsc fromPacket, ApidSsc toPacket);
-	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
-			bool addDefinition, store_address_t store_id);
-	static ReturnValue_t setReportSelectionDefinitionMessage(
-			CommandMessage* cmd);
-	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
-	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-			store_address_t storeId);
-	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
-	static void setDeleteContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void clear(CommandMessage* cmd);
-	static object_id_t getObjectId(CommandMessage* cmd);
-	static ApidSsc getPacketId1(CommandMessage* cmd);
-	static ApidSsc getPacketId2(CommandMessage* cmd);
-	static bool getEnableStoring(CommandMessage* cmd);
-	static bool getAddToSelection(CommandMessage* cmd);
-	static uint32_t getAddressLow(CommandMessage* cmd);
-	static uint32_t getAddressHigh(CommandMessage* cmd);
-
-	static store_address_t getStoreId(const CommandMessage* cmd);
-	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
-	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
-	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
-	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
-	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
-	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
-	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
-	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
-	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
-	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
-	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
-	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
-	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-private:
-	TmStoreMessage();
-};
-
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../objectmanager/SystemObjectIF.h"
+class TmStoreMessage  {
+public:
+	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
+			bool setEnabled);
+	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
+			ApidSsc upTo);
+	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
+			ApidSsc fromPacket, ApidSsc toPacket);
+	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
+			bool addDefinition, store_address_t store_id);
+	static ReturnValue_t setReportSelectionDefinitionMessage(
+			CommandMessage* cmd);
+	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
+	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+			store_address_t storeId);
+	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
+	static void setDeleteContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void clear(CommandMessage* cmd);
+	static object_id_t getObjectId(CommandMessage* cmd);
+	static ApidSsc getPacketId1(CommandMessage* cmd);
+	static ApidSsc getPacketId2(CommandMessage* cmd);
+	static bool getEnableStoring(CommandMessage* cmd);
+	static bool getAddToSelection(CommandMessage* cmd);
+	static uint32_t getAddressLow(CommandMessage* cmd);
+	static uint32_t getAddressHigh(CommandMessage* cmd);
+
+	static store_address_t getStoreId(const CommandMessage* cmd);
+	virtual ~TmStoreMessage();
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
+	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
+	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
+	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
+	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
+	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
+	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
+	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
+	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
+	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
+	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
+	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
+	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
+private:
+	TmStoreMessage();
+};
+
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 9a669a7d..3c8e1a24 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,300 +1,300 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-#include <framework/timemanager/TimeStamperIF.h>
-#include <framework/timemanager/CCSDSTime.h>
-#include <framework/globalfunctions/timevalOperations.h>
-
-class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint8_t> service;
-	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
-	LinkedElement<SerializeIF> linkedSubservices;
-	ServiceSubservice() :
-			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
-					&subservices) {
-		service.setNext(&linkedSubservices);
-	}
-};
-
-class ApidSsc: public SerializeIF {
-public:
-	ApidSsc() :
-			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
-	}
-	ApidSsc(uint16_t apid, uint16_t ssc) :
-			apid(apid), ssc(ssc) {
-	}
-	uint16_t apid;
-	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&ssc, buffer, size,
-				maxSize, streamEndianness);
-
-	}
-
-	size_t getSerializedSize() const {
-		return sizeof(apid) + sizeof(ssc);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				streamEndianness);
-	}
-};
-
-class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint16_t> apid;
-	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
-	LinkedElement<SerializeIF> linkedServiceList;
-	ChangeSelectionDefinition() :
-			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
-					&serviceList) {
-		apid.setNext(&linkedServiceList);
-	}
-};
-
-class TmPacketInformation: public SerializeIF {
-public:
-	TmPacketInformation(TmPacketMinimal* packet){
-		setContent(packet);
-	}
-	TmPacketInformation() :apid(
-					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
-					0), serviceSubtype(0), subCounter(0) {
-	}
-	void reset() {
-		apid = SpacePacketBase::LIMIT_APID;
-		sourceSequenceCount = 0;
-		serviceType = 0;
-		serviceSubtype = 0;
-		subCounter = 0;
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-	}
-	void setContent(TmPacketMinimal* packet) {
-		apid = packet->getAPID();
-		sourceSequenceCount = packet->getPacketSequenceCount();
-		serviceType = packet->getService();
-		serviceSubtype = packet->getSubService();
-		subCounter = packet->getPacketSubcounter();
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-		const uint8_t* pField = NULL;
-		uint32_t size = 0;
-		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
-				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
-			//Shortcut to avoid converting CDS back and forth.
-			memcpy(rawTimestamp, pField, size);
-			return;
-		}
-		timeval time = { 0, 0 };
-		result = packet->getPacketTime(&time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-
-		CCSDSTime::CDS_short cdsFormat;
-		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
-	}
-	void setContent(TmPacketInformation* content) {
-		apid = content->apid;
-		sourceSequenceCount = content->sourceSequenceCount;
-		serviceType = content->serviceType;
-		serviceSubtype = content->serviceSubtype;
-		subCounter = content->subCounter;
-		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
-	}
-	bool isValid() const {
-		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
-	}
-	static void reset(TmPacketInformation* packet){
-		packet->reset();
-	}
-
-	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime <= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime >= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount <= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount >= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	uint16_t getApid() const{
-		return apid;
-	}
-
-	uint16_t getSsc() const{
-		return sourceSequenceCount;
-	}
-
-	uint8_t getServiceType() const{
-		return serviceType;
-	}
-
-	uint8_t getServiceSubtype() const{
-		return serviceSubtype;
-	}
-
-	uint8_t getSubCounter() const{
-		return subCounter;
-	}
-
-	timeval getTime() const {
-		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-		return packetTime;
-	}
-
-	bool operator==(const TmPacketInformation& other) {
-		//TODO Does not compare Raw Timestamp
-		return ((apid == other.getApid())
-				&& (sourceSequenceCount == other.getSsc())
-				&& (serviceType == other.getServiceType()) && (serviceSubtype =
-						other.getServiceSubtype()));
-	}
-
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,maxSize,streamEndianness);
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&apid);
-		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += SerializeAdapter::getSerializedSize(&subCounter);
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		size += adapter.getSerializedSize();
-		return size;
-
-	};
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,streamEndianness);
-	}
-
-private:
-	uint16_t apid;
-	uint16_t sourceSequenceCount;
-	uint8_t serviceType;
-	uint8_t serviceSubtype;
-	uint8_t subCounter;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-
-};
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../tmtcpacket/pus/TmPacketMinimal.h"
+#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/CCSDSTime.h"
+#include "../globalfunctions/timevalOperations.h"
+
+class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint8_t> service;
+	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
+	LinkedElement<SerializeIF> linkedSubservices;
+	ServiceSubservice() :
+			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
+					&subservices) {
+		service.setNext(&linkedSubservices);
+	}
+};
+
+class ApidSsc: public SerializeIF {
+public:
+	ApidSsc() :
+			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
+	}
+	ApidSsc(uint16_t apid, uint16_t ssc) :
+			apid(apid), ssc(ssc) {
+	}
+	uint16_t apid;
+	uint16_t ssc;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&ssc, buffer, size,
+				maxSize, streamEndianness);
+
+	}
+
+	size_t getSerializedSize() const {
+		return sizeof(apid) + sizeof(ssc);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
+				streamEndianness);
+	}
+};
+
+class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint16_t> apid;
+	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
+	LinkedElement<SerializeIF> linkedServiceList;
+	ChangeSelectionDefinition() :
+			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
+					&serviceList) {
+		apid.setNext(&linkedServiceList);
+	}
+};
+
+class TmPacketInformation: public SerializeIF {
+public:
+	TmPacketInformation(TmPacketMinimal* packet){
+		setContent(packet);
+	}
+	TmPacketInformation() :apid(
+					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
+					0), serviceSubtype(0), subCounter(0) {
+	}
+	void reset() {
+		apid = SpacePacketBase::LIMIT_APID;
+		sourceSequenceCount = 0;
+		serviceType = 0;
+		serviceSubtype = 0;
+		subCounter = 0;
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+	}
+	void setContent(TmPacketMinimal* packet) {
+		apid = packet->getAPID();
+		sourceSequenceCount = packet->getPacketSequenceCount();
+		serviceType = packet->getService();
+		serviceSubtype = packet->getSubService();
+		subCounter = packet->getPacketSubcounter();
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+		const uint8_t* pField = NULL;
+		uint32_t size = 0;
+		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
+				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
+			//Shortcut to avoid converting CDS back and forth.
+			memcpy(rawTimestamp, pField, size);
+			return;
+		}
+		timeval time = { 0, 0 };
+		result = packet->getPacketTime(&time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
+		CCSDSTime::CDS_short cdsFormat;
+		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
+	}
+	void setContent(TmPacketInformation* content) {
+		apid = content->apid;
+		sourceSequenceCount = content->sourceSequenceCount;
+		serviceType = content->serviceType;
+		serviceSubtype = content->serviceSubtype;
+		subCounter = content->subCounter;
+		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+	}
+	bool isValid() const {
+		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
+	}
+	static void reset(TmPacketInformation* packet){
+		packet->reset();
+	}
+
+	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime <= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime >= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount <= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount >= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	uint16_t getApid() const{
+		return apid;
+	}
+
+	uint16_t getSsc() const{
+		return sourceSequenceCount;
+	}
+
+	uint8_t getServiceType() const{
+		return serviceType;
+	}
+
+	uint8_t getServiceSubtype() const{
+		return serviceSubtype;
+	}
+
+	uint8_t getSubCounter() const{
+		return subCounter;
+	}
+
+	timeval getTime() const {
+		timeval packetTime = {0,0};
+		uint32_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		return packetTime;
+	}
+
+	bool operator==(const TmPacketInformation& other) {
+		//TODO Does not compare Raw Timestamp
+		return ((apid == other.getApid())
+				&& (sourceSequenceCount == other.getSsc())
+				&& (serviceType == other.getServiceType()) && (serviceSubtype =
+						other.getServiceSubtype()));
+	}
+
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		size += adapter.getSerializedSize();
+		return size;
+
+	};
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.deSerialize(buffer,size,streamEndianness);
+	}
+
+private:
+	uint16_t apid;
+	uint16_t sourceSequenceCount;
+	uint8_t serviceType;
+	uint8_t serviceSubtype;
+	uint8_t subCounter;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+
+};
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index d9bc08fa..c04e143f 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,27 +1,27 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/ccsds_header.h>
-#include <framework/tmtcpacket/SpacePacket.h>
-#include <string.h>
-
-SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
-SpacePacketBase( (uint8_t*)&this->localData ) {
-	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
-	this->setPacketSequenceCount(sequenceCount);
-	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
-		this->setPacketDataLength(packetDataLength);
-	} else {
-		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
-	}
-}
-
-SpacePacket::~SpacePacket( void ) {
-}
-
-bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
-	if ( packet_size <= sizeof(this->data) ) {
-		memcpy( &this->localData.byteStream, p_Data, packet_size );
-		return true;
-	} else {
-		return false;
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/ccsds_header.h"
+#include "../tmtcpacket/SpacePacket.h"
+#include <string.h>
+
+SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
+SpacePacketBase( (uint8_t*)&this->localData ) {
+	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
+	this->setPacketSequenceCount(sequenceCount);
+	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
+		this->setPacketDataLength(packetDataLength);
+	} else {
+		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
+	}
+}
+
+SpacePacket::~SpacePacket( void ) {
+}
+
+bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
+	if ( packet_size <= sizeof(this->data) ) {
+		memcpy( &this->localData.byteStream, p_Data, packet_size );
+		return true;
+	} else {
+		return false;
+	}
+}
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index f2d45752..a75b9ae3 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,70 +1,70 @@
-#ifndef SPACEPACKET_H_
-#define SPACEPACKET_H_
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-/**
- * The SpacePacket class is a representation of a simple CCSDS Space Packet
- * without (control over) a secondary header.
- * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
- * main use is to serve as an idle packet in case no other packets are sent.
- * For the ECSS PUS part the TcPacket and TmPacket classes are used.
- * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
- * so the parent's methods are reachable.
- * @ingroup tmtcpackets
- */
-class SpacePacket: public SpacePacketBase {
-public:
-	static const uint16_t PACKET_MAX_SIZE = 1024;
-	/**
-	 * The constructor initializes the packet and sets all header information
-	 * according to the passed parameters.
-	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
-	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
-	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
-	 * @param sequenceCount ets the packet's Source Sequence Count field.
-	 */
-	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
-			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
-	/**
-	 * The class's default destructor.
-	 */
-	virtual ~SpacePacket();
-	/**
-	 * With this call, the complete data content (including the CCSDS Primary
-	 * Header) is overwritten with the byte stream given.
-	 * @param p_data		Pointer to data to overwrite the content with
-	 * @param packet_size	Size of the data
-	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
-	 * 			@li \c false else.
-	 */
-	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
-protected:
-	/**
-	 * This structure defines the data structure of a Space Packet as local data.
-	 * There's a buffer which corresponds to the Space Packet Data Field with a
-	 * maximum size of \c PACKET_MAX_SIZE.
-	 */
-	struct PacketStructured {
-		CCSDSPrimaryHeader header;
-		uint8_t buffer[PACKET_MAX_SIZE];
-	};
-	/**
-	 * This union simplifies accessing the full data content of the Space Packet.
-	 * This is achieved by putting the \c PacketStructured struct in a union with
-	 * a plain buffer.
-	 */
-	union SpacePacketData {
-		PacketStructured fields;
-		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
-	};
-	/**
-	 * This is the data representation of the class.
-	 * It is a struct of CCSDS Primary Header and a data field, which again is
-	 * packed in an union, so the data can be accessed as a byte stream without
-	 * a cast.
-	 */
-	SpacePacketData localData;
-};
-
-#endif /* SPACEPACKET_H_ */
+#ifndef SPACEPACKET_H_
+#define SPACEPACKET_H_
+
+#include "../tmtcpacket/SpacePacketBase.h"
+
+/**
+ * The SpacePacket class is a representation of a simple CCSDS Space Packet
+ * without (control over) a secondary header.
+ * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
+ * main use is to serve as an idle packet in case no other packets are sent.
+ * For the ECSS PUS part the TcPacket and TmPacket classes are used.
+ * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
+ * so the parent's methods are reachable.
+ * @ingroup tmtcpackets
+ */
+class SpacePacket: public SpacePacketBase {
+public:
+	static const uint16_t PACKET_MAX_SIZE = 1024;
+	/**
+	 * The constructor initializes the packet and sets all header information
+	 * according to the passed parameters.
+	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
+	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
+	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
+	 * @param sequenceCount ets the packet's Source Sequence Count field.
+	 */
+	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
+			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
+	/**
+	 * The class's default destructor.
+	 */
+	virtual ~SpacePacket();
+	/**
+	 * With this call, the complete data content (including the CCSDS Primary
+	 * Header) is overwritten with the byte stream given.
+	 * @param p_data		Pointer to data to overwrite the content with
+	 * @param packet_size	Size of the data
+	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
+	 * 			@li \c false else.
+	 */
+	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
+protected:
+	/**
+	 * This structure defines the data structure of a Space Packet as local data.
+	 * There's a buffer which corresponds to the Space Packet Data Field with a
+	 * maximum size of \c PACKET_MAX_SIZE.
+	 */
+	struct PacketStructured {
+		CCSDSPrimaryHeader header;
+		uint8_t buffer[PACKET_MAX_SIZE];
+	};
+	/**
+	 * This union simplifies accessing the full data content of the Space Packet.
+	 * This is achieved by putting the \c PacketStructured struct in a union with
+	 * a plain buffer.
+	 */
+	union SpacePacketData {
+		PacketStructured fields;
+		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 * It is a struct of CCSDS Primary Header and a data field, which again is
+	 * packed in an union, so the data can be accessed as a byte stream without
+	 * a cast.
+	 */
+	SpacePacketData localData;
+};
+
+#endif /* SPACEPACKET_H_ */
diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index b9ae0684..3d3a51e3 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,104 +1,104 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <string.h>
-
-SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
-	this->data = (SpacePacketPointer*) set_address;
-}
-
-SpacePacketBase::~SpacePacketBase() {
-};
-
-//CCSDS Methods:
-uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
-	return (this->data->header.packet_id_h & 0b11100000) >> 5;
-}
-
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
-		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
-	//reset header to zero:
-	memset(data,0, sizeof(this->data->header) );
-	//Set TC/TM bit.
-	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
-	//Set secondaryHeader bit
-	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
-	this->setAPID( apid );
-	//Always initialize as standalone packets.
-	data->header.sequence_control_h = 0b11000000;
-	setPacketSequenceCount(sequenceCount);
-
-}
-
-bool SpacePacketBase::isTelecommand( void ) {
-	return (this->data->header.packet_id_h & 0b00010000) >> 4;
-}
-
-bool SpacePacketBase::hasSecondaryHeader( void ) {
-	return (this->data->header.packet_id_h & 0b00001000) >> 3;
-}
-
-uint16_t SpacePacketBase::getPacketId() {
-	return ( (this->data->header.packet_id_h) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-uint16_t SpacePacketBase::getAPID( void ) const {
-	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-void SpacePacketBase::setAPID( uint16_t new_apid ) {
-	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
-	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
-	this->data->header.packet_id_l = ( new_apid & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
-	return ( (this->data->header.sequence_control_h) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-uint8_t SpacePacketBase::getSequenceFlags( void ) {
-	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
-}
-
-uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
-	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
-	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
-	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketDataLength( void ) {
-	return ( (this->data->header.packet_length_h) << 8 )
-		+ this->data->header.packet_length_l;
-}
-
-void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
-	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
-	this->data->header.packet_length_l = ( new_length & 0x00FF );
-}
-
-size_t SpacePacketBase::getFullSize() {
-	//+1 is done because size in packet data length field is: size of data field -1
-	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
-}
-
-uint8_t* SpacePacketBase::getWholeData() {
-	return (uint8_t*)this->data;
-}
-
-void SpacePacketBase::setData( const uint8_t* p_Data ) {
-	this->data = (SpacePacketPointer*)p_Data;
-}
-
-uint32_t SpacePacketBase::getApidAndSequenceCount() const {
-	return (getAPID() << 16) + getPacketSequenceCount();
-}
-
-uint8_t* SpacePacketBase::getPacketData() {
-	return &(data->packet_data);
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include <string.h>
+
+SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
+	this->data = (SpacePacketPointer*) set_address;
+}
+
+SpacePacketBase::~SpacePacketBase() {
+};
+
+//CCSDS Methods:
+uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
+	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+}
+
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+	//reset header to zero:
+	memset(data,0, sizeof(this->data->header) );
+	//Set TC/TM bit.
+	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
+	//Set secondaryHeader bit
+	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
+	this->setAPID( apid );
+	//Always initialize as standalone packets.
+	data->header.sequence_control_h = 0b11000000;
+	setPacketSequenceCount(sequenceCount);
+
+}
+
+bool SpacePacketBase::isTelecommand( void ) {
+	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+}
+
+bool SpacePacketBase::hasSecondaryHeader( void ) {
+	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+}
+
+uint16_t SpacePacketBase::getPacketId() {
+	return ( (this->data->header.packet_id_h) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+uint16_t SpacePacketBase::getAPID( void ) const {
+	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+void SpacePacketBase::setAPID( uint16_t new_apid ) {
+	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
+	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
+	return ( (this->data->header.sequence_control_h) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+uint8_t SpacePacketBase::getSequenceFlags( void ) {
+	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+}
+
+uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
+	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
+	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketDataLength( void ) {
+	return ( (this->data->header.packet_length_h) << 8 )
+		+ this->data->header.packet_length_l;
+}
+
+void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
+	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+	this->data->header.packet_length_l = ( new_length & 0x00FF );
+}
+
+size_t SpacePacketBase::getFullSize() {
+	//+1 is done because size in packet data length field is: size of data field -1
+	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+}
+
+uint8_t* SpacePacketBase::getWholeData() {
+	return (uint8_t*)this->data;
+}
+
+void SpacePacketBase::setData( const uint8_t* p_Data ) {
+	this->data = (SpacePacketPointer*)p_Data;
+}
+
+uint32_t SpacePacketBase::getApidAndSequenceCount() const {
+	return (getAPID() << 16) + getPacketSequenceCount();
+}
+
+uint8_t* SpacePacketBase::getPacketData() {
+	return &(data->packet_data);
+}
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index 57a5df9c..a132bfd1 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,177 +1,177 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
-
-#include <framework/tmtcpacket/ccsds_header.h>
-#include <cstddef>
-
-/**
- * @defgroup tmtcpackets Space Packets
- * This is the group, where all classes associated with Telecommand and
- * Telemetry packets belong to.
- * The class hierarchy resembles the dependency between the different standards
- * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
- * Utilization Standard. Most field and structure names are taken from these
- * standards.
- */
-
-/**
- * This struct defines the data structure of a Space Packet when accessed
- * via a pointer.
- * @ingroup tmtcpackets
- */
-struct SpacePacketPointer {
-	CCSDSPrimaryHeader header;
-	uint8_t packet_data;
-};
-
-/**
- * This class is the basic data handler for any CCSDS Space Packet
- * compatible Telecommand and Telemetry packet.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * Remark: All bit numbers in this documentation are counted from
- * the most significant bit (from left).
- * @ingroup tmtcpackets
- */
-class SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet header.
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	SpacePacketPointer* data;
-public:
-	static const uint16_t LIMIT_APID = 2048; //2^1
-	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
-	static const uint16_t APID_IDLE_PACKET = 0x7FF;
-	static const uint8_t TELECOMMAND_PACKET = 1;
-	static const uint8_t TELEMETRY_PACKET = 0;
-	/**
-	 * This definition defines the CRC size in byte.
-	 */
-	static const uint8_t CRC_SIZE = 2;
-	/**
-	 * This is the minimum size of a SpacePacket.
-	 */
-	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	SpacePacketBase( const uint8_t* set_address );
-	/**
-	 * No data is allocated, so the destructor is empty.
-	 */
-	virtual ~SpacePacketBase();
-
-	//CCSDS Methods:
-	/**
-	 * Getter for the packet version number field.
-	 * @return Returns the highest three bit of the packet in one byte.
-	 */
-	uint8_t getPacketVersionNumber( void );
-	/**
-	 * This method checks the type field in the header.
-	 * This bit specifies, if the command is interpreted as Telecommand of
-	 * as Telemetry. For a Telecommand, the bit is set.
-	 * @return Returns true if the bit is set and false if not.
-	 */
-	bool isTelecommand( void );
-
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
-	/**
-	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
-	 *  which is checked with this method.
-	 * @return	Returns true if the bit is set and false if not.
-	 */
-	bool hasSecondaryHeader( void );
-	/**
-	 * Returns the complete first two bytes of the packet, which together form
-	 * the CCSDS packet id.
-	 * @return	The CCSDS packet id.
-	 */
-	uint16_t getPacketId( void );
-	/**
-	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @return The CCSDS APID.
-	 */
-	uint16_t getAPID( void ) const;
-	/**
-	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @param 	The APID to set. The highest five bits of the parameter are
-	 * 			ignored.
-	 */
-	void setAPID( uint16_t setAPID );
-	/**
-	 * Returns the CCSDS packet sequence control field, which are the third and
-	 * the fourth byte of the CCSDS primary header.
-	 * @return The CCSDS packet sequence control field.
-	 */
-	uint16_t getPacketSequenceControl( void );
-	/**
-	 * Returns the SequenceFlags, which are the highest two bit of the packet
-	 * sequence control field.
-	 * @return	The CCSDS sequence flags.
-	 */
-	uint8_t getSequenceFlags( void );
-	/**
-	 * Returns the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * @return The CCSDS sequence count.
-	 */
-	uint16_t getPacketSequenceCount( void ) const;
-	/**
-	 * Sets the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
-	 * @param setCount	The value to set the count to.
-	 */
-	void setPacketSequenceCount( uint16_t setCount );
-	/**
-	 * Returns the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header. The packet data length is the size of every kind
-	 * of data \b after the CCSDS Primary Header \b -1.
-	 * @return The CCSDS packet data length.
-	 */
-	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
-	/**
-	 * Sets the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header.
-	 * @param setLength The value of the length to set. It must fit the true
-	 * 					CCSDS packet data length . The packet data length is
-	 * 					the size of every kind of data \b after the CCSDS
-	 * 					Primary Header \b -1.
-	 */
-	void setPacketDataLength( uint16_t setLength );
-
-	//Helper methods:
-	/**
-	 * This method returns a raw uint8_t pointer to the packet.
-	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-	 */
-	virtual uint8_t* getWholeData( void );
-
-	uint8_t* getPacketData();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 * @param p_Data A pointer to another raw Space Packet.
-	 */
-	virtual void setData( const uint8_t* p_Data );
-	/**
-	 * This method returns the full raw packet size.
-	 * @return	The full size of the packet in bytes.
-	 */
-	size_t getFullSize();
-
-	uint32_t getApidAndSequenceCount() const;
-
-};
-
-#endif /* SPACEPACKETBASE_H_ */
+#ifndef SPACEPACKETBASE_H_
+#define SPACEPACKETBASE_H_
+
+#include "../tmtcpacket/ccsds_header.h"
+#include <cstddef>
+
+/**
+ * @defgroup tmtcpackets Space Packets
+ * This is the group, where all classes associated with Telecommand and
+ * Telemetry packets belong to.
+ * The class hierarchy resembles the dependency between the different standards
+ * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
+ * Utilization Standard. Most field and structure names are taken from these
+ * standards.
+ */
+
+/**
+ * This struct defines the data structure of a Space Packet when accessed
+ * via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct SpacePacketPointer {
+	CCSDSPrimaryHeader header;
+	uint8_t packet_data;
+};
+
+/**
+ * This class is the basic data handler for any CCSDS Space Packet
+ * compatible Telecommand and Telemetry packet.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * Remark: All bit numbers in this documentation are counted from
+ * the most significant bit (from left).
+ * @ingroup tmtcpackets
+ */
+class SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet header.
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	SpacePacketPointer* data;
+public:
+	static const uint16_t LIMIT_APID = 2048; //2^1
+	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+	static const uint16_t APID_IDLE_PACKET = 0x7FF;
+	static const uint8_t TELECOMMAND_PACKET = 1;
+	static const uint8_t TELEMETRY_PACKET = 0;
+	/**
+	 * This definition defines the CRC size in byte.
+	 */
+	static const uint8_t CRC_SIZE = 2;
+	/**
+	 * This is the minimum size of a SpacePacket.
+	 */
+	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	SpacePacketBase( const uint8_t* set_address );
+	/**
+	 * No data is allocated, so the destructor is empty.
+	 */
+	virtual ~SpacePacketBase();
+
+	//CCSDS Methods:
+	/**
+	 * Getter for the packet version number field.
+	 * @return Returns the highest three bit of the packet in one byte.
+	 */
+	uint8_t getPacketVersionNumber( void );
+	/**
+	 * This method checks the type field in the header.
+	 * This bit specifies, if the command is interpreted as Telecommand of
+	 * as Telemetry. For a Telecommand, the bit is set.
+	 * @return Returns true if the bit is set and false if not.
+	 */
+	bool isTelecommand( void );
+
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	/**
+	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+	 *  which is checked with this method.
+	 * @return	Returns true if the bit is set and false if not.
+	 */
+	bool hasSecondaryHeader( void );
+	/**
+	 * Returns the complete first two bytes of the packet, which together form
+	 * the CCSDS packet id.
+	 * @return	The CCSDS packet id.
+	 */
+	uint16_t getPacketId( void );
+	/**
+	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @return The CCSDS APID.
+	 */
+	uint16_t getAPID( void ) const;
+	/**
+	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @param 	The APID to set. The highest five bits of the parameter are
+	 * 			ignored.
+	 */
+	void setAPID( uint16_t setAPID );
+	/**
+	 * Returns the CCSDS packet sequence control field, which are the third and
+	 * the fourth byte of the CCSDS primary header.
+	 * @return The CCSDS packet sequence control field.
+	 */
+	uint16_t getPacketSequenceControl( void );
+	/**
+	 * Returns the SequenceFlags, which are the highest two bit of the packet
+	 * sequence control field.
+	 * @return	The CCSDS sequence flags.
+	 */
+	uint8_t getSequenceFlags( void );
+	/**
+	 * Returns the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * @return The CCSDS sequence count.
+	 */
+	uint16_t getPacketSequenceCount( void ) const;
+	/**
+	 * Sets the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+	 * @param setCount	The value to set the count to.
+	 */
+	void setPacketSequenceCount( uint16_t setCount );
+	/**
+	 * Returns the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header. The packet data length is the size of every kind
+	 * of data \b after the CCSDS Primary Header \b -1.
+	 * @return The CCSDS packet data length.
+	 */
+	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
+	/**
+	 * Sets the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header.
+	 * @param setLength The value of the length to set. It must fit the true
+	 * 					CCSDS packet data length . The packet data length is
+	 * 					the size of every kind of data \b after the CCSDS
+	 * 					Primary Header \b -1.
+	 */
+	void setPacketDataLength( uint16_t setLength );
+
+	//Helper methods:
+	/**
+	 * This method returns a raw uint8_t pointer to the packet.
+	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
+	 */
+	virtual uint8_t* getWholeData( void );
+
+	uint8_t* getPacketData();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 * @param p_Data A pointer to another raw Space Packet.
+	 */
+	virtual void setData( const uint8_t* p_Data );
+	/**
+	 * This method returns the full raw packet size.
+	 * @return	The full size of the packet in bytes.
+	 */
+	size_t getFullSize();
+
+	uint32_t getApidAndSequenceCount() const;
+
+};
+
+#endif /* SPACEPACKETBASE_H_ */
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 3080ffef..7b1b89ff 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint16_t apid;
-public:
-	ApidMatcher(uint16_t setApid) :
-			apid(setApid) {
-	}
-	ApidMatcher(TmPacketMinimal* test) :
-			apid(test->getAPID()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getAPID() == apid) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&apid);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
-	}
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint16_t apid;
+public:
+	ApidMatcher(uint16_t setApid) :
+			apid(setApid) {
+	}
+	ApidMatcher(TmPacketMinimal* test) :
+			apid(test->getAPID()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getAPID() == apid) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&apid);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
+	}
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index d8f61ffb..356467dc 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,195 +1,195 @@
-#include <framework/tmtcpacket/packetmatcher/ApidMatcher.h>
-#include <framework/tmtcpacket/packetmatcher/PacketMatchTree.h>
-#include <framework/tmtcpacket/packetmatcher/ServiceMatcher.h>
-#include <framework/tmtcpacket/packetmatcher/SubserviceMatcher.h>
-
-PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::~PacketMatchTree() {
-}
-
-ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	//We assume adding APID is always requested.
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator lastTest;
-	iterator rollback;
-	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
-			this->begin(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		rollback = lastTest;
-	} else if (result != RETURN_OK) {
-		return result;
-	}
-	if (type == 0) {
-		//Check if lastTest has no children, otherwise, delete them,
-		//as a more general check is requested.
-		if (lastTest.left() != this->end()) {
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Type insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		if  (rollback == this->end()) {
-			rollback = lastTest;
-		}
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	if (subtype == 0) {
-		if (lastTest.left() != this->end()) {
-			//See above
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Subtype insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		return RETURN_OK;
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
-		iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = startAt;
-	while (iter != this->end()) {
-		bool isMatch = iter->match(test);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if (isMatch) {
-			return RETURN_OK;
-		} else {
-			//Go down OR branch.
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
-			test);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return NEW_NODE_CREATED;
-}
-
-ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator foundElement = findMatch(begin(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (type == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Go down AND branch. Will abort if empty.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (subtype == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Again, go down AND branch.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	}
-	return removeElementAndReconnectChildren(foundElement);
-}
-
-PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
-		TmPacketMinimal* test) {
-	iterator iter = startAt;
-	while (iter != end()) {
-		bool isMatch = iter->match(test);
-		if (isMatch) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t PacketMatchTree::initialize() {
-	return factoryBackend.initialize();
-}
-
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
-ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
-		uint8_t type, uint8_t subtype) {
-	if (addToMatch) {
-		return addMatch(apid, type, subtype);
-	} else {
-		return removeMatch(apid, type, subtype);
-	}
-}
-
-ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//Go on anyway, there's nothing we can do.
-	//SHOULDDO: Throw event, or write debug message?
-	return factory.destroy(position.element);
-}
+#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
+#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
+#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
+#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+
+PacketMatchTree::PacketMatchTree(Node* root) :
+		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
+				N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree(iterator root) :
+		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree() :
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::~PacketMatchTree() {
+}
+
+ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume adding APID is always requested.
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator lastTest;
+	iterator rollback;
+	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
+			this->begin(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		rollback = lastTest;
+	} else if (result != RETURN_OK) {
+		return result;
+	}
+	if (type == 0) {
+		//Check if lastTest has no children, otherwise, delete them,
+		//as a more general check is requested.
+		if (lastTest.left() != this->end()) {
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Type insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		if  (rollback == this->end()) {
+			rollback = lastTest;
+		}
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	if (subtype == 0) {
+		if (lastTest.left() != this->end()) {
+			//See above
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Subtype insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		return RETURN_OK;
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
+		iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = startAt;
+	while (iter != this->end()) {
+		bool isMatch = iter->match(test);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if (isMatch) {
+			return RETURN_OK;
+		} else {
+			//Go down OR branch.
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
+			test);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return NEW_NODE_CREATED;
+}
+
+ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator foundElement = findMatch(begin(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (type == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Go down AND branch. Will abort if empty.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (subtype == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Again, go down AND branch.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	}
+	return removeElementAndReconnectChildren(foundElement);
+}
+
+PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
+		TmPacketMinimal* test) {
+	iterator iter = startAt;
+	while (iter != end()) {
+		bool isMatch = iter->match(test);
+		if (isMatch) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t PacketMatchTree::initialize() {
+	return factoryBackend.initialize();
+}
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+		sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
+		uint8_t type, uint8_t subtype) {
+	if (addToMatch) {
+		return addMatch(apid, type, subtype);
+	} else {
+		return removeMatch(apid, type, subtype);
+	}
+}
+
+ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//Go on anyway, there's nothing we can do.
+	//SHOULDDO: Throw event, or write debug message?
+	return factory.destroy(position.element);
+}
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index a6c0c61e..0d246d21 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-
-#include <framework/container/PlacementFactory.h>
-#include <framework/globalfunctions/matching/MatchTree.h>
-#include <framework/storagemanager/LocalPool.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
-public:
-	PacketMatchTree(Node* root);
-	PacketMatchTree(iterator root);
-	PacketMatchTree();
-	virtual ~PacketMatchTree();
-	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t initialize();
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
-	PlacementFactory factory;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
-	iterator findMatch(iterator startAt, TmPacketMinimal* test);
-};
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
-
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../storagemanager/LocalPool.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+public:
+	PacketMatchTree(Node* root);
+	PacketMatchTree(iterator root);
+	PacketMatchTree();
+	virtual ~PacketMatchTree();
+	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t initialize();
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	static const uint8_t N_POOLS = 4;
+	LocalPool<N_POOLS> factoryBackend;
+	PlacementFactory factory;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
+	iterator findMatch(iterator startAt, TmPacketMinimal* test);
+};
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index f6e9e360..e22288f4 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -1,39 +1,39 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint8_t service;
-public:
-	ServiceMatcher(uint8_t setService) :
-			service(setService) {
-	}
-	ServiceMatcher(TmPacketMinimal* test) :
-			service(test->getService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getService() == service) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&service);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
-	}
-};
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint8_t service;
+public:
+	ServiceMatcher(uint8_t setService) :
+			service(setService) {
+	}
+	ServiceMatcher(TmPacketMinimal* test) :
+			service(test->getService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getService() == service) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&service);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
+	}
+};
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 2e8b82b2..1b173b1a 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-
-#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-
-class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-public:
-	SubServiceMatcher(uint8_t subService) :
-			subService(subService) {
-	}
-	SubServiceMatcher(TmPacketMinimal* test) :
-			subService(test->getSubService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getSubService() == subService) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&subService);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
-	}
-private:
-	uint8_t subService;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+public:
+	SubServiceMatcher(uint8_t subService) :
+			subService(subService) {
+	}
+	SubServiceMatcher(TmPacketMinimal* test) :
+			subService(test->getSubService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getSubService() == subService) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&subService);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
+	}
+private:
+	uint8_t subService;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index 6e19381a..9e442ed6 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-class TmPacketMinimal;
-
-class PacketTimestampInterpreterIF {
-public:
-	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
-	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class TmPacketMinimal;
+
+class PacketTimestampInterpreterIF {
+public:
+	virtual ~PacketTimestampInterpreterIF() {}
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 733c36df..3dc15872 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,93 +1,93 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-#include <string.h>
-
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
-}
-
-TcPacketBase::~TcPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TcPacketBase::getService() {
-	return tcData->dataField.service_type;
-}
-
-uint8_t TcPacketBase::getSubService() {
-	return tcData->dataField.service_subtype;
-}
-
-uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->dataField.version_type_ack & 0b00001111;
-}
-
-const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->appData;
-}
-
-uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
-}
-
-uint16_t TcPacketBase::getErrorControl() {
-	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->appData;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TcPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getApplicationDataSize();
-	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TcPacketBase::setData(const uint8_t* pData) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
-}
-
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
-uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
-}
-
-uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
-}
-
-void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-}
-
-void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
-	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
-	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->dataField.version_type_ack = 0b00010000;
-	tcData->dataField.version_type_ack |= (ack & 0x0F);
-	tcData->dataField.service_type = service;
-	tcData->dataField.service_subtype = subservice;
-}
-
-size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
-	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
-			appDataLen + TcPacketBase::CRC_SIZE;
-}
+#include "../../globalfunctions/CRC.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+#include <string.h>
+
+TcPacketBase::TcPacketBase(const uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tcData = (TcPacketPointer*) set_data;
+}
+
+TcPacketBase::~TcPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TcPacketBase::getService() {
+	return tcData->dataField.service_type;
+}
+
+uint8_t TcPacketBase::getSubService() {
+	return tcData->dataField.service_subtype;
+}
+
+uint8_t TcPacketBase::getAcknowledgeFlags() {
+	return tcData->dataField.version_type_ack & 0b00001111;
+}
+
+const uint8_t* TcPacketBase::getApplicationData() const {
+	return &tcData->appData;
+}
+
+uint16_t TcPacketBase::getApplicationDataSize() {
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
+}
+
+uint16_t TcPacketBase::getErrorControl() {
+	uint16_t size = getApplicationDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tcData->appData;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TcPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getApplicationDataSize();
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
+	SpacePacketBase::setPacketDataLength(dataLen +
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+}
+
+uint8_t TcPacketBase::getSecondaryHeaderFlag() {
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
+}
+
+uint8_t TcPacketBase::getPusVersionNumber() {
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
+}
+
+void TcPacketBase::print() {
+	uint8_t * wholeData = getWholeData();
+	sif::debug << "TcPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < getFullSize(); ++count) {
+		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+}
+
+void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
+		uint8_t ack, uint8_t service, uint8_t subservice) {
+	initSpacePacketHeader(true, true, apid, sequenceCount);
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
+}
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 73076176..1cfe233b 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,204 +1,204 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <cstddef>
-
-/**
- * This struct defines a byte-wise structured PUS TC Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, the Source Id field is present with one byte.
- * @ingroup tmtcpackets
- */
-struct PUSTcDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t source_id;
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TcPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader dataField;
-	uint8_t appData;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telecommand packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TC Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
-public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TcPacketBase( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
-	/**
-	 * This command returns the CCSDS Secondary Header Flag.
-	 * It shall always be zero for PUS Packets. This is the
-	 * highest bit of the first byte of the Data Field Header.
-	 * @return	the CCSDS Secondary Header Flag
-	 */
-	uint8_t getSecondaryHeaderFlag();
-	/**
-	 * This command returns the TC Packet PUS Version Number.
-	 * The version number of ECSS PUS 2003 is 1.
-	 * It consists of the second to fourth highest bits of the
-	 * first byte.
-	 * @return
-	 */
-	uint8_t getPusVersionNumber();
-	/**
-	 * This is a getter for the packet's Ack field, which are the lowest four
-	 * bits of the first byte of the Data Field Header.
-	 *
-	 * It is packed in a uint8_t variable.
-	 * @return	The packet's PUS Ack field.
-	 */
-	uint8_t getAcknowledgeFlags();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Application data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's application data.
-	 * @return	A pointer to the PUS Application Data.
-	 */
-	const uint8_t* getApplicationData() const;
-	/**
-	 * This method calculates the size of the PUS Application data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Application Data (without Error Control
-	 * 		field)
-	 */
-	uint16_t getApplicationDataSize();
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Application Data. If no
-	 * Application Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Calculate full packet length from application data length.
-	 * @param appDataLen
-	 * @return
-	 */
-	static size_t calculateFullPacketLength(size_t appDataLen);
-};
-
-
-#endif /* TCPACKETBASE_H_ */
+#ifndef TCPACKETBASE_H_
+#define TCPACKETBASE_H_
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include <cstddef>
+
+/**
+ * This struct defines a byte-wise structured PUS TC Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, the Source Id field is present with one byte.
+ * @ingroup tmtcpackets
+ */
+struct PUSTcDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t source_id;
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TcPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telecommand packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TC Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TcPacketBase : public SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TcPacketPointer* tcData;
+public:
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
+	/**
+	 * With this constant for the acknowledge field responses on all levels are expected.
+	 */
+	static const uint8_t ACK_ALL = 0b1111;
+	/**
+	 * With this constant for the acknowledge field a response on acceptance is expected.
+	 */
+	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+	/**
+	 * With this constant for the acknowledge field a response on start of execution is expected.
+	 */
+	static const uint8_t ACK_START = 0b0010;
+	/**
+	 * With this constant for the acknowledge field responses on execution steps are expected.
+	 */
+	static const uint8_t ACK_STEP = 0b0100;
+	/**
+	 * With this constant for the acknowledge field a response on completion is expected.
+	 */
+	static const uint8_t ACK_COMPLETION = 0b1000;
+	/**
+	 * With this constant for the acknowledge field no responses are expected.
+	 */
+	static const uint8_t ACK_NONE = 0b000;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TcPacketBase( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TcPacketBase();
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param sequenceCount Sequence Count in the primary header.
+	 * @param ack Which acknowledeges are expected from the receiver.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 */
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
+	/**
+	 * This command returns the CCSDS Secondary Header Flag.
+	 * It shall always be zero for PUS Packets. This is the
+	 * highest bit of the first byte of the Data Field Header.
+	 * @return	the CCSDS Secondary Header Flag
+	 */
+	uint8_t getSecondaryHeaderFlag();
+	/**
+	 * This command returns the TC Packet PUS Version Number.
+	 * The version number of ECSS PUS 2003 is 1.
+	 * It consists of the second to fourth highest bits of the
+	 * first byte.
+	 * @return
+	 */
+	uint8_t getPusVersionNumber();
+	/**
+	 * This is a getter for the packet's Ack field, which are the lowest four
+	 * bits of the first byte of the Data Field Header.
+	 *
+	 * It is packed in a uint8_t variable.
+	 * @return	The packet's PUS Ack field.
+	 */
+	uint8_t getAcknowledgeFlags();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Application data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's application data.
+	 * @return	A pointer to the PUS Application Data.
+	 */
+	const uint8_t* getApplicationData() const;
+	/**
+	 * This method calculates the size of the PUS Application data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Application Data (without Error Control
+	 * 		field)
+	 */
+	uint16_t getApplicationDataSize();
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Application Data. If no
+	 * Application Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telecommand Packet.
+	 */
+	void setData( const uint8_t* pData );
+
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
+};
+
+
+#endif /* TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 64aa74dc..3f10cac0 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,118 +1,118 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-
-#include <cstring>
-
-TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
-}
-
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
-		TcPacketBase(nullptr) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
-		return;
-	}
-	uint8_t* p_data = nullptr;
-	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != this->store->RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get free element from store!"
-				<< std::endl;
-		return;
-	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->appData, data, size);
-	this->setPacketDataLength(
-			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	this->setErrorControl();
-}
-
-ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
-		size_t* dataSize) {
-	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
-	}
-	return result;
-}
-
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->checkAndSetStore();
-
-}
-
-ReturnValue_t TcPacketStored::deletePacket() {
-	ReturnValue_t result = this->store->deleteData(this->storeAddress);
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
-	return result;
-}
-
-bool TcPacketStored::checkAndSetStore() {
-	if (this->store == NULL) {
-		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == NULL) {
-			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-void TcPacketStored::setStoreAddress(store_address_t setAddress) {
-	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
-				&temp_size);
-	}
-	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
-	} else {
-		this->setData(NULL);
-		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-store_address_t TcPacketStored::getStoreAddress() {
-	return this->storeAddress;
-}
-
-bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
-			&temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		if (this->getFullSize() == temp_size) {
-			return true;
-		}
-	}
-	return false;
-}
-
-StorageManagerIF* TcPacketStored::store = NULL;
-
-TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
-		TcPacketBase(data) {
-	if (getFullSize() != size) {
-		return;
-	}
-	if (this->checkAndSetStore()) {
-		ReturnValue_t status = store->addData(&storeAddress, data, size);
-		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
-		}
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketStored.h"
+
+#include <cstring>
+
+TcPacketStored::TcPacketStored(store_address_t setAddress) :
+		TcPacketBase(nullptr), storeAddress(setAddress) {
+	this->setStoreAddress(this->storeAddress);
+}
+
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
+		TcPacketBase(nullptr) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!this->checkAndSetStore()) {
+		return;
+	}
+	uint8_t* p_data = nullptr;
+	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
+			(TC_PACKET_MIN_SIZE + size), &p_data);
+	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
+		return;
+	}
+	this->setData(p_data);
+	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	memcpy(&tcData->appData, data, size);
+	this->setPacketDataLength(
+			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	this->setErrorControl();
+}
+
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
+TcPacketStored::TcPacketStored() :
+		TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->checkAndSetStore();
+
+}
+
+ReturnValue_t TcPacketStored::deletePacket() {
+	ReturnValue_t result = this->store->deleteData(this->storeAddress);
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL);
+	return result;
+}
+
+bool TcPacketStored::checkAndSetStore() {
+	if (this->store == NULL) {
+		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+		if (this->store == NULL) {
+			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+void TcPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+	if (this->checkAndSetStore()) {
+		status = this->store->getData(this->storeAddress, &temp_data,
+				&temp_size);
+	}
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+store_address_t TcPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+bool TcPacketStored::isSizeCorrect() {
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
+			&temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		if (this->getFullSize() == temp_size) {
+			return true;
+		}
+	}
+	return false;
+}
+
+StorageManagerIF* TcPacketStored::store = NULL;
+
+TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
+		TcPacketBase(data) {
+	if (getFullSize() != size) {
+		return;
+	}
+	if (this->checkAndSetStore()) {
+		ReturnValue_t status = store->addData(&storeAddress, data, size);
+		if (status != HasReturnvaluesIF::RETURN_OK) {
+			this->setData(NULL);
+		}
+	}
+}
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index de3eb85f..90cf2fba 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,110 +1,110 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
-
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-
-/**
- *	This class generates a ECSS PUS Telecommand packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TcPacketStored();
-	/**
-	 * With this constructor, the class instance is linked to an existing
-	 * packet in the packet store.
-	 * The packet content is neither checked nor changed with this call. If
-	 * the packet could not be found, the data pointer is set to NULL.
-	 */
-	TcPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telecommand Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
-	 * @param data		The data to be copied to the Application Data Field.
-	 * @param size		The amount of data to be copied.
-	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
-			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
-	/**
-	 * Another constructor to create a TcPacket from a raw packet stream.
-	 * Takes the data and adds it unchecked to the TcStore.
-	 * @param data	Pointer to the complete TC Space Packet.
-	 * @param Size size of the packet.
-	 */
-	TcPacketStored( const uint8_t* data, uint32_t size);
-
-	ReturnValue_t getData(const uint8_t ** dataPtr,
-			size_t* dataSize);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 * @return	returncode from deleting the data.
-	 */
-	ReturnValue_t deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-	/**
-	 * This method performs a size check.
-	 * It reads the stored size and compares it with the size entered in the
-	 * packet header. This class is the optimal place for such a check as it
-	 * has access to both the header data and the store.
-	 * @return	true if size is correct, false if packet is not registered in
-	 * 			store or size is incorrect.
-	 */
-	bool isSizeCorrect();
-};
-
-
-#endif /* TCPACKETSTORED_H_ */
+#ifndef TCPACKETSTORED_H_
+#define TCPACKETSTORED_H_
+
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+
+/**
+ *	This class generates a ECSS PUS Telecommand packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TcPacketStored : public TcPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TC_STORE.
+	 */
+	static StorageManagerIF* store;
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TcPacketStored();
+	/**
+	 * With this constructor, the class instance is linked to an existing
+	 * packet in the packet store.
+	 * The packet content is neither checked nor changed with this call. If
+	 * the packet could not be found, the data pointer is set to NULL.
+	 */
+	TcPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telecommand Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * @param apid			Sets the packet's APID field.
+	 * @param ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the destination service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the destination sub-service.
+	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * @param data		The data to be copied to the Application Data Field.
+	 * @param size		The amount of data to be copied.
+	 */
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+	/**
+	 * Another constructor to create a TcPacket from a raw packet stream.
+	 * Takes the data and adds it unchecked to the TcStore.
+	 * @param data	Pointer to the complete TC Space Packet.
+	 * @param Size size of the packet.
+	 */
+	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 * @return	returncode from deleting the data.
+	 */
+	ReturnValue_t deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+	/**
+	 * This method performs a size check.
+	 * It reads the stored size and compares it with the size entered in the
+	 * packet header. This class is the optimal place for such a check as it
+	 * has access to both the header data and the store.
+	 * @return	true if size is correct, false if packet is not registered in
+	 * 			store or size is incorrect.
+	 */
+	bool isSizeCorrect();
+};
+
+
+#endif /* TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index a2c27ce1..630471cc 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,119 +1,119 @@
-#include <framework/globalfunctions/CRC.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TmPacketBase.h>
-#include <framework/timemanager/CCSDSTime.h>
-#include <string.h>
-
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
-}
-
-TmPacketBase::~TmPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
-}
-
-uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
-			- CRC_SIZE + 1;
-}
-
-uint16_t TmPacketBase::getErrorControl() {
-	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TmPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getSourceDataSize();
-	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
-	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TmPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
-}
-
-void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
-}
-
-bool TmPacketBase::checkAndSetStamper() {
-	if (timeStamper == NULL) {
-		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
-		if (timeStamper == NULL) {
-			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
-}
-
-uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
-
-}
-
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
-	//Set primary header:
-	initSpacePacketHeader(false, true, apid);
-	//Set data Field Header:
-	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
-	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
-	//Timestamp packet
-	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
-	}
-}
-
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
-void TmPacketBase::setSourceDataSize(uint16_t size) {
-	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
-}
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
+#include "../../globalfunctions/CRC.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../timemanager/CCSDSTime.h"
+#include <string.h>
+
+TmPacketBase::TmPacketBase(uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tm_data = (TmPacketPointer*) set_data;
+}
+
+TmPacketBase::~TmPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TmPacketBase::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketBase::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t* TmPacketBase::getSourceData() {
+	return &tm_data->data;
+}
+
+uint16_t TmPacketBase::getSourceDataSize() {
+	return getPacketDataLength() - sizeof(tm_data->data_field)
+			- CRC_SIZE + 1;
+}
+
+uint16_t TmPacketBase::getErrorControl() {
+	uint32_t size = getSourceDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tm_data->data;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TmPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getSourceDataSize();
+	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
+	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TmPacketBase::setData(const uint8_t* p_Data) {
+	SpacePacketBase::setData(p_Data);
+	tm_data = (TmPacketPointer*) p_Data;
+}
+
+void TmPacketBase::print() {
+	/*uint8_t * wholeData = getWholeData();
+	 debug << "TmPacket contains: " << std::endl;
+	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
+	 debug << std::hex << (uint16_t)wholeData[count] << " ";
+	 }
+	 debug << std::dec << std::endl;*/
+}
+
+bool TmPacketBase::checkAndSetStamper() {
+	if (timeStamper == NULL) {
+		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
+		if (timeStamper == NULL) {
+			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
+	uint32_t tempSize = 0;
+	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
+			&tempSize, sizeof(tm_data->data_field.time));
+}
+
+uint8_t* TmPacketBase::getPacketTimeRaw() const{
+	return tm_data->data_field.time;
+
+}
+
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+	//Set primary header:
+	initSpacePacketHeader(false, true, apid);
+	//Set data Field Header:
+	//First, set to zero.
+	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
+	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
+	// The other 4 bits of the first byte are the spacecraft time reference status
+	// To change to PUS-C, set 0b00100000
+	tm_data->data_field.version_type_ack = 0b00010000;
+	tm_data->data_field.service_type = service;
+	tm_data->data_field.service_subtype = subservice;
+	tm_data->data_field.subcounter = packetSubcounter;
+	//Timestamp packet
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+	}
+}
+
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
+void TmPacketBase::setSourceDataSize(uint16_t size) {
+	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+uint32_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tm_data->data_field.time);
+}
+
+TimeStamperIF* TmPacketBase::timeStamper = NULL;
+object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index 6f3c4b59..acd08d72 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,186 +1,186 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
-
-#include <framework/timemanager/TimeStamperIF.h>
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/timemanager/Clock.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * This struct defines a byte-wise structured PUS TM Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
- * @ingroup tmtcpackets
- */
-struct PUSTmDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t subcounter;
-//	uint8_t destination;
-	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TmPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTmDataFieldHeader data_field;
-	uint8_t data;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telemetry packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TM Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TmPacketBase : public SpacePacketBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
-	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketBase( uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Source data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's source data.
-	 * @return	A pointer to the PUS Source Data.
-	 */
-	uint8_t* getSourceData();
-	/**
-	 * This method calculates the size of the PUS Source data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Source Data (without Error Control field)
-	 */
-	uint16_t getSourceDataSize();
-
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Source Data. If no
-	 * Source Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
-	 * @return Converted timestamp of packet.
-	 */
-	ReturnValue_t getPacketTime(timeval* timestamp) const;
-	/**
-	 * Returns a raw pointer to the beginning of the time field.
-	 * @return Raw pointer to time field.
-	 */
-	uint8_t* getPacketTimeRaw() const;
-
-	uint32_t getTimestampSize() const;
-
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketPointer* tm_data;
-	/**
-	 * The timeStamper is responsible for adding a timestamp to the packet.
-	 * It is initialized lazy.
-	 */
-	static TimeStamperIF* timeStamper;
-
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
-};
-
-
-#endif /* TMPACKETBASE_H_ */
+#ifndef TMPACKETBASE_H_
+#define TMPACKETBASE_H_
+
+#include "../../timemanager/TimeStamperIF.h"
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../timemanager/Clock.h"
+#include "../../objectmanager/SystemObjectIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * This struct defines a byte-wise structured PUS TM Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, no Destination field is present, but an eigth-byte representation
+ * for a time tag [TBD].
+ * @ingroup tmtcpackets
+ */
+struct PUSTmDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t subcounter;
+//	uint8_t destination;
+	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TmPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTmDataFieldHeader data_field;
+	uint8_t data;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telemetry packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TM Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TmPacketBase : public SpacePacketBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
+	 */
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketBase( uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketBase();
+	/**
+	 * Initializes the Tm Packet header.
+	 * Does set the timestamp (to now), but not the error control field.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Source data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's source data.
+	 * @return	A pointer to the PUS Source Data.
+	 */
+	uint8_t* getSourceData();
+	/**
+	 * This method calculates the size of the PUS Source data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Source Data (without Error Control field)
+	 */
+	uint16_t getSourceDataSize();
+
+	/**
+	 * In case data was filled manually (almost never the case).
+	 * @param size Size of source data (without CRC and data filed header!).
+	 */
+	void setSourceDataSize(uint16_t size);
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Source Data. If no
+	 * Source Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telemetry Packet.
+	 */
+	void setData( const uint8_t* p_Data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * @return Converted timestamp of packet.
+	 */
+	ReturnValue_t getPacketTime(timeval* timestamp) const;
+	/**
+	 * Returns a raw pointer to the beginning of the time field.
+	 * @return Raw pointer to time field.
+	 */
+	uint8_t* getPacketTimeRaw() const;
+
+	uint32_t getTimestampSize() const;
+
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketPointer* tm_data;
+	/**
+	 * The timeStamper is responsible for adding a timestamp to the packet.
+	 * It is initialized lazy.
+	 */
+	static TimeStamperIF* timeStamper;
+
+	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
+	/**
+	 * Checks if a time stamper is available and tries to set it if not.
+	 * @return Returns false if setting failed.
+	 */
+	bool checkAndSetStamper();
+};
+
+
+#endif /* TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index 9df0fe5d..ee56d46f 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,45 +1,45 @@
-#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
-#include <stddef.h>
-#include <time.h>
-#include <framework/tmtcpacket/pus/PacketTimestampInterpreterIF.h>
-
-TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
-	this->tm_data = (TmPacketMinimalPointer*)set_data;
-}
-
-TmPacketMinimal::~TmPacketMinimal() {
-}
-
-uint8_t TmPacketMinimal::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketMinimal::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t TmPacketMinimal::getPacketSubcounter() {
-	return tm_data->data_field.subcounter;
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTime(this, timestamp);
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
-}
-
-void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
-	if (TmPacketMinimal::timestampInterpreter == NULL) {
-		TmPacketMinimal::timestampInterpreter = interpreter;
-	}
-}
-
-PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include <stddef.h>
+#include <time.h>
+#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+
+TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
+	this->tm_data = (TmPacketMinimalPointer*)set_data;
+}
+
+TmPacketMinimal::~TmPacketMinimal() {
+}
+
+uint8_t TmPacketMinimal::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketMinimal::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t TmPacketMinimal::getPacketSubcounter() {
+	return tm_data->data_field.subcounter;
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTime(this, timestamp);
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
+}
+
+void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
+	if (TmPacketMinimal::timestampInterpreter == NULL) {
+		TmPacketMinimal::timestampInterpreter = interpreter;
+	}
+}
+
+PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
diff --git a/tmtcpacket/pus/TmPacketMinimal.h b/tmtcpacket/pus/TmPacketMinimal.h
index 7bfe0883..e7b362bf 100644
--- a/tmtcpacket/pus/TmPacketMinimal.h
+++ b/tmtcpacket/pus/TmPacketMinimal.h
@@ -1,84 +1,84 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-
-
-#include <framework/tmtcpacket/SpacePacketBase.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-
-struct timeval;
-class PacketTimestampInterpreterIF;
-/**
- * This is a minimal version of a PUS TmPacket without any variable field, or,
- * in other words with Service Type, Subtype and subcounter only.
- * This is required for handling TM packets with different APIDs with different
- * secondary headers.
- */
-class TmPacketMinimal : public SpacePacketBase {
-public:
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketMinimal( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketMinimal();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * Returns the subcounter.
-	 * @return the subcounter of the Data Field Header.
-	 */
-	uint8_t getPacketSubcounter();
-	struct PUSTmMinimalHeader {
-		uint8_t version_type_ack;
-		uint8_t service_type;
-		uint8_t service_subtype;
-		uint8_t subcounter;
-	};
-
-	ReturnValue_t getPacketTime(timeval* timestamp);
-
-	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
-
-	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
-	/**
-	 * This struct defines the data structure of a PUS Telecommand Packet when
-	 * accessed via a pointer.
-	 * @ingroup tmtcpackets
-	 */
-	struct TmPacketMinimalPointer {
-		CCSDSPrimaryHeader primary;
-		PUSTmMinimalHeader data_field;
-		uint8_t rest;
-	};
-	//Must include a checksum and is therefore at least one larger than the above struct.
-	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketMinimalPointer* tm_data;
-
-	static PacketTimestampInterpreterIF* timestampInterpreter;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+struct timeval;
+class PacketTimestampInterpreterIF;
+/**
+ * This is a minimal version of a PUS TmPacket without any variable field, or,
+ * in other words with Service Type, Subtype and subcounter only.
+ * This is required for handling TM packets with different APIDs with different
+ * secondary headers.
+ */
+class TmPacketMinimal : public SpacePacketBase {
+public:
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketMinimal( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketMinimal();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * Returns the subcounter.
+	 * @return the subcounter of the Data Field Header.
+	 */
+	uint8_t getPacketSubcounter();
+	struct PUSTmMinimalHeader {
+		uint8_t version_type_ack;
+		uint8_t service_type;
+		uint8_t service_subtype;
+		uint8_t subcounter;
+	};
+
+	ReturnValue_t getPacketTime(timeval* timestamp);
+
+	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
+
+	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
+	/**
+	 * This struct defines the data structure of a PUS Telecommand Packet when
+	 * accessed via a pointer.
+	 * @ingroup tmtcpackets
+	 */
+	struct TmPacketMinimalPointer {
+		CCSDSPrimaryHeader primary;
+		PUSTmMinimalHeader data_field;
+		uint8_t rest;
+	};
+	//Must include a checksum and is therefore at least one larger than the above struct.
+	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketMinimalPointer* tm_data;
+
+	static PacketTimestampInterpreterIF* timestampInterpreter;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 6eb852f0..e42f8cda 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,145 +1,145 @@
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
-
-TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
-	setStoreAddress(storeAddress);
-}
-
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	uint8_t *pData = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
-
-	if (returnValue != store->RETURN_OK) {
-		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
-		checkAndReportLostTm();
-		return;
-	}
-	setData(pData);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	memcpy(getSourceData(), headerData, headerSize);
-	memcpy(getSourceData() + headerSize, data, size);
-	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-// todo: Endianness flags as optional parameter?
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF *header) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	size_t sourceDataSize = 0;
-	if (content != NULL) {
-		sourceDataSize += content->getSerializedSize();
-	}
-	if (header != NULL) {
-		sourceDataSize += header->getSerializedSize();
-	}
-	uint8_t *p_data = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
-	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
-	}
-	setData(p_data);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t *putDataHere = getSourceData();
-	size_t size = 0;
-	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-store_address_t TmPacketStored::getStoreAddress() {
-	return storeAddress;
-}
-
-void TmPacketStored::deletePacket() {
-	store->deleteData(storeAddress);
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
-}
-
-void TmPacketStored::setStoreAddress(store_address_t setAddress) {
-	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
-	} else {
-		setData(NULL);
-		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
-		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
-			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
-ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
-		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
-		//SHOULDDO: More decent code.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-			&tmMessage, sentFrom);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		deletePacket();
-		if (doErrorReporting) {
-			checkAndReportLostTm();
-		}
-		return result;
-	}
-	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
-		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-				objects::INTERNAL_ERROR_REPORTER);
-	}
-	if (internalErrorReporter != NULL) {
-		internalErrorReporter->lostTm();
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketStored.h"
+#include "../../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+TmPacketStored::TmPacketStored(store_address_t setAddress) :
+		TmPacketBase(NULL), storeAddress(setAddress) {
+	setStoreAddress(storeAddress);
+}
+
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	uint8_t *pData = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
+
+	if (returnValue != store->RETURN_OK) {
+		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+		checkAndReportLostTm();
+		return;
+	}
+	setData(pData);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	memcpy(getSourceData(), headerData, headerSize);
+	memcpy(getSourceData() + headerSize, data, size);
+	setPacketDataLength(
+			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+// todo: Endianness flags as optional parameter?
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	size_t sourceDataSize = 0;
+	if (content != NULL) {
+		sourceDataSize += content->getSerializedSize();
+	}
+	if (header != NULL) {
+		sourceDataSize += header->getSerializedSize();
+	}
+	uint8_t *p_data = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
+	if (returnValue != store->RETURN_OK) {
+		checkAndReportLostTm();
+	}
+	setData(p_data);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
+	if (header != NULL) {
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	if (content != NULL) {
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	setPacketDataLength(
+			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+store_address_t TmPacketStored::getStoreAddress() {
+	return storeAddress;
+}
+
+void TmPacketStored::deletePacket() {
+	store->deleteData(storeAddress);
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	setData(NULL);
+}
+
+void TmPacketStored::setStoreAddress(store_address_t setAddress) {
+	storeAddress = setAddress;
+	const uint8_t *temp_data = NULL;
+	size_t temp_size;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		setData(temp_data);
+	} else {
+		setData(NULL);
+		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+bool TmPacketStored::checkAndSetStore() {
+	if (store == NULL) {
+		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+		if (store == NULL) {
+			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
+
+ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
+		MessageQueueId_t sentFrom, bool doErrorReporting) {
+	if (getWholeData() == NULL) {
+		//SHOULDDO: More decent code.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TmTcMessage tmMessage(getStoreAddress());
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		deletePacket();
+		if (doErrorReporting) {
+			checkAndReportLostTm();
+		}
+		return result;
+	}
+	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void TmPacketStored::checkAndReportLostTm() {
+	if (internalErrorReporter == NULL) {
+		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+				objects::INTERNAL_ERROR_REPORTER);
+	}
+	if (internalErrorReporter != NULL) {
+		internalErrorReporter->lostTm();
+	}
+}
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index eaa26ce7..195c3272 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,96 +1,96 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
-
-#include <framework/serialize/SerializeIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcpacket/pus/TmPacketBase.h>
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- *	This class generates a ECSS PUS Telemetry packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TmPacketStored : public TmPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TM_STORE.
-	 */
-	static StorageManagerIF* store;
-
-	static InternalErrorReporterIF *internalErrorReporter;
-
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
-};
-
-
-#endif /* TMPACKETSTORED_H_ */
+#ifndef TMPACKETSTORED_H_
+#define TMPACKETSTORED_H_
+
+#include "../../serialize/SerializeIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+
+/**
+ *	This class generates a ECSS PUS Telemetry packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TmPacketStored : public TmPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TM_STORE.
+	 */
+	static StorageManagerIF* store;
+
+	static InternalErrorReporterIF *internalErrorReporter;
+
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+
+	void checkAndReportLostTm();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet from two separate data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+};
+
+
+#endif /* TMPACKETSTORED_H_ */
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 2878dd5d..13928df5 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,43 +1,43 @@
-#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telecommands.
- * @details	Any service receiving telecommands shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelecommandsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
-	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelecommandsIF() {
-
-	}
-	/**
-	 * @brief	Getter for the service id.
-	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service ID. If the receiver can handle Telecommands, but for
-	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service ID or 0.
-	 */
-	virtual uint16_t getIdentifier() = 0;
-	/**
-	 * @brief	This method returns the message queue id of the telecommand
-	 * 			receiving message queue.
-	 * @return	The telecommand reception message queue id.
-	 */
-	virtual MessageQueueId_t getRequestQueue() = 0;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telecommands.
+ * @details	Any service receiving telecommands shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelecommandsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelecommandsIF() {
+
+	}
+	/**
+	 * @brief	Getter for the service id.
+	 * @details	Any receiving service (at least any PUS service) shall have a
+	 * 			service ID. If the receiver can handle Telecommands, but for
+	 * 			some reason has no service id, it shall return 0.
+	 * @return	The service ID or 0.
+	 */
+	virtual uint16_t getIdentifier() = 0;
+	/**
+	 * @brief	This method returns the message queue id of the telecommand
+	 * 			receiving message queue.
+	 * @return	The telecommand reception message queue id.
+	 */
+	virtual MessageQueueId_t getRequestQueue() = 0;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index 8c00b5c6..bcb38666 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,26 +1,26 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telemetry.
- * @details	Any object receiving telemetry shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelemetryIF {
-public:
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelemetryIF() {
-	}
-	/**
-	 * @brief	This method returns the message queue id of the telemetry
-	 * 			receiving message queue.
-	 * @return	The telemetry reception message queue id.
-	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
-};
-
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#ifndef ACCEPTSTELEMETRYIF_H_
+#define ACCEPTSTELEMETRYIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telemetry.
+ * @details	Any object receiving telemetry shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelemetryIF {
+public:
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelemetryIF() {
+	}
+	/**
+	 * @brief	This method returns the message queue id of the telemetry
+	 * 			receiving message queue.
+	 * @return	The telemetry reception message queue id.
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+};
+
+#endif /* ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index fe8bb288..a312390e 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,15 +1,15 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
-
-#include <framework/ipc/MessageQueueSenderIF.h>
-
-class AcceptsVerifyMessageIF {
-public:
-	virtual ~AcceptsVerifyMessageIF() {
-
-	}
-	virtual MessageQueueId_t getVerificationQueue() = 0;
-};
-
-
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsVerifyMessageIF {
+public:
+	virtual ~AcceptsVerifyMessageIF() {
+
+	}
+	virtual MessageQueueId_t getVerificationQueue() = 0;
+};
+
+
+#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 330fd00f..3325b10b 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,427 +1,427 @@
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
-
-#include <framework/tmtcservices/CommandingServiceBase.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-
-object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
-
-CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
-		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-}
-
-void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
-	this->packetSource = packetSource;
-}
-
-void CommandingServiceBase::setPacketDestination(
-		object_id_t packetDestination) {
-	this->packetDestination = packetDestination;
-}
-
-
-CommandingServiceBase::~CommandingServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-
-ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	handleRequestQueue();
-	checkTimeout();
-	doPeriodicOperation();
-	return RETURN_OK;
-}
-
-
-uint16_t CommandingServiceBase::getIdentifier() {
-	return service;
-}
-
-
-MessageQueueId_t CommandingServiceBase::getRequestQueue() {
-	return requestQueue->getId();
-}
-
-
-ReturnValue_t CommandingServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(packetDestination == objects::NO_OBJECT) {
-	    packetDestination = defaultPacketDestination;
-	}
-	AcceptsTelemetryIF* packetForwarding =
-			objectManager->get<AcceptsTelemetryIF>(packetDestination);
-
-	if(packetSource == objects::NO_OBJECT) {
-	    packetSource = defaultPacketSource;
-	}
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-
-	if (packetForwarding == nullptr or distributor == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: Packet source or "
-	            "packet destination invalid!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	distributor->registerService(this);
-	requestQueue->setDefaultDestination(
-			packetForwarding->getReportReceptionQueue());
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-
-	if (IPCStore == nullptr or TCStore == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
-	                    "not initialized yet!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	return RETURN_OK;
-
-}
-
-void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply;
-	ReturnValue_t result = RETURN_FAILED;
-	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(&reply);
-	}
-}
-
-
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
-	bool isStep = false;
-	CommandMessage nextCommand;
-	CommandMapIter iter = commandMap.find(reply->getSender());
-
-	// handle unrequested reply first
-	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
-			iter == commandMap.end()) {
-		handleUnrequestedReply(reply);
-		return;
-	}
-	nextCommand.setCommand(CommandMessage::CMD_NONE);
-
-
-	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
-
-	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
-	 * failure verification will be generated with the reason as the
-	 * return code and the initial command as failure parameter 1 */
-	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
-			(result == RETURN_FAILED or result == INVALID_REPLY)) {
-	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
-	}
-
-	switch (result) {
-	case EXECUTION_COMPLETE:
-	case RETURN_OK:
-	case NO_STEP_MESSAGE:
-		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
-		break;
-	case INVALID_REPLY:
-		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(reply);
-		break;
-	default:
-		if (isStep) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
-					failureParameter2);
-		} else {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, 0, failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-		break;
-	}
-
-}
-
-void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand,
-		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
-
-	// In case a new command is to be sent immediately, this is performed here.
-	// If no new command is sent, only analyse reply result by initializing
-	// sendResult as RETURN_OK
-	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply->getSender(),
-				nextCommand);
-	}
-
-	if (sendResult == RETURN_OK) {
-		if (isStep and result != NO_STEP_MESSAGE) {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
-		}
-		else {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
-			checkAndExecuteFifo(iter);
-		}
-	}
-	else {
-		if (isStep) {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
-		} else {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
-					failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-	}
-}
-
-void CommandingServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result;
-	store_address_t address;
-	TcPacketStored packet;
-	MessageQueueId_t queue;
-	object_id_t objectId;
-	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
-			result = requestQueue->receiveMessage(&message)) {
-		address = message.getStorageId();
-		packet.setStoreAddress(address);
-
-		if ((packet.getSubService() == 0)
-				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
-			continue;
-		}
-		result = getMessageQueueAndObject(packet.getSubService(),
-				packet.getApplicationData(), packet.getApplicationDataSize(),
-				&queue, &objectId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
-			continue;
-		}
-
-		//Is a command already active for the target object?
-		CommandMapIter iter;
-		iter = commandMap.find(queue);
-
-		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
-			}
-		} else {
-			CommandInfo newInfo; //Info will be set by startExecution if neccessary
-			newInfo.objectId = objectId;
-			result = commandMap.insert(queue, newInfo, &iter);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
-			} else {
-				startExecution(&packet, iter);
-			}
-		}
-
-	}
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
-		size_t headerSize) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, headerData, headerSize);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-	return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        object_id_t objectId, const uint8_t *data, size_t dataLen) {
-    uint8_t buffer[sizeof(object_id_t)];
-    uint8_t* pBuffer = buffer;
-    size_t size = 0;
-    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-                sizeof(object_id_t), SerializeIF::Endianness::BIG);
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, data, dataLen, buffer, size);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        SerializeIF* content, SerializeIF* header) {
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, content, header);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
-        CommandMapIter iter) {
-    ReturnValue_t result = RETURN_OK;
-    CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
-            storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
-
-    ReturnValue_t sendResult = RETURN_OK;
-	switch (result) {
-	case RETURN_OK:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
-					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	case EXECUTION_COMPLETE:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			//Fire-and-forget command.
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
-					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
-			checkAndExecuteFifo(iter);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
-		checkAndExecuteFifo(iter);
-		break;
-	}
-}
-
-
-void CommandingServiceBase::rejectPacket(uint8_t report_id,
-		TcPacketStored* packet, ReturnValue_t error_code) {
-	verificationReporter.sendFailureReport(report_id, packet, error_code);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::acceptPacket(uint8_t reportId,
-		TcPacketStored* packet) {
-	verificationReporter.sendSuccessReport(reportId, packet);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
-	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
-	} else {
-		TcPacketStored newPacket(address);
-		startExecution(&newPacket, iter);
-	}
-}
-
-
-void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clearCommandMessage();
-}
-
-
-inline void CommandingServiceBase::doPeriodicOperation() {
-}
-
-MessageQueueId_t CommandingServiceBase::getCommandQueue() {
-	return commandQueue->getId();
-}
-
-void CommandingServiceBase::checkTimeout() {
-	uint32_t uptime;
-	Clock::getUptime(&uptime);
-	CommandMapIter iter;
-	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					TIMEOUT);
-			checkAndExecuteFifo(iter);
-		}
-	}
-}
-
-void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
-    executingTask = task_;
-}
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../tmtcservices/CommandingServiceBase.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
+		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+}
+
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
+
+CommandingServiceBase::~CommandingServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+
+ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	handleRequestQueue();
+	checkTimeout();
+	doPeriodicOperation();
+	return RETURN_OK;
+}
+
+
+uint16_t CommandingServiceBase::getIdentifier() {
+	return service;
+}
+
+
+MessageQueueId_t CommandingServiceBase::getRequestQueue() {
+	return requestQueue->getId();
+}
+
+
+ReturnValue_t CommandingServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
+	AcceptsTelemetryIF* packetForwarding =
+			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+
+	if (packetForwarding == nullptr or distributor == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	distributor->registerService(this);
+	requestQueue->setDefaultDestination(
+			packetForwarding->getReportReceptionQueue());
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+
+	if (IPCStore == nullptr or TCStore == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	return RETURN_OK;
+
+}
+
+void CommandingServiceBase::handleCommandQueue() {
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
+	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&reply)) {
+		handleCommandMessage(&reply);
+	}
+}
+
+
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
+	}
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
+	iter->command = nextCommand->getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+	}
+}
+
+void CommandingServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result;
+	store_address_t address;
+	TcPacketStored packet;
+	MessageQueueId_t queue;
+	object_id_t objectId;
+	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
+			result = requestQueue->receiveMessage(&message)) {
+		address = message.getStorageId();
+		packet.setStoreAddress(address);
+
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			continue;
+		}
+		result = getMessageQueueAndObject(packet.getSubService(),
+				packet.getApplicationData(), packet.getApplicationDataSize(),
+				&queue, &objectId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			continue;
+		}
+
+		//Is a command already active for the target object?
+		CommandMapIter iter;
+		iter = commandMap.find(queue);
+
+		if (iter != commandMap.end()) {
+			result = iter->fifo.insert(address);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+			}
+		} else {
+			CommandInfo newInfo; //Info will be set by startExecution if neccessary
+			newInfo.objectId = objectId;
+			result = commandMap.insert(queue, newInfo, &iter);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+			} else {
+				startExecution(&packet, iter);
+			}
+		}
+
+	}
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
+	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+			this->tmPacketCounter, data, dataLen, headerData, headerSize);
+	ReturnValue_t result = tmPacketStored.sendPacket(
+			requestQueue->getDefaultDestination(), requestQueue->getId());
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		this->tmPacketCounter++;
+	}
+	return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
+        CommandMapIter iter) {
+    ReturnValue_t result = RETURN_OK;
+    CommandMessage command;
+    iter->subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->subservice,
+            storedPacket->getApplicationData(),
+            storedPacket->getApplicationDataSize(), &iter->state,
+            iter->objectId);
+
+    ReturnValue_t sendResult = RETURN_OK;
+	switch (result) {
+	case RETURN_OK:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			Clock::getUptime(&iter->uptimeOfStart);
+			iter->step = 0;
+			iter->subservice = storedPacket->getSubService();
+			iter->command = command.getCommand();
+			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->tcInfo.tcSequenceControl =
+					storedPacket->getPacketSequenceControl();
+			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	case EXECUTION_COMPLETE:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			//Fire-and-forget command.
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+					storedPacket);
+			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			checkAndExecuteFifo(iter);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	default:
+		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		checkAndExecuteFifo(iter);
+		break;
+	}
+}
+
+
+void CommandingServiceBase::rejectPacket(uint8_t report_id,
+		TcPacketStored* packet, ReturnValue_t error_code) {
+	verificationReporter.sendFailureReport(report_id, packet, error_code);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::acceptPacket(uint8_t reportId,
+		TcPacketStored* packet) {
+	verificationReporter.sendSuccessReport(reportId, packet);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+	store_address_t address;
+	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+		commandMap.erase(&iter);
+	} else {
+		TcPacketStored newPacket(address);
+		startExecution(&newPacket, iter);
+	}
+}
+
+
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clearCommandMessage();
+}
+
+
+inline void CommandingServiceBase::doPeriodicOperation() {
+}
+
+MessageQueueId_t CommandingServiceBase::getCommandQueue() {
+	return commandQueue->getId();
+}
+
+void CommandingServiceBase::checkTimeout() {
+	uint32_t uptime;
+	Clock::getUptime(&uptime);
+	CommandMapIter iter;
+	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TIMEOUT);
+			checkAndExecuteFifo(iter);
+		}
+	}
+}
+
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index b3a15985..32173d81 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,348 +1,348 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-
-#include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/ipc/CommandMessage.h>
-#include <framework/container/FixedMap.h>
-#include <framework/container/FIFO.h>
-#include <framework/serialize/SerializeIF.h>
-
-class TcPacketStored;
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This class is the basis for all PUS Services, which have to
- * 			relay Telecommands to software bus.
- *
- * It manages Telecommand reception and the generation of Verification Reports
- * similar to PusServiceBase. This class is used if a telecommand can't be
- * handled immediately and must be relayed to the internal software bus.
- *   - isValidSubservice
- *   - getMessageQueueAndObject
- *   - prepareCommand
- *   - handleReply
- * @author gaisser
- * @ingroup pus_services
- */
-class CommandingServiceBase: public SystemObject,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
-	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
-
-	/**
-	 * Class constructor. Initializes two important MessageQueues:
-	 * commandQueue for command reception and requestQueue for device reception
-	 * @param setObjectId
-	 * @param apid
-	 * @param service
-	 * @param numberOfParallelCommands
-	 * @param commandTimeout_seconds
-	 * @param setPacketSource
-	 * @param setPacketDestination
-	 * @param queueDepth
-	 */
-	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
-			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
-	virtual ~CommandingServiceBase();
-
-	/**
-	 * This setter can be used to set the packet source individually instead
-	 * of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetSource
-	 */
-	void setPacketSource(object_id_t packetSource);
-	/**
-	 * This setter can be used to set the packet destination individually
-	 * instead of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetDestination
-	 */
-	void setPacketDestination(object_id_t packetDestination);
-
-	/***
-	 * This is the periodically called function.
-	 * Handle request queue for external commands.
-	 * Handle command Queue for internal commands.
-	 * @param opCode is unused here at the moment
-	 * @return RETURN_OK
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual uint16_t getIdentifier();
-
-	/**
-	 * Returns the requestQueue MessageQueueId_t
-	 *
-	 * The requestQueue is the queue for external commands (TC)
-	 *
-	 * @return requestQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getRequestQueue();
-
-	/**
-	 * Returns the commandQueue MessageQueueId_t
-	 *
-	 * Remember the CommandQueue is the queue for internal communication
-	 * @return commandQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getCommandQueue();
-
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * 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) override;
-
-protected:
-	/**
-	 * Check the target subservice
-	 * @param subservice[in]
-	 * @return
-	 * -@c RETURN_OK Subservice valid, continue message handling
-     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its
-	 * target interface is checked and retrieved. The target message queue ID
-	 * can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return
-	 * - @c RETURN_OK Cotinue message handling
-	 * - @c RETURN_FAILED Reject the packet and generates a start failure
-	 *      verification
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined, the command is
-	 * prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object. It contains all necessary information
-	 * for the device to execute telecommands.
-	 * @param message [out] message which can be set and is sent to the object
-	 * @param subservice Subservice of the current communication
-	 * @param tcData Application data of command
-	 * @param tcDataLen Application data length
-	 * @param state [out/in] Setable state of the communication.
-	 * communication
-	 * @param objectId Target object ID
-	 * @return
-	 * - @c RETURN_OK to generate a verification start message
-	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
-	 *      verification message.
-	 * - @c Anything else rejects the packets and generates a start failure
-	 *      verification.
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled.
-	 * @param reply
-	 * This is the reply in form of a generic read-only command message.
-	 * @param previousCommand
-	 * Command_t of related command
-	 * @param state [out/in]
-	 * Additional parameter which can be used to pass state information.
-	 * State of the communication
-	 * @param optionalNextCommand [out]
-	 * An optional next command which can be set in this function
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return
-	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
-	 *   generate TC verification success
-	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
-	 * 	 INVALID_REPLY is returned and the command ID is
-	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
-	 * 	 the reason as the error parameter and the initial command as
-	 * 	 failure parameter 1 is generated.
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-	/**
-	 * This function can be overidden to handle unrequested reply,
-	 * when the reply sender ID is unknown or is not found is the command map.
-	 * The default implementation will clear the command message and all
-	 * its contents.
-	 * @param reply
-	 * Reply which is non-const so the default implementation can clear the
-	 * message.
-	 */
-	virtual void handleUnrequestedReply(CommandMessage* reply);
-
-	virtual void doPeriodicOperation();
-
-
-	struct CommandInfo {
-		struct tcInfo {
-			uint8_t ackFlags;
-			uint16_t tcPacketId;
-			uint16_t tcSequenceControl;
-		} tcInfo;
-		uint32_t uptimeOfStart;
-		uint8_t step;
-		uint8_t subservice;
-		uint32_t state;
-		Command_t command;
-		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
-	};
-
-	using CommandMapIter = FixedMap<MessageQueueId_t,
-	        CommandingServiceBase::CommandInfo>::Iterator;
-
-	const uint16_t apid;
-
-	const uint8_t service;
-
-	const uint16_t timeoutSeconds;
-
-	uint8_t tmPacketCounter = 0;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-	StorageManagerIF *TCStore = nullptr;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	MessageQueueIF* requestQueue = nullptr;
-
-	VerificationReporter verificationReporter;
-
-	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
-
-	/* May be set be children to return a more precise failure condition. */
-	uint32_t failureParameter1 = 0;
-	uint32_t failureParameter2 = 0;
-
-	static object_id_t defaultPacketSource;
-	object_id_t packetSource = objects::NO_OBJECT;
-	static object_id_t defaultPacketDestination;
-	object_id_t packetDestination = objects::NO_OBJECT;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	/**
-	 * @brief   Send TM data from pointer to data.
-	 *          If a header is supplied it is added before data
-	 * @param subservice Number of subservice
-	 * @param data Pointer to the data in the Packet
-	 * @param dataLen Lenght of data in the Packet
-	 * @param headerData HeaderData will be placed before data
-	 * @param headerSize Size of HeaderData
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
-	        size_t dataLen, const uint8_t* headerData = nullptr,
-	        size_t headerSize = 0);
-
-	/**
-	 * @brief   To send TM packets of objects that still need to be serialized
-	 *          and consist of an object ID with appended data.
-	 * @param subservice Number of subservice
-	 * @param objectId ObjectId is placed before data
-	 * @param data Data to append to the packet
-	 * @param dataLen Length of Data
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, size_t dataLen);
-
-	/**
-	 * @brief   To send packets which are contained inside a class implementing
-	 *          SerializeIF.
-	 * @param subservice Number of subservice
-	 * @param content This is a pointer to the serialized packet
-	 * @param header Serialize IF header which will be placed before content
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = nullptr);
-
-	void checkAndExecuteFifo(CommandMapIter iter);
-
-private:
-	/**
-	 * This method handles internal execution of a command,
-	 * once it has been started by @sa{startExecution()} in the request
-	 * queue handler.
-	 * It handles replies generated by the devices and relayed by the specific
-	 * service implementation. This means that it determines further course of
-	 * action depending on the return values specified in the service
-	 * implementation.
-	 * This includes the generation of TC verification messages. Note that
-	 * the static framework object ID @c VerificationReporter::messageReceiver
-	 * needs to be set.
-	 *   - TM[1,5] Step Successs
-	 *   - TM[1,6] Step Failure
-	 *   - TM[1,7] Completion Success
-	 *   - TM[1,8] Completion Failure
-	 */
-	void handleCommandQueue();
-
-	/**
-	 * @brief       Handler function for request queue
-	 * @details
-	 * Sequence of request queue handling:
-	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates a Start Success Reports TM[1,3] in subfunction
-	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
-	 * TC Verification Service.
-	 */
-	void handleRequestQueue();
-
-	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
-			ReturnValue_t errorCode);
-
-	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
-
-	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
-
-	void handleCommandMessage(CommandMessage* reply);
-	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
-
-	void checkTimeout();
-};
-
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/CommandMessage.h"
+#include "../container/FixedMap.h"
+#include "../container/FIFO.h"
+#include "../serialize/SerializeIF.h"
+
+class TcPacketStored;
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
+ *
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
+ *   - isValidSubservice
+ *   - getMessageQueueAndObject
+ *   - prepareCommand
+ *   - handleReply
+ * @author gaisser
+ * @ingroup pus_services
+ */
+class CommandingServiceBase: public SystemObject,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
+
+	/**
+	 * Class constructor. Initializes two important MessageQueues:
+	 * commandQueue for command reception and requestQueue for device reception
+	 * @param setObjectId
+	 * @param apid
+	 * @param service
+	 * @param numberOfParallelCommands
+	 * @param commandTimeout_seconds
+	 * @param setPacketSource
+	 * @param setPacketDestination
+	 * @param queueDepth
+	 */
+	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
+			uint8_t service, uint8_t numberOfParallelCommands,
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
+	virtual ~CommandingServiceBase();
+
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
+	/***
+	 * This is the periodically called function.
+	 * Handle request queue for external commands.
+	 * Handle command Queue for internal commands.
+	 * @param opCode is unused here at the moment
+	 * @return RETURN_OK
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual uint16_t getIdentifier();
+
+	/**
+	 * Returns the requestQueue MessageQueueId_t
+	 *
+	 * The requestQueue is the queue for external commands (TC)
+	 *
+	 * @return requestQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getRequestQueue();
+
+	/**
+	 * Returns the commandQueue MessageQueueId_t
+	 *
+	 * Remember the CommandQueue is the queue for internal communication
+	 * @return commandQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getCommandQueue();
+
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * 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) override;
+
+protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice[in]
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
+	 * @param objectId Target object ID
+	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled.
+	 * @param reply
+	 * This is the reply in form of a generic read-only command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
+	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
+	 */
+	virtual void handleUnrequestedReply(CommandMessage* reply);
+
+	virtual void doPeriodicOperation();
+
+
+	struct CommandInfo {
+		struct tcInfo {
+			uint8_t ackFlags;
+			uint16_t tcPacketId;
+			uint16_t tcSequenceControl;
+		} tcInfo;
+		uint32_t uptimeOfStart;
+		uint8_t step;
+		uint8_t subservice;
+		uint32_t state;
+		Command_t command;
+		object_id_t objectId;
+		FIFO<store_address_t, 3> fifo;
+	};
+
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+	        CommandingServiceBase::CommandInfo>::Iterator;
+
+	const uint16_t apid;
+
+	const uint8_t service;
+
+	const uint16_t timeoutSeconds;
+
+	uint8_t tmPacketCounter = 0;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+	StorageManagerIF *TCStore = nullptr;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	MessageQueueIF* requestQueue = nullptr;
+
+	VerificationReporter verificationReporter;
+
+	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
+
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
+
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	/**
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
+	 * @param subservice Number of subservice
+	 * @param data Pointer to the data in the Packet
+	 * @param dataLen Lenght of data in the Packet
+	 * @param headerData HeaderData will be placed before data
+	 * @param headerSize Size of HeaderData
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
+
+	/**
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
+	 * @param subservice Number of subservice
+	 * @param objectId ObjectId is placed before data
+	 * @param data Data to append to the packet
+	 * @param dataLen Length of Data
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
+			const uint8_t *data, size_t dataLen);
+
+	/**
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
+	 * @param subservice Number of subservice
+	 * @param content This is a pointer to the serialized packet
+	 * @param header Serialize IF header which will be placed before content
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
+			SerializeIF* header = nullptr);
+
+	void checkAndExecuteFifo(CommandMapIter iter);
+
+private:
+	/**
+	 * This method handles internal execution of a command,
+	 * once it has been started by @sa{startExecution()} in the request
+	 * queue handler.
+	 * It handles replies generated by the devices and relayed by the specific
+	 * service implementation. This means that it determines further course of
+	 * action depending on the return values specified in the service
+	 * implementation.
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver
+	 * needs to be set.
+	 *   - TM[1,5] Step Successs
+	 *   - TM[1,6] Step Failure
+	 *   - TM[1,7] Completion Success
+	 *   - TM[1,8] Completion Failure
+	 */
+	void handleCommandQueue();
+
+	/**
+	 * @brief       Handler function for request queue
+	 * @details
+	 * Sequence of request queue handling:
+	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
+	 */
+	void handleRequestQueue();
+
+	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
+			ReturnValue_t errorCode);
+
+	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
+
+	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
+
+	void handleCommandMessage(CommandMessage* reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
+
+	void checkTimeout();
+};
+
+#endif /* COMMANDINGSERVICEBASE_H_ */
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
index 3dd34a84..f9a0fc57 100644
--- a/tmtcservices/PusParser.cpp
+++ b/tmtcservices/PusParser.cpp
@@ -1,114 +1,114 @@
-#include <framework/tmtcservices/PusParser.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-PusParser::PusParser(uint16_t maxExpectedPusPackets,
-		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
-}
-
-ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
-		size_t frameSize) {
-	if(frame == nullptr or frameSize < 5) {
-		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(indexSizePairFIFO.full()) {
-		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	size_t lengthField = frame[4] << 8 | frame[5];
-
-	if(lengthField == 0) {
-		return NO_PACKET_FOUND;
-	}
-
-	size_t packetSize = lengthField + 7;
-	// sif::debug << frameSize << std::endl;
-	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize) {
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< packetSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-	else {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		if(packetSize == frameSize) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	// packet size is smaller than frame size, parse for more packets.
-	return readMultiplePackets(frame, frameSize, packetSize);
-}
-
-ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
-		size_t frameSize, size_t startIndex) {
-	while (startIndex < frameSize) {
-		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
-	return &indexSizePairFIFO;
-}
-
-PusParser::indexSizePair PusParser::getNextFifoPair() {
-	indexSizePair nextIndexSizePair;
-	indexSizePairFIFO.retrieve(&nextIndexSizePair);
-	return nextIndexSizePair;
-}
-
-ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
-		size_t frameSize, size_t& currentIndex) {
-	// sif::debug << startIndex << std::endl;
-    if(currentIndex + 5 > frameSize) {
-        currentIndex = frameSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-	uint16_t lengthField = frame[currentIndex + 4] << 8 |
-			frame[currentIndex + 5];
-	if(lengthField == 0) {
-		// It is assumed that no packet follows.
-		currentIndex = frameSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t nextPacketSize = lengthField + 7;
-	size_t remainingSize = frameSize - currentIndex;
-	if(nextPacketSize > remainingSize)
-	{
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< nextPacketSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-
-	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
-			nextPacketSize));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		// FIFO full.
-		sif::debug << "PusParser: Issue inserting into start index size "
-		        "FIFO, it is full!" << std::endl;
-	}
-	currentIndex += nextPacketSize;
-
-	return result;
-}
+#include "../tmtcservices/PusParser.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PusParser::PusParser(uint16_t maxExpectedPusPackets,
+		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
+}
+
+ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
+		size_t frameSize) {
+	if(frame == nullptr or frameSize < 5) {
+		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(indexSizePairFIFO.full()) {
+		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	size_t lengthField = frame[4] << 8 | frame[5];
+
+	if(lengthField == 0) {
+		return NO_PACKET_FOUND;
+	}
+
+	size_t packetSize = lengthField + 7;
+	// sif::debug << frameSize << std::endl;
+	// Size of a pus packet is the value in the packet length field plus 7.
+	if(packetSize > frameSize) {
+		if(storeSplitPackets) {
+			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
+		}
+		else {
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< packetSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+	else {
+		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
+		if(packetSize == frameSize) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+
+	// packet size is smaller than frame size, parse for more packets.
+	return readMultiplePackets(frame, frameSize, packetSize);
+}
+
+ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
+		size_t frameSize, size_t startIndex) {
+	while (startIndex < frameSize) {
+		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
+	return &indexSizePairFIFO;
+}
+
+PusParser::indexSizePair PusParser::getNextFifoPair() {
+	indexSizePair nextIndexSizePair;
+	indexSizePairFIFO.retrieve(&nextIndexSizePair);
+	return nextIndexSizePair;
+}
+
+ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
+		size_t frameSize, size_t& currentIndex) {
+	// sif::debug << startIndex << std::endl;
+    if(currentIndex + 5 > frameSize) {
+        currentIndex = frameSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+	uint16_t lengthField = frame[currentIndex + 4] << 8 |
+			frame[currentIndex + 5];
+	if(lengthField == 0) {
+		// It is assumed that no packet follows.
+		currentIndex = frameSize;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	size_t nextPacketSize = lengthField + 7;
+	size_t remainingSize = frameSize - currentIndex;
+	if(nextPacketSize > remainingSize)
+	{
+		if(storeSplitPackets) {
+			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
+		}
+		else {
+			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
+					"larger than remaining frame," << std::endl;
+			sif::debug << "Throwing away packet. Detected packet size: "
+					<< nextPacketSize << std::endl;
+		}
+		return SPLIT_PACKET;
+	}
+
+	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
+			nextPacketSize));
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		// FIFO full.
+		sif::debug << "PusParser: Issue inserting into start index size "
+		        "FIFO, it is full!" << std::endl;
+	}
+	currentIndex += nextPacketSize;
+
+	return result;
+}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
index d59673f6..24cba0c0 100644
--- a/tmtcservices/PusParser.h
+++ b/tmtcservices/PusParser.h
@@ -1,82 +1,82 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-
-#include <framework/container/DynamicFIFO.h>
-#include <utility>
-#include <cstdint>
-
-/**
- * @brief	This small helper class scans a given buffer for PUS packets.
- * 			Can be used if PUS packets are serialized in a tightly packed frame.
- * @details
- * The parser uses the payload length field of PUS packets to find
- * the respective PUS packet sizes.
- *
- * The parser parses a buffer by taking a pointer and the maximum size to scan.
- * If PUS packets are found, they are stored in a FIFO which stores pairs
- * consisting of the index in the buffer and the respective packet sizes.
- *
- * If the parser detects split packets (which means that the size of the
- * next packet is larger than the remaining size to scan), it can either
- * store that split packet or throw away the packet.
- */
-class PusParser {
-public:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
-	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
-	/**
-	 * Parser constructor.
-	 * @param maxExpectedPusPackets
-	 * Maximum expected number of PUS packets. A good estimate is to divide
-	 * the frame size by the minimum size of a PUS packet (12 bytes)
-	 * @param storeSplitPackets
-	 * Specifies whether split packets are also stored inside the FIFO,
-	 * with the size being the remaining frame size.
-	 */
-	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
-
-	/**
-	 * Parse a given frame for PUS packets
-	 * @param frame
-	 * @param frameSize
-	 * @return -@c NO_PACKET_FOUND if no packet was found.
-	 */
-	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
-
-	/**
-	 * Accessor function to get a reference to the internal FIFO which
-	 * stores pairs of indexi and packet sizes. This FIFO is filled
-	 * by the parsePusPackets() function.
-	 * @return
-	 */
-	DynamicFIFO<indexSizePair>* fifo();
-
-	/**
-	 * Retrieve the next index and packet size pair from the FIFO.
-	 * This also removed it from the FIFO. Please note that if the FIFO
-	 * is empty, an empty pair will be returned.
-	 * @return
-	 */
-	indexSizePair getNextFifoPair();
-
-private:
-	/** A FIFO is used to store information about multiple PUS packets
-	 * inside the receive buffer. The maximum number of entries is defined
-	 * by the first constructor argument.
-	 */
-	DynamicFIFO<indexSizePair> indexSizePairFIFO;
-
-	bool storeSplitPackets = false;
-
-	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
-			size_t startIndex);
-	ReturnValue_t readNextPacket(const uint8_t *frame,
-			size_t frameSize, size_t& startIndex);
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include "../container/DynamicFIFO.h"
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for PUS packets.
+ * 			Can be used if PUS packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the payload length field of PUS packets to find
+ * the respective PUS packet sizes.
+ *
+ * The parser parses a buffer by taking a pointer and the maximum size to scan.
+ * If PUS packets are found, they are stored in a FIFO which stores pairs
+ * consisting of the index in the buffer and the respective packet sizes.
+ *
+ * If the parser detects split packets (which means that the size of the
+ * next packet is larger than the remaining size to scan), it can either
+ * store that split packet or throw away the packet.
+ */
+class PusParser {
+public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using indexSizePair = std::pair<size_t, size_t>;
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
+	/**
+	 * Parser constructor.
+	 * @param maxExpectedPusPackets
+	 * Maximum expected number of PUS packets. A good estimate is to divide
+	 * the frame size by the minimum size of a PUS packet (12 bytes)
+	 * @param storeSplitPackets
+	 * Specifies whether split packets are also stored inside the FIFO,
+	 * with the size being the remaining frame size.
+	 */
+	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
+
+	/**
+	 * Parse a given frame for PUS packets
+	 * @param frame
+	 * @param frameSize
+	 * @return -@c NO_PACKET_FOUND if no packet was found.
+	 */
+	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
+
+	/**
+	 * Accessor function to get a reference to the internal FIFO which
+	 * stores pairs of indexi and packet sizes. This FIFO is filled
+	 * by the parsePusPackets() function.
+	 * @return
+	 */
+	DynamicFIFO<indexSizePair>* fifo();
+
+	/**
+	 * Retrieve the next index and packet size pair from the FIFO.
+	 * This also removed it from the FIFO. Please note that if the FIFO
+	 * is empty, an empty pair will be returned.
+	 * @return
+	 */
+	indexSizePair getNextFifoPair();
+
+private:
+	/** A FIFO is used to store information about multiple PUS packets
+	 * inside the receive buffer. The maximum number of entries is defined
+	 * by the first constructor argument.
+	 */
+	DynamicFIFO<indexSizePair> indexSizePairFIFO;
+
+	bool storeSplitPackets = false;
+
+	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
+			size_t startIndex);
+	ReturnValue_t readNextPacket(const uint8_t *frame,
+			size_t frameSize, size_t& startIndex);
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 877eff3e..a8b74e39 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,123 +1,123 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tcdistribution/PUSDistributorIF.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tmtcservices/PusServiceBase.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <framework/ipc/QueueFactory.h>
-
-object_id_t PusServiceBase::packetSource = 0;
-object_id_t PusServiceBase::packetDestination = 0;
-
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
-		uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
-	requestQueue = QueueFactory::instance()->
-			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
-}
-
-PusServiceBase::~PusServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
-	handleRequestQueue();
-	ReturnValue_t result = this->performService();
-	if (result != RETURN_OK) {
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) result
-				<< std::endl;
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
-    this->taskHandle = taskHandle;
-}
-
-void PusServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
-		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-//		if(status != MessageQueueIF::EMPTY) {
-//			sif::debug << "PusServiceBase::performOperation: Receiving from "
-//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
-//					<< std::setfill('0') << this->requestQueue->getId()
-//					<< std::dec << " returned: " << status << std::setfill(' ')
-//					<<  std::endl;
-//		}
-
-		if (status == RETURN_OK) {
-			this->currentPacket.setStoreAddress(message.getStorageId());
-			//info << "Service " << (uint16_t) this->serviceId <<
-			//     ": new packet!" << std::endl;
-
-			result = this->handleRequest(currentPacket.getSubService());
-
-			// debug << "Service " << (uint16_t)this->serviceId <<
-			//    ": handleRequest returned: " << (int)return_code << std::endl;
-			if (result == RETURN_OK) {
-				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			}
-			else {
-				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						result, 0, errorParameter1, errorParameter2);
-			}
-			this->currentPacket.deletePacket();
-			errorParameter1 = 0;
-			errorParameter2 = 0;
-		}
-		else if (status == MessageQueueIF::EMPTY) {
-			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId <<
-			//      ": no new packet." << std::endl;
-			break;
-		}
-		else {
-			sif::error << "PusServiceBase::performOperation: Service "
-					<< this->serviceId << ": Error receiving packet. Code: "
-					<< std::hex << status << std::dec << std::endl;
-		}
-	}
-}
-
-uint16_t PusServiceBase::getIdentifier() {
-	return this->serviceId;
-}
-
-MessageQueueId_t PusServiceBase::getRequestQueue() {
-	return this->requestQueue->getId();
-}
-
-ReturnValue_t PusServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
-			packetDestination);
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-	if (destService == nullptr or distributor == nullptr) {
-		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< this->serviceId << ": Configuration error. Make sure "
-				<<	"packetSource and packetDestination are defined correctly"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	this->requestQueue->setDefaultDestination(
-			destService->getReportReceptionQueue());
-	distributor->registerService(this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
-    // If task parameters, for example task frequency are required, this
-    // function should be overriden and the system object task IF can
-    // be used to get those parameters.
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tmtcservices/PusServiceBase.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t PusServiceBase::packetSource = 0;
+object_id_t PusServiceBase::packetDestination = 0;
+
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+}
+
+PusServiceBase::~PusServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
+void PusServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
+		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
+		if (status == RETURN_OK) {
+			this->currentPacket.setStoreAddress(message.getStorageId());
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
+
+			result = this->handleRequest(currentPacket.getSubService());
+
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
+				this->verifyReporter.sendSuccessReport(
+						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+			}
+			else {
+				this->verifyReporter.sendFailureReport(
+						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						result, 0, errorParameter1, errorParameter2);
+			}
+			this->currentPacket.deletePacket();
+			errorParameter1 = 0;
+			errorParameter2 = 0;
+		}
+		else if (status == MessageQueueIF::EMPTY) {
+			status = RETURN_OK;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
+			break;
+		}
+		else {
+			sif::error << "PusServiceBase::performOperation: Service "
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
+		}
+	}
+}
+
+uint16_t PusServiceBase::getIdentifier() {
+	return this->serviceId;
+}
+
+MessageQueueId_t PusServiceBase::getRequestQueue() {
+	return this->requestQueue->getId();
+}
+
+ReturnValue_t PusServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
+			packetDestination);
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+	if (destService == nullptr or distributor == nullptr) {
+		sif::error << "PusServiceBase::PusServiceBase: Service "
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 6d3d9bac..f9431275 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcpacket/pus/TcPacketStored.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-#include <framework/tmtcservices/VerificationReporter.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @defgroup pus_services PUS Service Framework
- * These group contains all implementations of PUS Services in the OBSW.
- * Most of the Services are directly taken from the ECSS PUS Standard.
- */
-
-/**
- * @brief 	This class is the basis for all PUS Services,
- * 			which can immediately process Telecommand Packets.
- * @details
- * It manages Telecommand reception and the generation of Verification Reports.
- * Every class that inherits from this abstract class has to implement
- * handleRequest and performService. Services that are created with this
- * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified
- * on construction.
- * @ingroup pus_services
- */
-class PusServiceBase : public ExecutableObjectIF,
-        public AcceptsTelecommandsIF,
-        public SystemObject,
-        public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * @brief	The passed values are set, but inter-object initialization is
-	 * 			done in the initialize method.
-	 * @param setObjectId
-	 * The system object identifier of this Service instance.
-	 * @param setApid
-	 * The APID the Service is instantiated for.
-	 * @param setServiceId
-	 * The Service Identifier as specified in ECSS PUS.
-	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
-			uint8_t setServiceId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PusServiceBase();
-	/**
-	 * @brief 	The handleRequest method shall handle any kind of Telecommand
-	 * 			Request immediately.
-	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform
-	 * any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the
-	 * verifyReporter, but Completion Success or Failure Reports are generated
-	 * automatically after execution of this method.
-	 *
-	 * If a Telecommand can not be executed within one call cycle,
-	 * this Base class is not the right parent.
-	 *
-	 * The child class may add additional error information by setting
-	 * #errorParameters which aren attached to the generated verification
-	 * message.
-	 *
-	 * Subservice checking should be implemented in this method.
-	 *
-	 * @return	The returned status_code is directly taken as main error code
-	 * 			in the Verification Report.
-	 * 			On success, RETURN_OK shall be returned.
-	 */
-	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
-	/**
-	 * In performService, implementations can handle periodic,
-	 * non-TC-triggered activities.
-	 * The performService method is always called.
-	 * @return	Currently, everything other that RETURN_OK only triggers
-	 * 			diagnostic output.
-	 */
-	virtual ReturnValue_t performService() = 0;
-	/**
-	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends
-	 * completion verification messages and deletes
-	 * the TC requests afterwards.
-	 * performService is always executed afterwards.
-	 * @return	@c RETURN_OK if the periodic performService was successful.
-	 * 			@c RETURN_FAILED else.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual uint16_t getIdentifier() override;
-	MessageQueueId_t getRequestQueue() override;
-	virtual ReturnValue_t initialize() override;
-
-	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-protected:
-	/**
-	 * @brief   Handle to the underlying task
-	 * @details
-	 * Will be set by setTaskIF(), which is called on task creation.
-	 */
-	PeriodicTaskIF* taskHandle = nullptr;
-	/**
-	 * The APID of this instance of the Service.
-	 */
-	uint16_t apid;
-	/**
-	 * The Service Identifier.
-	 */
-	uint8_t serviceId;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter1 = 0;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter2 = 0;
-	/**
-	 * This is a complete instance of the telecommand reception queue
-	 * of the class. It is initialized on construction of the class.
-	 */
-	MessageQueueIF* requestQueue = nullptr;
-	/**
-	 * An instance of the VerificationReporter class, that simplifies
-	 * sending any kind of verification message to the TC Verification Service.
-	 */
-	VerificationReporter verifyReporter;
-	/**
-	 * The current Telecommand to be processed.
-	 * It is deleted after handleRequest was executed.
-	 */
-	TcPacketStored currentPacket;
-
-	static object_id_t packetSource;
-
-	static object_id_t packetDestination;
-private:
-	/**
-	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one
-	 * #handleRequest call.
-	 */
-	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
-
-	void handleRequestQueue();
-};
-
-#endif /* PUSSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationCodes.h"
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/MessageQueueIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @defgroup pus_services PUS Service Framework
+ * These group contains all implementations of PUS Services in the OBSW.
+ * Most of the Services are directly taken from the ECSS PUS Standard.
+ */
+
+/**
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
+ * Base class have to handle any kind of request immediately on reception.
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
+ */
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
+	 */
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PusServiceBase();
+	/**
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
+	 * @details
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
+	 * 			On success, RETURN_OK shall be returned.
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
+	/**
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
+	 * The performService method is always called.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
+	 */
+	virtual ReturnValue_t performService() = 0;
+	/**
+	 * This method implements the typical activity of a simple PUS Service.
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
+	 * the TC requests afterwards.
+	 * performService is always executed afterwards.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
+	/**
+	 * The APID of this instance of the Service.
+	 */
+	uint16_t apid;
+	/**
+	 * The Service Identifier.
+	 */
+	uint8_t serviceId;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter1 = 0;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter2 = 0;
+	/**
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
+	 */
+	MessageQueueIF* requestQueue = nullptr;
+	/**
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
+	 */
+	VerificationReporter verifyReporter;
+	/**
+	 * The current Telecommand to be processed.
+	 * It is deleted after handleRequest was executed.
+	 */
+	TcPacketStored currentPacket;
+
+	static object_id_t packetSource;
+
+	static object_id_t packetDestination;
+private:
+	/**
+	 * This constant sets the maximum number of packets accepted per call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
+	 */
+	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
+};
+
+#endif /* PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 07631801..d83380a2 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -1,163 +1,163 @@
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-PusVerificationMessage::PusVerificationMessage() {
-}
-
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
-PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
-		uint32_t parameter2) {
-	uint8_t *data = this->getBuffer();
-	data[messageSize] = set_report_id;
-	messageSize += sizeof(set_report_id);
-	data[messageSize] = ackFlags;
-	messageSize += sizeof(ackFlags);
-	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-	messageSize += sizeof(tcPacketId);
-	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-	messageSize += sizeof(tcSequenceControl);
-	data[messageSize] = set_step;
-	messageSize += sizeof(set_step);
-	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-	messageSize += sizeof(set_error_code);
-	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-	messageSize += sizeof(parameter1);
-	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-	messageSize += sizeof(parameter2);
-}
-
-uint8_t PusVerificationMessage::getReportId() {
-
-	return getContent()->reportId;
-}
-
-uint8_t PusVerificationMessage::getAckFlags() {
-
-	return getContent()->ackFlags;
-}
-
-uint16_t PusVerificationMessage::getTcPacketId() {
-
-	uint16_t tcPacketId;
-	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
-	return tcPacketId;
-}
-
-uint16_t PusVerificationMessage::getTcSequenceControl() {
-
-	uint16_t tcSequenceControl;
-	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
-			sizeof(tcSequenceControl));
-	return tcSequenceControl;
-}
-
-uint8_t PusVerificationMessage::getStep() {
-
-	return getContent()->step;
-}
-
-ReturnValue_t PusVerificationMessage::getErrorCode() {
-	ReturnValue_t errorCode;
-	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
-	return errorCode;
-}
-
-PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
-	return (verifciationMessageContent*) this->getData();
-}
-
-uint32_t PusVerificationMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
-	return parameter;
-}
-
-uint32_t PusVerificationMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
-	return parameter;
-}
-
-PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, uint8_t setStep) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-}
-
-PusSuccessReport::~PusSuccessReport() {
-
-}
-
-uint32_t PusSuccessReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusSuccessReport::getReport() {
-	return reportBuffer;
-}
-
-PusFailureReport::PusFailureReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
-		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-}
-
-PusFailureReport::~PusFailureReport() {
-}
-
-size_t PusFailureReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusFailureReport::getReport() {
-	return reportBuffer;
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PusVerificationMessage::PusVerificationMessage() {
+}
+
+//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
+//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
+//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
+//	uint16_t tcPacketId = current_packet->getPacketId();
+//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
+//	uint8_t* data = this->getBuffer();
+//	data[messageSize] = set_report_id;
+//	messageSize += sizeof(set_report_id);
+//	data[messageSize] = ackFlags;
+//	messageSize += sizeof(ackFlags);
+//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+//	messageSize += sizeof(tcPacketId);
+//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+//	messageSize += sizeof(tcSequenceControl);
+//	data[messageSize] = set_step;
+//	messageSize += sizeof(set_step);
+//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+//	messageSize += sizeof(set_error_code);
+//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+//	messageSize += sizeof(parameter1);
+//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+//	messageSize += sizeof(parameter2);
+//}
+
+PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
+		uint32_t parameter2) {
+	uint8_t *data = this->getBuffer();
+	data[messageSize] = set_report_id;
+	messageSize += sizeof(set_report_id);
+	data[messageSize] = ackFlags;
+	messageSize += sizeof(ackFlags);
+	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+	messageSize += sizeof(tcPacketId);
+	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+	messageSize += sizeof(tcSequenceControl);
+	data[messageSize] = set_step;
+	messageSize += sizeof(set_step);
+	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+	messageSize += sizeof(set_error_code);
+	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+	messageSize += sizeof(parameter1);
+	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+	messageSize += sizeof(parameter2);
+}
+
+uint8_t PusVerificationMessage::getReportId() {
+
+	return getContent()->reportId;
+}
+
+uint8_t PusVerificationMessage::getAckFlags() {
+
+	return getContent()->ackFlags;
+}
+
+uint16_t PusVerificationMessage::getTcPacketId() {
+
+	uint16_t tcPacketId;
+	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
+	return tcPacketId;
+}
+
+uint16_t PusVerificationMessage::getTcSequenceControl() {
+
+	uint16_t tcSequenceControl;
+	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
+			sizeof(tcSequenceControl));
+	return tcSequenceControl;
+}
+
+uint8_t PusVerificationMessage::getStep() {
+
+	return getContent()->step;
+}
+
+ReturnValue_t PusVerificationMessage::getErrorCode() {
+	ReturnValue_t errorCode;
+	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
+	return errorCode;
+}
+
+PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
+	return (verifciationMessageContent*) this->getData();
+}
+
+uint32_t PusVerificationMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
+	return parameter;
+}
+
+uint32_t PusVerificationMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
+	return parameter;
+}
+
+PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, uint8_t setStep) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+}
+
+PusSuccessReport::~PusSuccessReport() {
+
+}
+
+uint32_t PusSuccessReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusSuccessReport::getReport() {
+	return reportBuffer;
+}
+
+PusFailureReport::PusFailureReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
+		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+}
+
+PusFailureReport::~PusFailureReport() {
+}
+
+size_t PusFailureReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusFailureReport::getReport() {
+	return reportBuffer;
+}
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index ee84f0c1..26a1eaed 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,77 +1,77 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/tmtcpacket/pus/TcPacketBase.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-class PusVerificationMessage: public MessageQueueMessage {
-private:
-	struct verifciationMessageContent {
-		uint8_t reportId;
-		uint8_t ackFlags;
-		uint8_t packetId_0;
-		uint8_t packetId_1;
-		uint8_t tcSequenceControl_0;
-		uint8_t tcSequenceControl_1;
-		uint8_t step;
-		uint8_t error_code_0;
-		uint8_t error_code_1;
-		uint8_t parameter1_0;
-		uint8_t parameter1_1;
-		uint8_t parameter1_2;
-		uint8_t parameter1_3;
-		uint8_t parameter2_0;
-		uint8_t parameter2_1;
-		uint8_t parameter2_2;
-		uint8_t parameter2_3;
-	};
-	verifciationMessageContent* getContent();
-public:
-	static const uint8_t VERIFICATION_MIN_SIZE = 6;
-	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
-	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	uint8_t getReportId();
-	uint8_t getAckFlags();
-	uint16_t getTcPacketId();
-	uint16_t getTcSequenceControl();
-	ReturnValue_t getErrorCode();
-	uint8_t getStep();
-	uint32_t getParameter1();
-	uint32_t getParameter2();
-};
-
-class PusSuccessReport {
-private:
-	static const uint16_t MAX_SIZE = 7;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			uint8_t set_step = 0);
-	~PusSuccessReport();
-	uint32_t getSize();
-	uint8_t* getReport();
-};
-
-class PusFailureReport {
-private:
-	static const uint16_t MAX_SIZE = 16;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			ReturnValue_t setErrorCode, uint8_t setStep = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	~PusFailureReport();
-	size_t getSize();
-	uint8_t* getReport();
-};
-
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#ifndef PUSVERIFICATIONREPORT_H_
+#define PUSVERIFICATIONREPORT_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../tmtcpacket/pus/TcPacketBase.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+class PusVerificationMessage: public MessageQueueMessage {
+private:
+	struct verifciationMessageContent {
+		uint8_t reportId;
+		uint8_t ackFlags;
+		uint8_t packetId_0;
+		uint8_t packetId_1;
+		uint8_t tcSequenceControl_0;
+		uint8_t tcSequenceControl_1;
+		uint8_t step;
+		uint8_t error_code_0;
+		uint8_t error_code_1;
+		uint8_t parameter1_0;
+		uint8_t parameter1_1;
+		uint8_t parameter1_2;
+		uint8_t parameter1_3;
+		uint8_t parameter2_0;
+		uint8_t parameter2_1;
+		uint8_t parameter2_2;
+		uint8_t parameter2_3;
+	};
+	verifciationMessageContent* getContent();
+public:
+	static const uint8_t VERIFICATION_MIN_SIZE = 6;
+	PusVerificationMessage();
+//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	uint8_t getReportId();
+	uint8_t getAckFlags();
+	uint16_t getTcPacketId();
+	uint16_t getTcSequenceControl();
+	ReturnValue_t getErrorCode();
+	uint8_t getStep();
+	uint32_t getParameter1();
+	uint32_t getParameter2();
+};
+
+class PusSuccessReport {
+private:
+	static const uint16_t MAX_SIZE = 7;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			uint8_t set_step = 0);
+	~PusSuccessReport();
+	uint32_t getSize();
+	uint8_t* getReport();
+};
+
+class PusFailureReport {
+private:
+	static const uint16_t MAX_SIZE = 16;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			ReturnValue_t setErrorCode, uint8_t setStep = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	~PusFailureReport();
+	size_t getSize();
+	uint8_t* getReport();
+};
+
+#endif /* PUSVERIFICATIONREPORT_H_ */
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index b92a5c84..0db53380 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,30 +1,30 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
-
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
-#include <framework/tmtcpacket/SpacePacketBase.h>
-
-class SourceSequenceCounter {
-private:
-	uint16_t sequenceCount;
-public:
-	SourceSequenceCounter() : sequenceCount(0) {}
-	void increment() {
-		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	void decrement() {
-		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	uint16_t get() { return this->sequenceCount; }
-	void reset(uint16_t toValue = 0) {
-		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-};
-
-
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+/**
+ * @file	SourceSequenceCounter.h
+ * @brief	This file defines the SourceSequenceCounter class.
+ * @date	04.02.2013
+ * @author	baetz
+ */
+
+#ifndef SOURCESEQUENCECOUNTER_H_
+#define SOURCESEQUENCECOUNTER_H_
+#include "../tmtcpacket/SpacePacketBase.h"
+
+class SourceSequenceCounter {
+private:
+	uint16_t sequenceCount;
+public:
+	SourceSequenceCounter() : sequenceCount(0) {}
+	void increment() {
+		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	void decrement() {
+		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	uint16_t get() { return this->sequenceCount; }
+	void reset(uint16_t toValue = 0) {
+		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+};
+
+
+#endif /* SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index b55803cb..732a2ea1 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,9 +1,9 @@
-#include <framework/tmtcservices/TmTcBridge.h>
+#include "../tmtcservices/TmTcBridge.h"
 
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/globalfunctions/arrayprinter.h>
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
 
 TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
 		object_id_t tmStoreId, object_id_t tcStoreId):
@@ -105,8 +105,8 @@ ReturnValue_t TmTcBridge::handleTm() {
 
 ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
-	const uint8_t* data = nullptr;
-	size_t size = 0;
+	const uint8_t* data = nullptr;
+	size_t size = 0;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
@@ -155,8 +155,8 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
-		const uint8_t* data = nullptr;
-		size_t size = 0;
+		const uint8_t* data = nullptr;
+		size_t size = 0;
 		tmFifo.retrieve(&storeId);
 		result = tmStore->getData(storeId, &data, &size);
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 993cd5b9..b91425e1 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,15 +1,15 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
 
-#include <framework/container/FIFO.h>
-#include <framework/tmtcservices/TmTcMessage.h>
+#include "../container/FIFO.h"
+#include "../tmtcservices/TmTcMessage.h"
 
 class TmTcBridge : public AcceptsTelemetryIF,
 		public AcceptsTelecommandsIF,
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index d437b41e..0fe3229c 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,29 +1,29 @@
-#include <framework/tmtcservices/TmTcMessage.h>
-#include <string.h>
-
-
-TmTcMessage::TmTcMessage() {
-	this->messageSize += sizeof(store_address_t);
-}
-
-TmTcMessage::~TmTcMessage() {
-}
-
-store_address_t TmTcMessage::getStorageId() {
-	store_address_t temp_id;
-	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
-	return temp_id;
-}
-
-TmTcMessage::TmTcMessage(store_address_t store_id) {
-	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
-}
-
-size_t TmTcMessage::getMinimumMessageSize() {
-	return this->HEADER_SIZE + sizeof(store_address_t);
-}
-
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
-}
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+
+TmTcMessage::TmTcMessage() {
+	this->messageSize += sizeof(store_address_t);
+}
+
+TmTcMessage::~TmTcMessage() {
+}
+
+store_address_t TmTcMessage::getStorageId() {
+	store_address_t temp_id;
+	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
+	return temp_id;
+}
+
+TmTcMessage::TmTcMessage(store_address_t store_id) {
+	this->messageSize += sizeof(store_address_t);
+	this->setStorageId(store_id);
+}
+
+size_t TmTcMessage::getMinimumMessageSize() {
+	return this->HEADER_SIZE + sizeof(store_address_t);
+}
+
+void TmTcMessage::setStorageId(store_address_t store_id) {
+	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+}
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index 73f741fb..ad97c056 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,50 +1,50 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
-
-#include <framework/ipc/MessageQueueMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-/**
- * @brief	This message class is used to pass Telecommand and Telemetry
- * 			packets between tasks.
- * @details	Within such a packet, nothing is transported but the identifier of
- * 			a packet stored in one of the IPC stores (typically a special TM and
- * 			a special TC store). This makes passing commands very simple and
- * 			efficient.
- *	\ingroup message_queue
- */
-class TmTcMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TmTcMessage();
-	/**
-	 * @brief	With this constructor, the passed packet id is directly put
-	 * 			into the message.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	TmTcMessage( store_address_t packet_id );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TmTcMessage();
-	/**
-	 * @brief	This getter returns the packet id in the correct format.
-	 * @return	Returns the packet id.
-	 */
-	store_address_t getStorageId();
-	/**
-	 * @brief	In some cases it might be useful to have a setter for packet id
-	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	void setStorageId( store_address_t packet_id );
-};
-
-#endif /* TMTCMESSAGE_H_ */
+#ifndef TMTCMESSAGE_H_
+#define TMTCMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+/**
+ * @brief	This message class is used to pass Telecommand and Telemetry
+ * 			packets between tasks.
+ * @details	Within such a packet, nothing is transported but the identifier of
+ * 			a packet stored in one of the IPC stores (typically a special TM and
+ * 			a special TC store). This makes passing commands very simple and
+ * 			efficient.
+ *	\ingroup message_queue
+ */
+class TmTcMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TmTcMessage();
+	/**
+	 * @brief	With this constructor, the passed packet id is directly put
+	 * 			into the message.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	TmTcMessage( store_address_t packet_id );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TmTcMessage();
+	/**
+	 * @brief	This getter returns the packet id in the correct format.
+	 * @return	Returns the packet id.
+	 */
+	store_address_t getStorageId();
+	/**
+	 * @brief	In some cases it might be useful to have a setter for packet id
+	 * 			as well.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	void setStorageId( store_address_t packet_id );
+};
+
+#endif /* TMTCMESSAGE_H_ */
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 79e650f1..e9a43855 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,105 +1,105 @@
-#include <framework/tmtcservices/VerificationReporter.h>
-
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/objectmanager/frameworkObjects.h>
-
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
-
-VerificationReporter::VerificationReporter() :
-		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
-}
-
-VerificationReporter::~VerificationReporter() {}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		TcPacketBase* current_packet, uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
-			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
-		uint32_t parameter1, uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), error_code, step,
-			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
-		uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
-			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::initialize() {
-	if(messageReceiver == objects::NO_OBJECT) {
-		sif::warning << "VerificationReporter::initialize: Verification message"
-				" receiver object ID not set yet in Factory!" << std::endl;
-		return;
-	}
-	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
-			messageReceiver);
-	if (temp == nullptr) {
-		sif::error << "VerificationReporter::initialize: Message "
-				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
-	}
-	this->acknowledgeQueue = temp->getVerificationQueue();
-}
+#include "../tmtcservices/VerificationReporter.h"
+
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/frameworkObjects.h"
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+
+VerificationReporter::VerificationReporter() :
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
+}
+
+VerificationReporter::~VerificationReporter() {}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		TcPacketBase* current_packet, uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
+			tcSequenceControl, 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
+		uint32_t parameter1, uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), error_code, step,
+			parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
+		uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
+			tcSequenceControl, error_code, step, parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
+	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
+			messageReceiver);
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
+	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
+}
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index f13998d9..86aea826 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,50 +1,50 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This helper object is used to forward verification messages
- * 			which are generated by the Flight Software Framework.
- * @details
- * The messages can be relayed to an arbitrary object, for example a dedicated
- * Verification Reporter. The destination is set by setting the static framework
- * Id VerificationReporter::messageReceiver. The default verification reporter
- * will be the PUS service 1, which sends verification messages according
- * to the PUS standard.
- *
- */
-class VerificationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	VerificationReporter();
-	virtual ~VerificationReporter();
-
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
-			uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			uint8_t set_step = 0);
-
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
-			ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0 );
-	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t error_code = 0, uint8_t step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	void initialize();
-
-private:
-	static object_id_t messageReceiver;
-	MessageQueueId_t acknowledgeQueue;
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
+class VerificationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	VerificationReporter();
+	virtual ~VerificationReporter();
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
+	void sendFailureReport(uint8_t report_id,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	void initialize();
+
+private:
+	static object_id_t messageReceiver;
+	MessageQueueId_t acknowledgeQueue;
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 5af50cfbf74fdf025b30030f0f2edfa29ed080b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 20:50:24 +0200
Subject: [PATCH 0639/1292] renamed .mk file

---
 framework.mk => fsfw.mk | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename framework.mk => fsfw.mk (100%)

diff --git a/framework.mk b/fsfw.mk
similarity index 100%
rename from framework.mk
rename to fsfw.mk

From a1d94ec556b6fbb35b6dbcc76499ba9620d663ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 18 Aug 2020 20:51:13 +0200
Subject: [PATCH 0640/1292] added aditional comment

---
 fsfw.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fsfw.mk b/fsfw.mk
index bfbd4b1f..db1931cc 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -1,3 +1,4 @@
+# This submake file needs to be included by the primary Makefile.
 # This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
 # Valid API settings: rtems, linux, freeRTOS, host
 

From 7b998268cb782f90e8daab6d3bbe94c08cb37047 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 19 Aug 2020 13:17:40 +0200
Subject: [PATCH 0641/1292] error message improvement

---
 fsfw.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fsfw.mk b/fsfw.mk
index db1931cc..a548b6a8 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -38,7 +38,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 else
-$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
+$(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
 
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
@@ -59,4 +59,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
\ No newline at end of file
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)

From f90bd012825b29ef0d4ec1d7b58f1b48da424103 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 19 Aug 2020 17:00:50 +0200
Subject: [PATCH 0642/1292] added srv17 and srv201

---
 pus/CService201HealthCommanding.cpp    | 84 ++++++++++++++++++++++++++
 pus/CService201HealthCommanding.h      | 58 ++++++++++++++++++
 pus/Service17Test.cpp                  | 41 +++++++++++++
 pus/Service17Test.h                    | 44 ++++++++++++++
 pus/servicepackets/Service201Packets.h | 48 +++++++++++++++
 5 files changed, 275 insertions(+)
 create mode 100644 pus/CService201HealthCommanding.cpp
 create mode 100644 pus/CService201HealthCommanding.h
 create mode 100644 pus/Service17Test.cpp
 create mode 100644 pus/Service17Test.h
 create mode 100644 pus/servicepackets/Service201Packets.h

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
new file mode 100644
index 00000000..057ff707
--- /dev/null
+++ b/pus/CService201HealthCommanding.cpp
@@ -0,0 +1,84 @@
+#include "CService201HealthCommanding.h"
+
+#include "../health/HasHealthIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../health/HealthMessage.h"
+#include "servicepackets/Service201Packets.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+	CommandingServiceBase(objectId, apid, serviceId,
+			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+}
+
+CService201HealthCommanding::~CService201HealthCommanding() {
+}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_SET_HEALTH):
+		return RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand
+		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	HealthCommand healthCommand;
+	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	} else {
+		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
+				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		return result;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply
+		(const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+		prepareHealthSetReply(reply);
+	}
+	return RETURN_OK;
+}
+
+void CService201HealthCommanding::prepareHealthSetReply(
+        const CommandMessage* reply) {
+	prepareHealthSetReply(reply);
+	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+	HealthSetReply healthSetReply(health, oldHealth);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+}
+
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
new file mode 100644
index 00000000..85d2e24c
--- /dev/null
+++ b/pus/CService201HealthCommanding.h
@@ -0,0 +1,58 @@
+#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Custom PUS service to set health of all objects
+ *          implementing hasHealthIF.
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * child class like this service
+ *
+ */
+class CService201HealthCommanding: public CommandingServiceBase {
+public:
+    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId);
+	virtual~ CService201HealthCommanding();
+protected:
+	/* CSB abstract function implementations */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	/** Prepare health command */
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	/** Handle health reply */
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	void prepareHealthSetReply(const CommandMessage *reply);
+
+	enum Subservice {
+		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
+		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	};
+};
+
+#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
diff --git a/pus/Service17Test.cpp b/pus/Service17Test.cpp
new file mode 100644
index 00000000..2ef44490
--- /dev/null
+++ b/pus/Service17Test.cpp
@@ -0,0 +1,41 @@
+#include "Service17Test.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service17Test::Service17Test(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+    PusServiceBase(objectId, apid, serviceId),
+    packetSubCounter(0) {
+}
+
+Service17Test::~Service17Test() {
+}
+
+ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
+	switch(subservice){
+	case Subservice::CONNECTION_TEST: {
+		TmPacketStored connectionPacket(apid, serviceId,
+		        Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+		connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+				requestQueue->getId());
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+    case Subservice::EVENT_TRIGGER_TEST: {
+        TmPacketStored connectionPacket(apid, serviceId,
+                Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+        connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+                requestQueue->getId());
+        triggerEvent(TEST, 1234, 5678);
+        return RETURN_OK;
+    }
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service17Test::performService() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
new file mode 100644
index 00000000..8d6a4377
--- /dev/null
+++ b/pus/Service17Test.h
@@ -0,0 +1,44 @@
+#ifndef MISSION_PUS_SERVICE17TEST_H_
+#define MISSION_PUS_SERVICE17TEST_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief Test Service
+ * Full Documentation: ECSS-E70-41A p.167
+ *
+ * The test service provides the capability to activate test functions
+ * implemented on-board and to report the results of such tests.
+ * Service capability:
+ *   - TC[17,1]: Perform connection test
+ *   - TM[17,2]: Send Connection Test Report
+ *   - TC[17,128]: Perform connection test and trigger event
+ *
+ * @ingroup pus_services
+ */
+class Service17Test: public PusServiceBase {
+public:
+	// Custom events which can be triggered
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
+	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+
+	enum Subservice: uint8_t {
+		//! [EXPORT] : [COMMAND] Perform connection test
+	    CONNECTION_TEST = 1,
+	    //! [EXPORT] : [REPLY] Connection test reply
+	    CONNECTION_TEST_REPORT = 2,
+		//!  [EXPORT] : [COMMAND] Trigger test reply and test event
+	    EVENT_TRIGGER_TEST = 128,
+	};
+
+	Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual ~Service17Test();
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+	virtual ReturnValue_t performService() override;
+
+protected:
+	uint16_t packetSubCounter = 0;
+};
+
+#endif /* MISSION_PUS_SERVICE17TEST_H_ */
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
new file mode 100644
index 00000000..5ff5dcd5
--- /dev/null
+++ b/pus/servicepackets/Service201Packets.h
@@ -0,0 +1,48 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../health/HasHealthIF.h"
+
+class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+public:
+
+	HealthCommand() {
+		setLinks();
+	}
+
+	HasHealthIF::HealthState getHealth() {
+		return static_cast<HasHealthIF::HealthState>(health.entry);
+	}
+private:
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
+};
+
+
+class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
+public:
+	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
+		health(health_), oldHealth(oldHealth_)
+	{
+		setLinks();
+	}
+
+private:
+	HealthSetReply(const HealthSetReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+		health.setNext(&oldHealth);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
+	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */

From adbf39166f1cd7d9b86033148f02b9c18c21f438 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 18:13:17 +0200
Subject: [PATCH 0643/1292] removed pus parser

---
 container/RingBufferBase.h     |   8 +--
 container/SimpleRingBuffer.cpp |   4 +-
 globalfunctions/DleEncoder.cpp |  26 ++++----
 globalfunctions/DleEncoder.h   |   6 +-
 returnvalues/FwClassIds.h      |   1 +
 tmtcservices/PusParser.cpp     | 114 ---------------------------------
 tmtcservices/PusParser.h       |  82 ------------------------
 7 files changed, 23 insertions(+), 218 deletions(-)
 delete mode 100644 tmtcservices/PusParser.cpp
 delete mode 100644 tmtcservices/PusParser.h

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index b6ac20c1..0e784631 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -21,10 +21,10 @@ public:
 		return (availableWriteSpace(n) == 0);
 	}
 	bool isEmpty(uint8_t n = 0) {
-		return (availableReadData(n) == 0);
+		return (getAvailableReadData(n) == 0);
 	}
 
-	size_t availableReadData(uint8_t n = 0) const {
+	size_t getAvailableReadData(uint8_t n = 0) const {
 		return ((write + size) - read[n]) % size;
 	}
 	size_t availableWriteSpace(uint8_t n = 0) const  {
@@ -36,7 +36,7 @@ public:
 		return overwriteOld;
 	}
 
-	size_t maxSize() const {
+	size_t getMaxSize() const {
 		return size - 1;
 	}
 
@@ -73,7 +73,7 @@ protected:
 	}
 
 	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (availableReadData(n) >= amount) {
+		if (getAvailableReadData(n) >= amount) {
 			incrementRead(amount, n);
 			return HasReturnvaluesIF::RETURN_OK;
 		} else {
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 8d817bb0..0b7a175f 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -71,7 +71,7 @@ ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
 
 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 availableData = getAvailableReadData(READ_PTR);
 	size_t amountTillWrap = readTillWrap(READ_PTR);
 	if (availableData < amount) {
 		if (readRemaining) {
@@ -110,7 +110,7 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = availableReadData(READ_PTR);
+	size_t availableData = getAvailableReadData(READ_PTR);
 	if (availableData < amount) {
 		if (deleteRemaining) {
 			amount = availableData;
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 8d74130f..1a46637f 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -13,7 +13,7 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 	size_t encodedIndex = 0, sourceIndex = 0;
 	uint8_t nextByte;
 	if (addStxEtx) {
-		destStream[0] = STX;
+		destStream[0] = STX_CHAR;
 		++encodedIndex;
 	}
 
@@ -21,12 +21,12 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 	{
 		nextByte = sourceStream[sourceIndex];
 		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX or nextByte == ETX or nextByte == CARRIAGE_RETURN) {
+		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
 			if (encodedIndex + 1 >= maxDestLen) {
 				return STREAM_TOO_SHORT;
 			}
 			else {
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 				++encodedIndex;
 				/* Escaped byte will be actual byte + 0x40. This prevents
 				 * STX, ETX, and carriage return characters from appearing
@@ -39,14 +39,14 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 			}
 		}
 		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE) {
+		else if (nextByte == DLE_CHAR) {
 			if (encodedIndex + 1 >= maxDestLen) {
 			    return STREAM_TOO_SHORT;
 			}
 			else {
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 				++encodedIndex;
-				destStream[encodedIndex] = DLE;
+				destStream[encodedIndex] = DLE_CHAR;
 			}
 		}
 		else {
@@ -58,7 +58,7 @@ ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
 
 	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
 		if (addStxEtx) {
-			destStream[encodedIndex] = ETX;
+			destStream[encodedIndex] = ETX_CHAR;
 			++encodedIndex;
 		}
 		*encodedLen = encodedIndex;
@@ -74,19 +74,19 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		size_t maxDestStreamlen, size_t *decodedLen) {
 	size_t encodedIndex = 0, decodedIndex = 0;
 	uint8_t nextByte;
-	if (*sourceStream != STX) {
+	if (*sourceStream != STX_CHAR) {
 		return DECODING_ERROR;
 	}
 	++encodedIndex;
 
 	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX)
-			&& (sourceStream[encodedIndex] != STX)) {
-		if (sourceStream[encodedIndex] == DLE) {
+			&& (sourceStream[encodedIndex] != ETX_CHAR)
+			&& (sourceStream[encodedIndex] != STX_CHAR)) {
+		if (sourceStream[encodedIndex] == DLE_CHAR) {
 			nextByte = sourceStream[encodedIndex + 1];
 			// The next byte is a DLE character that was escaped by another
 			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE) {
+			if (nextByte == DLE_CHAR) {
 				destStream[decodedIndex] = nextByte;
 			}
 			else {
@@ -111,7 +111,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 		++decodedIndex;
 	}
 
-	if (sourceStream[encodedIndex] != ETX) {
+	if (sourceStream[encodedIndex] != ETX_CHAR) {
 		return DECODING_ERROR;
 	}
 	else {
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index da3bbaaf..3c327a55 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -35,12 +35,12 @@ public:
 	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
 
 	//! Start Of Text character. First character is encoded stream
-	static constexpr uint8_t STX = 0x02;
+	static constexpr uint8_t STX_CHAR = 0x02;
 	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX = 0x03;
+	static constexpr uint8_t ETX_CHAR = 0x03;
 	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
 	//! in the source stream.
-	static constexpr uint8_t DLE = 0x10;
+	static constexpr uint8_t DLE_CHAR = 0x10;
 	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
 
     /**
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 7e4d8953..ebd1847d 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -66,6 +66,7 @@ enum {
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
+	SERIAL_ANALYZER, //SERA 63
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/PusParser.cpp b/tmtcservices/PusParser.cpp
deleted file mode 100644
index f9a0fc57..00000000
--- a/tmtcservices/PusParser.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "../tmtcservices/PusParser.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-PusParser::PusParser(uint16_t maxExpectedPusPackets,
-		bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
-}
-
-ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
-		size_t frameSize) {
-	if(frame == nullptr or frameSize < 5) {
-		sif::error << "PusParser::parsePusPackets: Frame invalid!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(indexSizePairFIFO.full()) {
-		sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	size_t lengthField = frame[4] << 8 | frame[5];
-
-	if(lengthField == 0) {
-		return NO_PACKET_FOUND;
-	}
-
-	size_t packetSize = lengthField + 7;
-	// sif::debug << frameSize << std::endl;
-	// Size of a pus packet is the value in the packet length field plus 7.
-	if(packetSize > frameSize) {
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(0, frameSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< packetSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-	else {
-		indexSizePairFIFO.insert(indexSizePair(0, packetSize));
-		if(packetSize == frameSize) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	// packet size is smaller than frame size, parse for more packets.
-	return readMultiplePackets(frame, frameSize, packetSize);
-}
-
-ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
-		size_t frameSize, size_t startIndex) {
-	while (startIndex < frameSize) {
-		ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-DynamicFIFO<PusParser::indexSizePair>* PusParser::fifo(){
-	return &indexSizePairFIFO;
-}
-
-PusParser::indexSizePair PusParser::getNextFifoPair() {
-	indexSizePair nextIndexSizePair;
-	indexSizePairFIFO.retrieve(&nextIndexSizePair);
-	return nextIndexSizePair;
-}
-
-ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
-		size_t frameSize, size_t& currentIndex) {
-	// sif::debug << startIndex << std::endl;
-    if(currentIndex + 5 > frameSize) {
-        currentIndex = frameSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-	uint16_t lengthField = frame[currentIndex + 4] << 8 |
-			frame[currentIndex + 5];
-	if(lengthField == 0) {
-		// It is assumed that no packet follows.
-		currentIndex = frameSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t nextPacketSize = lengthField + 7;
-	size_t remainingSize = frameSize - currentIndex;
-	if(nextPacketSize > remainingSize)
-	{
-		if(storeSplitPackets) {
-			indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
-		}
-		else {
-			sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
-					"larger than remaining frame," << std::endl;
-			sif::debug << "Throwing away packet. Detected packet size: "
-					<< nextPacketSize << std::endl;
-		}
-		return SPLIT_PACKET;
-	}
-
-	ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
-			nextPacketSize));
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		// FIFO full.
-		sif::debug << "PusParser: Issue inserting into start index size "
-		        "FIFO, it is full!" << std::endl;
-	}
-	currentIndex += nextPacketSize;
-
-	return result;
-}
diff --git a/tmtcservices/PusParser.h b/tmtcservices/PusParser.h
deleted file mode 100644
index 24cba0c0..00000000
--- a/tmtcservices/PusParser.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
-
-#include "../container/DynamicFIFO.h"
-#include <utility>
-#include <cstdint>
-
-/**
- * @brief	This small helper class scans a given buffer for PUS packets.
- * 			Can be used if PUS packets are serialized in a tightly packed frame.
- * @details
- * The parser uses the payload length field of PUS packets to find
- * the respective PUS packet sizes.
- *
- * The parser parses a buffer by taking a pointer and the maximum size to scan.
- * If PUS packets are found, they are stored in a FIFO which stores pairs
- * consisting of the index in the buffer and the respective packet sizes.
- *
- * If the parser detects split packets (which means that the size of the
- * next packet is larger than the remaining size to scan), it can either
- * store that split packet or throw away the packet.
- */
-class PusParser {
-public:
-	//! The first entry is the index inside the buffer while the second index
-	//! is the size of the PUS packet starting at that index.
-	using indexSizePair = std::pair<size_t, size_t>;
-
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
-	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
-	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
-	/**
-	 * Parser constructor.
-	 * @param maxExpectedPusPackets
-	 * Maximum expected number of PUS packets. A good estimate is to divide
-	 * the frame size by the minimum size of a PUS packet (12 bytes)
-	 * @param storeSplitPackets
-	 * Specifies whether split packets are also stored inside the FIFO,
-	 * with the size being the remaining frame size.
-	 */
-	PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
-
-	/**
-	 * Parse a given frame for PUS packets
-	 * @param frame
-	 * @param frameSize
-	 * @return -@c NO_PACKET_FOUND if no packet was found.
-	 */
-	ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
-
-	/**
-	 * Accessor function to get a reference to the internal FIFO which
-	 * stores pairs of indexi and packet sizes. This FIFO is filled
-	 * by the parsePusPackets() function.
-	 * @return
-	 */
-	DynamicFIFO<indexSizePair>* fifo();
-
-	/**
-	 * Retrieve the next index and packet size pair from the FIFO.
-	 * This also removed it from the FIFO. Please note that if the FIFO
-	 * is empty, an empty pair will be returned.
-	 * @return
-	 */
-	indexSizePair getNextFifoPair();
-
-private:
-	/** A FIFO is used to store information about multiple PUS packets
-	 * inside the receive buffer. The maximum number of entries is defined
-	 * by the first constructor argument.
-	 */
-	DynamicFIFO<indexSizePair> indexSizePairFIFO;
-
-	bool storeSplitPackets = false;
-
-	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
-			size_t startIndex);
-	ReturnValue_t readNextPacket(const uint8_t *frame,
-			size_t frameSize, size_t& startIndex);
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

From 9385f9024132a5f5edb23284ee70911e7a302110 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 20:36:49 +0200
Subject: [PATCH 0644/1292] some bugfixes and improvements

---
 container/SimpleRingBuffer.cpp   | 10 +++++++++-
 container/SimpleRingBuffer.h     | 11 ++++++++++-
 globalfunctions/arrayprinter.cpp |  2 +-
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 0b7a175f..7ed019b2 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -42,7 +42,6 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
             excessBytes = amount - amountTillWrap;
         }
         *writePointer = &buffer[write];
-        incrementWrite(amount);
         return HasReturnvaluesIF::RETURN_OK;
     }
     else {
@@ -50,6 +49,14 @@ 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) {
@@ -125,3 +132,4 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index a2cb96ab..b13e9f2a 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -56,7 +56,8 @@ public:
 	/**
 	 * 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.
+	 * 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
@@ -64,6 +65,14 @@ public:
 	 */
 	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
+	/**
+	 * 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);
+
 	virtual size_t getExcessBytes() const;
 	/**
 	 * Helper functions which moves any excess bytes to the start
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 3f02c882..ca080cc5 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
+				printf("\n");
 			}
 		}
 

From 15fd30b23f313a2f8678fb0946a7ec9c84c52266 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 20 Aug 2020 22:31:58 +0200
Subject: [PATCH 0645/1292] assigned read len for decoding error

---
 globalfunctions/DleEncoder.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 1a46637f..21dbd2e6 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -112,6 +112,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 	}
 
 	if (sourceStream[encodedIndex] != ETX_CHAR) {
+		*readLen = ++encodedIndex;
 		return DECODING_ERROR;
 	}
 	else {

From 0d476062299a1c5f305146327be3920480fd940a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 21 Aug 2020 15:49:06 +0200
Subject: [PATCH 0646/1292] tm/tc packet stored improvements

---
 tmtcpacket/pus/TcPacketStored.cpp | 10 +++++-----
 tmtcpacket/pus/TmPacketStored.cpp |  5 +++--
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 3f10cac0..64b369ea 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -20,9 +20,9 @@ TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
 	uint8_t* p_data = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != this->store->RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get free element from store!"
-				<< std::endl;
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
+				"free element from store!" << std::endl;
 		return;
 	}
 	this->setData(p_data);
@@ -57,9 +57,9 @@ ReturnValue_t TcPacketStored::deletePacket() {
 }
 
 bool TcPacketStored::checkAndSetStore() {
-	if (this->store == NULL) {
+	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == NULL) {
+		if (this->store == nullptr) {
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
 			return false;
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index e42f8cda..9476dcd6 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -21,8 +21,9 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
-	if (returnValue != store->RETURN_OK) {
-		sif::debug << "TM Packet Stored: Issue getting free storage" << std::endl;
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TmPacketStored::TmPacketStored: "
+				"Issue getting free storage" << std::endl;
 		checkAndReportLostTm();
 		return;
 	}

From cdaed4523bdbe6f27820de605344340fec6698b2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 21 Aug 2020 16:15:40 +0200
Subject: [PATCH 0647/1292] tmtc bridge todo added

---
 tmtcservices/TmTcBridge.cpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 732a2ea1..5df8eee9 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -107,31 +107,33 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
 		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
 		if(communicationLinkUp == false) {
-			result = storeDownlinkData(&message);
-			return result;
+			storeDownlinkData(&message);
+			continue;
 		}
 
 		result = tmStore->getData(message.getStorageId(), &data, &size);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "TmTcBridge::handleTmQueue: Invalid store "
+					"ID!" << std::endl;
 			continue;
 		}
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
 			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
-			tmStore->deleteData(message.getStorageId());
-			return result;
-
+			status = HasReturnvaluesIF::RETURN_FAILED;
 		}
 		tmStore->deleteData(message.getStorageId());
 	}
-	return RETURN_OK;
+	return status;
 }
 
+// todo: make it configurable whether old data is deleted.
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 

From 2b63f1b3f3557ae05bdb55791d90e2febf8a17c8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 21:00:25 +0200
Subject: [PATCH 0648/1292] New reporting mode

---
 datapoollocal/LocalDataPoolManager.cpp | 22 ++++------------------
 datapoollocal/LocalDataPoolManager.h   | 14 ++++++++++++--
 devicehandlers/DeviceHandlerBase.cpp   |  7 +------
 devicehandlers/DeviceHandlerBase.h     |  2 --
 4 files changed, 17 insertions(+), 28 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a437519e..1121ac7b 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -8,6 +8,8 @@
 #include <array>
 #include <cmath>
 
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
@@ -31,29 +33,13 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 }
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        object_id_t hkDestination, uint8_t nonDiagInvlFactor) {
+        uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
     }
     hkQueue = queueToUse;
 
-    if(hkDestination == objects::NO_OBJECT) {
-        return initializeHousekeepingPoolEntriesOnce();
-    }
-
-    AcceptsHkPacketsIF* hkReceiver =
-            objectManager->get<AcceptsHkPacketsIF>(hkDestination);
-    if(hkReceiver != nullptr) {
-        setHkPacketDestination(hkReceiver->getHkQueue());
-    }
-    else {
-        sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
-                " queue ID from HK destination object ID. " << std::flush;
-        sif::warning << "Make sure it exists and the object impements "
-                "AcceptsHkPacketsIF!" << std::endl;
-    }
-
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
     regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
@@ -228,7 +214,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             performPeriodicHkGeneration(receiver);
             break;
         }
-        case(ReportingType::ON_UPDATE): {
+        case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
             break;
         }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a4113ffe..9403911b 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -15,8 +15,13 @@
 
 #include <map>
 
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
 class LocalDataSetBase;
 
+
 /**
  * @brief 	This class is the managing instance for local data pool.
  * @details
@@ -40,6 +45,7 @@ class LocalDataPoolManager {
 	template<typename T, uint16_t vecSize>
 	friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
+	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -71,7 +77,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-	        object_id_t hkDestination, uint8_t nonDiagInvlFactor = 5);
+			uint8_t nonDiagInvlFactor = 5);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -136,9 +142,10 @@ public:
     enum class ReportingType: uint8_t {
         // Periodic generation of HK packets.
         PERIODIC,
+		UPDATE_NOTIFICATION,
         // Notification will be sent out as message.
         // Data is accessed via shared data set or multiple local data sets.
-        ON_UPDATE,
+        UPDATE_SNAPSHOT,
     };
 
     /* Copying forbidden */
@@ -157,6 +164,9 @@ private:
     dur_millis_t regularMinimumInterval = 0;
     dur_millis_t diagnosticMinimumInterval = 0;
 
+	/** Default receiver for periodic HK packets */
+	static object_id_t defaultHkDestination;
+
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
         /** Different member of this union will be used depending on the
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8d66411a..a3b861b5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -19,7 +19,6 @@
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultHkDestination = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * comCookie,
@@ -194,11 +193,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	if(hkDestination == objects::NO_OBJECT) {
-		hkDestination = defaultHkDestination;
-	}
-
-	result = hkManager.initialize(commandQueue, hkDestination);
+	result = hkManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4aa54fd6..c3640e2f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1043,8 +1043,6 @@ private:
 	/** the object used to set power switches */
 	PowerSwitchIF *powerSwitcher = nullptr;
 
-	/** Cached for initialize() */
-	static object_id_t defaultHkDestination;
 	/** HK destination can also be set individually */
 	object_id_t hkDestination = objects::NO_OBJECT;
 

From 687e124929f367f8009b517450e8f61322bb0613 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 21:52:44 +0200
Subject: [PATCH 0649/1292] doc added

---
 datapoollocal/LocalDataPoolManager.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 9403911b..8700fd38 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -140,11 +140,12 @@ public:
      *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
-        // Periodic generation of HK packets.
+        //! Periodic generation of HK packets.
         PERIODIC,
+		//! Update notification will be sent out as message.
 		UPDATE_NOTIFICATION,
-        // Notification will be sent out as message.
-        // Data is accessed via shared data set or multiple local data sets.
+        //! Notification will be sent out as message and a snapshot of the
+        //! current data will be generated.
         UPDATE_SNAPSHOT,
     };
 

From a95bc6b293683e63c3070b5f2ce33a5e2b3f942f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 22:33:22 +0200
Subject: [PATCH 0650/1292] sid cached now

---
 datapool/PoolDataSetBase.cpp           |  3 ---
 datapoollocal/LocalDataSet.cpp         | 32 +++++++------------------
 datapoollocal/LocalDataSet.h           |  5 ++--
 datapoollocal/LocalPoolDataSetBase.cpp | 33 ++++++++++++++++----------
 datapoollocal/LocalPoolDataSetBase.h   | 16 ++++++-------
 datapoollocal/SharedLocalDataSet.cpp   |  4 ++--
 datapoollocal/SharedLocalDataSet.h     |  2 +-
 datapoollocal/StaticLocalDataSet.h     |  4 ++--
 housekeeping/HousekeepingMessage.h     |  4 ++++
 9 files changed, 47 insertions(+), 56 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index f9a6f391..1acd3fd3 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -5,9 +5,6 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
         const size_t maxFillCount):
         registeredVariables(registeredVariablesArray),
         maxFillCount(maxFillCount) {
-	for (uint8_t count = 0; count < maxFillCount; count++) {
-		registeredVariables[count] = nullptr;
-	}
 }
 
 PoolDataSetBase::~PoolDataSetBase() {}
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index fe9b7d59..f6f13313 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -5,32 +5,16 @@
 #include <cmath>
 #include <cstring>
 
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner,
-        const size_t maxNumberOfVariables):
-        LocalPoolDataSetBase(hkOwner,poolVarList.data(), maxNumberOfVariables) {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
+LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
+        const size_t maxNumberOfVariables): poolVarList(maxNumberOfVariables),
+        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
 }
 
-LocalDataSet::LocalDataSet(object_id_t ownerId,
-        const size_t maxNumberOfVariables):
-        LocalPoolDataSetBase(ownerId, poolVarList.data(), maxNumberOfVariables)  {
-    poolVarList.reserve(maxNumberOfVariables);
-    poolVarList.resize(maxNumberOfVariables);
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
+LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables),
+		poolVarList(maxNumberOfVariables) {
+	this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::~LocalDataSet() {}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index d306fae3..5641ebfb 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -5,8 +5,9 @@
 
 class LocalDataSet: public LocalPoolDataSetBase {
 public:
-    LocalDataSet(HasLocalDataPoolIF* hkOwner, const size_t maxSize);
-    LocalDataSet(object_id_t owner, const size_t maxSize);
+    LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
+    		const size_t maxSize);
+    LocalDataSet(sid_t sid, const size_t maxSize);
     virtual~ LocalDataSet();
 
     //! Copying forbidden for now.
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index cbf2eeef..8abdc0e3 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -6,7 +6,7 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-        PoolVariableIF** registeredVariablesArray,
+		uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
@@ -15,20 +15,23 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
+    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.ownerSetId = setId;
 }
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(object_id_t ownerId,
+LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-            ownerId);
+            sid.objectId);
     if(hkOwner == nullptr) {
         sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
                 << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
+    this->sid = sid;
 }
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
@@ -123,14 +126,6 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
     if(withValidityBuffer) {
@@ -170,9 +165,21 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
     }
 }
 
-bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) const {
+void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
-        sif::debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
+		uint8_t position) const {
+    if(position > 7) {
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        		<< std::endl;
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 091670cf..bd127db4 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -30,28 +30,25 @@ class LocalDataPoolManager;
  *
  * @ingroup data_pool
  */
-// todo: make withValidityBuffer a member
 class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-	        PoolVariableIF** registeredVariablesArray,
+			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
 	 * @brief	Constructor for users of local pool data. The passed pool
 	 * 			owner should implement the HasHkPoolParametersIF.
-	 * 			The constructor simply sets the fill_count to zero and sets
-	 *  		the state to "uninitialized".
 	 * @details
-	 *
+	 * @param sid Unique identifier of dataset consisting of object ID and
+	 * set ID.
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
 	 */
-	LocalPoolDataSetBase(object_id_t ownerId,
-	        PoolVariableIF** registeredVariablesArray,
+	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
@@ -96,6 +93,7 @@ public:
 	bool isValid() const override;
 
 protected:
+	sid_t sid;
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index d44d1eb3..73e0e1fb 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -1,8 +1,8 @@
 #include "SharedLocalDataSet.h"
 
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
         const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(owner, nullptr, maxSize) {
+        LocalPoolDataSetBase(sid, nullptr, maxSize) {
     this->setContainer(poolVarVector.data());
     datasetLock = MutexFactory::instance()->createMutex();
 }
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index c5949e0a..f6748e4d 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -16,7 +16,7 @@ class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
-    SharedLocalDataSet(object_id_t objectId, object_id_t owner,
+    SharedLocalDataSet(object_id_t objectId, sid_t sid,
             const size_t maxSize);
     ReturnValue_t lockDataset(dur_millis_t mutexTimeout) override;
     ReturnValue_t unlockDataset() override;
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 1819cc2d..b3e8422c 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -16,8 +16,8 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-    StaticLocalDataSet(object_id_t owner):
-        LocalPoolDataSetBase(owner, poolVarList.data(), NUM_VARIABLES) {
+    StaticLocalDataSet(sid_t sid):
+        LocalPoolDataSetBase(sid, poolVarList.data(), NUM_VARIABLES) {
     }
 
 private:
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index ff4b39f9..75b31505 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -12,6 +12,10 @@ union sid_t {
 			std::numeric_limits<uint64_t>::max();
 	sid_t(): raw(INVALID_ADDRESS) {}
 
+	sid_t(object_id_t objectId, uint32_t setId):
+			objectId(objectId),
+			ownerSetId(setId) {}
+
 	struct {
 		object_id_t objectId ;
 		/**

From a5227115e5b0361ec33242453ae3435589033200 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 23 Aug 2020 23:24:48 +0200
Subject: [PATCH 0651/1292] first subscriptio nfunction written

---
 datapoollocal/LocalDataPoolManager.cpp | 157 ++++++++++++++-----------
 datapoollocal/LocalDataPoolManager.h   |  27 ++---
 2 files changed, 100 insertions(+), 84 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 1121ac7b..a0f4337c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -32,6 +32,8 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	hkQueue = queueToUse;
 }
 
+LocalDataPoolManager::~LocalDataPoolManager() {}
+
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
         uint8_t nonDiagInvlFactor) {
     if(queueToUse == nullptr) {
@@ -42,17 +44,11 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
 
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
-    regularMinimumInterval = diagnosticMinimumInterval * nonDiagnosticIntervalFactor;
+    regularMinimumInterval = diagnosticMinimumInterval *
+    		nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
-void LocalDataPoolManager::setHkPacketDestination(
-        MessageQueueId_t hkDestination) {
-    this->hkDestination = hkDestination;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {}
-
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
 		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
@@ -66,6 +62,58 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    for(auto& hkReceiversIter: hkReceiversMap) {
+        HkReceiver* receiver = &hkReceiversIter.second;
+        if(not receiver->reportingEnabled) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        switch(receiver->reportingType) {
+        case(ReportingType::PERIODIC): {
+            if(receiver->dataId.dataSetSid.notSet()) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
+            performPeriodicHkGeneration(receiver);
+            break;
+        }
+        case(ReportingType::UPDATE_SNAPSHOT): {
+            // check whether data has changed and send messages in case it has.
+            break;
+        }
+        default:
+            // This should never happen.
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+				" Invalid receiver!"<< std::endl;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.dataSetSid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	hkReceiver.reportingEnabled = enableReporting;
+	hkReceiver.hkParameter.collectionIntervalSeconds = collectionInterval;
+	hkReceiver.isDiagnostics = isDiagnostics;
+	hkReceiver.intervalCounter = 1;
+
+	hkReceiversMap.emplace(packetDestination, hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
@@ -106,46 +154,46 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        float collectionInterval, MessageQueueId_t sendTo) {
-	LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+	LocalPoolDataSetBase* dataSetToSerialize =
+			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	    return result;
-	}
+//	store_address_t storeId;
+//	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+//	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+//	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
+//	if(result != HasReturnvaluesIF::RETURN_OK) {
+//	    return result;
+//	}
 
 	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
+//	CommandMessage hkMessage;
+//	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+//	if(hkQueue == nullptr) {
+//	    return QUEUE_OR_DESTINATION_NOT_SET;
+//	}
+//
+//	if(sendTo != MessageQueueIF::NO_QUEUE) {
+//	    result = hkQueue->sendMessage(sendTo, &hkMessage);
+//	}
+//	else {
+//	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
+//	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
+//	                " Destination is not set properly!" << std::endl;
+//	        return QUEUE_OR_DESTINATION_NOT_SET;
+//	    }
+//	    else {
+//	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
+//	    }
+//	}
 
-	if(sendTo != MessageQueueIF::NO_QUEUE) {
-	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-	}
-	else {
-	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-	                " Destination is not set properly!" << std::endl;
-	        return QUEUE_OR_DESTINATION_NOT_SET;
-	    }
-	    else {
-	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-	    }
-	}
-
-	return result;
+//	return result;
+	return 0;
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
@@ -198,40 +246,14 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    for(auto& hkReceiversIter: hkReceiversMap) {
-        HkReceiver* receiver = &hkReceiversIter.second;
-        if(not receiver->reportingEnabled) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
 
-        switch(receiver->reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid.notSet()) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            // check whether data has changed and send messages in case it has.
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >= intervalSecondsToInterval(
             receiver->isDiagnostics,
             receiver->hkParameter.collectionIntervalSeconds)) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, receiver->destinationQueue);
+                receiver->dataId.dataSetSid /*, receiver->destinationQueue */);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
@@ -259,7 +281,8 @@ uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
 float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         uint32_t collectionInterval) {
     if(isDiagnostics) {
-        return static_cast<float>(collectionInterval * diagnosticMinimumInterval);
+        return static_cast<float>(collectionInterval *
+        		diagnosticMinimumInterval);
     }
     else {
         return static_cast<float>(collectionInterval * regularMinimumInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 8700fd38..df2155ef 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -53,7 +53,6 @@ public:
     static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
 
     static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
-    //static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -79,6 +78,13 @@ public:
 	ReturnValue_t initialize(MessageQueueIF* queueToUse,
 			uint8_t nonDiagInvlFactor = 5);
 
+	/**
+	 * @return
+	 */
+	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination = defaultHkDestination);
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -96,20 +102,13 @@ public:
 	 * @return
 	 */
 	ReturnValue_t performHkOperation();
-	/**
-	 * This function is used to set the default HK packet destination.
-	 * This destination will usually only be set once.
-	 * @param hkDestination
-	 */
-	void setHkPacketDestination(MessageQueueId_t hkDestination);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid, float collectionInterval,
-	        MessageQueueId_t sendTo = MessageQueueIF::NO_QUEUE);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -174,14 +173,15 @@ private:
         type of data the receiver is interested in (full datasets or
         single data variables. */
         union DataId {
+        	DataId(): dataSetSid() {}
             /** Will be initialized to INVALID_ADDRESS */
             sid_t dataSetSid;
             lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
         };
         DataId dataId;
 
-        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         ReportingType reportingType = ReportingType::PERIODIC;
+        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
         bool reportingEnabled = true;
         /** Different members of this union will be used depending on reporting
         type */
@@ -216,13 +216,6 @@ private:
 	 */
 	MessageQueueIF* hkQueue = nullptr;
 
-	/**
-	 * HK replies will always be a reply to the commander, but HK packet
-	 * can be sent to another destination by specifying this message queue
-	 * ID, for example to a dedicated housekeeping service implementation.
-	 */
-	MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
-
 	/** Global IPC store is used to store all packets. */
 	StorageManagerIF* ipcStore = nullptr;
 	/**

From 8e7f167a6628c0b219b0cbe18e991a2b203a2170 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 24 Aug 2020 14:48:22 +0200
Subject: [PATCH 0652/1292] small fix taken over

---
 serialize/SerialBufferAdapter.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index b1e0856a..5528331d 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -30,15 +30,16 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 	}
 	if (*size + serializedLength > maxSize) {
 		return BUFFER_TOO_SHORT;
-	} else {
+	} 
+	else {
 		if (serializeLength) {
 			SerializeAdapter::serialize(&bufferLength, buffer, size,
 					maxSize, streamEndianness);
 		}
-		if (constBuffer != nullptr) {
+		if (this->constBuffer != nullptr) {
 			memcpy(*buffer, this->constBuffer, bufferLength);
 		}
-		else if (buffer != nullptr) {
+		else if (this->buffer != nullptr) {
 			// This will propably be never reached, constBuffer should always be
 			// set if non-const buffer is set.
 			memcpy(*buffer, this->buffer, bufferLength);

From 11ce3d025fc58fd4205ddc3ef4302ab5262f8c2b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 24 Aug 2020 22:08:27 +0200
Subject: [PATCH 0653/1292] srv3 received reply now

---
 datapoollocal/HasLocalDataPoolIF.h        |  11 ++-
 datapoollocal/LocalDataPoolManager.cpp    | 113 ++++++++++++----------
 datapoollocal/LocalDataPoolManager.h      |  12 ++-
 datapoollocal/LocalDataSet.cpp            |   5 +-
 devicehandlers/DeviceHandlerBase.cpp      |  39 +++++---
 devicehandlers/DeviceHandlerBase.h        |  17 ++--
 housekeeping/HousekeepingPacketDownlink.h |   2 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp       |  12 ++-
 osal/FreeRTOS/FixedTimeslotTask.h         |   2 +-
 osal/host/FixedTimeslotTask.cpp           |   2 +-
 osal/host/FixedTimeslotTask.h             |   2 +-
 osal/linux/FixedTimeslotTask.cpp          |   2 +-
 osal/linux/FixedTimeslotTask.h            |   2 +-
 osal/rtems/PollingTask.cpp                |   2 +-
 osal/rtems/PollingTask.h                  |   2 +-
 tasks/FixedSequenceSlot.cpp               |  13 +--
 tasks/FixedSequenceSlot.h                 |  16 +--
 tasks/FixedSlotSequence.cpp               |  51 +++++-----
 tasks/FixedSlotSequence.h                 |   9 +-
 tasks/FixedTimeslotTaskIF.h               |   8 +-
 20 files changed, 193 insertions(+), 129 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index d923b391..9eb1c9f1 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -48,9 +48,14 @@ public:
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
-	/** Is used by pool owner to initialize the pool map once */
-	virtual ReturnValue_t initializePoolEntries(
-	        LocalDataPool& localDataPoolMap) = 0;
+	/**
+	 * Is used by pool owner to initialize the pool map once
+	 * The manager instance shall also be passed to this function.
+	 * It can be used to subscribe for periodic packets for for updates.
+	 */
+	virtual ReturnValue_t initializeLocalDataPool(
+	        LocalDataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) = 0;
 
 	/** Can be used to get a handle to the local data pool manager. */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a0f4337c..87a0a3cb 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -30,28 +30,41 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	}
 
 	hkQueue = queueToUse;
+
+	if(defaultHkDestination != objects::NO_OBJECT) {
+	    AcceptsHkPacketsIF* hkPacketReceiver =
+	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+	    if(hkPacketReceiver != nullptr) {
+	        defaultHkDestinationId = hkPacketReceiver->getHkQueue();
+	    }
+	}
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
-        uint8_t nonDiagInvlFactor) {
+ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         sif::error << "LocalDataPoolManager::initialize: Supplied queue "
                 "invalid!" << std::endl;
     }
     hkQueue = queueToUse;
 
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
+        uint8_t nonDiagInvlFactor) {
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
     diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
     regularMinimumInterval = diagnosticMinimumInterval *
-    		nonDiagnosticIntervalFactor;
+            nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializePoolEntries(localPoolMap);
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+		        *this);
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			mapInitialized = true;
 		}
@@ -106,7 +119,16 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 	hkReceiver.reportingEnabled = enableReporting;
-	hkReceiver.hkParameter.collectionIntervalSeconds = collectionInterval;
+	if(not isDiagnostics) {
+	    hkReceiver.hkParameter.collectionIntervalTicks =
+	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
+	            nonDiagnosticIntervalFactor);
+	}
+	else {
+	    hkReceiver.hkParameter.collectionIntervalTicks =
+	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
+	}
+
 	hkReceiver.isDiagnostics = isDiagnostics;
 	hkReceiver.intervalCounter = 1;
 
@@ -154,54 +176,47 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
     return owner;
 }
 
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
+ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
+        float collectionInterval, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
+				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
-//	store_address_t storeId;
-//	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-//	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-//	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-//	if(result != HasReturnvaluesIF::RETURN_OK) {
-//	    return result;
-//	}
+	sif::info << "hk gen called" << std::endl;
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
+	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	    return result;
+	}
 
 	// and now we set a HK message and send it the HK packet destination.
-//	CommandMessage hkMessage;
-//	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
-//	if(hkQueue == nullptr) {
-//	    return QUEUE_OR_DESTINATION_NOT_SET;
-//	}
-//
-//	if(sendTo != MessageQueueIF::NO_QUEUE) {
-//	    result = hkQueue->sendMessage(sendTo, &hkMessage);
-//	}
-//	else {
-//	    if(hkDestination == MessageQueueIF::NO_QUEUE) {
-//	        sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
-//	                " Destination is not set properly!" << std::endl;
-//	        return QUEUE_OR_DESTINATION_NOT_SET;
-//	    }
-//	    else {
-//	        result = hkQueue->sendMessage(hkDestination, &hkMessage);
-//	    }
-//	}
+	CommandMessage hkMessage;
+	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(hkQueue == nullptr) {
+	    return QUEUE_OR_DESTINATION_NOT_SET;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+	    if(defaultHkDestinationId == MessageQueueIF::NO_QUEUE) {
+	        // error, all destinations invalid
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
+	    destination = defaultHkDestinationId;
+	}
 
-//	return result;
-	return 0;
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
         store_address_t *storeId) {
     uint8_t* dataPtr = nullptr;
-    size_t serializedSize = hkPacket.getSerializedSize();
-    const size_t maxSize = serializedSize;
+    size_t serializedSize = 0;
+    const size_t maxSize = hkPacket.getSerializedSize();
     ReturnValue_t  result = ipcStore->getFreeElement(storeId,
             serializedSize, &dataPtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -246,20 +261,17 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 
-
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->intervalCounter >= intervalSecondsToInterval(
-            receiver->isDiagnostics,
-            receiver->hkParameter.collectionIntervalSeconds)) {
+    if(receiver->intervalCounter >=
+            receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid /*, receiver->destinationQueue */);
+                receiver->dataId.dataSetSid);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
                     << "0x" << std::setfill('0') << std::setw(8)
-            << owner->getObjectId() << " Error generating "
-            << "HK packet" << std::setfill(' ') << std::endl;
+                    << owner->getObjectId() << " Error generating "
+                    << "HK packet" << std::setfill(' ') << std::endl;
         }
         receiver->intervalCounter = 1;
     }
@@ -271,10 +283,12 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
 uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
         float collectionIntervalSeconds) {
     if(isDiagnostics) {
-        return std::ceil(collectionIntervalSeconds/diagnosticMinimumInterval);
+        return std::ceil(collectionIntervalSeconds * 1000
+                /diagnosticMinimumInterval);
     }
     else {
-        return std::ceil(collectionIntervalSeconds/regularMinimumInterval);
+        return std::ceil(collectionIntervalSeconds * 1000
+                /regularMinimumInterval);
     }
 }
 
@@ -285,6 +299,7 @@ float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
         		diagnosticMinimumInterval);
     }
     else {
-        return static_cast<float>(collectionInterval * regularMinimumInterval);
+        return static_cast<float>(collectionInterval *
+                regularMinimumInterval);
     }
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index df2155ef..c851978c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -75,8 +75,9 @@ public:
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse,
-			uint8_t nonDiagInvlFactor = 5);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse);
+
+	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
 	/**
 	 * @return
@@ -108,7 +109,9 @@ public:
 	 * @param sid
 	 * @return
 	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid);
+	ReturnValue_t generateHousekeepingPacket(sid_t sid,
+	        float collectionInterval = 0,
+	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -166,6 +169,7 @@ private:
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
+	MessageQueueId_t defaultHkDestinationId = MessageQueueIF::NO_QUEUE;
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
@@ -187,7 +191,7 @@ private:
         type */
         union HkParameter {
             /** This parameter will be used for the PERIODIC type */
-            float collectionIntervalSeconds = 0;
+            uint32_t collectionIntervalTicks = 0;
             /** This parameter will be used for the ON_UPDATE type */
             bool hkDataChanged;
         };
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index f6f13313..394a9abe 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -6,8 +6,9 @@
 #include <cstring>
 
 LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
-        const size_t maxNumberOfVariables): poolVarList(maxNumberOfVariables),
-        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables) {
+        const size_t maxNumberOfVariables):
+        LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
+        poolVarList(maxNumberOfVariables) {
 	this->setContainer(poolVarList.data());
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index a3b861b5..0253d6a7 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -391,24 +391,28 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		size_t replyLen, bool periodic, bool hasDifferentReplyId,
-		DeviceCommandId_t replyId) {
+		PoolDataSetIF* replyDataSet, size_t replyLen, bool periodic,
+		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
 	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
 	if (hasDifferentReplyId) {
-		return insertInReplyMap(replyId, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(replyId, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	} else {
-		return insertInReplyMap(deviceCommand, maxDelayCycles, replyLen, periodic);
+		return insertInReplyMap(deviceCommand, maxDelayCycles,
+		        replyDataSet, replyLen, periodic);
 	}
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, size_t replyLen, bool periodic) {
+		uint16_t maxDelayCycles, PoolDataSetIF* dataSet,
+		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
 	info.periodic = periodic;
 	info.delayCycles = 0;
 	info.replyLen = replyLen;
+	info.dataSet = dataSet;
 	info.command = deviceCommandMap.end();
 	auto resultPair = deviceReplyMap.emplace(replyId, info);
 	if (resultPair.second) {
@@ -434,13 +438,12 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(
 
 ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceReply,
 		uint16_t delayCycles, uint16_t maxDelayCycles, bool periodic) {
-	std::map<DeviceCommandId_t, DeviceReplyInfo>::iterator iter =
-			deviceReplyMap.find(deviceReply);
-	if (iter == deviceReplyMap.end()) {
+	auto replyIter = deviceReplyMap.find(deviceReply);
+	if (replyIter == deviceReplyMap.end()) {
 		triggerEvent(INVALID_DEVICE_COMMAND, deviceReply);
 		return RETURN_FAILED;
 	} else {
-		DeviceReplyInfo *info = &(iter->second);
+		DeviceReplyInfo *info = &(replyIter->second);
 		if (maxDelayCycles != 0) {
 			info->maxDelayCycles = maxDelayCycles;
 		}
@@ -450,6 +453,17 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 	}
 }
 
+
+ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
+        PoolDataSetIF *dataSet) {
+    auto replyIter = deviceReplyMap.find(replyId);
+    if(replyIter == deviceReplyMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    replyIter->second.dataSet = dataSet;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 void DeviceHandlerBase::callChildStatemachine() {
 	if (mode == _MODE_START_UP) {
 		doStartUp();
@@ -1363,8 +1377,9 @@ void DeviceHandlerBase::debugInterface(uint8_t positionTracker,
 void DeviceHandlerBase::performOperationHook() {
 }
 
-ReturnValue_t DeviceHandlerBase::initializePoolEntries(
-		LocalDataPool &localDataPoolMap) {
+ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
+		LocalDataPool &localDataPoolMap,
+        LocalDataPoolManager& poolManager) {
 	return RETURN_OK;
 }
 
@@ -1379,6 +1394,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }
+    this->hkManager.initializeAfterTaskCreation();
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -1399,3 +1415,4 @@ object_id_t DeviceHandlerBase::getObjectId() const {
 dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
+
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c3640e2f..5357148e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -387,7 +387,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false,
+			uint16_t maxDelayCycles, PoolDataSetIF* replyDataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
 	/**
@@ -401,7 +402,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, size_t replyLen = 0, bool periodic = false);
+			uint16_t maxDelayCycles, PoolDataSetIF* dataSet = nullptr,
+			size_t replyLen = 0, bool periodic = false);
 
 	/**
 	 * @brief 	A simple command to add a command to the commandList.
@@ -429,6 +431,9 @@ protected:
 			uint16_t delayCycles, uint16_t maxDelayCycles,
 			bool periodic = false);
 
+	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
+	        PoolDataSetIF* dataset);
+
 	/**
 	 * @brief   Can be implemented by child handler to
 	 *          perform debugging
@@ -482,8 +487,8 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializePoolEntries(
-				LocalDataPool& localDataPoolMap) override;
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
 	virtual LocalDataPoolManager* getHkManagerHandle() override;
@@ -656,7 +661,7 @@ protected:
 		//! The dataset used to access housekeeping data related to the
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
-		DataSetIF* dataSet = nullptr;
+		PoolDataSetIF* dataSet = nullptr;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1197,7 +1202,7 @@ private:
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
 	virtual ReturnValue_t initializeAfterTaskCreation() override;
-	DataSetIF* getDataSetHandle(sid_t sid) override;
+	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
 
 	void parseReply(const uint8_t* receivedData,
 	            size_t receivedDataLen);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index 97b6a994..bee0bac1 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -25,7 +25,7 @@ public:
 
     /**
      * Helper functions which can be used to move HK data from the IPC store
-     * to the telemetry store.
+     * to the telemetry store. TODO: maybe not needed.
      * @param formerStore
      * @param storeId
      * @param newStore
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 769f31e1..a112092f 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -8,7 +8,7 @@ const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod overallPeriod,
 		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(NULL), pst(overallPeriod * 1000) {
+		started(false), handle(nullptr), pst(overallPeriod * 1000) {
 	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
 	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
 	// All additional attributes are applied to the object.
@@ -62,8 +62,10 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+    ExecutableObjectIF* handler =
+            objectManager->get<ExecutableObjectIF>(componentId);
+	if (handler != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -76,8 +78,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+	return pst.checkAndInitializeSequence();
 }
 
 void FixedTimeslotTask::taskFunctionality() {
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 42af14b8..0e9611d2 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -54,7 +54,7 @@ public:
 
 	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkSequence() const override;
+	ReturnValue_t checkAndInitializeSequence() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1999c9e6..2bb0f84d 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -132,7 +132,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
     return pollingSeqTable.checkSequence();
 }
 
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index bbee94a6..861a072e 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -61,7 +61,7 @@ public:
     ReturnValue_t addSlot(object_id_t componentId,
                    uint32_t slotTimeMs, int8_t executionStep);
 
-    ReturnValue_t checkSequence() const;
+    ReturnValue_t checkAndInitializeSequence() const;
 
     uint32_t getPeriodMs() const;
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 60ce9a63..c381bb78 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -49,7 +49,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 83bf203e..f7b6e954 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -33,7 +33,7 @@ public:
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
 			int8_t executionStep);
 
-	virtual ReturnValue_t checkSequence() const;
+	virtual ReturnValue_t checkAndInitializeSequence() const;
 
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 527df367..b53d6a5a 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -82,7 +82,7 @@ uint32_t PollingTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t PollingTask::checkSequence() const {
+ReturnValue_t PollingTask::checkAndInitializeSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 759ed43d..60ce0816 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -42,7 +42,7 @@ class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
 
 	uint32_t getPeriodMs() const;
 
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkAndInitializeSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
 protected:
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index cccc6371..9d290d19 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -3,13 +3,14 @@
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, PeriodicTaskIF* executingTask) :
+		int8_t setSequenceId, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) :
 		pollingTimeMs(setTime), opcode(setSequenceId) {
-	handler = objectManager->get<ExecutableObjectIF>(handlerId);
-	if(executingTask != nullptr) {
-	    handler->setTaskIF(executingTask);
-	}
-	handler->initializeAfterTaskCreation();
+    if(executableObject == nullptr) {
+        return;
+    }
+    this->executableObject = executableObject;
+    this->executableObject->setTaskIF(executingTask);
 }
 
 FixedSequenceSlot::~FixedSequenceSlot() {}
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index e33134de..9cf5894c 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -16,21 +16,23 @@ class PeriodicTaskIF;
 class FixedSequenceSlot {
 public:
 	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, PeriodicTaskIF* executingTask );
+			int8_t setSequenceId, ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
 	virtual ~FixedSequenceSlot();
 
 	/**
-	 * @brief	Handler identifies which device handler object is executed in this slot.
+	 * @brief	Handler identifies which object is executed in this slot.
 	 */
-	ExecutableObjectIF*	handler = nullptr;
+	ExecutableObjectIF*	executableObject = nullptr;
 
 	/**
 	 * @brief	This attribute defines when a device handler object is executed.
-	 *
-	 * @details	The pollingTime attribute identifies the time the handler is executed in ms.
-	 * 			It must be smaller than the period length of the polling sequence.
+	 * @details
+	 * The pollingTime attribute identifies the time the handler is
+	 * executed in ms. It must be smaller than the period length of the
+	 * polling sequence.
 	 */
-	uint32_t	pollingTimeMs;
+	uint32_t pollingTimeMs;
 
 	/**
 	 * @brief	This value defines the type of device communication.
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 27dfff2b..e51762ea 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -13,7 +13,7 @@ FixedSlotSequence::~FixedSlotSequence() {
 }
 
 void FixedSlotSequence::executeAndAdvance() {
-	current->handler->performOperation(current->opcode);
+	current->executableObject->performOperation(current->opcode);
 //	if (returnValue != RETURN_OK) {
 //		this->sendErrorMessage( returnValue );
 //	}
@@ -81,34 +81,38 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 	return this->lengthMs;
 }
 
-ReturnValue_t FixedSlotSequence::checkSequence() const {
+ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 	if(slotList.empty()) {
 		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	auto slotIt = slotList.begin();
+	std::set<ExecutableObjectIF*> uniqueObjects;
 	uint32_t count = 0;
 	uint32_t time = 0;
-	while (slotIt != slotList.end()) {
-		if (slotIt->handler == nullptr) {
-			sif::error << "FixedSlotSequene::initialize: ObjectId does not exist!"
-					<< std::endl;
+	for(const auto& slot: slotList) {
+		if (slot.executableObject == nullptr) {
 			count++;
-		} else if (slotIt->pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slotIt->pollingTimeMs
-					<< " is smaller than previous with " << time << std::endl;
-			count++;
-		} else {
-			// All ok, print slot.
-			//info << "Current slot polling time: " << std::endl;
-			//info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
-		time = slotIt->pollingTimeMs;
-		slotIt++;
+		else if (slot.pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slot.pollingTimeMs << " is smaller than previous with "
+					<< time << std::endl;
+			count++;
+		}
+		else {
+			// All ok, print slot.
+			//sif::info << "Current slot polling time: " << std::endl;
+			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slot.pollingTimeMs;
+		// Ensure that each unique object is initialized once.
+		if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+		    slot.executableObject->initializeAfterTaskCreation();
+		    uniqueObjects.emplace(slot.executableObject);
+		}
 	}
-	//info << "Number of elements in slot list: "
+	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
 	if (count > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -117,8 +121,9 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 }
 
 void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, PeriodicTaskIF* executingTask) {
-	this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs, executionStep,
-			executingTask));
-	this->current = slotList.begin();
+		int8_t executionStep, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
 }
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 67ce0094..1aa420ce 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -59,7 +59,7 @@ public:
 	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			PeriodicTaskIF* executingTask);
+			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
 
 	/**
 	 * Checks if the current slot shall be executed immediately after the one before.
@@ -125,11 +125,14 @@ public:
 	SlotListIter current;
 
 	/**
-	 * Iterate through slotList and check successful creation.
+	 * @brief   Check and initialize slot list.
+	 * @details
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * Also calls any initialization steps which are required after task
+	 * creation.
 	 * @return
 	 */
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkAndInitializeSequence() const;
 
 protected:
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 3456dae7..d3155490 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -22,8 +22,12 @@ public:
 	 */
 	virtual ReturnValue_t addSlot(object_id_t componentId,
 			uint32_t slotTimeMs, int8_t executionStep) = 0;
-	/** Check whether the sequence is valid */
-	virtual ReturnValue_t checkSequence() const = 0;
+
+	/**
+	 * Check whether the sequence is valid and perform all other required
+	 * initialization steps which are needed after task creation
+	 */
+	virtual ReturnValue_t checkAndInitializeSequence() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

From c8ba486538fe6086ab8835a70c5656dd5a4ce1af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:17:57 +0200
Subject: [PATCH 0654/1292] serial buffer adapter

---
 serialize/SerialBufferAdapter.cpp | 33 ++++++++++++++-----------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 5528331d..53d0b8d4 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -20,9 +20,9 @@ template<typename count_t>
 SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += SerializeAdapter::getSerializedSize(
@@ -53,8 +53,8 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
 	}
 }
 
-template<typename T>
-size_t SerialBufferAdapter<T>::getSerializedSize() const {
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 	if (serializeLength) {
 		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
 	} else {
@@ -62,26 +62,22 @@ size_t SerialBufferAdapter<T>::getSerializedSize() const {
 	}
 }
 
-template<typename T>
-ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, Endianness streamEndianness) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
+	if (this->buffer != nullptr) {
 		if(serializeLength){
-			T serializedSize = SerializeAdapter::getSerializedSize(
-					&bufferLength);
-			if(bufferLength + serializedSize <= *size) {
-				*buffer +=  serializedSize;
-				*size -= serializedSize;
-			}
-			else {
-				return STREAM_TOO_SHORT;
+			ReturnValue_t result = SerializeAdapter::deSerialize(&bufferLength,
+					buffer, size, streamEndianness);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
 			}
 		}
 		//No Else If, go on with buffer
 		if (bufferLength <= *size) {
 			*size -= bufferLength;
-			memcpy(this->buffer, *buffer, bufferLength);
+			std::memcpy(this->buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
@@ -107,7 +103,8 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter: Buffers are unitialized!" << std::endl;
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;

From b97128c12eed9d6b3e5d74f861ab99c6c7cea7ba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:29:10 +0200
Subject: [PATCH 0655/1292] deserialize improved

---
 serialize/SerialBufferAdapter.cpp | 39 +++++++++++++++++--------------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 53d0b8d4..8a5bef4a 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -65,28 +65,31 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 		size_t* size, Endianness streamEndianness) {
-	//TODO Ignores Endian flag!
-	if (this->buffer != nullptr) {
-		if(serializeLength){
-			ReturnValue_t result = SerializeAdapter::deSerialize(&bufferLength,
-					buffer, size, streamEndianness);
-			if(result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
 		}
-		//No Else If, go on with buffer
-		if (bufferLength <= *size) {
-			*size -= bufferLength;
-			std::memcpy(this->buffer, *buffer, bufferLength);
-			(*buffer) += bufferLength;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		else {
-			return STREAM_TOO_SHORT;
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
 		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return STREAM_TOO_SHORT;
 	}
 }
 

From 92e18b91a3a9d4dac069281971009b4dba5a1dd7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:38:53 +0200
Subject: [PATCH 0656/1292] seriasl buffer update

---
 serialize/SerialBufferAdapter.cpp | 49 ++++++++++++++++---------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 8a5bef4a..ab52262f 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -23,34 +23,33 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
 		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
-		serializedLength += SerializeAdapter::getSerializedSize(
-				&bufferLength);
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 	}
-	if (*size + serializedLength > maxSize) {
+
+	if (*size + bufferLength > maxSize) {
 		return BUFFER_TOO_SHORT;
-	} 
-	else {
-		if (serializeLength) {
-			SerializeAdapter::serialize(&bufferLength, buffer, size,
-					maxSize, streamEndianness);
-		}
-		if (this->constBuffer != nullptr) {
-			memcpy(*buffer, this->constBuffer, bufferLength);
-		}
-		else if (this->buffer != nullptr) {
-			// This will propably be never reached, constBuffer should always be
-			// set if non-const buffer is set.
-			memcpy(*buffer, this->buffer, bufferLength);
-		}
-		else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*size += bufferLength;
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
 	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
 }
 
 template<typename count_t>
@@ -126,4 +125,6 @@ void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
 template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
 template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+template class SerialBufferAdapter<size_t>;
 

From 6afbeb8423cdb3d5a0cf2d2c41623d1310ed2e73 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 13:42:11 +0200
Subject: [PATCH 0657/1292] removed linker forward decl

---
 serialize/SerialBufferAdapter.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index ab52262f..812cd34b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -126,5 +126,4 @@ template class SerialBufferAdapter<uint8_t>;
 template class SerialBufferAdapter<uint16_t>;
 template class SerialBufferAdapter<uint32_t>;
 template class SerialBufferAdapter<uint64_t>;
-template class SerialBufferAdapter<size_t>;
 

From da3b2b2500592047335c689d8f7d9b9b15f60a86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 25 Aug 2020 18:09:05 +0200
Subject: [PATCH 0658/1292] form improvements

---
 ipc/CommandMessage.cpp         |   4 +-
 ipc/CommandMessage.h           |  12 ++--
 ipc/CommandMessageIF.h         |  10 +--
 ipc/MessageQueueIF.h           | 111 ++++++++++++++++++++------------
 ipc/MessageQueueMessage.cpp    |   2 +-
 ipc/MessageQueueMessage.h      |   6 +-
 ipc/MessageQueueMessageIF.h    |   6 +-
 ipc/MutexHelper.h              |   6 +-
 ipc/QueueFactory.h             |   2 +-
 osal/FreeRTOS/MessageQueue.cpp |  10 +--
 osal/FreeRTOS/MessageQueue.h   | 113 ++++++++-------------------------
 11 files changed, 125 insertions(+), 157 deletions(-)

diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 6934e6ce..16293608 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,5 +1,5 @@
-#include "../ipc/CommandMessage.h"
-#include "../ipc/CommandMessageCleaner.h"
+#include "CommandMessage.h"
+#include "CommandMessageCleaner.h"
 #include <cstring>
 
 CommandMessage::CommandMessage() {
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 73b73dc9..3be9a120 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGE_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGE_H_
+#ifndef FSFW_IPC_COMMANDMESSAGE_H_
+#define FSFW_IPC_COMMANDMESSAGE_H_
 
-#include "../ipc/CommandMessageIF.h"
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/FwMessageTypes.h"
+#include "CommandMessageIF.h"
+#include "MessageQueueMessage.h"
+#include "FwMessageTypes.h"
 
 /**
  * @brief 	Default command message used to pass command messages between tasks.
@@ -126,4 +126,4 @@ public:
     size_t getMinimumMessageSize() const override;
 };
 
-#endif /* COMMANDMESSAGE_H_ */
+#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index e5f962ae..68a8d956 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGEIF_H_
+#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
+#define FSFW_IPC_COMMANDMESSAGEIF_H_
 
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/FwMessageTypes.h"
+#include "MessageQueueMessageIF.h"
+#include "FwMessageTypes.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 #define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
@@ -70,4 +70,4 @@ public:
 
 };
 
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGEIF_H_ */
+#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 6ae852ea..1e80f7bd 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEIF_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
+#define FSFW_IPC_MESSAGEQUEUEIF_H_
 
 // COULDDO: We could support blocking calls
 // semaphores are being implemented, which makes this idea even more iteresting.
@@ -30,21 +30,28 @@ public:
 	virtual ~MessageQueueIF() {}
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return RETURN_OK if ok
-	 * @return NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found
+	 * @details
+	 * This operation simplifies answering an incoming message by using the
+	 * stored lastParnter information as destination. If there was no message
+	 * received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message
+	 * A pointer to a previously created message, which is sent.
+	 * @return
+	 * -@c RETURN_OK if ok
+	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
 	 */
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) = 0;
+	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
 
 	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 * @brief	This function reads available messages from the message queue
+	 *          and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in addition
+	 * returns the sender's queue id.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
+	 * @param receivedFrom
+	 * A pointer to a queue id in which the sender's id is stored.
 	 */
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) = 0;
@@ -57,7 +64,8 @@ public:
 	 * information is stored in theblastPartner attribute. Else, the lastPartner
 	 * information remains untouched, the message's content is cleared and the
 	 * function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::EMPTY if queue is empty
 	 */
@@ -69,24 +77,33 @@ public:
 	 */
 	virtual ReturnValue_t flush(uint32_t* count) = 0;
 	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
+	 * @brief	This method returns the message queue
+	 *          id of the last communication partner.
 	 */
 	virtual MessageQueueId_t getLastPartner() const = 0;
 	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
+	 * @brief	This method returns the message queue
+	 *          id of this class's message queue.
 	 */
 	virtual MessageQueueId_t getId() const = 0;
 
 	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * @details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send the message to.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full (if implemented).
+	 * @brief	With the sendMessage call, a queue message
+	 *          is sent to a receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information
+	 * and passes it on to the destination provided with an operating system
+	 * call. The OS's returnvalue is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full (if implemented).
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
@@ -96,21 +113,31 @@ public:
 
 	/**
 	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 * @details
+	 * It directly uses the sendMessage call of the MessageQueueSender parent,
+	 * but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo
+	 * This parameter specifies the message queue id of the destination
+	 * message queue.
+	 * @param message
+	 * A pointer to a previously created message, which is sent.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full.
 	 */
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
 
 	/**
-	 * @brief	The sendToDefaultFrom method sends a queue message to the default destination.
-	 * @details	In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
+	 * @brief	The sendToDefaultFrom method sends a queue message
+	 *          to the default destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
@@ -118,19 +145,21 @@ public:
 			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
 	/**
 	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			Implementation class and adds its queue id as "sentFrom" information.
+	 * @details
+	 * As in the sendMessage method, this function uses the sendToDefault
+	 * call of the Implementation class and adds its queue id as
+	 * "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 * @return -@c RETURN_OK on success
 	 *         -@c MessageQueueIF::FULL if queue is full
 	 */
 	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
 	/**
-	 * \brief	This method is a simple setter for the default destination.
+	 * @brief	This method is a simple setter for the default destination.
 	 */
 	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
 	/**
-	 * \brief	This method is a simple getter for the default destination.
+	 * @brief	This method is a simple getter for the default destination.
 	 */
 	virtual MessageQueueId_t getDefaultDestination() const = 0;
 
@@ -139,4 +168,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUEIF_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index d0032129..2f79cb3b 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,4 +1,4 @@
-#include "../ipc/MessageQueueMessage.h"
+#include "MessageQueueMessage.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index cf06fde6..da5c78cb 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGE_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include "../ipc/MessageQueueMessageIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -147,4 +147,4 @@ public:
 	void print(bool printWholeMessage);
 };
 
-#endif /* MESSAGEQUEUEMESSAGE_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index c6c677c1..91753ced 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -29,8 +29,10 @@ public:
 
 	/**
 	 * @brief	With this method, the whole content and the message
-	 * 			size is set to zero. Implementations should also take care
-	 * 			to clear data which is stored indirectly (e.g. storage data).
+	 * 			size is set to zero.
+	 * @details
+	 * Implementations should also take care to clear data which is stored
+	 * indirectly (e.g. storage data).
 	 */
 	virtual void clear() = 0;
 
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 31d8d9ec..97e28007 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
 #define FRAMEWORK_IPC_MUTEXHELPER_H_
 
-#include "../ipc/MutexFactory.h"
+#include "MutexFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 class MutexHelper {
@@ -16,8 +16,8 @@ public:
 					<< timeoutMs << " milliseconds!" << std::endl;
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
-					status << std::endl;
+			sif::error << "MutexHelper: Lock of Mutex failed with code "
+			        << status << std::endl;
 		}
 	}
 
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 8141a3cf..e9891987 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
-#include "../ipc/MessageQueueIF.h"
+#include "MessageQueueIF.h"
 #include <cstdint>
 /**
  * Creates message queues.
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 933689e8..e3e0ef1c 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/MessageQueue.h"
+#include "MessageQueue.h"
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
@@ -10,13 +10,13 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
-	if (handle == NULL) {
-		sif::error << "MessageQueue: Creation failed" << std::endl;
+	if (handle == nullptr) {
+		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
 	}
 }
 
 MessageQueue::~MessageQueue() {
-	if (handle != NULL) {
+	if (handle != nullptr) {
 		vQueueDelete(handle);
 	}
 }
@@ -126,7 +126,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	BaseType_t result = pdFALSE;
 	QueueHandle_t destination = nullptr;
 
-	if(sendTo == MessageQueueIF::NO_QUEUE) {
+	if(sendTo == MessageQueueIF::NO_QUEUE or sendTo == 0x00) {
 		return MessageQueueIF::DESTINVATION_INVALID;
 	}
 	else  {
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 48a5ab6a..11986751 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -43,11 +43,12 @@ public:
 	/**
 	 * @brief	The constructor initializes and configures the message queue.
 	 * @details
-	 * By making use of the according operating system call, a message queue is created
-	 * and initialized. The message depth - the maximum number of messages to be
-	 * buffered - may be set with the help of a parameter, whereas the message size is
-	 * automatically set to the maximum message queue message size. The operating system
-	 * sets the message queue id, or i case of failure, it is set to zero.
+	 * By making use of the according operating system call, a message queue
+	 * is created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
 	 * @param message_depth
 	 * The number of messages to be buffered before passing an error to the
 	 * sender. Default is three.
@@ -76,103 +77,39 @@ public:
 	 */
 	void switchSystemContext(CallContext callContext);
 
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
+	/** MessageQueueIF implementation */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 
-	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * @details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send the message to.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
 	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
-	/**
-	 * @brief	The sendToDefault method sends a queue message to the default destination.
-	 * @details	In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
 	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
 			MessageQueueId_t sentFrom = NO_QUEUE,
 			bool ignoreFault = false) override;
 
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
 	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) override;
 
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
 	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
 
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
+	ReturnValue_t flush(uint32_t* count) override;
+
+	MessageQueueId_t getLastPartner() const override;
+
+	MessageQueueId_t getId() const override;
+
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
 
-	bool isDefaultDestinationSet() const;
 protected:
 	/**
 	 * @brief 	Implementation to be called from any send Call within
@@ -205,8 +142,8 @@ private:
 	MessageQueueId_t defaultDestination = 0;
 	MessageQueueId_t lastPartner = 0;
 	const size_t maxMessageSize;
-	//!< Stores the current system context
+	//! Stores the current system context
 	CallContext callContext =  CallContext::TASK;
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */

From c314792e86042a2d60a7ce3a6af265fea4da61a7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 02:52:59 +0200
Subject: [PATCH 0659/1292] linebreak changed

---
 globalfunctions/arrayprinter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index ca080cc5..1e58ca75 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				printf("\n");
+				sif::info << "\r\n" << std::flush;
 			}
 		}
 

From 51b62fd9b189ea149b64a2015c0497240041129c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 03:21:26 +0200
Subject: [PATCH 0660/1292] debug output fix

---
 pus/Service1TelecommandVerification.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index f6cbf6bf..fb66c160 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -53,7 +53,7 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
+		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
 	}
 	return result;

From 83c9d4fc1cb22228f1d58a0f6ba5a1f0f36b6fb0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 14:55:27 +0200
Subject: [PATCH 0661/1292] improved tmtc bridge

---
 tmtcservices/TmTcBridge.cpp | 88 +++++++++++++++++++++++--------------
 tmtcservices/TmTcBridge.h   | 14 ++++--
 2 files changed, 65 insertions(+), 37 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 5df8eee9..29153dd5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -66,6 +66,8 @@ ReturnValue_t TmTcBridge::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
+	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
+
 	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
 	return RETURN_OK;
 }
@@ -90,17 +92,25 @@ ReturnValue_t TmTcBridge::handleTc() {
 }
 
 ReturnValue_t TmTcBridge::handleTm() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
-		return RETURN_FAILED;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
+		        << std::endl;
+		status = result;
 	}
 
-	if(tmStored and communicationLinkUp) {
-		result = handleStoredTm();
+	if(tmStored and communicationLinkUp and
+	        (packetSentCounter < sentPacketsPerCycle)) {
+	    result = handleStoredTm();
+	    if(result != RETURN_OK) {
+	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
+	                << std::endl;
+	        status = result;
+	    }
 	}
-	return result;
-
+	packetSentCounter = 0;
+	return status;
 }
 
 ReturnValue_t TmTcBridge::handleTmQueue() {
@@ -109,85 +119,91 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	size_t size = 0;
 	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
-		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
+		 result == HasReturnvaluesIF::RETURN_OK;
+		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
-		if(communicationLinkUp == false) {
+		if(communicationLinkUp == false or
+		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
 			continue;
 		}
 
 		result = tmStore->getData(message.getStorageId(), &data, &size);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "TmTcBridge::handleTmQueue: Invalid store "
-					"ID!" << std::endl;
+			status = result;
 			continue;
 		}
 
 		result = sendTm(data, size);
-		if (result != RETURN_OK) {
-			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
-			status = HasReturnvaluesIF::RETURN_FAILED;
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
 		}
 		tmStore->deleteData(message.getStorageId());
+		packetSentCounter++;
 	}
 	return status;
 }
 
-// todo: make it configurable whether old data is deleted.
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
-	if(tmFifo.full()) {
-		sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-		        << "of stored packet IDs reached! "
-		        << "Overwriting old data" << std::endl;
-		tmFifo.retrieve(&storeId);
-		tmStore->deleteData(storeId);
+	if(tmFifo->full()) {
+	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+	                    << "of stored packet IDs reached! " << std::endl;
+	    if(overwriteOld) {
+	        tmFifo->retrieve(&storeId);
+	                tmStore->deleteData(storeId);
+	    }
+	    else {
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
 	}
+
 	storeId = message->getStorageId();
-	tmFifo.insert(storeId);
+	tmFifo->insert(storeId);
 	tmStored = true;
 	return RETURN_OK;
 }
 
 ReturnValue_t TmTcBridge::handleStoredTm() {
-	uint8_t counter = 0;
-	ReturnValue_t result = RETURN_OK;
-	while(not tmFifo.empty() and counter < sentPacketsPerCycle) {
+    ReturnValue_t status = RETURN_OK;
+	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
 		//info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
 		size_t size = 0;
-		tmFifo.retrieve(&storeId);
-		result = tmStore->getData(storeId, &data, &size);
-
-		sendTm(data,size);
+		tmFifo->retrieve(&storeId);
+		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    status = result;
+		}
 
+		result = sendTm(data,size);
 		if(result != RETURN_OK) {
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
-			result = RETURN_FAILED;
+			status = result;
 		}
-		counter ++;
+		packetSentCounter ++;
 
-		if(tmFifo.empty()) {
+		if(tmFifo->empty()) {
 			tmStored = false;
 		}
 		tmStore->deleteData(storeId);
 	}
-	return result;
+	return status;
 }
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
-		//info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
-	//info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}
@@ -211,3 +227,7 @@ MessageQueueId_t TmTcBridge::getRequestQueue() {
 	// Default implementation: Relay TC messages to TC distributor directly.
 	return tmTcReceptionQueue->getDefaultDestination();
 }
+
+void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
+    this->overwriteOld = overwriteOld;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index b91425e1..763980dc 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
+
 #include "../objectmanager/SystemObject.h"
 #include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-#include "../container/FIFO.h"
+#include "../container/DynamicFIFO.h"
 #include "../tmtcservices/TmTcMessage.h"
 
 class TmTcBridge : public AcceptsTelemetryIF,
@@ -46,6 +46,12 @@ public:
 	 */
 	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
 
+	/**
+	 * This will set up the bridge to overwrite old data in the FIFO.
+	 * @param overwriteOld
+	 */
+	void setFifoToOverwriteOldData(bool overwriteOld);
+
 	virtual void registerCommConnect();
 	virtual void registerCommDisconnect();
 
@@ -86,6 +92,8 @@ protected:
 	//! by default, so telemetry will be handled immediately.
 	bool communicationLinkUp = true;
 	bool tmStored = false;
+	bool overwriteOld = true;
+	uint8_t packetSentCounter = 0;
 
 	/**
 	 * @brief 	Handle TC reception
@@ -145,7 +153,7 @@ protected:
 	 * This fifo can be used to store downlink data
 	 * which can not be sent at the moment.
 	 */
-	FIFO<store_address_t, LIMIT_DOWNLINK_PACKETS_STORED> tmFifo;
+	DynamicFIFO<store_address_t>* tmFifo = nullptr;
     uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
     uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
 };

From 0f9930524b4b7ff8e3e4d5b13ea926ce4b3676f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 26 Aug 2020 15:54:13 +0200
Subject: [PATCH 0662/1292] some minor improvements

---
 tmtcservices/TmTcBridge.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 29153dd5..706bbbf2 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -122,6 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
+	    //sif::info << (int) packetSentCounter << std::endl;
 		if(communicationLinkUp == false or
 		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
@@ -138,8 +139,10 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			status = result;
 		}
-		tmStore->deleteData(message.getStorageId());
-		packetSentCounter++;
+		else {
+		    tmStore->deleteData(message.getStorageId());
+		    packetSentCounter++;
+		}
 	}
 	return status;
 }
@@ -152,7 +155,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	                    << "of stored packet IDs reached! " << std::endl;
 	    if(overwriteOld) {
 	        tmFifo->retrieve(&storeId);
-	                tmStore->deleteData(storeId);
+	        tmStore->deleteData(storeId);
 	    }
 	    else {
 	        return HasReturnvaluesIF::RETURN_FAILED;
@@ -168,8 +171,9 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-		//info << "TMTC Bridge: Sending stored TM data. There are "
-		//     << (int) fifo.size() << " left to send\r\n" << std::flush;
+		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
+		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
 		size_t size = 0;

From 67ab1f6240772ba1c85c6c826f8e9ee097418127 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 14:17:13 +0200
Subject: [PATCH 0663/1292] initialize after task crteation moved

---
 controller/ControllerBase.cpp  | 15 ++++++----
 controller/ControllerBase.h    | 55 +++++++++++++++++++++-------------
 osal/FreeRTOS/PeriodicTask.cpp |  7 ++++-
 3 files changed, 50 insertions(+), 27 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 4ce854dc..2f43b13e 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -4,13 +4,12 @@
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
 
-ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId,
+ControllerBase::ControllerBase(object_id_t setObjectId, object_id_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) {
+		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
+		submode(SUBMODE_NONE), modeHelper(this),
+		healthHelper(this, setObjectId), hkSwitcher(this) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-
 }
 
 ControllerBase::~ControllerBase() {
@@ -24,7 +23,7 @@ ReturnValue_t ControllerBase::initialize() {
 	}
 
 	MessageQueueId_t parentQueue = 0;
-	if (parentId != 0) {
+	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
 		if (parent == NULL) {
 			return RETURN_FAILED;
@@ -135,3 +134,7 @@ void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
 
 void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index d98a6665..5aacd9d8 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,5 +1,5 @@
-#ifndef CONTROLLERBASE_H_
-#define CONTROLLERBASE_H_
+#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
+#define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -9,29 +9,32 @@
 #include "../tasks/ExecutableObjectIF.h"
 #include "../datapool/HkSwitchHelper.h"
 
-
+/**
+ * @brief  Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers.
+ */
 class ControllerBase: public HasModesIF,
 		public HasHealthIF,
 		public ExecutableObjectIF,
 		public SystemObject,
 		public HasReturnvaluesIF {
 public:
-
 	static const Mode_t MODE_NORMAL = 2;
 
-	ControllerBase(uint32_t setObjectId, uint32_t parentId,
+	ControllerBase(object_id_t setObjectId, object_id_t parentId,
 			size_t commandQueueDepth = 3);
 	virtual ~ControllerBase();
 
-	ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t setHealth(HealthState health) override;
 
-	virtual HasHealthIF::HealthState getHealth();
+	virtual HasHealthIF::HealthState getHealth() override;
 
 	/**
 	 * Implementation of ExecutableObjectIF function
@@ -39,17 +42,32 @@ public:
 	 * 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_);
+	virtual  void setTaskIF(PeriodicTaskIF* task_) override;
 
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
-	const uint32_t parentId;
+
+	/**
+	 * Implemented by child class. Handle command messages which are not
+	 * mode or health messages.
+	 * @param message
+	 * @return
+	 */
+    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;
+
+	const object_id_t parentId;
 
 	Mode_t mode;
 
 	Submode_t submode;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	ModeHelper modeHelper;
 
@@ -58,16 +76,13 @@ protected:
 	HkSwitchHelper hkSwitcher;
 
 	/**
-	 * Pointer to the task which executes this component, is invalid before setTaskIF was called.
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
 	 */
-	PeriodicTaskIF* executingTask;
+	PeriodicTaskIF* executingTask = nullptr;
 
 	void handleQueue();
 
-	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);
@@ -76,4 +91,4 @@ protected:
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 };
 
-#endif /* CONTROLLERBASE_H_ */
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 662ece3b..f99e8a4e 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -64,6 +64,11 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 void PeriodicTask::taskFunctionality() {
 	TickType_t xLastWakeTime;
 	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
+
+	for (auto const& object: objectList) {
+	    object->initializeAfterTaskCreation();
+	}
+
 	/* The xLastWakeTime variable needs to be initialized with the current tick
 	 count. Note that this is the only time the variable is written to
 	 explicitly. After this assignment, xLastWakeTime is updated automatically
@@ -93,7 +98,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	objectList.push_back(newObject);
 	newObject->setTaskIF(this);
 
-	return newObject->initializeAfterTaskCreation();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 uint32_t PeriodicTask::getPeriodMs() const {

From 1dfdd65662583271a202ee759c2fb48cc0ad6386 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 14:42:10 +0200
Subject: [PATCH 0664/1292] new initializeSequence func

---
 osal/FreeRTOS/FixedTimeslotTask.cpp |  6 ++--
 osal/FreeRTOS/FixedTimeslotTask.h   |  2 +-
 osal/linux/FixedTimeslotTask.cpp    |  4 ++-
 osal/linux/FixedTimeslotTask.h      |  2 +-
 osal/linux/PeriodicPosixTask.cpp    |  1 +
 tasks/FixedSlotSequence.cpp         | 44 ++++++++++++++++++++---------
 tasks/FixedSlotSequence.h           |  4 ++-
 tasks/FixedTimeslotTaskIF.h         |  2 +-
 8 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index a112092f..772c4bca 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -78,8 +78,8 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
-	return pst.checkAndInitializeSequence();
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
 }
 
 void FixedTimeslotTask::taskFunctionality() {
@@ -87,6 +87,8 @@ void FixedTimeslotTask::taskFunctionality() {
     // start time for the first entry.
 	auto slotListIter = pst.current;
 
+	pst.intializeSequenceAfterTaskCreation();
+
 	//The start time for the first entry is read.
 	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 0e9611d2..42af14b8 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -54,7 +54,7 @@ public:
 
 	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkAndInitializeSequence() const override;
+	ReturnValue_t checkSequence() const override;
 
 	ReturnValue_t sleepFor(uint32_t ms) override;
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index c381bb78..99acf606 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -49,7 +49,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
@@ -58,6 +58,8 @@ void FixedTimeslotTask::taskFunctionality() {
 	if (!started) {
 		suspend();
 	}
+
+	pst.intializeSequenceAfterTaskCreation();
 	//The start time for the first entry is read.
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	uint64_t interval = pst.getIntervalToNextSlotMs();
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index f7b6e954..83bf203e 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -33,7 +33,7 @@ public:
 	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
 			int8_t executionStep);
 
-	virtual ReturnValue_t checkAndInitializeSequence() const;
+	virtual ReturnValue_t checkSequence() const;
 
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 9b6148c5..c0a29f47 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -52,6 +52,7 @@ void PeriodicPosixTask::taskFunctionality(void) {
 	if(!started){
 		suspend();
 	}
+
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	//The task's "infinite" inner loop is entered.
 	while (1) {
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index e51762ea..d803a419 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -81,13 +81,20 @@ uint32_t FixedSlotSequence::getLengthMs() const {
 	return this->lengthMs;
 }
 
-ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+        int8_t executionStep, ExecutableObjectIF* executableObject,
+        PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	std::set<ExecutableObjectIF*> uniqueObjects;
 	uint32_t count = 0;
 	uint32_t time = 0;
 	for(const auto& slot: slotList) {
@@ -106,11 +113,7 @@ ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
 		}
 		time = slot.pollingTimeMs;
-		// Ensure that each unique object is initialized once.
-		if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
-		    slot.executableObject->initializeAfterTaskCreation();
-		    uniqueObjects.emplace(slot.executableObject);
-		}
+
 	}
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
@@ -120,10 +123,25 @@ ReturnValue_t FixedSlotSequence::checkAndInitializeSequence() const {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-		int8_t executionStep, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) {
-    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
-            executionStep, executableObject, executingTask));
-   this->current = slotList.begin();
+
+ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
+    std::set<ExecutableObjectIF*> uniqueObjects;
+    uint32_t count = 0;
+    for(const auto& slot: slotList) {
+        // Ensure that each unique object is initialized once.
+        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+            ReturnValue_t result =
+                    slot.executableObject->initializeAfterTaskCreation();
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                count++;
+            }
+            uniqueObjects.emplace(slot.executableObject);
+        }
+    }
+    if (count > 0) {
+        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
+                "Counted " << count << " failed initializations!"  << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 1aa420ce..9ab84552 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -132,7 +132,9 @@ public:
 	 * creation.
 	 * @return
 	 */
-	ReturnValue_t checkAndInitializeSequence() const;
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
 protected:
 
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index d3155490..daced785 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -27,7 +27,7 @@ public:
 	 * Check whether the sequence is valid and perform all other required
 	 * initialization steps which are needed after task creation
 	 */
-	virtual ReturnValue_t checkAndInitializeSequence() const = 0;
+	virtual ReturnValue_t checkSequence() const = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

From 6d3fdab9446d0129823b16aba8cc9e71e2067006 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 15:52:55 +0200
Subject: [PATCH 0665/1292] adapted semaphore IF to mutex IF

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      | 24 ++++++++++++---------
 osal/FreeRTOS/BinSemaphUsingTask.h        |  9 ++++----
 osal/FreeRTOS/BinarySemaphore.cpp         | 19 +++++++++++------
 osal/FreeRTOS/BinarySemaphore.h           |  8 +++----
 osal/FreeRTOS/CountingSemaphUsingTask.cpp | 24 ++++++++++++---------
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 ++++--
 osal/FreeRTOS/SemaphoreFactory.cpp        |  2 --
 tasks/SemaphoreIF.h                       | 26 ++++++++++-------------
 8 files changed, 64 insertions(+), 54 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 71c0aba9..8c831bbe 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -16,19 +16,23 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
-ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
+ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+	return acquireWithTickTimeout(timeoutType, timeout);
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
-        TickType_t timeoutTicks) {
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
 	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index e6989970..2d2cf159 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -25,8 +25,8 @@ public:
 	//! @brief Default dtor
 	virtual~ BinarySemaphoreUsingTask();
 
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
@@ -39,8 +39,9 @@ public:
 	 * @return - @c RETURN_OK on success
 	 *         - @c RETURN_FAILED on failure
 	 */
-	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::BLOCKING);
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8e15b7a5..f1c78473 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -35,18 +35,23 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-	    timeout = SemaphoreIF::BLOCKING;
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+	    timeout = 0;
 	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
-	return acquireWithTickTimeout(timeout);
+	else {
+	    timeout = portMAX_DELAY;
+	}
+	return acquireWithTickTimeout(timeoutType, timeout);
 }
 
-ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TickType_t timeoutTicks) {
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TimeoutType timeoutType,
+        TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 4cf270de..5a32088a 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -52,8 +52,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs =
-			SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = portMAX_DELAY) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -61,8 +61,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-			SemaphoreIF::BLOCKING);
+	ReturnValue_t  acquireWithTickTimeout(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 333865c8..e66671ac 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -37,20 +37,24 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
-ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::BLOCKING;
-	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	return acquireWithTickTimeout(timeout);
+ReturnValue_t CountingSemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+    return acquireWithTickTimeout(timeoutType, timeout);
 
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
-		TickType_t timeoutTicks) {
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
 	// Decrement notfication value without resetting it.
 	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
 	if (getSemaphoreCounter() == oldCount - 1) {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 801e3430..e3733382 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -31,7 +31,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +62,8 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+			TickType_t timeoutTicks = portMAX_DELAY);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 453f2226..8575cf4a 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,8 +6,6 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 3fed4511..30d4ed88 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -20,21 +20,16 @@
  */
 class SemaphoreIF {
 public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
 	virtual~ SemaphoreIF() {};
-	/**
-	 * @brief 	Timeout value used for polling lock attempt.
-	 * @details
-	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
-	 * immediately. Value needs to be defined in implementation.
-	 */
-	static const uint32_t POLLING;
-	/**
-	 * @brief 	Timeout value used for permanent blocking lock attempt.
-	 * @details
-	 * The task will be blocked (indefinitely) until the mutex is unlocked.
-	 * Value needs to be defined in implementation.
-	 */
-	static const uint32_t BLOCKING;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
@@ -52,7 +47,8 @@ public:
 	 * @param timeoutMs
 	 * @return - c RETURN_OK for successfull acquisition
 	 */
-	virtual ReturnValue_t acquire(uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
 
 	/**
 	 * Corrensponding call to release a semaphore.

From fd42d8cd46bdefece3002e15e585fa18578f1372 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 16:14:42 +0200
Subject: [PATCH 0666/1292] periodic task taken over from master

---
 osal/FreeRTOS/PeriodicTask.cpp | 286 ++++++++++++++++-----------------
 osal/FreeRTOS/PeriodicTask.h   | 254 +++++++++++++++--------------
 2 files changed, 269 insertions(+), 271 deletions(-)

diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index f99e8a4e..990d38d6 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -1,143 +1,143 @@
-#include "PeriodicTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		TaskDeadlineMissedFunction deadlineMissedFunc) :
-		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
-		deadlineMissedFunc)
-{
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	BaseType_t status = xTaskCreate(taskEntryPoint, name,
-			stackSize, this, setPriority, &handle);
-	if(status != pdPASS){
-		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
-		        "Status: " << status << std::endl;
-	}
-
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	// The argument is re-interpreted as PeriodicTask. The Task object is
-    // global, so it is found from any place.
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicTask::taskFunctionality() {
-	TickType_t xLastWakeTime;
-	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
-
-	for (auto const& object: objectList) {
-	    object->initializeAfterTaskCreation();
-	}
-
-	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to
-	 explicitly. After this assignment, xLastWakeTime is updated automatically
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		for (auto const& object: objectList) {
-			object->performOperation();
-		}
-
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implement ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-TaskHandle_t PeriodicTask::getTaskHandle() {
-    return handle;
-}
-
-void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
+#include "PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		TaskDeadlineMissedFunction deadlineMissedFunc) :
+		started(false), handle(NULL), period(setPeriod), deadlineMissedFunc(
+		deadlineMissedFunc)
+{
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	BaseType_t status = xTaskCreate(taskEntryPoint, name,
+			stackSize, this, setPriority, &handle);
+	if(status != pdPASS){
+		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
+		        "Status: " << status << std::endl;
+	}
+
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	// The argument is re-interpreted as PeriodicTask. The Task object is
+    // global, so it is found from any place.
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	TickType_t xLastWakeTime;
+	const TickType_t xPeriod = pdMS_TO_TICKS(this->period * 1000.);
+	
+	for (auto const &object: objectList) {
+		object->initializeAfterTaskCreation();
+	}
+
+	/* The xLastWakeTime variable needs to be initialized with the current tick
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		for (auto const& object: objectList) {
+			object->performOperation();
+		}
+
+		checkMissedDeadline(xLastWakeTime, xPeriod);
+
+		vTaskDelayUntil(&xLastWakeTime, xPeriod);
+
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implement ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+TaskHandle_t PeriodicTask::getTaskHandle() {
+    return handle;
+}
+
+void PeriodicTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 1cdc3df7..87b8b6d2 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -1,128 +1,126 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
-
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @ingroup task_handling
- */
-class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
-public:
-	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * TODO: why does this need to be called before vTaskStartScheduler?
-	 * @details
-	 * The class is initialized without allocated objects.
-	 * These need to be added with #addComponent.
-	 * @param priority
-	 * Sets the priority of a task. Values depend on freeRTOS configuration,
-	 * high number means high priority.
-	 * @param stack_size
-	 * The stack size reserved by the operating system for the task.
-	 * @param setPeriod
-	 * The length of the period with which the task's
-	 * functionality will be executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall
-	 * be assigned.
-	 */
-	PeriodicTask(TaskName name, TaskPriority setPriority,
-	        TaskStackSize setStack, TaskPeriod setPeriod,
-	        TaskDeadlineMissedFunction deadlineMissedFunc);
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with
-	 * 			the task object's lifetime, so the destructor is empty.
-	 */
-	virtual ~PeriodicTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask() override;
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return
-	 * -@c RETURN_OK on success
-	 * -@c RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	//! Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details
-	 * The period determines the frequency of the task's execution.
-	 * It is expressed in clock ticks.
-	 */
-	TaskPeriod period;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details
-	 * This pointer stores the function that is executed if the task's deadline
-	 * is missed so each may react individually on a timing failure.
-	 * The pointer may be NULL, then nothing happens on missing the deadline.
-	 * The deadline is equal to the next execution of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details
-	 * It converts the argument back to the thread object type and copies the
-	 * class instance to the task context. The taskFunctionality method is
-	 * called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-
-	static void taskEntryPoint(void* argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details
-	 * The method sets and starts the task's period, then enters a loop that is
-	 * repeated as long as the isRunning attribute is true. Within the loop,
-	 * all performOperation methods of the added objects are called.
-	 * Afterwards the checkAndRestartPeriod system call blocks the task until
-	 * the next period.
-	 * On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* PERIODICTASK_H_ */
+#ifndef FSFW_OSAL_FREERTOS_PERIODICTASK_H_
+#define FSFW_OSAL_FREERTOS_PERIODICTASK_H_
+
+#include "FreeRTOSTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF, public FreeRTOSTaskIF {
+public:
+	/**
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @details
+	 * The class is initialized without allocated objects.
+	 * These need to be added with #addComponent.
+	 * @param priority
+	 * Sets the priority of a task. Values depend on freeRTOS configuration,
+	 * high number means high priority.
+	 * @param stack_size
+	 * The stack size reserved by the operating system for the task.
+	 * @param setPeriod
+	 * The length of the period with which the task's
+	 * functionality will be executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall
+	 * be assigned.
+	 */
+	PeriodicTask(TaskName name, TaskPriority setPriority,
+	        TaskStackSize setStack, TaskPeriod setPeriod,
+	        TaskDeadlineMissedFunction deadlineMissedFunc);
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask() override;
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 * -@c RETURN_OK on success
+	 * -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	//! Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed so each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context. The taskFunctionality method is
+	 * called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	static void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called.
+	 * Afterwards the checkAndRestartPeriod system call blocks the task until
+	 * the next period.
+	 * On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* FSFW_OSAL_FREERTOS_PERIODICTASK_H_ */

From 5aa664648e8e0d102e29a68c42fac9b16c5ecbb9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:03:54 +0200
Subject: [PATCH 0667/1292] linux semaph update

---
 osal/linux/BinarySemaphore.cpp   | 9 +++++----
 osal/linux/BinarySemaphore.h     | 4 ++--
 osal/linux/FixedTimeslotTask.cpp | 7 +++++--
 osal/linux/SemaphoreFactory.cpp  | 3 ---
 4 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 37947b26..5216ff37 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -25,15 +25,16 @@ BinarySemaphore& BinarySemaphore::operator =(
 	return * this;
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+		 uint32_t timeoutMs) {
 	int result = 0;
-	if(timeoutMs == SemaphoreIF::POLLING) {
+	if(timeoutType == TimeoutType::POLLING) {
 		result = sem_trywait(&handle);
 	}
-	else if(timeoutMs == SemaphoreIF::BLOCKING) {
+	else if(timeoutType == TimeoutType::BLOCKING) {
 	    result = sem_wait(&handle);
 	}
-	else if(timeoutMs > SemaphoreIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 9ac9ba7f..4181de85 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -49,8 +49,8 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::BLOCKING) override;
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+			uint32_t timeoutMs = 0) override;
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 99acf606..12db83b1 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -39,8 +39,11 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	ExecutableObjectIF* executableObject =
+			objectManager->get<ExecutableObjectIF>(componentId);
+	if (executableObject != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep,
+				executableObject,this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 43b1978d..805865ca 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -3,9 +3,6 @@
 #include "../../osal/linux/CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
-
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
 SemaphoreFactory::SemaphoreFactory() {

From b9314cffb955b95234a7c82e1a847c9533fee57a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:13:52 +0200
Subject: [PATCH 0668/1292] small improvements

---
 osal/linux/SemaphoreFactory.cpp | 4 ++--
 tasks/SemaphoreFactory.h        | 7 ++++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index 805865ca..bcb5d16f 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,6 +1,6 @@
 #include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
+#include "BinarySemaphore.h"
+#include "CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index b2f34788..2c41a135 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
-#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
+#define FSFW_TASKS_SEMAPHOREFACTORY_H_
+
 #include "../tasks/SemaphoreIF.h"
 
 /**
@@ -46,4 +47,4 @@ private:
 	static SemaphoreFactory* factoryInstance;
 };
 
-#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */
+#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */

From 4d1b1ba50662984bd90af489dfa811d8165be6fb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 17:24:40 +0200
Subject: [PATCH 0669/1292] additonal doc for freeRTOS semaphores

---
 osal/FreeRTOS/BinSemaphUsingTask.h      | 3 +++
 osal/FreeRTOS/CountingSemaphUsingTask.h | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 2d2cf159..0b30c094 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -14,6 +14,9 @@
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
+ * This semaphore is bound to the task it is created in!
+ * Take care of calling this function with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function).
  */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index e3733382..d3b23ebe 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -16,6 +16,9 @@ extern "C" {
  * @details
  *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
  *  and general semaphore documentation.
+ *  This semaphore is bound to the task it is created in!
+ *  Take care of calling this function with the correct executing task,
+ *  (for example in the initializeAfterTaskCreation() function).
  */
 class CountingSemaphoreUsingTask: public SemaphoreIF {
 public:

From a6e99e443aaa483b705d8b5570d30ef2a524ec9e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:00:36 +0200
Subject: [PATCH 0670/1292] took over dHB failure isolation base fixes

---
 .../DeviceHandlerFailureIsolation.cpp         | 502 +++++++++---------
 .../DeviceHandlerFailureIsolation.h           | 107 ++--
 2 files changed, 304 insertions(+), 305 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 54788600..8831f9ae 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,251 +1,251 @@
-#include "../devicehandlers/DeviceHandlerBase.h"
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-#include "../health/HealthTableIF.h"
-#include "../power/Fuse.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../thermal/ThermalComponentIF.h"
-
-object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0;
-
-DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
-		object_id_t parent) :
-		FailureIsolationBase(owner, parent),
-		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
-				parameterDomainBase++),
-		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
-				parameterDomainBase++),
-		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
-		fdirState(NONE), powerConfirmation(0) {
-}
-
-DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
-	if(isFdirInActionOrAreWeFaulty(event)) {
-		return RETURN_OK;
-	}
-	ReturnValue_t result = RETURN_FAILED;
-	switch (event->getEvent()) {
-	case HasModesIF::MODE_TRANSITION_FAILED:
-	case HasModesIF::OBJECT_IN_INVALID_MODE:
-		//We'll try a recovery as long as defined in MAX_REBOOT.
-		//Might cause some AssemblyBase cycles, so keep number low.
-		handleRecovery(event->getEvent());
-		break;
-	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
-	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
-	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
-		//These faults all mean that there were stupid replies from a device.
-		if (strangeReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-		//The two above should never be confirmed.
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		result = sendConfirmationRequest(event);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-		//else
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case StorageManagerIF::GET_DATA_FAILED:
-	case StorageManagerIF::STORE_DATA_FAILED:
-		//Rather strange bugs, occur in RAW mode only. Ignore.
-		break;
-	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
-		//Ignore, is bad configuration. We can't do anything in flight.
-		break;
-	case HasHealthIF::HEALTH_INFO:
-	case HasModesIF::MODE_INFO:
-	case HasModesIF::CHANGING_MODE:
-		//Do nothing, but mark as handled.
-		break;
-		//****Power*****
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		if(hasPowerConfirmation) {
-			result = sendConfirmationRequest(event, powerConfirmation);
-			if (result == RETURN_OK) {
-				setFdirState(DEVICE_MIGHT_BE_OFF);
-			}
-		}
-		break;
-	case Fuse::FUSE_WENT_OFF:
-		//Not so good, because PCDU reacted.
-	case Fuse::POWER_ABOVE_HIGH_LIMIT:
-		//Better, because software detected over-current.
-		setFaulty(event->getEvent());
-		break;
-	case Fuse::POWER_BELOW_LOW_LIMIT:
-		//Device might got stuck during boot, retry.
-		handleRecovery(event->getEvent());
-		break;
-		//****Thermal*****
-	case ThermalComponentIF::COMPONENT_TEMP_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
-	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
-		//Well, the device is not really faulty, but it is required to stay off as long as possible.
-		setFaulty(event->getEvent());
-		break;
-	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
-		//Ignore, is information only.
-		break;
-		//*******Default monitoring variables. Are currently not used.*****
-//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
-//		setFaulty(event->getEvent());
-//		break;
-//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
-//		break;
-	default:
-		//We don't know the event, someone else should handle it.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
-	switch (event->getEvent()) {
-	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
-	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
-	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
-		if (missedReplyCount.incrementAndCheck()) {
-			handleRecovery(event->getEvent());
-		}
-		break;
-	case PowerSwitchIF::SWITCH_WENT_OFF:
-		//This means the switch went off only for one device.
-		handleRecovery(event->getEvent());
-		break;
-	default:
-		break;
-	}
-}
-
-void DeviceHandlerFailureIsolation::decrementFaultCounters() {
-	strangeReplyCount.checkForDecrement();
-	missedReplyCount.checkForDecrement();
-	recoveryCounter.checkForDecrement();
-}
-
-void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
-	clearFaultCounters();
-	if (not recoveryCounter.incrementAndCheck()) {
-		startRecovery(reason);
-	} else {
-		setFaulty(reason);
-	}
-}
-
-void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
-	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
-	//This means, no fault message will come through until a MODE_ or
-	//HEALTH_INFO message comes through -> Is that ok?
-	//Same issue in TxFailureIsolation!
-//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
-//			&& (fdirState != RECOVERY_ONGOING)) {
-//		setFdirState(NONE);
-//	}
-}
-
-void DeviceHandlerFailureIsolation::clearFaultCounters() {
-	strangeReplyCount.clear();
-	missedReplyCount.clear();
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
-	ReturnValue_t result = FailureIsolationBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
-				" initialize FailureIsolationBase." << std::endl;
-		return result;
-	}
-	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
-			powerConfirmationId);
-	if (power != nullptr) {
-		powerConfirmation = power->getEventReceptionQueue();
-		hasPowerConfirmation = true;
-	}
-
-	return RETURN_OK;
-}
-
-void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
-	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
-	fdirState = state;
-}
-
-void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//Do not throw error events if fdirState != none.
-	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
-		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
-	}
-}
-
-bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
-	return (fdirState != NONE);
-}
-
-void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
-	setFdirState(RECOVERY_ONGOING);
-}
-
-ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = missedReplyCount.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = recoveryCounter.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	return INVALID_DOMAIN_ID;
-}
-
-void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
-	setOwnerHealth(HasHealthIF::FAULTY);
-	setFdirState(AWAIT_SHUTDOWN);
-}
-
-bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
-		EventMessage* event) {
-	if (fdirState != NONE) {
-		//Only wait for those events, ignore all others.
-		if (event->getParameter1() == HasHealthIF::HEALTHY
-				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
-			setFdirState(NONE);
-		}
-		if (event->getEvent() == HasModesIF::MODE_INFO
-				&& fdirState != RECOVERY_ONGOING) {
-			setFdirState(NONE);
-		}
-		return true;
-	}
-	if (owner->getHealth() == HasHealthIF::FAULTY
-			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
-		//Ignore all events in case device is already faulty.
-		return true;
-	}
-	return false;
-}
+#include "DeviceHandlerBase.h"
+#include "DeviceHandlerFailureIsolation.h"
+#include "../health/HealthTableIF.h"
+#include "../power/Fuse.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../thermal/ThermalComponentIF.h"
+
+object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
+        objects::NO_OBJECT;
+
+DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
+		object_id_t parent) :
+		FailureIsolationBase(owner, parent),
+		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
+				parameterDomainBase++),
+		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
+				parameterDomainBase++),
+		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
+		fdirState(NONE), powerConfirmation(0) {
+}
+
+DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event) {
+	if(isFdirInActionOrAreWeFaulty(event)) {
+		return RETURN_OK;
+	}
+	ReturnValue_t result = RETURN_FAILED;
+	switch (event->getEvent()) {
+	case HasModesIF::MODE_TRANSITION_FAILED:
+	case HasModesIF::OBJECT_IN_INVALID_MODE:
+		//We'll try a recovery as long as defined in MAX_REBOOT.
+		//Might cause some AssemblyBase cycles, so keep number low.
+		handleRecovery(event->getEvent());
+		break;
+	case DeviceHandlerIF::DEVICE_INTERPRETING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_READING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_UNREQUESTED_REPLY:
+	case DeviceHandlerIF::DEVICE_UNKNOWN_REPLY: //Some DH's generate generic reply-ids.
+	case DeviceHandlerIF::DEVICE_BUILDING_COMMAND_FAILED:
+		//These faults all mean that there were stupid replies from a device.
+		if (strangeReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+		//The two above should never be confirmed.
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		result = sendConfirmationRequest(event);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			break;
+		}
+		//else
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case StorageManagerIF::GET_DATA_FAILED:
+	case StorageManagerIF::STORE_DATA_FAILED:
+		//Rather strange bugs, occur in RAW mode only. Ignore.
+		break;
+	case DeviceHandlerIF::INVALID_DEVICE_COMMAND:
+		//Ignore, is bad configuration. We can't do anything in flight.
+		break;
+	case HasHealthIF::HEALTH_INFO:
+	case HasModesIF::MODE_INFO:
+	case HasModesIF::CHANGING_MODE:
+		//Do nothing, but mark as handled.
+		break;
+		//****Power*****
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		if(powerConfirmation != MessageQueueIF::NO_QUEUE) {
+			result = sendConfirmationRequest(event, powerConfirmation);
+			if (result == RETURN_OK) {
+				setFdirState(DEVICE_MIGHT_BE_OFF);
+			}
+		}
+		break;
+	case Fuse::FUSE_WENT_OFF:
+		//Not so good, because PCDU reacted.
+	case Fuse::POWER_ABOVE_HIGH_LIMIT:
+		//Better, because software detected over-current.
+		setFaulty(event->getEvent());
+		break;
+	case Fuse::POWER_BELOW_LOW_LIMIT:
+		//Device might got stuck during boot, retry.
+		handleRecovery(event->getEvent());
+		break;
+		//****Thermal*****
+	case ThermalComponentIF::COMPONENT_TEMP_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_HIGH:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_LOW:
+	case ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH:
+		//Well, the device is not really faulty, but it is required to stay off as long as possible.
+		setFaulty(event->getEvent());
+		break;
+	case ThermalComponentIF::TEMP_NOT_IN_OP_RANGE:
+		//Ignore, is information only.
+		break;
+		//*******Default monitoring variables. Are currently not used.*****
+//	case DeviceHandlerIF::MONITORING_LIMIT_EXCEEDED:
+//		setFaulty(event->getEvent());
+//		break;
+//	case DeviceHandlerIF::MONITORING_AMBIGUOUS:
+//		break;
+	default:
+		//We don't know the event, someone else should handle it.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::eventConfirmed(EventMessage* event) {
+	switch (event->getEvent()) {
+	case DeviceHandlerIF::DEVICE_SENDING_COMMAND_FAILED:
+	case DeviceHandlerIF::DEVICE_REQUESTING_REPLY_FAILED:
+	case DeviceHandlerIF::DEVICE_MISSED_REPLY:
+		if (missedReplyCount.incrementAndCheck()) {
+			handleRecovery(event->getEvent());
+		}
+		break;
+	case PowerSwitchIF::SWITCH_WENT_OFF:
+		//This means the switch went off only for one device.
+		handleRecovery(event->getEvent());
+		break;
+	default:
+		break;
+	}
+}
+
+void DeviceHandlerFailureIsolation::decrementFaultCounters() {
+	strangeReplyCount.checkForDecrement();
+	missedReplyCount.checkForDecrement();
+	recoveryCounter.checkForDecrement();
+}
+
+void DeviceHandlerFailureIsolation::handleRecovery(Event reason) {
+	clearFaultCounters();
+	if (not recoveryCounter.incrementAndCheck()) {
+		startRecovery(reason);
+	} else {
+		setFaulty(reason);
+	}
+}
+
+void DeviceHandlerFailureIsolation::wasParentsFault(EventMessage* event) {
+	//We'll better ignore the SWITCH_WENT_OFF event and await a system-wide reset.
+	//This means, no fault message will come through until a MODE_ or
+	//HEALTH_INFO message comes through -> Is that ok?
+	//Same issue in TxFailureIsolation!
+//	if ((event->getEvent() == PowerSwitchIF::SWITCH_WENT_OFF)
+//			&& (fdirState != RECOVERY_ONGOING)) {
+//		setFdirState(NONE);
+//	}
+}
+
+void DeviceHandlerFailureIsolation::clearFaultCounters() {
+	strangeReplyCount.clear();
+	missedReplyCount.clear();
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
+	ReturnValue_t result = FailureIsolationBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
+				" initialize FailureIsolationBase." << std::endl;
+		return result;
+	}
+	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
+			powerConfirmationId);
+	if (power != nullptr) {
+		powerConfirmation = power->getEventReceptionQueue();
+	}
+
+	return RETURN_OK;
+}
+
+void DeviceHandlerFailureIsolation::setFdirState(FDIRState state) {
+	FailureIsolationBase::throwFdirEvent(FDIR_CHANGED_STATE, state, fdirState);
+	fdirState = state;
+}
+
+void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//Do not throw error events if fdirState != none.
+	//This will still forward MODE and HEALTH INFO events in any case.
+	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
+	}
+}
+
+bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
+	return (fdirState != NONE);
+}
+
+void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
+	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
+	setFdirState(RECOVERY_ONGOING);
+}
+
+ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	ReturnValue_t result = strangeReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = missedReplyCount.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = recoveryCounter.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	return INVALID_DOMAIN_ID;
+}
+
+void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	setOwnerHealth(HasHealthIF::FAULTY);
+	setFdirState(AWAIT_SHUTDOWN);
+}
+
+bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
+		EventMessage* event) {
+	if (fdirState != NONE) {
+		//Only wait for those events, ignore all others.
+		if (event->getParameter1() == HasHealthIF::HEALTHY
+				&& event->getEvent() == HasHealthIF::HEALTH_INFO) {
+			setFdirState(NONE);
+		}
+		if (event->getEvent() == HasModesIF::MODE_INFO
+				&& fdirState != RECOVERY_ONGOING) {
+			setFdirState(NONE);
+		}
+		return true;
+	}
+	if (owner->getHealth() == HasHealthIF::FAULTY
+			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
+		//Ignore all events in case device is already faulty.
+		return true;
+	}
+	return false;
+}
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 25247a8d..6ed53efd 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,54 +1,53 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-
-#include "../fdir/FaultCounter.h"
-#include "../fdir/FailureIsolationBase.h"
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-
-class DeviceHandlerFailureIsolation: public FailureIsolationBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	friend class Heater;
-public:
-	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
-	~DeviceHandlerFailureIsolation();
-	ReturnValue_t initialize();
-	void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);bool isFdirActionInProgress();
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-protected:
-	FaultCounter strangeReplyCount;
-	FaultCounter missedReplyCount;
-	FaultCounter recoveryCounter;
-	enum FDIRState {
-		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
-	};
-	FDIRState fdirState;
-	bool hasPowerConfirmation = false;
-	MessageQueueId_t powerConfirmation;
-	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	static const uint32_t MAX_REBOOT = 1;
-	static const uint32_t REBOOT_TIME_MS = 180000;
-	static const uint32_t MAX_STRANGE_REPLIES = 10;
-	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
-	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
-	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
-	virtual ReturnValue_t eventReceived(EventMessage* event);
-	virtual void eventConfirmed(EventMessage* event);
-	void wasParentsFault(EventMessage* event);
-	void decrementFaultCounters();
-	void handleRecovery(Event reason);
-	virtual void clearFaultCounters();
-	void setFdirState(FDIRState state);
-	void startRecovery(Event reason);
-	void setFaulty(Event reason);
-
-	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+
+#include "../fdir/FaultCounter.h"
+#include "../fdir/FailureIsolationBase.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class DeviceHandlerFailureIsolation: public FailureIsolationBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+	friend class Heater;
+public:
+	DeviceHandlerFailureIsolation(object_id_t owner, object_id_t parent);
+	~DeviceHandlerFailureIsolation();
+	ReturnValue_t initialize();
+	void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);bool isFdirActionInProgress();
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+protected:
+	FaultCounter strangeReplyCount;
+	FaultCounter missedReplyCount;
+	FaultCounter recoveryCounter;
+	enum FDIRState {
+		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
+	};
+	FDIRState fdirState;
+	MessageQueueId_t powerConfirmation = MessageQueueIF::NO_QUEUE;
+	static object_id_t powerConfirmationId;
+	// TODO: Are those hardcoded value? How can they be changed.
+	static const uint32_t MAX_REBOOT = 1;
+	static const uint32_t REBOOT_TIME_MS = 180000;
+	static const uint32_t MAX_STRANGE_REPLIES = 10;
+	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
+	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
+	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
+	virtual ReturnValue_t eventReceived(EventMessage* event);
+	virtual void eventConfirmed(EventMessage* event);
+	void wasParentsFault(EventMessage* event);
+	void decrementFaultCounters();
+	void handleRecovery(Event reason);
+	virtual void clearFaultCounters();
+	void setFdirState(FDIRState state);
+	void startRecovery(Event reason);
+	void setFaulty(Event reason);
+
+	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

From ed70f3861272b064fae00a6fab155ccfe67b1e93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:04:17 +0200
Subject: [PATCH 0671/1292] some renaming

---
 .../DeviceHandlerFailureIsolation.cpp         |  6 ++---
 .../DeviceHandlerFailureIsolation.h           | 24 +++++++++++--------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 8831f9ae..2ca2df2a 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -11,11 +11,11 @@ object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
 DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
 		object_id_t parent) :
 		FailureIsolationBase(owner, parent),
-		strangeReplyCount(MAX_STRANGE_REPLIES, STRANGE_REPLIES_TIME_MS,
+		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES, DEFAULT_STRANGE_REPLIES_TIME_MS,
 				parameterDomainBase++),
-		missedReplyCount( MAX_MISSED_REPLY_COUNT, MISSED_REPLY_TIME_MS,
+		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT, DEFAULT_MISSED_REPLY_TIME_MS,
 				parameterDomainBase++),
-		recoveryCounter(MAX_REBOOT, REBOOT_TIME_MS, parameterDomainBase++),
+		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS, parameterDomainBase++),
 		fdirState(NONE), powerConfirmation(0) {
 }
 
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h
index 6ed53efd..8a3fd9dd 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.h
+++ b/devicehandlers/DeviceHandlerFailureIsolation.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_
 
 #include "../fdir/FaultCounter.h"
 #include "../fdir/FailureIsolationBase.h"
@@ -20,23 +20,27 @@ public:
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
 protected:
 	FaultCounter strangeReplyCount;
 	FaultCounter missedReplyCount;
 	FaultCounter recoveryCounter;
+
 	enum FDIRState {
 		NONE, RECOVERY_ONGOING, DEVICE_MIGHT_BE_OFF, AWAIT_SHUTDOWN
 	};
 	FDIRState fdirState;
+
 	MessageQueueId_t powerConfirmation = MessageQueueIF::NO_QUEUE;
 	static object_id_t powerConfirmationId;
-	// TODO: Are those hardcoded value? How can they be changed.
-	static const uint32_t MAX_REBOOT = 1;
-	static const uint32_t REBOOT_TIME_MS = 180000;
-	static const uint32_t MAX_STRANGE_REPLIES = 10;
-	static const uint32_t STRANGE_REPLIES_TIME_MS = 10000;
-	static const uint32_t MAX_MISSED_REPLY_COUNT = 5;
-	static const uint32_t MISSED_REPLY_TIME_MS = 10000;
+
+	static const uint32_t DEFAULT_MAX_REBOOT = 1;
+	static const uint32_t DEFAULT_REBOOT_TIME_MS = 180000;
+	static const uint32_t DEFAULT_MAX_STRANGE_REPLIES = 10;
+	static const uint32_t DEFAULT_STRANGE_REPLIES_TIME_MS = 10000;
+	static const uint32_t DEFAULT_MAX_MISSED_REPLY_COUNT = 5;
+	static const uint32_t DEFAULT_MISSED_REPLY_TIME_MS = 10000;
+
 	virtual ReturnValue_t eventReceived(EventMessage* event);
 	virtual void eventConfirmed(EventMessage* event);
 	void wasParentsFault(EventMessage* event);
@@ -50,4 +54,4 @@ protected:
 	bool isFdirInActionOrAreWeFaulty(EventMessage* event);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ */

From 42dd665e2649b8e37a27862640f1f73c1147c627 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 27 Aug 2020 20:06:19 +0200
Subject: [PATCH 0672/1292] include improvement

---
 devicehandlers/DeviceHandlerFailureIsolation.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 2ca2df2a..9fbe71d8 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -1,5 +1,7 @@
-#include "DeviceHandlerBase.h"
 #include "DeviceHandlerFailureIsolation.h"
+
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../modes/HasModesIF.h"
 #include "../health/HealthTableIF.h"
 #include "../power/Fuse.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -11,12 +13,15 @@ object_id_t DeviceHandlerFailureIsolation::powerConfirmationId =
 DeviceHandlerFailureIsolation::DeviceHandlerFailureIsolation(object_id_t owner,
 		object_id_t parent) :
 		FailureIsolationBase(owner, parent),
-		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES, DEFAULT_STRANGE_REPLIES_TIME_MS,
+		strangeReplyCount(DEFAULT_MAX_STRANGE_REPLIES,
+		        DEFAULT_STRANGE_REPLIES_TIME_MS,
 				parameterDomainBase++),
-		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT, DEFAULT_MISSED_REPLY_TIME_MS,
+		missedReplyCount( DEFAULT_MAX_MISSED_REPLY_COUNT,
+		        DEFAULT_MISSED_REPLY_TIME_MS,
 				parameterDomainBase++),
-		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS, parameterDomainBase++),
-		fdirState(NONE), powerConfirmation(0) {
+		recoveryCounter(DEFAULT_MAX_REBOOT, DEFAULT_REBOOT_TIME_MS,
+		        parameterDomainBase++),
+		fdirState(NONE) {
 }
 
 DeviceHandlerFailureIsolation::~DeviceHandlerFailureIsolation() {

From 5ca26a72ea2101786cdfbd6a812a2d9913809224 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:00:16 +0200
Subject: [PATCH 0673/1292] fixed some shadowing issues

---
 objectmanager/ObjectManager.cpp |    1 -
 subsystem/Subsystem.cpp         | 1320 +++++++++++++++----------------
 subsystem/Subsystem.h           |    6 +-
 timemanager/CCSDSTime.cpp       |    2 +-
 4 files changed, 662 insertions(+), 667 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 13d67559..467eed4b 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -100,7 +100,6 @@ void ObjectManager::initialize() {
 }
 
 void ObjectManager::printList() {
-	std::map<object_id_t, SystemObjectIF*>::iterator it;
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index a4869eba..400ecc83 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -1,662 +1,658 @@
-#include "../health/HealthMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../subsystem/Subsystem.h"
-#include <string>
-
-Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
-		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
-		SubsystemBase(setObjectId, parent, 0), isInTransition(false), childrenChangedHealth(
-				false), uptimeStartTable(0), currentTargetTable(), targetMode(
-				0), targetSubmode(SUBMODE_NONE), initialMode(0), currentSequenceIterator(), modeTables(
-				maxNumberOfTables), modeSequences(maxNumberOfSequences), IPCStore(
-		NULL)
-#ifdef USE_MODESTORE
-,modeStore(NULL)
-#endif
-{
-
-}
-
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
-
-ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
-		Mode_t fallbackSequence) {
-
-	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
-	//the fallback sequence will be checked when it is needed.
-	if (!existsModeSequence(fallbackSequence)) {
-		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
-	}
-
-	if (iter.value == NULL) {
-		return NO_TARGET_TABLE;
-	}
-
-	for (; iter.value != NULL; ++iter) {
-		if (!existsModeTable(iter->getTableId())) {
-			return TABLE_DOES_NOT_EXIST;
-		} else {
-			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
-			if (result != RETURN_OK) {
-				return result;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
-	if (!existsModeSequence(sequence)) {
-		return SEQUENCE_DOES_NOT_EXIST;
-	}
-	HybridIterator<ModeListEntry> iter = getSequence(sequence);
-	return checkSequence(iter, getFallbackSequence(sequence));
-}
-
-bool Subsystem::existsModeSequence(Mode_t id) {
-	return modeSequences.exists(id) == RETURN_OK;
-}
-
-bool Subsystem::existsModeTable(Mode_t id) {
-	return modeTables.exists(id) == RETURN_OK;
-}
-
-HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
-	return getTable(currentSequenceIterator->getTableId());
-}
-
-void Subsystem::performChildOperation() {
-	if (isInTransition) {
-		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
-			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
-				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
-						== RETURN_OK) {
-					setMode(targetMode, targetSubmode);
-					isInTransition = false;
-					return;
-				} else {
-					transitionFailed(TARGET_TABLE_NOT_REACHED,
-							getSequence(targetMode)->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->checkSuccess()) {
-				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
-						!= RETURN_OK) {
-					transitionFailed(TABLE_CHECK_FAILED,
-							currentSequenceIterator->getTableId());
-					return;
-				}
-			}
-			if (currentSequenceIterator->getWaitSeconds() != 0) {
-				if (uptimeStartTable == 0) {
-					Clock::getUptime(&uptimeStartTable);
-					return;
-				} else {
-					uint32_t uptimeNow;
-					Clock::getUptime(&uptimeNow);
-					if ((uptimeNow - uptimeStartTable)
-							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
-						return;
-					}
-				}
-			}
-			uptimeStartTable = 0;
-			//next Table, but only if there is one
-			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
-				executeTable(getCurrentTable(), targetSubmode);
-			}
-		}
-	} else {
-		if (childrenChangedHealth) {
-			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
-			childrenChangedHealth = false;
-			startTransition(mode, submode);
-		} else if (childrenChangedMode) {
-			if (checkStateAgainstTable(currentTargetTable, submode)
-					!= RETURN_OK) {
-				triggerEvent(CANT_KEEP_MODE, mode, submode);
-				cantKeepMode();
-			}
-		}
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
-	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
-	if (sequenceInfo->entries.islinked) {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(
-				sequenceInfo->entries.array->front(),
-				sequenceInfo->entries.array->back());
-	}
-}
-
-HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
-	EntryPointer *entry = modeTables.findValue(id);
-	if (entry->islinked) {
-		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
-	} else {
-		return HybridIterator<ModeListEntry>(entry->array->front(),
-				entry->array->back());
-	}
-}
-
-ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
-	ReturnValue_t result;
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_INFO: {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			//Ignore external control, as it has an effect only if the mode changes,
-			//which is communicated with an additional mode info event.
-			childrenChangedHealth = true;
-		}
-	}
-		break;
-	case ModeSequenceMessage::ADD_SEQUENCE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			Mode_t fallbackId;
-			size_t size = sizeRead;
-			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
-					SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
-						&sequence, &pointer, &size,
-						SerializeIF::Endianness::BIG);
-				if (result == RETURN_OK) {
-					result = addSequence(&sequence,
-							ModeSequenceMessage::getSequenceId(message),
-							fallbackId);
-				}
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-	}
-		break;
-	case ModeSequenceMessage::ADD_TABLE: {
-		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
-		const uint8_t *pointer;
-		size_t sizeRead;
-		result = IPCStore->getData(
-				ModeSequenceMessage::getStoreAddress(message), &pointer,
-				&sizeRead);
-		if (result == RETURN_OK) {
-			size_t size = sizeRead;
-			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
-					&pointer, &size, SerializeIF::Endianness::BIG);
-			if (result == RETURN_OK) {
-				result = addTable(&table,
-						ModeSequenceMessage::getSequenceId(message));
-			}
-			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-		replyToCommand(result, 0);
-
-	}
-		break;
-	case ModeSequenceMessage::DELETE_SEQUENCE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::DELETE_TABLE:
-		if (isInTransition) {
-			replyToCommand(IN_TRANSITION, 0);
-			break;
-		}
-		result = deleteTable(ModeSequenceMessage::getTableId(message));
-		replyToCommand(result, 0);
-		break;
-	case ModeSequenceMessage::LIST_SEQUENCES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
-		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
-		for (iter = modeSequences.begin(); iter != modeSequences.end();
-				++iter) {
-			sequences.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &sequences;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::LIST_TABLES: {
-		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
-		FixedMap<Mode_t, EntryPointer>::Iterator iter;
-		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
-			tables.insert(iter.value->first);
-		}
-		SerializeIF *pointer = &tables;
-		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
-				&pointer, 1);
-	}
-		break;
-	case ModeSequenceMessage::READ_SEQUENCE: {
-		ReturnValue_t result;
-		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
-		SequenceInfo *sequenceInfo = NULL;
-		result = modeSequences.find(sequence, &sequenceInfo);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[3];
-		SerializeElement<Mode_t> sequenceId(sequence);
-		SerializeElement<Mode_t> fallbackSequenceId(
-				getFallbackSequence(sequence));
-
-		elements[0] = &sequenceId;
-		elements[1] = &fallbackSequenceId;
-
-		if (sequenceInfo->entries.islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					sequenceInfo->entries.firstLinkedElement, true);
-			elements[2] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					sequenceInfo->entries.array);
-
-			elements[2] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
-					elements, 3);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_TABLE: {
-		ReturnValue_t result;
-		Mode_t table = ModeSequenceMessage::getSequenceId(message);
-		EntryPointer *entry = NULL;
-		result = modeTables.find(table, &entry);
-		if (result != RETURN_OK) {
-			replyToCommand(result, 0);
-		}
-
-		SerializeIF *elements[2];
-		SerializeElement<Mode_t> tableId(table);
-
-		elements[0] = &tableId;
-
-		if (entry->islinked) {
-			SerialLinkedListAdapter<ModeListEntry> list(
-					entry->firstLinkedElement, true);
-			elements[1] = &list;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		} else {
-			SerialArrayListAdapter<ModeListEntry> serializableArray(
-					entry->array);
-			elements[1] = &serializableArray;
-			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
-					elements, 2);
-		}
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
-		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
-		commandQueue->reply(&reply);
-	}
-		break;
-	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
-		uint32_t free = modeTables.maxSize() - modeTables.size();
-		CommandMessage reply;
-		ModeSequenceMessage::setModeSequenceMessage(&reply,
-				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
-		commandQueue->reply(&reply);
-	}
-		break;
-	default:
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
-	if (status == RETURN_OK) {
-		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
-		commandQueue->reply(&reply);
-	} else {
-		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
-		commandQueue->reply(&reply);
-	}
-}
-
-ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
-		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Sequences added before are checked by initialize()
-	if (!preInit) {
-		result = checkSequence(
-				HybridIterator<ModeListEntry>(sequence->front(),
-						sequence->back()), fallbackSequence);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	SequenceInfo info;
-
-	info.fallbackSequence = fallbackSequence;
-
-	info.entries.islinked = inStore;
-	info.entries.array = sequence;
-
-	result = modeSequences.insert(id, info);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(sequence,
-				&(modeSequences.find(id)->entries.firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeSequences.erase(id);
-		}
-#else
-		modeSequences.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-
-	return result;
-
-}
-
-ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-		bool inStore, bool preInit) {
-
-	ReturnValue_t result;
-
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
-	if (!preInit) {
-		result = checkTable(
-				HybridIterator<ModeListEntry>(table->front(), table->back()));
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	EntryPointer pointer;
-
-	pointer.islinked = inStore;
-	pointer.array = table;
-
-	result = modeTables.insert(id, pointer);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (inStore) {
-#ifdef USE_MODESTORE
-		result = modeStore->storeArray(table,
-				&(modeTables.find(id)->firstLinkedElement));
-		if (result != RETURN_OK) {
-			modeTables.erase(id);
-		}
-#else
-		modeTables.erase(id);
-		return RETURN_FAILED;
-#endif
-	}
-	return result;
-}
-
-ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
-
-	if (isFallbackSequence(id)) {
-		return IS_FALLBACK_SEQUENCE;
-	}
-
-	SequenceInfo *sequenceInfo;
-	ReturnValue_t result;
-	result = modeSequences.find(id, &sequenceInfo);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!sequenceInfo->entries.islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::deleteTable(Mode_t id) {
-
-	if (isTableUsed(id)) {
-		return TABLE_IN_USE;
-	}
-
-	EntryPointer *pointer;
-	ReturnValue_t result;
-	result = modeTables.find(id, &pointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (!pointer->islinked) {
-		return ACCESS_DENIED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore->deleteList(pointer->firstLinkedElement);
-#endif
-	modeSequences.erase(id);
-	return RETURN_OK;
-}
-
-ReturnValue_t Subsystem::initialize() {
-	ReturnValue_t result = SubsystemBase::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (IPCStore == NULL) {
-		return RETURN_FAILED;
-	}
-
-#ifdef USE_MODESTORE
-	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
-
-	if (modeStore == NULL) {
-		return RETURN_FAILED;
-	}
-#endif
-
-	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
-			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
-		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
-	}
-
-	mode = initialMode;
-
-	return RETURN_OK;
-}
-
-MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
-	return SubsystemBase::getCommandQueue();
-}
-
-ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t *msToReachTheMode) {
-	//Need to accept all submodes to be able to inherit submodes
-//	if (submode != SUBMODE_NONE) {
-//		return INVALID_SUBMODE;
-//	}
-
-	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
-		return HasModesIF::IN_TRANSITION;
-	} else {
-		return checkSequence(mode);
-	}
-}
-
-void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, sequence, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, sequence, submode);
-	}
-	targetMode = sequence;
-	targetSubmode = submode;
-	isInTransition = true;
-	commandsOutstanding = 0;
-	currentSequenceIterator = getSequence(sequence);
-
-	currentTargetTable = getTable(currentSequenceIterator->getTableId());
-
-	++currentSequenceIterator;
-
-	if (currentSequenceIterator.value != NULL) {
-		executeTable(getCurrentTable(), targetSubmode);
-	}
-}
-
-Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); ++iter) {
-		if (iter.value->first == sequence) {
-			return iter->fallbackSequence;
-		}
-	}
-	return -1;
-}
-
-bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool Subsystem::isTableUsed(Mode_t tableId) {
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
-			modeSequences.begin(); sequence != modeSequences.end();
-			sequence++) {
-		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
-				sequence.value->first);
-		while (sequenceIterator.value != NULL) {
-			if (sequenceIterator->getTableId() == tableId) {
-				return true;
-			}
-			++sequenceIterator;
-		}
-	}
-	return false;
-}
-
-void Subsystem::transitionFailed(ReturnValue_t failureCode,
-		uint32_t parameter) {
-	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
-	if (mode == targetMode) {
-		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
-		modeHelper.setForced(true);
-		ReturnValue_t result;
-		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
-			return;
-		}
-		mode = getFallbackSequence(mode);
-		startTransition(mode, submode);
-	} else {
-		//try to go back to the current mode
-		startTransition(mode, submode);
-	}
-}
-
-void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
-		SerializeIF **elements, uint8_t count) {
-	ReturnValue_t result;
-	size_t maxSize = 0;
-	for (uint8_t i = 0; i < count; i++) {
-		maxSize += elements[i]->getSerializedSize();
-	}
-	uint8_t *storeBuffer;
-	store_address_t address;
-	size_t size = 0;
-
-	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		replyToCommand(result, 0);
-		return;
-	}
-	for (uint8_t i = 0; i < count; i++) {
-		elements[i]->serialize(&storeBuffer, &size, maxSize,
-				SerializeIF::Endianness::BIG);
-	}
-	CommandMessage reply;
-	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
-	if (commandQueue->reply(&reply) != RETURN_OK) {
-		IPCStore->deleteData(address);
-	}
-}
-
-ReturnValue_t Subsystem::checkObjectConnections() {
-	ReturnValue_t result = RETURN_OK;
-	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
-			iter != modeSequences.end(); iter++) {
-		result = checkSequence(iter.value->first);
-		if (result != RETURN_OK) {
-			return result;
-		}
-
-	}
-	return RETURN_OK;
-}
-
-void Subsystem::setInitialMode(Mode_t mode) {
-	initialMode = mode;
-}
-
-void Subsystem::cantKeepMode() {
-	ReturnValue_t result;
-	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
-		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-		return;
-	}
-
-	modeHelper.setForced(true);
-
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
-	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
-	startTransition(mode, SUBMODE_NONE);
-}
+#include "Subsystem.h"
+#include "../health/HealthMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+
+#include <string>
+
+Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
+		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
+		SubsystemBase(setObjectId, parent, 0), isInTransition(false),
+		childrenChangedHealth(false), currentTargetTable(),
+		targetMode(0), targetSubmode(SUBMODE_NONE), initialMode(0),
+		currentSequenceIterator(), modeTables(maxNumberOfTables),
+		modeSequences(maxNumberOfSequences) {}
+
+Subsystem::~Subsystem() {
+	//Auto-generated destructor stub
+}
+
+ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
+		Mode_t fallbackSequence) {
+
+	//only check for existence, checking the fallback would lead to a (possibly infinite) recursion.
+	//the fallback sequence will be checked when it is needed.
+	if (!existsModeSequence(fallbackSequence)) {
+		return FALLBACK_SEQUENCE_DOES_NOT_EXIST;
+	}
+
+	if (iter.value == NULL) {
+		return NO_TARGET_TABLE;
+	}
+
+	for (; iter.value != NULL; ++iter) {
+		if (!existsModeTable(iter->getTableId())) {
+			return TABLE_DOES_NOT_EXIST;
+		} else {
+			ReturnValue_t result = checkTable(getTable(iter->getTableId()));
+			if (result != RETURN_OK) {
+				return result;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::checkSequence(Mode_t sequence) {
+	if (!existsModeSequence(sequence)) {
+		return SEQUENCE_DOES_NOT_EXIST;
+	}
+	HybridIterator<ModeListEntry> iter = getSequence(sequence);
+	return checkSequence(iter, getFallbackSequence(sequence));
+}
+
+bool Subsystem::existsModeSequence(Mode_t id) {
+	return modeSequences.exists(id) == RETURN_OK;
+}
+
+bool Subsystem::existsModeTable(Mode_t id) {
+	return modeTables.exists(id) == RETURN_OK;
+}
+
+HybridIterator<ModeListEntry> Subsystem::getCurrentTable() {
+	return getTable(currentSequenceIterator->getTableId());
+}
+
+void Subsystem::performChildOperation() {
+	if (isInTransition) {
+		if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
+			if (currentSequenceIterator.value == NULL) { //we're through with this sequence
+				if (checkStateAgainstTable(currentTargetTable, targetSubmode)
+						== RETURN_OK) {
+					setMode(targetMode, targetSubmode);
+					isInTransition = false;
+					return;
+				} else {
+					transitionFailed(TARGET_TABLE_NOT_REACHED,
+							getSequence(targetMode)->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->checkSuccess()) {
+				if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
+						!= RETURN_OK) {
+					transitionFailed(TABLE_CHECK_FAILED,
+							currentSequenceIterator->getTableId());
+					return;
+				}
+			}
+			if (currentSequenceIterator->getWaitSeconds() != 0) {
+				if (uptimeStartTable == 0) {
+					Clock::getUptime(&uptimeStartTable);
+					return;
+				} else {
+					uint32_t uptimeNow;
+					Clock::getUptime(&uptimeNow);
+					if ((uptimeNow - uptimeStartTable)
+							< (currentSequenceIterator->getWaitSeconds() * 1000)) {
+						return;
+					}
+				}
+			}
+			uptimeStartTable = 0;
+			//next Table, but only if there is one
+			if ((++currentSequenceIterator).value != NULL) { //we're through with this sequence
+				executeTable(getCurrentTable(), targetSubmode);
+			}
+		}
+	} else {
+		if (childrenChangedHealth) {
+			triggerEvent(CHILD_CHANGED_HEALTH, 0, 0);
+			childrenChangedHealth = false;
+			startTransition(mode, submode);
+		} else if (childrenChangedMode) {
+			if (checkStateAgainstTable(currentTargetTable, submode)
+					!= RETURN_OK) {
+				triggerEvent(CANT_KEEP_MODE, mode, submode);
+				cantKeepMode();
+			}
+		}
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getSequence(Mode_t id) {
+	SequenceInfo *sequenceInfo = modeSequences.findValue(id);
+	if (sequenceInfo->entries.islinked) {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(
+				sequenceInfo->entries.array->front(),
+				sequenceInfo->entries.array->back());
+	}
+}
+
+HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
+	EntryPointer *entry = modeTables.findValue(id);
+	if (entry->islinked) {
+		return HybridIterator<ModeListEntry>(entry->firstLinkedElement);
+	} else {
+		return HybridIterator<ModeListEntry>(entry->array->front(),
+				entry->array->back());
+	}
+}
+
+ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_INFO: {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			//Ignore external control, as it has an effect only if the mode changes,
+			//which is communicated with an additional mode info event.
+			childrenChangedHealth = true;
+		}
+	}
+		break;
+	case ModeSequenceMessage::ADD_SEQUENCE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> sequence;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		ReturnValue_t result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			Mode_t fallbackId;
+			size_t size = sizeRead;
+			result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
+					SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
+						&sequence, &pointer, &size,
+						SerializeIF::Endianness::BIG);
+				if (result == RETURN_OK) {
+					result = addSequence(&sequence,
+							ModeSequenceMessage::getSequenceId(message),
+							fallbackId);
+				}
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::ADD_TABLE: {
+		FixedArrayList<ModeListEntry, MAX_LENGTH_OF_TABLE_OR_SEQUENCE> table;
+		const uint8_t *pointer;
+		size_t sizeRead;
+		ReturnValue_t result = IPCStore->getData(
+				ModeSequenceMessage::getStoreAddress(message), &pointer,
+				&sizeRead);
+		if (result == RETURN_OK) {
+			size_t size = sizeRead;
+			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
+					&pointer, &size, SerializeIF::Endianness::BIG);
+			if (result == RETURN_OK) {
+				result = addTable(&table,
+						ModeSequenceMessage::getSequenceId(message));
+			}
+			IPCStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+		replyToCommand(result, 0);
+
+	}
+		break;
+	case ModeSequenceMessage::DELETE_SEQUENCE:{
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		ReturnValue_t result = deleteSequence(ModeSequenceMessage::getSequenceId(message));
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::DELETE_TABLE:{
+		if (isInTransition) {
+			replyToCommand(IN_TRANSITION, 0);
+			break;
+		}
+		ReturnValue_t result = deleteTable(ModeSequenceMessage::getTableId(message));
+		replyToCommand(result, 0);
+	}
+		break;
+	case ModeSequenceMessage::LIST_SEQUENCES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> sequences;
+		FixedMap<Mode_t, SequenceInfo>::Iterator iter;
+		for (iter = modeSequences.begin(); iter != modeSequences.end();
+				++iter) {
+			sequences.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &sequences;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::LIST_TABLES: {
+		SerialFixedArrayListAdapter<Mode_t, MAX_NUMBER_OF_TABLES_OR_SEQUENCES> tables;
+		FixedMap<Mode_t, EntryPointer>::Iterator iter;
+		for (iter = modeTables.begin(); iter != modeTables.end(); ++iter) {
+			tables.insert(iter.value->first);
+		}
+		SerializeIF *pointer = &tables;
+		sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE_LIST,
+				&pointer, 1);
+	}
+		break;
+	case ModeSequenceMessage::READ_SEQUENCE: {
+		ReturnValue_t result;
+		Mode_t sequence = ModeSequenceMessage::getSequenceId(message);
+		SequenceInfo *sequenceInfo = NULL;
+		result = modeSequences.find(sequence, &sequenceInfo);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[3];
+		SerializeElement<Mode_t> sequenceId(sequence);
+		SerializeElement<Mode_t> fallbackSequenceId(
+				getFallbackSequence(sequence));
+
+		elements[0] = &sequenceId;
+		elements[1] = &fallbackSequenceId;
+
+		if (sequenceInfo->entries.islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					sequenceInfo->entries.firstLinkedElement, true);
+			elements[2] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					sequenceInfo->entries.array);
+
+			elements[2] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::SEQUENCE,
+					elements, 3);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_TABLE: {
+		ReturnValue_t result;
+		Mode_t table = ModeSequenceMessage::getSequenceId(message);
+		EntryPointer *entry = NULL;
+		result = modeTables.find(table, &entry);
+		if (result != RETURN_OK) {
+			replyToCommand(result, 0);
+		}
+
+		SerializeIF *elements[2];
+		SerializeElement<Mode_t> tableId(table);
+
+		elements[0] = &tableId;
+
+		if (entry->islinked) {
+			SerialLinkedListAdapter<ModeListEntry> list(
+					entry->firstLinkedElement, true);
+			elements[1] = &list;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		} else {
+			SerialArrayListAdapter<ModeListEntry> serializableArray(
+					entry->array);
+			elements[1] = &serializableArray;
+			sendSerializablesAsCommandMessage(ModeSequenceMessage::TABLE,
+					elements, 2);
+		}
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_SEQUENCE_SLOTS: {
+		uint32_t freeSlots = modeSequences.maxSize() - modeSequences.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_SEQUENCE_SLOTS, freeSlots);
+		commandQueue->reply(&reply);
+	}
+		break;
+	case ModeSequenceMessage::READ_FREE_TABLE_SLOTS: {
+		uint32_t free = modeTables.maxSize() - modeTables.size();
+		CommandMessage reply;
+		ModeSequenceMessage::setModeSequenceMessage(&reply,
+				ModeSequenceMessage::FREE_TABLE_SLOTS, free);
+		commandQueue->reply(&reply);
+	}
+		break;
+	default:
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
+	if (status == RETURN_OK) {
+		CommandMessage reply(CommandMessage::REPLY_COMMAND_OK, 0, 0);
+		commandQueue->reply(&reply);
+	} else {
+		CommandMessage reply(CommandMessage::REPLY_REJECTED, status, 0);
+		commandQueue->reply(&reply);
+	}
+}
+
+ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
+		Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Sequences added before are checked by initialize()
+	if (!preInit) {
+		result = checkSequence(
+				HybridIterator<ModeListEntry>(sequence->front(),
+						sequence->back()), fallbackSequence);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	SequenceInfo info;
+
+	info.fallbackSequence = fallbackSequence;
+
+	info.entries.islinked = inStore;
+	info.entries.array = sequence;
+
+	result = modeSequences.insert(id, info);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(sequence,
+				&(modeSequences.find(id)->entries.firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeSequences.erase(id);
+		}
+#else
+		modeSequences.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+
+	return result;
+
+}
+
+ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+		bool inStore, bool preInit) {
+
+	ReturnValue_t result;
+
+	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Tables added before are checked by initialize()
+	if (!preInit) {
+		result = checkTable(
+				HybridIterator<ModeListEntry>(table->front(), table->back()));
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	EntryPointer pointer;
+
+	pointer.islinked = inStore;
+	pointer.array = table;
+
+	result = modeTables.insert(id, pointer);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (inStore) {
+#ifdef USE_MODESTORE
+		result = modeStore->storeArray(table,
+				&(modeTables.find(id)->firstLinkedElement));
+		if (result != RETURN_OK) {
+			modeTables.erase(id);
+		}
+#else
+		modeTables.erase(id);
+		return RETURN_FAILED;
+#endif
+	}
+	return result;
+}
+
+ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
+
+	if (isFallbackSequence(id)) {
+		return IS_FALLBACK_SEQUENCE;
+	}
+
+	SequenceInfo *sequenceInfo;
+	ReturnValue_t result;
+	result = modeSequences.find(id, &sequenceInfo);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!sequenceInfo->entries.islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::deleteTable(Mode_t id) {
+
+	if (isTableUsed(id)) {
+		return TABLE_IN_USE;
+	}
+
+	EntryPointer *pointer;
+	ReturnValue_t result;
+	result = modeTables.find(id, &pointer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (!pointer->islinked) {
+		return ACCESS_DENIED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore->deleteList(pointer->firstLinkedElement);
+#endif
+	modeSequences.erase(id);
+	return RETURN_OK;
+}
+
+ReturnValue_t Subsystem::initialize() {
+	ReturnValue_t result = SubsystemBase::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (IPCStore == NULL) {
+		return RETURN_FAILED;
+	}
+
+#ifdef USE_MODESTORE
+	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
+
+	if (modeStore == NULL) {
+		return RETURN_FAILED;
+	}
+#endif
+
+	if ((modeSequences.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)
+			|| (modeTables.maxSize() > MAX_NUMBER_OF_TABLES_OR_SEQUENCES)) {
+		return TABLE_OR_SEQUENCE_LENGTH_INVALID;
+	}
+
+	mode = initialMode;
+
+	return RETURN_OK;
+}
+
+MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
+	return SubsystemBase::getCommandQueue();
+}
+
+ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t *msToReachTheMode) {
+	//Need to accept all submodes to be able to inherit submodes
+//	if (submode != SUBMODE_NONE) {
+//		return INVALID_SUBMODE;
+//	}
+
+	if (isInTransition && (mode != getFallbackSequence(targetMode))) {
+		return HasModesIF::IN_TRANSITION;
+	} else {
+		return checkSequence(mode);
+	}
+}
+
+void Subsystem::startTransition(Mode_t sequence, Submode_t submode) {
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, sequence, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, sequence, submode);
+	}
+	targetMode = sequence;
+	targetSubmode = submode;
+	isInTransition = true;
+	commandsOutstanding = 0;
+	currentSequenceIterator = getSequence(sequence);
+
+	currentTargetTable = getTable(currentSequenceIterator->getTableId());
+
+	++currentSequenceIterator;
+
+	if (currentSequenceIterator.value != NULL) {
+		executeTable(getCurrentTable(), targetSubmode);
+	}
+}
+
+Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); ++iter) {
+		if (iter.value->first == sequence) {
+			return iter->fallbackSequence;
+		}
+	}
+	return -1;
+}
+
+bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		if (iter->fallbackSequence == SequenceId) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Subsystem::isTableUsed(Mode_t tableId) {
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator sequence =
+			modeSequences.begin(); sequence != modeSequences.end();
+			sequence++) {
+		HybridIterator<ModeListEntry> sequenceIterator = getSequence(
+				sequence.value->first);
+		while (sequenceIterator.value != NULL) {
+			if (sequenceIterator->getTableId() == tableId) {
+				return true;
+			}
+			++sequenceIterator;
+		}
+	}
+	return false;
+}
+
+void Subsystem::transitionFailed(ReturnValue_t failureCode,
+		uint32_t parameter) {
+	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
+	if (mode == targetMode) {
+		//already tried going back to the current mode
+		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		modeHelper.setForced(true);
+		ReturnValue_t result;
+		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			return;
+		}
+		mode = getFallbackSequence(mode);
+		startTransition(mode, submode);
+	} else {
+		//try to go back to the current mode
+		startTransition(mode, submode);
+	}
+}
+
+void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
+		SerializeIF **elements, uint8_t count) {
+	ReturnValue_t result;
+	size_t maxSize = 0;
+	for (uint8_t i = 0; i < count; i++) {
+		maxSize += elements[i]->getSerializedSize();
+	}
+	uint8_t *storeBuffer;
+	store_address_t address;
+	size_t size = 0;
+
+	result = IPCStore->getFreeElement(&address, maxSize, &storeBuffer);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		replyToCommand(result, 0);
+		return;
+	}
+	for (uint8_t i = 0; i < count; i++) {
+		elements[i]->serialize(&storeBuffer, &size, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	CommandMessage reply;
+	ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);
+	if (commandQueue->reply(&reply) != RETURN_OK) {
+		IPCStore->deleteData(address);
+	}
+}
+
+ReturnValue_t Subsystem::checkObjectConnections() {
+	ReturnValue_t result = RETURN_OK;
+	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
+			iter != modeSequences.end(); iter++) {
+		result = checkSequence(iter.value->first);
+		if (result != RETURN_OK) {
+			return result;
+		}
+
+	}
+	return RETURN_OK;
+}
+
+void Subsystem::setInitialMode(Mode_t mode) {
+	initialMode = mode;
+}
+
+void Subsystem::cantKeepMode() {
+	ReturnValue_t result;
+	if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
+		triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
+		return;
+	}
+
+	modeHelper.setForced(true);
+
+	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	mode = getFallbackSequence(mode);
+	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	startTransition(mode, SUBMODE_NONE);
+}
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index b296a2e8..de4761fa 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -92,7 +92,7 @@ protected:
 
 	bool childrenChangedHealth;
 
-	uint32_t uptimeStartTable;
+	uint32_t uptimeStartTable = 0;
 
 	HybridIterator<ModeListEntry> currentTargetTable;
 
@@ -108,10 +108,10 @@ protected:
 
 	FixedMap<Mode_t, SequenceInfo> modeSequences;
 
-	StorageManagerIF *IPCStore;
+	StorageManagerIF *IPCStore = nullptr;
 
 #ifdef USE_MODESTORE
-	ModeStoreIF *modeStore;
+	ModeStoreIF *modeStore = nullptr;
 #endif
 
 	bool existsModeSequence(Mode_t id);
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index e073ad86..7124d8bd 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -119,7 +119,7 @@ ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* f
 
 	if (temp->pField & (1 << 3)) { //day of year variation
 		uint16_t tempDay = (temp->month << 8) + temp->day;
-		ReturnValue_t result = convertDaysOfYear(tempDay, to->year,
+		result = convertDaysOfYear(tempDay, to->year,
 				&(temp->month), &(temp->day));
 		if (result != RETURN_OK) {
 			return result;

From 468ebfb809f4ec6140492e3146f134f54b4f1d7d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:18:11 +0200
Subject: [PATCH 0674/1292] include improvement

---
 globalfunctions/timevalOperations.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index aa921511..ae49ef21 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/timevalOperations.h"
+#include "timevalOperations.h"
 
 timeval& operator+=(timeval& lhs, const timeval& rhs) {
 	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;

From 8862f35ad136991e4f4a04d5551a507aba3ed31b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:35:27 +0200
Subject: [PATCH 0675/1292] git is weird

---
 action/ActionHelper.cpp        | 220 ++++++++++++++--------------
 action/ActionHelper.h          | 186 ++++++++++++------------
 action/ActionMessage.cpp       | 158 ++++++++++----------
 action/ActionMessage.h         |  64 ++++-----
 action/CommandActionHelper.cpp | 254 ++++++++++++++++-----------------
 action/CommandActionHelper.h   |  72 +++++-----
 action/CommandsActionsIF.h     |  68 ++++-----
 action/HasActionsIF.h          | 120 ++++++++--------
 action/SimpleActionHelper.cpp  | 148 +++++++++----------
 action/SimpleActionHelper.h    |  48 +++----
 10 files changed, 669 insertions(+), 669 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index a367af16..b43c676d 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,110 +1,110 @@
-#include "../action/ActionHelper.h"
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
-}
-
-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;
-	}
-}
-
-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_);
-	}
-
-	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::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
-}
-
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	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;
-	}
-}
-
-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);
-
-	//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;
-}
-
-void ActionHelper::resetHelper() {
-}
+#include "ActionHelper.h"
+#include "HasActionsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+}
+
+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;
+	}
+}
+
+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_);
+	}
+
+	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::finish(MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+	CommandMessage reply;
+	ActionMessage::setCompletionReply(&reply, commandId, result);
+	queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
+	queueToUse = queue;
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
+		store_address_t dataAddress) {
+	const uint8_t* dataPtr = NULL;
+	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;
+	}
+}
+
+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);
+
+	//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;
+}
+
+void ActionHelper::resetHelper() {
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index f528b031..bbc6d114 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -1,93 +1,93 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
-
-#include "../action/ActionMessage.h"
-#include "../serialize/SerializeIF.h"
-#include "../ipc/MessageQueueIF.h"
-/**
- * \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!
- */
-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);
-
-	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);
-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();
-};
-
-#endif /* ACTIONHELPER_H_ */
+#ifndef ACTIONHELPER_H_
+#define ACTIONHELPER_H_
+
+#include "ActionMessage.h"
+#include "../serialize/SerializeIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * \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!
+ */
+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);
+
+	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 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);
+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();
+};
+
+#endif /* ACTIONHELPER_H_ */
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index 5743cc74..b0bcabaa 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -1,79 +1,79 @@
-#include "../action/ActionMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-ActionMessage::ActionMessage() {
-}
-
-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);
-}
-
-ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
-}
-
-store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	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);
-}
-
-uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
-}
-
-ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	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);
-}
-
-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);
-}
-
-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;
-	}
-}
+#include "ActionMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+ActionMessage::ActionMessage() {
+}
+
+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);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+	return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+	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);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+	return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+	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);
+}
+
+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);
+}
+
+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;
+	}
+}
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index aae44e16..0a718aab 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,32 +1,32 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-typedef uint32_t ActionId_t;
-
-class ActionMessage {
-private:
-	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);
-};
-
-#endif /* ACTIONMESSAGE_H_ */
+#ifndef ACTIONMESSAGE_H_
+#define ACTIONMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+typedef uint32_t ActionId_t;
+
+class ActionMessage {
+private:
+	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);
+};
+
+#endif /* ACTIONMESSAGE_H_ */
diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp
index d8d506aa..4e88f3c3 100644
--- a/action/CommandActionHelper.cpp
+++ b/action/CommandActionHelper.cpp
@@ -1,127 +1,127 @@
-#include "../action/ActionMessage.h"
-#include "../action/CommandActionHelper.h"
-#include "../action/CommandsActionsIF.h"
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		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);
-}
-
-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);
-}
-
-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;
-}
-
-ReturnValue_t CommandActionHelper::initialize() {
-	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;
-}
-
-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;
-	}
-}
-
-uint8_t CommandActionHelper::getCommandCount() const {
-	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);
-}
+#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) {
+}
+
+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);
+}
+
+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);
+}
+
+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;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+	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;
+}
+
+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;
+	}
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+	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);
+}
diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h
index edbcaadd..cfed8c94 100644
--- a/action/CommandActionHelper.h
+++ b/action/CommandActionHelper.h
@@ -1,36 +1,36 @@
-#ifndef COMMANDACTIONHELPER_H_
-#define COMMANDACTIONHELPER_H_
-
-#include "../action/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;
-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;
-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);
-};
-
-#endif /* COMMANDACTIONHELPER_H_ */
+#ifndef COMMANDACTIONHELPER_H_
+#define COMMANDACTIONHELPER_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;
+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;
+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);
+};
+
+#endif /* COMMANDACTIONHELPER_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index bead3140..3d04015d 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,34 +1,34 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
-
-#include "../action/CommandActionHelper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-/**
- * Interface to separate commanding actions of other objects.
- * In next iteration, IF should be shortened to three calls:
- * - dataReceived(data)
- * - successReceived(id, step)
- * - failureReceived(id, step, cause)
- * or even
- * - replyReceived(id, step, cause) (if cause == OK, it's a success).
- */
-class CommandsActionsIF {
-	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;
-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;
-};
-
-
-#endif /* COMMANDSACTIONSIF_H_ */
+#ifndef COMMANDSACTIONSIF_H_
+#define COMMANDSACTIONSIF_H_
+
+#include "CommandActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * Interface to separate commanding actions of other objects.
+ * In next iteration, IF should be shortened to three calls:
+ * - dataReceived(data)
+ * - successReceived(id, step)
+ * - failureReceived(id, step, cause)
+ * or even
+ * - replyReceived(id, step, cause) (if cause == OK, it's a success).
+ */
+class CommandsActionsIF {
+	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;
+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;
+};
+
+
+#endif /* COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 283664a3..886d0837 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -1,60 +1,60 @@
-#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
-#define FRAMEWORK_ACTION_HASACTIONSIF_H_
-
-#include "../action/ActionHelper.h"
-#include "../action/ActionMessage.h"
-#include "../action/SimpleActionHelper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-/**
- * @brief
- * Interface for component which uses actions
- *
- * @details
- * This interface is used to execute actions in the component. Actions, in the
- * sense of this interface, are activities with a well-defined beginning and
- * end in time. They may adjust sub-states of components, but are not supposed
- * to change the main mode of operation, which is handled with the HasModesIF
- * described below.
- *
- * The HasActionsIF allows components to define such actions and make them
- * available for other components to use. Implementing the interface is
- * straightforward: There’s a single executeAction call, which provides an
- * identifier for the action to execute, as well as arbitrary parameters for
- * input.
- * Aside from direct, software-based actions, it is used in device handler
- * components as an interface to forward commands to devices.
- * Implementing components of the interface are supposed to check identifier
- * (ID) and parameters and immediately start execution of the action.
- * It is, however, not required to immediately finish execution.
- * Instead, this may be deferred to a later point in time, at which the
- * component needs to inform the caller about finished or failed execution.
- *
- * @ingroup interfaces
- */
-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;
-};
-
-
-#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
+#ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_
+#define FRAMEWORK_ACTION_HASACTIONSIF_H_
+
+#include "ActionHelper.h"
+#include "ActionMessage.h"
+#include "SimpleActionHelper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+/**
+ * @brief
+ * Interface for component which uses actions
+ *
+ * @details
+ * This interface is used to execute actions in the component. Actions, in the
+ * sense of this interface, are activities with a well-defined beginning and
+ * end in time. They may adjust sub-states of components, but are not supposed
+ * to change the main mode of operation, which is handled with the HasModesIF
+ * described below.
+ *
+ * The HasActionsIF allows components to define such actions and make them
+ * available for other components to use. Implementing the interface is
+ * straightforward: There’s a single executeAction call, which provides an
+ * identifier for the action to execute, as well as arbitrary parameters for
+ * input.
+ * Aside from direct, software-based actions, it is used in device handler
+ * components as an interface to forward commands to devices.
+ * Implementing components of the interface are supposed to check identifier
+ * (ID) and parameters and immediately start execution of the action.
+ * It is, however, not required to immediately finish execution.
+ * Instead, this may be deferred to a later point in time, at which the
+ * component needs to inform the caller about finished or failed execution.
+ *
+ * @ingroup interfaces
+ */
+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;
+};
+
+
+#endif /* FRAMEWORK_ACTION_HASACTIONSIF_H_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 83ce3c85..d79a3c97 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,74 +1,74 @@
-#include "../action/HasActionsIF.h"
-#include "../action/SimpleActionHelper.h"
-SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
-}
-
-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();
-	}
-}
-
-void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
-}
-
-ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
-}
-
-void SimpleActionHelper::resetHelper() {
-	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;
-	}
-
-}
+#include "HasActionsIF.h"
+#include "SimpleActionHelper.h"
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+		MessageQueueIF* useThisQueue) :
+		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
+				0), lastAction(0), stepCount(0) {
+}
+
+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();
+	}
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+	ActionHelper::finish(lastCommander, lastAction, result);
+	resetHelper();
+}
+
+ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
+	return ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+	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;
+	}
+
+}
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 05025f82..1329b5fb 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,24 +1,24 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
-
-#include "../action/ActionHelper.h"
-
-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);
-
-protected:
-	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;
-};
-
-#endif /* SIMPLEACTIONHELPER_H_ */
+#ifndef SIMPLEACTIONHELPER_H_
+#define SIMPLEACTIONHELPER_H_
+
+#include "ActionHelper.h"
+
+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);
+
+protected:
+	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;
+};
+
+#endif /* SIMPLEACTIONHELPER_H_ */

From 5ce954672b023ea804d7915ac3031b284ad10091 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:40:21 +0200
Subject: [PATCH 0676/1292] taken over coordinates  from upstream

---
 coordinates/CoordinateTransformations.cpp | 454 ++++++++++-----------
 coordinates/CoordinateTransformations.h   |  68 ++--
 coordinates/Jgm3Model.h                   | 360 ++++++++---------
 coordinates/Sgp4Propagator.cpp            | 456 +++++++++++-----------
 coordinates/Sgp4Propagator.h              |  88 ++---
 5 files changed, 713 insertions(+), 713 deletions(-)

diff --git a/coordinates/CoordinateTransformations.cpp b/coordinates/CoordinateTransformations.cpp
index df9b3cac..4e2debbe 100644
--- a/coordinates/CoordinateTransformations.cpp
+++ b/coordinates/CoordinateTransformations.cpp
@@ -1,227 +1,227 @@
-#include "../coordinates/CoordinateTransformations.h"
-#include "../globalfunctions/constants.h"
-#include "../globalfunctions/math/MatrixOperations.h"
-#include "../globalfunctions/math/VectorOperations.h"
-#include <stddef.h>
-#include <cmath>
-
-
-void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
-		double* eciPosition, timeval *timeUTC) {
-	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
-
-}
-
-void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
-		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
-	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
-}
-
-void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
-	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
-};
-
-void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
-	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
-}
-
-double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
-
-	double jD2000UTC;
-	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
-
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-	double theta = 2 * Math::PI
-			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
-
-	//Correct theta according to IAU 2000 precession-nutation model
-	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
-			+ 6.77128219501896E-006 * TTt2000 * TTt2000
-			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
-			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
-	return theta;
-}
-
-void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
-		double matrix[][3]) {
-	double theta = getEarthRotationAngle(timeUTC);
-
-	matrix[0][0] = cos(theta);
-	matrix[0][1] = sin(theta);
-	matrix[0][2] = 0;
-	matrix[1][0] = -sin(theta);
-	matrix[1][1] = cos(theta);
-	matrix[1][2] = 0;
-	matrix[2][0] = 0;
-	matrix[2][1] = 0;
-	matrix[2][2] = 1;
-}
-
-void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
-		double* eciCoordinates,
-		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
-
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	} else {
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-	double Tif[3][3];
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
-
-	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
-			3, 3, 1);
-
-
-
-
-	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
-
-		double Tdotfi[3][3];
-		double Tdotif[3][3];
-		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-				3);
-
-		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
-
-		double velocityCorrection[3];
-
-		MatrixOperations<double>::multiply(Tdotif[0],
-				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-				1);
-
-		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
-				eciCoordinates, 3);
-	}
-}
-
-double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
-	timeval timeTT;
-	Clock::convertUTCToTT(timeUTC, &timeTT);
-	double jD2000TT;
-	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
-
-	return jD2000TT / 36525.;
-}
-
-void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
-		double* ecfCoordinates,
-		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
-	timeval timeUTC;
-	if (timeUTCin != NULL) {
-		timeUTC = *timeUTCin;
-	}else{
-		Clock::getClock_timeval(&timeUTC);
-	}
-
-	double Tfi[3][3];
-
-	getTransMatrixECITOECF(timeUTC,Tfi);
-
-	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
-
-	if (eciPositionIfCoordinatesAreVelocity != NULL) {
-
-			double Tdotfi[3][3];
-			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
-					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
-
-			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
-					3);
-
-			double velocityCorrection[3];
-
-			MatrixOperations<double>::multiply(Tdotfi[0],
-					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
-					1);
-
-			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
-					ecfCoordinates, 3);
-		}
-};
-
-void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
-	double TTt2000 = getJuleanCenturiesTT(timeUTC);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Precession Matrix
-
-		double zeta = 0.0111808609 * TTt2000
-				+ 1.46355554053347E-006 * TTt2000 * TTt2000
-				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
-		double theta_p = 0.0097171735 * TTt2000
-				- 2.06845757045384E-006 * TTt2000 * TTt2000
-				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
-		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
-				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
-
-		double mPrecession[3][3];
-
-		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
-		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
-		mPrecession[2][0] = sin(theta_p) * cos(zeta);
-
-		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
-		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
-		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
-
-		mPrecession[0][2] = -cos(z) * sin(theta_p);
-		mPrecession[1][2] = -sin(z) * sin(theta_p);
-		mPrecession[2][2] = cos(theta_p);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Nutation Matrix
-
-		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
-				+ 3.61428599267159E-005 * TTt2000 * TTt2000
-				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
-
-		double deltaPsi = -0.000083388 * sin(omega_moon);
-		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
-
-		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
-				- 2.86040071854626E-009 * TTt2000 * TTt2000
-				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
-
-
-		double mNutation[3][3];
-
-		mNutation[0][0] = cos(deltaPsi);
-		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
-		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
-
-		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
-		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- sin(epsilon) * cos(epsilon + deltaEpsilon);
-
-		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
-		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
-				- cos(epsilon) * sin(epsilon + deltaEpsilon);
-		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
-				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
-
-		//////////////////////////////////////////////////////////
-		// Calculate Earth rotation matrix
-		//calculate theta
-
-		double mTheta[3][3];
-		double Ttemp[3][3];
-		getEarthRotationMatrix(timeUTC, mTheta);
-
-		//polar motion is neglected
-		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
-				3, 3, 3);
-
-		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
-};
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/constants.h"
+#include "../globalfunctions/math/MatrixOperations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include <stddef.h>
+#include <cmath>
+
+
+void CoordinateTransformations::positionEcfToEci(const double* ecfPosition,
+		double* eciPosition, timeval *timeUTC) {
+	ecfToEci(ecfPosition, eciPosition, NULL, timeUTC);
+
+}
+
+void CoordinateTransformations::velocityEcfToEci(const double* ecfVelocity,
+		const double* ecfPosition, double* eciVelocity, timeval *timeUTC) {
+	ecfToEci(ecfVelocity, eciVelocity, ecfPosition, timeUTC);
+}
+
+void CoordinateTransformations::positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC){
+	eciToEcf(eciCoordinates,ecfCoordinates,NULL,timeUTC);
+};
+
+void CoordinateTransformations::velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC){
+	eciToEcf(eciVelocity,ecfVelocity,eciPosition,timeUTC);
+}
+
+double CoordinateTransformations::getEarthRotationAngle(timeval timeUTC) {
+
+	double jD2000UTC;
+	Clock::convertTimevalToJD2000(timeUTC, &jD2000UTC);
+
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+	double theta = 2 * Math::PI
+			* (0.779057273264 + 1.00273781191135448 * jD2000UTC);
+
+	//Correct theta according to IAU 2000 precession-nutation model
+	theta = theta + 7.03270725817493E-008 + 0.0223603701 * TTt2000
+			+ 6.77128219501896E-006 * TTt2000 * TTt2000
+			+ 4.5300990362875E-010 * TTt2000 * TTt2000 * TTt2000
+			+ 9.12419347848147E-011 * TTt2000 * TTt2000 * TTt2000 * TTt2000;
+	return theta;
+}
+
+void CoordinateTransformations::getEarthRotationMatrix(timeval timeUTC,
+		double matrix[][3]) {
+	double theta = getEarthRotationAngle(timeUTC);
+
+	matrix[0][0] = cos(theta);
+	matrix[0][1] = sin(theta);
+	matrix[0][2] = 0;
+	matrix[1][0] = -sin(theta);
+	matrix[1][1] = cos(theta);
+	matrix[1][2] = 0;
+	matrix[2][0] = 0;
+	matrix[2][1] = 0;
+	matrix[2][2] = 1;
+}
+
+void CoordinateTransformations::ecfToEci(const double* ecfCoordinates,
+		double* eciCoordinates,
+		const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin) {
+
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	} else {
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+	double Tif[3][3];
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::transpose(Tfi[0], Tif[0], 3);
+
+	MatrixOperations<double>::multiply(Tif[0], ecfCoordinates, eciCoordinates,
+			3, 3, 1);
+
+
+
+
+	if (ecfPositionIfCoordinatesAreVelocity != NULL) {
+
+		double Tdotfi[3][3];
+		double Tdotif[3][3];
+		double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+				{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+		MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+				3);
+
+		MatrixOperations<double>::transpose(Tdotfi[0], Tdotif[0], 3);
+
+		double velocityCorrection[3];
+
+		MatrixOperations<double>::multiply(Tdotif[0],
+				ecfPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+				1);
+
+		VectorOperations<double>::add(velocityCorrection, eciCoordinates,
+				eciCoordinates, 3);
+	}
+}
+
+double CoordinateTransformations::getJuleanCenturiesTT(timeval timeUTC) {
+	timeval timeTT;
+	Clock::convertUTCToTT(timeUTC, &timeTT);
+	double jD2000TT;
+	Clock::convertTimevalToJD2000(timeTT, &jD2000TT);
+
+	return jD2000TT / 36525.;
+}
+
+void CoordinateTransformations::eciToEcf(const double* eciCoordinates,
+		double* ecfCoordinates,
+		const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin){
+	timeval timeUTC;
+	if (timeUTCin != NULL) {
+		timeUTC = *timeUTCin;
+	}else{
+		Clock::getClock_timeval(&timeUTC);
+	}
+
+	double Tfi[3][3];
+
+	getTransMatrixECITOECF(timeUTC,Tfi);
+
+	MatrixOperations<double>::multiply(Tfi[0],eciCoordinates,ecfCoordinates,3,3,1);
+
+	if (eciPositionIfCoordinatesAreVelocity != NULL) {
+
+			double Tdotfi[3][3];
+			double Trot[3][3] = { { 0, Earth::OMEGA, 0 },
+					{ 0 - Earth::OMEGA, 0, 0 }, { 0, 0, 0 } };
+
+			MatrixOperations<double>::multiply(Trot[0], Tfi[0], Tdotfi[0], 3, 3,
+					3);
+
+			double velocityCorrection[3];
+
+			MatrixOperations<double>::multiply(Tdotfi[0],
+					eciPositionIfCoordinatesAreVelocity, velocityCorrection, 3, 3,
+					1);
+
+			VectorOperations<double>::add(ecfCoordinates, velocityCorrection,
+					ecfCoordinates, 3);
+		}
+};
+
+void CoordinateTransformations::getTransMatrixECITOECF(timeval timeUTC,double Tfi[3][3]){
+	double TTt2000 = getJuleanCenturiesTT(timeUTC);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Precession Matrix
+
+		double zeta = 0.0111808609 * TTt2000
+				+ 1.46355554053347E-006 * TTt2000 * TTt2000
+				+ 8.72567663260943E-008 * TTt2000 * TTt2000 * TTt2000;
+		double theta_p = 0.0097171735 * TTt2000
+				- 2.06845757045384E-006 * TTt2000 * TTt2000
+				- 2.02812107218552E-007 * TTt2000 * TTt2000 * TTt2000;
+		double z = zeta + 3.8436028638364E-006 * TTt2000 * TTt2000
+				+ 0.000000001 * TTt2000 * TTt2000 * TTt2000;
+
+		double mPrecession[3][3];
+
+		mPrecession[0][0] = -sin(z) * sin(zeta) + cos(z) * cos(theta_p) * cos(zeta);
+		mPrecession[1][0] = cos(z) * sin(zeta) + sin(z) * cos(theta_p) * cos(zeta);
+		mPrecession[2][0] = sin(theta_p) * cos(zeta);
+
+		mPrecession[0][1] = -sin(z) * cos(zeta) - cos(z) * cos(theta_p) * sin(zeta);
+		mPrecession[1][1] = cos(z) * cos(zeta) - sin(z) * cos(theta_p) * sin(zeta);
+		mPrecession[2][1] = -sin(theta_p) * sin(zeta);
+
+		mPrecession[0][2] = -cos(z) * sin(theta_p);
+		mPrecession[1][2] = -sin(z) * sin(theta_p);
+		mPrecession[2][2] = cos(theta_p);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Nutation Matrix
+
+		double omega_moon = 2.1824386244 - 33.7570459338 * TTt2000
+				+ 3.61428599267159E-005 * TTt2000 * TTt2000
+				+ 3.87850944887629E-008 * TTt2000 * TTt2000 * TTt2000;
+
+		double deltaPsi = -0.000083388 * sin(omega_moon);
+		double deltaEpsilon = 4.46174030725106E-005 * cos(omega_moon);
+
+		double epsilon = 0.4090928042 - 0.0002269655 * TTt2000
+				- 2.86040071854626E-009 * TTt2000 * TTt2000
+				+ 8.78967203851589E-009 * TTt2000 * TTt2000 * TTt2000;
+
+
+		double mNutation[3][3];
+
+		mNutation[0][0] = cos(deltaPsi);
+		mNutation[1][0] = cos(epsilon + deltaEpsilon) * sin(deltaPsi);
+		mNutation[2][0] = sin(epsilon + deltaEpsilon) * sin(deltaPsi);
+
+		mNutation[0][1] = -cos(epsilon) * sin(deltaPsi);
+		mNutation[1][1] = cos(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ sin(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][1] = cos(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- sin(epsilon) * cos(epsilon + deltaEpsilon);
+
+		mNutation[0][2] = -sin(epsilon) * sin(deltaPsi);
+		mNutation[1][2] = sin(epsilon) * cos(epsilon + deltaEpsilon) * cos(deltaPsi)
+				- cos(epsilon) * sin(epsilon + deltaEpsilon);
+		mNutation[2][2] = sin(epsilon) * sin(epsilon + deltaEpsilon) * cos(deltaPsi)
+				+ cos(epsilon) * cos(epsilon + deltaEpsilon);
+
+		//////////////////////////////////////////////////////////
+		// Calculate Earth rotation matrix
+		//calculate theta
+
+		double mTheta[3][3];
+		double Ttemp[3][3];
+		getEarthRotationMatrix(timeUTC, mTheta);
+
+		//polar motion is neglected
+		MatrixOperations<double>::multiply(mNutation[0], mPrecession[0], Ttemp[0],
+				3, 3, 3);
+
+		MatrixOperations<double>::multiply(mTheta[0], Ttemp[0], Tfi[0], 3, 3, 3);
+};
diff --git a/coordinates/CoordinateTransformations.h b/coordinates/CoordinateTransformations.h
index 0bfb203d..09ea2c48 100644
--- a/coordinates/CoordinateTransformations.h
+++ b/coordinates/CoordinateTransformations.h
@@ -1,34 +1,34 @@
-#ifndef COORDINATETRANSFORMATIONS_H_
-#define COORDINATETRANSFORMATIONS_H_
-
-#include "../timemanager/Clock.h"
-#include <cstring>
-
-class CoordinateTransformations {
-public:
-	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
-
-	static void velocityEcfToEci(const double* ecfVelocity,
-			const double* ecfPosition,
-			double* eciVelocity, timeval *timeUTC = NULL);
-
-	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
-	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
-
-	static double getEarthRotationAngle(timeval timeUTC);
-
-	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
-private:
-	CoordinateTransformations();
-	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
-			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
-	static void eciToEcf(const double* eciCoordinates,
-				double* ecfCoordinates,
-				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
-
-	static double getJuleanCenturiesTT(timeval timeUTC);
-	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
-
-};
-
-#endif /* COORDINATETRANSFORMATIONS_H_ */
+#ifndef COORDINATETRANSFORMATIONS_H_
+#define COORDINATETRANSFORMATIONS_H_
+
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class CoordinateTransformations {
+public:
+	static void positionEcfToEci(const double* ecfCoordinates, double* eciCoordinates, timeval *timeUTC = NULL);
+
+	static void velocityEcfToEci(const double* ecfVelocity,
+			const double* ecfPosition,
+			double* eciVelocity, timeval *timeUTC = NULL);
+
+	static void positionEciToEcf(const double* eciCoordinates, double* ecfCoordinates,timeval *timeUTC = NULL);
+	static void velocityEciToEcf(const double* eciVelocity,const double* eciPosition, double* ecfVelocity,timeval* timeUTC = NULL);
+
+	static double getEarthRotationAngle(timeval timeUTC);
+
+	static void getEarthRotationMatrix(timeval timeUTC, double matrix[][3]);
+private:
+	CoordinateTransformations();
+	static void ecfToEci(const double* ecfCoordinates, double* eciCoordinates,
+			const double* ecfPositionIfCoordinatesAreVelocity, timeval *timeUTCin);
+	static void eciToEcf(const double* eciCoordinates,
+				double* ecfCoordinates,
+				const double* eciPositionIfCoordinatesAreVelocity,timeval *timeUTCin);
+
+	static double getJuleanCenturiesTT(timeval timeUTC);
+	static void getTransMatrixECITOECF(timeval time,double Tfi[3][3]);
+
+};
+
+#endif /* COORDINATETRANSFORMATIONS_H_ */
diff --git a/coordinates/Jgm3Model.h b/coordinates/Jgm3Model.h
index fd74741d..884ed141 100644
--- a/coordinates/Jgm3Model.h
+++ b/coordinates/Jgm3Model.h
@@ -1,180 +1,180 @@
-#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
-#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
-
-#include <stdint.h>
-#include "../coordinates/CoordinateTransformations.h"
-#include "../globalfunctions/math/VectorOperations.h"
-#include "../globalfunctions/timevalOperations.h"
-#include "../globalfunctions/constants.h"
-#include <memory.h>
-
-
-template<uint8_t DEGREE,uint8_t ORDER>
-class Jgm3Model {
-public:
-	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
-
-	Jgm3Model() {
-		y0[0] = 0;
-		y0[1] = 0;
-		y0[2] = 0;
-		y0[3] = 0;
-		y0[4] = 0;
-		y0[5] = 0;
-
-		lastExecutionTime.tv_sec = 0;
-		lastExecutionTime.tv_usec = 0;
-	}
-	virtual ~Jgm3Model(){};
-
-	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
-
-	double y0[6]; //position and velocity at beginning of RK step in EC
-	timeval lastExecutionTime; //Time of last execution
-
-
-	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
-		//Get radius of this position
-		double r = VectorOperations<double>::norm(pos,3);
-
-
-
-		//Initialize the V and W matrix
-		double V[DEGREE+2][ORDER+2] = {{0}};
-		double W[DEGREE+2][ORDER+2] = {{0}};
-
-		for(uint8_t m=0;m<(ORDER+2);m++){
-			for(uint8_t n=m;n<(DEGREE+2);n++){
-				if((n==0) && (m==0)){
-					//Montenbruck "Satellite Orbits Eq.3.31"
-					V[0][0] = Earth::MEAN_RADIUS / r;
-					W[0][0] = 0;
-				}else{
-					if(n==m){
-						//Montenbruck "Satellite Orbits Eq.3.29"
-						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
-						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
-					}else{
-						//Montenbruck "Satellite Orbits Eq.3.30"
-						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
-						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
-						if(n!=(m+1)){
-							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
-							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
-						}//End of if(n!=(m+1))
-					}//End of if(n==m){
-				}//End of if(n==0 and m==0)
-			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
-		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
-
-
-		//overwrite accel if not properly initialized
-		accel[0] = 0;
-		accel[1] = 0;
-		accel[2] = 0;
-
-		for(uint8_t m=0;m<(ORDER+1);m++){
-			for(uint8_t n=m;n<(DEGREE+1);n++){
-				//Use table lookup to get factorial
-				double partAccel[3] = {0};
-				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
-				if(m==0){
-					//Montenbruck "Satellite Orbits Eq.3.33"
-					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
-					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
-				}else{
-					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
-					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
-					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
-				}
-
-				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
-
-
-				accel[0] += partAccel[0];
-				accel[1] += partAccel[1];
-				accel[2] += partAccel[2];
-			}//End of for(uint8_t n=0;n<DEGREE;n++)
-		}//End of uint8_t m=0;m<ORDER;m++
-	}
-
-	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
-		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
-		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
-		lastExecutionTime = timeUTC;
-	}
-
-
-	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
-
-		//RK4 Integration for this timestamp
-		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
-
-		double y0dot[6] = {0,0,0,0,0,0};
-		double yA[6] = {0,0,0,0,0,0};
-		double yAdot[6] = {0,0,0,0,0,0};
-		double yB[6] = {0,0,0,0,0,0};
-		double yBdot[6] = {0,0,0,0,0,0};
-		double yC[6] = {0,0,0,0,0,0};
-		double yCdot[6] = {0,0,0,0,0,0};
-
-		//Step One
-		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
-
-		//Step Two
-		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
-		VectorOperations<double>::add(y0,yA,yA,6);
-		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
-
-		//Step Three
-		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
-		VectorOperations<double>::add(y0,yB,yB,6);
-		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
-
-		//Step Four
-		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
-		VectorOperations<double>::add(y0,yC,yC,6);
-		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
-
-		//Calc new State
-		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
-		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
-		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
-		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
-		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
-		VectorOperations<double>::add(y0,y0dot,y0,6);
-
-		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
-		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
-
-		lastExecutionTime = timeUTC;
-
-
-	}
-
-
-	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
-		double rECF[3] = {0,0,0};
-		double rDotECF[3] = {0,0,0};
-		double accelECF[3] = {0,0,0};
-		double accelECI[3] = {0,0,0};
-
-
-		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
-		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
-		accelDegOrd(rECF,S,C,accelECF);
-		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
-		//Tests showed that a wrong velocity does make the equation worse than neglecting it
-		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
-		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
-		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
-	}
-};
-
-
-
-
-
-
-#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
+#ifndef FRAMEWORK_COORDINATES_JGM3MODEL_H_
+#define FRAMEWORK_COORDINATES_JGM3MODEL_H_
+
+#include <stdint.h>
+#include "CoordinateTransformations.h"
+#include "../globalfunctions/math/VectorOperations.h"
+#include "../globalfunctions/timevalOperations.h"
+#include "../globalfunctions/constants.h"
+#include <memory.h>
+
+
+template<uint8_t DEGREE,uint8_t ORDER>
+class Jgm3Model {
+public:
+	static const uint32_t factorialLookupTable[DEGREE+3]; //This table is used instead of factorial calculation, must be increased if order or degree is higher
+
+	Jgm3Model() {
+		y0[0] = 0;
+		y0[1] = 0;
+		y0[2] = 0;
+		y0[3] = 0;
+		y0[4] = 0;
+		y0[5] = 0;
+
+		lastExecutionTime.tv_sec = 0;
+		lastExecutionTime.tv_usec = 0;
+	}
+	virtual ~Jgm3Model(){};
+
+	//double acsNavOrbit(double posECF[3],double velECF[3],timeval gpsTime);
+
+	double y0[6]; //position and velocity at beginning of RK step in EC
+	timeval lastExecutionTime; //Time of last execution
+
+
+	void accelDegOrd(const double pos[3],const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1],double* accel){
+		//Get radius of this position
+		double r = VectorOperations<double>::norm(pos,3);
+
+
+
+		//Initialize the V and W matrix
+		double V[DEGREE+2][ORDER+2] = {{0}};
+		double W[DEGREE+2][ORDER+2] = {{0}};
+
+		for(uint8_t m=0;m<(ORDER+2);m++){
+			for(uint8_t n=m;n<(DEGREE+2);n++){
+				if((n==0) && (m==0)){
+					//Montenbruck "Satellite Orbits Eq.3.31"
+					V[0][0] = Earth::MEAN_RADIUS / r;
+					W[0][0] = 0;
+				}else{
+					if(n==m){
+						//Montenbruck "Satellite Orbits Eq.3.29"
+						V[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1] - pos[1]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1]);
+						W[m][m] = (2*m-1)* (pos[0]*Earth::MEAN_RADIUS/pow(r,2)*W[m-1][m-1] + pos[1]*Earth::MEAN_RADIUS/pow(r,2)*V[m-1][m-1]);
+					}else{
+						//Montenbruck "Satellite Orbits Eq.3.30"
+						V[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*V[n-1][m];
+						W[n][m] = ((2*n-1)/(double)(n-m))*pos[2]*Earth::MEAN_RADIUS / pow(r,2)*W[n-1][m];
+						if(n!=(m+1)){
+							V[n][m] = V[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * V[n-2][m]);
+							W[n][m] = W[n][m] - (((n+m-1)/(double)(n-m)) * (pow(Earth::MEAN_RADIUS,2) / pow(r,2)) * W[n-2][m]);
+						}//End of if(n!=(m+1))
+					}//End of if(n==m){
+				}//End of if(n==0 and m==0)
+			}//End of for(uint8_t n=0;n<(DEGREE+1);n++)
+		}//End of for(uint8_t m=0;m<(ORDER+1);m++)
+
+
+		//overwrite accel if not properly initialized
+		accel[0] = 0;
+		accel[1] = 0;
+		accel[2] = 0;
+
+		for(uint8_t m=0;m<(ORDER+1);m++){
+			for(uint8_t n=m;n<(DEGREE+1);n++){
+				//Use table lookup to get factorial
+				double partAccel[3] = {0};
+				double factor = Earth::STANDARD_GRAVITATIONAL_PARAMETER/pow(Earth::MEAN_RADIUS,2);
+				if(m==0){
+					//Montenbruck "Satellite Orbits Eq.3.33"
+					partAccel[0] = factor * (-C[n][0]*V[n+1][1]);
+					partAccel[1] = factor * (-C[n][0]*W[n+1][1]);
+				}else{
+					double factMN = static_cast<double>(factorialLookupTable[n-m+2]) / static_cast<double>(factorialLookupTable[n-m]);
+					partAccel[0] = factor * 0.5 * ((-C[n][m]*V[n+1][m+1]-S[n][m]*W[n+1][m+1])+factMN*(C[n][m]*V[n+1][m-1]+S[n][m]*W[n+1][m-1]));
+					partAccel[1] = factor * 0.5 * ((-C[n][m]*W[n+1][m+1]+S[n][m]*V[n+1][m+1])+factMN*(-C[n][m]*W[n+1][m-1]+S[n][m]*V[n+1][m-1]));
+				}
+
+				partAccel[2] = factor * ((n-m+1)*(-C[n][m]*V[n+1][m]-S[n][m]*W[n+1][m]));
+
+
+				accel[0] += partAccel[0];
+				accel[1] += partAccel[1];
+				accel[2] += partAccel[2];
+			}//End of for(uint8_t n=0;n<DEGREE;n++)
+		}//End of uint8_t m=0;m<ORDER;m++
+	}
+
+	void initializeNavOrbit(const double position[3],const double velocity[3], timeval timeUTC){
+		CoordinateTransformations::positionEcfToEci(position,&y0[0],&timeUTC);
+		CoordinateTransformations::velocityEcfToEci(velocity,position,&y0[3],&timeUTC);
+		lastExecutionTime = timeUTC;
+	}
+
+
+	void acsNavOrbit(timeval timeUTC, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1], double outputPos[3],double outputVel[3]){
+
+		//RK4 Integration for this timestamp
+		double deltaT = timevalOperations::toDouble(timeUTC-lastExecutionTime);
+
+		double y0dot[6] = {0,0,0,0,0,0};
+		double yA[6] = {0,0,0,0,0,0};
+		double yAdot[6] = {0,0,0,0,0,0};
+		double yB[6] = {0,0,0,0,0,0};
+		double yBdot[6] = {0,0,0,0,0,0};
+		double yC[6] = {0,0,0,0,0,0};
+		double yCdot[6] = {0,0,0,0,0,0};
+
+		//Step One
+		rungeKuttaStep(y0,y0dot,lastExecutionTime,S,C);
+
+		//Step Two
+		VectorOperations<double>::mulScalar(y0dot,deltaT/2,yA,6);
+		VectorOperations<double>::add(y0,yA,yA,6);
+		rungeKuttaStep(yA,yAdot,lastExecutionTime,S,C);
+
+		//Step Three
+		VectorOperations<double>::mulScalar(yAdot,deltaT/2,yB,6);
+		VectorOperations<double>::add(y0,yB,yB,6);
+		rungeKuttaStep(yB,yBdot,lastExecutionTime,S,C);
+
+		//Step Four
+		VectorOperations<double>::mulScalar(yBdot,deltaT,yC,6);
+		VectorOperations<double>::add(y0,yC,yC,6);
+		rungeKuttaStep(yC,yCdot,lastExecutionTime,S,C);
+
+		//Calc new State
+		VectorOperations<double>::mulScalar(yAdot,2,yAdot,6);
+		VectorOperations<double>::mulScalar(yBdot,2,yBdot,6);
+		VectorOperations<double>::add(y0dot,yAdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yBdot,y0dot,6);
+		VectorOperations<double>::add(y0dot,yCdot,y0dot,6);
+		VectorOperations<double>::mulScalar(y0dot,1./6.*deltaT,y0dot,6);
+		VectorOperations<double>::add(y0,y0dot,y0,6);
+
+		CoordinateTransformations::positionEciToEcf(&y0[0],outputPos,&timeUTC);
+		CoordinateTransformations::velocityEciToEcf(&y0[3],&y0[0],outputVel,&timeUTC);
+
+		lastExecutionTime = timeUTC;
+
+
+	}
+
+
+	void rungeKuttaStep(const double* yIn,double* yOut,timeval time, const double S[ORDER+1][DEGREE+1],const double C[ORDER+1][DEGREE+1]){
+		double rECF[3] = {0,0,0};
+		double rDotECF[3] = {0,0,0};
+		double accelECF[3] = {0,0,0};
+		double accelECI[3] = {0,0,0};
+
+
+		CoordinateTransformations::positionEciToEcf(&yIn[0],rECF,&time);
+		CoordinateTransformations::velocityEciToEcf(&yIn[3],&yIn[0],rDotECF,&time);
+		accelDegOrd(rECF,S,C,accelECF);
+		//This is not correct, as the acceleration would have derived terms but we don't know the velocity and position at that time
+		//Tests showed that a wrong velocity does make the equation worse than neglecting it
+		CoordinateTransformations::positionEcfToEci(accelECF,accelECI,&time);
+		memcpy(&yOut[0],&yIn[3],sizeof(yOut[0])*3);
+		memcpy(&yOut[3],accelECI,sizeof(yOut[0])*3);
+	}
+};
+
+
+
+
+
+
+#endif /* FRAMEWORK_COORDINATES_JGM3MODEL_H_ */
diff --git a/coordinates/Sgp4Propagator.cpp b/coordinates/Sgp4Propagator.cpp
index 84a52799..5cb1497c 100644
--- a/coordinates/Sgp4Propagator.cpp
+++ b/coordinates/Sgp4Propagator.cpp
@@ -1,228 +1,228 @@
-#include "../coordinates/CoordinateTransformations.h"
-#include "../coordinates/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) {
-
-}
-
-Sgp4Propagator::~Sgp4Propagator() {
-
-}
-
-void jday(int year, int mon, int day, int hr, int minute, double sec,
-		double& jd) {
-	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
-			+ floor(275 * mon / 9.0) + day + 1721013.5
-			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
-			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
-}
-
-void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
-		double& sec) {
-	int i, inttemp, dayofyr;
-	double temp;
-	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-	dayofyr = (int) floor(days);
-	/* ----------------- find month and day of month ---------------- */
-	if ((year % 4) == 0)
-		lmonth[1] = 29;
-
-	i = 1;
-	inttemp = 0;
-	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
-		inttemp = inttemp + lmonth[i - 1];
-		i++;
-	}
-	mon = i;
-	day = dayofyr - inttemp;
-
-	/* ----------------- find hours minutes and seconds ------------- */
-	temp = (days - dayofyr) * 24.0;
-	hr = (int) floor(temp);
-	temp = (temp - hr) * 60.0;
-	minute = (int) floor(temp);
-	sec = (temp - minute) * 60.0;
-}
-
-ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
-		const uint8_t* line2) {
-
-	char longstr1[130];
-	char longstr2[130];
-
-	//need some space for decimal points
-	memcpy(longstr1, line1, 69);
-	memcpy(longstr2, line2, 69);
-
-	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
-	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
-
-	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
-	int cardnumb, numb, j;
-	long revnum = 0, elnum = 0;
-	char classification, intldesg[11];
-	int year = 0;
-	int mon, day, hr, minute, nexp, ibexp;
-
-	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
-
-	satrec.error = 0;
-
-	// set the implied decimal points since doing a formated read
-	// fixes for bad input data values (missing, ...)
-	for (j = 10; j <= 15; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '_';
-
-	if (longstr1[44] != ' ')
-		longstr1[43] = longstr1[44];
-	longstr1[44] = '.';
-	if (longstr1[7] == ' ')
-		longstr1[7] = 'U';
-	if (longstr1[9] == ' ')
-		longstr1[9] = '.';
-	for (j = 45; j <= 49; j++)
-		if (longstr1[j] == ' ')
-			longstr1[j] = '0';
-	if (longstr1[51] == ' ')
-		longstr1[51] = '0';
-	if (longstr1[53] != ' ')
-		longstr1[52] = longstr1[53];
-	longstr1[53] = '.';
-	longstr2[25] = '.';
-	for (j = 26; j <= 32; j++)
-		if (longstr2[j] == ' ')
-			longstr2[j] = '0';
-	if (longstr1[62] == ' ')
-		longstr1[62] = '0';
-	if (longstr1[68] == ' ')
-		longstr1[68] = '0';
-
-	sscanf(longstr1,
-			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
-			&cardnumb, &satrec.satnum, &classification, intldesg,
-			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
-			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
-
-	if (longstr2[52] == ' ') {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	} else {
-		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
-				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
-				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
-	}
-
-	// ---- find no, ndot, nddot ----
-	satrec.no = satrec.no / xpdotp; //* rad/min
-	satrec.nddot = satrec.nddot * pow(10.0, nexp);
-	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
-
-	// ---- convert to sgp4 units ----
-	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
-	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
-	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
-
-	// ---- find standard orbital elements ----
-	satrec.inclo = satrec.inclo * deg2rad;
-	satrec.nodeo = satrec.nodeo * deg2rad;
-	satrec.argpo = satrec.argpo * deg2rad;
-	satrec.mo = satrec.mo * deg2rad;
-
-	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
-	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
-
-	// ----------------------------------------------------------------
-	// find sgp4epoch time of element set
-	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
-	// and minutes from the epoch (time)
-	// ----------------------------------------------------------------
-
-	// ---------------- temp fix for years from 1957-2056 -------------------
-	// --------- correct fix will occur when year is 4-digit in tle ---------
-	if (satrec.epochyr < 57) {
-		year = satrec.epochyr + 2000;
-	} else {
-		year = satrec.epochyr + 1900;
-	}
-
-	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
-	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
-
-	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
-			+ 946684800;
-
-	epoch.tv_sec = unixSeconds;
-	double subseconds = unixSeconds - epoch.tv_sec;
-	epoch.tv_usec = subseconds * 1000000;
-
-	// ---------------- initialize the orbit at sgp4epoch -------------------
-	uint8_t result = sgp4init(whichconst, satrec.satnum,
-			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
-			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
-			satrec);
-
-	if (result != 00) {
-		return MAKE_RETURN_CODE(result);
-	} else {
-		initialized = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-}
-
-ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
-		timeval time, uint8_t gpsUtcOffset) {
-
-	if (!initialized) {
-		return TLE_NOT_INITIALIZED;
-	}
-
-	//Time since epoch in minutes
-	timeval timeSinceEpoch = time - epoch;
-	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
-			+ timeSinceEpoch.tv_usec / 60000000.;
-
-	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
-
-	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
-		return TLE_TOO_OLD;
-	}
-
-	double positionTEME[3];
-	double velocityTEME[3];
-
-	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
-			velocityTEME);
-
-	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
-	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
-
-	//Transform to ECF
-	double earthRotationMatrix[3][3];
-	CoordinateTransformations::getEarthRotationMatrix(time,
-			earthRotationMatrix);
-
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
-			position, 3, 3, 1);
-	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
-			velocity, 3, 3, 1);
-
-	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
-	double velocityCorrection[3];
-	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
-	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
-
-	if (result != 0) {
-		return MAKE_RETURN_CODE(result || 0xB0);
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
+#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) {
+
+}
+
+Sgp4Propagator::~Sgp4Propagator() {
+
+}
+
+void jday(int year, int mon, int day, int hr, int minute, double sec,
+		double& jd) {
+	jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25)
+			+ floor(275 * mon / 9.0) + day + 1721013.5
+			+ ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
+			// - 0.5*sgn(100.0*year + mon - 190002.5) + 0.5;
+}
+
+void days2mdhms(int year, double days, int& mon, int& day, int& hr, int& minute,
+		double& sec) {
+	int i, inttemp, dayofyr;
+	double temp;
+	int lmonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+	dayofyr = (int) floor(days);
+	/* ----------------- find month and day of month ---------------- */
+	if ((year % 4) == 0)
+		lmonth[1] = 29;
+
+	i = 1;
+	inttemp = 0;
+	while ((dayofyr > inttemp + lmonth[i - 1]) && (i < 12)) {
+		inttemp = inttemp + lmonth[i - 1];
+		i++;
+	}
+	mon = i;
+	day = dayofyr - inttemp;
+
+	/* ----------------- find hours minutes and seconds ------------- */
+	temp = (days - dayofyr) * 24.0;
+	hr = (int) floor(temp);
+	temp = (temp - hr) * 60.0;
+	minute = (int) floor(temp);
+	sec = (temp - minute) * 60.0;
+}
+
+ReturnValue_t Sgp4Propagator::initialize(const uint8_t* line1,
+		const uint8_t* line2) {
+
+	char longstr1[130];
+	char longstr2[130];
+
+	//need some space for decimal points
+	memcpy(longstr1, line1, 69);
+	memcpy(longstr2, line2, 69);
+
+	const double deg2rad = Math::PI / 180.0;    //   0.0174532925199433
+	const double xpdotp = 1440.0 / (2.0 * Math::PI); // 229.1831180523293
+
+	double sec, mu, radiusearthkm, tumin, xke, j2, j3, j4, j3oj2;
+	int cardnumb, numb, j;
+	long revnum = 0, elnum = 0;
+	char classification, intldesg[11];
+	int year = 0;
+	int mon, day, hr, minute, nexp, ibexp;
+
+	getgravconst(whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2);
+
+	satrec.error = 0;
+
+	// set the implied decimal points since doing a formated read
+	// fixes for bad input data values (missing, ...)
+	for (j = 10; j <= 15; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '_';
+
+	if (longstr1[44] != ' ')
+		longstr1[43] = longstr1[44];
+	longstr1[44] = '.';
+	if (longstr1[7] == ' ')
+		longstr1[7] = 'U';
+	if (longstr1[9] == ' ')
+		longstr1[9] = '.';
+	for (j = 45; j <= 49; j++)
+		if (longstr1[j] == ' ')
+			longstr1[j] = '0';
+	if (longstr1[51] == ' ')
+		longstr1[51] = '0';
+	if (longstr1[53] != ' ')
+		longstr1[52] = longstr1[53];
+	longstr1[53] = '.';
+	longstr2[25] = '.';
+	for (j = 26; j <= 32; j++)
+		if (longstr2[j] == ' ')
+			longstr2[j] = '0';
+	if (longstr1[62] == ' ')
+		longstr1[62] = '0';
+	if (longstr1[68] == ' ')
+		longstr1[68] = '0';
+
+	sscanf(longstr1,
+			"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
+			&cardnumb, &satrec.satnum, &classification, intldesg,
+			&satrec.epochyr, &satrec.epochdays, &satrec.ndot, &satrec.nddot,
+			&nexp, &satrec.bstar, &ibexp, &numb, &elnum);
+
+	if (longstr2[52] == ' ') {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	} else {
+		sscanf(longstr2, "%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
+				&cardnumb, &satrec.satnum, &satrec.inclo, &satrec.nodeo,
+				&satrec.ecco, &satrec.argpo, &satrec.mo, &satrec.no, &revnum);
+	}
+
+	// ---- find no, ndot, nddot ----
+	satrec.no = satrec.no / xpdotp; //* rad/min
+	satrec.nddot = satrec.nddot * pow(10.0, nexp);
+	satrec.bstar = satrec.bstar * pow(10.0, ibexp);
+
+	// ---- convert to sgp4 units ----
+	satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0));
+	satrec.ndot = satrec.ndot / (xpdotp * 1440.0);  //* ? * minperday
+	satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440);
+
+	// ---- find standard orbital elements ----
+	satrec.inclo = satrec.inclo * deg2rad;
+	satrec.nodeo = satrec.nodeo * deg2rad;
+	satrec.argpo = satrec.argpo * deg2rad;
+	satrec.mo = satrec.mo * deg2rad;
+
+	satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0;
+	satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0;
+
+	// ----------------------------------------------------------------
+	// find sgp4epoch time of element set
+	// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
+	// and minutes from the epoch (time)
+	// ----------------------------------------------------------------
+
+	// ---------------- temp fix for years from 1957-2056 -------------------
+	// --------- correct fix will occur when year is 4-digit in tle ---------
+	if (satrec.epochyr < 57) {
+		year = satrec.epochyr + 2000;
+	} else {
+		year = satrec.epochyr + 1900;
+	}
+
+	days2mdhms(year, satrec.epochdays, mon, day, hr, minute, sec);
+	jday(year, mon, day, hr, minute, sec, satrec.jdsatepoch);
+
+	double unixSeconds = (satrec.jdsatepoch - 2451544.5) * 24 * 3600
+			+ 946684800;
+
+	epoch.tv_sec = unixSeconds;
+	double subseconds = unixSeconds - epoch.tv_sec;
+	epoch.tv_usec = subseconds * 1000000;
+
+	// ---------------- initialize the orbit at sgp4epoch -------------------
+	uint8_t result = sgp4init(whichconst, satrec.satnum,
+			satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
+			satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
+			satrec);
+
+	if (result != 00) {
+		return MAKE_RETURN_CODE(result);
+	} else {
+		initialized = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+}
+
+ReturnValue_t Sgp4Propagator::propagate(double* position, double* velocity,
+		timeval time, uint8_t gpsUtcOffset) {
+
+	if (!initialized) {
+		return TLE_NOT_INITIALIZED;
+	}
+
+	//Time since epoch in minutes
+	timeval timeSinceEpoch = time - epoch;
+	double minutesSinceEpoch = timeSinceEpoch.tv_sec / 60.
+			+ timeSinceEpoch.tv_usec / 60000000.;
+
+	double yearsSinceEpoch = minutesSinceEpoch / 60 / 24 / 365;
+
+	if ((yearsSinceEpoch > 1) || (yearsSinceEpoch < -1)) {
+		return TLE_TOO_OLD;
+	}
+
+	double positionTEME[3];
+	double velocityTEME[3];
+
+	uint8_t result = sgp4(whichconst, satrec, minutesSinceEpoch, positionTEME,
+			velocityTEME);
+
+	VectorOperations<double>::mulScalar(positionTEME, 1000, positionTEME, 3);
+	VectorOperations<double>::mulScalar(velocityTEME, 1000, velocityTEME, 3);
+
+	//Transform to ECF
+	double earthRotationMatrix[3][3];
+	CoordinateTransformations::getEarthRotationMatrix(time,
+			earthRotationMatrix);
+
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], positionTEME,
+			position, 3, 3, 1);
+	MatrixOperations<double>::multiply(earthRotationMatrix[0], velocityTEME,
+			velocity, 3, 3, 1);
+
+	double omegaEarth[3] = { 0, 0, Earth::OMEGA };
+	double velocityCorrection[3];
+	VectorOperations<double>::cross(omegaEarth, position, velocityCorrection);
+	VectorOperations<double>::subtract(velocity, velocityCorrection, velocity);
+
+	if (result != 0) {
+		return MAKE_RETURN_CODE(result || 0xB0);
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index f041ec07..3949547e 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,44 +1,44 @@
-#ifndef SGP4PROPAGATOR_H_
-#define SGP4PROPAGATOR_H_
-
-#include <sys/time.h>
-#include "../contrib/sgp4/sgp4unit.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class Sgp4Propagator {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
-	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
-	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
-
-
-
-	Sgp4Propagator();
-	virtual ~Sgp4Propagator();
-
-	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
-
-	/**
-	 *
-	 * @param[out] position in ECF
-	 * @param[out] velocity in ECF
-	 * @param time to which to propagate
-	 * @return
-	 */
-	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
-
-private:
-	bool initialized;
-	timeval epoch;
-	elsetrec satrec;
-	gravconsttype whichconst;
-
-};
-
-#endif /* SGP4PROPAGATOR_H_ */
+#ifndef SGP4PROPAGATOR_H_
+#define SGP4PROPAGATOR_H_
+
+#include <sys/time.h>
+#include "../contrib/sgp4/sgp4unit.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class Sgp4Propagator {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SGP4PROPAGATOR_CLASS;
+	static const ReturnValue_t INVALID_ECCENTRICITY = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t INVALID_MEAN_MOTION = MAKE_RETURN_CODE(0xA2);
+	static const ReturnValue_t INVALID_PERTURBATION_ELEMENTS = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t INVALID_SEMI_LATUS_RECTUM = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t INVALID_EPOCH_ELEMENTS = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t SATELLITE_HAS_DECAYED = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t TLE_TOO_OLD = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t TLE_NOT_INITIALIZED = MAKE_RETURN_CODE(0xB2);
+
+
+
+	Sgp4Propagator();
+	virtual ~Sgp4Propagator();
+
+	ReturnValue_t initialize(const uint8_t *line1, const uint8_t *line2);
+
+	/**
+	 *
+	 * @param[out] position in ECF
+	 * @param[out] velocity in ECF
+	 * @param time to which to propagate
+	 * @return
+	 */
+	ReturnValue_t propagate(double *position, double *velocity, timeval time, uint8_t gpsUtcOffset);
+
+private:
+	bool initialized;
+	timeval epoch;
+	elsetrec satrec;
+	gravconsttype whichconst;
+
+};
+
+#endif /* SGP4PROPAGATOR_H_ */

From d2ef2b2be46e6ac29a6b75a5b44e32f56a7f16b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:40:53 +0200
Subject: [PATCH 0677/1292] taken over datalinklayer form upstream

---
 datalinklayer/BCFrame.h                   | 124 ++++-----
 datalinklayer/CCSDSReturnValuesIF.h       | 112 ++++----
 datalinklayer/Clcw.cpp                    | 126 ++++-----
 datalinklayer/Clcw.h                      | 132 +++++-----
 datalinklayer/DataLinkLayer.cpp           | 278 +++++++++----------
 datalinklayer/DataLinkLayer.h             | 224 ++++++++--------
 datalinklayer/Farm1StateIF.h              | 108 ++++----
 datalinklayer/Farm1StateLockout.cpp       |  70 ++---
 datalinklayer/Farm1StateLockout.h         | 118 ++++-----
 datalinklayer/Farm1StateOpen.cpp          |  98 +++----
 datalinklayer/Farm1StateOpen.h            | 124 ++++-----
 datalinklayer/Farm1StateWait.cpp          |  86 +++---
 datalinklayer/Farm1StateWait.h            | 116 ++++----
 datalinklayer/MapPacketExtraction.cpp     | 308 +++++++++++-----------
 datalinklayer/MapPacketExtraction.h       | 156 +++++------
 datalinklayer/MapPacketExtractionIF.h     |  94 +++----
 datalinklayer/TcTransferFrame.cpp         | 204 +++++++-------
 datalinklayer/TcTransferFrameLocal.cpp    |  98 +++----
 datalinklayer/TcTransferFrameLocal.h      |  98 +++----
 datalinklayer/VirtualChannelReception.cpp | 242 ++++++++---------
 datalinklayer/VirtualChannelReception.h   | 228 ++++++++--------
 datalinklayer/VirtualChannelReceptionIF.h | 114 ++++----
 22 files changed, 1629 insertions(+), 1629 deletions(-)

diff --git a/datalinklayer/BCFrame.h b/datalinklayer/BCFrame.h
index 785cbb75..b7795556 100644
--- a/datalinklayer/BCFrame.h
+++ b/datalinklayer/BCFrame.h
@@ -1,62 +1,62 @@
-/**
- * @file	BCFrame.h
- * @brief	This file defines the BCFrame class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef BCFRAME_H_
-#define BCFRAME_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-
-/**
- * Small helper class to identify a BcFrame.
- * @ingroup ccsds_handling
- */
-class BcFrame: public CCSDSReturnValuesIF {
-private:
-	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
-	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
-
-public:
-	uint8_t byte1;	//!< First content byte
-	uint8_t byte2;	//!< Second content byte
-	uint8_t vR;	//!< vR byte
-	/**
-	 * Simple default constructor.
-	 */
-	BcFrame() :
-			byte1(0), byte2(0), vR(0) {
-	}
-	/**
-	 * Main and only useful method of the class.
-	 * With the buffer and size information passed, the class passes the content
-	 * and checks if it is one of the two valid BC Command Frames.
-	 * @param inBuffer	Content of the frame to check,
-	 * @param inSize	Size of the data to check.
-	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
-	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
-	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
-	 */
-	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
-		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
-		if (inSize == 1) {
-			byte1 = inBuffer[0];
-			if (byte1 == UNLOCK_COMMAND) {
-				returnValue = BC_IS_UNLOCK_COMMAND;
-			}
-		} else if (inSize == 3) {
-			byte1 = inBuffer[0];
-			byte2 = inBuffer[1];
-			vR = inBuffer[2];
-			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
-				returnValue = BC_IS_SET_VR_COMMAND;
-			}
-		}
-		return returnValue;
-	}
-};
-
-#endif /* BCFRAME_H_ */
+/**
+ * @file	BCFrame.h
+ * @brief	This file defines the BCFrame class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef BCFRAME_H_
+#define BCFRAME_H_
+
+#include "CCSDSReturnValuesIF.h"
+
+/**
+ * Small helper class to identify a BcFrame.
+ * @ingroup ccsds_handling
+ */
+class BcFrame: public CCSDSReturnValuesIF {
+private:
+	static const uint8_t UNLOCK_COMMAND = 0b00000000;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_1 = 0b10000010;//! Identifier for a certain BC Command.
+	static const uint8_t SET_V_R_2 = 0b00000000;//! Identifier for a certain BC Command.
+
+public:
+	uint8_t byte1;	//!< First content byte
+	uint8_t byte2;	//!< Second content byte
+	uint8_t vR;	//!< vR byte
+	/**
+	 * Simple default constructor.
+	 */
+	BcFrame() :
+			byte1(0), byte2(0), vR(0) {
+	}
+	/**
+	 * Main and only useful method of the class.
+	 * With the buffer and size information passed, the class passes the content
+	 * and checks if it is one of the two valid BC Command Frames.
+	 * @param inBuffer	Content of the frame to check,
+	 * @param inSize	Size of the data to check.
+	 * @return 	- #BC_ILLEGAL_COMMAND if it is no command.
+	 * 			- #BC_IS_UNLOCK_COMMAND if it is an unlock command.
+	 * 			- #BC_IS_SET_VR_COMMAND if it is such.
+	 */
+	ReturnValue_t initialize(const uint8_t* inBuffer, uint16_t inSize) {
+		ReturnValue_t returnValue = BC_ILLEGAL_COMMAND;
+		if (inSize == 1) {
+			byte1 = inBuffer[0];
+			if (byte1 == UNLOCK_COMMAND) {
+				returnValue = BC_IS_UNLOCK_COMMAND;
+			}
+		} else if (inSize == 3) {
+			byte1 = inBuffer[0];
+			byte2 = inBuffer[1];
+			vR = inBuffer[2];
+			if (byte1 == SET_V_R_1 && byte2 == SET_V_R_2) {
+				returnValue = BC_IS_SET_VR_COMMAND;
+			}
+		}
+		return returnValue;
+	}
+};
+
+#endif /* BCFRAME_H_ */
diff --git a/datalinklayer/CCSDSReturnValuesIF.h b/datalinklayer/CCSDSReturnValuesIF.h
index 054be9e7..805b6969 100644
--- a/datalinklayer/CCSDSReturnValuesIF.h
+++ b/datalinklayer/CCSDSReturnValuesIF.h
@@ -1,56 +1,56 @@
-/**
- * @file	CCSDSReturnValuesIF.h
- * @brief	This file defines the CCSDSReturnValuesIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef CCSDSRETURNVALUESIF_H_
-#define CCSDSRETURNVALUESIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- * This is a helper class to collect special return values that come up during CCSDS Handling.
- * @ingroup ccsds_handling
- */
-class CCSDSReturnValuesIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
-
-	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
-	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
-	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
-
-	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
-	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
-	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
-	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
-	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
-
-	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
-	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
-	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
-	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
-	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
-	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
-	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
-	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
-	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
-	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
-	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
-	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
-	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
-	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
-
-	virtual ~CCSDSReturnValuesIF() {
-	} //!< Empty virtual destructor
-};
-
-#endif /* CCSDSRETURNVALUESIF_H_ */
+/**
+ * @file	CCSDSReturnValuesIF.h
+ * @brief	This file defines the CCSDSReturnValuesIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef CCSDSRETURNVALUESIF_H_
+#define CCSDSRETURNVALUESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * This is a helper class to collect special return values that come up during CCSDS Handling.
+ * @ingroup ccsds_handling
+ */
+class CCSDSReturnValuesIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER_IF;	//!< Basic ID of the interface.
+
+	static const ReturnValue_t BC_IS_SET_VR_COMMAND = MAKE_RETURN_CODE( 0x01 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_IS_UNLOCK_COMMAND = MAKE_RETURN_CODE( 0x02 );	//!< A value to describe a BC frame.
+	static const ReturnValue_t BC_ILLEGAL_COMMAND = MAKE_RETURN_CODE( 0xB0 );//!< A value to describe an illegal BC frame.
+	static const ReturnValue_t BOARD_READING_NOT_FINISHED = MAKE_RETURN_CODE( 0xB1 );	//! The CCSDS Board is not yet finished reading, it requires another cycle.
+
+	static const ReturnValue_t NS_POSITIVE_W = MAKE_RETURN_CODE( 0xF0 );//!< NS is in the positive window
+	static const ReturnValue_t NS_NEGATIVE_W = MAKE_RETURN_CODE( 0xF1 );//!< NS is in the negative window
+	static const ReturnValue_t NS_LOCKOUT = MAKE_RETURN_CODE( 0xF2 );	//!< NS is in lockout state
+	static const ReturnValue_t FARM_IN_LOCKOUT = MAKE_RETURN_CODE( 0xF3 );//!< FARM-1 is currently in lockout state
+	static const ReturnValue_t FARM_IN_WAIT = MAKE_RETURN_CODE( 0xF4 );	//!< FARM-1 is currently in wait state
+
+	static const ReturnValue_t WRONG_SYMBOL = MAKE_RETURN_CODE( 0xE0 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t DOUBLE_START = MAKE_RETURN_CODE( 0xE1 );	//!< An error code in the FrameFinder.
+	static const ReturnValue_t START_SYMBOL_MISSED = MAKE_RETURN_CODE( 0xE2 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t END_WITHOUT_START = MAKE_RETURN_CODE( 0xE3 );//!< An error code in the FrameFinder.
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE( 0xE4 );//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT = MAKE_RETURN_CODE( 0xE5 );//!< An error code for a frame.
+	static const ReturnValue_t WRONG_TF_VERSION = MAKE_RETURN_CODE( 0xE6 );	//!< An error code for a frame.
+	static const ReturnValue_t WRONG_SPACECRAFT_ID = MAKE_RETURN_CODE( 0xE7 );//!< An error code for a frame.
+	static const ReturnValue_t NO_VALID_FRAME_TYPE = MAKE_RETURN_CODE( 0xE8 );//!< An error code for a frame.
+	static const ReturnValue_t CRC_FAILED = MAKE_RETURN_CODE( 0xE9 );//!< An error code for a frame.
+	static const ReturnValue_t VC_NOT_FOUND = MAKE_RETURN_CODE( 0xEA );	//!< An error code for a frame.
+	static const ReturnValue_t FORWARDING_FAILED = MAKE_RETURN_CODE( 0xEB );//!< An error code for a frame.
+	static const ReturnValue_t CONTENT_TOO_LARGE = MAKE_RETURN_CODE( 0xEC );//!< An error code for a frame.
+	static const ReturnValue_t RESIDUAL_DATA = MAKE_RETURN_CODE( 0xED );//!< An error code for a frame.
+	static const ReturnValue_t DATA_CORRUPTED = MAKE_RETURN_CODE( 0xEE );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_SEGMENTATION_FLAG = MAKE_RETURN_CODE( 0xEF );//!< An error code for a frame.
+	static const ReturnValue_t ILLEGAL_FLAG_COMBINATION = MAKE_RETURN_CODE( 0xD0 );	//!< An error code for a frame.
+	static const ReturnValue_t SHORTER_THAN_HEADER = MAKE_RETURN_CODE( 0xD1 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_BLOCKED_PACKET = MAKE_RETURN_CODE( 0xD2 );	//!< An error code for a frame.
+	static const ReturnValue_t TOO_SHORT_MAP_EXTRACTION = MAKE_RETURN_CODE( 0xD3 );	//!< An error code for a frame.
+
+	virtual ~CCSDSReturnValuesIF() {
+	} //!< Empty virtual destructor
+};
+
+#endif /* CCSDSRETURNVALUESIF_H_ */
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 53424e8a..dc435a2b 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -1,63 +1,63 @@
-/**
- * @file	Clcw.cpp
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/Clcw.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Clcw::Clcw() {
-	content.raw = 0;
-	content.status = STATUS_FIELD_DEFAULT;
-}
-
-Clcw::~Clcw() {
-}
-
-void Clcw::setVirtualChannel(uint8_t setChannel) {
-	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
-}
-
-void Clcw::setLockoutFlag(bool lockout) {
-	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
-}
-
-void Clcw::setWaitFlag(bool waitFlag) {
-	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
-}
-
-void Clcw::setRetransmitFlag(bool retransmitFlag) {
-	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
-}
-
-void Clcw::setFarmBCount(uint8_t count) {
-	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
-}
-
-void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
-	content.vRValue = vR;
-}
-
-uint32_t Clcw::getAsWhole() {
-	return content.raw;
-}
-
-void Clcw::setRFAvailable(bool rfAvailable) {
-	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
-}
-
-void Clcw::setBitLock(bool bitLock) {
-	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
-}
-
-void Clcw::print() {
-	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
-}
-
-void Clcw::setWhole(uint32_t rawClcw) {
-	content.raw = rawClcw;
-}
+/**
+ * @file	Clcw.cpp
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "Clcw.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Clcw::Clcw() {
+	content.raw = 0;
+	content.status = STATUS_FIELD_DEFAULT;
+}
+
+Clcw::~Clcw() {
+}
+
+void Clcw::setVirtualChannel(uint8_t setChannel) {
+	content.virtualChannelIdSpare = ((setChannel & 0x3F) << 2);
+}
+
+void Clcw::setLockoutFlag(bool lockout) {
+	content.flags = (content.flags & LOCKOUT_FLAG_MASK) | (lockout << LOCKOUT_FLAG_POSITION);
+}
+
+void Clcw::setWaitFlag(bool waitFlag) {
+	content.flags = (content.flags & WAIT_FLAG_MASK) | (waitFlag << WAIT_FLAG_POSITION);
+}
+
+void Clcw::setRetransmitFlag(bool retransmitFlag) {
+	content.flags = (content.flags & RETRANSMIT_FLAG_MASK) | (retransmitFlag << RETRANSMIT_FLAG_POSITION);
+}
+
+void Clcw::setFarmBCount(uint8_t count) {
+	content.flags = (content.flags & FARM_B_COUNT_MASK) | ((count & 0x03) << 1);
+}
+
+void Clcw::setReceiverFrameSequenceNumber(uint8_t vR) {
+	content.vRValue = vR;
+}
+
+uint32_t Clcw::getAsWhole() {
+	return content.raw;
+}
+
+void Clcw::setRFAvailable(bool rfAvailable) {
+	content.flags = (content.flags & NO_RF_AVIALABLE_MASK) | (!rfAvailable << NO_RF_AVIALABLE_POSITION);
+}
+
+void Clcw::setBitLock(bool bitLock) {
+	content.flags = (content.flags & NO_BIT_LOCK_MASK) | (!bitLock << NO_BIT_LOCK_POSITION);
+}
+
+void Clcw::print() {
+	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+}
+
+void Clcw::setWhole(uint32_t rawClcw) {
+	content.raw = rawClcw;
+}
diff --git a/datalinklayer/Clcw.h b/datalinklayer/Clcw.h
index 72ccd77a..8116d63b 100644
--- a/datalinklayer/Clcw.h
+++ b/datalinklayer/Clcw.h
@@ -1,66 +1,66 @@
-/**
- * @file	Clcw.h
- * @brief	This file defines the Clcw class.
- * @date	17.04.2013
- * @author	baetz
- */
-
-#ifndef CLCW_H_
-#define CLCW_H_
-
-#include "../datalinklayer/ClcwIF.h"
-/**
- * Small helper method to handle the Clcw values.
- * It has a content struct that manages the register and can be set externally.
- * @ingroup ccsds_handling
- */
-class Clcw : public ClcwIF {
-private:
-	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
-	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
-	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
-	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
-	/**
-	 * This is the data structure of the CLCW register.
-	 */
-	union clcwContent {
-		uint32_t raw;
-		struct {
-			uint8_t status;
-			uint8_t virtualChannelIdSpare;
-			uint8_t flags;
-			uint8_t vRValue;
-		};
-	};
-	clcwContent content;	//!< Represents the content of the register.
-public:
-	/**
-	 * The constructor sets everything to default values.
-	 */
-	Clcw();
-	/**
-	 * Nothing happens in the destructor.
-	 */
-	~Clcw();
-	void setVirtualChannel( uint8_t setChannel );
-	void setLockoutFlag( bool lockout );
-	void setWaitFlag( bool waitFlag );
-	void setRetransmitFlag( bool retransmitFlag );
-	void setFarmBCount( uint8_t count );
-	void setReceiverFrameSequenceNumber( uint8_t vR );
-	void setRFAvailable( bool rfAvailable );
-	void setBitLock( bool bitLock );
-	uint32_t getAsWhole();
-	void setWhole( uint32_t rawClcw );
-	void print();
-};
-
-#endif /* CLCW_H_ */
+/**
+ * @file	Clcw.h
+ * @brief	This file defines the Clcw class.
+ * @date	17.04.2013
+ * @author	baetz
+ */
+
+#ifndef CLCW_H_
+#define CLCW_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.
+ * @ingroup ccsds_handling
+ */
+class Clcw : public ClcwIF {
+private:
+	static const uint8_t STATUS_FIELD_DEFAULT = 0b00000001; //!< Default for the status field.
+	static const uint8_t NO_RF_AVIALABLE_POSITION = 7;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_BIT_LOCK_POSITION = 6;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t LOCKOUT_FLAG_POSITION = 5;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t WAIT_FLAG_POSITION = 4;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t RETRANSMIT_FLAG_POSITION = 3;	//!< Position of a flag in the register (starting with 0).
+	static const uint8_t NO_RF_AVIALABLE_MASK = 0xFF xor (1 << NO_RF_AVIALABLE_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t NO_BIT_LOCK_MASK = 0xFF xor (1 << NO_BIT_LOCK_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t LOCKOUT_FLAG_MASK = 0xFF xor (1 << LOCKOUT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t WAIT_FLAG_MASK = 0xFF xor (1 << WAIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t RETRANSMIT_FLAG_MASK = 0xFF xor (1 << RETRANSMIT_FLAG_POSITION);	//!< Mask for a flag in the register.
+	static const uint8_t FARM_B_COUNT_MASK = 0b11111001;	//!< Mask for a counter in the register.
+	/**
+	 * This is the data structure of the CLCW register.
+	 */
+	union clcwContent {
+		uint32_t raw;
+		struct {
+			uint8_t status;
+			uint8_t virtualChannelIdSpare;
+			uint8_t flags;
+			uint8_t vRValue;
+		};
+	};
+	clcwContent content;	//!< Represents the content of the register.
+public:
+	/**
+	 * The constructor sets everything to default values.
+	 */
+	Clcw();
+	/**
+	 * Nothing happens in the destructor.
+	 */
+	~Clcw();
+	void setVirtualChannel( uint8_t setChannel );
+	void setLockoutFlag( bool lockout );
+	void setWaitFlag( bool waitFlag );
+	void setRetransmitFlag( bool retransmitFlag );
+	void setFarmBCount( uint8_t count );
+	void setReceiverFrameSequenceNumber( uint8_t vR );
+	void setRFAvailable( bool rfAvailable );
+	void setBitLock( bool bitLock );
+	uint32_t getAsWhole();
+	void setWhole( uint32_t rawClcw );
+	void print();
+};
+
+#endif /* CLCW_H_ */
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 83fe1e61..75f2edda 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -1,139 +1,139 @@
-#include "../datalinklayer/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) :
-		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
-				NULL), startSequenceLength(set_start_sequence_length) {
-	//Nothing to do except from setting the values above.
-}
-
-DataLinkLayer::~DataLinkLayer() {
-
-}
-
-ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
-	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
-		return SHORTER_THAN_HEADER;
-	}
-	//Removing start sequence.
-	//SHOULDDO: Not implemented here.
-	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
-		frameBuffer++;
-	}
-	TcTransferFrame frame_candidate(frameBuffer);
-	this->currentFrame = frame_candidate; //should work with shallow copy.
-
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameValidationCheck() {
-	//Check TF_version number
-	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
-		return WRONG_TF_VERSION;
-	}
-	//Check SpaceCraft ID
-	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
-		return WRONG_SPACECRAFT_ID;
-	}
-	//Check other header limitations:
-	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//- Spares are zero
-	if (!this->currentFrame.spareIsZero()) {
-		return NO_VALID_FRAME_TYPE;
-	}
-	//Compare detected frame length with the one in the header
-	uint16_t length = currentFrame.getFullSize();
-	if (length > receivedDataLength) {
-		//Frame is too long or just right
-//		error << "frameValidationCheck: Too short.";
-//		currentFrame.print();
-		return TOO_SHORT;
-	}
-	if (USE_CRC) {
-		return this->frameCheckCRC();
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t DataLinkLayer::frameCheckCRC() {
-	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
-			this->currentFrame.getFullSize());
-	if (checkValue == 0) {
-		return RETURN_OK;
-	} else {
-		return CRC_FAILED;
-	}
-
-}
-
-ReturnValue_t DataLinkLayer::allFramesReception() {
-	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
-	if (status != RETURN_OK) {
-		return status;
-	}
-	return this->frameValidationCheck();
-}
-
-ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
-	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
-	return virtualChannelDemultiplexing();
-}
-
-ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
-	uint8_t vcId = currentFrame.getVirtualChannelId();
-	virtualChannelIterator iter = virtualChannels.find(vcId);
-	if (iter == virtualChannels.end()) {
-		//Do not report because passive board will get this error all the time.
-		return RETURN_OK;
-	} else {
-		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
-	}
-}
-
-ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
-	receivedDataLength = length;
-	ReturnValue_t status = allFramesReception();
-	if (status != RETURN_OK) {
-		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
-		         "Error code: " << std::hex << status << std::dec << std::endl;
-//		currentFrame.print();
-		return status;
-	} else {
-		return masterChannelDemultiplexing();
-	}
-}
-
-ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
-		VirtualChannelReceptionIF* object) {
-	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
-			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t DataLinkLayer::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
-	if ( virtualChannels.begin() != virtualChannels.end() ) {
-		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
-	} else {
-		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
-		return RETURN_FAILED;
-	}
-
-	for (virtualChannelIterator iterator = virtualChannels.begin();
-			iterator != virtualChannels.end(); iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-
-}
+#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) :
+		spacecraftId(set_scid), frameBuffer(set_frame_buffer), clcw(setClcw), receivedDataLength(0), currentFrame(
+				NULL), startSequenceLength(set_start_sequence_length) {
+	//Nothing to do except from setting the values above.
+}
+
+DataLinkLayer::~DataLinkLayer() {
+
+}
+
+ReturnValue_t DataLinkLayer::frameDelimitingAndFillRemoval() {
+	if ((receivedDataLength - startSequenceLength) < FRAME_PRIMARY_HEADER_LENGTH) {
+		return SHORTER_THAN_HEADER;
+	}
+	//Removing start sequence.
+	//SHOULDDO: Not implemented here.
+	while ( *frameBuffer == START_SEQUENCE_PATTERN ) {
+		frameBuffer++;
+	}
+	TcTransferFrame frame_candidate(frameBuffer);
+	this->currentFrame = frame_candidate; //should work with shallow copy.
+
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameValidationCheck() {
+	//Check TF_version number
+	if (this->currentFrame.getVersionNumber() != FRAME_VERSION_NUMBER_DEFAULT) {
+		return WRONG_TF_VERSION;
+	}
+	//Check SpaceCraft ID
+	if (this->currentFrame.getSpacecraftId() != this->spacecraftId) {
+		return WRONG_SPACECRAFT_ID;
+	}
+	//Check other header limitations:
+	if (!this->currentFrame.bypassFlagSet() && this->currentFrame.controlCommandFlagSet()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//- Spares are zero
+	if (!this->currentFrame.spareIsZero()) {
+		return NO_VALID_FRAME_TYPE;
+	}
+	//Compare detected frame length with the one in the header
+	uint16_t length = currentFrame.getFullSize();
+	if (length > receivedDataLength) {
+		//Frame is too long or just right
+//		error << "frameValidationCheck: Too short.";
+//		currentFrame.print();
+		return TOO_SHORT;
+	}
+	if (USE_CRC) {
+		return this->frameCheckCRC();
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t DataLinkLayer::frameCheckCRC() {
+	uint16_t checkValue = CRC::crc16ccitt(this->currentFrame.getFullFrame(),
+			this->currentFrame.getFullSize());
+	if (checkValue == 0) {
+		return RETURN_OK;
+	} else {
+		return CRC_FAILED;
+	}
+
+}
+
+ReturnValue_t DataLinkLayer::allFramesReception() {
+	ReturnValue_t status = this->frameDelimitingAndFillRemoval();
+	if (status != RETURN_OK) {
+		return status;
+	}
+	return this->frameValidationCheck();
+}
+
+ReturnValue_t DataLinkLayer::masterChannelDemultiplexing() {
+	//Nothing to do at present. Ideally, there would be a map of MCID's identifying which MC to use.
+	return virtualChannelDemultiplexing();
+}
+
+ReturnValue_t DataLinkLayer::virtualChannelDemultiplexing() {
+	uint8_t vcId = currentFrame.getVirtualChannelId();
+	virtualChannelIterator iter = virtualChannels.find(vcId);
+	if (iter == virtualChannels.end()) {
+		//Do not report because passive board will get this error all the time.
+		return RETURN_OK;
+	} else {
+		return (iter->second)->frameAcceptanceAndReportingMechanism(&currentFrame, clcw);
+	}
+}
+
+ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
+	receivedDataLength = length;
+	ReturnValue_t status = allFramesReception();
+	if (status != RETURN_OK) {
+		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
+		         "Error code: " << std::hex << status << std::dec << std::endl;
+//		currentFrame.print();
+		return status;
+	} else {
+		return masterChannelDemultiplexing();
+	}
+}
+
+ReturnValue_t DataLinkLayer::addVirtualChannel(uint8_t virtualChannelId,
+		VirtualChannelReceptionIF* object) {
+	std::pair<virtualChannelIterator, bool> returnValue = virtualChannels.insert(
+			std::pair<uint8_t, VirtualChannelReceptionIF*>(virtualChannelId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t DataLinkLayer::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	//Set Virtual Channel ID to first virtual channel instance in this DataLinkLayer instance to avoid faulty information (e.g. 0) in the VCID.
+	if ( virtualChannels.begin() != virtualChannels.end() ) {
+		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
+	} else {
+		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+		return RETURN_FAILED;
+	}
+
+	for (virtualChannelIterator iterator = virtualChannels.begin();
+			iterator != virtualChannels.end(); iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+
+}
diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index cf5cf42e..5a900099 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -1,112 +1,112 @@
-#ifndef DATALINKLAYER_H_
-#define DATALINKLAYER_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReceptionIF.h"
-#include "../events/Event.h"
-#include <map>
-
-
-class VirtualChannelReception;
-/**
- * A complete representation of the CCSDS Data Link Layer.
- * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
- * document. It is configured to handle a VC Demultiplexing function. All reception
- * steps are performed.
- */
-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
-	/**
-	 * The Constructor sets the passed parameters and nothing else.
-	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
-	 * @param setClcw	The CLCW class to work on when returning CLCW information.
-	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
-	 * @param set_scid	The SCID to operate on.
-	 */
-	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
-	/**
-	 * Empty virtual destructor.
-	 */
-	~DataLinkLayer();
-	/**
-	 * This method tries to process a frame that is placed in #frameBuffer.
-	 * The procedures described in the Standard are performed.
-	 * @param length	Length of the incoming frame candidate.
-	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
-	 */
-	ReturnValue_t processFrame( uint16_t length );
-	/**
-	 * Configuration method to add a new TC Virtual Channel.
-	 * Shall only be called during initialization. As soon as the method was called, the layer can
-	 * handle Frames directed to this VC.
-	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
-	 * @param object	Reference to the object that handles the Frame.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
-	/**
-	 * The initialization method calls the @c initialize routine of all virtual channels.
-	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
-	 */
-	ReturnValue_t initialize();
-private:
-	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
-	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
-	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
-	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
-	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
-	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
-	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
-	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
-	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
-	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
-	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
-	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
-	/**
-	 * Method that performs all possible frame validity checks (as specified).
-	 * @return	Various error codes or @c RETURN_OK on success.
-	 */
-	ReturnValue_t frameValidationCheck();
-	/**
-	 * First method to call.
-	 * Removes start sequence bytes and checks if the complete frame was received.
-	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
-	 * @return @c RETURN_OK or @c TOO_SHORT.
-	 */
-	ReturnValue_t frameDelimitingAndFillRemoval();
-	/**
-	 * Small helper method to check the CRC of the Frame.
-	 * @return @c RETURN_OK or @c CRC_FAILED.
-	 */
-	ReturnValue_t frameCheckCRC();
-	/**
-	 * Method that groups the reception process of all Frames.
-	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
-	 * @return The return codes of the sub calls.
-	 */
-	ReturnValue_t allFramesReception();
-	/**
-	 * Dummy method for master channel demultiplexing.
-	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
-	 * @return	The return codes of #virtualChannelDemultiplexing.
-	 */
-	ReturnValue_t masterChannelDemultiplexing();
-	/**
-	 * Method to demultiplex the Frames to Virtual Channels (VC's).
-	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
-	 * #frameAcceptanceAndReportingMechanism method, if found.
-	 * @return The higher method codes or @c VC_NOT_FOUND.
-	 */
-	ReturnValue_t virtualChannelDemultiplexing();
-};
-
-#endif /* DATALINKLAYER_H_ */
+#ifndef DATALINKLAYER_H_
+#define DATALINKLAYER_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReceptionIF.h"
+#include "../events/Event.h"
+#include <map>
+
+
+class VirtualChannelReception;
+/**
+ * A complete representation of the CCSDS Data Link Layer.
+ * The operations of this layer are defined in the CCSDS TC Space Data Link Protocol
+ * document. It is configured to handle a VC Demultiplexing function. All reception
+ * steps are performed.
+ */
+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
+	/**
+	 * The Constructor sets the passed parameters and nothing else.
+	 * @param set_frame_buffer The buffer in which incoming frame candidates are stored.
+	 * @param setClcw	The CLCW class to work on when returning CLCW information.
+	 * @param set_start_sequence_length	Length of the Start sequence in front of every TC Transfer Frame.
+	 * @param set_scid	The SCID to operate on.
+	 */
+	DataLinkLayer( uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid );
+	/**
+	 * Empty virtual destructor.
+	 */
+	~DataLinkLayer();
+	/**
+	 * This method tries to process a frame that is placed in #frameBuffer.
+	 * The procedures described in the Standard are performed.
+	 * @param length	Length of the incoming frame candidate.
+	 * @return	@c RETURN_OK on successful handling, otherwise the return codes of the higher methods.
+	 */
+	ReturnValue_t processFrame( uint16_t length );
+	/**
+	 * Configuration method to add a new TC Virtual Channel.
+	 * Shall only be called during initialization. As soon as the method was called, the layer can
+	 * handle Frames directed to this VC.
+	 * @param virtualChannelId	Id of the VC. Shall be smaller than 64.
+	 * @param object	Reference to the object that handles the Frame.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addVirtualChannel( uint8_t virtualChannelId, VirtualChannelReceptionIF* object );
+	/**
+	 * The initialization method calls the @c initialize routine of all virtual channels.
+	 * @return The return code of the first failed VC initialization or @c RETURN_OK.
+	 */
+	ReturnValue_t initialize();
+private:
+	typedef std::map<uint8_t, VirtualChannelReceptionIF*>::iterator virtualChannelIterator; //!< Typedef to simplify handling the #virtualChannels map.
+	static const uint8_t FRAME_VERSION_NUMBER_DEFAULT = 0x00;	//!< Constant for the default value of Frame Version Numbers.
+	static const uint8_t FRAME_PRIMARY_HEADER_LENGTH = 5;	//!< Length of the frame's primary header.
+	static const uint8_t START_SEQUENCE_PATTERN = 0x00; //!< The start sequence pattern which might be with the frame.
+	static const bool USE_CRC = true;	//!< A global, so called "Managed Parameter" that identifies if incoming frames have CRC's or not.
+	uint16_t spacecraftId;	//!< The Space Craft Identifier (SCID) configured.
+	uint8_t* frameBuffer;	//!< A pointer to point to the current incoming frame.
+	ClcwIF* clcw;	//!< Pointer to store the CLCW to work on.
+	uint16_t receivedDataLength;	//!< Stores the length of the currently processed frame.
+	TcTransferFrame currentFrame;	//!< Stores a more convenient access to the current frame.
+	uint8_t startSequenceLength;	//!< Configured length of the start sequence. Maybe this must be done more variable.
+	std::map<uint8_t, VirtualChannelReceptionIF*> virtualChannels;	//!< Map of all virtual channels assigned.
+	/**
+	 * Method that performs all possible frame validity checks (as specified).
+	 * @return	Various error codes or @c RETURN_OK on success.
+	 */
+	ReturnValue_t frameValidationCheck();
+	/**
+	 * First method to call.
+	 * Removes start sequence bytes and checks if the complete frame was received.
+	 * SHOULDDO: Maybe handling the start sequence must be done more variable.
+	 * @return @c RETURN_OK or @c TOO_SHORT.
+	 */
+	ReturnValue_t frameDelimitingAndFillRemoval();
+	/**
+	 * Small helper method to check the CRC of the Frame.
+	 * @return @c RETURN_OK or @c CRC_FAILED.
+	 */
+	ReturnValue_t frameCheckCRC();
+	/**
+	 * Method that groups the reception process of all Frames.
+	 * Calls #frameDelimitingAndFillRemoval and #frameValidationCheck.
+	 * @return The return codes of the sub calls.
+	 */
+	ReturnValue_t allFramesReception();
+	/**
+	 * Dummy method for master channel demultiplexing.
+	 * As there's only one Master Channel here, the method calls #virtualChannelDemultiplexing.
+	 * @return	The return codes of #virtualChannelDemultiplexing.
+	 */
+	ReturnValue_t masterChannelDemultiplexing();
+	/**
+	 * Method to demultiplex the Frames to Virtual Channels (VC's).
+	 * Looks up the requested VC in #virtualChannels and forwards the Frame to its
+	 * #frameAcceptanceAndReportingMechanism method, if found.
+	 * @return The higher method codes or @c VC_NOT_FOUND.
+	 */
+	ReturnValue_t virtualChannelDemultiplexing();
+};
+
+#endif /* DATALINKLAYER_H_ */
diff --git a/datalinklayer/Farm1StateIF.h b/datalinklayer/Farm1StateIF.h
index ef02d891..71794d75 100644
--- a/datalinklayer/Farm1StateIF.h
+++ b/datalinklayer/Farm1StateIF.h
@@ -1,54 +1,54 @@
-/**
- * @file	Farm1StateIF.h
- * @brief	This file defines the Farm1StateIF class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEIF_H_
-#define FARM1STATEIF_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-class VirtualChannelReception;
-class TcTransferFrame;
-class ClcwIF;
-
-/**
- * This is the interface for states of the FARM-1 state machine.
- * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
- * of the state pattern.
- */
-class Farm1StateIF : public CCSDSReturnValuesIF {
-public:
-	/**
-	 * A method that shall handle an incoming frame as AD Frame.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
-	/**
-	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
-	 * 			Otherwise, an appropriate return value or error code shall be generated.
-	 */
-	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~Farm1StateIF() {
-
-	}
-};
-
-#endif /* FARM1STATEIF_H_ */
+/**
+ * @file	Farm1StateIF.h
+ * @brief	This file defines the Farm1StateIF class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEIF_H_
+#define FARM1STATEIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+class VirtualChannelReception;
+class TcTransferFrame;
+class ClcwIF;
+
+/**
+ * This is the interface for states of the FARM-1 state machine.
+ * Classes implementing this interface can be used as FARM-1 states. This is a simple implementation
+ * of the state pattern.
+ */
+class Farm1StateIF : public CCSDSReturnValuesIF {
+public:
+	/**
+	 * A method that shall handle an incoming frame as AD Frame.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Unlock frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw ) = 0;
+	/**
+	 * This method shall handle frames that have been successfully identified as BC Set VR frames.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	If forwarding to a MAP Channel is required, the return value shall be #FRAME_OK.
+	 * 			Otherwise, an appropriate return value or error code shall be generated.
+	 */
+	virtual ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~Farm1StateIF() {
+
+	}
+};
+
+#endif /* FARM1STATEIF_H_ */
diff --git a/datalinklayer/Farm1StateLockout.cpp b/datalinklayer/Farm1StateLockout.cpp
index f8dca9fd..1b339a85 100644
--- a/datalinklayer/Farm1StateLockout.cpp
+++ b/datalinklayer/Farm1StateLockout.cpp
@@ -1,35 +1,35 @@
-/**
- * @file	Farm1StateLockout.cpp
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateLockout.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	return FARM_IN_LOCKOUT;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setLockoutFlag( false );
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
-		uint8_t vr) {
-	myVC->farmBCounter++;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateLockout.cpp
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "ClcwIF.h"
+#include "Farm1StateLockout.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateLockout::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	return FARM_IN_LOCKOUT;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setLockoutFlag( false );
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateLockout::handleBCSetVrCommand(ClcwIF* clcw,
+		uint8_t vr) {
+	myVC->farmBCounter++;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateLockout.h b/datalinklayer/Farm1StateLockout.h
index 9e3713cc..63cdc4d2 100644
--- a/datalinklayer/Farm1StateLockout.h
+++ b/datalinklayer/Farm1StateLockout.h
@@ -1,59 +1,59 @@
-/**
- * @file	Farm1StateLockout.h
- * @brief	This file defines the Farm1StateLockout class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATELOCKOUT_H_
-#define FARM1STATELOCKOUT_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Lockout" State.
- * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
- * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
- * command is required.
- */
-class Farm1StateLockout : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateLockout( VirtualChannelReception* setMyVC );
-	/**
-	 * All AD Frames are rejected with FARM_IN_LOCKOUT
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return FARM_IN_LOCKOUT
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATELOCKOUT_H_ */
+/**
+ * @file	Farm1StateLockout.h
+ * @brief	This file defines the Farm1StateLockout class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATELOCKOUT_H_
+#define FARM1STATELOCKOUT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Lockout" State.
+ * The Lockout state is reached if the received Transfer Frame Sequence Number is completely wrong
+ * (i.e. within the Lockout Window). No AD Frames are forwarded. To leave the State, a BC Unlock
+ * command is required.
+ */
+class Farm1StateLockout : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateLockout( VirtualChannelReception* setMyVC );
+	/**
+	 * All AD Frames are rejected with FARM_IN_LOCKOUT
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return FARM_IN_LOCKOUT
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * The V(r) value is not set in Lockout State, even though the Command itself is accepted.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATELOCKOUT_H_ */
diff --git a/datalinklayer/Farm1StateOpen.cpp b/datalinklayer/Farm1StateOpen.cpp
index b7837013..61c0997f 100644
--- a/datalinklayer/Farm1StateOpen.cpp
+++ b/datalinklayer/Farm1StateOpen.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	Farm1StateOpen.cpp
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateOpen.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-
-Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if (diff == 0 ) {
-		myVC->vR++;
-		clcw->setRetransmitFlag(false);
-		return RETURN_OK;
-	} else if (diff < myVC->positiveWindow && diff > 0 ) {
-		clcw->setRetransmitFlag(true);
-		return NS_POSITIVE_W;
-	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
-		return NS_NEGATIVE_W;
-	} else {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-		return NS_LOCKOUT;
-	}
-}
-
-ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateOpen.cpp
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+
+
+#include "ClcwIF.h"
+#include "Farm1StateOpen.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+
+Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateOpen::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if (diff == 0 ) {
+		myVC->vR++;
+		clcw->setRetransmitFlag(false);
+		return RETURN_OK;
+	} else if (diff < myVC->positiveWindow && diff > 0 ) {
+		clcw->setRetransmitFlag(true);
+		return NS_POSITIVE_W;
+	} else if (diff < 0 && diff >= -myVC->negativeWindow) {
+		return NS_NEGATIVE_W;
+	} else {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+		return NS_LOCKOUT;
+	}
+}
+
+ReturnValue_t Farm1StateOpen::handleBCUnlockCommand( ClcwIF* clcw ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateOpen::handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr ) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateOpen.h b/datalinklayer/Farm1StateOpen.h
index ebc3b333..3b3a2604 100644
--- a/datalinklayer/Farm1StateOpen.h
+++ b/datalinklayer/Farm1StateOpen.h
@@ -1,62 +1,62 @@
-/**
- * @file	Farm1StateOpen.h
- * @brief	This file defines the Farm1StateOpen class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEOPEN_H_
-#define FARM1STATEOPEN_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Open" State.
- * The Open state is the state of normal operation. It handles all types of frames,
- * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
- * State reacts as specified.
- */
-class Farm1StateOpen : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateOpen( VirtualChannelReception* setMyVC );
-	/**
-	 * Method to check the validity of AD Frames.
-	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
-	 * change to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
-	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State does not change.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEOPEN_H_ */
+/**
+ * @file	Farm1StateOpen.h
+ * @brief	This file defines the Farm1StateOpen class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEOPEN_H_
+#define FARM1STATEOPEN_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Open" State.
+ * The Open state is the state of normal operation. It handles all types of frames,
+ * including AD Frames. If a wrong Frame Sequence Number is detected in an AD Frame, the
+ * State reacts as specified.
+ */
+class Farm1StateOpen : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateOpen( VirtualChannelReception* setMyVC );
+	/**
+	 * Method to check the validity of AD Frames.
+	 * It checks the Frame Sequence Number and reacts as specified in the standard. The state may
+	 * change to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return If the Sequence Number is ok, it returns #RETURN_OK. Otherwise either #NS_POSITIVE_W,
+	 * 			#NS_NEGATIVE_W or NS_LOCKOUT is returned.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State does not change.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEOPEN_H_ */
diff --git a/datalinklayer/Farm1StateWait.cpp b/datalinklayer/Farm1StateWait.cpp
index c3cc85de..9001e1f5 100644
--- a/datalinklayer/Farm1StateWait.cpp
+++ b/datalinklayer/Farm1StateWait.cpp
@@ -1,43 +1,43 @@
-/**
- * @file	Farm1StateWait.cpp
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/Farm1StateWait.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-
-Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
-}
-
-ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-
-	int8_t diff = frame->getSequenceNumber() - myVC->vR;
-	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
-		clcw->setLockoutFlag(true);
-		myVC->currentState = &(myVC->lockoutState);
-	}
-	return FARM_IN_WAIT;
-}
-
-ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
-	myVC->farmBCounter++;
-	clcw->setRetransmitFlag(false);
-	clcw->setWaitFlag( false );
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_UNLOCK_COMMAND;
-}
-
-ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
-	myVC->farmBCounter++;
-	clcw->setWaitFlag( false );
-	clcw->setRetransmitFlag(false);
-	myVC->vR = vr;
-	myVC->currentState = &(myVC->openState);
-	return BC_IS_SET_VR_COMMAND;
-}
+/**
+ * @file	Farm1StateWait.cpp
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+
+#include "ClcwIF.h"
+#include "Farm1StateWait.h"
+#include "TcTransferFrame.h"
+#include "VirtualChannelReception.h"
+
+Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) {
+}
+
+ReturnValue_t Farm1StateWait::handleADFrame(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+
+	int8_t diff = frame->getSequenceNumber() - myVC->vR;
+	if ( diff < -myVC->negativeWindow || diff >= myVC->positiveWindow ) {
+		clcw->setLockoutFlag(true);
+		myVC->currentState = &(myVC->lockoutState);
+	}
+	return FARM_IN_WAIT;
+}
+
+ReturnValue_t Farm1StateWait::handleBCUnlockCommand(ClcwIF* clcw) {
+	myVC->farmBCounter++;
+	clcw->setRetransmitFlag(false);
+	clcw->setWaitFlag( false );
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_UNLOCK_COMMAND;
+}
+
+ReturnValue_t Farm1StateWait::handleBCSetVrCommand(ClcwIF* clcw, uint8_t vr) {
+	myVC->farmBCounter++;
+	clcw->setWaitFlag( false );
+	clcw->setRetransmitFlag(false);
+	myVC->vR = vr;
+	myVC->currentState = &(myVC->openState);
+	return BC_IS_SET_VR_COMMAND;
+}
diff --git a/datalinklayer/Farm1StateWait.h b/datalinklayer/Farm1StateWait.h
index aa456664..877c36c2 100644
--- a/datalinklayer/Farm1StateWait.h
+++ b/datalinklayer/Farm1StateWait.h
@@ -1,58 +1,58 @@
-/**
- * @file	Farm1StateWait.h
- * @brief	This file defines the Farm1StateWait class.
- * @date	24.04.2013
- * @author	baetz
- */
-
-#ifndef FARM1STATEWAIT_H_
-#define FARM1STATEWAIT_H_
-
-#include "../datalinklayer/Farm1StateIF.h"
-
-/**
- * This class represents the FARM-1 "Wait" State.
- * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
- * for a certain period. Currently, it is not in use.
- */
-class Farm1StateWait : public Farm1StateIF {
-private:
-	/**
-	 * This is a reference to the "owner" class the State works on.
-	 */
-	VirtualChannelReception* myVC;
-public:
-	/**
-	 * The default constructor if the State.
-	 * Sets the "owner" of the State.
-	 * @param setMyVC	The "owner" class.
-	 */
-	Farm1StateWait( VirtualChannelReception* setMyVC );
-	/**
-	 * AD Frames are always discarded.
-	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
-	 * @param frame	The frame to handle.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	Always returns FARM_IN_WAIT.
-	 */
-	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * State changes to Farm1StateOpen.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
-	/**
-	 * These commands are handled as specified.
-	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
-	 * @param vr The V(r) value found in the frame.
-	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
-	 * 			is returned.
-	 */
-	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
-};
-
-
-#endif /* FARM1STATEWAIT_H_ */
+/**
+ * @file	Farm1StateWait.h
+ * @brief	This file defines the Farm1StateWait class.
+ * @date	24.04.2013
+ * @author	baetz
+ */
+
+#ifndef FARM1STATEWAIT_H_
+#define FARM1STATEWAIT_H_
+
+#include "Farm1StateIF.h"
+
+/**
+ * This class represents the FARM-1 "Wait" State.
+ * The Wait state is reached if higher level procedures inform the FARM-1 Machine to wait
+ * for a certain period. Currently, it is not in use.
+ */
+class Farm1StateWait : public Farm1StateIF {
+private:
+	/**
+	 * This is a reference to the "owner" class the State works on.
+	 */
+	VirtualChannelReception* myVC;
+public:
+	/**
+	 * The default constructor if the State.
+	 * Sets the "owner" of the State.
+	 * @param setMyVC	The "owner" class.
+	 */
+	Farm1StateWait( VirtualChannelReception* setMyVC );
+	/**
+	 * AD Frames are always discarded.
+	 * If the frame number is in the lockout window, the state changes to Farm1StateLockout.
+	 * @param frame	The frame to handle.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	Always returns FARM_IN_WAIT.
+	 */
+	ReturnValue_t handleADFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * State changes to Farm1StateOpen.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_UNLOCK_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCUnlockCommand( ClcwIF* clcw );
+	/**
+	 * These commands are handled as specified.
+	 * @param clcw	Any changes to the CLCW shall be done with the help of this interface.
+	 * @param vr The V(r) value found in the frame.
+	 * @return	As the frame needs no forwarding to a MAP Channel, #BC_IS_SET_VR_COMMAND
+	 * 			is returned.
+	 */
+	ReturnValue_t handleBCSetVrCommand( ClcwIF* clcw, uint8_t vr );
+};
+
+
+#endif /* FARM1STATEWAIT_H_ */
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index a14bcefe..cb12b321 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,154 +1,154 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/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 <string.h>
-
-MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
-		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
-		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
-		packetStore(nullptr), tcQueueId(MessageQueueMessageIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-}
-
-ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
-	uint8_t segmentationFlag = frame->getSequenceFlags();
-	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
-	switch (segmentationFlag) {
-	case NO_SEGMENTATION:
-		status = unpackBlockingPackets(frame);
-		break;
-	case FIRST_PORTION:
-		packetLength = frame->getDataLength();
-		if (packetLength <= MAX_PACKET_SIZE) {
-			memcpy(packetBuffer, frame->getDataField(), packetLength);
-			bufferPosition = &packetBuffer[packetLength];
-			status = RETURN_OK;
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-					<< packetLength << std::endl;
-			clearBuffers();
-			status = CONTENT_TOO_LARGE;
-		}
-		break;
-	case CONTINUING_PORTION:
-	case LAST_PORTION:
-		if (lastSegmentationFlag == FIRST_PORTION
-				|| lastSegmentationFlag == CONTINUING_PORTION) {
-			packetLength += frame->getDataLength();
-			if (packetLength <= MAX_PACKET_SIZE) {
-				memcpy(bufferPosition, frame->getDataField(),
-						frame->getDataLength());
-				bufferPosition = &packetBuffer[packetLength];
-				if (segmentationFlag == LAST_PORTION) {
-					status = sendCompletePacket(packetBuffer, packetLength);
-					clearBuffers();
-				}
-				status = RETURN_OK;
-			} else {
-				sif::error
-						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
-						<< packetLength << std::endl;
-				clearBuffers();
-				status = CONTENT_TOO_LARGE;
-			}
-		} else {
-			sif::error
-					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
-					<< (int) lastSegmentationFlag << std::endl;
-			clearBuffers();
-			status = ILLEGAL_SEGMENTATION_FLAG;
-		}
-		break;
-	default:
-		sif::error
-				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
-				<< (int) segmentationFlag << std::endl;
-		clearBuffers();
-		status = DATA_CORRUPTED;
-		break;
-	}
-	lastSegmentationFlag = segmentationFlag;
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
-		TcTransferFrame* frame) {
-	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
-	uint32_t totalLength = frame->getDataLength();
-	if (totalLength > MAX_PACKET_SIZE)
-		return CONTENT_TOO_LARGE;
-	uint8_t* position = frame->getDataField();
-	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
-		SpacePacketBase packet(position);
-		uint32_t packetSize = packet.getFullSize();
-		if (packetSize <= totalLength) {
-			status = sendCompletePacket(packet.getWholeData(),
-					packet.getFullSize());
-			totalLength -= packet.getFullSize();
-			position += packet.getFullSize();
-			status = RETURN_OK;
-		} else {
-			status = DATA_CORRUPTED;
-			totalLength = 0;
-		}
-	}
-	if (totalLength > 0) {
-		status = RESIDUAL_DATA;
-	}
-	return status;
-}
-
-ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
-		uint32_t size) {
-	store_address_t store_id;
-	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
-	if (status == RETURN_OK) {
-		TmTcMessage message(store_id);
-		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
-	}
-	return status;
-}
-
-void MapPacketExtraction::clearBuffers() {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
-	bufferPosition = packetBuffer;
-	packetLength = 0;
-	lastSegmentationFlag = NO_SEGMENTATION;
-}
-
-ReturnValue_t MapPacketExtraction::initialize() {
-	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	AcceptsTelecommandsIF* distributor = objectManager->get<
-			AcceptsTelecommandsIF>(packetDestination);
-	if ((packetStore != NULL) && (distributor != NULL)) {
-		tcQueueId = distributor->getRequestQueue();
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-void MapPacketExtraction::printPacketBuffer(void) {
-	sif::debug << "DLL: packet_buffer contains: " << std::endl;
-	for (uint32_t i = 0; i < this->packetLength; ++i) {
-		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
-				<< (uint16_t) this->packetBuffer[i] << std::endl;
-	}
-}
-
-uint8_t MapPacketExtraction::getMapId() const {
-	return mapId;
-}
+/**
+ * @file	MapPacketExtraction.cpp
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#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 <string.h>
+
+MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
+		object_id_t setPacketDestination) :
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
+				packetBuffer), packetDestination(setPacketDestination), packetStore(
+				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+}
+
+ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
+	uint8_t segmentationFlag = frame->getSequenceFlags();
+	ReturnValue_t status = TOO_SHORT_MAP_EXTRACTION;
+	switch (segmentationFlag) {
+	case NO_SEGMENTATION:
+		status = unpackBlockingPackets(frame);
+		break;
+	case FIRST_PORTION:
+		packetLength = frame->getDataLength();
+		if (packetLength <= MAX_PACKET_SIZE) {
+			memcpy(packetBuffer, frame->getDataField(), packetLength);
+			bufferPosition = &packetBuffer[packetLength];
+			status = RETURN_OK;
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+					<< packetLength << std::endl;
+			clearBuffers();
+			status = CONTENT_TOO_LARGE;
+		}
+		break;
+	case CONTINUING_PORTION:
+	case LAST_PORTION:
+		if (lastSegmentationFlag == FIRST_PORTION
+				|| lastSegmentationFlag == CONTINUING_PORTION) {
+			packetLength += frame->getDataLength();
+			if (packetLength <= MAX_PACKET_SIZE) {
+				memcpy(bufferPosition, frame->getDataField(),
+						frame->getDataLength());
+				bufferPosition = &packetBuffer[packetLength];
+				if (segmentationFlag == LAST_PORTION) {
+					status = sendCompletePacket(packetBuffer, packetLength);
+					clearBuffers();
+				}
+				status = RETURN_OK;
+			} else {
+				sif::error
+						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
+						<< packetLength << std::endl;
+				clearBuffers();
+				status = CONTENT_TOO_LARGE;
+			}
+		} else {
+			sif::error
+					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
+					<< (int) lastSegmentationFlag << std::endl;
+			clearBuffers();
+			status = ILLEGAL_SEGMENTATION_FLAG;
+		}
+		break;
+	default:
+		sif::error
+				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
+				<< (int) segmentationFlag << std::endl;
+		clearBuffers();
+		status = DATA_CORRUPTED;
+		break;
+	}
+	lastSegmentationFlag = segmentationFlag;
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::unpackBlockingPackets(
+		TcTransferFrame* frame) {
+	ReturnValue_t status = TOO_SHORT_BLOCKED_PACKET;
+	uint32_t totalLength = frame->getDataLength();
+	if (totalLength > MAX_PACKET_SIZE)
+		return CONTENT_TOO_LARGE;
+	uint8_t* position = frame->getDataField();
+	while ((totalLength > SpacePacketBase::MINIMUM_SIZE)) {
+		SpacePacketBase packet(position);
+		uint32_t packetSize = packet.getFullSize();
+		if (packetSize <= totalLength) {
+			status = sendCompletePacket(packet.getWholeData(),
+					packet.getFullSize());
+			totalLength -= packet.getFullSize();
+			position += packet.getFullSize();
+			status = RETURN_OK;
+		} else {
+			status = DATA_CORRUPTED;
+			totalLength = 0;
+		}
+	}
+	if (totalLength > 0) {
+		status = RESIDUAL_DATA;
+	}
+	return status;
+}
+
+ReturnValue_t MapPacketExtraction::sendCompletePacket(uint8_t* data,
+		uint32_t size) {
+	store_address_t store_id;
+	ReturnValue_t status = this->packetStore->addData(&store_id, data, size);
+	if (status == RETURN_OK) {
+		TmTcMessage message(store_id);
+		status = MessageQueueSenderIF::sendMessage(tcQueueId,&message);
+	}
+	return status;
+}
+
+void MapPacketExtraction::clearBuffers() {
+	memset(packetBuffer, 0, sizeof(packetBuffer));
+	bufferPosition = packetBuffer;
+	packetLength = 0;
+	lastSegmentationFlag = NO_SEGMENTATION;
+}
+
+ReturnValue_t MapPacketExtraction::initialize() {
+	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	AcceptsTelecommandsIF* distributor = objectManager->get<
+			AcceptsTelecommandsIF>(packetDestination);
+	if ((packetStore != NULL) && (distributor != NULL)) {
+		tcQueueId = distributor->getRequestQueue();
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+void MapPacketExtraction::printPacketBuffer(void) {
+	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+	for (uint32_t i = 0; i < this->packetLength; ++i) {
+		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
+				<< (uint16_t) this->packetBuffer[i] << std::endl;
+	}
+}
+
+uint8_t MapPacketExtraction::getMapId() const {
+	return mapId;
+}
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index cb09c27f..507f13db 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,78 +1,78 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
-
-#include "../datalinklayer/MapPacketExtractionIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class StorageManagerIF;
-
-/**
- * Implementation of a MAP Packet Extraction class.
- * 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.
- */
-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.
-	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.
-	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
-	/**
-	 * Debug method to print the packet Buffer's content.
-	 */
-	void printPacketBuffer();
-	/**
-	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
-	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
-	 * @param frame	The TC Transfer Frame to work on.
-	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
-	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
-	 */
-	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
-	/**
-	 * Helper method to forward a complete packet to the OBSW.
-	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
-	 * @param size	Complete total size of the packet.
-	 * @return	Return Code of the Packet Store or the Message Queue.
-	 */
-	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
-	/**
-	 * Helper method to reset the internal buffer.
-	 */
-	void clearBuffers();
-public:
-	/**
-	 * Default constructor.
-	 * Members are set to default values.
-	 * @param setMapId	The MAP ID of the instance.
-	 */
-	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
-	ReturnValue_t extractPackets(TcTransferFrame* frame);
-	/**
-	 * The #packetStore and the default destination of #tcQueue are initialized here.
-	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter.
-	 * @return The MAP ID of this instance.
-	 */
-	uint8_t getMapId() const;
-};
-
-#endif /* MAPPACKETEXTRACTION_H_ */
+/**
+ * @file	MapPacketExtraction.h
+ * @brief	This file defines the MapPacketExtraction class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTION_H_
+#define MAPPACKETEXTRACTION_H_
+
+#include "MapPacketExtractionIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class StorageManagerIF;
+
+/**
+ * Implementation of a MAP Packet Extraction class.
+ * 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.
+ */
+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.
+	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.
+	MessageQueueId_t tcQueueId;		//!< QueueId to send found packets to the distributor.
+	/**
+	 * Debug method to print the packet Buffer's content.
+	 */
+	void printPacketBuffer();
+	/**
+	 * Method that is called if the segmentation flag is @c NO_SEGMENTATION.
+	 * The method extracts one or more packets within the frame and forwards them to the OBSW.
+	 * @param frame	The TC Transfer Frame to work on.
+	 * @return	@c RETURN_OK if all Packets were extracted. If something is entirely wrong,
+	 * 	 @c DATA_CORRUPTED is returned, if some bytes are left over @c RESIDUAL_DATA.
+	 */
+	ReturnValue_t unpackBlockingPackets(TcTransferFrame* frame);
+	/**
+	 * Helper method to forward a complete packet to the OBSW.
+	 * @param data	Pointer to the data, either directly from the frame or from the packetBuffer.
+	 * @param size	Complete total size of the packet.
+	 * @return	Return Code of the Packet Store or the Message Queue.
+	 */
+	ReturnValue_t sendCompletePacket( uint8_t* data, uint32_t size );
+	/**
+	 * Helper method to reset the internal buffer.
+	 */
+	void clearBuffers();
+public:
+	/**
+	 * Default constructor.
+	 * Members are set to default values.
+	 * @param setMapId	The MAP ID of the instance.
+	 */
+	MapPacketExtraction( uint8_t setMapId, object_id_t setPacketDestination );
+	ReturnValue_t extractPackets(TcTransferFrame* frame);
+	/**
+	 * The #packetStore and the default destination of #tcQueue are initialized here.
+	 * @return	@c RETURN_OK on success, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter.
+	 * @return The MAP ID of this instance.
+	 */
+	uint8_t getMapId() const;
+};
+
+#endif /* MAPPACKETEXTRACTION_H_ */
diff --git a/datalinklayer/MapPacketExtractionIF.h b/datalinklayer/MapPacketExtractionIF.h
index d66831de..e29ac666 100644
--- a/datalinklayer/MapPacketExtractionIF.h
+++ b/datalinklayer/MapPacketExtractionIF.h
@@ -1,47 +1,47 @@
-/**
- * @file	MapPacketExtractionIF.h
- * @brief	This file defines the MapPacketExtractionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef MAPPACKETEXTRACTIONIF_H_
-#define MAPPACKETEXTRACTIONIF_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-
-/**
- * This is the interface for MAP Packet Extraction classes.
- * All classes implementing this interface shall be able to extract blocked or segmented Space
- * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
- * Protocol.
- */
-class MapPacketExtractionIF : public CCSDSReturnValuesIF {
-protected:
-	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
-	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
-	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
-	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
-public:
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~MapPacketExtractionIF() {
-	}
-	/**
-	 * Method to call to handle a single Transfer Frame.
-	 * The method tries to extract Packets from the frame as stated in the Standard.
-	 * @param frame
-	 * @return
-	 */
-	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
-	/**
-	 * Any post-instantiation initialization shall be done in this method.
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() = 0;
-};
-
-
-#endif /* MAPPACKETEXTRACTIONIF_H_ */
+/**
+ * @file	MapPacketExtractionIF.h
+ * @brief	This file defines the MapPacketExtractionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef MAPPACKETEXTRACTIONIF_H_
+#define MAPPACKETEXTRACTIONIF_H_
+
+#include "CCSDSReturnValuesIF.h"
+#include "TcTransferFrame.h"
+
+/**
+ * This is the interface for MAP Packet Extraction classes.
+ * All classes implementing this interface shall be able to extract blocked or segmented Space
+ * Packets on a certain MAP channel. This is done in accordance with the CCSDS TC Space Data Link
+ * Protocol.
+ */
+class MapPacketExtractionIF : public CCSDSReturnValuesIF {
+protected:
+	static const uint8_t FIRST_PORTION = 0b01;		//!< Identification of the first part of a segmented Packet.
+	static const uint8_t CONTINUING_PORTION = 0b00;	//!< Identification of a continuing part of segmented Packets.
+	static const uint8_t LAST_PORTION = 0b10;		//!< The last portion of a segmented Packet.
+	static const uint8_t NO_SEGMENTATION = 0b11;	//!< A Frame without segmentation but maybe with blocking.
+public:
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~MapPacketExtractionIF() {
+	}
+	/**
+	 * Method to call to handle a single Transfer Frame.
+	 * The method tries to extract Packets from the frame as stated in the Standard.
+	 * @param frame
+	 * @return
+	 */
+	virtual ReturnValue_t extractPackets( TcTransferFrame* frame ) = 0;
+	/**
+	 * Any post-instantiation initialization shall be done in this method.
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() = 0;
+};
+
+
+#endif /* MAPPACKETEXTRACTIONIF_H_ */
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 8a3e1d76..f1a70bdc 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -1,102 +1,102 @@
-/**
- * @file	TcTransferFrame.cpp
- * @brief	This file defines the TcTransferFrame class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-
-
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-TcTransferFrame::TcTransferFrame() {
-	 frame = NULL;
-}
-
-TcTransferFrame::TcTransferFrame(uint8_t* setData) {
-	 this->frame = (tc_transfer_frame*)setData;
-}
-
-uint8_t TcTransferFrame::getVersionNumber() {
-	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
-}
-
-bool TcTransferFrame::bypassFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
-}
-
-bool TcTransferFrame::controlCommandFlagSet() {
-	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
-}
-
-bool TcTransferFrame::spareIsZero() {
-	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
-}
-
-uint16_t TcTransferFrame::getSpacecraftId() {
-	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
-}
-
-uint8_t TcTransferFrame::getVirtualChannelId() {
-	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
-}
-
-uint16_t TcTransferFrame::getFrameLength() {
-	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
-}
-
-uint16_t TcTransferFrame::getDataLength() {
-	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
-}
-
-uint8_t TcTransferFrame::getSequenceNumber() {
-	 return this->frame->header.sequenceNumber;
-}
-
-uint8_t TcTransferFrame::getSequenceFlags() {
-	 return (this->frame->dataField & 0b11000000)>>6;
-}
-
-uint8_t TcTransferFrame::getMAPId() {
-	 return this->frame->dataField & 0b00111111;
-}
-
-uint8_t* TcTransferFrame::getDataField() {
-	return &(this->frame->dataField) + 1;
-}
-
-uint8_t* TcTransferFrame::getFullFrame() {
-	return (uint8_t*)this->frame;
-}
-
-uint16_t TcTransferFrame::getFullSize() {
-	return this->getFrameLength() + 1;
-}
-
-uint16_t TcTransferFrame::getHeaderSize() {
-	 return sizeof(frame->header);
-}
-
-uint16_t TcTransferFrame::getFullDataLength() {
-	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
-}
-
-uint8_t* TcTransferFrame::getFullDataField() {
-	return &frame->dataField;
-}
-
-void TcTransferFrame::print() {
-	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;
-}
+/**
+ * @file	TcTransferFrame.cpp
+ * @brief	This file defines the TcTransferFrame class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+
+
+#include "TcTransferFrame.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+TcTransferFrame::TcTransferFrame() {
+	 frame = NULL;
+}
+
+TcTransferFrame::TcTransferFrame(uint8_t* setData) {
+	 this->frame = (tc_transfer_frame*)setData;
+}
+
+uint8_t TcTransferFrame::getVersionNumber() {
+	 return (this->frame->header.flagsAndScid & 0b11000000) >> 6;
+}
+
+bool TcTransferFrame::bypassFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00100000) != 0;
+}
+
+bool TcTransferFrame::controlCommandFlagSet() {
+	 return (this->frame->header.flagsAndScid & 0b00010000) != 0;
+}
+
+bool TcTransferFrame::spareIsZero() {
+	 return ( (this->frame->header.flagsAndScid & 0b00001100) == 0 );
+}
+
+uint16_t TcTransferFrame::getSpacecraftId() {
+	 return ( (this->frame->header.flagsAndScid & 0b00000011) << 8 ) + this->frame->header.spacecraftId_l;
+}
+
+uint8_t TcTransferFrame::getVirtualChannelId() {
+	 return (this->frame->header.vcidAndLength_h & 0b11111100) >> 2;
+}
+
+uint16_t TcTransferFrame::getFrameLength() {
+	 return  ( (this->frame->header.vcidAndLength_h & 0b00000011) << 8 ) + this->frame->header.length_l;
+}
+
+uint16_t TcTransferFrame::getDataLength() {
+	 return  this->getFrameLength() - this->getHeaderSize() -1 - FRAME_CRC_SIZE + 1; // -1 for the segment header.
+}
+
+uint8_t TcTransferFrame::getSequenceNumber() {
+	 return this->frame->header.sequenceNumber;
+}
+
+uint8_t TcTransferFrame::getSequenceFlags() {
+	 return (this->frame->dataField & 0b11000000)>>6;
+}
+
+uint8_t TcTransferFrame::getMAPId() {
+	 return this->frame->dataField & 0b00111111;
+}
+
+uint8_t* TcTransferFrame::getDataField() {
+	return &(this->frame->dataField) + 1;
+}
+
+uint8_t* TcTransferFrame::getFullFrame() {
+	return (uint8_t*)this->frame;
+}
+
+uint16_t TcTransferFrame::getFullSize() {
+	return this->getFrameLength() + 1;
+}
+
+uint16_t TcTransferFrame::getHeaderSize() {
+	 return sizeof(frame->header);
+}
+
+uint16_t TcTransferFrame::getFullDataLength() {
+	return this->getFrameLength() - this->getHeaderSize() - FRAME_CRC_SIZE + 1;
+}
+
+uint8_t* TcTransferFrame::getFullDataField() {
+	return &frame->dataField;
+}
+
+void TcTransferFrame::print() {
+	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;
+}
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 0bffa586..e8785c92 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.cpp
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/TcTransferFrameLocal.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <string.h>
-
-TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
-		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
-	this->frame = (tc_transfer_frame*)&localData;
-	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
-	frame->header.spacecraftId_l = (scid & 0x00FF);
-	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
-	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
-	frame->header.sequenceNumber = sequenceNumber;
-	frame->dataField = setSegmentHeader;
-	if (data != NULL) {
-		if (bypass && controlCommand) {
-			memcpy(&(frame->dataField), data, dataSize);
-			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
-			frame->header.length_l = (totalSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else if (dataSize <= 1016) {
-			memcpy(&(frame->dataField) +1, data, dataSize);
-			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
-			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
-			frame->header.length_l = (dataCrcSize & 0x00FF);
-			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
-			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
-			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
-		} else {
-			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
-		}
-	} else {
-		//No data in frame
-	}
-	if (forceCrc != 0 ) {
-		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
-		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
-	}
-}
+/**
+ * @file	TcTransferFrameLocal.cpp
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#include "TcTransferFrameLocal.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <string.h>
+
+TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
+		uint8_t vcId, uint8_t sequenceNumber, uint8_t setSegmentHeader, uint8_t* data, uint16_t dataSize, uint16_t forceCrc) {
+	this->frame = (tc_transfer_frame*)&localData;
+	frame->header.flagsAndScid = (bypass << 5) + (controlCommand << 4) + ((scid & 0x0300) >> 8);
+	frame->header.spacecraftId_l = (scid & 0x00FF);
+	frame->header.vcidAndLength_h = (vcId & 0b00111111) << 2;
+	frame->header.length_l = sizeof(TcTransferFramePrimaryHeader) -1;
+	frame->header.sequenceNumber = sequenceNumber;
+	frame->dataField = setSegmentHeader;
+	if (data != NULL) {
+		if (bypass && controlCommand) {
+			memcpy(&(frame->dataField), data, dataSize);
+			uint16_t totalSize = sizeof(TcTransferFramePrimaryHeader) + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (totalSize & 0x0300) >> 8;
+			frame->header.length_l = (totalSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else if (dataSize <= 1016) {
+			memcpy(&(frame->dataField) +1, data, dataSize);
+			uint16_t dataCrcSize = sizeof(TcTransferFramePrimaryHeader) + 1 + dataSize + FRAME_CRC_SIZE -1;
+			frame->header.vcidAndLength_h |= (dataCrcSize & 0x0300) >> 8;
+			frame->header.length_l = (dataCrcSize & 0x00FF);
+			uint16_t crc = CRC::crc16ccitt(getFullFrame(), getFullSize() -2);
+			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
+			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
+		} else {
+			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+		}
+	} else {
+		//No data in frame
+	}
+	if (forceCrc != 0 ) {
+		localData.data[getFullSize()-2] = (forceCrc & 0xFF00) >> 8;
+		localData.data[getFullSize()-1] = (forceCrc & 0x00FF);
+	}
+}
diff --git a/datalinklayer/TcTransferFrameLocal.h b/datalinklayer/TcTransferFrameLocal.h
index d98350fe..487d8940 100644
--- a/datalinklayer/TcTransferFrameLocal.h
+++ b/datalinklayer/TcTransferFrameLocal.h
@@ -1,49 +1,49 @@
-/**
- * @file	TcTransferFrameLocal.h
- * @brief	This file defines the TcTransferFrameLocal class.
- * @date	27.04.2013
- * @author	baetz
- */
-
-#ifndef TCTRANSFERFRAMELOCAL_H_
-#define TCTRANSFERFRAMELOCAL_H_
-
-#include "../datalinklayer/TcTransferFrame.h"
-
-/**
- * This is a helper class to locally create TC Transfer Frames.
- * This is mainly required for testing purposes and therefore not very sophisticated.
- * @ingroup ccsds_handling
- */
-class TcTransferFrameLocal : public TcTransferFrame {
-private:
-	/**
-	 * A stuct to locally store the complete data.
-	 */
-	struct frameData {
-		TcTransferFramePrimaryHeader header;	//!< The primary header.
-		uint8_t data[1019];	//!< The data field.
-	};
-public:
-	frameData localData; //!< The local data in the Frame.
-	/**
-	 * The default Constructor.
-	 * All parameters in the Header are passed.
-	 * If a BC Frame is detected no segment header is created.
-	 * Otherwise (AD and BD), the Segment Header is set.
-	 * @param bypass			The bypass flag.
-	 * @param controlCommand	The Control Command flag.
-	 * @param scid				The SCID.
-	 * @param vcId				The VCID.
-	 * @param sequenceNumber	The Frame Sequence Number N(s)
-	 * @param setSegmentHeader	A value for the Segment Header.
-	 * @param data				Data to put into the Frame Data Field.
-	 * @param dataSize			Size of the Data.
-	 * @param forceCrc			if != 0, the value is used as CRC.
-	 */
-	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
-			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
-};
-
-
-#endif /* TCTRANSFERFRAMELOCAL_H_ */
+/**
+ * @file	TcTransferFrameLocal.h
+ * @brief	This file defines the TcTransferFrameLocal class.
+ * @date	27.04.2013
+ * @author	baetz
+ */
+
+#ifndef TCTRANSFERFRAMELOCAL_H_
+#define TCTRANSFERFRAMELOCAL_H_
+
+#include "TcTransferFrame.h"
+
+/**
+ * This is a helper class to locally create TC Transfer Frames.
+ * This is mainly required for testing purposes and therefore not very sophisticated.
+ * @ingroup ccsds_handling
+ */
+class TcTransferFrameLocal : public TcTransferFrame {
+private:
+	/**
+	 * A stuct to locally store the complete data.
+	 */
+	struct frameData {
+		TcTransferFramePrimaryHeader header;	//!< The primary header.
+		uint8_t data[1019];	//!< The data field.
+	};
+public:
+	frameData localData; //!< The local data in the Frame.
+	/**
+	 * The default Constructor.
+	 * All parameters in the Header are passed.
+	 * If a BC Frame is detected no segment header is created.
+	 * Otherwise (AD and BD), the Segment Header is set.
+	 * @param bypass			The bypass flag.
+	 * @param controlCommand	The Control Command flag.
+	 * @param scid				The SCID.
+	 * @param vcId				The VCID.
+	 * @param sequenceNumber	The Frame Sequence Number N(s)
+	 * @param setSegmentHeader	A value for the Segment Header.
+	 * @param data				Data to put into the Frame Data Field.
+	 * @param dataSize			Size of the Data.
+	 * @param forceCrc			if != 0, the value is used as CRC.
+	 */
+	TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, uint8_t vcId, uint8_t sequenceNumber,
+			uint8_t setSegmentHeader = 0xC0, uint8_t* data = NULL, uint16_t dataSize = 0, uint16_t forceCrc = 0);
+};
+
+
+#endif /* TCTRANSFERFRAMELOCAL_H_ */
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 55169c42..cde28de3 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -1,121 +1,121 @@
-/**
- * @file	VirtualChannelReception.cpp
- * @brief	This file defines the VirtualChannelReception class.
- * @date	26.03.2013
- * @author	baetz
- */
-
-#include "../datalinklayer/BCFrame.h"
-#include "../datalinklayer/VirtualChannelReception.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
-		uint8_t setSlidingWindowWidth) :
-		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
-				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
-				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
-				0) {
-	internalClcw.setVirtualChannel(channelId);
-}
-
-ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
-	uint8_t mapId = frame->getMAPId();
-	mapChannelIterator iter = mapChannels.find(mapId);
-	if (iter == mapChannels.end()) {
-//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
-//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
-		return VC_NOT_FOUND;
-	} else {
-		return (iter->second)->extractPackets(frame);
-	}
-}
-
-ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
-	uint8_t bypass = frame->bypassFlagSet();
-	uint8_t controlCommand = frame->controlCommandFlagSet();
-	uint8_t typeValue = (bypass << 1) + controlCommand;
-	switch (typeValue) {
-	case AD_FRAME:
-		return currentState->handleADFrame(frame, clcw);
-	case BD_FRAME:
-		return handleBDFrame(frame, clcw);
-	case BC_FRAME:
-		return handleBCFrame(frame, clcw);
-	default:
-		return ILLEGAL_FLAG_COMBINATION;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
-		ClcwIF* clcw) {
-	ReturnValue_t result = RETURN_OK;
-	result = doFARM(frame, &internalClcw);
-	internalClcw.setReceiverFrameSequenceNumber(vR);
-	internalClcw.setFarmBCount(farmBCounter);
-	clcw->setWhole(internalClcw.getAsWhole());
-	switch (result) {
-	case RETURN_OK:
-		return mapDemultiplexing(frame);
-	case BC_IS_SET_VR_COMMAND:
-	case BC_IS_UNLOCK_COMMAND:
-		//Need to catch these codes to avoid error reporting later.
-		return RETURN_OK;
-	default:
-		break;
-	}
-	return result;
-}
-
-ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
-	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
-			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
-	if (returnValue.second == true) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	farmBCounter++;
-	return RETURN_OK;
-}
-
-ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
-	BcFrame content;
-	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
-			frame->getFullDataLength());
-	if (returnValue == BC_IS_UNLOCK_COMMAND) {
-		returnValue = currentState->handleBCUnlockCommand(clcw);
-	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
-		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
-	} else {
-		//Do nothing
-	}
-	return returnValue;
-}
-
-uint8_t VirtualChannelReception::getChannelId() const {
-	return channelId;
-}
-
-ReturnValue_t VirtualChannelReception::initialize() {
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
-				<< (int) slidingWindowWidth << std::endl;
-		return RETURN_FAILED;
-	}
-	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
-			iterator++) {
-		returnValue = iterator->second->initialize();
-		if (returnValue != RETURN_OK)
-			break;
-	}
-	return returnValue;
-}
-
-void VirtualChannelReception::setToWaitState() {
-	internalClcw.setWaitFlag(true);
-	this->currentState = &waitState;
-}
+/**
+ * @file	VirtualChannelReception.cpp
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	26.03.2013
+ * @author	baetz
+ */
+
+#include "BCFrame.h"
+#include "VirtualChannelReception.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
+		uint8_t setSlidingWindowWidth) :
+		channelId(setChannelId), slidingWindowWidth(setSlidingWindowWidth), positiveWindow(
+				setSlidingWindowWidth / 2), negativeWindow(setSlidingWindowWidth / 2), currentState(
+				&openState), openState(this), waitState(this), lockoutState(this), vR(0), farmBCounter(
+				0) {
+	internalClcw.setVirtualChannel(channelId);
+}
+
+ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame) {
+	uint8_t mapId = frame->getMAPId();
+	mapChannelIterator iter = mapChannels.find(mapId);
+	if (iter == mapChannels.end()) {
+//		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int) channelId
+//				<< ": MapChannel " << (int) mapId << std::dec << " not found." << std::endl;
+		return VC_NOT_FOUND;
+	} else {
+		return (iter->second)->extractPackets(frame);
+	}
+}
+
+ReturnValue_t VirtualChannelReception::doFARM(TcTransferFrame* frame, ClcwIF* clcw) {
+	uint8_t bypass = frame->bypassFlagSet();
+	uint8_t controlCommand = frame->controlCommandFlagSet();
+	uint8_t typeValue = (bypass << 1) + controlCommand;
+	switch (typeValue) {
+	case AD_FRAME:
+		return currentState->handleADFrame(frame, clcw);
+	case BD_FRAME:
+		return handleBDFrame(frame, clcw);
+	case BC_FRAME:
+		return handleBCFrame(frame, clcw);
+	default:
+		return ILLEGAL_FLAG_COMBINATION;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::frameAcceptanceAndReportingMechanism(TcTransferFrame* frame,
+		ClcwIF* clcw) {
+	ReturnValue_t result = RETURN_OK;
+	result = doFARM(frame, &internalClcw);
+	internalClcw.setReceiverFrameSequenceNumber(vR);
+	internalClcw.setFarmBCount(farmBCounter);
+	clcw->setWhole(internalClcw.getAsWhole());
+	switch (result) {
+	case RETURN_OK:
+		return mapDemultiplexing(frame);
+	case BC_IS_SET_VR_COMMAND:
+	case BC_IS_UNLOCK_COMMAND:
+		//Need to catch these codes to avoid error reporting later.
+		return RETURN_OK;
+	default:
+		break;
+	}
+	return result;
+}
+
+ReturnValue_t VirtualChannelReception::addMapChannel(uint8_t mapId, MapPacketExtractionIF* object) {
+	std::pair<mapChannelIterator, bool> returnValue = mapChannels.insert(
+			std::pair<uint8_t, MapPacketExtractionIF*>(mapId, object));
+	if (returnValue.second == true) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t VirtualChannelReception::handleBDFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	farmBCounter++;
+	return RETURN_OK;
+}
+
+ReturnValue_t VirtualChannelReception::handleBCFrame(TcTransferFrame* frame, ClcwIF* clcw) {
+	BcFrame content;
+	ReturnValue_t returnValue = content.initialize(frame->getFullDataField(),
+			frame->getFullDataLength());
+	if (returnValue == BC_IS_UNLOCK_COMMAND) {
+		returnValue = currentState->handleBCUnlockCommand(clcw);
+	} else if (returnValue == BC_IS_SET_VR_COMMAND) {
+		returnValue = currentState->handleBCSetVrCommand(clcw, content.vR);
+	} else {
+		//Do nothing
+	}
+	return returnValue;
+}
+
+uint8_t VirtualChannelReception::getChannelId() const {
+	return channelId;
+}
+
+ReturnValue_t VirtualChannelReception::initialize() {
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
+		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
+				<< (int) slidingWindowWidth << std::endl;
+		return RETURN_FAILED;
+	}
+	for (mapChannelIterator iterator = mapChannels.begin(); iterator != mapChannels.end();
+			iterator++) {
+		returnValue = iterator->second->initialize();
+		if (returnValue != RETURN_OK)
+			break;
+	}
+	return returnValue;
+}
+
+void VirtualChannelReception::setToWaitState() {
+	internalClcw.setWaitFlag(true);
+	this->currentState = &waitState;
+}
diff --git a/datalinklayer/VirtualChannelReception.h b/datalinklayer/VirtualChannelReception.h
index f7111e42..9b4e2987 100644
--- a/datalinklayer/VirtualChannelReception.h
+++ b/datalinklayer/VirtualChannelReception.h
@@ -1,114 +1,114 @@
-/**
- * @file	VirtualChannelReception.h
- * @brief	This file defines the VirtualChannelReception class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTION_H_
-#define VIRTUALCHANNELRECEPTION_H_
-
-#include "../datalinklayer/CCSDSReturnValuesIF.h"
-#include "../datalinklayer/Clcw.h"
-#include "../datalinklayer/Farm1StateIF.h"
-#include "../datalinklayer/Farm1StateLockout.h"
-#include "../datalinklayer/Farm1StateOpen.h"
-#include "../datalinklayer/Farm1StateWait.h"
-#include "../datalinklayer/MapPacketExtractionIF.h"
-#include "../datalinklayer/VirtualChannelReceptionIF.h"
-#include <map>
-/**
- * Implementation of a TC Virtual Channel.
- * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
- * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
- * Features:
- *  - any (6bit) Virtual Channel ID is assignable.
- *  - Supports an arbitrary number of MAP Channels (with a map).
- *  - Has a complete FARM-1 Machine built-in.
- *
- * The FARM-1 state machine uses the State Pattern.
- */
-class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
-	friend class Farm1StateOpen;
-	friend class Farm1StateWait;
-	friend class Farm1StateLockout;
-private:
-	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
-	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
-	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
-	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
-protected:
-	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
-	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
-	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
-	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
-	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
-	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
-	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
-	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
-	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
-	/**
-	 * This method handles demultiplexing to different map channels.
-	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
-	 * @param frame	The frame to forward.
-	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
-	 */
-	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
-	/**
-	 * A sub-method that actually does the FARM-1 handling for different Frame types.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
-	 */
-	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
-	/**
-	 * Handles incoming BD Frames.
-	 * Handling these Frames is independent of the State, so no subcall to #currentState is
-	 * required.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return Always returns @c RETURN_OK.
-	 */
-	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Handles incoming BC Frames.
-	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
-	 * @param frame	The Tc Transfer Frame to handle.
-	 * @param clcw	Any changes on the CLCW shall be done with this method.
-	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
-	 */
-	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
-public:
-	/**
-	 * Default constructor.
-	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
-	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
-	 */
-	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
-	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
-	/**
-	 * Helper method to simplify adding a mapChannel during construction.
-	 * @param mapId	The mapId of the object to add.
-	 * @param object	Pointer to the MapPacketExtraction object itself.
-	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
-	/**
-	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
-	 * channels.
-	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
-	 */
-	ReturnValue_t initialize();
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	uint8_t getChannelId() const;
-	/**
-	 * Small method to set the state to Farm1StateWait.
-	 */
-	void setToWaitState();
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTION_H_ */
+/**
+ * @file	VirtualChannelReception.h
+ * @brief	This file defines the VirtualChannelReception class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTION_H_
+#define VIRTUALCHANNELRECEPTION_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.
+ * This is a full implementation of a virtual channel as specified in the CCSDS TC Space Data Link
+ * Protocol. It is designed to operate within an instance of the @c DataLinkLayer class.
+ * Features:
+ *  - any (6bit) Virtual Channel ID is assignable.
+ *  - Supports an arbitrary number of MAP Channels (with a map).
+ *  - Has a complete FARM-1 Machine built-in.
+ *
+ * The FARM-1 state machine uses the State Pattern.
+ */
+class VirtualChannelReception : public VirtualChannelReceptionIF, public CCSDSReturnValuesIF {
+	friend class Farm1StateOpen;
+	friend class Farm1StateWait;
+	friend class Farm1StateLockout;
+private:
+	uint8_t channelId;	//!< Stores the VCID that was assigned on construction.
+	uint8_t slidingWindowWidth;	//!< A constant to set the FARM-1 sliding window width.
+	uint8_t positiveWindow;	//!< The positive window for the FARM-1 machine.
+	uint8_t negativeWindow; //!< The negative window for the FARM-1 machine.
+protected:
+	Farm1StateIF* currentState;	//!< The current state. To change, one of the other states must be assigned to this pointer.
+	Farm1StateOpen openState;	//!< Instance of the FARM-1 State "Open".
+	Farm1StateWait waitState;	//!< Instance of the FARM-1 State "Wait".
+	Farm1StateLockout lockoutState;	//!< Instance of the FARM-1 State "Lockout".
+	Clcw internalClcw;	//!< A CLCW class to internally set the values before writing them back to the TTC System.
+	uint8_t vR;	//!< The Receiver Frame Sequence Number V(R) as it shall be maintained for every Virtual Channel.
+	uint8_t farmBCounter;	//!< The FARM-B COunter as it shall be maintained for every Virtual Channel.
+	typedef std::map<uint8_t, MapPacketExtractionIF*>::iterator mapChannelIterator;	//!< Typedef to simplify handling of the mapChannels map.
+	std::map<uint8_t, MapPacketExtractionIF*> mapChannels;	//!< A map that maintains all map Channels. Channels must be configured on initialization. MAy be omitted in a simplified version.
+	/**
+	 * This method handles demultiplexing to different map channels.
+	 * It parses the entries of #mapChannels and forwards the Frame to a found MAP Channel.
+	 * @param frame	The frame to forward.
+	 * @return	#VC_NOT_FOUND or the return value of the map channel extraction.
+	 */
+	ReturnValue_t mapDemultiplexing( TcTransferFrame* frame );
+	/**
+	 * A sub-method that actually does the FARM-1 handling for different Frame types.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return	The return code of higher methods or @c ILLEGAL_FLAG_COMBINATION.
+	 */
+	ReturnValue_t doFARM(TcTransferFrame* frame, ClcwIF* clcw);
+	/**
+	 * Handles incoming BD Frames.
+	 * Handling these Frames is independent of the State, so no subcall to #currentState is
+	 * required.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return Always returns @c RETURN_OK.
+	 */
+	ReturnValue_t handleBDFrame( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Handles incoming BC Frames.
+	 * The type of the BC Frame is detected and checked first, then methods of #currentState are called.
+	 * @param frame	The Tc Transfer Frame to handle.
+	 * @param clcw	Any changes on the CLCW shall be done with this method.
+	 * @return The failure code of BC Frame interpretation or the return code of higher methods.
+	 */
+	ReturnValue_t handleBCFrame( TcTransferFrame* frame, ClcwIF* clcw );
+public:
+	/**
+	 * Default constructor.
+	 * Only sets the channelId of the channel. Setting the Sliding Window width is possible as well.
+	 * @param setChannelId	Virtual Channel Identifier (VCID) of the channel.
+	 */
+	VirtualChannelReception( uint8_t setChannelId, uint8_t setSlidingWindowWidth );
+	ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw );
+	/**
+	 * Helper method to simplify adding a mapChannel during construction.
+	 * @param mapId	The mapId of the object to add.
+	 * @param object	Pointer to the MapPacketExtraction object itself.
+	 * @return	@c RETURN_OK if the channel was successfully inserted, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t addMapChannel( uint8_t mapId, MapPacketExtractionIF* object );
+	/**
+	 * The initialization routine checks the set #slidingWindowWidth and initializes all MAP
+	 * channels.
+	 * @return	@c RETURN_OK on successful initialization, @c RETURN_FAILED otherwise.
+	 */
+	ReturnValue_t initialize();
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	uint8_t getChannelId() const;
+	/**
+	 * Small method to set the state to Farm1StateWait.
+	 */
+	void setToWaitState();
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTION_H_ */
diff --git a/datalinklayer/VirtualChannelReceptionIF.h b/datalinklayer/VirtualChannelReceptionIF.h
index da544081..36f60e8c 100644
--- a/datalinklayer/VirtualChannelReceptionIF.h
+++ b/datalinklayer/VirtualChannelReceptionIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	VirtualChannelReceptionIF.h
- * @brief	This file defines the VirtualChannelReceptionIF class.
- * @date	25.03.2013
- * @author	baetz
- */
-
-#ifndef VIRTUALCHANNELRECEPTIONIF_H_
-#define VIRTUALCHANNELRECEPTIONIF_H_
-
-#include "../datalinklayer/ClcwIF.h"
-#include "../datalinklayer/TcTransferFrame.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * This is the interface for Virtual Channel reception classes.
- * It represents a single TC Virtual Channel that operates on one IO
- */
-class VirtualChannelReceptionIF {
-public:
-	/**
-	 * Enum including all valid types of frames.
-	 * The type is made up by two flags, so 0b1111 is definitely illegal.
-	 */
-	enum frameType  {
-		AD_FRAME = 0b00,
-		BC_FRAME = 0b11,
-		BD_FRAME = 0b10,
-		ILLEGAL_FRAME = 0b1111
-	};
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~VirtualChannelReceptionIF() {
-	}
-	/**
-	 * This method shall accept frames and do all FARM-1 stuff.
-	 * Handling the Frame includes forwarding to higher-level procedures.
-	 * @param frame	The Tc Transfer Frame that was received and checked.
-	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
-	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
-	 */
-	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
-	/**
-	 * If any other System Objects are required for operation they shall be initialized here.
-	 * @return	@c RETURN_OK for successful initialization.
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * Getter for the VCID.
-	 * @return	The #channelId.
-	 */
-	virtual uint8_t getChannelId() const = 0;
-};
-
-
-#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */
+/**
+ * @file	VirtualChannelReceptionIF.h
+ * @brief	This file defines the VirtualChannelReceptionIF class.
+ * @date	25.03.2013
+ * @author	baetz
+ */
+
+#ifndef VIRTUALCHANNELRECEPTIONIF_H_
+#define VIRTUALCHANNELRECEPTIONIF_H_
+
+#include "ClcwIF.h"
+#include "TcTransferFrame.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * This is the interface for Virtual Channel reception classes.
+ * It represents a single TC Virtual Channel that operates on one IO
+ */
+class VirtualChannelReceptionIF {
+public:
+	/**
+	 * Enum including all valid types of frames.
+	 * The type is made up by two flags, so 0b1111 is definitely illegal.
+	 */
+	enum frameType  {
+		AD_FRAME = 0b00,
+		BC_FRAME = 0b11,
+		BD_FRAME = 0b10,
+		ILLEGAL_FRAME = 0b1111
+	};
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~VirtualChannelReceptionIF() {
+	}
+	/**
+	 * This method shall accept frames and do all FARM-1 stuff.
+	 * Handling the Frame includes forwarding to higher-level procedures.
+	 * @param frame	The Tc Transfer Frame that was received and checked.
+	 * @param clcw	Any changes to the CLCW value are forwarded by using this parameter.
+	 * @return The return Value shall indicate successful processing with @c RETURN_OK.
+	 */
+	virtual ReturnValue_t frameAcceptanceAndReportingMechanism( TcTransferFrame* frame, ClcwIF* clcw ) = 0;
+	/**
+	 * If any other System Objects are required for operation they shall be initialized here.
+	 * @return	@c RETURN_OK for successful initialization.
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * Getter for the VCID.
+	 * @return	The #channelId.
+	 */
+	virtual uint8_t getChannelId() const = 0;
+};
+
+
+#endif /* VIRTUALCHANNELRECEPTIONIF_H_ */

From e800aad97993d36f6800a35cc6ccd805a6e269d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:44:10 +0200
Subject: [PATCH 0678/1292] event git update

---
 events/Event.cpp                              |  28 +-
 events/Event.h                                |  89 +++--
 events/EventManager.cpp                       | 320 +++++++++---------
 events/EventManager.h                         | 122 +++----
 events/EventManagerIF.h                       | 104 +++---
 events/EventMessage.cpp                       | 228 ++++++-------
 events/EventMessage.h                         | 104 +++---
 events/EventReportingProxyIF.h                |  38 +--
 events/eventmatching/EventIdRangeMatcher.cpp  |  24 +-
 events/eventmatching/EventIdRangeMatcher.h    |  26 +-
 events/eventmatching/EventMatchTree.cpp       | 298 ++++++++--------
 events/eventmatching/EventMatchTree.h         |  72 ++--
 events/eventmatching/EventRangeMatcherBase.h  |  58 ++--
 events/eventmatching/ReporterRangeMatcher.cpp |  26 +-
 events/eventmatching/ReporterRangeMatcher.h   |  26 +-
 events/eventmatching/SeverityRangeMatcher.cpp |  28 +-
 events/eventmatching/SeverityRangeMatcher.h   |  26 +-
 events/eventmatching/eventmatching.h          |  20 +-
 18 files changed, 813 insertions(+), 824 deletions(-)

diff --git a/events/Event.cpp b/events/Event.cpp
index a94ae6db..ea3d46fe 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,14 +1,14 @@
-#include "../events/Event.h"
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
-}
-}
+#include "Event.h"
+namespace EVENT {
+EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
+}
+
+EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
+}
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (eventId & 0xFFFF);
+}
+}
diff --git a/events/Event.h b/events/Event.h
index f613e701..e22c9db1 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -1,45 +1,44 @@
-#ifndef FRAMEWORK_EVENTS_EVENT_H_
-#define FRAMEWORK_EVENTS_EVENT_H_
-
-#include <cstdint>
-#include "../events/fwSubsystemIdRanges.h"
-//could be move to more suitable location
-#include <subsystemIdRanges.h>
-
-typedef uint16_t EventId_t;
-typedef uint8_t EventSeverity_t;
-
-#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
-
-typedef uint32_t Event;
-
-namespace EVENT {
-EventId_t getEventId(Event event);
-
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
-}
-
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
-}
-
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
-
-#endif /* FRAMEWORK_EVENTS_EVENT_H_ */
+#ifndef EVENTOBJECT_EVENT_H_
+#define EVENTOBJECT_EVENT_H_
+
+#include <stdint.h>
+#include "fwSubsystemIdRanges.h"
+//could be move to more suitable location
+#include <config/tmtc/subsystemIdRanges.h>
+
+typedef uint16_t EventId_t;
+typedef uint8_t EventSeverity_t;
+
+#define MAKE_EVENT(id, severity) (((severity)<<16)+(SUBSYSTEM_ID*100)+(id))
+
+typedef uint32_t Event;
+
+namespace EVENT {
+EventId_t getEventId(Event event);
+
+EventSeverity_t getSeverity(Event event);
+
+Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
+
+}
+namespace SEVERITY {
+	static const EventSeverity_t INFO = 1;
+	static const EventSeverity_t LOW = 2;
+	static const EventSeverity_t MEDIUM = 3;
+	static const EventSeverity_t HIGH = 4;
+}
+
+//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
+//struct Event {
+//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
+//			id(domain*100+counter), severity(severity) {
+//	}
+//	EventId_t id;
+//	EventSeverity_t severity;
+//	static const EventSeverity_t INFO = 1;
+//	static const EventSeverity_t LOW = 2;
+//	static const EventSeverity_t MEDIUM = 3;
+//	static const EventSeverity_t HIGH = 4;
+//};
+
+#endif /* EVENTOBJECT_EVENT_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 5848dd74..e58f251a 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,165 +1,155 @@
-#include "../events/EventManager.h"
-#include "../events/EventMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/QueueFactory.h"
-#include "../ipc/MutexFactory.h"
-
-
-const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
-		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
-		sizeof(ReporterRangeMatcher) };
-// If one checks registerListener calls, there are around 40 (to max 50)
-// objects registering for certain events.
-// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
-// So a good guess is 75 to a max of 100 pools required for each, which fits well.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
-
-EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
-}
-
-ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
-			printEvent(&message);
-#endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-			        message->getSender());
-		}
-	}
-	unlockMutex();
-}
-
-ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
-bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
-}
-
-ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
-}
-
-ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-#ifdef DEBUG
-
-//forward declaration, should be implemented by mission
-const char* translateObject(object_id_t object);
-const char * translateEvents(Event event);
-
-void EventManager::printEvent(EventMessage* message) {
-	const char *string = 0;
-	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
-//		string = translateObject(message->getReporter());
-//		sif::info << "EVENT: ";
-//		if (string != 0) {
-//			sif::info << string;
-//		} else {
-//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-//		}
-//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-//				<< message->getParameter1() << " P2: 0x"
-//				<< message->getParameter2() << std::dec << std::endl;
-		break;
-	default:
-		string = translateObject(message->getReporter());
-		sif::debug << "EventManager: ";
-		if (string != 0) {
-			sif::debug << string;
-		}
-		else {
-			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
-		}
-		sif::debug << " reported " << translateEvents(message->getEvent())
-				<< " (" << std::dec << message->getEventId() << ") "
-				<< std::endl;
-
-		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
-				<< ", P1 Dec: " << std::dec << message->getParameter1()
-				<< std::endl;
-		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
-				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
-				<< std::endl;
-		break;
-	}
-
-}
-#endif
-
-void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-}
-
-void EventManager::unlockMutex() {
-	mutex->unlockMutex();
-}
+#include "EventManager.h"
+#include "EventMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/QueueFactory.h"
+#include "../ipc/MutexFactory.h"
+
+
+const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
+		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
+		sizeof(ReporterRangeMatcher) };
+//If one checks registerListener calls, there are around 40 (to max 50) objects registering for certain events.
+//Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher. So a good guess is 75 to a max of 100 pools required for each, which fits well.
+const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
+
+EventManager::EventManager(object_id_t setObjectId) :
+		SystemObject(setObjectId), eventReportQueue(NULL), mutex(NULL), factoryBackend(
+				0, POOL_SIZES, N_ELEMENTS, false, true) {
+	mutex = MutexFactory::instance()->createMutex();
+	eventReportQueue = QueueFactory::instance()->createMessageQueue(
+			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+EventManager::~EventManager() {
+	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+MessageQueueId_t EventManager::getEventReportQueue() {
+	return eventReportQueue->getId();
+}
+
+ReturnValue_t EventManager::performOperation(uint8_t opCode) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	while (result == HasReturnvaluesIF::RETURN_OK) {
+		EventMessage message;
+		result = eventReportQueue->receiveMessage(&message);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+#ifdef DEBUG
+			printEvent(&message);
+#endif
+			notifyListeners(&message);
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void EventManager::notifyListeners(EventMessage* message) {
+	lockMutex();
+	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+		if (iter->second.match(message)) {
+			MessageQueueSenderIF::sendMessage(iter->first, message,
+					message->getSender());
+		}
+	}
+	unlockMutex();
+}
+
+ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
+bool forwardAllButSelected) {
+	auto result = listenerList.insert(
+			std::pair<MessageQueueId_t, EventMatchTree>(listener,
+					EventMatchTree(&factoryBackend, forwardAllButSelected)));
+	if (!result.second) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
+		EventId_t event) {
+	return subscribeToEventRange(listener, event);
+}
+
+ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
+		object_id_t object) {
+	return subscribeToEventRange(listener, 0, 0, true, object);
+}
+
+ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
+		EventId_t idFrom, EventId_t idTo, bool idInverted,
+		object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	auto iter = listenerList.find(listener);
+	if (iter == listenerList.end()) {
+		return LISTENER_NOT_FOUND;
+	}
+	lockMutex();
+	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
+			reporterFrom, reporterTo, reporterInverted);
+	unlockMutex();
+	return result;
+}
+
+#ifdef DEBUG
+
+//forward declaration, should be implemented by mission
+const char* translateObject(object_id_t object);
+const char * translateEvents(Event event);
+
+void EventManager::printEvent(EventMessage* message) {
+	const char *string = 0;
+	switch (message->getSeverity()) {
+	case SEVERITY::INFO:
+//		string = translateObject(message->getReporter());
+//		sif::info << "EVENT: ";
+//		if (string != 0) {
+//			sif::info << string;
+//		} else {
+//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
+//		}
+//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
+//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
+//				<< message->getParameter1() << " P2: 0x"
+//				<< message->getParameter2() << std::dec << std::endl;
+		break;
+	default:
+		string = translateObject(message->getReporter());
+		sif::error << "EVENT: ";
+		if (string != 0) {
+			sif::error << string;
+		} else {
+			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
+				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
+				<< message->getParameter1() << " P2: 0x"
+				<< message->getParameter2() << std::dec << std::endl;
+		break;
+	}
+
+}
+#endif
+
+void EventManager::lockMutex() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+}
+
+void EventManager::unlockMutex() {
+	mutex->unlockMutex();
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index 5323edd8..7badc3bf 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,61 +1,61 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
-
-#include "../events/eventmatching/EventMatchTree.h"
-#include "../events/EventManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../storagemanager/LocalPool.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-class EventManager: public EventManagerIF,
-		public ExecutableObjectIF,
-		public SystemObject {
-public:
-	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
-
-	EventManager(object_id_t setObjectId);
-	virtual ~EventManager();
-
-	MessageQueueId_t getEventReportQueue();
-
-	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
-	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
-	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object);
-	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t performOperation(uint8_t opCode);
-protected:
-
-	MessageQueueIF* eventReportQueue = nullptr;
-
-	std::map<MessageQueueId_t, EventMatchTree> listenerList;
-
-	MutexIF* mutex = nullptr;
-
-	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-
-	void notifyListeners(EventMessage *message);
-
-#ifdef DEBUG
-	void printEvent(EventMessage *message);
-#endif
-
-	void lockMutex();
-
-	void unlockMutex();
-};
-
-#endif /* EVENTMANAGER_H_ */
+#ifndef EVENTMANAGER_H_
+#define EVENTMANAGER_H_
+
+#include "eventmatching/EventMatchTree.h"
+#include "EventManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/LocalPool.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+class EventManager: public EventManagerIF,
+		public ExecutableObjectIF,
+		public SystemObject {
+public:
+	static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+	EventManager(object_id_t setObjectId);
+	virtual ~EventManager();
+
+	MessageQueueId_t getEventReportQueue();
+
+	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+	ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
+	ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object);
+	ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t performOperation(uint8_t opCode);
+protected:
+
+	MessageQueueIF* eventReportQueue;
+
+	std::map<MessageQueueId_t, EventMatchTree> listenerList;
+
+	MutexIF* mutex;
+
+	static const uint8_t N_POOLS = 3;
+	LocalPool<N_POOLS> factoryBackend;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+
+	void notifyListeners(EventMessage *message);
+
+#ifdef DEBUG
+	void printEvent(EventMessage *message);
+#endif
+
+	void lockMutex();
+
+	void unlockMutex();
+};
+
+#endif /* EVENTMANAGER_H_ */
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index bb36f0a3..f9ac420b 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMANAGERIF_H_
-#define EVENTMANAGERIF_H_
-
-#include "../events/eventmatching/eventmatching.h"
-#include "../events/EventMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class EventManagerIF {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
-	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
-	virtual ~EventManagerIF() {
-	}
-
-	virtual MessageQueueId_t getEventReportQueue() = 0;
-
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
-	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
-			EventId_t event) = 0;
-	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
-			object_id_t object) = 0;
-	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
-			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false) = 0;
-
-	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
-		EventMessage message(event, reportingObject, parameter1, parameter2);
-		triggerEvent(&message, sentFrom);
-	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
-			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
-					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
-			}
-		}
-		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
-	}
-
-};
-
-#endif /* EVENTMANAGERIF_H_ */
+#ifndef EVENTMANAGERIF_H_
+#define EVENTMANAGERIF_H_
+
+#include "eventmatching/eventmatching.h"
+#include "EventMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class EventManagerIF {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::EVENT_MANAGER_IF;
+	static const ReturnValue_t LISTENER_NOT_FOUND = MAKE_RETURN_CODE(1);
+	virtual ~EventManagerIF() {
+	}
+
+	virtual MessageQueueId_t getEventReportQueue() = 0;
+
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
+			EventId_t event) = 0;
+	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
+			object_id_t object) = 0;
+	virtual ReturnValue_t subscribeToEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+	virtual ReturnValue_t unsubscribeFromEventRange(MessageQueueId_t listener,
+			EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false) = 0;
+
+	static void triggerEvent(object_id_t reportingObject, Event event,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+		EventMessage message(event, reportingObject, parameter1, parameter2);
+		triggerEvent(&message, sentFrom);
+	}
+	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = 0;
+		if (eventmanagerQueue == 0) {
+			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
+					objects::EVENT_MANAGER);
+			if (eventmanager != NULL) {
+				eventmanagerQueue = eventmanager->getEventReportQueue();
+			}
+		}
+		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
+	}
+
+};
+
+#endif /* EVENTMANAGERIF_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index 28538f7f..b911abab 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -1,114 +1,114 @@
-#include "../events/EventMessage.h"
-#include <cstring>
-
-EventMessage::EventMessage() {
-	messageSize = EVENT_MESSAGE_SIZE;
-	clearEventMessage();
-}
-
-EventMessage::EventMessage(Event event, object_id_t reporter,
-		uint32_t parameter1, uint32_t parameter2) {
-	messageSize = EVENT_MESSAGE_SIZE;
-	setMessageId(EVENT_MESSAGE);
-	setEvent(event);
-	setReporter(reporter);
-	setParameter1(parameter1);
-	setParameter2(parameter2);
-}
-
-EventMessage::~EventMessage() {
-}
-
-Event EventMessage::getEvent() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFFFFFF);
-}
-
-void EventMessage::setEvent(Event event) {
-	Event tempEvent;
-	memcpy(&tempEvent, getData(), sizeof(Event));
-	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
-	memcpy(getData(), &tempEvent, sizeof(Event));
-}
-
-uint8_t EventMessage::getMessageId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return (event & 0xFF000000) >> 24;
-}
-
-void EventMessage::setMessageId(uint8_t id) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0x00FFFFFF) + (id << 24);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventSeverity_t EventMessage::getSeverity() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
-}
-
-void EventMessage::setSeverity(EventSeverity_t severity) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFF00FFFF) + (severity << 16);
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-EventId_t EventMessage::getEventId() {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
-}
-
-void EventMessage::setEventId(EventId_t eventId) {
-	Event event;
-	memcpy(&event, getData(), sizeof(Event));
-	event = (event & 0xFFFF0000) + eventId;
-	memcpy(getData(), &event, sizeof(Event));
-}
-
-object_id_t EventMessage::getReporter() {
-	object_id_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
-	return parameter;
-}
-
-void EventMessage::setReporter(object_id_t reporter) {
-	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
-}
-
-uint32_t EventMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
-	return parameter;
-}
-
-void EventMessage::setParameter1(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
-}
-
-uint32_t EventMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
-	return parameter;
-}
-
-void EventMessage::setParameter2(uint32_t parameter) {
-	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
-}
-
-void EventMessage::clearEventMessage() {
-	setEvent(INVALID_EVENT);
-}
-
-bool EventMessage::isClearedEventMessage() {
-	return getEvent() == INVALID_EVENT;
-}
-
-size_t EventMessage::getMinimumMessageSize() {
-	return EVENT_MESSAGE_SIZE;
-}
+#include "EventMessage.h"
+#include <cstring>
+
+EventMessage::EventMessage() {
+	messageSize = EVENT_MESSAGE_SIZE;
+	clearEventMessage();
+}
+
+EventMessage::EventMessage(Event event, object_id_t reporter,
+		uint32_t parameter1, uint32_t parameter2) {
+	messageSize = EVENT_MESSAGE_SIZE;
+	setMessageId(EVENT_MESSAGE);
+	setEvent(event);
+	setReporter(reporter);
+	setParameter1(parameter1);
+	setParameter2(parameter2);
+}
+
+EventMessage::~EventMessage() {
+}
+
+Event EventMessage::getEvent() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFFFFFF);
+}
+
+void EventMessage::setEvent(Event event) {
+	Event tempEvent;
+	memcpy(&tempEvent, getData(), sizeof(Event));
+	tempEvent = (tempEvent & 0xFF000000) + (event & 0xFFFFFF);
+	memcpy(getData(), &tempEvent, sizeof(Event));
+}
+
+uint8_t EventMessage::getMessageId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return (event & 0xFF000000) >> 24;
+}
+
+void EventMessage::setMessageId(uint8_t id) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0x00FFFFFF) + (id << 24);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventSeverity_t EventMessage::getSeverity() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getSeverity(event);
+}
+
+void EventMessage::setSeverity(EventSeverity_t severity) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFF00FFFF) + (severity << 16);
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+EventId_t EventMessage::getEventId() {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	return EVENT::getEventId(event);
+}
+
+void EventMessage::setEventId(EventId_t eventId) {
+	Event event;
+	memcpy(&event, getData(), sizeof(Event));
+	event = (event & 0xFFFF0000) + eventId;
+	memcpy(getData(), &event, sizeof(Event));
+}
+
+object_id_t EventMessage::getReporter() {
+	object_id_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event), sizeof(object_id_t));
+	return parameter;
+}
+
+void EventMessage::setReporter(object_id_t reporter) {
+	memcpy(getData() + sizeof(Event), &reporter, sizeof(object_id_t));
+}
+
+uint32_t EventMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t), 4);
+	return parameter;
+}
+
+void EventMessage::setParameter1(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t), &parameter, 4);
+}
+
+uint32_t EventMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, getData() + sizeof(Event) + sizeof(object_id_t) + 4, 4);
+	return parameter;
+}
+
+void EventMessage::setParameter2(uint32_t parameter) {
+	memcpy(getData() + sizeof(Event) + sizeof(object_id_t) + 4, &parameter, 4);
+}
+
+void EventMessage::clearEventMessage() {
+	setEvent(INVALID_EVENT);
+}
+
+bool EventMessage::isClearedEventMessage() {
+	return getEvent() == INVALID_EVENT;
+}
+
+size_t EventMessage::getMinimumMessageSize() {
+	return EVENT_MESSAGE_SIZE;
+}
diff --git a/events/EventMessage.h b/events/EventMessage.h
index 8769333b..4d003bd7 100644
--- a/events/EventMessage.h
+++ b/events/EventMessage.h
@@ -1,52 +1,52 @@
-#ifndef EVENTMESSAGE_H_
-#define EVENTMESSAGE_H_
-
-#include "../events/Event.h"
-#include "../ipc/MessageQueueMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-/**
- * Passing on events through IPC.
- * Event Id, severity and message type retrieval is a bit difficult.
- */
-class EventMessage: public MessageQueueMessage {
-public:
-	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
-	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
-	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
-	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
-	//Add other messageIDs here if necessary.
-	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
-			+ 3 * sizeof(uint32_t);
-
-	EventMessage();
-//	EventMessage(EventId_t event, EventSeverity_t severity,
-//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
-	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
-			uint32_t parameter2 = 0);
-	virtual ~EventMessage();
-	Event getEvent();
-	void setEvent(Event event);
-	uint8_t getMessageId();
-	void setMessageId(uint8_t id);
-	EventSeverity_t getSeverity();
-	void setSeverity(EventSeverity_t severity);
-	EventId_t getEventId();
-	void setEventId(EventId_t event);
-	object_id_t getReporter();
-	void setReporter(object_id_t reporter);
-	uint32_t getParameter1();
-	void setParameter1(uint32_t parameter);
-	uint32_t getParameter2();
-	void setParameter2(uint32_t parameter);
-
-	void clearEventMessage();
-	bool isClearedEventMessage();
-
-protected:
-	static const Event INVALID_EVENT = 0;
-	virtual size_t getMinimumMessageSize();
-
-};
-
-#endif /* EVENTMESSAGE_H_ */
+#ifndef EVENTMESSAGE_H_
+#define EVENTMESSAGE_H_
+
+#include "Event.h"
+#include "../ipc/MessageQueueMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+/**
+ * Passing on events through IPC.
+ * Event Id, severity and message type retrieval is a bit difficult.
+ */
+class EventMessage: public MessageQueueMessage {
+public:
+	static const uint8_t EVENT_MESSAGE = 0; //!< Normal event
+	static const uint8_t CONFIRMATION_REQUEST = 1; //!< Request to parent if event is caused by child or not.
+	static const uint8_t YOUR_FAULT = 2; //!< The fault was caused by child, parent believes it's ok.
+	static const uint8_t MY_FAULT = 3; //!< The fault was caused by the parent, child is ok.
+	//Add other messageIDs here if necessary.
+	static const uint8_t EVENT_MESSAGE_SIZE = HEADER_SIZE + sizeof(Event)
+			+ 3 * sizeof(uint32_t);
+
+	EventMessage();
+//	EventMessage(EventId_t event, EventSeverity_t severity,
+//			object_id_t reporter, uint32_t parameter1, uint32_t parameter2 = 0);
+	EventMessage(Event event, object_id_t reporter, uint32_t parameter1,
+			uint32_t parameter2 = 0);
+	virtual ~EventMessage();
+	Event getEvent();
+	void setEvent(Event event);
+	uint8_t getMessageId();
+	void setMessageId(uint8_t id);
+	EventSeverity_t getSeverity();
+	void setSeverity(EventSeverity_t severity);
+	EventId_t getEventId();
+	void setEventId(EventId_t event);
+	object_id_t getReporter();
+	void setReporter(object_id_t reporter);
+	uint32_t getParameter1();
+	void setParameter1(uint32_t parameter);
+	uint32_t getParameter2();
+	void setParameter2(uint32_t parameter);
+
+	void clearEventMessage();
+	bool isClearedEventMessage();
+
+protected:
+	static const Event INVALID_EVENT = 0;
+	virtual size_t getMinimumMessageSize();
+
+};
+
+#endif /* EVENTMESSAGE_H_ */
diff --git a/events/EventReportingProxyIF.h b/events/EventReportingProxyIF.h
index 1b8064bd..7a96e3d1 100644
--- a/events/EventReportingProxyIF.h
+++ b/events/EventReportingProxyIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
-
-#include "../events/Event.h"
-
-
-class EventReportingProxyIF {
-public:
-	virtual ~EventReportingProxyIF() {
-	}
-
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
-
-};
-
-
-
-
-#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+#define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_
+
+#include "Event.h"
+
+
+class EventReportingProxyIF {
+public:
+	virtual ~EventReportingProxyIF() {
+	}
+
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const = 0;
+
+};
+
+
+
+
+#endif /* FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ */
diff --git a/events/eventmatching/EventIdRangeMatcher.cpp b/events/eventmatching/EventIdRangeMatcher.cpp
index 40220e4b..974567d4 100644
--- a/events/eventmatching/EventIdRangeMatcher.cpp
+++ b/events/eventmatching/EventIdRangeMatcher.cpp
@@ -1,12 +1,12 @@
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-
-EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
-		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
-}
-
-EventIdRangeMatcher::~EventIdRangeMatcher() {
-}
-
-bool EventIdRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getEventId());
-}
+#include "EventIdRangeMatcher.h"
+
+EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper,
+		bool inverted) : EventRangeMatcherBase<EventId_t>(lower, upper, inverted) {
+}
+
+EventIdRangeMatcher::~EventIdRangeMatcher() {
+}
+
+bool EventIdRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getEventId());
+}
diff --git a/events/eventmatching/EventIdRangeMatcher.h b/events/eventmatching/EventIdRangeMatcher.h
index ffc2ce80..540d372f 100644
--- a/events/eventmatching/EventIdRangeMatcher.h
+++ b/events/eventmatching/EventIdRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
-public:
-	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
-	~EventIdRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class EventIdRangeMatcher: public EventRangeMatcherBase<EventId_t> {
+public:
+	EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted);
+	~EventIdRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ */
diff --git a/events/eventmatching/EventMatchTree.cpp b/events/eventmatching/EventMatchTree.cpp
index fef1b83e..55e4083f 100644
--- a/events/eventmatching/EventMatchTree.cpp
+++ b/events/eventmatching/EventMatchTree.cpp
@@ -1,149 +1,149 @@
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-#include "../../events/eventmatching/EventMatchTree.h"
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-
-EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
-		bool invertedMatch) :
-		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
-				invertedMatch) {
-}
-
-EventMatchTree::~EventMatchTree() {
-}
-
-bool EventMatchTree::match(EventMessage* number) {
-	if (invertedMatch) {
-		return !MatchTree<EventMessage*>::match(number);
-	} else {
-		return MatchTree<EventMessage*>::match(number);
-	}
-}
-
-ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	if (idFrom == 0) {
-		//Assuming all events shall be forwarded.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	iterator lastTest;
-	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
-			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (reporterFrom == 0) {
-		//No need to add another AND branch
-		return RETURN_OK;
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
-			&lastTest);
-}
-
-ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
-		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-
-	iterator foundElement;
-
-	if (idFrom == 0) {
-		//Assuming a "forward all events" request.
-		idTo = 0;
-		idInverted = true;
-	}
-	if (idTo == 0) {
-		idTo = idFrom;
-	}
-	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
-			idFrom, idTo, idInverted);
-	if (foundElement == end()) {
-		return NO_MATCH; //Can't tell if too detailed or just not found.
-	}
-	if (reporterFrom == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	if (reporterTo == 0) {
-		reporterTo = reporterFrom;
-	}
-	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
-			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	} else {
-		return removeElementAndReconnectChildren(foundElement);
-	}
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			return RETURN_OK;
-		} else {
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
-			INSERTION_T>(idFrom, idTo, inverted);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
-		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
-	iterator iter = start;
-	while (iter != end()) {
-		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
-		if ((matcher->rangeMatcher.lowerBound == idFrom)
-				&& (matcher->rangeMatcher.upperBound == idTo)
-				&& (matcher->rangeMatcher.inverted == inverted)) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//If deletion fails, delete element anyway, nothing we can do.
-	//SHOULDO: Throw event, or write debug output.
-	return factory.destroy(position.element);
-}
+#include "EventIdRangeMatcher.h"
+#include "EventMatchTree.h"
+#include "ReporterRangeMatcher.h"
+#include "SeverityRangeMatcher.h"
+
+EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend,
+		bool invertedMatch) :
+		MatchTree<EventMessage*>(end(), 1), factory(storageBackend), invertedMatch(
+				invertedMatch) {
+}
+
+EventMatchTree::~EventMatchTree() {
+}
+
+bool EventMatchTree::match(EventMessage* number) {
+	if (invertedMatch) {
+		return !MatchTree<EventMessage*>::match(number);
+	} else {
+		return MatchTree<EventMessage*>::match(number);
+	}
+}
+
+ReturnValue_t EventMatchTree::addMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+	if (idFrom == 0) {
+		//Assuming all events shall be forwarded.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	iterator lastTest;
+	ReturnValue_t result = findOrInsertRangeMatcher<EventId_t,
+			EventIdRangeMatcher>(begin(), idFrom, idTo, idInverted, &lastTest);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (reporterFrom == 0) {
+		//No need to add another AND branch
+		return RETURN_OK;
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	return findOrInsertRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			lastTest.left(), reporterFrom, reporterTo, reporterInverted,
+			&lastTest);
+}
+
+ReturnValue_t EventMatchTree::removeMatch(EventId_t idFrom, EventId_t idTo,
+		bool idInverted, object_id_t reporterFrom, object_id_t reporterTo,
+		bool reporterInverted) {
+
+	iterator foundElement;
+
+	if (idFrom == 0) {
+		//Assuming a "forward all events" request.
+		idTo = 0;
+		idInverted = true;
+	}
+	if (idTo == 0) {
+		idTo = idFrom;
+	}
+	foundElement = findRangeMatcher<EventId_t, EventIdRangeMatcher>(begin(),
+			idFrom, idTo, idInverted);
+	if (foundElement == end()) {
+		return NO_MATCH; //Can't tell if too detailed or just not found.
+	}
+	if (reporterFrom == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	if (reporterTo == 0) {
+		reporterTo = reporterFrom;
+	}
+	foundElement = findRangeMatcher<object_id_t, ReporterRangeMatcher>(
+			foundElement.left(), reporterFrom, reporterTo, reporterInverted);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	} else {
+		return removeElementAndReconnectChildren(foundElement);
+	}
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+inline ReturnValue_t EventMatchTree::findOrInsertRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted, iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			return RETURN_OK;
+		} else {
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<EventMessage*>* newContent = factory.generate<
+			INSERTION_T>(idFrom, idTo, inverted);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+EventMatchTree::iterator EventMatchTree::findRangeMatcher(iterator start,
+		VALUE_T idFrom, VALUE_T idTo, bool inverted) {
+	iterator iter = start;
+	while (iter != end()) {
+		INSERTION_T* matcher = static_cast<INSERTION_T*>(*iter);
+		if ((matcher->rangeMatcher.lowerBound == idFrom)
+				&& (matcher->rangeMatcher.upperBound == idTo)
+				&& (matcher->rangeMatcher.inverted == inverted)) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t EventMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//If deletion fails, delete element anyway, nothing we can do.
+	//SHOULDO: Throw event, or write debug output.
+	return factory.destroy(position.element);
+}
diff --git a/events/eventmatching/EventMatchTree.h b/events/eventmatching/EventMatchTree.h
index ba02217a..82a6de81 100644
--- a/events/eventmatching/EventMatchTree.h
+++ b/events/eventmatching/EventMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
-
-#include "../../container/PlacementFactory.h"
-#include "../../events/EventMessage.h"
-#include "../../globalfunctions/matching/MatchTree.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-class StorageManagerIF;
-
-class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
-public:
-	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
-	virtual ~EventMatchTree();
-	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
-			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
-			bool reporterInverted = false);
-	bool match(EventMessage* number);
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	PlacementFactory factory;
-	bool invertedMatch;
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
-			VALUE_T idTo, bool inverted, iterator* lastTest);
-
-	template<typename VALUE_T, typename INSERTION_T>
-	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
-			bool inverted);
-
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class StorageManagerIF;
+
+class EventMatchTree: public MatchTree<EventMessage*>, public HasReturnvaluesIF {
+public:
+	EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch);
+	virtual ~EventMatchTree();
+	ReturnValue_t addMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	ReturnValue_t removeMatch(EventId_t idFrom = 0, EventId_t idTo = 0, bool idInverted = false,
+			object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
+			bool reporterInverted = false);
+	bool match(EventMessage* number);
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	PlacementFactory factory;
+	bool invertedMatch;
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertRangeMatcher(iterator start, VALUE_T idFrom,
+			VALUE_T idTo, bool inverted, iterator* lastTest);
+
+	template<typename VALUE_T, typename INSERTION_T>
+	iterator findRangeMatcher(iterator start, VALUE_T idFrom, VALUE_T idTo,
+			bool inverted);
+
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ */
diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h
index ab42800a..e9d57f1c 100644
--- a/events/eventmatching/EventRangeMatcherBase.h
+++ b/events/eventmatching/EventRangeMatcherBase.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
-
-#include "../../events/EventMessage.h"
-#include "../../globalfunctions/matching/RangeMatcher.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-
-template <typename T>
-class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
-	friend class EventMatchTree;
-public:
-	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
-	virtual ~EventRangeMatcherBase() { }
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return rangeMatcher.getSerializedSize();
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
-	}
-protected:
-	RangeMatcher<T> rangeMatcher;
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_
+
+#include "../../events/EventMessage.h"
+#include "../../globalfunctions/matching/RangeMatcher.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+
+template <typename T>
+class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
+	friend class EventMatchTree;
+public:
+	EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) {	}
+	virtual ~EventRangeMatcherBase() { }
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return rangeMatcher.getSerializedSize();
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return rangeMatcher.deSerialize(buffer, size, streamEndianness);
+	}
+protected:
+	RangeMatcher<T> rangeMatcher;
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ */
diff --git a/events/eventmatching/ReporterRangeMatcher.cpp b/events/eventmatching/ReporterRangeMatcher.cpp
index 6751b5e0..61179726 100644
--- a/events/eventmatching/ReporterRangeMatcher.cpp
+++ b/events/eventmatching/ReporterRangeMatcher.cpp
@@ -1,13 +1,13 @@
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-
-ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
-		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
-}
-
-ReporterRangeMatcher::~ReporterRangeMatcher() {
-	
-}
-
-bool ReporterRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getReporter());
-}
+#include "ReporterRangeMatcher.h"
+
+ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper,
+		bool inverted) : EventRangeMatcherBase<object_id_t>(lower, upper, inverted) {
+}
+
+ReporterRangeMatcher::~ReporterRangeMatcher() {
+	
+}
+
+bool ReporterRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getReporter());
+}
diff --git a/events/eventmatching/ReporterRangeMatcher.h b/events/eventmatching/ReporterRangeMatcher.h
index ee23d076..9a0a5fcf 100644
--- a/events/eventmatching/ReporterRangeMatcher.h
+++ b/events/eventmatching/ReporterRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
-public:
-	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
-	~ReporterRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class ReporterRangeMatcher: public EventRangeMatcherBase<object_id_t> {
+public:
+	ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted);
+	~ReporterRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ */
diff --git a/events/eventmatching/SeverityRangeMatcher.cpp b/events/eventmatching/SeverityRangeMatcher.cpp
index 41eb9020..6fd38271 100644
--- a/events/eventmatching/SeverityRangeMatcher.cpp
+++ b/events/eventmatching/SeverityRangeMatcher.cpp
@@ -1,14 +1,14 @@
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-#include "../../events/EventMessage.h"
-#include "../../serialize/SerializeAdapter.h"
-
-SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
-		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
-}
-
-SeverityRangeMatcher::~SeverityRangeMatcher() {
-}
-
-bool SeverityRangeMatcher::match(EventMessage* message) {
-	return rangeMatcher.match(message->getSeverity());
-}
+#include "SeverityRangeMatcher.h"
+#include "../../events/EventMessage.h"
+#include "../../serialize/SerializeAdapter.h"
+
+SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from,
+		EventSeverity_t till, bool inverted) : EventRangeMatcherBase<EventSeverity_t>(from, till, inverted) {
+}
+
+SeverityRangeMatcher::~SeverityRangeMatcher() {
+}
+
+bool SeverityRangeMatcher::match(EventMessage* message) {
+	return rangeMatcher.match(message->getSeverity());
+}
diff --git a/events/eventmatching/SeverityRangeMatcher.h b/events/eventmatching/SeverityRangeMatcher.h
index b3c3fbc8..3f7cc418 100644
--- a/events/eventmatching/SeverityRangeMatcher.h
+++ b/events/eventmatching/SeverityRangeMatcher.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
-
-#include "../../events/eventmatching/EventRangeMatcherBase.h"
-
-class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
-public:
-	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
-	~SeverityRangeMatcher();
-	bool match(EventMessage* message);
-};
-
-#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
+#ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+#define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_
+
+#include "EventRangeMatcherBase.h"
+
+class SeverityRangeMatcher: public EventRangeMatcherBase<EventSeverity_t> {
+public:
+	SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted);
+	~SeverityRangeMatcher();
+	bool match(EventMessage* message);
+};
+
+#endif /* FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ */
diff --git a/events/eventmatching/eventmatching.h b/events/eventmatching/eventmatching.h
index 85b852a5..7a87e177 100644
--- a/events/eventmatching/eventmatching.h
+++ b/events/eventmatching/eventmatching.h
@@ -1,10 +1,10 @@
-#ifndef EVENTMATCHING_H_
-#define EVENTMATCHING_H_
-
-#include "../../events/eventmatching/EventIdRangeMatcher.h"
-#include "../../events/eventmatching/EventMatchTree.h"
-#include "../../events/eventmatching/ReporterRangeMatcher.h"
-#include "../../events/eventmatching/SeverityRangeMatcher.h"
-
-
-#endif /* EVENTMATCHING_H_ */
+#ifndef EVENTMATCHING_H_
+#define EVENTMATCHING_H_
+
+#include "EventIdRangeMatcher.h"
+#include "EventMatchTree.h"
+#include "ReporterRangeMatcher.h"
+#include "SeverityRangeMatcher.h"
+
+
+#endif /* EVENTMATCHING_H_ */

From 9f522466f0529e4fc56abc0ebf2d952e82d39e89 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:52:13 +0200
Subject: [PATCH 0679/1292] wrapped info output in additonal ifdef

---
 events/EventManager.cpp | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 5848dd74..d459fa4c 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -111,25 +111,27 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 
 #ifdef DEBUG
 
-//forward declaration, should be implemented by mission
-const char* translateObject(object_id_t object);
-const char * translateEvents(Event event);
+// forward declaration, should be implemented by mission
+extern const char* translateObject(object_id_t object);
+extern const char* translateEvents(Event event);
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-//		string = translateObject(message->getReporter());
-//		sif::info << "EVENT: ";
-//		if (string != 0) {
-//			sif::info << string;
-//		} else {
-//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-//		}
-//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-//				<< message->getParameter1() << " P2: 0x"
-//				<< message->getParameter2() << std::dec << std::endl;
+#ifdef DEBUG_INFO_EVENT
+		string = translateObject(message->getReporter());
+		sif::info << "EVENT: ";
+		if (string != 0) {
+			sif::info << string;
+		} else {
+			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
+				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
+				<< message->getParameter1() << " P2: 0x"
+				<< message->getParameter2() << std::dec << std::endl;
+#endif
 		break;
 	default:
 		string = translateObject(message->getReporter());
@@ -152,7 +154,6 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::endl;
 		break;
 	}
-
 }
 #endif
 

From b71cab399330f3ae631bb51fd2cfdbb43dd32cf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:55:13 +0200
Subject: [PATCH 0680/1292] integrated all changes

---
 events/EventManager.cpp | 59 +++++++++++++++++++++++------------------
 events/EventManager.h   | 10 +++++--
 2 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e58f251a..e71951e3 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -8,13 +8,16 @@
 const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
 		sizeof(ReporterRangeMatcher) };
-//If one checks registerListener calls, there are around 40 (to max 50) objects registering for certain events.
-//Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher. So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// If one checks registerListener calls, there are around 40 (to max 50)
+// objects registering for certain events.
+// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
+// So a good guess is 75 to a max of 100 pools required for each, which fits well.
+// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
 EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId), eventReportQueue(NULL), mutex(NULL), factoryBackend(
-				0, POOL_SIZES, N_ELEMENTS, false, true) {
+		SystemObject(setObjectId),
+		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
@@ -108,41 +111,45 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 
 #ifdef DEBUG
 
-//forward declaration, should be implemented by mission
-const char* translateObject(object_id_t object);
-const char * translateEvents(Event event);
-
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-//		string = translateObject(message->getReporter());
-//		sif::info << "EVENT: ";
-//		if (string != 0) {
-//			sif::info << string;
-//		} else {
-//			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-//		}
-//		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-//				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-//				<< message->getParameter1() << " P2: 0x"
-//				<< message->getParameter2() << std::dec << std::endl;
-		break;
-	default:
+#ifdef DEBUG_INFO_EVENT
 		string = translateObject(message->getReporter());
-		sif::error << "EVENT: ";
+		sif::info << "EVENT: ";
 		if (string != 0) {
-			sif::error << string;
+			sif::info << string;
 		} else {
-			sif::error << "0x" << std::hex << message->getReporter() << std::dec;
+			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
 		}
-		sif::error << " reported " << translateEvents(message->getEvent()) << " ("
+		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
+#endif
+		break;
+	default:
+		string = translateObject(message->getReporter());
+		sif::debug << "EventManager: ";
+		if (string != 0) {
+			sif::debug << string;
+		}
+		else {
+			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
+		}
+		sif::debug << " reported " << translateEvents(message->getEvent())
+				<< " (" << std::dec << message->getEventId() << ") "
+				<< std::endl;
+
+		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
+				<< ", P1 Dec: " << std::dec << message->getParameter1()
+				<< std::endl;
+		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
+				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
+				<< std::endl;
 		break;
 	}
-
 }
 #endif
 
diff --git a/events/EventManager.h b/events/EventManager.h
index 7badc3bf..2602aeb2 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -10,6 +10,12 @@
 #include "../ipc/MutexIF.h"
 #include <map>
 
+#ifdef DEBUG
+// forward declaration, should be implemented by mission
+extern const char* translateObject(object_id_t object);
+extern const char* translateEvents(Event event);
+#endif
+
 class EventManager: public EventManagerIF,
 		public ExecutableObjectIF,
 		public SystemObject {
@@ -36,11 +42,11 @@ public:
 	ReturnValue_t performOperation(uint8_t opCode);
 protected:
 
-	MessageQueueIF* eventReportQueue;
+	MessageQueueIF* eventReportQueue = nullptr;
 
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
-	MutexIF* mutex;
+	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool<N_POOLS> factoryBackend;

From 9abd796e6fd1ad0d8fa91e78bf7b68e8d61ca61b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 17:58:36 +0200
Subject: [PATCH 0681/1292] updated map packet extraction

---
 datalinklayer/MapPacketExtraction.cpp | 17 +++++------------
 datalinklayer/MapPacketExtraction.h   |  8 +-------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index cb12b321..45f7d3f8 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.cpp
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #include "MapPacketExtraction.h"
 #include "../ipc/QueueFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -12,14 +5,14 @@
 #include "../tmtcpacket/SpacePacketBase.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include <cstring>
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
 		object_id_t setPacketDestination) :
-		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0), bufferPosition(
-				packetBuffer), packetDestination(setPacketDestination), packetStore(
-				NULL), tcQueueId(MessageQueueSenderIF::NO_QUEUE) {
-	memset(packetBuffer, 0, sizeof(packetBuffer));
+		lastSegmentationFlag(NO_SEGMENTATION), mapId(setMapId), packetLength(0),
+		bufferPosition(packetBuffer), packetDestination(setPacketDestination),
+		packetStore(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
 ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index 507f13db..eff9b7c3 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,10 +1,3 @@
-/**
- * @file	MapPacketExtraction.h
- * @brief	This file defines the MapPacketExtraction class.
- * @date	26.03.2013
- * @author	baetz
- */
-
 #ifndef MAPPACKETEXTRACTION_H_
 #define MAPPACKETEXTRACTION_H_
 
@@ -20,6 +13,7 @@ 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:

From 1b9c8446b7bb7fa005eaf7ce390c12800a3a2177 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:33:29 +0200
Subject: [PATCH 0682/1292] renormalized line endings

---
 container/ArrayList.h                         |  494 +-
 container/DynamicFIFO.h                       |   84 +-
 container/FIFO.h                              |   68 +-
 container/FIFOBase.h                          |  130 +-
 container/FixedArrayList.h                    |  114 +-
 container/FixedMap.h                          |  450 +-
 container/HybridIterator.h                    |  180 +-
 container/IndexedRingMemoryArray.h            | 1442 +++---
 container/PlacementFactory.h                  |   70 +-
 container/RingBufferBase.h                    |  226 +-
 container/SharedRingBuffer.cpp                |   60 +-
 container/SharedRingBuffer.h                  |  136 +-
 container/SimpleRingBuffer.cpp                |  270 +-
 container/SimpleRingBuffer.h                  |  256 +-
 contrib/sgp4/sgp4unit.cpp                     | 4180 ++++++++---------
 contrib/sgp4/sgp4unit.h                       |  234 +-
 controller/ControllerBase.cpp                 |  280 +-
 controller/ControllerBase.h                   |  188 +-
 datapool/ControllerSet.cpp                    |   28 +-
 datapool/ControllerSet.h                      |   30 +-
 datapool/HkSwitchHelper.cpp                   |  150 +-
 datapool/HkSwitchHelper.h                     |   92 +-
 datapool/PoolEntry.cpp                        |  174 +-
 datapool/PoolEntry.h                          |  260 +-
 datapool/PoolEntryIF.h                        |  126 +-
 datapool/PoolRawAccessHelper.cpp              |  376 +-
 datapool/PoolRawAccessHelper.h                |  222 +-
 datapool/PoolVarList.h                        |   56 +-
 datapoolglob/DataPoolAdmin.cpp                |  600 +--
 datapoolglob/DataPoolAdmin.h                  |  118 +-
 datapoolglob/DataPoolParameterWrapper.cpp     |  358 +-
 datapoolglob/DataPoolParameterWrapper.h       |   76 +-
 datapoolglob/GlobalDataPool.cpp               |  266 +-
 datapoolglob/GlobalDataPool.h                 |  298 +-
 datapoolglob/GlobalPoolVariable.h             |  426 +-
 datapoolglob/GlobalPoolVector.h               |  370 +-
 datapoolglob/PIDReader.h                      |  328 +-
 datapoolglob/PIDReaderList.h                  |   54 +-
 datapoolglob/PoolRawAccess.cpp                |  478 +-
 datapoolglob/PoolRawAccess.h                  |  440 +-
 datapoollocal/LocalPoolVector.h               |  400 +-
 datapoollocal/SharedLocalDataSet.cpp          |   32 +-
 devicehandlers/AcceptsDeviceResponsesIF.h     |   38 +-
 devicehandlers/AssemblyBase.cpp               |  546 +--
 devicehandlers/AssemblyBase.h                 |  326 +-
 devicehandlers/ChildHandlerBase.cpp           |   94 +-
 devicehandlers/ChildHandlerBase.h             |   48 +-
 devicehandlers/ChildHandlerFDIR.cpp           |   20 +-
 devicehandlers/ChildHandlerFDIR.h             |   40 +-
 devicehandlers/CommunicationMessage.cpp       |  402 +-
 devicehandlers/CommunicationMessage.h         |  346 +-
 devicehandlers/DeviceCommunicationIF.h        |  254 +-
 devicehandlers/DeviceHandlerIF.h              |  310 +-
 devicehandlers/DeviceHandlerMessage.cpp       |  202 +-
 devicehandlers/DeviceHandlerMessage.h         |  182 +-
 devicehandlers/DeviceTmReportingWrapper.cpp   |   92 +-
 devicehandlers/DeviceTmReportingWrapper.h     |   54 +-
 devicehandlers/HealthDevice.cpp               |  118 +-
 devicehandlers/HealthDevice.h                 |   80 +-
 fdir/ConfirmsFailuresIF.h                     |   40 +-
 fdir/EventCorrelation.cpp                     |   88 +-
 fdir/EventCorrelation.h                       |   46 +-
 fdir/FailureIsolationBase.cpp                 |  328 +-
 fdir/FailureIsolationBase.h                   |  112 +-
 fdir/FaultCounter.cpp                         |  172 +-
 fdir/FaultCounter.h                           |   76 +-
 globalfunctions/AsciiConverter.cpp            |  460 +-
 globalfunctions/AsciiConverter.h              |   78 +-
 globalfunctions/CRC.cpp                       |  278 +-
 globalfunctions/DleEncoder.cpp                |  248 +-
 globalfunctions/DleEncoder.h                  |  158 +-
 globalfunctions/Type.cpp                      |  362 +-
 globalfunctions/Type.h                        |  188 +-
 globalfunctions/arrayprinter.cpp              |  122 +-
 globalfunctions/matching/BinaryMatcher.h      |   82 +-
 globalfunctions/matching/DecimalMatcher.h     |  100 +-
 globalfunctions/matching/MatchTree.h          |  432 +-
 globalfunctions/matching/RangeMatcher.h       |  140 +-
 .../matching/SerializeableMatcherIF.h         |   26 +-
 globalfunctions/math/QuaternionOperations.cpp |  312 +-
 globalfunctions/timevalOperations.cpp         |  198 +-
 health/HasHealthIF.h                          |  100 +-
 health/HealthHelper.cpp                       |  210 +-
 health/HealthHelper.h                         |  242 +-
 health/HealthMessage.cpp                      |   56 +-
 health/HealthMessage.h                        |   60 +-
 health/HealthTable.cpp                        |  200 +-
 health/HealthTable.h                          |   70 +-
 health/HealthTableIF.h                        |   56 +-
 health/ManagesHealthIF.h                      |  104 +-
 housekeeping/AcceptsHkPacketsIF.h             |   22 +-
 internalError/InternalErrorReporter.cpp       |  250 +-
 internalError/InternalErrorReporter.h         |  100 +-
 ipc/CommandMessage.cpp                        |  222 +-
 ipc/CommandMessage.h                          |  258 +-
 ipc/CommandMessageCleaner.cpp                 |   90 +-
 ipc/CommandMessageCleaner.h                   |   32 +-
 ipc/CommandMessageIF.h                        |  146 +-
 ipc/MessageQueueIF.h                          |  342 +-
 ipc/MessageQueueMessage.cpp                   |  168 +-
 ipc/MessageQueueMessage.h                     |  300 +-
 ipc/MessageQueueSenderIF.h                    |   50 +-
 ipc/MutexFactory.h                            |   68 +-
 ipc/MutexHelper.h                             |   60 +-
 ipc/MutexIF.h                                 |  178 +-
 ipc/QueueFactory.h                            |   66 +-
 memory/AcceptsMemoryMessagesIF.h              |   42 +-
 memory/FileSystemMessage.cpp                  |   56 +-
 memory/FileSystemMessage.h                    |   60 +-
 memory/HasFileSystemIF.h                      |   72 +-
 memory/HasMemoryIF.h                          |   94 +-
 memory/MemoryHelper.cpp                       |  386 +-
 memory/MemoryHelper.h                         |   74 +-
 memory/MemoryMessage.cpp                      |  224 +-
 memory/MemoryMessage.h                        |   78 +-
 memory/MemoryProxyIF.h                        |   44 +-
 modes/HasModesIF.h                            |  114 +-
 modes/ModeHelper.cpp                          |  270 +-
 modes/ModeHelper.h                            |  106 +-
 modes/ModeMessage.cpp                         |   62 +-
 modes/ModeMessage.h                           |   80 +-
 monitoring/AbsLimitMonitor.h                  |  146 +-
 monitoring/HasMonitorsIF.h                    |   60 +-
 monitoring/LimitMonitor.h                     |  190 +-
 monitoring/LimitViolationReporter.cpp         |  120 +-
 monitoring/LimitViolationReporter.h           |   62 +-
 monitoring/MonitorBase.h                      |  124 +-
 monitoring/MonitorReporter.h                  |  356 +-
 monitoring/MonitoringIF.h                     |  134 +-
 monitoring/MonitoringMessage.cpp              |   76 +-
 monitoring/MonitoringMessage.h                |   42 +-
 monitoring/MonitoringMessageContent.h         |  154 +-
 monitoring/ReceivesMonitoringReportsIF.h      |   30 +-
 monitoring/TriplexMonitor.h                   |  310 +-
 monitoring/TwoValueLimitMonitor.h             |   88 +-
 objectmanager/ObjectManager.cpp               |  214 +-
 objectmanager/ObjectManager.h                 |  134 +-
 objectmanager/ObjectManagerIF.h               |  190 +-
 objectmanager/SystemObject.cpp                |   74 +-
 objectmanager/SystemObjectIF.h                |  124 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  190 +-
 osal/FreeRTOS/BinSemaphUsingTask.h            |  158 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |  216 +-
 osal/FreeRTOS/BinarySemaphore.h               |  214 +-
 osal/FreeRTOS/Clock.cpp                       |  392 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  228 +-
 osal/FreeRTOS/CountingSemaphUsingTask.h       |  210 +-
 osal/FreeRTOS/CountingSemaphore.cpp           |   86 +-
 osal/FreeRTOS/CountingSemaphore.h             |   68 +-
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  332 +-
 osal/FreeRTOS/FixedTimeslotTask.h             |  202 +-
 osal/FreeRTOS/MessageQueue.h                  |  298 +-
 osal/FreeRTOS/Mutex.cpp                       |  102 +-
 osal/FreeRTOS/Mutex.h                         |   58 +-
 osal/FreeRTOS/MutexFactory.cpp                |   56 +-
 osal/FreeRTOS/QueueFactory.cpp                |   72 +-
 osal/FreeRTOS/SemaphoreFactory.cpp            |  118 +-
 osal/FreeRTOS/TaskFactory.cpp                 |  106 +-
 osal/FreeRTOS/TaskManagement.cpp              |   48 +-
 osal/FreeRTOS/TaskManagement.h                |  128 +-
 osal/FreeRTOS/Timekeeper.cpp                  |   82 +-
 osal/FreeRTOS/Timekeeper.h                    |   80 +-
 osal/InternalErrorCodes.h                     |   78 +-
 osal/host/Clock.cpp                           |  454 +-
 osal/host/FixedTimeslotTask.cpp               |  382 +-
 osal/host/FixedTimeslotTask.h                 |  260 +-
 osal/host/MessageQueue.cpp                    |  310 +-
 osal/host/MessageQueue.h                      |  460 +-
 osal/host/Mutex.cpp                           |   80 +-
 osal/host/Mutex.h                             |   56 +-
 osal/host/MutexFactory.cpp                    |   56 +-
 osal/host/PeriodicTask.cpp                    |  352 +-
 osal/host/PeriodicTask.h                      |  246 +-
 osal/host/QueueFactory.cpp                    |   82 +-
 osal/host/QueueMapManager.cpp                 |  102 +-
 osal/host/QueueMapManager.h                   |   94 +-
 osal/host/SemaphoreFactory.cpp                |   84 +-
 osal/host/TaskFactory.cpp                     |  110 +-
 osal/linux/BinarySemaphore.cpp                |  298 +-
 osal/linux/BinarySemaphore.h                  |  162 +-
 osal/linux/Clock.cpp                          |  440 +-
 osal/linux/CountingSemaphore.cpp              |  108 +-
 osal/linux/CountingSemaphore.h                |   74 +-
 osal/linux/FixedTimeslotTask.cpp              |  192 +-
 osal/linux/FixedTimeslotTask.h                |  154 +-
 osal/linux/InternalErrorCodes.cpp             |   28 +-
 osal/linux/MessageQueue.cpp                   |  738 +--
 osal/linux/MessageQueue.h                     |  374 +-
 osal/linux/Mutex.cpp                          |  222 +-
 osal/linux/Mutex.h                            |   44 +-
 osal/linux/MutexFactory.cpp                   |   46 +-
 osal/linux/PeriodicPosixTask.cpp              |  166 +-
 osal/linux/PeriodicPosixTask.h                |  180 +-
 osal/linux/PosixThread.cpp                    |  434 +-
 osal/linux/PosixThread.h                      |  154 +-
 osal/linux/QueueFactory.cpp                   |   76 +-
 osal/linux/SemaphoreFactory.cpp               |   66 +-
 osal/linux/TaskFactory.cpp                    |   84 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |  274 +-
 osal/linux/TcUnixUdpPollingTask.h             |  134 +-
 osal/linux/Timer.cpp                          |   84 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  336 +-
 osal/linux/TmTcUnixUdpBridge.h                |   96 +-
 osal/rtems/Clock.cpp                          |  396 +-
 osal/rtems/CpuUsage.cpp                       |  366 +-
 osal/rtems/CpuUsage.h                         |  106 +-
 osal/rtems/InternalErrorCodes.cpp             |  120 +-
 osal/rtems/Interrupt.h                        |  100 +-
 osal/rtems/MessageQueue.cpp                   |  294 +-
 osal/rtems/MessageQueue.h                     |  362 +-
 osal/rtems/MultiObjectTask.cpp                |  174 +-
 osal/rtems/MultiObjectTask.h                  |  226 +-
 osal/rtems/Mutex.cpp                          |  130 +-
 osal/rtems/Mutex.h                            |   36 +-
 osal/rtems/MutexFactory.cpp                   |   48 +-
 osal/rtems/PollingTask.cpp                    |  244 +-
 osal/rtems/PollingTask.h                      |  170 +-
 osal/rtems/QueueFactory.cpp                   |  118 +-
 osal/rtems/RtemsBasic.h                       |   50 +-
 osal/rtems/TaskBase.cpp                       |  164 +-
 osal/rtems/TaskBase.h                         |   94 +-
 osal/rtems/TaskFactory.cpp                    |   82 +-
 parameters/HasParametersIF.h                  |  134 +-
 parameters/ParameterHelper.cpp                |  264 +-
 parameters/ParameterHelper.h                  |   72 +-
 parameters/ParameterMessage.cpp               |   96 +-
 parameters/ParameterMessage.h                 |   58 +-
 parameters/ParameterWrapper.cpp               |  560 +--
 parameters/ParameterWrapper.h                 |  324 +-
 parameters/ReceivesParameterMessagesIF.h      |   38 +-
 power/Fuse.cpp                                |  520 +-
 power/Fuse.h                                  |  212 +-
 power/PowerComponent.cpp                      |  172 +-
 power/PowerComponent.h                        |   96 +-
 power/PowerComponentIF.h                      |   48 +-
 power/PowerSensor.cpp                         |  256 +-
 power/PowerSensor.h                           |  142 +-
 power/PowerSwitchIF.h                         |  160 +-
 power/PowerSwitcher.cpp                       |  254 +-
 power/PowerSwitcher.h                         |   90 +-
 pus/CService200ModeCommanding.cpp             |  238 +-
 pus/CService200ModeCommanding.h               |  170 +-
 pus/CService201HealthCommanding.cpp           |  168 +-
 pus/CService201HealthCommanding.h             |  116 +-
 pus/Service1TelecommandVerification.cpp       |  200 +-
 pus/Service1TelecommandVerification.h         |  188 +-
 pus/Service2DeviceAccess.cpp                  |  330 +-
 pus/Service2DeviceAccess.h                    |  184 +-
 pus/Service5EventReporting.cpp                |  182 +-
 pus/Service5EventReporting.h                  |  172 +-
 pus/Service8FunctionManagement.cpp            |  284 +-
 pus/Service8FunctionManagement.h              |  134 +-
 pus/servicepackets/Service1Packets.h          |  332 +-
 pus/servicepackets/Service200Packets.h        |  126 +-
 pus/servicepackets/Service201Packets.h        |   96 +-
 pus/servicepackets/Service2Packets.h          |  152 +-
 pus/servicepackets/Service5Packets.h          |  152 +-
 pus/servicepackets/Service8Packets.h          |  242 +-
 returnvalues/HasReturnvaluesIF.h              |   62 +-
 rmap/RMAP.cpp                                 |  178 +-
 rmap/RMAP.h                                   |  454 +-
 rmap/RMAPChannelIF.h                          |  232 +-
 rmap/RMAPCookie.cpp                           |  248 +-
 rmap/RMAPCookie.h                             |  118 +-
 rmap/RmapDeviceCommunicationIF.cpp            |   94 +-
 rmap/RmapDeviceCommunicationIF.h              |  178 +-
 serialize/EndianConverter.h                   |  248 +-
 serialize/SerialArrayListAdapter.h            |  182 +-
 serialize/SerialBufferAdapter.cpp             |  258 +-
 serialize/SerialBufferAdapter.h               |  156 +-
 serialize/SerialFixedArrayListAdapter.h       |  126 +-
 serialize/SerialLinkedListAdapter.h           |  266 +-
 serialize/SerializeAdapter.h                  |  350 +-
 serialize/SerializeElement.h                  |  120 +-
 serialize/SerializeIF.h                       |  116 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   |  434 +-
 serviceinterface/ServiceInterfaceBuffer.h     |  290 +-
 serviceinterface/ServiceInterfaceStream.cpp   |   64 +-
 serviceinterface/ServiceInterfaceStream.h     |  116 +-
 storagemanager/ConstStorageAccessor.cpp       |  174 +-
 storagemanager/ConstStorageAccessor.h         |  232 +-
 storagemanager/LocalPool.h                    |  378 +-
 storagemanager/PoolManager.h                  |   98 +-
 storagemanager/StorageAccessor.cpp            |  134 +-
 storagemanager/StorageAccessor.h              |   90 +-
 storagemanager/StorageManagerIF.h             |  334 +-
 subsystem/Subsystem.h                         |  328 +-
 subsystem/SubsystemBase.cpp                   |  712 +--
 subsystem/SubsystemBase.h                     |  258 +-
 subsystem/modes/HasModeSequenceIF.h           |   40 +-
 subsystem/modes/ModeDefinitions.h             |  304 +-
 subsystem/modes/ModeSequenceMessage.cpp       |  178 +-
 subsystem/modes/ModeSequenceMessage.h         |   96 +-
 subsystem/modes/ModeStore.cpp                 |  252 +-
 subsystem/modes/ModeStore.h                   |   90 +-
 subsystem/modes/ModeStoreIF.h                 |   74 +-
 tasks/ExecutableObjectIF.h                    |  106 +-
 tasks/FixedSequenceSlot.cpp                   |   34 +-
 tasks/FixedSequenceSlot.h                     |  114 +-
 tasks/FixedSlotSequence.cpp                   |  294 +-
 tasks/FixedSlotSequence.h                     |  318 +-
 tasks/FixedTimeslotTaskIF.h                   |   66 +-
 tasks/PeriodicTaskIF.h                        |   98 +-
 tasks/SemaphoreFactory.h                      |  100 +-
 tasks/SemaphoreIF.h                           |  136 +-
 tasks/TaskFactory.h                           |  146 +-
 tcdistribution/CCSDSDistributor.cpp           |  164 +-
 tcdistribution/CCSDSDistributor.h             |  138 +-
 tcdistribution/CCSDSDistributorIF.h           |   80 +-
 tcdistribution/PUSDistributor.cpp             |  184 +-
 tcdistribution/PUSDistributor.h               |  154 +-
 tcdistribution/PUSDistributorIF.h             |   52 +-
 tcdistribution/TcDistributor.cpp              |  108 +-
 tcdistribution/TcDistributor.h                |  240 +-
 tcdistribution/TcPacketCheck.cpp              |   74 +-
 tcdistribution/TcPacketCheck.h                |  118 +-
 thermal/AbstractTemperatureSensor.cpp         |  140 +-
 thermal/AbstractTemperatureSensor.h           |  128 +-
 thermal/AcceptsThermalMessagesIF.h            |   44 +-
 thermal/CoreComponent.h                       |  192 +-
 thermal/Heater.cpp                            |  700 +--
 thermal/Heater.h                              |  180 +-
 thermal/RedundantHeater.h                     |  100 +-
 thermal/TemperatureSensor.h                   |  444 +-
 thermal/ThermalComponentIF.h                  |  228 +-
 thermal/ThermalModule.cpp                     |  576 +--
 thermal/ThermalModule.h                       |  190 +-
 thermal/ThermalMonitor.cpp                    |  136 +-
 thermal/ThermalMonitor.h                      |   52 +-
 timemanager/CCSDSTime.cpp                     | 1204 ++---
 timemanager/CCSDSTime.h                       |  466 +-
 timemanager/Clock.h                           |  310 +-
 timemanager/Countdown.cpp                     |   90 +-
 timemanager/Countdown.h                       |   62 +-
 timemanager/ReceivesTimeInfoIF.h              |   64 +-
 timemanager/Stopwatch.cpp                     |  114 +-
 timemanager/Stopwatch.h                       |  142 +-
 timemanager/TimeMessage.cpp                   |   74 +-
 timemanager/TimeMessage.h                     |  112 +-
 timemanager/TimeStamperIF.h                   |   48 +-
 tmstorage/TmStoreBackendIF.h                  |  190 +-
 tmstorage/TmStoreFrontendIF.h                 |  126 +-
 tmstorage/TmStoreMessage.cpp                  |  330 +-
 tmstorage/TmStoreMessage.h                    |  126 +-
 tmstorage/TmStorePackets.h                    |  600 +--
 tmtcpacket/SpacePacket.cpp                    |   54 +-
 tmtcpacket/SpacePacket.h                      |  140 +-
 tmtcpacket/SpacePacketBase.cpp                |  208 +-
 tmtcpacket/SpacePacketBase.h                  |  354 +-
 tmtcpacket/packetmatcher/ApidMatcher.h        |   80 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp  |  390 +-
 tmtcpacket/packetmatcher/PacketMatchTree.h    |   72 +-
 tmtcpacket/packetmatcher/ServiceMatcher.h     |   78 +-
 tmtcpacket/packetmatcher/SubserviceMatcher.h  |   80 +-
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   32 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  186 +-
 tmtcpacket/pus/TcPacketBase.h                 |  408 +-
 tmtcpacket/pus/TcPacketStored.cpp             |  236 +-
 tmtcpacket/pus/TcPacketStored.h               |  220 +-
 tmtcpacket/pus/TmPacketBase.cpp               |  238 +-
 tmtcpacket/pus/TmPacketBase.h                 |  372 +-
 tmtcpacket/pus/TmPacketMinimal.cpp            |   90 +-
 tmtcpacket/pus/TmPacketMinimal.h              |  168 +-
 tmtcpacket/pus/TmPacketStored.cpp             |  292 +-
 tmtcpacket/pus/TmPacketStored.h               |  192 +-
 tmtcservices/AcceptsTelecommandsIF.h          |   86 +-
 tmtcservices/AcceptsTelemetryIF.h             |   52 +-
 tmtcservices/AcceptsVerifyMessageIF.h         |   30 +-
 tmtcservices/CommandingServiceBase.cpp        |  854 ++--
 tmtcservices/CommandingServiceBase.h          |  696 +--
 tmtcservices/PusServiceBase.cpp               |  246 +-
 tmtcservices/PusServiceBase.h                 |  318 +-
 tmtcservices/PusVerificationReport.cpp        |  326 +-
 tmtcservices/PusVerificationReport.h          |  154 +-
 tmtcservices/SourceSequenceCounter.h          |   60 +-
 tmtcservices/TmTcBridge.cpp                   |  474 +-
 tmtcservices/TmTcBridge.h                     |  324 +-
 tmtcservices/TmTcMessage.cpp                  |   58 +-
 tmtcservices/TmTcMessage.h                    |  100 +-
 tmtcservices/VerificationReporter.cpp         |  210 +-
 tmtcservices/VerificationReporter.h           |  100 +-
 381 files changed, 38723 insertions(+), 38723 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 436dc716..9f5e76de 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,247 +1,247 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeIF.h"
-
-/**
- * @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.
- *
- * @ingroup container
- */
-template<typename T, typename count_t = uint8_t>
-class ArrayList {
-	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);
-
-    /**
-     * 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;
-
-	/**
-	 * 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;
-		}
-	}
-
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
-
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
-
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
-
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
-
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
-
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
-
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
-
-        T operator*() {
-            return *value;
-        }
-
-        T *operator->() {
-            return value;
-        }
-
-        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]);
-	}
-
-	/**
-	 * 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]);
-	}
-
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
-
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
-
-	/**
-	 * 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());
-	}
-
-	const T* back() const{
-		return &entries[size-1];
-	}
-
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	uint32_t maxSize() const {
-		return this->maxSize_;
-	}
-
-	/**
-	 * 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_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
-};
-
-#endif /* ARRAYLIST_H_ */
+#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @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.
+ *
+ * @ingroup container
+ */
+template<typename T, typename count_t = uint8_t>
+class ArrayList {
+	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);
+
+    /**
+     * 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;
+
+	/**
+	 * 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;
+		}
+	}
+
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
+
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
+
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
+
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
+
+        T operator*() {
+            return *value;
+        }
+
+        T *operator->() {
+            return value;
+        }
+
+        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]);
+	}
+
+	/**
+	 * 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]);
+	}
+
+	T & operator[](count_t i) const {
+		return entries[i];
+	}
+
+	/**
+	 * The first element
+	 *
+	 * @return pointer to the first stored element
+	 */
+	T *front() {
+		return entries;
+	}
+
+	/**
+	 * 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());
+	}
+
+	const T* back() const{
+		return &entries[size-1];
+	}
+
+	/**
+	 * The maximum number of elements this List can contain
+	 *
+	 * @return maximum number of elements
+	 */
+	uint32_t maxSize() const {
+		return this->maxSize_;
+	}
+
+	/**
+	 * 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_;
+
+	/**
+	 * true if the array was allocated and needs to be deleted in the destructor.
+	 */
+	bool allocated;
+};
+
+#endif /* ARRAYLIST_H_ */
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index b63cee65..9af98f96 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,42 +1,42 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-
-#include "../container/FIFOBase.h"
-#include <vector>
-
-/**
- * @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!
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-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());
-	}
-
-
-private:
-	std::vector<T> fifoVector;
-};
-
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+
+#include "../container/FIFOBase.h"
+#include <vector>
+
+/**
+ * @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!
+ * The public interface of FIFOBase exposes the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+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());
+	}
+
+
+private:
+	std::vector<T> fifoVector;
+};
+
+#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index a870e773..4688a7b0 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../container/FIFOBase.h"
-#include <array>
-
-/**
- * @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.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class FIFO: public FIFOBase<T> {
-public:
-	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
-
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->setData(fifoArray.data());
-	}
-
-private:
-	std::array<T, capacity> fifoArray;
-};
-
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../container/FIFOBase.h"
+#include <array>
+
+/**
+ * @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.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class FIFO: public FIFOBase<T> {
+public:
+	FIFO(): FIFOBase<T>(fifoArray.data(), capacity) {};
+
+	/**
+	 * @brief 	Custom copy constructor to set pointer correctly.
+	 * @param other
+	 */
+	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->setData(fifoArray.data());
+	}
+
+private:
+	std::array<T, capacity> fifoArray;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index ddccbdd4..410e52a5 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,65 +1,65 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_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);
-
-	/** 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();
-
-	bool empty();
-	bool full();
-	size_t size();
-
-
-	size_t getMaxCapacity() const;
-
-protected:
-	void setData(T* data);
-	size_t maxCapacity = 0;
-
-	T* values;
-
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
-
-	size_t next(size_t current);
-};
-
-#include "../container/FIFOBase.tpp"
-
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_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);
+
+	/** 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();
+
+	bool empty();
+	bool full();
+	size_t size();
+
+
+	size_t getMaxCapacity() const;
+
+protected:
+	void setData(T* data);
+	size_t maxCapacity = 0;
+
+	T* values;
+
+	size_t readIndex = 0;
+	size_t writeIndex = 0;
+	size_t currentSize = 0;
+
+	size_t next(size_t current);
+};
+
+#include "../container/FIFOBase.tpp"
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index 70a1d5e2..da85c623 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,57 +1,57 @@
-#ifndef FIXEDARRAYLIST_H_
-#define FIXEDARRAYLIST_H_
-
-#include "../container/ArrayList.h"
-
-/**
- * @brief 	Array List with a fixed maximum size
- * @ingroup container
- */
-template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class FixedArrayList: public ArrayList<T, count_t> {
-private:
-	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) {
-	}
-
-	// (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;
-	}
-
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
-
-};
-
-#endif /* FIXEDARRAYLIST_H_ */
+#ifndef FIXEDARRAYLIST_H_
+#define FIXEDARRAYLIST_H_
+
+#include "../container/ArrayList.h"
+
+/**
+ * @brief 	Array List with a fixed maximum size
+ * @ingroup container
+ */
+template<typename T, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class FixedArrayList: public ArrayList<T, count_t> {
+private:
+	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) {
+	}
+
+	// (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;
+	}
+
+	FixedArrayList& operator=(FixedArrayList other) {
+		memcpy(this->data, other.data, sizeof(this->data));
+		this->entries = data;
+		return *this;
+	}
+
+	virtual ~FixedArrayList() {
+	}
+
+};
+
+#endif /* FIXEDARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index a3afc023..3da65784 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,225 +1,225 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
-
-#include "../container/ArrayList.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <utility>
-
-/**
- * @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).
- * @ingroup container
- */
-template<typename key_t, typename T>
-class FixedMap: public SerializeIF {
-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);
-
-private:
-	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;
-	}
-public:
-	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() {
-		}
-
-		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;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// 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;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			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 (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 insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.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;
-	}
-
-	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 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;
-	}
-
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
-
-	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;
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
-	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;
-	}
-
-};
-
-#endif /* FIXEDMAP_H_ */
+#ifndef FIXEDMAP_H_
+#define FIXEDMAP_H_
+
+#include "../container/ArrayList.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <utility>
+
+/**
+ * @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).
+ * @ingroup container
+ */
+template<typename key_t, typename T>
+class FixedMap: public SerializeIF {
+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);
+
+private:
+	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;
+	}
+public:
+	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() {
+		}
+
+		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;
+		}
+
+		// -> operator overloaded, can be used to access value
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		// 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;
+		}
+
+		// Alternative to access value, similar to std::map implementation
+		T second() {
+			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 (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 insert(std::pair<key_t, T> pair) {
+		return insert(pair.first, pair.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;
+	}
+
+	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 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;
+	}
+
+	T *findValue(key_t key) const {
+		return &theMap[findIndex(key)].second;
+	}
+
+	Iterator find(key_t key) const {
+		ReturnValue_t result = exists(key);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return end();
+		}
+		return Iterator(&theMap[findIndex(key)]);
+	}
+
+	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;
+	}
+
+	void clear() {
+		_size = 0;
+	}
+
+	uint32_t maxSize() const {
+		return theMap.maxSize();
+	}
+
+
+	bool full() {
+		if(_size == theMap.maxSize()) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	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;
+	}
+
+};
+
+#endif /* FIXEDMAP_H_ */
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 11881326..630bae28 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-
-#include "../container/ArrayList.h"
-#include "../container/SinglyLinkedList.h"
-
-template<typename T, typename count_t = uint8_t>
-class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
-public:
-	HybridIterator() {}
-
-	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(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& 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;
-	}
-
-	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 !(*this == other);
-	}
-
-	T operator*() {
-		return *value;
-	}
-
-	T *operator->() {
-		return value;
-	}
-
-	T* value = nullptr;
-
-private:
-	bool linked = false;
-	T *end = nullptr;
-};
-
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+
+#include "../container/ArrayList.h"
+#include "../container/SinglyLinkedList.h"
+
+template<typename T, typename count_t = uint8_t>
+class HybridIterator: public LinkedElement<T>::Iterator,
+		public ArrayList<T, count_t>::Iterator {
+public:
+	HybridIterator() {}
+
+	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(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& 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;
+	}
+
+	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 !(*this == other);
+	}
+
+	T operator*() {
+		return *value;
+	}
+
+	T *operator->() {
+		return value;
+	}
+
+	T* value = nullptr;
+
+private:
+	bool linked = false;
+	T *end = nullptr;
+};
+
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 282916e1..0968abfa 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,721 +1,721 @@
-#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-
-#include "../container/ArrayList.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include <cmath>
-
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
-template<typename T>
-class Index: public SerializeIF{
-	/**
-	 *
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
-public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
-
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
-	}
-
-	void setBlockStartAddress(uint32_t newAddress) {
-		this->blockStartAddress = newAddress;
-	}
-
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
-
-	const T* getIndexType() const {
-		return &indexType;
-	}
-
-	T* modifyIndexType() {
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
-
-	uint32_t getSize() const {
-		return size;
-	}
-
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
-
-	void addSize(uint32_t size){
-		this->size += size;
-	}
-
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
-
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
-
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
-
-
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
-
-private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
-};
-
-
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
-template<typename T>
-class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 *
-	 */
-public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
-
-		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
-
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
-
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-
-		//Update the totalSize for calculations
-		totalSize = useableSize;
-
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
-
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
-
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
-
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
-
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
-
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
-
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
-
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
-
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
-
-	/**
-	 * Reading
-	 * @param it
-	 */
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
-
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
-
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-
-	}
-
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
-
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
-
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}
-			else {
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}
-		else {
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0) {
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
-
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
-
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
-
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
-
-
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
-
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
-
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
-
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
-
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
-
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
-
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
-		return (sizeToWrite < availableSize);
-	}
-
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
-
-
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
-
-		size_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
-
-
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
-
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
-
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
-
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
-
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
-
-		return (double)filledSize/(double)this->totalSize;
-	}
-
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
-private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
-
-	//The address of the index
-	const uint32_t indexAddress;
-
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
-
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
-
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
-
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
-
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
-
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
-
-};
-
-#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
+
+#include "../container/ArrayList.h"
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include <cmath>
+
+/**
+ * Index is the Type used for the list of indices.
+ *
+ * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
+ * 			 to be able to make it persistent
+ */
+template<typename T>
+class Index: public SerializeIF{
+	/**
+	 *
+	 */
+	static_assert(std::is_base_of<SerializeIF,T>::value,
+			"Wrong Type for Index, Type must implement SerializeIF");
+public:
+	Index():blockStartAddress(0),size(0),storedPackets(0){}
+
+	Index(uint32_t startAddress):blockStartAddress(startAddress),
+			size(0),storedPackets(0) {
+	}
+
+	void setBlockStartAddress(uint32_t newAddress) {
+		this->blockStartAddress = newAddress;
+	}
+
+	uint32_t getBlockStartAddress() const {
+		return blockStartAddress;
+	}
+
+	const T* getIndexType() const {
+		return &indexType;
+	}
+
+	T* modifyIndexType() {
+		return &indexType;
+	}
+	/**
+	 * Updates the index Type. Uses = operator
+	 * @param indexType Type to copy from
+	 */
+	void setIndexType(T* indexType) {
+		this->indexType = *indexType;
+	}
+
+	uint32_t getSize() const {
+		return size;
+	}
+
+	void setSize(uint32_t size) {
+		this->size = size;
+	}
+
+	void addSize(uint32_t size){
+		this->size += size;
+	}
+
+	void setStoredPackets(uint32_t newStoredPackets){
+		this->storedPackets = newStoredPackets;
+	}
+
+	void addStoredPackets(uint32_t packets){
+		this->storedPackets += packets;
+	}
+
+	uint32_t getStoredPackets() const{
+		return this->storedPackets;
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = indexType.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+		size += indexType.getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+		return size;
+	}
+
+
+	bool operator==(const Index<T>& other){
+		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+	}
+
+private:
+	uint32_t blockStartAddress;
+	uint32_t size;
+	uint32_t storedPackets;
+	T indexType;
+};
+
+
+/**
+ * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
+ * @details
+ * It assumes that the newest data comes in last
+ * It uses the currentWriteBlock as pointer to the current writing position
+ * The currentReadBlock must be set manually
+ * @tparam T
+ */
+template<typename T>
+class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
+	/**
+	 *
+	 */
+public:
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
+			SerializeIF* additionalInfo, bool overwriteOld):
+			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
+			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
+			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
+	{
+		//Calculate the maximum number of indices needed for this blocksize
+		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+
+		//Calculate the Size needeed for the index itself
+		size_t serializedSize = 0;
+		if(additionalInfo!=NULL) {
+			serializedSize += additionalInfo->getSerializedSize();
+		}
+
+		//Size of current iterator type
+		Index<T> tempIndex;
+		serializedSize += tempIndex.getSerializedSize();
+
+		//Add Size of Array
+		serializedSize += sizeof(uint32_t); //size of array
+		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+		serializedSize += sizeof(uint16_t); //size of crc
+
+		//Calculate new size after index
+		if(serializedSize > totalSize){
+			error << "IndexedRingMemory: Store is too small for index" << std::endl;
+		}
+		uint32_t useableSize = totalSize - serializedSize;
+
+		//Update the totalSize for calculations
+		totalSize = useableSize;
+
+		//True StartAddress
+		uint32_t trueStartAddress = indexAddress + serializedSize;
+
+		//Calculate True number of Blocks and reset size of true Number of Blocks
+		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+
+		//allocate memory now
+		this->entries = new Index<T>[trueNumberOfBlocks];
+		this->size = trueNumberOfBlocks;
+		this->maxSize_ = trueNumberOfBlocks;
+		this->allocated = true;
+
+		//Check trueNumberOfBlocks
+		if(trueNumberOfBlocks<1) {
+			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+		}
+
+		//Fill address into index
+		uint32_t address = trueStartAddress;
+		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+			it->setBlockStartAddress(address);
+			it->setSize(0);
+			it->setStoredPackets(0);
+			address += bytesPerBlock;
+		}
+
+		//Initialize iterators
+		currentWriteBlock = this->begin();
+		currentReadBlock = this->begin();
+		lastBlockToRead = this->begin();
+
+		//Check last blockSize
+		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+			//remove the last Block so the second last block has more size
+			this->size -= 1;
+			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+		}
+	}
+
+	/**
+	 * Resets the whole index, the iterators and executes the given reset function on every index type
+	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
+	 */
+	void reset(void (*typeResetFnc)(T*)){
+		currentReadBlock = this->begin();
+		currentWriteBlock = this->begin();
+		lastBlockToRead = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = 0;
+		lastBlockToReadSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+			it->setSize(0);
+			it->setStoredPackets(0);
+			(*typeResetFnc)(it->modifyIndexType());
+		}
+	}
+
+	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+		it->setSize(0);
+		it->setStoredPackets(0);
+		(*typeResetFnc)(it->modifyIndexType());
+	}
+
+	/**
+	 * Reading
+	 * @param it
+	 */
+	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+		currentReadBlock = it;
+		currentReadBlockSizeCached = it->getSize();
+	}
+
+	void resetRead(){
+		currentReadBlock = this->begin();
+		currentReadSize = 0;
+		currentReadBlockSizeCached = this->begin()->getSize();
+		lastBlockToRead = currentWriteBlock;
+		lastBlockToReadSize = currentWriteBlock->getSize();
+	}
+
+	/**
+	 * Sets the last block to read to this iterator.
+	 * Can be used to dump until block x
+	 * @param it The iterator for the last read block
+	 */
+	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+		lastBlockToRead = it;
+		lastBlockToReadSize = it->getSize();
+	}
+
+	/**
+	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+	 * Can be the currentWriteBlock as well
+	 */
+	void readOldest(){
+		resetRead();
+		currentReadBlock = getNextNonEmptyBlock();
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+
+	}
+
+	/**
+	 * Sets the current read iterator to the next Block and resets the current read size
+	 * The current size of the block will be cached to avoid race condition between write and read
+	 * If the end of the ring is reached the read pointer will be set to the begin
+	 */
+	void readNext(){
+		currentReadSize = 0;
+		if((this->size != 0) && (currentReadBlock.value ==this->back())){
+			currentReadBlock = this->begin();
+		}else{
+			currentReadBlock++;
+		}
+
+		currentReadBlockSizeCached = currentReadBlock->getSize();
+	}
+
+	/**
+	 * Returns the address which is currently read from
+	 * @return Address to read from
+	 */
+	uint32_t getCurrentReadAddress() const {
+		return getAddressOfCurrentReadBlock() + currentReadSize;
+	}
+
+	/**
+	 * Adds readSize to the current size and checks if the read has no more data
+	 * left and advances the read block.
+	 * @param readSize The size that was read
+	 * @return Returns true if the read can go on
+	 */
+	bool addReadSize(uint32_t readSize) {
+		if(currentReadBlock == lastBlockToRead) {
+			//The current read block is the last to read
+			if((currentReadSize+readSize)<lastBlockToReadSize) {
+				//the block has more data -> return true
+				currentReadSize += readSize;
+				return true;
+			}
+			else {
+				//Reached end of read -> return false
+				currentReadSize = lastBlockToReadSize;
+				return false;
+			}
+		}
+		else {
+			//We are not in the last Block
+			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+				//The current Block has more data
+				currentReadSize += readSize;
+				return true;
+			}
+			// TODO: Maybe some logic blocks should be extracted
+			else {
+				//The current block is written completely
+				readNext();
+				if(currentReadBlockSizeCached==0) {
+					//Next block is empty
+					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+					//Search if any block between this and the last block is not empty
+					for(;it!=lastBlockToRead;++it){
+						if(it == this->end()){
+							//This is the end, next block is the begin
+							it = this->begin();
+							if(it == lastBlockToRead){
+								//Break if the begin is the lastBlockToRead
+								break;
+							}
+						}
+						if(it->getSize()!=0){
+							//This is a non empty block. Go on reading with this block
+							currentReadBlock = it;
+							currentReadBlockSizeCached = it->getSize();
+							return true;
+						}
+					}
+					//reached lastBlockToRead and every block was empty, check if the last block is also empty
+					if(lastBlockToReadSize!=0){
+						//go on with last Block
+						currentReadBlock = lastBlockToRead;
+						currentReadBlockSizeCached = lastBlockToReadSize;
+						return true;
+					}
+					//There is no non empty block left
+					return false;
+				}
+				//Size is larger than 0
+				return true;
+			}
+		}
+	}
+	uint32_t getRemainigSizeOfCurrentReadBlock() const{
+		if(currentReadBlock == lastBlockToRead){
+			return (lastBlockToReadSize - currentReadSize);
+		}else{
+			return (currentReadBlockSizeCached - currentReadSize);
+		}
+	}
+
+	uint32_t getAddressOfCurrentReadBlock() const {
+		return currentReadBlock->getBlockStartAddress();
+	}
+
+	/**
+	 * Gets the next non empty Block after the current write block,
+	 * @return Returns the iterator to the block. If there is non, the current write block is returned
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+				if(it == this->end()){
+					it = this->begin();
+					if(it == currentWriteBlock){
+						break;
+					}
+				}
+				if(it->getSize()!=0){
+					return it;
+				}
+		}
+		return currentWriteBlock;
+	}
+
+	/**
+	 * Returns a copy of the oldest Index type
+	 * @return Type of Index
+	 */
+	T* getOldest(){
+		return (getNextNonEmptyBlock()->modifyIndexType());
+	}
+
+
+	/*
+	 * Writing
+	 */
+	uint32_t getAddressOfCurrentWriteBlock() const{
+		return currentWriteBlock->getBlockStartAddress();
+	}
+
+	uint32_t getSizeOfCurrentWriteBlock() const{
+		return currentWriteBlock->getSize();
+	}
+
+	uint32_t getCurrentWriteAddress() const{
+		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+	}
+
+	void clearCurrentWriteBlock(){
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+	}
+
+	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+		currentWriteBlock->addSize(size);
+		currentWriteBlock->addStoredPackets(storedPackets);
+	}
+
+	T* modifyCurrentWriteBlockIndexType(){
+		return currentWriteBlock->modifyIndexType();
+	}
+
+	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+		it->addSize(size);
+		it->addStoredPackets(storedPackets);
+	}
+
+	/**
+	 * Checks if the block has enough space for sizeToWrite
+	 * @param sizeToWrite The data to be written in the Block
+	 * @return Returns true if size to write is smaller the remaining size of the block
+	 */
+	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+		uint32_t addressOfNextBlock = next->getBlockStartAddress();
+		uint32_t availableSize =
+				( ( addressOfNextBlock + totalSize ) -
+				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
+				% totalSize;
+		return (sizeToWrite < availableSize);
+	}
+
+	/**
+	 * Checks if the store is full if overwrite old is false
+	 * @return Returns true if it is writeable and false if not
+	 */
+	bool isNextBlockWritable(){
+		//First check if this is the end of the list
+		typename IndexedRingMemoryArray<T>::Iterator next;
+		next = getNextWrite();
+		if((next->getSize()!=0) && (!overwriteOld)){
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Updates current write Block Index Type
+	 * @param infoOfNewBlock
+	 */
+	void updateCurrentBlock(T* infoOfNewBlock){
+		currentWriteBlock->setIndexType(infoOfNewBlock);
+	}
+
+
+	/**
+	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
+	 * @return
+	 */
+	ReturnValue_t writeNext(){
+		//Check Next Block
+		if(!isNextBlockWritable()){
+			//The Index is full and does not overwrite old
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		//Next block can be written, update Metadata
+		currentWriteBlock = getNextWrite();
+		currentWriteBlock->setSize(0);
+		currentWriteBlock->setStoredPackets(0);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * Serializes the Index and calculates the CRC.
+	 * Parameters according to HasSerializeIF
+	 * @param buffer
+	 * @param size
+	 * @param maxSize
+	 * @param streamEndianness
+	 * @return
+	 */
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const{
+		uint8_t* crcBuffer = *buffer;
+		uint32_t oldSize = *size;
+		if(additionalInfo!=NULL){
+			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+		}
+		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+		return result;
+	}
+
+
+	/**
+	 * Get the serialized Size of the index
+	 * @return The serialized size of the index
+	 */
+	size_t getSerializedSize() const {
+
+		size_t size = 0;
+		if(additionalInfo!=NULL){
+			size += additionalInfo->getSerializedSize();
+		}
+		size += currentWriteBlock->getSerializedSize();
+		size += SerializeAdapter::getSerializedSize(&this->size);
+		size += (this->entries[0].getSerializedSize()) * this->size;
+		uint16_t crc = 0;
+		size += SerializeAdapter::getSerializedSize(&crc);
+		return size;
+	}
+	/**
+	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+	 * CRC Has to be checked before!
+	 * @param buffer
+	 * @param size
+	 * @param streamEndianness
+	 * @return
+	 */
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness){
+
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if(additionalInfo!=NULL){
+			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+
+		Index<T> tempIndex;
+		result = tempIndex.deSerialize(buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		uint32_t tempSize = 0;
+		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		if(this->size != tempSize){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		uint32_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+			result = SerializeAdapter::deSerialize(
+					&this->entries[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		if(result != HasReturnvaluesIF::RETURN_OK){
+					return result;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			if(*(cmp.value) == *(it.value)){
+				currentWriteBlock = it;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		//Reached if current write block iterator is not found
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t getIndexAddress() const {
+		return indexAddress;
+	}
+
+
+	/*
+	 * Statistics
+	 */
+	uint32_t getStoredPackets() const {
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getStoredPackets();
+		}
+		return size;
+	}
+
+	uint32_t getTotalSize() const {
+		return totalSize;
+	}
+
+	uint32_t getCurrentSize() const{
+		uint32_t size = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			size += it->getSize();
+		}
+		return size;
+	}
+
+	bool isEmpty() const{
+		return getCurrentSize()==0;
+	}
+
+	double getPercentageFilled() const{
+		uint32_t filledSize = 0;
+		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+			filledSize += it->getSize();
+		}
+
+		return (double)filledSize/(double)this->totalSize;
+	}
+
+	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+		return currentWriteBlock;
+	}
+	/**
+	 * Get the next block of the currentWriteBlock.
+	 * Returns the first one if currentWriteBlock is the last one
+	 * @return Iterator pointing to the next block after currentWriteBlock
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+		if((this->size != 0) && (currentWriteBlock.value == this->back())){
+			next = this->begin();
+		}else{
+			++next;
+		}
+		return next;
+	}
+	/**
+	 * Get the block in front of the Iterator
+	 * Returns the last block if it is the first block
+	 * @param it iterator which you want the previous block from
+	 * @return pointing to the block before it
+	 */
+	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+		if(this->begin() == it){
+			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+			return next;
+		}
+		typename IndexedRingMemoryArray<T>::Iterator next(it);
+		--next;
+		return next;
+	}
+private:
+	//The total size used by the blocks (without index)
+	uint32_t totalSize;
+
+	//The address of the index
+	const uint32_t indexAddress;
+
+	//The iterators for writing and reading
+	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+
+	//How much of the current read block is read already
+	uint32_t currentReadSize;
+
+	//Cached Size of current read block
+	uint32_t currentReadBlockSizeCached;
+
+	//Last block of current write (should be write block)
+	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+	//current size of last Block to read
+	uint32_t lastBlockToReadSize;
+
+	//Additional Info to be serialized with the index
+	SerializeIF* additionalInfo;
+
+	//Does it overwrite old blocks?
+	const bool overwriteOld;
+
+};
+
+#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index 4a1b7df2..05538478 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-
-#include "../storagemanager/StorageManagerIF.h"
-#include <utility>
-
-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));
-	}
-private:
-	StorageManagerIF* dataBackend;
-};
-
-#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
+#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
+
+#include "../storagemanager/StorageManagerIF.h"
+#include <utility>
+
+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));
+	}
+private:
+	StorageManagerIF* dataBackend;
+};
+
+#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 0e784631..243a2915 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,113 +1,113 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_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;
-		}
-	}
-
-	virtual ~RingBufferBase() {}
-
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
-
-	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;
-	}
-
-	size_t getMaxSize() const {
-		return size - 1;
-	}
-
-	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 readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
-
-	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;
-	}
-
-	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];
-	}
-
-	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;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
-};
-
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_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;
+		}
+	}
+
+	virtual ~RingBufferBase() {}
+
+	bool isFull(uint8_t n = 0) {
+		return (availableWriteSpace(n) == 0);
+	}
+	bool isEmpty(uint8_t n = 0) {
+		return (getAvailableReadData(n) == 0);
+	}
+
+	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;
+	}
+
+	size_t getMaxSize() const {
+		return size - 1;
+	}
+
+	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 readTillWrap(uint8_t n = 0) {
+		return (start + size) - read[n];
+	}
+
+	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;
+	}
+
+	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];
+	}
+
+	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;
+	}
+
+	void setWrite(uint32_t write) {
+		this->write = write;
+	}
+};
+
+#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index c41e8d30..490988e5 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,30 +1,30 @@
-#include "../container/SharedRingBuffer.h"
-#include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		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):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
-        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
-    return mutex->lockMutex(timeoutType, timeout);
-}
-
-ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
-    return mutex->unlockMutex();
-}
-
-MutexIF* SharedRingBuffer::getMutexHandle() const {
-    return mutex;
-}
+#include "../container/SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		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):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
+}
+
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
+}
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index c6d958cc..394dcaaa 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-
-#include "../container/SimpleRingBuffer.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:
-	/**
-	 * 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);
-
-	/**
-	 * 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();
-
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
-private:
-	MutexIF* mutex = nullptr;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "../container/SimpleRingBuffer.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:
+	/**
+	 * 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);
+
+	/**
+	 * 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();
+
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
+	MutexIF* getMutexHandle() const;
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 7ed019b2..d6b6f5af 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,135 +1,135 @@
-#include "../container/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];
-}
-
-SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-}
-
-
-SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
-}
-
-
-ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
-        size_t amount) {
-    if (availableWriteSpace() >= amount or overwriteOld) {
-        size_t amountTillWrap = writeTillWrap();
-        if (amountTillWrap < amount) {
-            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            excessBytes = amount - amountTillWrap;
-        }
-        *writePointer = &buffer[write];
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-}
-
-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;
-	}
-}
-
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		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;
-}
-
-size_t SimpleRingBuffer::getExcessBytes() const {
-    return excessBytes;
-}
-
-void SimpleRingBuffer::moveExcessBytesToStart() {
-    if(excessBytes > 0) {
-        std::memcpy(buffer, &buffer[size], excessBytes);
-        excessBytes = 0;
-    }
-}
-
-ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		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;
-}
-
-
+#include "../container/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];
+}
+
+SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
+	if(maxExcessBytes > size) {
+		this->maxExcessBytes = size;
+	}
+	else {
+		this->maxExcessBytes = maxExcessBytes;
+	}
+}
+
+
+SimpleRingBuffer::~SimpleRingBuffer() {
+	delete[] buffer;
+}
+
+
+ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap < amount) {
+            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
+                return HasReturnvaluesIF::RETURN_FAILED;
+            }
+            excessBytes = amount - amountTillWrap;
+        }
+        *writePointer = &buffer[write];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+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;
+	}
+}
+
+ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
+		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;
+}
+
+size_t SimpleRingBuffer::getExcessBytes() const {
+    return excessBytes;
+}
+
+void SimpleRingBuffer::moveExcessBytesToStart() {
+    if(excessBytes > 0) {
+        std::memcpy(buffer, &buffer[size], excessBytes);
+        excessBytes = 0;
+    }
+}
+
+ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
+		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;
+}
+
+
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index b13e9f2a..dcf2684b 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,128 +1,128 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-
-#include "../container/RingBufferBase.h"
-#include <cstddef>
-
-/**
- * @brief 	Circular buffer implementation, useful for buffering
- *          into data streams.
- * @details
- * Note that the deleteData() has to be called to increment the read pointer.
- * This class allocated dynamically, so
- * @ingroup containers
- */
-class SimpleRingBuffer: public RingBufferBase<> {
-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
-     * operation, the oldest data will be overwritten.
-     * @param maxExcessBytes These additional bytes will be allocated in addtion
-     * to the specified size to accomodate contiguous write operations
-     * 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
-     * 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);
-
-	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);
-
-	/**
-	 * 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);
-
-	/**
-	 * 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);
-
-	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);
-private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
-};
-
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
-
+#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+
+#include "../container/RingBufferBase.h"
+#include <cstddef>
+
+/**
+ * @brief 	Circular buffer implementation, useful for buffering
+ *          into data streams.
+ * @details
+ * Note that the deleteData() has to be called to increment the read pointer.
+ * This class allocated dynamically, so
+ * @ingroup containers
+ */
+class SimpleRingBuffer: public RingBufferBase<> {
+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
+     * operation, the oldest data will be overwritten.
+     * @param maxExcessBytes These additional bytes will be allocated in addtion
+     * to the specified size to accomodate contiguous write operations
+     * 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
+     * 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);
+
+	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);
+
+	/**
+	 * 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);
+
+	/**
+	 * 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);
+
+	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);
+private:
+	static const uint8_t READ_PTR = 0;
+	uint8_t* buffer = nullptr;
+	size_t maxExcessBytes;
+	size_t excessBytes = 0;
+};
+
+#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+
diff --git a/contrib/sgp4/sgp4unit.cpp b/contrib/sgp4/sgp4unit.cpp
index 24d63aa9..b707a7a2 100644
--- a/contrib/sgp4/sgp4unit.cpp
+++ b/contrib/sgp4/sgp4unit.cpp
@@ -1,2090 +1,2090 @@
-/*     ----------------------------------------------------------------
-*
-*                               sgp4unit.cpp
-*
-*    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 :
-*              16 nov 07  david vallado
-*                           misc fixes for better compliance
-*    changes :
-*              20 apr 07  david vallado
-*                           misc fixes for constants
-*              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 "sgp4unit.h"
-
-const char help = 'n';
-FILE *dbgfile;
-
-#define pi 3.14159265358979323846
-
-
-/* ----------- local functions - only ever used internally by sgp4 ---------- */
-static void dpper
-     (
-       double e3,     double ee2,    double peo,     double pgho,   double pho,
-       double pinco,  double plo,    double se2,     double se3,    double sgh2,
-       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
-       double si3,    double sl2,    double sl3,     double sl4,    double t,
-       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
-       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
-       double zmol,   double zmos,   double inclo,
-       char init,
-       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
-     );
-
-static void dscom
-     (
-       double epoch,  double ep,     double argpp,   double tc,     double inclp,
-       double nodep,  double np,
-       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
-       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
-       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
-       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
-       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
-       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
-       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
-       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
-       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
-       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
-       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
-       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
-       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
-       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
-       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
-       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
-       double& zmos
-     );
-
-static void dsinit
-     (
-       gravconsttype whichconst,
-       double cosim,  double emsq,   double argpo,   double s1,     double s2,
-       double s3,     double s4,     double s5,      double sinim,  double ss1,
-       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
-       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
-       double sz31,   double sz33,   double t,       double tc,     double gsto,
-       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
-       double xpidot, double z1,     double z3,      double z11,    double z13,
-       double z21,    double z23,    double z31,     double z33,    double ecco,
-       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
-       double& nm,    double& nodem,
-       int& irez,
-       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
-       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
-       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
-       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
-       double& xfact, double& xlamo, double& xli,    double& xni
-     );
-
-static void dspace
-     (
-       int irez,
-       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
-       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
-       double dedt,   double del1,   double del2,    double del3,   double didt,
-       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
-       double t,      double tc,     double gsto,    double xfact,  double xlamo,
-       double no,
-       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
-       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
-     );
-
-static void initl
-     (
-       int satn,      gravconsttype whichconst,
-       double ecco,   double epoch,  double inclo,   double& no,
-       char& method,
-       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
-       double& cosio2,double& eccsq, double& omeosq, double& posq,
-       double& rp,    double& rteosq,double& sinio , double& gsto
-     );
-
-/* -----------------------------------------------------------------------------
-*
-*                           procedure dpper
-*
-*  this procedure provides deep space long period periodic contributions
-*    to the mean elements.  by design, these periodics are zero at epoch.
-*    this used to be dscom which included initialization, but it's really a
-*    recurring function.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    e3          -
-*    ee2         -
-*    peo         -
-*    pgho        -
-*    pho         -
-*    pinco       -
-*    plo         -
-*    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
-*    t           -
-*    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
-*    zmol        -
-*    zmos        -
-*    ep          - eccentricity                           0.0 - 1.0
-*    inclo       - inclination - needed for lyddane modification
-*    nodep       - right ascension of ascending node
-*    argpp       - argument of perigee
-*    mp          - mean anomaly
-*
-*  outputs       :
-*    ep          - eccentricity                           0.0 - 1.0
-*    inclp       - inclination
-*    nodep        - right ascension of ascending node
-*    argpp       - argument of perigee
-*    mp          - mean anomaly
-*
-*  locals        :
-*    alfdp       -
-*    betdp       -
-*    cosip  , sinip  , cosop  , sinop  ,
-*    dalf        -
-*    dbet        -
-*    dls         -
-*    f2, f3      -
-*    pe          -
-*    pgh         -
-*    ph          -
-*    pinc        -
-*    pl          -
-*    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
-*    sll   , sls
-*    xls         -
-*    xnoh        -
-*    zf          -
-*    zm          -
-*
-*  coupling      :
-*    none.
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dpper
-     (
-       double e3,     double ee2,    double peo,     double pgho,   double pho,
-       double pinco,  double plo,    double se2,     double se3,    double sgh2,
-       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
-       double si3,    double sl2,    double sl3,     double sl4,    double t,
-       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
-       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
-       double zmol,   double zmos,   double inclo,
-       char init,
-       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     const double twopi = 2.0 * pi;
-     double alfdp, betdp, cosip, cosop, dalf, dbet, dls,
-          f2,    f3,    pe,    pgh,   ph,   pinc, pl ,
-          sel,   ses,   sghl,  sghs,  shll, shs,  sil,
-          sinip, sinop, sinzf, sis,   sll,  sls,  xls,
-          xnoh,  zf,    zm,    zel,   zes,  znl,  zns;
-
-     /* ---------------------- constants ----------------------------- */
-     zns   = 1.19459e-5;
-     zes   = 0.01675;
-     znl   = 1.5835218e-4;
-     zel   = 0.05490;
-
-     /* --------------- calculate time varying periodics ----------- */
-     zm    = zmos + zns * t;
-     // be sure that the initial call has time set to zero
-     if (init == 'y')
-         zm = zmos;
-     zf    = zm + 2.0 * zes * sin(zm);
-     sinzf = sin(zf);
-     f2    =  0.5 * sinzf * sinzf - 0.25;
-     f3    = -0.5 * sinzf * cos(zf);
-     ses   = se2* f2 + se3 * f3;
-     sis   = si2 * f2 + si3 * f3;
-     sls   = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
-     sghs  = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
-     shs   = sh2 * f2 + sh3 * f3;
-     zm    = zmol + znl * t;
-     if (init == 'y')
-         zm = zmol;
-     zf    = zm + 2.0 * zel * sin(zm);
-     sinzf = sin(zf);
-     f2    =  0.5 * sinzf * sinzf - 0.25;
-     f3    = -0.5 * sinzf * cos(zf);
-     sel   = ee2 * f2 + e3 * f3;
-     sil   = xi2 * f2 + xi3 * f3;
-     sll   = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
-     sghl  = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
-     shll  = xh2 * f2 + xh3 * f3;
-     pe    = ses + sel;
-     pinc  = sis + sil;
-     pl    = sls + sll;
-     pgh   = sghs + sghl;
-     ph    = shs + shll;
-
-     if (init == 'n')
-       {
-       pe    = pe - peo;
-       pinc  = pinc - pinco;
-       pl    = pl - plo;
-       pgh   = pgh - pgho;
-       ph    = ph - pho;
-       inclp = inclp + pinc;
-       ep    = ep + pe;
-       sinip = sin(inclp);
-       cosip = cos(inclp);
-
-       /* ----------------- apply periodics directly ------------ */
-       //  sgp4fix for lyddane choice
-       //  strn3 used original inclination - this is technically feasible
-       //  gsfc used perturbed inclination - also technically feasible
-       //  probably best to readjust the 0.2 limit value and limit discontinuity
-       //  0.2 rad = 11.45916 deg
-       //  use next line for original strn3 approach and original inclination
-       //  if (inclo >= 0.2)
-       //  use next line for gsfc version and perturbed inclination
-       if (inclp >= 0.2)
-         {
-           ph     = ph / sinip;
-           pgh    = pgh - cosip * ph;
-           argpp  = argpp + pgh;
-           nodep  = nodep + ph;
-           mp     = mp + pl;
-         }
-         else
-         {
-           /* ---- apply periodics with lyddane modification ---- */
-           sinop  = sin(nodep);
-           cosop  = cos(nodep);
-           alfdp  = sinip * sinop;
-           betdp  = sinip * cosop;
-           dalf   =  ph * cosop + pinc * cosip * sinop;
-           dbet   = -ph * sinop + pinc * cosip * cosop;
-           alfdp  = alfdp + dalf;
-           betdp  = betdp + dbet;
-           nodep  = fmod(nodep, twopi);
-           //  sgp4fix for afspc written intrinsic functions
-           // nodep used without a trigonometric function ahead
-           if (nodep < 0.0)
-               nodep = nodep + twopi;
-           xls    = mp + argpp + cosip * nodep;
-           dls    = pl + pgh - pinc * nodep * sinip;
-           xls    = xls + dls;
-           xnoh   = nodep;
-           nodep  = atan2(alfdp, betdp);
-           //  sgp4fix for afspc written intrinsic functions
-           // nodep used without a trigonometric function ahead
-           if (nodep < 0.0)
-               nodep = nodep + twopi;
-           if (fabs(xnoh - nodep) > pi){
-             if (nodep < xnoh)
-                nodep = nodep + twopi;
-               else
-                nodep = nodep - twopi;
-           }
-           mp    = mp + pl;
-           argpp = xls - mp - cosip * nodep;
-         }
-       }   // if init == 'n'
-
-//#include "debug1.cpp"
-}  // end dpper
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dscom
-*
-*  this procedure provides deep space common items used by both the secular
-*    and periodics subroutines.  input is provided as shown. this routine
-*    used to be called dpper, but the functions inside weren't well organized.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    epoch       -
-*    ep          - eccentricity
-*    argpp       - argument of perigee
-*    tc          -
-*    inclp       - inclination
-*    nodep       - right ascension of ascending node
-*    np          - mean motion
-*
-*  outputs       :
-*    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
-*    day         -
-*    e3          -
-*    ee2         -
-*    em          - eccentricity
-*    emsq        - eccentricity squared
-*    gam         -
-*    peo         -
-*    pgho        -
-*    pho         -
-*    pinco       -
-*    plo         -
-*    rtemsq      -
-*    se2, se3         -
-*    sgh2, sgh3, sgh4        -
-*    sh2, sh3, si2, si3, sl2, sl3, sl4         -
-*    s1, s2, s3, s4, s5, s6, s7          -
-*    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
-*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-*    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
-*    nm          - mean motion
-*    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-*    zmol        -
-*    zmos        -
-*
-*  locals        :
-*    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
-*    betasq      -
-*    cc          -
-*    ctem, stem        -
-*    x1, x2, x3, x4, x5, x6, x7, x8          -
-*    xnodce      -
-*    xnoi        -
-*    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
-*    zcosi  , zsini  , zcosil , zsinil ,
-*    zx          -
-*    zy          -
-*
-*  coupling      :
-*    none.
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dscom
-     (
-       double epoch,  double ep,     double argpp,   double tc,     double inclp,
-       double nodep,  double np,
-       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
-       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
-       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
-       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
-       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
-       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
-       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
-       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
-       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
-       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
-       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
-       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
-       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
-       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
-       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
-       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
-       double& zmos
-     )
-{
-     /* -------------------------- constants ------------------------- */
-     const double zes     =  0.01675;
-     const double zel     =  0.05490;
-     const double c1ss    =  2.9864797e-6;
-     const double c1l     =  4.7968065e-7;
-     const double zsinis  =  0.39785416;
-     const double zcosis  =  0.91744867;
-     const double zcosgs  =  0.1945905;
-     const double zsings  = -0.98088458;
-     const double twopi   =  2.0 * pi;
-
-     /* --------------------- local variables ------------------------ */
-     int lsflg;
-     double a1    , a2    , a3    , a4    , a5    , a6    , a7    ,
-        a8    , a9    , a10   , betasq, cc    , ctem  , stem  ,
-        x1    , x2    , x3    , x4    , x5    , x6    , x7    ,
-        x8    , xnodce, xnoi  , zcosg , zcosgl, zcosh , zcoshl,
-        zcosi , zcosil, zsing , zsingl, zsinh , zsinhl, zsini ,
-        zsinil, zx    , zy;
-
-     nm     = np;
-     em     = ep;
-     snodm  = sin(nodep);
-     cnodm  = cos(nodep);
-     sinomm = sin(argpp);
-     cosomm = cos(argpp);
-     sinim  = sin(inclp);
-     cosim  = cos(inclp);
-     emsq   = em * em;
-     betasq = 1.0 - emsq;
-     rtemsq = sqrt(betasq);
-
-     /* ----------------- initialize lunar solar terms --------------- */
-     peo    = 0.0;
-     pinco  = 0.0;
-     plo    = 0.0;
-     pgho   = 0.0;
-     pho    = 0.0;
-     day    = epoch + 18261.5 + tc / 1440.0;
-     xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
-     stem   = sin(xnodce);
-     ctem   = cos(xnodce);
-     zcosil = 0.91375164 - 0.03568096 * ctem;
-     zsinil = sqrt(1.0 - zcosil * zcosil);
-     zsinhl = 0.089683511 * stem / zsinil;
-     zcoshl = sqrt(1.0 - zsinhl * zsinhl);
-     gam    = 5.8351514 + 0.0019443680 * day;
-     zx     = 0.39785416 * stem / zsinil;
-     zy     = zcoshl * ctem + 0.91744867 * zsinhl * stem;
-     zx     = atan2(zx, zy);
-     zx     = gam + zx - xnodce;
-     zcosgl = cos(zx);
-     zsingl = sin(zx);
-
-     /* ------------------------- do solar terms --------------------- */
-     zcosg = zcosgs;
-     zsing = zsings;
-     zcosi = zcosis;
-     zsini = zsinis;
-     zcosh = cnodm;
-     zsinh = snodm;
-     cc    = c1ss;
-     xnoi  = 1.0 / nm;
-
-     for (lsflg = 1; lsflg <= 2; lsflg++)
-       {
-         a1  =   zcosg * zcosh + zsing * zcosi * zsinh;
-         a3  =  -zsing * zcosh + zcosg * zcosi * zsinh;
-         a7  =  -zcosg * zsinh + zsing * zcosi * zcosh;
-         a8  =   zsing * zsini;
-         a9  =   zsing * zsinh + zcosg * zcosi * zcosh;
-         a10 =   zcosg * zsini;
-         a2  =   cosim * a7 + sinim * a8;
-         a4  =   cosim * a9 + sinim * a10;
-         a5  =  -sinim * a7 + cosim * a8;
-         a6  =  -sinim * a9 + cosim * a10;
-
-         x1  =  a1 * cosomm + a2 * sinomm;
-         x2  =  a3 * cosomm + a4 * sinomm;
-         x3  = -a1 * sinomm + a2 * cosomm;
-         x4  = -a3 * sinomm + a4 * cosomm;
-         x5  =  a5 * sinomm;
-         x6  =  a6 * sinomm;
-         x7  =  a5 * cosomm;
-         x8  =  a6 * cosomm;
-
-         z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
-         z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
-         z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
-         z1  =  3.0 *  (a1 * a1 + a2 * a2) + z31 * emsq;
-         z2  =  6.0 *  (a1 * a3 + a2 * a4) + z32 * emsq;
-         z3  =  3.0 *  (a3 * a3 + a4 * a4) + z33 * emsq;
-         z11 = -6.0 * a1 * a5 + emsq *  (-24.0 * x1 * x7-6.0 * x3 * x5);
-         z12 = -6.0 *  (a1 * a6 + a3 * a5) + emsq *
-                (-24.0 * (x2 * x7 + x1 * x8) - 6.0 * (x3 * x6 + x4 * x5));
-         z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
-         z21 =  6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
-         z22 =  6.0 *  (a4 * a5 + a2 * a6) + emsq *
-                (24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
-         z23 =  6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
-         z1  = z1 + z1 + betasq * z31;
-         z2  = z2 + z2 + betasq * z32;
-         z3  = z3 + z3 + betasq * z33;
-         s3  = cc * xnoi;
-         s2  = -0.5 * s3 / rtemsq;
-         s4  = s3 * rtemsq;
-         s1  = -15.0 * em * s4;
-         s5  = x1 * x3 + x2 * x4;
-         s6  = x2 * x3 + x1 * x4;
-         s7  = x2 * x4 - x1 * x3;
-
-         /* ----------------------- do lunar terms ------------------- */
-         if (lsflg == 1)
-           {
-             ss1   = s1;
-             ss2   = s2;
-             ss3   = s3;
-             ss4   = s4;
-             ss5   = s5;
-             ss6   = s6;
-             ss7   = s7;
-             sz1   = z1;
-             sz2   = z2;
-             sz3   = z3;
-             sz11  = z11;
-             sz12  = z12;
-             sz13  = z13;
-             sz21  = z21;
-             sz22  = z22;
-             sz23  = z23;
-             sz31  = z31;
-             sz32  = z32;
-             sz33  = z33;
-             zcosg = zcosgl;
-             zsing = zsingl;
-             zcosi = zcosil;
-             zsini = zsinil;
-             zcosh = zcoshl * cnodm + zsinhl * snodm;
-             zsinh = snodm * zcoshl - cnodm * zsinhl;
-             cc    = c1l;
-          }
-       }
-
-     zmol = fmod(4.7199672 + 0.22997150  * day - gam, twopi);
-     zmos = fmod(6.2565837 + 0.017201977 * day, twopi);
-
-     /* ------------------------ do solar terms ---------------------- */
-     se2  =   2.0 * ss1 * ss6;
-     se3  =   2.0 * ss1 * ss7;
-     si2  =   2.0 * ss2 * sz12;
-     si3  =   2.0 * ss2 * (sz13 - sz11);
-     sl2  =  -2.0 * ss3 * sz2;
-     sl3  =  -2.0 * ss3 * (sz3 - sz1);
-     sl4  =  -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
-     sgh2 =   2.0 * ss4 * sz32;
-     sgh3 =   2.0 * ss4 * (sz33 - sz31);
-     sgh4 = -18.0 * ss4 * zes;
-     sh2  =  -2.0 * ss2 * sz22;
-     sh3  =  -2.0 * ss2 * (sz23 - sz21);
-
-     /* ------------------------ do lunar terms ---------------------- */
-     ee2  =   2.0 * s1 * s6;
-     e3   =   2.0 * s1 * s7;
-     xi2  =   2.0 * s2 * z12;
-     xi3  =   2.0 * s2 * (z13 - z11);
-     xl2  =  -2.0 * s3 * z2;
-     xl3  =  -2.0 * s3 * (z3 - z1);
-     xl4  =  -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
-     xgh2 =   2.0 * s4 * z32;
-     xgh3 =   2.0 * s4 * (z33 - z31);
-     xgh4 = -18.0 * s4 * zel;
-     xh2  =  -2.0 * s2 * z22;
-     xh3  =  -2.0 * s2 * (z23 - z21);
-
-//#include "debug2.cpp"
-}  // end dscom
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dsinit
-*
-*  this procedure provides deep space contributions to mean motion dot due
-*    to geopotential resonance with half day and one day orbits.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    cosim, sinim-
-*    emsq        - eccentricity squared
-*    argpo       - argument of perigee
-*    s1, s2, s3, s4, s5      -
-*    ss1, ss2, ss3, ss4, ss5 -
-*    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
-*    t           - time
-*    tc          -
-*    gsto        - greenwich sidereal time                   rad
-*    mo          - mean anomaly
-*    mdot        - mean anomaly dot (rate)
-*    no          - mean motion
-*    nodeo       - right ascension of ascending node
-*    nodedot     - right ascension of ascending node dot (rate)
-*    xpidot      -
-*    z1, z3, z11, z13, z21, z23, z31, z33 -
-*    eccm        - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    xn          - mean motion
-*    nodem       - right ascension of ascending node
-*
-*  outputs       :
-*    em          - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    nodem       - right ascension of ascending node
-*    irez        - flag for resonance           0-none, 1-one day, 2-half day
-*    atime       -
-*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
-*    dedt        -
-*    didt        -
-*    dmdt        -
-*    dndt        -
-*    dnodt       -
-*    domdt       -
-*    del1, del2, del3        -
-*    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
-*    theta       -
-*    xfact       -
-*    xlamo       -
-*    xli         -
-*    xni
-*
-*  locals        :
-*    ainv2       -
-*    aonv        -
-*    cosisq      -
-*    eoc         -
-*    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
-*    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
-*    sini2       -
-*    temp        -
-*    temp1       -
-*    theta       -
-*    xno2        -
-*
-*  coupling      :
-*    getgravconst
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dsinit
-     (
-       gravconsttype whichconst,
-       double cosim,  double emsq,   double argpo,   double s1,     double s2,
-       double s3,     double s4,     double s5,      double sinim,  double ss1,
-       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
-       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
-       double sz31,   double sz33,   double t,       double tc,     double gsto,
-       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
-       double xpidot, double z1,     double z3,      double z11,    double z13,
-       double z21,    double z23,    double z31,     double z33,    double ecco,
-       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
-       double& nm,    double& nodem,
-       int& irez,
-       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
-       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
-       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
-       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
-       double& xfact, double& xlamo, double& xli,    double& xni
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     const double twopi = 2.0 * pi;
-
-     double ainv2 , aonv=0.0, cosisq, eoc, f220 , f221  , f311  ,
-          f321  , f322  , f330  , f441  , f442  , f522  , f523  ,
-          f542  , f543  , g200  , g201  , g211  , g300  , g310  ,
-          g322  , g410  , g422  , g520  , g521  , g532  , g533  ,
-          ses   , sgs   , sghl  , sghs  , shs   , shll  , sis   ,
-          sini2 , sls   , temp  , temp1 , theta , xno2  , q22   ,
-          q31   , q33   , root22, root44, root54, rptim , root32,
-          root52, x2o3  , xke   , znl   , emo   , zns   , emsqo,
-          tumin, mu, radiusearthkm, j2, j3, j4, j3oj2;
-
-     q22    = 1.7891679e-6;
-     q31    = 2.1460748e-6;
-     q33    = 2.2123015e-7;
-     root22 = 1.7891679e-6;
-     root44 = 7.3636953e-9;
-     root54 = 2.1765803e-9;
-     rptim  = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
-     root32 = 3.7393792e-7;
-     root52 = 1.1428639e-7;
-     x2o3   = 2.0 / 3.0;
-     znl    = 1.5835218e-4;
-     zns    = 1.19459e-5;
-
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-
-     /* -------------------- deep space initialization ------------ */
-     irez = 0;
-     if ((nm < 0.0052359877) && (nm > 0.0034906585))
-         irez = 1;
-     if ((nm >= 8.26e-3) && (nm <= 9.24e-3) && (em >= 0.5))
-         irez = 2;
-
-     /* ------------------------ do solar terms ------------------- */
-     ses  =  ss1 * zns * ss5;
-     sis  =  ss2 * zns * (sz11 + sz13);
-     sls  = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
-     sghs =  ss4 * zns * (sz31 + sz33 - 6.0);
-     shs  = -zns * ss2 * (sz21 + sz23);
-     // sgp4fix for 180 deg incl
-     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
-       shs = 0.0;
-     if (sinim != 0.0)
-       shs = shs / sinim;
-     sgs  = sghs - cosim * shs;
-
-     /* ------------------------- do lunar terms ------------------ */
-     dedt = ses + s1 * znl * s5;
-     didt = sis + s2 * znl * (z11 + z13);
-     dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
-     sghl = s4 * znl * (z31 + z33 - 6.0);
-     shll = -znl * s2 * (z21 + z23);
-     // sgp4fix for 180 deg incl
-     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
-         shll = 0.0;
-     domdt = sgs + sghl;
-     dnodt = shs;
-     if (sinim != 0.0)
-       {
-         domdt = domdt - cosim / sinim * shll;
-         dnodt = dnodt + shll / sinim;
-       }
-
-     /* ----------- calculate deep space resonance effects -------- */
-     dndt   = 0.0;
-     theta  = fmod(gsto + tc * rptim, twopi);
-     em     = em + dedt * t;
-     inclm  = inclm + didt * t;
-     argpm  = argpm + domdt * t;
-     nodem  = nodem + dnodt * t;
-     mm     = mm + dmdt * t;
-     //   sgp4fix for negative inclinations
-     //   the following if statement should be commented out
-     //if (inclm < 0.0)
-     //  {
-     //    inclm  = -inclm;
-     //    argpm  = argpm - pi;
-     //    nodem = nodem + pi;
-     //  }
-
-     /* -------------- initialize the resonance terms ------------- */
-     if (irez != 0)
-       {
-         aonv = pow(nm / xke, x2o3);
-
-         /* ---------- geopotential resonance for 12 hour orbits ------ */
-         if (irez == 2)
-           {
-             cosisq = cosim * cosim;
-             emo    = em;
-             em     = ecco;
-             emsqo  = emsq;
-             emsq   = eccsq;
-             eoc    = em * emsq;
-             g201   = -0.306 - (em - 0.64) * 0.440;
-
-             if (em <= 0.65)
-               {
-                 g211 =    3.616  -  13.2470 * em +  16.2900 * emsq;
-                 g310 =  -19.302  + 117.3900 * em - 228.4190 * emsq +  156.5910 * eoc;
-                 g322 =  -18.9068 + 109.7927 * em - 214.6334 * emsq +  146.5816 * eoc;
-                 g410 =  -41.122  + 242.6940 * em - 471.0940 * emsq +  313.9530 * eoc;
-                 g422 = -146.407  + 841.8800 * em - 1629.014 * emsq + 1083.4350 * eoc;
-                 g520 = -532.114  + 3017.977 * em - 5740.032 * emsq + 3708.2760 * eoc;
-               }
-               else
-               {
-                 g211 =   -72.099 +   331.819 * em -   508.738 * emsq +   266.724 * eoc;
-                 g310 =  -346.844 +  1582.851 * em -  2415.925 * emsq +  1246.113 * eoc;
-                 g322 =  -342.585 +  1554.908 * em -  2366.899 * emsq +  1215.972 * eoc;
-                 g410 = -1052.797 +  4758.686 * em -  7193.992 * emsq +  3651.957 * eoc;
-                 g422 = -3581.690 + 16178.110 * em - 24462.770 * emsq + 12422.520 * eoc;
-                 if (em > 0.715)
-                     g520 =-5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
-                   else
-                     g520 = 1464.74 -  4664.75 * em +  3763.64 * emsq;
-               }
-             if (em < 0.7)
-               {
-                 g533 = -919.22770 + 4988.6100 * em - 9064.7700 * emsq + 5542.21  * eoc;
-                 g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
-                 g532 = -853.66600 + 4690.2500 * em - 8624.7700 * emsq + 5341.4  * eoc;
-               }
-               else
-               {
-                 g533 =-37995.780 + 161616.52 * em - 229838.20 * emsq + 109377.94 * eoc;
-                 g521 =-51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
-                 g532 =-40023.880 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
-               }
-
-             sini2=  sinim * sinim;
-             f220 =  0.75 * (1.0 + 2.0 * cosim+cosisq);
-             f221 =  1.5 * sini2;
-             f321 =  1.875 * sinim  *  (1.0 - 2.0 * cosim - 3.0 * cosisq);
-             f322 = -1.875 * sinim  *  (1.0 + 2.0 * cosim - 3.0 * cosisq);
-             f441 = 35.0 * sini2 * f220;
-             f442 = 39.3750 * sini2 * sini2;
-             f522 =  9.84375 * sinim * (sini2 * (1.0 - 2.0 * cosim- 5.0 * cosisq) +
-                     0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq) );
-             f523 = sinim * (4.92187512 * sini2 * (-2.0 - 4.0 * cosim +
-                    10.0 * cosisq) + 6.56250012 * (1.0+2.0 * cosim - 3.0 * cosisq));
-             f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim+cosisq *
-                    (-12.0 + 8.0 * cosim + 10.0 * cosisq));
-             f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim+cosisq *
-                    (12.0 + 8.0 * cosim - 10.0 * cosisq));
-             xno2  =  nm * nm;
-             ainv2 =  aonv * aonv;
-             temp1 =  3.0 * xno2 * ainv2;
-             temp  =  temp1 * root22;
-             d2201 =  temp * f220 * g201;
-             d2211 =  temp * f221 * g211;
-             temp1 =  temp1 * aonv;
-             temp  =  temp1 * root32;
-             d3210 =  temp * f321 * g310;
-             d3222 =  temp * f322 * g322;
-             temp1 =  temp1 * aonv;
-             temp  =  2.0 * temp1 * root44;
-             d4410 =  temp * f441 * g410;
-             d4422 =  temp * f442 * g422;
-             temp1 =  temp1 * aonv;
-             temp  =  temp1 * root52;
-             d5220 =  temp * f522 * g520;
-             d5232 =  temp * f523 * g532;
-             temp  =  2.0 * temp1 * root54;
-             d5421 =  temp * f542 * g521;
-             d5433 =  temp * f543 * g533;
-             xlamo =  fmod(mo + nodeo + nodeo-theta - theta, twopi);
-             xfact =  mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
-             em    = emo;
-             emsq  = emsqo;
-           }
-
-         /* ---------------- synchronous resonance terms -------------- */
-         if (irez == 1)
-           {
-             g200  = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
-             g310  = 1.0 + 2.0 * emsq;
-             g300  = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
-             f220  = 0.75 * (1.0 + cosim) * (1.0 + cosim);
-             f311  = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
-             f330  = 1.0 + cosim;
-             f330  = 1.875 * f330 * f330 * f330;
-             del1  = 3.0 * nm * nm * aonv * aonv;
-             del2  = 2.0 * del1 * f220 * g200 * q22;
-             del3  = 3.0 * del1 * f330 * g300 * q33 * aonv;
-             del1  = del1 * f311 * g310 * q31 * aonv;
-             xlamo = fmod(mo + nodeo + argpo - theta, twopi);
-             xfact = mdot + xpidot - rptim + dmdt + domdt + dnodt - no;
-           }
-
-         /* ------------ for sgp4, initialize the integrator ---------- */
-         xli   = xlamo;
-         xni   = no;
-         atime = 0.0;
-         nm    = no + dndt;
-       }
-
-//#include "debug3.cpp"
-}  // end dsinit
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure dspace
-*
-*  this procedure provides deep space contributions to mean elements for
-*    perturbing third body.  these effects have been averaged over one
-*    revolution of the sun and moon.  for earth resonance effects, the
-*    effects have been averaged over no revolutions of the satellite.
-*    (mean motion)
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
-*    dedt        -
-*    del1, del2, del3  -
-*    didt        -
-*    dmdt        -
-*    dnodt       -
-*    domdt       -
-*    irez        - flag for resonance           0-none, 1-one day, 2-half day
-*    argpo       - argument of perigee
-*    argpdot     - argument of perigee dot (rate)
-*    t           - time
-*    tc          -
-*    gsto        - gst
-*    xfact       -
-*    xlamo       -
-*    no          - mean motion
-*    atime       -
-*    em          - eccentricity
-*    ft          -
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    xli         -
-*    mm          - mean anomaly
-*    xni         - mean motion
-*    nodem       - right ascension of ascending node
-*
-*  outputs       :
-*    atime       -
-*    em          - eccentricity
-*    argpm       - argument of perigee
-*    inclm       - inclination
-*    xli         -
-*    mm          - mean anomaly
-*    xni         -
-*    nodem       - right ascension of ascending node
-*    dndt        -
-*    nm          - mean motion
-*
-*  locals        :
-*    delt        -
-*    ft          -
-*    theta       -
-*    x2li        -
-*    x2omi       -
-*    xl          -
-*    xldot       -
-*    xnddt       -
-*    xndt        -
-*    xomi        -
-*
-*  coupling      :
-*    none        -
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void dspace
-     (
-       int irez,
-       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
-       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
-       double dedt,   double del1,   double del2,    double del3,   double didt,
-       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
-       double t,      double tc,     double gsto,    double xfact,  double xlamo,
-       double no,
-       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
-       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
-     )
-{
-     const double twopi = 2.0 * pi;
-     int iretn , iret;
-     double delt, ft, theta, x2li, x2omi, xl, xldot , xnddt, xndt, xomi, g22, g32,
-          g44, g52, g54, fasx2, fasx4, fasx6, rptim , step2, stepn , stepp;
-
-     ft    = 0.0;
-     fasx2 = 0.13130908;
-     fasx4 = 2.8843198;
-     fasx6 = 0.37448087;
-     g22   = 5.7686396;
-     g32   = 0.95240898;
-     g44   = 1.8014998;
-     g52   = 1.0508330;
-     g54   = 4.4108898;
-     rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
-     stepp =    720.0;
-     stepn =   -720.0;
-     step2 = 259200.0;
-
-     /* ----------- calculate deep space resonance effects ----------- */
-     dndt   = 0.0;
-     theta  = fmod(gsto + tc * rptim, twopi);
-     em     = em + dedt * t;
-
-     inclm  = inclm + didt * t;
-     argpm  = argpm + domdt * t;
-     nodem  = nodem + dnodt * t;
-     mm     = mm + dmdt * t;
-
-     //   sgp4fix for negative inclinations
-     //   the following if statement should be commented out
-     //  if (inclm < 0.0)
-     // {
-     //    inclm = -inclm;
-     //    argpm = argpm - pi;
-     //    nodem = nodem + pi;
-     //  }
-
-     /* - update resonances : numerical (euler-maclaurin) integration - */
-     /* ------------------------- epoch restart ----------------------  */
-     //   sgp4fix for propagator problems
-     //   the following integration works for negative time steps and periods
-     //   the specific changes are unknown because the original code was so convoluted
-
-     ft    = 0.0;
-     atime = 0.0;
-     if (irez != 0)
-       {
-         if ((atime == 0.0) || ((t >= 0.0) && (atime < 0.0)) ||
-             ((t < 0.0) && (atime >= 0.0)))
-           {
-             if (t >= 0.0)
-                 delt = stepp;
-               else
-                 delt = stepn;
-             atime  = 0.0;
-             xni    = no;
-             xli    = xlamo;
-           }
-         iretn = 381; // added for do loop
-         iret  =   0; // added for loop
-         while (iretn == 381)
-           {
-             if ((fabs(t) < fabs(atime)) || (iret == 351))
-               {
-                 if (t >= 0.0)
-                     delt = stepn;
-                   else
-                     delt = stepp;
-                 iret  = 351;
-                 iretn = 381;
-               }
-               else
-               {
-                 if (t > 0.0)  // error if prev if has atime:=0.0 and t:=0.0 (ge)
-                     delt = stepp;
-                   else
-                     delt = stepn;
-                 if (fabs(t - atime) >= stepp)
-                   {
-                     iret  = 0;
-                     iretn = 381;
-                   }
-                   else
-                   {
-                     ft    = t - atime;
-                     iretn = 0;
-                   }
-               }
-
-             /* ------------------- dot terms calculated ------------- */
-             /* ----------- near - synchronous resonance terms ------- */
-             if (irez != 2)
-               {
-                 xndt  = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
-                         del3 * sin(3.0 * (xli - fasx6));
-                 xldot = xni + xfact;
-                 xnddt = del1 * cos(xli - fasx2) +
-                         2.0 * del2 * cos(2.0 * (xli - fasx4)) +
-                         3.0 * del3 * cos(3.0 * (xli - fasx6));
-                 xnddt = xnddt * xldot;
-               }
-               else
-               {
-                 /* --------- near - half-day resonance terms -------- */
-                 xomi  = argpo + argpdot * atime;
-                 x2omi = xomi + xomi;
-                 x2li  = xli + xli;
-                 xndt  = d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) +
-                       d3210 * sin(xomi + xli - g32)  + d3222 * sin(-xomi + xli - g32)+
-                       d4410 * sin(x2omi + x2li - g44)+ d4422 * sin(x2li - g44) +
-                       d5220 * sin(xomi + xli - g52)  + d5232 * sin(-xomi + xli - g52)+
-                       d5421 * sin(xomi + x2li - g54) + d5433 * sin(-xomi + x2li - g54);
-                 xldot = xni + xfact;
-                 xnddt = d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) +
-                       d3210 * cos(xomi + xli - g32) + d3222 * cos(-xomi + xli - g32) +
-                       d5220 * cos(xomi + xli - g52) + d5232 * cos(-xomi + xli - g52) +
-                       2.0 * (d4410 * cos(x2omi + x2li - g44) +
-                       d4422 * cos(x2li - g44) + d5421 * cos(xomi + x2li - g54) +
-                       d5433 * cos(-xomi + x2li - g54));
-                 xnddt = xnddt * xldot;
-               }
-
-             /* ----------------------- integrator ------------------- */
-             if (iretn == 381)
-               {
-                 xli   = xli + xldot * delt + xndt * step2;
-                 xni   = xni + xndt * delt + xnddt * step2;
-                 atime = atime + delt;
-               }
-           }  // while iretn = 381
-
-         nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
-         xl = xli + xldot * ft + xndt * ft * ft * 0.5;
-         if (irez != 1)
-           {
-             mm   = xl - 2.0 * nodem + 2.0 * theta;
-             dndt = nm - no;
-           }
-           else
-           {
-             mm   = xl - nodem - argpm + theta;
-             dndt = nm - no;
-           }
-         nm = no + dndt;
-       }
-
-//#include "debug4.cpp"
-}  // end dsspace
-
-/*-----------------------------------------------------------------------------
-*
-*                           procedure initl
-*
-*  this procedure initializes the spg4 propagator. all the initialization is
-*    consolidated here instead of having multiple loops inside other routines.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    ecco        - eccentricity                           0.0 - 1.0
-*    epoch       - epoch time in days from jan 0, 1950. 0 hr
-*    inclo       - inclination of satellite
-*    no          - mean motion of satellite
-*    satn        - satellite number
-*
-*  outputs       :
-*    ainv        - 1.0 / a
-*    ao          - semi major axis
-*    con41       -
-*    con42       - 1.0 - 5.0 cos(i)
-*    cosio       - cosine of inclination
-*    cosio2      - cosio squared
-*    eccsq       - eccentricity squared
-*    method      - flag for deep space                    'd', 'n'
-*    omeosq      - 1.0 - ecco * ecco
-*    posq        - semi-parameter squared
-*    rp          - radius of perigee
-*    rteosq      - square root of (1.0 - ecco*ecco)
-*    sinio       - sine of inclination
-*    gsto        - gst at time of observation               rad
-*    no          - mean motion of satellite
-*
-*  locals        :
-*    ak          -
-*    d1          -
-*    del         -
-*    adel        -
-*    po          -
-*
-*  coupling      :
-*    getgravconst
-*    gstime      - find greenwich sidereal time from the julian date
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-static void initl
-     (
-       int satn,      gravconsttype whichconst,
-       double ecco,   double epoch,  double inclo,   double& no,
-       char& method,
-       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
-       double& cosio2,double& eccsq, double& omeosq, double& posq,
-       double& rp,    double& rteosq,double& sinio , double& gsto
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     double ak, d1, del, adel, po, x2o3, j2, xke,
-            tumin, mu, radiusearthkm, j3, j4, j3oj2;
-
-     // sgp4fix use old way of finding gst
-     int ids70;
-     double ts70, ds70, tfrac, c1, thgr70, fk5r, c1p2p;
-     const double twopi = 2.0 * pi;
-
-     /* ----------------------- earth constants ---------------------- */
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     x2o3   = 2.0 / 3.0;
-
-     /* ------------- calculate auxillary epoch quantities ---------- */
-     eccsq  = ecco * ecco;
-     omeosq = 1.0 - eccsq;
-     rteosq = sqrt(omeosq);
-     cosio  = cos(inclo);
-     cosio2 = cosio * cosio;
-
-     /* ------------------ un-kozai the mean motion ----------------- */
-     ak    = pow(xke / no, x2o3);
-     d1    = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
-     del   = d1 / (ak * ak);
-     adel  = ak * (1.0 - del * del - del *
-             (1.0 / 3.0 + 134.0 * del * del / 81.0));
-     del   = d1/(adel * adel);
-     no    = no / (1.0 + del);
-
-     ao    = pow(xke / no, x2o3);
-     sinio = sin(inclo);
-     po    = ao * omeosq;
-     con42 = 1.0 - 5.0 * cosio2;
-     con41 = -con42-cosio2-cosio2;
-     ainv  = 1.0 / ao;
-     posq  = po * po;
-     rp    = ao * (1.0 - ecco);
-     method = 'n';
-
-     // sgp4fix modern approach to finding sidereal timew
-     // gsto = gstime(epoch + 2433281.5);
-
-     // sgp4fix use old way of finding gst
-     // count integer number of days from 0 jan 1970
-     ts70  = epoch - 7305.0;
-     ids70 = floor(ts70 + 1.0e-8);
-     ds70  = ids70;
-     tfrac = ts70 - ds70;
-     // find greenwich location at epoch
-     c1    = 1.72027916940703639e-2;
-     thgr70= 1.7321343856509374;
-     fk5r  = 5.07551419432269442e-15;
-     c1p2p = c1 + twopi;
-     gsto  = fmod( thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r, twopi);
-     if ( gsto < 0.0 )
-         gsto = gsto + twopi;
-
-//#include "debug5.cpp"
-}  // end initl
-
-/*-----------------------------------------------------------------------------
-*
-*                             procedure sgp4init
-*
-*  this procedure initializes variables for sgp4.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    satn        - satellite number
-*    bstar       - sgp4 type drag coefficient              kg/m2er
-*    ecco        - eccentricity
-*    epoch       - epoch time in days from jan 0, 1950. 0 hr
-*    argpo       - argument of perigee (output if ds)
-*    inclo       - inclination
-*    mo          - mean anomaly (output if ds)
-*    no          - mean motion
-*    nodeo       - right ascension of ascending node
-*
-*  outputs       :
-*    satrec      - common values for subsequent calls
-*    return code - non-zero on error.
-*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-*                   2 - mean motion less than 0.0
-*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-*                   4 - semi-latus rectum < 0.0
-*                   5 - epoch elements are sub-orbital
-*                   6 - satellite has decayed
-*
-*  locals        :
-*    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
-*    cc1sq  , cc2    , cc3
-*    coef   , coef1
-*    cosio4      -
-*    day         -
-*    dndt        -
-*    em          - eccentricity
-*    emsq        - eccentricity squared
-*    eeta        -
-*    etasq       -
-*    gam         -
-*    argpm       - argument of perigee
-*    nodem       -
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    perige      - perigee
-*    pinvsq      -
-*    psisq       -
-*    qzms24      -
-*    rtemsq      -
-*    s1, s2, s3, s4, s5, s6, s7          -
-*    sfour       -
-*    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
-*    sz1, sz2, sz3
-*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
-*    tc          -
-*    temp        -
-*    temp1, temp2, temp3       -
-*    tsi         -
-*    xpidot      -
-*    xhdot1      -
-*    z1, z2, z3          -
-*    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
-*
-*  coupling      :
-*    getgravconst-
-*    initl       -
-*    dscom       -
-*    dpper       -
-*    dsinit      -
-*    sgp4        -
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-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
-     )
-{
-     /* --------------------- local variables ------------------------ */
-     double ao, ainv,   con42, cosio, sinio, cosio2, eccsq,
-          omeosq, posq,   rp,     rteosq,
-          cnodm , snodm , cosim , sinim , cosomm, sinomm, cc1sq ,
-          cc2   , cc3   , coef  , coef1 , cosio4, day   , dndt  ,
-          em    , emsq  , eeta  , etasq , gam   , argpm , nodem ,
-          inclm , mm    , nm    , perige, pinvsq, psisq , qzms24,
-          rtemsq, s1    , s2    , s3    , s4    , s5    , s6    ,
-          s7    , sfour , ss1 = 0   , ss2 = 0   , ss3 = 0   , ss4 = 0   , ss5 = 0   ,
-          ss6 = 0   , ss7 = 0   , sz1 = 0   , sz2 = 0   , sz3 = 0   , sz11 = 0  , sz12 = 0  ,
-          sz13 = 0  , sz21 = 0  , sz22 = 0  , sz23 = 0  , sz31 = 0  , sz32 = 0  , sz33 = 0  ,
-          tc    , temp  , temp1 , temp2 , temp3 , tsi   , xpidot,
-          xhdot1, z1    , z2    , z3    , z11   , z12   , z13   ,
-          z21   , z22   , z23   , z31   , z32   , z33,
-          qzms2t, ss, j2, j3oj2, j4, x2o3, r[3], v[3],
-          tumin, mu, radiusearthkm, xke, j3;
-
-     /* ------------------------ initialization --------------------- */
-     // sgp4fix divisor for divide by zero check on inclination
-     const double temp4    =   1.0 + cos(pi-1.0e-9);
-
-     /* ----------- set all near earth variables to zero ------------ */
-     satrec.isimp   = 0;   satrec.method = 'n'; satrec.aycof    = 0.0;
-     satrec.con41   = 0.0; satrec.cc1    = 0.0; satrec.cc4      = 0.0;
-     satrec.cc5     = 0.0; satrec.d2     = 0.0; satrec.d3       = 0.0;
-     satrec.d4      = 0.0; satrec.delmo  = 0.0; satrec.eta      = 0.0;
-     satrec.argpdot = 0.0; satrec.omgcof = 0.0; satrec.sinmao   = 0.0;
-     satrec.t       = 0.0; satrec.t2cof  = 0.0; satrec.t3cof    = 0.0;
-     satrec.t4cof   = 0.0; satrec.t5cof  = 0.0; satrec.x1mth2   = 0.0;
-     satrec.x7thm1  = 0.0; satrec.mdot   = 0.0; satrec.nodedot  = 0.0;
-     satrec.xlcof   = 0.0; satrec.xmcof  = 0.0; satrec.nodecf   = 0.0;
-
-     /* ----------- set all deep space variables to zero ------------ */
-     satrec.irez  = 0;   satrec.d2201 = 0.0; satrec.d2211 = 0.0;
-     satrec.d3210 = 0.0; satrec.d3222 = 0.0; satrec.d4410 = 0.0;
-     satrec.d4422 = 0.0; satrec.d5220 = 0.0; satrec.d5232 = 0.0;
-     satrec.d5421 = 0.0; satrec.d5433 = 0.0; satrec.dedt  = 0.0;
-     satrec.del1  = 0.0; satrec.del2  = 0.0; satrec.del3  = 0.0;
-     satrec.didt  = 0.0; satrec.dmdt  = 0.0; satrec.dnodt = 0.0;
-     satrec.domdt = 0.0; satrec.e3    = 0.0; satrec.ee2   = 0.0;
-     satrec.peo   = 0.0; satrec.pgho  = 0.0; satrec.pho   = 0.0;
-     satrec.pinco = 0.0; satrec.plo   = 0.0; satrec.se2   = 0.0;
-     satrec.se3   = 0.0; satrec.sgh2  = 0.0; satrec.sgh3  = 0.0;
-     satrec.sgh4  = 0.0; satrec.sh2   = 0.0; satrec.sh3   = 0.0;
-     satrec.si2   = 0.0; satrec.si3   = 0.0; satrec.sl2   = 0.0;
-     satrec.sl3   = 0.0; satrec.sl4   = 0.0; satrec.gsto  = 0.0;
-     satrec.xfact = 0.0; satrec.xgh2  = 0.0; satrec.xgh3  = 0.0;
-     satrec.xgh4  = 0.0; satrec.xh2   = 0.0; satrec.xh3   = 0.0;
-     satrec.xi2   = 0.0; satrec.xi3   = 0.0; satrec.xl2   = 0.0;
-     satrec.xl3   = 0.0; satrec.xl4   = 0.0; satrec.xlamo = 0.0;
-     satrec.zmol  = 0.0; satrec.zmos  = 0.0; satrec.atime = 0.0;
-     satrec.xli   = 0.0; satrec.xni   = 0.0;
-
-     // sgp4fix - note the following variables are also passed directly via satrec.
-     // it is possible to streamline the sgp4init call by deleting the "x"
-     // variables, but the user would need to set the satrec.* values first. we
-     // include the additional assignments in case twoline2rv is not used.
-     satrec.bstar   = xbstar;
-     satrec.ecco    = xecco;
-     satrec.argpo   = xargpo;
-     satrec.inclo   = xinclo;
-     satrec.mo	    = xmo;
-     satrec.no	    = xno;
-     satrec.nodeo   = xnodeo;
-
-     /* ------------------------ earth constants ----------------------- */
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     ss     = 78.0 / radiusearthkm + 1.0;
-     qzms2t = pow(((120.0 - 78.0) / radiusearthkm), 4);
-     x2o3   =  2.0 / 3.0;
-
-     satrec.init = 'y';
-     satrec.t	 = 0.0;
-
-     initl
-         (
-           satn, whichconst, satrec.ecco, epoch, satrec.inclo, satrec.no, satrec.method,
-           ainv, ao, satrec.con41, con42, cosio, cosio2, eccsq, omeosq,
-           posq, rp, rteosq, sinio, satrec.gsto
-         );
-     satrec.error = 0;
-
-     if (rp < 1.0)
-       {
-//         printf("# *** satn%d epoch elts sub-orbital ***\n", satn);
-         satrec.error = 5;
-       }
-
-     if ((omeosq >= 0.0 ) || ( satrec.no >= 0.0))
-       {
-         satrec.isimp = 0;
-         if (rp < (220.0 / radiusearthkm + 1.0))
-             satrec.isimp = 1;
-         sfour  = ss;
-         qzms24 = qzms2t;
-         perige = (rp - 1.0) * radiusearthkm;
-
-         /* - for perigees below 156 km, s and qoms2t are altered - */
-         if (perige < 156.0)
-           {
-             sfour = perige - 78.0;
-             if (perige < 98.0)
-                 sfour = 20.0;
-             qzms24 = pow(((120.0 - sfour) / radiusearthkm), 4.0);
-             sfour  = sfour / radiusearthkm + 1.0;
-           }
-         pinvsq = 1.0 / posq;
-
-         tsi  = 1.0 / (ao - sfour);
-         satrec.eta  = ao * satrec.ecco * tsi;
-         etasq = satrec.eta * satrec.eta;
-         eeta  = satrec.ecco * satrec.eta;
-         psisq = fabs(1.0 - etasq);
-         coef  = qzms24 * pow(tsi, 4.0);
-         coef1 = coef / pow(psisq, 3.5);
-         cc2   = coef1 * satrec.no * (ao * (1.0 + 1.5 * etasq + eeta *
-                        (4.0 + etasq)) + 0.375 * j2 * tsi / psisq * satrec.con41 *
-                        (8.0 + 3.0 * etasq * (8.0 + etasq)));
-         satrec.cc1   = satrec.bstar * cc2;
-         cc3   = 0.0;
-         if (satrec.ecco > 1.0e-4)
-             cc3 = -2.0 * coef * tsi * j3oj2 * satrec.no * sinio / satrec.ecco;
-         satrec.x1mth2 = 1.0 - cosio2;
-         satrec.cc4    = 2.0* satrec.no * coef1 * ao * omeosq *
-                           (satrec.eta * (2.0 + 0.5 * etasq) + satrec.ecco *
-                           (0.5 + 2.0 * etasq) - j2 * tsi / (ao * psisq) *
-                           (-3.0 * satrec.con41 * (1.0 - 2.0 * eeta + etasq *
-                           (1.5 - 0.5 * eeta)) + 0.75 * satrec.x1mth2 *
-                           (2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * satrec.argpo)));
-         satrec.cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 *
-                        (etasq + eeta) + eeta * etasq);
-         cosio4 = cosio2 * cosio2;
-         temp1  = 1.5 * j2 * pinvsq * satrec.no;
-         temp2  = 0.5 * temp1 * j2 * pinvsq;
-         temp3  = -0.46875 * j4 * pinvsq * pinvsq * satrec.no;
-         satrec.mdot     = satrec.no + 0.5 * temp1 * rteosq * satrec.con41 + 0.0625 *
-                            temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
-         satrec.argpdot  = -0.5 * temp1 * con42 + 0.0625 * temp2 *
-                             (7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
-                             temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
-         xhdot1            = -temp1 * cosio;
-         satrec.nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) +
-                              2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
-         xpidot            =  satrec.argpdot+ satrec.nodedot;
-         satrec.omgcof   = satrec.bstar * cc3 * cos(satrec.argpo);
-         satrec.xmcof    = 0.0;
-         if (satrec.ecco > 1.0e-4)
-             satrec.xmcof = -x2o3 * coef * satrec.bstar / eeta;
-         satrec.nodecf = 3.5 * omeosq * xhdot1 * satrec.cc1;
-         satrec.t2cof   = 1.5 * satrec.cc1;
-         // sgp4fix for divide by zero with xinco = 180 deg
-         if (fabs(cosio+1.0) > 1.5e-12)
-             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / (1.0 + cosio);
-           else
-             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / temp4;
-         satrec.aycof   = -0.5 * j3oj2 * sinio;
-         satrec.delmo   = pow((1.0 + satrec.eta * cos(satrec.mo)), 3);
-         satrec.sinmao  = sin(satrec.mo);
-         satrec.x7thm1  = 7.0 * cosio2 - 1.0;
-
-         /* --------------- deep space initialization ------------- */
-         if ((2*pi / satrec.no) >= 225.0)
-           {
-             satrec.method = 'd';
-             satrec.isimp  = 1;
-             tc    =  0.0;
-             inclm = satrec.inclo;
-
-             dscom
-                 (
-                   epoch, satrec.ecco, satrec.argpo, tc, satrec.inclo, satrec.nodeo,
-                   satrec.no, snodm, cnodm,  sinim, cosim,sinomm,     cosomm,
-                   day, satrec.e3, satrec.ee2, em,         emsq, gam,
-                   satrec.peo,  satrec.pgho,   satrec.pho, satrec.pinco,
-                   satrec.plo,  rtemsq,        satrec.se2, satrec.se3,
-                   satrec.sgh2, satrec.sgh3,   satrec.sgh4,
-                   satrec.sh2,  satrec.sh3,    satrec.si2, satrec.si3,
-                   satrec.sl2,  satrec.sl3,    satrec.sl4, s1, s2, s3, s4, s5,
-                   s6,   s7,   ss1,  ss2,  ss3,  ss4,  ss5,  ss6,  ss7, sz1, sz2, sz3,
-                   sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33,
-                   satrec.xgh2, satrec.xgh3,   satrec.xgh4, satrec.xh2,
-                   satrec.xh3,  satrec.xi2,    satrec.xi3,  satrec.xl2,
-                   satrec.xl3,  satrec.xl4,    nm, z1, z2, z3, z11,
-                   z12, z13, z21, z22, z23, z31, z32, z33,
-                   satrec.zmol, satrec.zmos
-                 );
-             dpper
-                 (
-                   satrec.e3, satrec.ee2, satrec.peo, satrec.pgho,
-                   satrec.pho, satrec.pinco, satrec.plo, satrec.se2,
-                   satrec.se3, satrec.sgh2, satrec.sgh3, satrec.sgh4,
-                   satrec.sh2, satrec.sh3, satrec.si2,  satrec.si3,
-                   satrec.sl2, satrec.sl3, satrec.sl4,  satrec.t,
-                   satrec.xgh2,satrec.xgh3,satrec.xgh4, satrec.xh2,
-                   satrec.xh3, satrec.xi2, satrec.xi3,  satrec.xl2,
-                   satrec.xl3, satrec.xl4, satrec.zmol, satrec.zmos, inclm, satrec.init,
-                   satrec.ecco, satrec.inclo, satrec.nodeo, satrec.argpo, satrec.mo
-                 );
-
-             argpm  = 0.0;
-             nodem  = 0.0;
-             mm     = 0.0;
-
-             dsinit
-                 (
-                   whichconst,
-                   cosim, emsq, satrec.argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4,
-                   ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, satrec.t, tc,
-                   satrec.gsto, satrec.mo, satrec.mdot, satrec.no, satrec.nodeo,
-                   satrec.nodedot, xpidot, z1, z3, z11, z13, z21, z23, z31, z33,
-                   satrec.ecco, eccsq, em, argpm, inclm, mm, nm, nodem,
-                   satrec.irez,  satrec.atime,
-                   satrec.d2201, satrec.d2211, satrec.d3210, satrec.d3222 ,
-                   satrec.d4410, satrec.d4422, satrec.d5220, satrec.d5232,
-                   satrec.d5421, satrec.d5433, satrec.dedt,  satrec.didt,
-                   satrec.dmdt,  dndt,         satrec.dnodt, satrec.domdt ,
-                   satrec.del1,  satrec.del2,  satrec.del3,  satrec.xfact,
-                   satrec.xlamo, satrec.xli,   satrec.xni
-                 );
-           }
-
-       /* ----------- set variables if not deep space ----------- */
-       if (satrec.isimp != 1)
-         {
-           cc1sq          = satrec.cc1 * satrec.cc1;
-           satrec.d2    = 4.0 * ao * tsi * cc1sq;
-           temp           = satrec.d2 * tsi * satrec.cc1 / 3.0;
-           satrec.d3    = (17.0 * ao + sfour) * temp;
-           satrec.d4    = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) *
-                            satrec.cc1;
-           satrec.t3cof = satrec.d2 + 2.0 * cc1sq;
-           satrec.t4cof = 0.25 * (3.0 * satrec.d3 + satrec.cc1 *
-                            (12.0 * satrec.d2 + 10.0 * cc1sq));
-           satrec.t5cof = 0.2 * (3.0 * satrec.d4 +
-                            12.0 * satrec.cc1 * satrec.d3 +
-                            6.0 * satrec.d2 * satrec.d2 +
-                            15.0 * cc1sq * (2.0 * satrec.d2 + cc1sq));
-         }
-       } // if omeosq = 0 ...
-
-       /* finally propogate to zero epoch to initialise all others. */
-       if(satrec.error == 0)
-           sgp4(whichconst, satrec, 0.0, r, v);
-
-       satrec.init = 'n';
-
-//#include "debug6.cpp"
-       return satrec.error;
-}  // end sgp4init
-
-/*-----------------------------------------------------------------------------
-*
-*                             procedure sgp4
-*
-*  this procedure is the sgp4 prediction model from space command. this is an
-*    updated and combined version of sgp4 and sdp4, which were originally
-*    published separately in spacetrack report #3. this version follows the
-*    methodology from the aiaa paper (2006) describing the history and
-*    development of the code.
-*
-*  author        : david vallado                  719-573-2600   28 jun 2005
-*
-*  inputs        :
-*    satrec	 - initialised structure from sgp4init() call.
-*    tsince	 - time eince epoch (minutes)
-*
-*  outputs       :
-*    r           - position vector                     km
-*    v           - velocity                            km/sec
-*  return code - non-zero on error.
-*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
-*                   2 - mean motion less than 0.0
-*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
-*                   4 - semi-latus rectum < 0.0
-*                   5 - epoch elements are sub-orbital
-*                   6 - satellite has decayed
-*
-*  locals        :
-*    am          -
-*    axnl, aynl        -
-*    betal       -
-*    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
-*    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
-*    cosisq  , cossu   , sinsu   , cosu    , sinu
-*    delm        -
-*    delomg      -
-*    dndt        -
-*    eccm        -
-*    emsq        -
-*    ecose       -
-*    el2         -
-*    eo1         -
-*    eccp        -
-*    esine       -
-*    argpm       -
-*    argpp       -
-*    omgadf      -
-*    pl          -
-*    r           -
-*    rtemsq      -
-*    rdotl       -
-*    rl          -
-*    rvdot       -
-*    rvdotl      -
-*    su          -
-*    t2  , t3   , t4    , tc
-*    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
-*    u   , ux   , uy    , uz     , vx     , vy     , vz
-*    inclm       - inclination
-*    mm          - mean anomaly
-*    nm          - mean motion
-*    nodem       - right asc of ascending node
-*    xinc        -
-*    xincp       -
-*    xl          -
-*    xlm         -
-*    mp          -
-*    xmdf        -
-*    xmx         -
-*    xmy         -
-*    nodedf      -
-*    xnode       -
-*    nodep       -
-*    np          -
-*
-*  coupling      :
-*    getgravconst-
-*    dpper
-*    dpspace
-*
-*  references    :
-*    hoots, roehrich, norad spacetrack report #3 1980
-*    hoots, norad spacetrack report #6 1986
-*    hoots, schumacher and glover 2004
-*    vallado, crawford, hujsak, kelso  2006
-  ----------------------------------------------------------------------------*/
-
-int sgp4
-     (
-       gravconsttype whichconst, elsetrec& satrec,  double tsince,
-       double r[3],  double v[3]
-     )
-{
-     double am   , axnl  , aynl , betal ,  cosim , cnod  ,
-         cos2u, coseo1, cosi , cosip ,  cosisq, cossu , cosu,
-         delm , delomg, em   , emsq  ,  ecose , el2   , eo1 ,
-         ep   , esine , argpm, argpp ,  argpdf, pl,     mrt = 0.0,
-         mvt  , rdotl , rl   , rvdot ,  rvdotl, sinim ,
-         sin2u, sineo1, sini , sinip ,  sinsu , sinu  ,
-         snod , su    , t2   , t3    ,  t4    , tem5  , temp,
-         temp1, temp2 , tempa, tempe ,  templ , u     , ux  ,
-         uy   , uz    , vx   , vy    ,  vz    , inclm , mm  ,
-         nm   , nodem, xinc , xincp ,  xl    , xlm   , mp  ,
-         xmdf , xmx   , xmy  , nodedf, xnode , nodep, tc  , dndt,
-         twopi, x2o3  , j2   , j3    , tumin, j4 , xke   , j3oj2, radiusearthkm,
-         mu, vkmpersec;
-     int ktr;
-
-     /* ------------------ set mathematical constants --------------- */
-     // sgp4fix divisor for divide by zero check on inclination
-     const double temp4    =   1.0 + cos(pi-1.0e-9);
-     twopi = 2.0 * pi;
-     x2o3  = 2.0 / 3.0;
-     // sgp4fix identify constants and allow alternate values
-     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
-     vkmpersec     = radiusearthkm * xke/60.0;
-
-     /* --------------------- clear sgp4 error flag ----------------- */
-     satrec.t     = tsince;
-     satrec.error = 0;
-
-     /* ------- update for secular gravity and atmospheric drag ----- */
-     xmdf    = satrec.mo + satrec.mdot * satrec.t;
-     argpdf  = satrec.argpo + satrec.argpdot * satrec.t;
-     nodedf  = satrec.nodeo + satrec.nodedot * satrec.t;
-     argpm   = argpdf;
-     mm      = xmdf;
-     t2      = satrec.t * satrec.t;
-     nodem   = nodedf + satrec.nodecf * t2;
-     tempa   = 1.0 - satrec.cc1 * satrec.t;
-     tempe   = satrec.bstar * satrec.cc4 * satrec.t;
-     templ   = satrec.t2cof * t2;
-
-     if (satrec.isimp != 1)
-       {
-         delomg = satrec.omgcof * satrec.t;
-         delm   = satrec.xmcof *
-                  (pow((1.0 + satrec.eta * cos(xmdf)), 3) -
-                  satrec.delmo);
-         temp   = delomg + delm;
-         mm     = xmdf + temp;
-         argpm  = argpdf - temp;
-         t3     = t2 * satrec.t;
-         t4     = t3 * satrec.t;
-         tempa  = tempa - satrec.d2 * t2 - satrec.d3 * t3 -
-                          satrec.d4 * t4;
-         tempe  = tempe + satrec.bstar * satrec.cc5 * (sin(mm) -
-                          satrec.sinmao);
-         templ  = templ + satrec.t3cof * t3 + t4 * (satrec.t4cof +
-                          satrec.t * satrec.t5cof);
-       }
-
-     nm    = satrec.no;
-     em    = satrec.ecco;
-     inclm = satrec.inclo;
-     if (satrec.method == 'd')
-       {
-         tc = satrec.t;
-         dspace
-             (
-               satrec.irez,
-               satrec.d2201, satrec.d2211, satrec.d3210,
-               satrec.d3222, satrec.d4410, satrec.d4422,
-               satrec.d5220, satrec.d5232, satrec.d5421,
-               satrec.d5433, satrec.dedt,  satrec.del1,
-               satrec.del2,  satrec.del3,  satrec.didt,
-               satrec.dmdt,  satrec.dnodt, satrec.domdt,
-               satrec.argpo, satrec.argpdot, satrec.t, tc,
-               satrec.gsto, satrec.xfact, satrec.xlamo,
-               satrec.no, satrec.atime,
-               em, argpm, inclm, satrec.xli, mm, satrec.xni,
-               nodem, dndt, nm
-             );
-       } // if method = d
-
-     if (nm <= 0.0)
-       {
-//         printf("# error nm %f\n", nm);
-         satrec.error = 2;
-       }
-     am = pow((xke / nm),x2o3) * tempa * tempa;
-     nm = xke / pow(am, 1.5);
-     em = em - tempe;
-
-     // fix tolerance for error recognition
-     if ((em >= 1.0) || (em < -0.001) || (am < 0.95))
-       {
-//         printf("# error em %f\n", em);
-         satrec.error = 1;
-       }
-     if (em < 0.0)
-         em  = 1.0e-6;
-     mm     = mm + satrec.no * templ;
-     xlm    = mm + argpm + nodem;
-     emsq   = em * em;
-     temp   = 1.0 - emsq;
-
-     nodem  = fmod(nodem, twopi);
-     argpm  = fmod(argpm, twopi);
-     xlm    = fmod(xlm, twopi);
-     mm     = fmod(xlm - argpm - nodem, twopi);
-
-     /* ----------------- compute extra mean quantities ------------- */
-     sinim = sin(inclm);
-     cosim = cos(inclm);
-
-     /* -------------------- add lunar-solar periodics -------------- */
-     ep     = em;
-     xincp  = inclm;
-     argpp  = argpm;
-     nodep  = nodem;
-     mp     = mm;
-     sinip  = sinim;
-     cosip  = cosim;
-     if (satrec.method == 'd')
-       {
-         dpper
-             (
-               satrec.e3,   satrec.ee2,  satrec.peo,
-               satrec.pgho, satrec.pho,  satrec.pinco,
-               satrec.plo,  satrec.se2,  satrec.se3,
-               satrec.sgh2, satrec.sgh3, satrec.sgh4,
-               satrec.sh2,  satrec.sh3,  satrec.si2,
-               satrec.si3,  satrec.sl2,  satrec.sl3,
-               satrec.sl4,  satrec.t,    satrec.xgh2,
-               satrec.xgh3, satrec.xgh4, satrec.xh2,
-               satrec.xh3,  satrec.xi2,  satrec.xi3,
-               satrec.xl2,  satrec.xl3,  satrec.xl4,
-               satrec.zmol, satrec.zmos, satrec.inclo,
-               'n', ep, xincp, nodep, argpp, mp
-             );
-         if (xincp < 0.0)
-           {
-             xincp  = -xincp;
-             nodep = nodep + pi;
-             argpp  = argpp - pi;
-           }
-         if ((ep < 0.0 ) || ( ep > 1.0))
-           {
- //            printf("# error ep %f\n", ep);
-             satrec.error = 3;
-           }
-       } // if method = d
-
-     /* -------------------- long period periodics ------------------ */
-     if (satrec.method == 'd')
-       {
-         sinip =  sin(xincp);
-         cosip =  cos(xincp);
-         satrec.aycof = -0.5*j3oj2*sinip;
-         // sgp4fix for divide by zero for xincp = 180 deg
-         if (fabs(cosip+1.0) > 1.5e-12)
-             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / (1.0 + cosip);
-           else
-             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / temp4;
-       }
-     axnl = ep * cos(argpp);
-     temp = 1.0 / (am * (1.0 - ep * ep));
-     aynl = ep* sin(argpp) + temp * satrec.aycof;
-     xl   = mp + argpp + nodep + temp * satrec.xlcof * axnl;
-
-     /* --------------------- solve kepler's equation --------------- */
-     u    = fmod(xl - nodep, twopi);
-     eo1  = u;
-     tem5 = 9999.9;
-     ktr = 1;
-     //   sgp4fix for kepler iteration
-     //   the following iteration needs better limits on corrections
-     while (( fabs(tem5) >= 1.0e-12) && (ktr <= 10) )
-       {
-         sineo1 = sin(eo1);
-         coseo1 = cos(eo1);
-         tem5   = 1.0 - coseo1 * axnl - sineo1 * aynl;
-         tem5   = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
-         if(fabs(tem5) >= 0.95)
-             tem5 = tem5 > 0.0 ? 0.95 : -0.95;
-         eo1    = eo1 + tem5;
-         ktr = ktr + 1;
-       }
-
-     /* ------------- short period preliminary quantities ----------- */
-     ecose = axnl*coseo1 + aynl*sineo1;
-     esine = axnl*sineo1 - aynl*coseo1;
-     el2   = axnl*axnl + aynl*aynl;
-     pl    = am*(1.0-el2);
-     if (pl < 0.0)
-       {
-//         printf("# error pl %f\n", pl);
-         satrec.error = 4;
-       }
-       else
-       {
-         rl     = am * (1.0 - ecose);
-         rdotl  = sqrt(am) * esine/rl;
-         rvdotl = sqrt(pl) / rl;
-         betal  = sqrt(1.0 - el2);
-         temp   = esine / (1.0 + betal);
-         sinu   = am / rl * (sineo1 - aynl - axnl * temp);
-         cosu   = am / rl * (coseo1 - axnl + aynl * temp);
-         su     = atan2(sinu, cosu);
-         sin2u  = (cosu + cosu) * sinu;
-         cos2u  = 1.0 - 2.0 * sinu * sinu;
-         temp   = 1.0 / pl;
-         temp1  = 0.5 * j2 * temp;
-         temp2  = temp1 * temp;
-
-         /* -------------- update for short period periodics ------------ */
-         if (satrec.method == 'd')
-           {
-             cosisq                 = cosip * cosip;
-             satrec.con41  = 3.0*cosisq - 1.0;
-             satrec.x1mth2 = 1.0 - cosisq;
-             satrec.x7thm1 = 7.0*cosisq - 1.0;
-           }
-         mrt   = rl * (1.0 - 1.5 * temp2 * betal * satrec.con41) +
-                 0.5 * temp1 * satrec.x1mth2 * cos2u;
-         su    = su - 0.25 * temp2 * satrec.x7thm1 * sin2u;
-         xnode = nodep + 1.5 * temp2 * cosip * sin2u;
-         xinc  = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
-         mvt   = rdotl - nm * temp1 * satrec.x1mth2 * sin2u / xke;
-         rvdot = rvdotl + nm * temp1 * (satrec.x1mth2 * cos2u +
-                 1.5 * satrec.con41) / xke;
-
-         /* --------------------- orientation vectors ------------------- */
-         sinsu =  sin(su);
-         cossu =  cos(su);
-         snod  =  sin(xnode);
-         cnod  =  cos(xnode);
-         sini  =  sin(xinc);
-         cosi  =  cos(xinc);
-         xmx   = -snod * cosi;
-         xmy   =  cnod * cosi;
-         ux    =  xmx * sinsu + cnod * cossu;
-         uy    =  xmy * sinsu + snod * cossu;
-         uz    =  sini * sinsu;
-         vx    =  xmx * cossu - cnod * sinsu;
-         vy    =  xmy * cossu - snod * sinsu;
-         vz    =  sini * cossu;
-
-         /* --------- position and velocity (in km and km/sec) ---------- */
-         r[0] = (mrt * ux)* radiusearthkm;
-         r[1] = (mrt * uy)* radiusearthkm;
-         r[2] = (mrt * uz)* radiusearthkm;
-         v[0] = (mvt * ux + rvdot * vx) * vkmpersec;
-         v[1] = (mvt * uy + rvdot * vy) * vkmpersec;
-         v[2] = (mvt * uz + rvdot * vz) * vkmpersec;
-       }  // if pl > 0
-
-     // sgp4fix for decaying satellites
-     if (mrt < 1.0)
-       {
-//         printf("# decay condition %11.6f \n",mrt);
-         satrec.error = 6;
-       }
-
-
-//#include "debug7.cpp"
-     return satrec.error;
-}  // end sgp4
-
-
-/* -----------------------------------------------------------------------------
-*
-*                           function gstime
-*
-*  this function finds the greenwich sidereal time.
-*
-*  author        : david vallado                  719-573-2600    1 mar 2001
-*
-*  inputs          description                    range / units
-*    jdut1       - julian date in ut1             days from 4713 bc
-*
-*  outputs       :
-*    gstime      - greenwich sidereal time        0 to 2pi rad
-*
-*  locals        :
-*    temp        - temporary variable for doubles   rad
-*    tut1        - julian centuries from the
-*                  jan 1, 2000 12 h epoch (ut1)
-*
-*  coupling      :
-*    none
-*
-*  references    :
-*    vallado       2004, 191, eq 3-45
-* --------------------------------------------------------------------------- */
-
-double  gstime
-        (
-          double jdut1
-        )
-   {
-     const double twopi = 2.0 * pi;
-     const double deg2rad = pi / 180.0;
-     double       temp, tut1;
-
-     tut1 = (jdut1 - 2451545.0) / 36525.0;
-     temp = -6.2e-6* tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
-             (876600.0*3600 + 8640184.812866) * tut1 + 67310.54841;  // sec
-     temp = fmod(temp * deg2rad / 240.0, twopi); //360/86400 = 1/240, to deg, to rad
-
-     // ------------------------ check quadrants ---------------------
-     if (temp < 0.0)
-         temp += twopi;
-
-     return temp;
-   }  // end gstime
-
-/* -----------------------------------------------------------------------------
-*
-*                           function getgravconst
-*
-*  this function gets constants for the propagator. note that mu is identified to
-*    facilitiate comparisons with newer models. the common useage is wgs72.
-*
-*  author        : david vallado                  719-573-2600   21 jul 2006
-*
-*  inputs        :
-*    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
-*
-*  outputs       :
-*    tumin       - minutes in one time unit
-*    mu          - earth gravitational parameter
-*    radiusearthkm - radius of the earth in km
-*    xke         - reciprocal of tumin
-*    j2, j3, j4  - un-normalized zonal harmonic values
-*    j3oj2       - j3 divided by j2
-*
-*  locals        :
-*
-*  coupling      :
-*    none
-*
-*  references    :
-*    norad spacetrack report #3
-*    vallado, crawford, hujsak, kelso  2006
-  --------------------------------------------------------------------------- */
-
-void getgravconst
-     (
-      gravconsttype whichconst,
-      double& tumin,
-      double& mu,
-      double& radiusearthkm,
-      double& xke,
-      double& j2,
-      double& j3,
-      double& j4,
-      double& j3oj2
-     )
-     {
-
-       switch (whichconst)
-         {
-           // -- wgs-72 low precision str#3 constants --
-           case wgs72old:
-           mu     = 398600.79964;        // in km3 / s2
-           radiusearthkm = 6378.135;     // km
-           xke    = 0.0743669161;
-           tumin  = 1.0 / xke;
-           j2     =   0.001082616;
-           j3     =  -0.00000253881;
-           j4     =  -0.00000165597;
-           j3oj2  =  j3 / j2;
-         break;
-           // ------------ wgs-72 constants ------------
-           case wgs72:
-           mu     = 398600.8;            // in km3 / s2
-           radiusearthkm = 6378.135;     // km
-           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
-           tumin  = 1.0 / xke;
-           j2     =   0.001082616;
-           j3     =  -0.00000253881;
-           j4     =  -0.00000165597;
-           j3oj2  =  j3 / j2;
-         break;
-           case wgs84:
-           // ------------ wgs-84 constants ------------
-           mu     = 398600.5;            // in km3 / s2
-           radiusearthkm = 6378.137;     // km
-           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
-           tumin  = 1.0 / xke;
-           j2     =   0.00108262998905;
-           j3     =  -0.00000253215306;
-           j4     =  -0.00000161098761;
-           j3oj2  =  j3 / j2;
-         break;
-         default:
-           fprintf(stderr,"unknown gravity option (%d)\n",whichconst);
-         break;
-         }
-
-     }   // end getgravconst
-
-
-
-
-
+/*     ----------------------------------------------------------------
+*
+*                               sgp4unit.cpp
+*
+*    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 :
+*              16 nov 07  david vallado
+*                           misc fixes for better compliance
+*    changes :
+*              20 apr 07  david vallado
+*                           misc fixes for constants
+*              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 "sgp4unit.h"
+
+const char help = 'n';
+FILE *dbgfile;
+
+#define pi 3.14159265358979323846
+
+
+/* ----------- local functions - only ever used internally by sgp4 ---------- */
+static void dpper
+     (
+       double e3,     double ee2,    double peo,     double pgho,   double pho,
+       double pinco,  double plo,    double se2,     double se3,    double sgh2,
+       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
+       double si3,    double sl2,    double sl3,     double sl4,    double t,
+       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
+       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
+       double zmol,   double zmos,   double inclo,
+       char init,
+       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
+     );
+
+static void dscom
+     (
+       double epoch,  double ep,     double argpp,   double tc,     double inclp,
+       double nodep,  double np,
+       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
+       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
+       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
+       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
+       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
+       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
+       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
+       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
+       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
+       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
+       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
+       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
+       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
+       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
+       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
+       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
+       double& zmos
+     );
+
+static void dsinit
+     (
+       gravconsttype whichconst,
+       double cosim,  double emsq,   double argpo,   double s1,     double s2,
+       double s3,     double s4,     double s5,      double sinim,  double ss1,
+       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
+       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
+       double sz31,   double sz33,   double t,       double tc,     double gsto,
+       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
+       double xpidot, double z1,     double z3,      double z11,    double z13,
+       double z21,    double z23,    double z31,     double z33,    double ecco,
+       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
+       double& nm,    double& nodem,
+       int& irez,
+       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
+       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
+       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
+       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
+       double& xfact, double& xlamo, double& xli,    double& xni
+     );
+
+static void dspace
+     (
+       int irez,
+       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
+       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
+       double dedt,   double del1,   double del2,    double del3,   double didt,
+       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
+       double t,      double tc,     double gsto,    double xfact,  double xlamo,
+       double no,
+       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
+       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
+     );
+
+static void initl
+     (
+       int satn,      gravconsttype whichconst,
+       double ecco,   double epoch,  double inclo,   double& no,
+       char& method,
+       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
+       double& cosio2,double& eccsq, double& omeosq, double& posq,
+       double& rp,    double& rteosq,double& sinio , double& gsto
+     );
+
+/* -----------------------------------------------------------------------------
+*
+*                           procedure dpper
+*
+*  this procedure provides deep space long period periodic contributions
+*    to the mean elements.  by design, these periodics are zero at epoch.
+*    this used to be dscom which included initialization, but it's really a
+*    recurring function.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    e3          -
+*    ee2         -
+*    peo         -
+*    pgho        -
+*    pho         -
+*    pinco       -
+*    plo         -
+*    se2 , se3 , sgh2, sgh3, sgh4, sh2, sh3, si2, si3, sl2, sl3, sl4 -
+*    t           -
+*    xh2, xh3, xi2, xi3, xl2, xl3, xl4 -
+*    zmol        -
+*    zmos        -
+*    ep          - eccentricity                           0.0 - 1.0
+*    inclo       - inclination - needed for lyddane modification
+*    nodep       - right ascension of ascending node
+*    argpp       - argument of perigee
+*    mp          - mean anomaly
+*
+*  outputs       :
+*    ep          - eccentricity                           0.0 - 1.0
+*    inclp       - inclination
+*    nodep        - right ascension of ascending node
+*    argpp       - argument of perigee
+*    mp          - mean anomaly
+*
+*  locals        :
+*    alfdp       -
+*    betdp       -
+*    cosip  , sinip  , cosop  , sinop  ,
+*    dalf        -
+*    dbet        -
+*    dls         -
+*    f2, f3      -
+*    pe          -
+*    pgh         -
+*    ph          -
+*    pinc        -
+*    pl          -
+*    sel   , ses   , sghl  , sghs  , shl   , shs   , sil   , sinzf , sis   ,
+*    sll   , sls
+*    xls         -
+*    xnoh        -
+*    zf          -
+*    zm          -
+*
+*  coupling      :
+*    none.
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dpper
+     (
+       double e3,     double ee2,    double peo,     double pgho,   double pho,
+       double pinco,  double plo,    double se2,     double se3,    double sgh2,
+       double sgh3,   double sgh4,   double sh2,     double sh3,    double si2,
+       double si3,    double sl2,    double sl3,     double sl4,    double t,
+       double xgh2,   double xgh3,   double xgh4,    double xh2,    double xh3,
+       double xi2,    double xi3,    double xl2,     double xl3,    double xl4,
+       double zmol,   double zmos,   double inclo,
+       char init,
+       double& ep,    double& inclp, double& nodep,  double& argpp, double& mp
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     const double twopi = 2.0 * pi;
+     double alfdp, betdp, cosip, cosop, dalf, dbet, dls,
+          f2,    f3,    pe,    pgh,   ph,   pinc, pl ,
+          sel,   ses,   sghl,  sghs,  shll, shs,  sil,
+          sinip, sinop, sinzf, sis,   sll,  sls,  xls,
+          xnoh,  zf,    zm,    zel,   zes,  znl,  zns;
+
+     /* ---------------------- constants ----------------------------- */
+     zns   = 1.19459e-5;
+     zes   = 0.01675;
+     znl   = 1.5835218e-4;
+     zel   = 0.05490;
+
+     /* --------------- calculate time varying periodics ----------- */
+     zm    = zmos + zns * t;
+     // be sure that the initial call has time set to zero
+     if (init == 'y')
+         zm = zmos;
+     zf    = zm + 2.0 * zes * sin(zm);
+     sinzf = sin(zf);
+     f2    =  0.5 * sinzf * sinzf - 0.25;
+     f3    = -0.5 * sinzf * cos(zf);
+     ses   = se2* f2 + se3 * f3;
+     sis   = si2 * f2 + si3 * f3;
+     sls   = sl2 * f2 + sl3 * f3 + sl4 * sinzf;
+     sghs  = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf;
+     shs   = sh2 * f2 + sh3 * f3;
+     zm    = zmol + znl * t;
+     if (init == 'y')
+         zm = zmol;
+     zf    = zm + 2.0 * zel * sin(zm);
+     sinzf = sin(zf);
+     f2    =  0.5 * sinzf * sinzf - 0.25;
+     f3    = -0.5 * sinzf * cos(zf);
+     sel   = ee2 * f2 + e3 * f3;
+     sil   = xi2 * f2 + xi3 * f3;
+     sll   = xl2 * f2 + xl3 * f3 + xl4 * sinzf;
+     sghl  = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf;
+     shll  = xh2 * f2 + xh3 * f3;
+     pe    = ses + sel;
+     pinc  = sis + sil;
+     pl    = sls + sll;
+     pgh   = sghs + sghl;
+     ph    = shs + shll;
+
+     if (init == 'n')
+       {
+       pe    = pe - peo;
+       pinc  = pinc - pinco;
+       pl    = pl - plo;
+       pgh   = pgh - pgho;
+       ph    = ph - pho;
+       inclp = inclp + pinc;
+       ep    = ep + pe;
+       sinip = sin(inclp);
+       cosip = cos(inclp);
+
+       /* ----------------- apply periodics directly ------------ */
+       //  sgp4fix for lyddane choice
+       //  strn3 used original inclination - this is technically feasible
+       //  gsfc used perturbed inclination - also technically feasible
+       //  probably best to readjust the 0.2 limit value and limit discontinuity
+       //  0.2 rad = 11.45916 deg
+       //  use next line for original strn3 approach and original inclination
+       //  if (inclo >= 0.2)
+       //  use next line for gsfc version and perturbed inclination
+       if (inclp >= 0.2)
+         {
+           ph     = ph / sinip;
+           pgh    = pgh - cosip * ph;
+           argpp  = argpp + pgh;
+           nodep  = nodep + ph;
+           mp     = mp + pl;
+         }
+         else
+         {
+           /* ---- apply periodics with lyddane modification ---- */
+           sinop  = sin(nodep);
+           cosop  = cos(nodep);
+           alfdp  = sinip * sinop;
+           betdp  = sinip * cosop;
+           dalf   =  ph * cosop + pinc * cosip * sinop;
+           dbet   = -ph * sinop + pinc * cosip * cosop;
+           alfdp  = alfdp + dalf;
+           betdp  = betdp + dbet;
+           nodep  = fmod(nodep, twopi);
+           //  sgp4fix for afspc written intrinsic functions
+           // nodep used without a trigonometric function ahead
+           if (nodep < 0.0)
+               nodep = nodep + twopi;
+           xls    = mp + argpp + cosip * nodep;
+           dls    = pl + pgh - pinc * nodep * sinip;
+           xls    = xls + dls;
+           xnoh   = nodep;
+           nodep  = atan2(alfdp, betdp);
+           //  sgp4fix for afspc written intrinsic functions
+           // nodep used without a trigonometric function ahead
+           if (nodep < 0.0)
+               nodep = nodep + twopi;
+           if (fabs(xnoh - nodep) > pi){
+             if (nodep < xnoh)
+                nodep = nodep + twopi;
+               else
+                nodep = nodep - twopi;
+           }
+           mp    = mp + pl;
+           argpp = xls - mp - cosip * nodep;
+         }
+       }   // if init == 'n'
+
+//#include "debug1.cpp"
+}  // end dpper
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dscom
+*
+*  this procedure provides deep space common items used by both the secular
+*    and periodics subroutines.  input is provided as shown. this routine
+*    used to be called dpper, but the functions inside weren't well organized.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    epoch       -
+*    ep          - eccentricity
+*    argpp       - argument of perigee
+*    tc          -
+*    inclp       - inclination
+*    nodep       - right ascension of ascending node
+*    np          - mean motion
+*
+*  outputs       :
+*    sinim  , cosim  , sinomm , cosomm , snodm  , cnodm
+*    day         -
+*    e3          -
+*    ee2         -
+*    em          - eccentricity
+*    emsq        - eccentricity squared
+*    gam         -
+*    peo         -
+*    pgho        -
+*    pho         -
+*    pinco       -
+*    plo         -
+*    rtemsq      -
+*    se2, se3         -
+*    sgh2, sgh3, sgh4        -
+*    sh2, sh3, si2, si3, sl2, sl3, sl4         -
+*    s1, s2, s3, s4, s5, s6, s7          -
+*    ss1, ss2, ss3, ss4, ss5, ss6, ss7, sz1, sz2, sz3         -
+*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
+*    xgh2, xgh3, xgh4, xh2, xh3, xi2, xi3, xl2, xl3, xl4         -
+*    nm          - mean motion
+*    z1, z2, z3, z11, z12, z13, z21, z22, z23, z31, z32, z33         -
+*    zmol        -
+*    zmos        -
+*
+*  locals        :
+*    a1, a2, a3, a4, a5, a6, a7, a8, a9, a10         -
+*    betasq      -
+*    cc          -
+*    ctem, stem        -
+*    x1, x2, x3, x4, x5, x6, x7, x8          -
+*    xnodce      -
+*    xnoi        -
+*    zcosg  , zsing  , zcosgl , zsingl , zcosh  , zsinh  , zcoshl , zsinhl ,
+*    zcosi  , zsini  , zcosil , zsinil ,
+*    zx          -
+*    zy          -
+*
+*  coupling      :
+*    none.
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dscom
+     (
+       double epoch,  double ep,     double argpp,   double tc,     double inclp,
+       double nodep,  double np,
+       double& snodm, double& cnodm, double& sinim,  double& cosim, double& sinomm,
+       double& cosomm,double& day,   double& e3,     double& ee2,   double& em,
+       double& emsq,  double& gam,   double& peo,    double& pgho,  double& pho,
+       double& pinco, double& plo,   double& rtemsq, double& se2,   double& se3,
+       double& sgh2,  double& sgh3,  double& sgh4,   double& sh2,   double& sh3,
+       double& si2,   double& si3,   double& sl2,    double& sl3,   double& sl4,
+       double& s1,    double& s2,    double& s3,     double& s4,    double& s5,
+       double& s6,    double& s7,    double& ss1,    double& ss2,   double& ss3,
+       double& ss4,   double& ss5,   double& ss6,    double& ss7,   double& sz1,
+       double& sz2,   double& sz3,   double& sz11,   double& sz12,  double& sz13,
+       double& sz21,  double& sz22,  double& sz23,   double& sz31,  double& sz32,
+       double& sz33,  double& xgh2,  double& xgh3,   double& xgh4,  double& xh2,
+       double& xh3,   double& xi2,   double& xi3,    double& xl2,   double& xl3,
+       double& xl4,   double& nm,    double& z1,     double& z2,    double& z3,
+       double& z11,   double& z12,   double& z13,    double& z21,   double& z22,
+       double& z23,   double& z31,   double& z32,    double& z33,   double& zmol,
+       double& zmos
+     )
+{
+     /* -------------------------- constants ------------------------- */
+     const double zes     =  0.01675;
+     const double zel     =  0.05490;
+     const double c1ss    =  2.9864797e-6;
+     const double c1l     =  4.7968065e-7;
+     const double zsinis  =  0.39785416;
+     const double zcosis  =  0.91744867;
+     const double zcosgs  =  0.1945905;
+     const double zsings  = -0.98088458;
+     const double twopi   =  2.0 * pi;
+
+     /* --------------------- local variables ------------------------ */
+     int lsflg;
+     double a1    , a2    , a3    , a4    , a5    , a6    , a7    ,
+        a8    , a9    , a10   , betasq, cc    , ctem  , stem  ,
+        x1    , x2    , x3    , x4    , x5    , x6    , x7    ,
+        x8    , xnodce, xnoi  , zcosg , zcosgl, zcosh , zcoshl,
+        zcosi , zcosil, zsing , zsingl, zsinh , zsinhl, zsini ,
+        zsinil, zx    , zy;
+
+     nm     = np;
+     em     = ep;
+     snodm  = sin(nodep);
+     cnodm  = cos(nodep);
+     sinomm = sin(argpp);
+     cosomm = cos(argpp);
+     sinim  = sin(inclp);
+     cosim  = cos(inclp);
+     emsq   = em * em;
+     betasq = 1.0 - emsq;
+     rtemsq = sqrt(betasq);
+
+     /* ----------------- initialize lunar solar terms --------------- */
+     peo    = 0.0;
+     pinco  = 0.0;
+     plo    = 0.0;
+     pgho   = 0.0;
+     pho    = 0.0;
+     day    = epoch + 18261.5 + tc / 1440.0;
+     xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
+     stem   = sin(xnodce);
+     ctem   = cos(xnodce);
+     zcosil = 0.91375164 - 0.03568096 * ctem;
+     zsinil = sqrt(1.0 - zcosil * zcosil);
+     zsinhl = 0.089683511 * stem / zsinil;
+     zcoshl = sqrt(1.0 - zsinhl * zsinhl);
+     gam    = 5.8351514 + 0.0019443680 * day;
+     zx     = 0.39785416 * stem / zsinil;
+     zy     = zcoshl * ctem + 0.91744867 * zsinhl * stem;
+     zx     = atan2(zx, zy);
+     zx     = gam + zx - xnodce;
+     zcosgl = cos(zx);
+     zsingl = sin(zx);
+
+     /* ------------------------- do solar terms --------------------- */
+     zcosg = zcosgs;
+     zsing = zsings;
+     zcosi = zcosis;
+     zsini = zsinis;
+     zcosh = cnodm;
+     zsinh = snodm;
+     cc    = c1ss;
+     xnoi  = 1.0 / nm;
+
+     for (lsflg = 1; lsflg <= 2; lsflg++)
+       {
+         a1  =   zcosg * zcosh + zsing * zcosi * zsinh;
+         a3  =  -zsing * zcosh + zcosg * zcosi * zsinh;
+         a7  =  -zcosg * zsinh + zsing * zcosi * zcosh;
+         a8  =   zsing * zsini;
+         a9  =   zsing * zsinh + zcosg * zcosi * zcosh;
+         a10 =   zcosg * zsini;
+         a2  =   cosim * a7 + sinim * a8;
+         a4  =   cosim * a9 + sinim * a10;
+         a5  =  -sinim * a7 + cosim * a8;
+         a6  =  -sinim * a9 + cosim * a10;
+
+         x1  =  a1 * cosomm + a2 * sinomm;
+         x2  =  a3 * cosomm + a4 * sinomm;
+         x3  = -a1 * sinomm + a2 * cosomm;
+         x4  = -a3 * sinomm + a4 * cosomm;
+         x5  =  a5 * sinomm;
+         x6  =  a6 * sinomm;
+         x7  =  a5 * cosomm;
+         x8  =  a6 * cosomm;
+
+         z31 = 12.0 * x1 * x1 - 3.0 * x3 * x3;
+         z32 = 24.0 * x1 * x2 - 6.0 * x3 * x4;
+         z33 = 12.0 * x2 * x2 - 3.0 * x4 * x4;
+         z1  =  3.0 *  (a1 * a1 + a2 * a2) + z31 * emsq;
+         z2  =  6.0 *  (a1 * a3 + a2 * a4) + z32 * emsq;
+         z3  =  3.0 *  (a3 * a3 + a4 * a4) + z33 * emsq;
+         z11 = -6.0 * a1 * a5 + emsq *  (-24.0 * x1 * x7-6.0 * x3 * x5);
+         z12 = -6.0 *  (a1 * a6 + a3 * a5) + emsq *
+                (-24.0 * (x2 * x7 + x1 * x8) - 6.0 * (x3 * x6 + x4 * x5));
+         z13 = -6.0 * a3 * a6 + emsq * (-24.0 * x2 * x8 - 6.0 * x4 * x6);
+         z21 =  6.0 * a2 * a5 + emsq * (24.0 * x1 * x5 - 6.0 * x3 * x7);
+         z22 =  6.0 *  (a4 * a5 + a2 * a6) + emsq *
+                (24.0 * (x2 * x5 + x1 * x6) - 6.0 * (x4 * x7 + x3 * x8));
+         z23 =  6.0 * a4 * a6 + emsq * (24.0 * x2 * x6 - 6.0 * x4 * x8);
+         z1  = z1 + z1 + betasq * z31;
+         z2  = z2 + z2 + betasq * z32;
+         z3  = z3 + z3 + betasq * z33;
+         s3  = cc * xnoi;
+         s2  = -0.5 * s3 / rtemsq;
+         s4  = s3 * rtemsq;
+         s1  = -15.0 * em * s4;
+         s5  = x1 * x3 + x2 * x4;
+         s6  = x2 * x3 + x1 * x4;
+         s7  = x2 * x4 - x1 * x3;
+
+         /* ----------------------- do lunar terms ------------------- */
+         if (lsflg == 1)
+           {
+             ss1   = s1;
+             ss2   = s2;
+             ss3   = s3;
+             ss4   = s4;
+             ss5   = s5;
+             ss6   = s6;
+             ss7   = s7;
+             sz1   = z1;
+             sz2   = z2;
+             sz3   = z3;
+             sz11  = z11;
+             sz12  = z12;
+             sz13  = z13;
+             sz21  = z21;
+             sz22  = z22;
+             sz23  = z23;
+             sz31  = z31;
+             sz32  = z32;
+             sz33  = z33;
+             zcosg = zcosgl;
+             zsing = zsingl;
+             zcosi = zcosil;
+             zsini = zsinil;
+             zcosh = zcoshl * cnodm + zsinhl * snodm;
+             zsinh = snodm * zcoshl - cnodm * zsinhl;
+             cc    = c1l;
+          }
+       }
+
+     zmol = fmod(4.7199672 + 0.22997150  * day - gam, twopi);
+     zmos = fmod(6.2565837 + 0.017201977 * day, twopi);
+
+     /* ------------------------ do solar terms ---------------------- */
+     se2  =   2.0 * ss1 * ss6;
+     se3  =   2.0 * ss1 * ss7;
+     si2  =   2.0 * ss2 * sz12;
+     si3  =   2.0 * ss2 * (sz13 - sz11);
+     sl2  =  -2.0 * ss3 * sz2;
+     sl3  =  -2.0 * ss3 * (sz3 - sz1);
+     sl4  =  -2.0 * ss3 * (-21.0 - 9.0 * emsq) * zes;
+     sgh2 =   2.0 * ss4 * sz32;
+     sgh3 =   2.0 * ss4 * (sz33 - sz31);
+     sgh4 = -18.0 * ss4 * zes;
+     sh2  =  -2.0 * ss2 * sz22;
+     sh3  =  -2.0 * ss2 * (sz23 - sz21);
+
+     /* ------------------------ do lunar terms ---------------------- */
+     ee2  =   2.0 * s1 * s6;
+     e3   =   2.0 * s1 * s7;
+     xi2  =   2.0 * s2 * z12;
+     xi3  =   2.0 * s2 * (z13 - z11);
+     xl2  =  -2.0 * s3 * z2;
+     xl3  =  -2.0 * s3 * (z3 - z1);
+     xl4  =  -2.0 * s3 * (-21.0 - 9.0 * emsq) * zel;
+     xgh2 =   2.0 * s4 * z32;
+     xgh3 =   2.0 * s4 * (z33 - z31);
+     xgh4 = -18.0 * s4 * zel;
+     xh2  =  -2.0 * s2 * z22;
+     xh3  =  -2.0 * s2 * (z23 - z21);
+
+//#include "debug2.cpp"
+}  // end dscom
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dsinit
+*
+*  this procedure provides deep space contributions to mean motion dot due
+*    to geopotential resonance with half day and one day orbits.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    cosim, sinim-
+*    emsq        - eccentricity squared
+*    argpo       - argument of perigee
+*    s1, s2, s3, s4, s5      -
+*    ss1, ss2, ss3, ss4, ss5 -
+*    sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33 -
+*    t           - time
+*    tc          -
+*    gsto        - greenwich sidereal time                   rad
+*    mo          - mean anomaly
+*    mdot        - mean anomaly dot (rate)
+*    no          - mean motion
+*    nodeo       - right ascension of ascending node
+*    nodedot     - right ascension of ascending node dot (rate)
+*    xpidot      -
+*    z1, z3, z11, z13, z21, z23, z31, z33 -
+*    eccm        - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    xn          - mean motion
+*    nodem       - right ascension of ascending node
+*
+*  outputs       :
+*    em          - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    nodem       - right ascension of ascending node
+*    irez        - flag for resonance           0-none, 1-one day, 2-half day
+*    atime       -
+*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433    -
+*    dedt        -
+*    didt        -
+*    dmdt        -
+*    dndt        -
+*    dnodt       -
+*    domdt       -
+*    del1, del2, del3        -
+*    ses  , sghl , sghs , sgs  , shl  , shs  , sis  , sls
+*    theta       -
+*    xfact       -
+*    xlamo       -
+*    xli         -
+*    xni
+*
+*  locals        :
+*    ainv2       -
+*    aonv        -
+*    cosisq      -
+*    eoc         -
+*    f220, f221, f311, f321, f322, f330, f441, f442, f522, f523, f542, f543  -
+*    g200, g201, g211, g300, g310, g322, g410, g422, g520, g521, g532, g533  -
+*    sini2       -
+*    temp        -
+*    temp1       -
+*    theta       -
+*    xno2        -
+*
+*  coupling      :
+*    getgravconst
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dsinit
+     (
+       gravconsttype whichconst,
+       double cosim,  double emsq,   double argpo,   double s1,     double s2,
+       double s3,     double s4,     double s5,      double sinim,  double ss1,
+       double ss2,    double ss3,    double ss4,     double ss5,    double sz1,
+       double sz3,    double sz11,   double sz13,    double sz21,   double sz23,
+       double sz31,   double sz33,   double t,       double tc,     double gsto,
+       double mo,     double mdot,   double no,      double nodeo,  double nodedot,
+       double xpidot, double z1,     double z3,      double z11,    double z13,
+       double z21,    double z23,    double z31,     double z33,    double ecco,
+       double eccsq,  double& em,    double& argpm,  double& inclm, double& mm,
+       double& nm,    double& nodem,
+       int& irez,
+       double& atime, double& d2201, double& d2211,  double& d3210, double& d3222,
+       double& d4410, double& d4422, double& d5220,  double& d5232, double& d5421,
+       double& d5433, double& dedt,  double& didt,   double& dmdt,  double& dndt,
+       double& dnodt, double& domdt, double& del1,   double& del2,  double& del3,
+       double& xfact, double& xlamo, double& xli,    double& xni
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     const double twopi = 2.0 * pi;
+
+     double ainv2 , aonv=0.0, cosisq, eoc, f220 , f221  , f311  ,
+          f321  , f322  , f330  , f441  , f442  , f522  , f523  ,
+          f542  , f543  , g200  , g201  , g211  , g300  , g310  ,
+          g322  , g410  , g422  , g520  , g521  , g532  , g533  ,
+          ses   , sgs   , sghl  , sghs  , shs   , shll  , sis   ,
+          sini2 , sls   , temp  , temp1 , theta , xno2  , q22   ,
+          q31   , q33   , root22, root44, root54, rptim , root32,
+          root52, x2o3  , xke   , znl   , emo   , zns   , emsqo,
+          tumin, mu, radiusearthkm, j2, j3, j4, j3oj2;
+
+     q22    = 1.7891679e-6;
+     q31    = 2.1460748e-6;
+     q33    = 2.2123015e-7;
+     root22 = 1.7891679e-6;
+     root44 = 7.3636953e-9;
+     root54 = 2.1765803e-9;
+     rptim  = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
+     root32 = 3.7393792e-7;
+     root52 = 1.1428639e-7;
+     x2o3   = 2.0 / 3.0;
+     znl    = 1.5835218e-4;
+     zns    = 1.19459e-5;
+
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+
+     /* -------------------- deep space initialization ------------ */
+     irez = 0;
+     if ((nm < 0.0052359877) && (nm > 0.0034906585))
+         irez = 1;
+     if ((nm >= 8.26e-3) && (nm <= 9.24e-3) && (em >= 0.5))
+         irez = 2;
+
+     /* ------------------------ do solar terms ------------------- */
+     ses  =  ss1 * zns * ss5;
+     sis  =  ss2 * zns * (sz11 + sz13);
+     sls  = -zns * ss3 * (sz1 + sz3 - 14.0 - 6.0 * emsq);
+     sghs =  ss4 * zns * (sz31 + sz33 - 6.0);
+     shs  = -zns * ss2 * (sz21 + sz23);
+     // sgp4fix for 180 deg incl
+     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
+       shs = 0.0;
+     if (sinim != 0.0)
+       shs = shs / sinim;
+     sgs  = sghs - cosim * shs;
+
+     /* ------------------------- do lunar terms ------------------ */
+     dedt = ses + s1 * znl * s5;
+     didt = sis + s2 * znl * (z11 + z13);
+     dmdt = sls - znl * s3 * (z1 + z3 - 14.0 - 6.0 * emsq);
+     sghl = s4 * znl * (z31 + z33 - 6.0);
+     shll = -znl * s2 * (z21 + z23);
+     // sgp4fix for 180 deg incl
+     if ((inclm < 5.2359877e-2) || (inclm > pi - 5.2359877e-2))
+         shll = 0.0;
+     domdt = sgs + sghl;
+     dnodt = shs;
+     if (sinim != 0.0)
+       {
+         domdt = domdt - cosim / sinim * shll;
+         dnodt = dnodt + shll / sinim;
+       }
+
+     /* ----------- calculate deep space resonance effects -------- */
+     dndt   = 0.0;
+     theta  = fmod(gsto + tc * rptim, twopi);
+     em     = em + dedt * t;
+     inclm  = inclm + didt * t;
+     argpm  = argpm + domdt * t;
+     nodem  = nodem + dnodt * t;
+     mm     = mm + dmdt * t;
+     //   sgp4fix for negative inclinations
+     //   the following if statement should be commented out
+     //if (inclm < 0.0)
+     //  {
+     //    inclm  = -inclm;
+     //    argpm  = argpm - pi;
+     //    nodem = nodem + pi;
+     //  }
+
+     /* -------------- initialize the resonance terms ------------- */
+     if (irez != 0)
+       {
+         aonv = pow(nm / xke, x2o3);
+
+         /* ---------- geopotential resonance for 12 hour orbits ------ */
+         if (irez == 2)
+           {
+             cosisq = cosim * cosim;
+             emo    = em;
+             em     = ecco;
+             emsqo  = emsq;
+             emsq   = eccsq;
+             eoc    = em * emsq;
+             g201   = -0.306 - (em - 0.64) * 0.440;
+
+             if (em <= 0.65)
+               {
+                 g211 =    3.616  -  13.2470 * em +  16.2900 * emsq;
+                 g310 =  -19.302  + 117.3900 * em - 228.4190 * emsq +  156.5910 * eoc;
+                 g322 =  -18.9068 + 109.7927 * em - 214.6334 * emsq +  146.5816 * eoc;
+                 g410 =  -41.122  + 242.6940 * em - 471.0940 * emsq +  313.9530 * eoc;
+                 g422 = -146.407  + 841.8800 * em - 1629.014 * emsq + 1083.4350 * eoc;
+                 g520 = -532.114  + 3017.977 * em - 5740.032 * emsq + 3708.2760 * eoc;
+               }
+               else
+               {
+                 g211 =   -72.099 +   331.819 * em -   508.738 * emsq +   266.724 * eoc;
+                 g310 =  -346.844 +  1582.851 * em -  2415.925 * emsq +  1246.113 * eoc;
+                 g322 =  -342.585 +  1554.908 * em -  2366.899 * emsq +  1215.972 * eoc;
+                 g410 = -1052.797 +  4758.686 * em -  7193.992 * emsq +  3651.957 * eoc;
+                 g422 = -3581.690 + 16178.110 * em - 24462.770 * emsq + 12422.520 * eoc;
+                 if (em > 0.715)
+                     g520 =-5149.66 + 29936.92 * em - 54087.36 * emsq + 31324.56 * eoc;
+                   else
+                     g520 = 1464.74 -  4664.75 * em +  3763.64 * emsq;
+               }
+             if (em < 0.7)
+               {
+                 g533 = -919.22770 + 4988.6100 * em - 9064.7700 * emsq + 5542.21  * eoc;
+                 g521 = -822.71072 + 4568.6173 * em - 8491.4146 * emsq + 5337.524 * eoc;
+                 g532 = -853.66600 + 4690.2500 * em - 8624.7700 * emsq + 5341.4  * eoc;
+               }
+               else
+               {
+                 g533 =-37995.780 + 161616.52 * em - 229838.20 * emsq + 109377.94 * eoc;
+                 g521 =-51752.104 + 218913.95 * em - 309468.16 * emsq + 146349.42 * eoc;
+                 g532 =-40023.880 + 170470.89 * em - 242699.48 * emsq + 115605.82 * eoc;
+               }
+
+             sini2=  sinim * sinim;
+             f220 =  0.75 * (1.0 + 2.0 * cosim+cosisq);
+             f221 =  1.5 * sini2;
+             f321 =  1.875 * sinim  *  (1.0 - 2.0 * cosim - 3.0 * cosisq);
+             f322 = -1.875 * sinim  *  (1.0 + 2.0 * cosim - 3.0 * cosisq);
+             f441 = 35.0 * sini2 * f220;
+             f442 = 39.3750 * sini2 * sini2;
+             f522 =  9.84375 * sinim * (sini2 * (1.0 - 2.0 * cosim- 5.0 * cosisq) +
+                     0.33333333 * (-2.0 + 4.0 * cosim + 6.0 * cosisq) );
+             f523 = sinim * (4.92187512 * sini2 * (-2.0 - 4.0 * cosim +
+                    10.0 * cosisq) + 6.56250012 * (1.0+2.0 * cosim - 3.0 * cosisq));
+             f542 = 29.53125 * sinim * (2.0 - 8.0 * cosim+cosisq *
+                    (-12.0 + 8.0 * cosim + 10.0 * cosisq));
+             f543 = 29.53125 * sinim * (-2.0 - 8.0 * cosim+cosisq *
+                    (12.0 + 8.0 * cosim - 10.0 * cosisq));
+             xno2  =  nm * nm;
+             ainv2 =  aonv * aonv;
+             temp1 =  3.0 * xno2 * ainv2;
+             temp  =  temp1 * root22;
+             d2201 =  temp * f220 * g201;
+             d2211 =  temp * f221 * g211;
+             temp1 =  temp1 * aonv;
+             temp  =  temp1 * root32;
+             d3210 =  temp * f321 * g310;
+             d3222 =  temp * f322 * g322;
+             temp1 =  temp1 * aonv;
+             temp  =  2.0 * temp1 * root44;
+             d4410 =  temp * f441 * g410;
+             d4422 =  temp * f442 * g422;
+             temp1 =  temp1 * aonv;
+             temp  =  temp1 * root52;
+             d5220 =  temp * f522 * g520;
+             d5232 =  temp * f523 * g532;
+             temp  =  2.0 * temp1 * root54;
+             d5421 =  temp * f542 * g521;
+             d5433 =  temp * f543 * g533;
+             xlamo =  fmod(mo + nodeo + nodeo-theta - theta, twopi);
+             xfact =  mdot + dmdt + 2.0 * (nodedot + dnodt - rptim) - no;
+             em    = emo;
+             emsq  = emsqo;
+           }
+
+         /* ---------------- synchronous resonance terms -------------- */
+         if (irez == 1)
+           {
+             g200  = 1.0 + emsq * (-2.5 + 0.8125 * emsq);
+             g310  = 1.0 + 2.0 * emsq;
+             g300  = 1.0 + emsq * (-6.0 + 6.60937 * emsq);
+             f220  = 0.75 * (1.0 + cosim) * (1.0 + cosim);
+             f311  = 0.9375 * sinim * sinim * (1.0 + 3.0 * cosim) - 0.75 * (1.0 + cosim);
+             f330  = 1.0 + cosim;
+             f330  = 1.875 * f330 * f330 * f330;
+             del1  = 3.0 * nm * nm * aonv * aonv;
+             del2  = 2.0 * del1 * f220 * g200 * q22;
+             del3  = 3.0 * del1 * f330 * g300 * q33 * aonv;
+             del1  = del1 * f311 * g310 * q31 * aonv;
+             xlamo = fmod(mo + nodeo + argpo - theta, twopi);
+             xfact = mdot + xpidot - rptim + dmdt + domdt + dnodt - no;
+           }
+
+         /* ------------ for sgp4, initialize the integrator ---------- */
+         xli   = xlamo;
+         xni   = no;
+         atime = 0.0;
+         nm    = no + dndt;
+       }
+
+//#include "debug3.cpp"
+}  // end dsinit
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure dspace
+*
+*  this procedure provides deep space contributions to mean elements for
+*    perturbing third body.  these effects have been averaged over one
+*    revolution of the sun and moon.  for earth resonance effects, the
+*    effects have been averaged over no revolutions of the satellite.
+*    (mean motion)
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    d2201, d2211, d3210, d3222, d4410, d4422, d5220, d5232, d5421, d5433 -
+*    dedt        -
+*    del1, del2, del3  -
+*    didt        -
+*    dmdt        -
+*    dnodt       -
+*    domdt       -
+*    irez        - flag for resonance           0-none, 1-one day, 2-half day
+*    argpo       - argument of perigee
+*    argpdot     - argument of perigee dot (rate)
+*    t           - time
+*    tc          -
+*    gsto        - gst
+*    xfact       -
+*    xlamo       -
+*    no          - mean motion
+*    atime       -
+*    em          - eccentricity
+*    ft          -
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    xli         -
+*    mm          - mean anomaly
+*    xni         - mean motion
+*    nodem       - right ascension of ascending node
+*
+*  outputs       :
+*    atime       -
+*    em          - eccentricity
+*    argpm       - argument of perigee
+*    inclm       - inclination
+*    xli         -
+*    mm          - mean anomaly
+*    xni         -
+*    nodem       - right ascension of ascending node
+*    dndt        -
+*    nm          - mean motion
+*
+*  locals        :
+*    delt        -
+*    ft          -
+*    theta       -
+*    x2li        -
+*    x2omi       -
+*    xl          -
+*    xldot       -
+*    xnddt       -
+*    xndt        -
+*    xomi        -
+*
+*  coupling      :
+*    none        -
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void dspace
+     (
+       int irez,
+       double d2201,  double d2211,  double d3210,   double d3222,  double d4410,
+       double d4422,  double d5220,  double d5232,   double d5421,  double d5433,
+       double dedt,   double del1,   double del2,    double del3,   double didt,
+       double dmdt,   double dnodt,  double domdt,   double argpo,  double argpdot,
+       double t,      double tc,     double gsto,    double xfact,  double xlamo,
+       double no,
+       double& atime, double& em,    double& argpm,  double& inclm, double& xli,
+       double& mm,    double& xni,   double& nodem,  double& dndt,  double& nm
+     )
+{
+     const double twopi = 2.0 * pi;
+     int iretn , iret;
+     double delt, ft, theta, x2li, x2omi, xl, xldot , xnddt, xndt, xomi, g22, g32,
+          g44, g52, g54, fasx2, fasx4, fasx6, rptim , step2, stepn , stepp;
+
+     ft    = 0.0;
+     fasx2 = 0.13130908;
+     fasx4 = 2.8843198;
+     fasx6 = 0.37448087;
+     g22   = 5.7686396;
+     g32   = 0.95240898;
+     g44   = 1.8014998;
+     g52   = 1.0508330;
+     g54   = 4.4108898;
+     rptim = 4.37526908801129966e-3; // this equates to 7.29211514668855e-5 rad/sec
+     stepp =    720.0;
+     stepn =   -720.0;
+     step2 = 259200.0;
+
+     /* ----------- calculate deep space resonance effects ----------- */
+     dndt   = 0.0;
+     theta  = fmod(gsto + tc * rptim, twopi);
+     em     = em + dedt * t;
+
+     inclm  = inclm + didt * t;
+     argpm  = argpm + domdt * t;
+     nodem  = nodem + dnodt * t;
+     mm     = mm + dmdt * t;
+
+     //   sgp4fix for negative inclinations
+     //   the following if statement should be commented out
+     //  if (inclm < 0.0)
+     // {
+     //    inclm = -inclm;
+     //    argpm = argpm - pi;
+     //    nodem = nodem + pi;
+     //  }
+
+     /* - update resonances : numerical (euler-maclaurin) integration - */
+     /* ------------------------- epoch restart ----------------------  */
+     //   sgp4fix for propagator problems
+     //   the following integration works for negative time steps and periods
+     //   the specific changes are unknown because the original code was so convoluted
+
+     ft    = 0.0;
+     atime = 0.0;
+     if (irez != 0)
+       {
+         if ((atime == 0.0) || ((t >= 0.0) && (atime < 0.0)) ||
+             ((t < 0.0) && (atime >= 0.0)))
+           {
+             if (t >= 0.0)
+                 delt = stepp;
+               else
+                 delt = stepn;
+             atime  = 0.0;
+             xni    = no;
+             xli    = xlamo;
+           }
+         iretn = 381; // added for do loop
+         iret  =   0; // added for loop
+         while (iretn == 381)
+           {
+             if ((fabs(t) < fabs(atime)) || (iret == 351))
+               {
+                 if (t >= 0.0)
+                     delt = stepn;
+                   else
+                     delt = stepp;
+                 iret  = 351;
+                 iretn = 381;
+               }
+               else
+               {
+                 if (t > 0.0)  // error if prev if has atime:=0.0 and t:=0.0 (ge)
+                     delt = stepp;
+                   else
+                     delt = stepn;
+                 if (fabs(t - atime) >= stepp)
+                   {
+                     iret  = 0;
+                     iretn = 381;
+                   }
+                   else
+                   {
+                     ft    = t - atime;
+                     iretn = 0;
+                   }
+               }
+
+             /* ------------------- dot terms calculated ------------- */
+             /* ----------- near - synchronous resonance terms ------- */
+             if (irez != 2)
+               {
+                 xndt  = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
+                         del3 * sin(3.0 * (xli - fasx6));
+                 xldot = xni + xfact;
+                 xnddt = del1 * cos(xli - fasx2) +
+                         2.0 * del2 * cos(2.0 * (xli - fasx4)) +
+                         3.0 * del3 * cos(3.0 * (xli - fasx6));
+                 xnddt = xnddt * xldot;
+               }
+               else
+               {
+                 /* --------- near - half-day resonance terms -------- */
+                 xomi  = argpo + argpdot * atime;
+                 x2omi = xomi + xomi;
+                 x2li  = xli + xli;
+                 xndt  = d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) +
+                       d3210 * sin(xomi + xli - g32)  + d3222 * sin(-xomi + xli - g32)+
+                       d4410 * sin(x2omi + x2li - g44)+ d4422 * sin(x2li - g44) +
+                       d5220 * sin(xomi + xli - g52)  + d5232 * sin(-xomi + xli - g52)+
+                       d5421 * sin(xomi + x2li - g54) + d5433 * sin(-xomi + x2li - g54);
+                 xldot = xni + xfact;
+                 xnddt = d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) +
+                       d3210 * cos(xomi + xli - g32) + d3222 * cos(-xomi + xli - g32) +
+                       d5220 * cos(xomi + xli - g52) + d5232 * cos(-xomi + xli - g52) +
+                       2.0 * (d4410 * cos(x2omi + x2li - g44) +
+                       d4422 * cos(x2li - g44) + d5421 * cos(xomi + x2li - g54) +
+                       d5433 * cos(-xomi + x2li - g54));
+                 xnddt = xnddt * xldot;
+               }
+
+             /* ----------------------- integrator ------------------- */
+             if (iretn == 381)
+               {
+                 xli   = xli + xldot * delt + xndt * step2;
+                 xni   = xni + xndt * delt + xnddt * step2;
+                 atime = atime + delt;
+               }
+           }  // while iretn = 381
+
+         nm = xni + xndt * ft + xnddt * ft * ft * 0.5;
+         xl = xli + xldot * ft + xndt * ft * ft * 0.5;
+         if (irez != 1)
+           {
+             mm   = xl - 2.0 * nodem + 2.0 * theta;
+             dndt = nm - no;
+           }
+           else
+           {
+             mm   = xl - nodem - argpm + theta;
+             dndt = nm - no;
+           }
+         nm = no + dndt;
+       }
+
+//#include "debug4.cpp"
+}  // end dsspace
+
+/*-----------------------------------------------------------------------------
+*
+*                           procedure initl
+*
+*  this procedure initializes the spg4 propagator. all the initialization is
+*    consolidated here instead of having multiple loops inside other routines.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    ecco        - eccentricity                           0.0 - 1.0
+*    epoch       - epoch time in days from jan 0, 1950. 0 hr
+*    inclo       - inclination of satellite
+*    no          - mean motion of satellite
+*    satn        - satellite number
+*
+*  outputs       :
+*    ainv        - 1.0 / a
+*    ao          - semi major axis
+*    con41       -
+*    con42       - 1.0 - 5.0 cos(i)
+*    cosio       - cosine of inclination
+*    cosio2      - cosio squared
+*    eccsq       - eccentricity squared
+*    method      - flag for deep space                    'd', 'n'
+*    omeosq      - 1.0 - ecco * ecco
+*    posq        - semi-parameter squared
+*    rp          - radius of perigee
+*    rteosq      - square root of (1.0 - ecco*ecco)
+*    sinio       - sine of inclination
+*    gsto        - gst at time of observation               rad
+*    no          - mean motion of satellite
+*
+*  locals        :
+*    ak          -
+*    d1          -
+*    del         -
+*    adel        -
+*    po          -
+*
+*  coupling      :
+*    getgravconst
+*    gstime      - find greenwich sidereal time from the julian date
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+static void initl
+     (
+       int satn,      gravconsttype whichconst,
+       double ecco,   double epoch,  double inclo,   double& no,
+       char& method,
+       double& ainv,  double& ao,    double& con41,  double& con42, double& cosio,
+       double& cosio2,double& eccsq, double& omeosq, double& posq,
+       double& rp,    double& rteosq,double& sinio , double& gsto
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     double ak, d1, del, adel, po, x2o3, j2, xke,
+            tumin, mu, radiusearthkm, j3, j4, j3oj2;
+
+     // sgp4fix use old way of finding gst
+     int ids70;
+     double ts70, ds70, tfrac, c1, thgr70, fk5r, c1p2p;
+     const double twopi = 2.0 * pi;
+
+     /* ----------------------- earth constants ---------------------- */
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     x2o3   = 2.0 / 3.0;
+
+     /* ------------- calculate auxillary epoch quantities ---------- */
+     eccsq  = ecco * ecco;
+     omeosq = 1.0 - eccsq;
+     rteosq = sqrt(omeosq);
+     cosio  = cos(inclo);
+     cosio2 = cosio * cosio;
+
+     /* ------------------ un-kozai the mean motion ----------------- */
+     ak    = pow(xke / no, x2o3);
+     d1    = 0.75 * j2 * (3.0 * cosio2 - 1.0) / (rteosq * omeosq);
+     del   = d1 / (ak * ak);
+     adel  = ak * (1.0 - del * del - del *
+             (1.0 / 3.0 + 134.0 * del * del / 81.0));
+     del   = d1/(adel * adel);
+     no    = no / (1.0 + del);
+
+     ao    = pow(xke / no, x2o3);
+     sinio = sin(inclo);
+     po    = ao * omeosq;
+     con42 = 1.0 - 5.0 * cosio2;
+     con41 = -con42-cosio2-cosio2;
+     ainv  = 1.0 / ao;
+     posq  = po * po;
+     rp    = ao * (1.0 - ecco);
+     method = 'n';
+
+     // sgp4fix modern approach to finding sidereal timew
+     // gsto = gstime(epoch + 2433281.5);
+
+     // sgp4fix use old way of finding gst
+     // count integer number of days from 0 jan 1970
+     ts70  = epoch - 7305.0;
+     ids70 = floor(ts70 + 1.0e-8);
+     ds70  = ids70;
+     tfrac = ts70 - ds70;
+     // find greenwich location at epoch
+     c1    = 1.72027916940703639e-2;
+     thgr70= 1.7321343856509374;
+     fk5r  = 5.07551419432269442e-15;
+     c1p2p = c1 + twopi;
+     gsto  = fmod( thgr70 + c1*ds70 + c1p2p*tfrac + ts70*ts70*fk5r, twopi);
+     if ( gsto < 0.0 )
+         gsto = gsto + twopi;
+
+//#include "debug5.cpp"
+}  // end initl
+
+/*-----------------------------------------------------------------------------
+*
+*                             procedure sgp4init
+*
+*  this procedure initializes variables for sgp4.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    satn        - satellite number
+*    bstar       - sgp4 type drag coefficient              kg/m2er
+*    ecco        - eccentricity
+*    epoch       - epoch time in days from jan 0, 1950. 0 hr
+*    argpo       - argument of perigee (output if ds)
+*    inclo       - inclination
+*    mo          - mean anomaly (output if ds)
+*    no          - mean motion
+*    nodeo       - right ascension of ascending node
+*
+*  outputs       :
+*    satrec      - common values for subsequent calls
+*    return code - non-zero on error.
+*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
+*                   2 - mean motion less than 0.0
+*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
+*                   4 - semi-latus rectum < 0.0
+*                   5 - epoch elements are sub-orbital
+*                   6 - satellite has decayed
+*
+*  locals        :
+*    cnodm  , snodm  , cosim  , sinim  , cosomm , sinomm
+*    cc1sq  , cc2    , cc3
+*    coef   , coef1
+*    cosio4      -
+*    day         -
+*    dndt        -
+*    em          - eccentricity
+*    emsq        - eccentricity squared
+*    eeta        -
+*    etasq       -
+*    gam         -
+*    argpm       - argument of perigee
+*    nodem       -
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    perige      - perigee
+*    pinvsq      -
+*    psisq       -
+*    qzms24      -
+*    rtemsq      -
+*    s1, s2, s3, s4, s5, s6, s7          -
+*    sfour       -
+*    ss1, ss2, ss3, ss4, ss5, ss6, ss7         -
+*    sz1, sz2, sz3
+*    sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33        -
+*    tc          -
+*    temp        -
+*    temp1, temp2, temp3       -
+*    tsi         -
+*    xpidot      -
+*    xhdot1      -
+*    z1, z2, z3          -
+*    z11, z12, z13, z21, z22, z23, z31, z32, z33         -
+*
+*  coupling      :
+*    getgravconst-
+*    initl       -
+*    dscom       -
+*    dpper       -
+*    dsinit      -
+*    sgp4        -
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+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
+     )
+{
+     /* --------------------- local variables ------------------------ */
+     double ao, ainv,   con42, cosio, sinio, cosio2, eccsq,
+          omeosq, posq,   rp,     rteosq,
+          cnodm , snodm , cosim , sinim , cosomm, sinomm, cc1sq ,
+          cc2   , cc3   , coef  , coef1 , cosio4, day   , dndt  ,
+          em    , emsq  , eeta  , etasq , gam   , argpm , nodem ,
+          inclm , mm    , nm    , perige, pinvsq, psisq , qzms24,
+          rtemsq, s1    , s2    , s3    , s4    , s5    , s6    ,
+          s7    , sfour , ss1 = 0   , ss2 = 0   , ss3 = 0   , ss4 = 0   , ss5 = 0   ,
+          ss6 = 0   , ss7 = 0   , sz1 = 0   , sz2 = 0   , sz3 = 0   , sz11 = 0  , sz12 = 0  ,
+          sz13 = 0  , sz21 = 0  , sz22 = 0  , sz23 = 0  , sz31 = 0  , sz32 = 0  , sz33 = 0  ,
+          tc    , temp  , temp1 , temp2 , temp3 , tsi   , xpidot,
+          xhdot1, z1    , z2    , z3    , z11   , z12   , z13   ,
+          z21   , z22   , z23   , z31   , z32   , z33,
+          qzms2t, ss, j2, j3oj2, j4, x2o3, r[3], v[3],
+          tumin, mu, radiusearthkm, xke, j3;
+
+     /* ------------------------ initialization --------------------- */
+     // sgp4fix divisor for divide by zero check on inclination
+     const double temp4    =   1.0 + cos(pi-1.0e-9);
+
+     /* ----------- set all near earth variables to zero ------------ */
+     satrec.isimp   = 0;   satrec.method = 'n'; satrec.aycof    = 0.0;
+     satrec.con41   = 0.0; satrec.cc1    = 0.0; satrec.cc4      = 0.0;
+     satrec.cc5     = 0.0; satrec.d2     = 0.0; satrec.d3       = 0.0;
+     satrec.d4      = 0.0; satrec.delmo  = 0.0; satrec.eta      = 0.0;
+     satrec.argpdot = 0.0; satrec.omgcof = 0.0; satrec.sinmao   = 0.0;
+     satrec.t       = 0.0; satrec.t2cof  = 0.0; satrec.t3cof    = 0.0;
+     satrec.t4cof   = 0.0; satrec.t5cof  = 0.0; satrec.x1mth2   = 0.0;
+     satrec.x7thm1  = 0.0; satrec.mdot   = 0.0; satrec.nodedot  = 0.0;
+     satrec.xlcof   = 0.0; satrec.xmcof  = 0.0; satrec.nodecf   = 0.0;
+
+     /* ----------- set all deep space variables to zero ------------ */
+     satrec.irez  = 0;   satrec.d2201 = 0.0; satrec.d2211 = 0.0;
+     satrec.d3210 = 0.0; satrec.d3222 = 0.0; satrec.d4410 = 0.0;
+     satrec.d4422 = 0.0; satrec.d5220 = 0.0; satrec.d5232 = 0.0;
+     satrec.d5421 = 0.0; satrec.d5433 = 0.0; satrec.dedt  = 0.0;
+     satrec.del1  = 0.0; satrec.del2  = 0.0; satrec.del3  = 0.0;
+     satrec.didt  = 0.0; satrec.dmdt  = 0.0; satrec.dnodt = 0.0;
+     satrec.domdt = 0.0; satrec.e3    = 0.0; satrec.ee2   = 0.0;
+     satrec.peo   = 0.0; satrec.pgho  = 0.0; satrec.pho   = 0.0;
+     satrec.pinco = 0.0; satrec.plo   = 0.0; satrec.se2   = 0.0;
+     satrec.se3   = 0.0; satrec.sgh2  = 0.0; satrec.sgh3  = 0.0;
+     satrec.sgh4  = 0.0; satrec.sh2   = 0.0; satrec.sh3   = 0.0;
+     satrec.si2   = 0.0; satrec.si3   = 0.0; satrec.sl2   = 0.0;
+     satrec.sl3   = 0.0; satrec.sl4   = 0.0; satrec.gsto  = 0.0;
+     satrec.xfact = 0.0; satrec.xgh2  = 0.0; satrec.xgh3  = 0.0;
+     satrec.xgh4  = 0.0; satrec.xh2   = 0.0; satrec.xh3   = 0.0;
+     satrec.xi2   = 0.0; satrec.xi3   = 0.0; satrec.xl2   = 0.0;
+     satrec.xl3   = 0.0; satrec.xl4   = 0.0; satrec.xlamo = 0.0;
+     satrec.zmol  = 0.0; satrec.zmos  = 0.0; satrec.atime = 0.0;
+     satrec.xli   = 0.0; satrec.xni   = 0.0;
+
+     // sgp4fix - note the following variables are also passed directly via satrec.
+     // it is possible to streamline the sgp4init call by deleting the "x"
+     // variables, but the user would need to set the satrec.* values first. we
+     // include the additional assignments in case twoline2rv is not used.
+     satrec.bstar   = xbstar;
+     satrec.ecco    = xecco;
+     satrec.argpo   = xargpo;
+     satrec.inclo   = xinclo;
+     satrec.mo	    = xmo;
+     satrec.no	    = xno;
+     satrec.nodeo   = xnodeo;
+
+     /* ------------------------ earth constants ----------------------- */
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     ss     = 78.0 / radiusearthkm + 1.0;
+     qzms2t = pow(((120.0 - 78.0) / radiusearthkm), 4);
+     x2o3   =  2.0 / 3.0;
+
+     satrec.init = 'y';
+     satrec.t	 = 0.0;
+
+     initl
+         (
+           satn, whichconst, satrec.ecco, epoch, satrec.inclo, satrec.no, satrec.method,
+           ainv, ao, satrec.con41, con42, cosio, cosio2, eccsq, omeosq,
+           posq, rp, rteosq, sinio, satrec.gsto
+         );
+     satrec.error = 0;
+
+     if (rp < 1.0)
+       {
+//         printf("# *** satn%d epoch elts sub-orbital ***\n", satn);
+         satrec.error = 5;
+       }
+
+     if ((omeosq >= 0.0 ) || ( satrec.no >= 0.0))
+       {
+         satrec.isimp = 0;
+         if (rp < (220.0 / radiusearthkm + 1.0))
+             satrec.isimp = 1;
+         sfour  = ss;
+         qzms24 = qzms2t;
+         perige = (rp - 1.0) * radiusearthkm;
+
+         /* - for perigees below 156 km, s and qoms2t are altered - */
+         if (perige < 156.0)
+           {
+             sfour = perige - 78.0;
+             if (perige < 98.0)
+                 sfour = 20.0;
+             qzms24 = pow(((120.0 - sfour) / radiusearthkm), 4.0);
+             sfour  = sfour / radiusearthkm + 1.0;
+           }
+         pinvsq = 1.0 / posq;
+
+         tsi  = 1.0 / (ao - sfour);
+         satrec.eta  = ao * satrec.ecco * tsi;
+         etasq = satrec.eta * satrec.eta;
+         eeta  = satrec.ecco * satrec.eta;
+         psisq = fabs(1.0 - etasq);
+         coef  = qzms24 * pow(tsi, 4.0);
+         coef1 = coef / pow(psisq, 3.5);
+         cc2   = coef1 * satrec.no * (ao * (1.0 + 1.5 * etasq + eeta *
+                        (4.0 + etasq)) + 0.375 * j2 * tsi / psisq * satrec.con41 *
+                        (8.0 + 3.0 * etasq * (8.0 + etasq)));
+         satrec.cc1   = satrec.bstar * cc2;
+         cc3   = 0.0;
+         if (satrec.ecco > 1.0e-4)
+             cc3 = -2.0 * coef * tsi * j3oj2 * satrec.no * sinio / satrec.ecco;
+         satrec.x1mth2 = 1.0 - cosio2;
+         satrec.cc4    = 2.0* satrec.no * coef1 * ao * omeosq *
+                           (satrec.eta * (2.0 + 0.5 * etasq) + satrec.ecco *
+                           (0.5 + 2.0 * etasq) - j2 * tsi / (ao * psisq) *
+                           (-3.0 * satrec.con41 * (1.0 - 2.0 * eeta + etasq *
+                           (1.5 - 0.5 * eeta)) + 0.75 * satrec.x1mth2 *
+                           (2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * satrec.argpo)));
+         satrec.cc5 = 2.0 * coef1 * ao * omeosq * (1.0 + 2.75 *
+                        (etasq + eeta) + eeta * etasq);
+         cosio4 = cosio2 * cosio2;
+         temp1  = 1.5 * j2 * pinvsq * satrec.no;
+         temp2  = 0.5 * temp1 * j2 * pinvsq;
+         temp3  = -0.46875 * j4 * pinvsq * pinvsq * satrec.no;
+         satrec.mdot     = satrec.no + 0.5 * temp1 * rteosq * satrec.con41 + 0.0625 *
+                            temp2 * rteosq * (13.0 - 78.0 * cosio2 + 137.0 * cosio4);
+         satrec.argpdot  = -0.5 * temp1 * con42 + 0.0625 * temp2 *
+                             (7.0 - 114.0 * cosio2 + 395.0 * cosio4) +
+                             temp3 * (3.0 - 36.0 * cosio2 + 49.0 * cosio4);
+         xhdot1            = -temp1 * cosio;
+         satrec.nodedot = xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * cosio2) +
+                              2.0 * temp3 * (3.0 - 7.0 * cosio2)) * cosio;
+         xpidot            =  satrec.argpdot+ satrec.nodedot;
+         satrec.omgcof   = satrec.bstar * cc3 * cos(satrec.argpo);
+         satrec.xmcof    = 0.0;
+         if (satrec.ecco > 1.0e-4)
+             satrec.xmcof = -x2o3 * coef * satrec.bstar / eeta;
+         satrec.nodecf = 3.5 * omeosq * xhdot1 * satrec.cc1;
+         satrec.t2cof   = 1.5 * satrec.cc1;
+         // sgp4fix for divide by zero with xinco = 180 deg
+         if (fabs(cosio+1.0) > 1.5e-12)
+             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / (1.0 + cosio);
+           else
+             satrec.xlcof = -0.25 * j3oj2 * sinio * (3.0 + 5.0 * cosio) / temp4;
+         satrec.aycof   = -0.5 * j3oj2 * sinio;
+         satrec.delmo   = pow((1.0 + satrec.eta * cos(satrec.mo)), 3);
+         satrec.sinmao  = sin(satrec.mo);
+         satrec.x7thm1  = 7.0 * cosio2 - 1.0;
+
+         /* --------------- deep space initialization ------------- */
+         if ((2*pi / satrec.no) >= 225.0)
+           {
+             satrec.method = 'd';
+             satrec.isimp  = 1;
+             tc    =  0.0;
+             inclm = satrec.inclo;
+
+             dscom
+                 (
+                   epoch, satrec.ecco, satrec.argpo, tc, satrec.inclo, satrec.nodeo,
+                   satrec.no, snodm, cnodm,  sinim, cosim,sinomm,     cosomm,
+                   day, satrec.e3, satrec.ee2, em,         emsq, gam,
+                   satrec.peo,  satrec.pgho,   satrec.pho, satrec.pinco,
+                   satrec.plo,  rtemsq,        satrec.se2, satrec.se3,
+                   satrec.sgh2, satrec.sgh3,   satrec.sgh4,
+                   satrec.sh2,  satrec.sh3,    satrec.si2, satrec.si3,
+                   satrec.sl2,  satrec.sl3,    satrec.sl4, s1, s2, s3, s4, s5,
+                   s6,   s7,   ss1,  ss2,  ss3,  ss4,  ss5,  ss6,  ss7, sz1, sz2, sz3,
+                   sz11, sz12, sz13, sz21, sz22, sz23, sz31, sz32, sz33,
+                   satrec.xgh2, satrec.xgh3,   satrec.xgh4, satrec.xh2,
+                   satrec.xh3,  satrec.xi2,    satrec.xi3,  satrec.xl2,
+                   satrec.xl3,  satrec.xl4,    nm, z1, z2, z3, z11,
+                   z12, z13, z21, z22, z23, z31, z32, z33,
+                   satrec.zmol, satrec.zmos
+                 );
+             dpper
+                 (
+                   satrec.e3, satrec.ee2, satrec.peo, satrec.pgho,
+                   satrec.pho, satrec.pinco, satrec.plo, satrec.se2,
+                   satrec.se3, satrec.sgh2, satrec.sgh3, satrec.sgh4,
+                   satrec.sh2, satrec.sh3, satrec.si2,  satrec.si3,
+                   satrec.sl2, satrec.sl3, satrec.sl4,  satrec.t,
+                   satrec.xgh2,satrec.xgh3,satrec.xgh4, satrec.xh2,
+                   satrec.xh3, satrec.xi2, satrec.xi3,  satrec.xl2,
+                   satrec.xl3, satrec.xl4, satrec.zmol, satrec.zmos, inclm, satrec.init,
+                   satrec.ecco, satrec.inclo, satrec.nodeo, satrec.argpo, satrec.mo
+                 );
+
+             argpm  = 0.0;
+             nodem  = 0.0;
+             mm     = 0.0;
+
+             dsinit
+                 (
+                   whichconst,
+                   cosim, emsq, satrec.argpo, s1, s2, s3, s4, s5, sinim, ss1, ss2, ss3, ss4,
+                   ss5, sz1, sz3, sz11, sz13, sz21, sz23, sz31, sz33, satrec.t, tc,
+                   satrec.gsto, satrec.mo, satrec.mdot, satrec.no, satrec.nodeo,
+                   satrec.nodedot, xpidot, z1, z3, z11, z13, z21, z23, z31, z33,
+                   satrec.ecco, eccsq, em, argpm, inclm, mm, nm, nodem,
+                   satrec.irez,  satrec.atime,
+                   satrec.d2201, satrec.d2211, satrec.d3210, satrec.d3222 ,
+                   satrec.d4410, satrec.d4422, satrec.d5220, satrec.d5232,
+                   satrec.d5421, satrec.d5433, satrec.dedt,  satrec.didt,
+                   satrec.dmdt,  dndt,         satrec.dnodt, satrec.domdt ,
+                   satrec.del1,  satrec.del2,  satrec.del3,  satrec.xfact,
+                   satrec.xlamo, satrec.xli,   satrec.xni
+                 );
+           }
+
+       /* ----------- set variables if not deep space ----------- */
+       if (satrec.isimp != 1)
+         {
+           cc1sq          = satrec.cc1 * satrec.cc1;
+           satrec.d2    = 4.0 * ao * tsi * cc1sq;
+           temp           = satrec.d2 * tsi * satrec.cc1 / 3.0;
+           satrec.d3    = (17.0 * ao + sfour) * temp;
+           satrec.d4    = 0.5 * temp * ao * tsi * (221.0 * ao + 31.0 * sfour) *
+                            satrec.cc1;
+           satrec.t3cof = satrec.d2 + 2.0 * cc1sq;
+           satrec.t4cof = 0.25 * (3.0 * satrec.d3 + satrec.cc1 *
+                            (12.0 * satrec.d2 + 10.0 * cc1sq));
+           satrec.t5cof = 0.2 * (3.0 * satrec.d4 +
+                            12.0 * satrec.cc1 * satrec.d3 +
+                            6.0 * satrec.d2 * satrec.d2 +
+                            15.0 * cc1sq * (2.0 * satrec.d2 + cc1sq));
+         }
+       } // if omeosq = 0 ...
+
+       /* finally propogate to zero epoch to initialise all others. */
+       if(satrec.error == 0)
+           sgp4(whichconst, satrec, 0.0, r, v);
+
+       satrec.init = 'n';
+
+//#include "debug6.cpp"
+       return satrec.error;
+}  // end sgp4init
+
+/*-----------------------------------------------------------------------------
+*
+*                             procedure sgp4
+*
+*  this procedure is the sgp4 prediction model from space command. this is an
+*    updated and combined version of sgp4 and sdp4, which were originally
+*    published separately in spacetrack report #3. this version follows the
+*    methodology from the aiaa paper (2006) describing the history and
+*    development of the code.
+*
+*  author        : david vallado                  719-573-2600   28 jun 2005
+*
+*  inputs        :
+*    satrec	 - initialised structure from sgp4init() call.
+*    tsince	 - time eince epoch (minutes)
+*
+*  outputs       :
+*    r           - position vector                     km
+*    v           - velocity                            km/sec
+*  return code - non-zero on error.
+*                   1 - mean elements, ecc >= 1.0 or ecc < -0.001 or a < 0.95 er
+*                   2 - mean motion less than 0.0
+*                   3 - pert elements, ecc < 0.0  or  ecc > 1.0
+*                   4 - semi-latus rectum < 0.0
+*                   5 - epoch elements are sub-orbital
+*                   6 - satellite has decayed
+*
+*  locals        :
+*    am          -
+*    axnl, aynl        -
+*    betal       -
+*    cosim   , sinim   , cosomm  , sinomm  , cnod    , snod    , cos2u   ,
+*    sin2u   , coseo1  , sineo1  , cosi    , sini    , cosip   , sinip   ,
+*    cosisq  , cossu   , sinsu   , cosu    , sinu
+*    delm        -
+*    delomg      -
+*    dndt        -
+*    eccm        -
+*    emsq        -
+*    ecose       -
+*    el2         -
+*    eo1         -
+*    eccp        -
+*    esine       -
+*    argpm       -
+*    argpp       -
+*    omgadf      -
+*    pl          -
+*    r           -
+*    rtemsq      -
+*    rdotl       -
+*    rl          -
+*    rvdot       -
+*    rvdotl      -
+*    su          -
+*    t2  , t3   , t4    , tc
+*    tem5, temp , temp1 , temp2  , tempa  , tempe  , templ
+*    u   , ux   , uy    , uz     , vx     , vy     , vz
+*    inclm       - inclination
+*    mm          - mean anomaly
+*    nm          - mean motion
+*    nodem       - right asc of ascending node
+*    xinc        -
+*    xincp       -
+*    xl          -
+*    xlm         -
+*    mp          -
+*    xmdf        -
+*    xmx         -
+*    xmy         -
+*    nodedf      -
+*    xnode       -
+*    nodep       -
+*    np          -
+*
+*  coupling      :
+*    getgravconst-
+*    dpper
+*    dpspace
+*
+*  references    :
+*    hoots, roehrich, norad spacetrack report #3 1980
+*    hoots, norad spacetrack report #6 1986
+*    hoots, schumacher and glover 2004
+*    vallado, crawford, hujsak, kelso  2006
+  ----------------------------------------------------------------------------*/
+
+int sgp4
+     (
+       gravconsttype whichconst, elsetrec& satrec,  double tsince,
+       double r[3],  double v[3]
+     )
+{
+     double am   , axnl  , aynl , betal ,  cosim , cnod  ,
+         cos2u, coseo1, cosi , cosip ,  cosisq, cossu , cosu,
+         delm , delomg, em   , emsq  ,  ecose , el2   , eo1 ,
+         ep   , esine , argpm, argpp ,  argpdf, pl,     mrt = 0.0,
+         mvt  , rdotl , rl   , rvdot ,  rvdotl, sinim ,
+         sin2u, sineo1, sini , sinip ,  sinsu , sinu  ,
+         snod , su    , t2   , t3    ,  t4    , tem5  , temp,
+         temp1, temp2 , tempa, tempe ,  templ , u     , ux  ,
+         uy   , uz    , vx   , vy    ,  vz    , inclm , mm  ,
+         nm   , nodem, xinc , xincp ,  xl    , xlm   , mp  ,
+         xmdf , xmx   , xmy  , nodedf, xnode , nodep, tc  , dndt,
+         twopi, x2o3  , j2   , j3    , tumin, j4 , xke   , j3oj2, radiusearthkm,
+         mu, vkmpersec;
+     int ktr;
+
+     /* ------------------ set mathematical constants --------------- */
+     // sgp4fix divisor for divide by zero check on inclination
+     const double temp4    =   1.0 + cos(pi-1.0e-9);
+     twopi = 2.0 * pi;
+     x2o3  = 2.0 / 3.0;
+     // sgp4fix identify constants and allow alternate values
+     getgravconst( whichconst, tumin, mu, radiusearthkm, xke, j2, j3, j4, j3oj2 );
+     vkmpersec     = radiusearthkm * xke/60.0;
+
+     /* --------------------- clear sgp4 error flag ----------------- */
+     satrec.t     = tsince;
+     satrec.error = 0;
+
+     /* ------- update for secular gravity and atmospheric drag ----- */
+     xmdf    = satrec.mo + satrec.mdot * satrec.t;
+     argpdf  = satrec.argpo + satrec.argpdot * satrec.t;
+     nodedf  = satrec.nodeo + satrec.nodedot * satrec.t;
+     argpm   = argpdf;
+     mm      = xmdf;
+     t2      = satrec.t * satrec.t;
+     nodem   = nodedf + satrec.nodecf * t2;
+     tempa   = 1.0 - satrec.cc1 * satrec.t;
+     tempe   = satrec.bstar * satrec.cc4 * satrec.t;
+     templ   = satrec.t2cof * t2;
+
+     if (satrec.isimp != 1)
+       {
+         delomg = satrec.omgcof * satrec.t;
+         delm   = satrec.xmcof *
+                  (pow((1.0 + satrec.eta * cos(xmdf)), 3) -
+                  satrec.delmo);
+         temp   = delomg + delm;
+         mm     = xmdf + temp;
+         argpm  = argpdf - temp;
+         t3     = t2 * satrec.t;
+         t4     = t3 * satrec.t;
+         tempa  = tempa - satrec.d2 * t2 - satrec.d3 * t3 -
+                          satrec.d4 * t4;
+         tempe  = tempe + satrec.bstar * satrec.cc5 * (sin(mm) -
+                          satrec.sinmao);
+         templ  = templ + satrec.t3cof * t3 + t4 * (satrec.t4cof +
+                          satrec.t * satrec.t5cof);
+       }
+
+     nm    = satrec.no;
+     em    = satrec.ecco;
+     inclm = satrec.inclo;
+     if (satrec.method == 'd')
+       {
+         tc = satrec.t;
+         dspace
+             (
+               satrec.irez,
+               satrec.d2201, satrec.d2211, satrec.d3210,
+               satrec.d3222, satrec.d4410, satrec.d4422,
+               satrec.d5220, satrec.d5232, satrec.d5421,
+               satrec.d5433, satrec.dedt,  satrec.del1,
+               satrec.del2,  satrec.del3,  satrec.didt,
+               satrec.dmdt,  satrec.dnodt, satrec.domdt,
+               satrec.argpo, satrec.argpdot, satrec.t, tc,
+               satrec.gsto, satrec.xfact, satrec.xlamo,
+               satrec.no, satrec.atime,
+               em, argpm, inclm, satrec.xli, mm, satrec.xni,
+               nodem, dndt, nm
+             );
+       } // if method = d
+
+     if (nm <= 0.0)
+       {
+//         printf("# error nm %f\n", nm);
+         satrec.error = 2;
+       }
+     am = pow((xke / nm),x2o3) * tempa * tempa;
+     nm = xke / pow(am, 1.5);
+     em = em - tempe;
+
+     // fix tolerance for error recognition
+     if ((em >= 1.0) || (em < -0.001) || (am < 0.95))
+       {
+//         printf("# error em %f\n", em);
+         satrec.error = 1;
+       }
+     if (em < 0.0)
+         em  = 1.0e-6;
+     mm     = mm + satrec.no * templ;
+     xlm    = mm + argpm + nodem;
+     emsq   = em * em;
+     temp   = 1.0 - emsq;
+
+     nodem  = fmod(nodem, twopi);
+     argpm  = fmod(argpm, twopi);
+     xlm    = fmod(xlm, twopi);
+     mm     = fmod(xlm - argpm - nodem, twopi);
+
+     /* ----------------- compute extra mean quantities ------------- */
+     sinim = sin(inclm);
+     cosim = cos(inclm);
+
+     /* -------------------- add lunar-solar periodics -------------- */
+     ep     = em;
+     xincp  = inclm;
+     argpp  = argpm;
+     nodep  = nodem;
+     mp     = mm;
+     sinip  = sinim;
+     cosip  = cosim;
+     if (satrec.method == 'd')
+       {
+         dpper
+             (
+               satrec.e3,   satrec.ee2,  satrec.peo,
+               satrec.pgho, satrec.pho,  satrec.pinco,
+               satrec.plo,  satrec.se2,  satrec.se3,
+               satrec.sgh2, satrec.sgh3, satrec.sgh4,
+               satrec.sh2,  satrec.sh3,  satrec.si2,
+               satrec.si3,  satrec.sl2,  satrec.sl3,
+               satrec.sl4,  satrec.t,    satrec.xgh2,
+               satrec.xgh3, satrec.xgh4, satrec.xh2,
+               satrec.xh3,  satrec.xi2,  satrec.xi3,
+               satrec.xl2,  satrec.xl3,  satrec.xl4,
+               satrec.zmol, satrec.zmos, satrec.inclo,
+               'n', ep, xincp, nodep, argpp, mp
+             );
+         if (xincp < 0.0)
+           {
+             xincp  = -xincp;
+             nodep = nodep + pi;
+             argpp  = argpp - pi;
+           }
+         if ((ep < 0.0 ) || ( ep > 1.0))
+           {
+ //            printf("# error ep %f\n", ep);
+             satrec.error = 3;
+           }
+       } // if method = d
+
+     /* -------------------- long period periodics ------------------ */
+     if (satrec.method == 'd')
+       {
+         sinip =  sin(xincp);
+         cosip =  cos(xincp);
+         satrec.aycof = -0.5*j3oj2*sinip;
+         // sgp4fix for divide by zero for xincp = 180 deg
+         if (fabs(cosip+1.0) > 1.5e-12)
+             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / (1.0 + cosip);
+           else
+             satrec.xlcof = -0.25 * j3oj2 * sinip * (3.0 + 5.0 * cosip) / temp4;
+       }
+     axnl = ep * cos(argpp);
+     temp = 1.0 / (am * (1.0 - ep * ep));
+     aynl = ep* sin(argpp) + temp * satrec.aycof;
+     xl   = mp + argpp + nodep + temp * satrec.xlcof * axnl;
+
+     /* --------------------- solve kepler's equation --------------- */
+     u    = fmod(xl - nodep, twopi);
+     eo1  = u;
+     tem5 = 9999.9;
+     ktr = 1;
+     //   sgp4fix for kepler iteration
+     //   the following iteration needs better limits on corrections
+     while (( fabs(tem5) >= 1.0e-12) && (ktr <= 10) )
+       {
+         sineo1 = sin(eo1);
+         coseo1 = cos(eo1);
+         tem5   = 1.0 - coseo1 * axnl - sineo1 * aynl;
+         tem5   = (u - aynl * coseo1 + axnl * sineo1 - eo1) / tem5;
+         if(fabs(tem5) >= 0.95)
+             tem5 = tem5 > 0.0 ? 0.95 : -0.95;
+         eo1    = eo1 + tem5;
+         ktr = ktr + 1;
+       }
+
+     /* ------------- short period preliminary quantities ----------- */
+     ecose = axnl*coseo1 + aynl*sineo1;
+     esine = axnl*sineo1 - aynl*coseo1;
+     el2   = axnl*axnl + aynl*aynl;
+     pl    = am*(1.0-el2);
+     if (pl < 0.0)
+       {
+//         printf("# error pl %f\n", pl);
+         satrec.error = 4;
+       }
+       else
+       {
+         rl     = am * (1.0 - ecose);
+         rdotl  = sqrt(am) * esine/rl;
+         rvdotl = sqrt(pl) / rl;
+         betal  = sqrt(1.0 - el2);
+         temp   = esine / (1.0 + betal);
+         sinu   = am / rl * (sineo1 - aynl - axnl * temp);
+         cosu   = am / rl * (coseo1 - axnl + aynl * temp);
+         su     = atan2(sinu, cosu);
+         sin2u  = (cosu + cosu) * sinu;
+         cos2u  = 1.0 - 2.0 * sinu * sinu;
+         temp   = 1.0 / pl;
+         temp1  = 0.5 * j2 * temp;
+         temp2  = temp1 * temp;
+
+         /* -------------- update for short period periodics ------------ */
+         if (satrec.method == 'd')
+           {
+             cosisq                 = cosip * cosip;
+             satrec.con41  = 3.0*cosisq - 1.0;
+             satrec.x1mth2 = 1.0 - cosisq;
+             satrec.x7thm1 = 7.0*cosisq - 1.0;
+           }
+         mrt   = rl * (1.0 - 1.5 * temp2 * betal * satrec.con41) +
+                 0.5 * temp1 * satrec.x1mth2 * cos2u;
+         su    = su - 0.25 * temp2 * satrec.x7thm1 * sin2u;
+         xnode = nodep + 1.5 * temp2 * cosip * sin2u;
+         xinc  = xincp + 1.5 * temp2 * cosip * sinip * cos2u;
+         mvt   = rdotl - nm * temp1 * satrec.x1mth2 * sin2u / xke;
+         rvdot = rvdotl + nm * temp1 * (satrec.x1mth2 * cos2u +
+                 1.5 * satrec.con41) / xke;
+
+         /* --------------------- orientation vectors ------------------- */
+         sinsu =  sin(su);
+         cossu =  cos(su);
+         snod  =  sin(xnode);
+         cnod  =  cos(xnode);
+         sini  =  sin(xinc);
+         cosi  =  cos(xinc);
+         xmx   = -snod * cosi;
+         xmy   =  cnod * cosi;
+         ux    =  xmx * sinsu + cnod * cossu;
+         uy    =  xmy * sinsu + snod * cossu;
+         uz    =  sini * sinsu;
+         vx    =  xmx * cossu - cnod * sinsu;
+         vy    =  xmy * cossu - snod * sinsu;
+         vz    =  sini * cossu;
+
+         /* --------- position and velocity (in km and km/sec) ---------- */
+         r[0] = (mrt * ux)* radiusearthkm;
+         r[1] = (mrt * uy)* radiusearthkm;
+         r[2] = (mrt * uz)* radiusearthkm;
+         v[0] = (mvt * ux + rvdot * vx) * vkmpersec;
+         v[1] = (mvt * uy + rvdot * vy) * vkmpersec;
+         v[2] = (mvt * uz + rvdot * vz) * vkmpersec;
+       }  // if pl > 0
+
+     // sgp4fix for decaying satellites
+     if (mrt < 1.0)
+       {
+//         printf("# decay condition %11.6f \n",mrt);
+         satrec.error = 6;
+       }
+
+
+//#include "debug7.cpp"
+     return satrec.error;
+}  // end sgp4
+
+
+/* -----------------------------------------------------------------------------
+*
+*                           function gstime
+*
+*  this function finds the greenwich sidereal time.
+*
+*  author        : david vallado                  719-573-2600    1 mar 2001
+*
+*  inputs          description                    range / units
+*    jdut1       - julian date in ut1             days from 4713 bc
+*
+*  outputs       :
+*    gstime      - greenwich sidereal time        0 to 2pi rad
+*
+*  locals        :
+*    temp        - temporary variable for doubles   rad
+*    tut1        - julian centuries from the
+*                  jan 1, 2000 12 h epoch (ut1)
+*
+*  coupling      :
+*    none
+*
+*  references    :
+*    vallado       2004, 191, eq 3-45
+* --------------------------------------------------------------------------- */
+
+double  gstime
+        (
+          double jdut1
+        )
+   {
+     const double twopi = 2.0 * pi;
+     const double deg2rad = pi / 180.0;
+     double       temp, tut1;
+
+     tut1 = (jdut1 - 2451545.0) / 36525.0;
+     temp = -6.2e-6* tut1 * tut1 * tut1 + 0.093104 * tut1 * tut1 +
+             (876600.0*3600 + 8640184.812866) * tut1 + 67310.54841;  // sec
+     temp = fmod(temp * deg2rad / 240.0, twopi); //360/86400 = 1/240, to deg, to rad
+
+     // ------------------------ check quadrants ---------------------
+     if (temp < 0.0)
+         temp += twopi;
+
+     return temp;
+   }  // end gstime
+
+/* -----------------------------------------------------------------------------
+*
+*                           function getgravconst
+*
+*  this function gets constants for the propagator. note that mu is identified to
+*    facilitiate comparisons with newer models. the common useage is wgs72.
+*
+*  author        : david vallado                  719-573-2600   21 jul 2006
+*
+*  inputs        :
+*    whichconst  - which set of constants to use  wgs72old, wgs72, wgs84
+*
+*  outputs       :
+*    tumin       - minutes in one time unit
+*    mu          - earth gravitational parameter
+*    radiusearthkm - radius of the earth in km
+*    xke         - reciprocal of tumin
+*    j2, j3, j4  - un-normalized zonal harmonic values
+*    j3oj2       - j3 divided by j2
+*
+*  locals        :
+*
+*  coupling      :
+*    none
+*
+*  references    :
+*    norad spacetrack report #3
+*    vallado, crawford, hujsak, kelso  2006
+  --------------------------------------------------------------------------- */
+
+void getgravconst
+     (
+      gravconsttype whichconst,
+      double& tumin,
+      double& mu,
+      double& radiusearthkm,
+      double& xke,
+      double& j2,
+      double& j3,
+      double& j4,
+      double& j3oj2
+     )
+     {
+
+       switch (whichconst)
+         {
+           // -- wgs-72 low precision str#3 constants --
+           case wgs72old:
+           mu     = 398600.79964;        // in km3 / s2
+           radiusearthkm = 6378.135;     // km
+           xke    = 0.0743669161;
+           tumin  = 1.0 / xke;
+           j2     =   0.001082616;
+           j3     =  -0.00000253881;
+           j4     =  -0.00000165597;
+           j3oj2  =  j3 / j2;
+         break;
+           // ------------ wgs-72 constants ------------
+           case wgs72:
+           mu     = 398600.8;            // in km3 / s2
+           radiusearthkm = 6378.135;     // km
+           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
+           tumin  = 1.0 / xke;
+           j2     =   0.001082616;
+           j3     =  -0.00000253881;
+           j4     =  -0.00000165597;
+           j3oj2  =  j3 / j2;
+         break;
+           case wgs84:
+           // ------------ wgs-84 constants ------------
+           mu     = 398600.5;            // in km3 / s2
+           radiusearthkm = 6378.137;     // km
+           xke    = 60.0 / sqrt(radiusearthkm*radiusearthkm*radiusearthkm/mu);
+           tumin  = 1.0 / xke;
+           j2     =   0.00108262998905;
+           j3     =  -0.00000253215306;
+           j4     =  -0.00000161098761;
+           j3oj2  =  j3 / j2;
+         break;
+         default:
+           fprintf(stderr,"unknown gravity option (%d)\n",whichconst);
+         break;
+         }
+
+     }   // end getgravconst
+
+
+
+
+
diff --git a/contrib/sgp4/sgp4unit.h b/contrib/sgp4/sgp4unit.h
index 48c113d7..f16acbd9 100644
--- a/contrib/sgp4/sgp4unit.h
+++ b/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
+
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 2f43b13e..da84ed27 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,140 +1,140 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../controller/ControllerBase.h"
-#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), hkSwitcher(this) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-}
-
-ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.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;
-}
-
-MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		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);
-	}
-
-}
-
-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);
-}
-
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	hkSwitcher.performOperation();
-	performControlOperation();
-	return RETURN_OK;
-}
-
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	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;
-	}
-}
-
-HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
-}
-
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
-
-ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../controller/ControllerBase.h"
+#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), hkSwitcher(this) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+}
+
+ControllerBase::~ControllerBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t ControllerBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.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;
+}
+
+MessageQueueId_t ControllerBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void ControllerBase::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result;
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		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);
+	}
+
+}
+
+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);
+}
+
+void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void ControllerBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void ControllerBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+}
+
+ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
+	handleQueue();
+	hkSwitcher.performOperation();
+	performControlOperation();
+	return RETURN_OK;
+}
+
+void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
+	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;
+	}
+}
+
+HasHealthIF::HealthState ControllerBase::getHealth() {
+	return healthHelper.getHealth();
+}
+void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
+			executingTask = task_;
+}
+
+void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
+}
+
+ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 5aacd9d8..400c3bb6 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -1,94 +1,94 @@
-#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 "../datapool/HkSwitchHelper.h"
-
-/**
- * @brief  Generic base class for controller classes
- * @details
- * Implements common interfaces for controllers.
- */
-class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
-public:
-	static const Mode_t MODE_NORMAL = 2;
-
-	ControllerBase(object_id_t setObjectId, object_id_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
-
-	virtual ReturnValue_t initialize() override;
-
-	virtual MessageQueueId_t getCommandQueue() const override;
-
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual ReturnValue_t setHealth(HealthState health) override;
-
-	virtual HasHealthIF::HealthState getHealth() override;
-
-	/**
-	 * 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_) override;
-
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-protected:
-
-	/**
-	 * Implemented by child class. Handle command messages which are not
-	 * mode or health messages.
-	 * @param message
-	 * @return
-	 */
-    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;
-
-	const object_id_t parentId;
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	ModeHelper modeHelper;
-
-	HealthHelper healthHelper;
-
-	HkSwitchHelper hkSwitcher;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	void handleQueue();
-
-	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);
-};
-
-#endif /* FSFW_CONTROLLER_CONTROLLERBASE_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 "../datapool/HkSwitchHelper.h"
+
+/**
+ * @brief  Generic base class for controller classes
+ * @details
+ * Implements common interfaces for controllers.
+ */
+class ControllerBase: public HasModesIF,
+		public HasHealthIF,
+		public ExecutableObjectIF,
+		public SystemObject,
+		public HasReturnvaluesIF {
+public:
+	static const Mode_t MODE_NORMAL = 2;
+
+	ControllerBase(object_id_t setObjectId, object_id_t parentId,
+			size_t commandQueueDepth = 3);
+	virtual ~ControllerBase();
+
+	virtual ReturnValue_t initialize() override;
+
+	virtual MessageQueueId_t getCommandQueue() const override;
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual ReturnValue_t setHealth(HealthState health) override;
+
+	virtual HasHealthIF::HealthState getHealth() override;
+
+	/**
+	 * 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_) override;
+
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+
+	/**
+	 * Implemented by child class. Handle command messages which are not
+	 * mode or health messages.
+	 * @param message
+	 * @return
+	 */
+    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;
+
+	const object_id_t parentId;
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	ModeHelper modeHelper;
+
+	HealthHelper healthHelper;
+
+	HkSwitchHelper hkSwitcher;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	void handleQueue();
+
+	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);
+};
+
+#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapool/ControllerSet.cpp
index f83b38d5..4055158b 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapool/ControllerSet.cpp
@@ -1,14 +1,14 @@
-#include "../datapool/ControllerSet.h"
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
+#include "../datapool/ControllerSet.h"
+
+ControllerSet::ControllerSet() {
+
+}
+
+ControllerSet::~ControllerSet() {
+}
+
+void ControllerSet::setInvalid() {
+	read();
+	setToDefault();
+	commit(PoolVariableIF::INVALID);
+}
diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h
index da6a9bf4..43e1cbf2 100644
--- a/datapool/ControllerSet.h
+++ b/datapool/ControllerSet.h
@@ -1,15 +1,15 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /* CONTROLLERSET_H_ */
+#ifndef CONTROLLERSET_H_
+#define CONTROLLERSET_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+
+class ControllerSet :public GlobDataSet {
+public:
+	ControllerSet();
+	virtual ~ControllerSet();
+
+	virtual void setToDefault() = 0;
+	void setInvalid();
+};
+
+#endif /* CONTROLLERSET_H_ */
diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp
index 5a59f94c..1a2a25eb 100644
--- a/datapool/HkSwitchHelper.cpp
+++ b/datapool/HkSwitchHelper.cpp
@@ -1,75 +1,75 @@
-#include "../datapool/HkSwitchHelper.h"
-#include "../ipc/QueueFactory.h"
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
-		commandActionHelper(this), eventProxy(eventProxy) {
-	actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() {
-	// TODO Auto-generated destructor stub
-}
-
-ReturnValue_t HkSwitchHelper::initialize() {
-	ReturnValue_t result = commandActionHelper.initialize();
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-	CommandMessage command;
-	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-		ReturnValue_t result = commandActionHelper.handleReply(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		actionQueue->reply(&command);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
-}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
-		uint32_t size) {
-}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
-}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
-		ReturnValue_t returnCode) {
-	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-//	ActionId_t action = HKService::DISABLE_HK;
-//	if (enable) {
-//		action = HKService::ENABLE_HK;
-//	}
-//
-//	ReturnValue_t result = commandActionHelper.commandAction(
-//			objects::PUS_HK_SERVICE, action, sids);
-//
-//	if (result != HasReturnvaluesIF::RETURN_OK) {
-//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-//	}
-//	return result;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
-	return actionQueue;
-}
+#include "../datapool/HkSwitchHelper.h"
+#include "../ipc/QueueFactory.h"
+
+HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) :
+		commandActionHelper(this), eventProxy(eventProxy) {
+	actionQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+HkSwitchHelper::~HkSwitchHelper() {
+	// TODO Auto-generated destructor stub
+}
+
+ReturnValue_t HkSwitchHelper::initialize() {
+	ReturnValue_t result = commandActionHelper.initialize();
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return result;
+}
+
+ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
+	CommandMessage command;
+	while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
+		ReturnValue_t result = commandActionHelper.handleReply(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			continue;
+		}
+		command.setToUnknownCommand();
+		actionQueue->reply(&command);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {
+}
+
+void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data,
+		uint32_t size) {
+}
+
+void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {
+}
+
+void HkSwitchHelper::completionFailedReceived(ActionId_t actionId,
+		ReturnValue_t returnCode) {
+	eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
+}
+
+ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
+//	ActionId_t action = HKService::DISABLE_HK;
+//	if (enable) {
+//		action = HKService::ENABLE_HK;
+//	}
+//
+//	ReturnValue_t result = commandActionHelper.commandAction(
+//			objects::PUS_HK_SERVICE, action, sids);
+//
+//	if (result != HasReturnvaluesIF::RETURN_OK) {
+//		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
+//	}
+//	return result;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() {
+	return actionQueue;
+}
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index de34ab23..385b2047 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -1,46 +1,46 @@
-#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_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
-//implemented decentrally
-
-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
-
-	HkSwitchHelper(EventReportingProxyIF *eventProxy);
-	virtual ~HkSwitchHelper();
-
-	ReturnValue_t initialize();
-
-	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
-
-	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
-
-	virtual void setTaskIF(PeriodicTaskIF* task_){};
-
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode);
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size);
-	virtual void completionSuccessfulReceived(ActionId_t actionId);
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode);
-	virtual MessageQueueIF* getCommandQueuePtr();
-
-private:
-	CommandActionHelper commandActionHelper;
-	MessageQueueIF* actionQueue;
-	EventReportingProxyIF *eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
+#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
+#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_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
+//implemented decentrally
+
+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
+
+	HkSwitchHelper(EventReportingProxyIF *eventProxy);
+	virtual ~HkSwitchHelper();
+
+	ReturnValue_t initialize();
+
+	virtual ReturnValue_t  performOperation(uint8_t operationCode = 0);
+
+	ReturnValue_t switchHK(SerializeIF *sids, bool enable);
+
+	virtual void setTaskIF(PeriodicTaskIF* task_){};
+
+protected:
+	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
+	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
+			ReturnValue_t returnCode);
+	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
+			uint32_t size);
+	virtual void completionSuccessfulReceived(ActionId_t actionId);
+	virtual void completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode);
+	virtual MessageQueueIF* getCommandQueuePtr();
+
+private:
+	CommandActionHelper commandActionHelper;
+	MessageQueueIF* actionQueue;
+	EventReportingProxyIF *eventProxy;
+};
+
+#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index a21d521f..b0506b82 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,87 +1,87 @@
-#include "../datapool/PoolEntry.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-#include <cstring>
-
-template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
-		bool setValid ) : length(setLength), 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 ) :
-		length(setLength), valid(setValid) {
-	this->address = new T[this->length];
-	if (initValue != nullptr) {
-		std::memcpy(this->address, initValue, this->getByteSize() );
-	} else {
-		std::memset(this->address, 0, this->getByteSize() );
-	}
-}
-
-//As the data pool is global, this dtor is only be called on program exit.
-//Warning! Never copy pool entries!
-template <typename T>
-PoolEntry<T>::~PoolEntry() {
-	delete[] this->address;
-}
-
-template <typename T>
-uint16_t PoolEntry<T>::getByteSize() {
-	return ( sizeof(T) * this->length );
-}
-
-template <typename T>
-uint8_t PoolEntry<T>::getSize() {
-	return this->length;
-}
-
-template <typename T>
-void* PoolEntry<T>::getRawData() {
-	return this->address;
-}
-
-template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
-	this->valid = isValid;
-}
-
-template <typename T>
-bool PoolEntry<T>::getValid() {
-	return valid;
-}
-
-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;
-}
-
-template<typename T>
-Type PoolEntry<T>::getType() {
-	return PodTypeConversion<T>::type;
-}
-
-template class PoolEntry<uint8_t>;
-template class PoolEntry<uint16_t>;
-template class PoolEntry<uint32_t>;
-template class PoolEntry<int8_t>;
-template class PoolEntry<int16_t>;
-template class PoolEntry<int32_t>;
-template class PoolEntry<float>;
-template class PoolEntry<double>;
+#include "../datapool/PoolEntry.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+template <typename T>
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+		bool setValid ) : length(setLength), 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 ) :
+		length(setLength), valid(setValid) {
+	this->address = new T[this->length];
+	if (initValue != nullptr) {
+		std::memcpy(this->address, initValue, this->getByteSize() );
+	} else {
+		std::memset(this->address, 0, this->getByteSize() );
+	}
+}
+
+//As the data pool is global, this dtor is only be called on program exit.
+//Warning! Never copy pool entries!
+template <typename T>
+PoolEntry<T>::~PoolEntry() {
+	delete[] this->address;
+}
+
+template <typename T>
+uint16_t PoolEntry<T>::getByteSize() {
+	return ( sizeof(T) * this->length );
+}
+
+template <typename T>
+uint8_t PoolEntry<T>::getSize() {
+	return this->length;
+}
+
+template <typename T>
+void* PoolEntry<T>::getRawData() {
+	return this->address;
+}
+
+template <typename T>
+void PoolEntry<T>::setValid(bool isValid) {
+	this->valid = isValid;
+}
+
+template <typename T>
+bool PoolEntry<T>::getValid() {
+	return valid;
+}
+
+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;
+}
+
+template<typename T>
+Type PoolEntry<T>::getType() {
+	return PodTypeConversion<T>::type;
+}
+
+template class PoolEntry<uint8_t>;
+template class PoolEntry<uint16_t>;
+template class PoolEntry<uint32_t>;
+template class PoolEntry<int8_t>;
+template class PoolEntry<int16_t>;
+template class PoolEntry<int32_t>;
+template class PoolEntry<float>;
+template class PoolEntry<double>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 67891af8..6a3daacf 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
-
-#include "../datapool/PoolEntryIF.h"
-
-#include <initializer_list>
-#include <type_traits>
-#include <cstddef>
-
-/**
- * @brief	This is a small helper class that defines a single data pool entry.
- * @details
- * The helper is used to store all information together with the data as a
- * single data pool entry. The content's type is defined by the template
- * argument.
- *
- * It is prepared for use with plain old data types, but may be
- * extended to complex types if necessary. It can be initialized with a
- * certain value, size and validity flag.
- *
- * It holds a pointer to the real data and offers methods to access this data
- * and to acquire additional information (such as validity and array/byte size).
- * It is NOT intended to be used outside DataPool implementations as it performs
- * dynamic memory allocation.
- *
- * @ingroup data_pool
- */
-template <typename T>
-class PoolEntry : public PoolEntryIF {
-public:
-	static_assert(not std::is_same<T, bool>::value,
-				"Do not use boolean for the PoolEntry type, use uint8_t "
-				"instead! The ECSS standard defines a boolean as a one bit "
-				"field. Therefore it is preferred to store a boolean as an "
-				"uint8_t");
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init 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.
-	 * @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.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
-			bool setValid = false);
-	/**
-	 * @brief	In the classe's constructor, space is allocated on the heap and
-	 * 			potential init values are copied to that space.
-	 * @param initValue
-	 * A pointer to the single value or array that holds the init value.
-	 * With the default value (nullptr), the entry is initalized with all 0.
-	 * @param setLength
-	 * Defines the array length of this entry.
-	 * @param setValid
-	 * Sets the initialization flag. It is invalid by default.
-	 */
-	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
-
-	//! Explicitely deleted copy ctor, copying is not allowed!
-	PoolEntry(const PoolEntry&) = delete;
-	//! Explicitely deleted copy assignment, copying is not allowed!
-	PoolEntry& operator=(const PoolEntry&) = delete;
-
-	/**
-	 * @brief	The allocated memory for the variable is freed
-	 * 			in the destructor.
-	 * @details
-	 * As the data pool is global, this dtor is only called on program exit.
-	 * PoolEntries shall never be copied, as a copy might delete the variable
-	 * on the heap.
-	 */
-	~PoolEntry();
-
-	/**
-	 * @brief	This is the address pointing to the allocated memory.
-	 */
-	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;
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * @details	A single parameter has size 1.
-	 */
-	uint8_t getSize();
-	/**
-	 * @brief	This operation returns the size in bytes.
-	 * @details	The size is calculated by sizeof(type) * array_size.
-	 */
-	uint16_t getByteSize();
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	void* getRawData();
-	/**
-	 * @brief	This method allows to set the valid information
-	 * 			of the pool entry.
-	 */
-	void setValid( bool isValid );
-	/**
-	 * @brief	This method allows to get the valid information
-	 * 			of the pool entry.
-	 */
-	bool getValid();
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 */
-	void print();
-
-	Type getType();
-};
-
-#endif /* POOLENTRY_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRY_H_
+
+#include "../datapool/PoolEntryIF.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <cstddef>
+
+/**
+ * @brief	This is a small helper class that defines a single data pool entry.
+ * @details
+ * The helper is used to store all information together with the data as a
+ * single data pool entry. The content's type is defined by the template
+ * argument.
+ *
+ * It is prepared for use with plain old data types, but may be
+ * extended to complex types if necessary. It can be initialized with a
+ * certain value, size and validity flag.
+ *
+ * It holds a pointer to the real data and offers methods to access this data
+ * and to acquire additional information (such as validity and array/byte size).
+ * It is NOT intended to be used outside DataPool implementations as it performs
+ * dynamic memory allocation.
+ *
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolEntry : public PoolEntryIF {
+public:
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init 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.
+	 * @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.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+			bool setValid = false);
+	/**
+	 * @brief	In the classe's constructor, space is allocated on the heap and
+	 * 			potential init values are copied to that space.
+	 * @param initValue
+	 * A pointer to the single value or array that holds the init value.
+	 * With the default value (nullptr), the entry is initalized with all 0.
+	 * @param setLength
+	 * Defines the array length of this entry.
+	 * @param setValid
+	 * Sets the initialization flag. It is invalid by default.
+	 */
+	PoolEntry(T* initValue, uint8_t setLength = 1, bool setValid = false);
+
+	//! Explicitely deleted copy ctor, copying is not allowed!
+	PoolEntry(const PoolEntry&) = delete;
+	//! Explicitely deleted copy assignment, copying is not allowed!
+	PoolEntry& operator=(const PoolEntry&) = delete;
+
+	/**
+	 * @brief	The allocated memory for the variable is freed
+	 * 			in the destructor.
+	 * @details
+	 * As the data pool is global, this dtor is only called on program exit.
+	 * PoolEntries shall never be copied, as a copy might delete the variable
+	 * on the heap.
+	 */
+	~PoolEntry();
+
+	/**
+	 * @brief	This is the address pointing to the allocated memory.
+	 */
+	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;
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * @details	A single parameter has size 1.
+	 */
+	uint8_t getSize();
+	/**
+	 * @brief	This operation returns the size in bytes.
+	 * @details	The size is calculated by sizeof(type) * array_size.
+	 */
+	uint16_t getByteSize();
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	void* getRawData();
+	/**
+	 * @brief	This method allows to set the valid information
+	 * 			of the pool entry.
+	 */
+	void setValid( bool isValid );
+	/**
+	 * @brief	This method allows to get the valid information
+	 * 			of the pool entry.
+	 */
+	bool getValid();
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 */
+	void print();
+
+	Type getType();
+};
+
+#endif /* POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index a9fb44ef..462de18b 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-
-#include "../globalfunctions/Type.h"
-#include <cstdint>
-
-/**
- * @brief	This interface defines the access possibilities to a
- * 			single data pool entry.
- * @details
- * The interface provides methods to determine the size and the validity
- * information of a value. It also defines a method to receive a pointer to the
- * raw data content. It is mainly used by DataPool itself, but also as a
- * return pointer.
- *
- * @author	Bastian Baetz
- * @ingroup data_pool
- *
- */
-class PoolEntryIF {
-public:
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is required for C++ interfaces.
-	 */
-	virtual ~PoolEntryIF() {
-	}
-	/**
-	 * @brief	getSize returns the array size of the entry.
-	 * 			A single variable parameter has size 1.
-	 */
-	virtual uint8_t getSize() = 0;
-	/**
-	 * @brief	This operation returns the size in bytes, which is calculated by
-	 * 			sizeof(type) * array_size.
-	 */
-	virtual uint16_t getByteSize() = 0;
-	/**
-	 * @brief	This operation returns a the address pointer casted to void*.
-	 */
-	virtual void* getRawData() = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual void setValid(bool isValid) = 0;
-	/**
-	 * @brief	This method allows to set the valid information of the pool entry.
-	 */
-	virtual bool getValid() = 0;
-	/**
-	 * @brief	This is a debug method that prints all values and the valid
-	 * 			information to the screen. It prints all array entries in a row.
-	 * @details
-	 * Also displays whether the pool entry is valid or invalid.
-	 */
-	virtual void print() = 0;
-	/**
-	 * Returns the type of the entry.
-	 */
-	virtual Type getType() = 0;
-};
-
-#endif /* POOLENTRYIF_H_ */
+#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+
+#include "../globalfunctions/Type.h"
+#include <cstdint>
+
+/**
+ * @brief	This interface defines the access possibilities to a
+ * 			single data pool entry.
+ * @details
+ * The interface provides methods to determine the size and the validity
+ * information of a value. It also defines a method to receive a pointer to the
+ * raw data content. It is mainly used by DataPool itself, but also as a
+ * return pointer.
+ *
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ *
+ */
+class PoolEntryIF {
+public:
+	/**
+	 * @brief	This is an empty virtual destructor,
+	 * 			as it is required for C++ interfaces.
+	 */
+	virtual ~PoolEntryIF() {
+	}
+	/**
+	 * @brief	getSize returns the array size of the entry.
+	 * 			A single variable parameter has size 1.
+	 */
+	virtual uint8_t getSize() = 0;
+	/**
+	 * @brief	This operation returns the size in bytes, which is calculated by
+	 * 			sizeof(type) * array_size.
+	 */
+	virtual uint16_t getByteSize() = 0;
+	/**
+	 * @brief	This operation returns a the address pointer casted to void*.
+	 */
+	virtual void* getRawData() = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual void setValid(bool isValid) = 0;
+	/**
+	 * @brief	This method allows to set the valid information of the pool entry.
+	 */
+	virtual bool getValid() = 0;
+	/**
+	 * @brief	This is a debug method that prints all values and the valid
+	 * 			information to the screen. It prints all array entries in a row.
+	 * @details
+	 * Also displays whether the pool entry is valid or invalid.
+	 */
+	virtual void print() = 0;
+	/**
+	 * Returns the type of the entry.
+	 */
+	virtual Type getType() = 0;
+};
+
+#endif /* POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 272bb502..3696a21d 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -1,188 +1,188 @@
-/**
- * @file PoolRawAccessHelper.cpp
- *
- * @date 22.12.2019
- * @author R. Mueller
- */
-
-#include "../datapool/PoolRawAccessHelper.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../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;
-}
+/**
+ * @file PoolRawAccessHelper.cpp
+ *
+ * @date 22.12.2019
+ * @author R. Mueller
+ */
+
+#include "../datapool/PoolRawAccessHelper.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../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;
+}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index a09f7a2f..db25acdf 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -1,111 +1,111 @@
-/**
- * @file PoolRawAccessHelper.h
- *
- * @date 22.12.2019
- */
-
-#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../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_ */
+/**
+ * @file PoolRawAccessHelper.h
+ *
+ * @date 22.12.2019
+ */
+
+#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../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_ */
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 10c0e074..1c8a7be4 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,28 +1,28 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-template <class T, uint8_t n_var>
-class PoolVarList {
-private:
-	GlobPoolVar<T> variables[n_var];
-public:
-	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].dataPoolId = set_id[count];
-			variables[count].readWriteMode = setReadWriteMode;
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* POOLVARLIST_H_ */
+#ifndef POOLVARLIST_H_
+#define POOLVARLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+template <class T, uint8_t n_var>
+class PoolVarList {
+private:
+	GlobPoolVar<T> variables[n_var];
+public:
+	PoolVarList( const uint32_t set_id[n_var], DataSetIF* dataSet, PoolVariableIF::ReadWriteMode_t setReadWriteMode ) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].dataPoolId = set_id[count];
+			variables[count].readWriteMode = setReadWriteMode;
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	GlobPoolVar<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* POOLVARLIST_H_ */
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 669bcc00..029a336d 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,300 +1,300 @@
-#include "../datapoolglob/DataPoolAdmin.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../ipc/CommandMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../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);
-}
+#include "../datapoolglob/DataPoolAdmin.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../ipc/CommandMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../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);
+}
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index 3d5d4d0c..a08f322d 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,59 +1,59 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-
-#include "../memory/MemoryHelper.h"
-#include "../action/SimpleActionHelper.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* DATAPOOLADMIN_H_ */
+#ifndef DATAPOOLADMIN_H_
+#define DATAPOOLADMIN_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+#include "../memory/MemoryHelper.h"
+#include "../action/SimpleActionHelper.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+
+class DataPoolAdmin: public HasActionsIF,
+		public ExecutableObjectIF,
+		public AcceptsMemoryMessagesIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SystemObject {
+public:
+	static const ActionId_t SET_VALIDITY = 1;
+
+	DataPoolAdmin(object_id_t objectId);
+
+	~DataPoolAdmin();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
+			size_t size, uint8_t** dataPointer);
+	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
+			uint8_t** dataPointer, uint8_t* copyHere);
+
+	ReturnValue_t executeAction(ActionId_t actionId,
+			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
+
+	//not implemented as ParameterHelper is no used
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	ReturnValue_t initialize();
+private:
+	StorageManagerIF *storage;
+	MessageQueueIF* commandQueue;
+	MemoryHelper memoryHelper;
+	SimpleActionHelper actionHelper;
+	void handleCommand();
+	ReturnValue_t handleParameterCommand(CommandMessage *command);
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const DataPoolParameterWrapper* wrapper);
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index 597cc86b..3a57d90d 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -1,179 +1,179 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../parameters/HasParametersIF.h"
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../parameters/HasParametersIF.h"
+
+
+DataPoolParameterWrapper::DataPoolParameterWrapper() :
+		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
+				PoolVariableIF::NO_PARAMETER) {
+
+}
+
+DataPoolParameterWrapper::~DataPoolParameterWrapper() {
+
+}
+
+ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
+		uint16_t parameterId) {
+	poolId = (domainId << 16) + parameterId;
+
+	GlobDataSet mySet;
+	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
+	ReturnValue_t status = mySet.read();
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		//should only fail for invalid pool id
+		return HasParametersIF::INVALID_MATRIX_ID;
+	}
+
+	type = raw.getType();
+	rows = raw.getArraySize();
+	columns = 1;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size,
+			maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	for (uint8_t index = 0; index < rows; index++){
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
+		mySet.read();
+		result = raw.serialize(buffer,size,maxSize,streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//same as ParameterWrapper
+size_t DataPoolParameterWrapper::getSerializedSize() const {
+	size_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+template<typename T>
+ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void* from, uint8_t fromRows) {
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t *) from;
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		GlobDataSet mySet;
+		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
+				PoolVariableIF::VAR_READ_WRITE);
+		mySet.read();
+
+		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
+
+		fromAsStream += sizeof(T);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		mySet.commit();
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
+		uint16_t startWritingAtIndex) {
+	if (poolId == PoolVariableIF::NO_PARAMETER) {
+		return ParameterWrapper::NOT_SET;
+	}
+
+	if (type != from->type) {
+		return ParameterWrapper::DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return ParameterWrapper::TOO_BIG;
+	}
+
+	ReturnValue_t result;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows);
+			break;
+		default:
+			result = ParameterWrapper::UNKNOW_DATATYPE;
+			break;
+		}
+	} else {
+		//not supported
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return result;
+}
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/datapoolglob/DataPoolParameterWrapper.h
index 0c5c65ea..b1e505a7 100644
--- a/datapoolglob/DataPoolParameterWrapper.h
+++ b/datapoolglob/DataPoolParameterWrapper.h
@@ -1,38 +1,38 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include "../globalfunctions/Type.h"
-#include "../parameters/ParameterWrapper.h"
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
+#ifndef DATAPOOLPARAMETERWRAPPER_H_
+#define DATAPOOLPARAMETERWRAPPER_H_
+
+#include "../globalfunctions/Type.h"
+#include "../parameters/ParameterWrapper.h"
+
+class DataPoolParameterWrapper: public SerializeIF {
+public:
+	DataPoolParameterWrapper();
+	virtual ~DataPoolParameterWrapper();
+
+	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	Type type;
+	uint8_t rows;
+	uint8_t columns;
+
+	uint32_t poolId;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows);
+
+};
+
+#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index aa6831f8..afb27b77 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -1,133 +1,133 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../ipc/MutexFactory.h"
+
+GlobalDataPool::GlobalDataPool(
+		void(*initFunction)(GlobPoolMap* pool_map)) {
+	mutex = MutexFactory::instance()->createMutex();
+	if (initFunction != NULL ) {
+		initFunction( &this->globDataPool );
+	}
+}
+
+GlobalDataPool::~GlobalDataPool() {
+	MutexFactory::instance()->deleteMutex(mutex);
+	for(GlobPoolMapIter it = this->globDataPool.begin();
+	    it != this->globDataPool.end(); ++it )
+	{
+		delete it->second;
+	}
+}
+
+// The function checks PID, type and array length before returning a copy of
+// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
+template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
+		uint8_t sizeOrPosition ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
+		if (entry != nullptr ) {
+			if ( sizeOrPosition <= entry->length ) {
+				return entry;
+			}
+		}
+	}
+	return nullptr;
+}
+
+PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
+	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
+	if ( it != this->globDataPool.end() ) {
+		return it->second;
+	} else {
+		return nullptr;
+	}
+}
+
+ReturnValue_t GlobalDataPool::unlockDataPool() {
+	ReturnValue_t status = mutex->unlockMutex();
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: unlock of mutex failed with"
+				" error code: " << status << std::endl;
+	}
+	return status;
+}
+
+ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
+	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
+	        timeoutMs);
+	if(status != RETURN_OK) {
+		sif::error << "DataPool::DataPool: lock of mutex failed "
+				"with error code: " << status << std::endl;
+	}
+	return status;
+}
+
+void GlobalDataPool::print() {
+	sif::debug << "DataPool contains: " << std::endl;
+	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
+	dataPoolIt = this->globDataPool.begin();
+	while( dataPoolIt != this->globDataPool.end() ) {
+		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
+		dataPoolIt->second->print();
+		dataPoolIt++;
+	}
+}
+
+uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
+	return (parameter_id >> 8) & 0x00FFFFFF;
+}
+
+uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
+	return (parameter_id & 0x000000FF);
+}
+
+uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
+	return (poolId << 8) + index;
+}
+
+
+//SHOULDDO: Do we need a mutex lock here... I don't think so,
+//as we only check static const values of elements in a list that do not change.
+//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
+ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
+	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
+	if ( it != this->globDataPool.end() ) {
+		*type = it->second->getType();
+		return RETURN_OK;
+	} else {
+		*type = Type::UNKNOWN_TYPE;
+		return RETURN_FAILED;
+	}
+}
+
+bool GlobalDataPool::exists(uint32_t parameterId) {
+	uint32_t poolId = PIDToDataPoolId(parameterId);
+	uint32_t index = PIDToArrayIndex(parameterId);
+	GlobPoolMapIter it = this->globDataPool.find( poolId );
+	if (it != globDataPool.end()) {
+		if (it->second->getSize() >= index) {
+			return true;
+		}
+	}
+	return false;
+}
+
+template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
+		uint32_t data_pool_id, uint8_t size);
+template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<float>* GlobalDataPool::getData<float>(
+		uint32_t data_pool_id, uint8_t size );
+template PoolEntry<double>* GlobalDataPool::getData<double>(
+		uint32_t data_pool_id, uint8_t size);
diff --git a/datapoolglob/GlobalDataPool.h b/datapoolglob/GlobalDataPool.h
index 37a4057b..ce5b132c 100644
--- a/datapoolglob/GlobalDataPool.h
+++ b/datapoolglob/GlobalDataPool.h
@@ -1,149 +1,149 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include "../datapool/PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
+#ifndef GLOBALDATAPOOL_H_
+#define GLOBALDATAPOOL_H_
+
+#include "../datapool/PoolEntry.h"
+#include "../globalfunctions/Type.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+/**
+ * @defgroup data_pool Global data pool
+ * This is the group, where all classes associated with global
+ * data pool handling belong to.
+ * This includes classes to access Data Pool variables.
+ */
+
+/**
+ * Typedefs for the global pool representations
+ */
+using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
+using GlobPoolMapIter = GlobPoolMap::iterator;
+
+/**
+ * @brief		This class represents the OBSW global data-pool.
+ *
+ * @details
+ * All variables are registered and space is allocated in an initialization
+ * function, which is passed do the constructor. Space for the variables is
+ * allocated on the heap (with a new call).
+ *
+ * The data is found by a data pool id, which uniquely represents a variable.
+ * Data pool variables should be used with a blackboard logic in mind,
+ * which means read data is valid (if flagged so),
+ * but not necessarily up-to-date.
+ *
+ * Variables are either single values or arrays.
+ * @author	Bastian Baetz
+ * @ingroup data_pool
+ */
+class GlobalDataPool : public HasReturnvaluesIF {
+private:
+	/**
+	 * @brief	This is the actual data pool itself.
+	 * @details	It is represented by a map with the data pool id as index
+	 * 			and a pointer to a single PoolEntry as value.
+	 */
+	GlobPoolMap globDataPool;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking the pool is only done by the DataSet class.
+	 */
+	MutexIF*	mutex;
+public:
+	/**
+	 * @brief	In the classes constructor,
+	 * 			the passed initialization function is called.
+	 * @details
+	 * To enable filling the pool, a pointer to the map is passed,
+	 * allowing direct access to the pool's content.
+	 * On runtime, adding or removing variables is forbidden.
+	 */
+	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
+
+	/**
+	 * 	@brief	The destructor iterates through the data_pool map and
+	 * 			calls all entries destructors to clean up the heap.
+	 */
+	~GlobalDataPool();
+
+	/**
+	 * @brief	This is the default call to access the pool.
+	 * @details
+	 * A pointer to the PoolEntry object is returned.
+	 * The call checks data pool id, type and array size.
+	 * Returns NULL in case of failure.
+	 * @param data_pool_id	The data pool id to search.
+	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
+	 * or the position the user wants to read.
+	 * 			If smaller than the entry size, everything's ok.
+	 */
+	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
+			uint8_t sizeOrPosition );
+
+	/**
+	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
+	 * 			(i.e. in Housekeeping Telemetry).
+	 * @details	It returns a basic interface and does NOT perform
+	 * 			a size check. The caller has to assure he does not copy too much data.
+	 * 			Returns NULL in case the entry is not found.
+	 * @param data_pool_id	The data pool id to search.
+	 */
+	PoolEntryIF* getRawData( uint32_t data_pool_id );
+	/**
+	 * @brief	This is a small helper function to facilitate locking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
+	 */
+	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
+	/**
+	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
+	 * @details	It fetches the pool's mutex id and tries to free the mutex.
+	 */
+	ReturnValue_t unlockDataPool();
+	/**
+	 * @brief	The print call is a simple debug method.
+	 * @details	It prints the current content of the data pool.
+	 *  		It iterates through the data_pool map and calls each entry's print() method.
+	 */
+	void print();
+	/**
+	 * Extracts the data pool id from a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The data pool id as used within the OBSW.
+	 */
+	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
+	/**
+	 * Extracts an array index out of a SCOS 2000 PID.
+	 * @param parameter_id The passed Parameter ID.
+	 * @return The index of the corresponding data pool entry.
+	 */
+	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
+	/**
+	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
+	 */
+	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
+
+	/**
+	 * Method to return the type of a pool variable.
+	 * @param parameter_id A parameterID (not pool id) of a DP member.
+	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
+	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
+	 */
+	ReturnValue_t getType( uint32_t parameter_id, Type* type );
+
+	/**
+	 * Method to check if a PID exists. Does not lock, as there's no
+	 * possibility to alter the list that is checked during run-time.
+	 * @param parameterId The PID (not pool id!) of a parameter.
+	 * @return	true if exists, false else.
+	 */
+	bool exists(uint32_t parameterId);
+};
+
+//We assume someone globally instantiates a DataPool.
+namespace glob {
+extern GlobalDataPool dataPool;
+}
+
+#endif /* DATAPOOL_H_ */
diff --git a/datapoolglob/GlobalPoolVariable.h b/datapoolglob/GlobalPoolVariable.h
index f5fc49f8..a995bfaf 100644
--- a/datapoolglob/GlobalPoolVariable.h
+++ b/datapoolglob/GlobalPoolVariable.h
@@ -1,213 +1,213 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include "../datapoolglob/GlobalPoolVariable.tpp"
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
+#ifndef GLOBALPOOLVARIABLE_H_
+#define GLOBALPOOLVARIABLE_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename T, uint8_t n_var> class PoolVarList;
+
+
+/**
+ * @brief	This is the access class for non-array data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly
+ * on the data pool entries, but on local copies. This class provides simple
+ * type-safe access to single data pool entries (i.e. entries with length = 1).
+ * The class can be instantiated as read-write and read only.
+ * It provides a commit-and-roll-back semantic, which means that the
+ * variable's value in the data pool is not changed until the
+ * commit call is executed.
+ * 	@tparam	T The template parameter sets the type of the variable.
+ * 	Currently, all plain data types are supported, but in principle
+ * 	any type is possible.
+ *	@ingroup data_pool
+ */
+template<typename T>
+class GlobPoolVar: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PoolVarList;
+	static_assert(not std::is_same<T, bool>::value,
+			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
+			"There is no boolean type in CCSDS.");
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if nullptr is not passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but
+	 * sets the value attribute to default (0).
+	 * The value is fetched within the read() operation.
+	 * @param set_id	This is the id in the global data pool
+	 * 					this instance of the access class corresponds to.
+	 * @param dataSet	The data set in which the variable shall register
+	 * 					itself. If NULL, the variable is not registered.
+	 * @param setWritable If this flag is set to true, changes in the value
+	 * 			attribute can be written back to the data pool, otherwise not.
+	 */
+	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a simple local variable.
+	 */
+	T value = 0;
+
+	/**
+	 * @brief 	Copy ctor to copy classes containing Pool Variables.
+	 * 			(Robin): This only copies member variables, which is done
+	 * 			by the default copy ctor. maybe we can ommit this ctor?
+	 */
+	GlobPoolVar(const GlobPoolVar& rhs);
+
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVar() {}
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * The commit call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool is stored.
+	 */
+	uint32_t dataPoolId;
+
+	/**
+	 * @brief	The valid information as it was stored in the data pool is
+	 * 			copied to this attribute.
+	 */
+	uint8_t valid;
+
+	/**
+	 * @brief	The information whether the class is read-write or read-only
+	 * 			is stored here.
+	 */
+	pool_rwm_t readWriteMode;
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	GlobPoolVar();
+public:
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const override;
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const override;
+	/**
+	 * This operation sets the data pool id of the variable.
+	 * The method is necessary to set id's of data pool member variables with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+
+	uint8_t getValid();
+
+	void setValid(bool valid) override;
+
+	operator T() {
+		return value;
+	}
+
+	operator T() const {
+		return value;
+	}
+
+	GlobPoolVar<T> &operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
+		value = newPoolVariable.value;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size,
+			SerializeIF::Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, max_size,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+		        streamEndianness);
+	}
+};
+
+#include "../datapoolglob/GlobalPoolVariable.tpp"
+
+typedef GlobPoolVar<uint8_t> gp_bool_t;
+typedef GlobPoolVar<uint8_t> gp_uint8_t;
+typedef GlobPoolVar<uint16_t> gp_uint16_t;
+typedef GlobPoolVar<uint32_t> gp_uint32_t;
+typedef GlobPoolVar<int8_t> gp_int8_t;
+typedef GlobPoolVar<int16_t> gp_int16_t;
+typedef GlobPoolVar<int32_t> gp_int32_t;
+typedef GlobPoolVar<float> gp_float_t;
+typedef GlobPoolVar<double> gp_double_t;
+
+#endif /* POOLVARIABLE_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index eb40d1f1..6b592fc6 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,185 +1,185 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include "../datapoolglob/GlobalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* POOLVECTOR_H_ */
+#ifndef GLOBALPOOLVECTOR_H_
+#define GLOBALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ *
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class GlobPoolVector: public PoolVariableIF {
+public:
+	/**
+	 * @brief	In the constructor, the variable can register itself in a
+	 * 			DataSet (if no nullptr is passed).
+	 * @details
+	 * It DOES NOT fetch the current value from the data pool, but sets the
+	 * value attribute to default (0). The value is fetched within the
+	 * read() operation.
+	 * @param set_id
+	 * This is the id in the global data pool this instance of the access
+	 * class corresponds to.
+	 * @param dataSet
+	 * The data set in which the variable shall register itself. If nullptr,
+	 * the variable is not registered.
+	 * @param setWritable
+	 * If this flag is set to true, changes in the value attribute can be
+	 * written back to the data pool, otherwise not.
+	 */
+	GlobPoolVector(uint32_t set_id, DataSetIF* set,
+			ReadWriteMode_t setReadWriteMode);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details	The user can work on this attribute
+	 * 			just like he would on a local array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~GlobPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return dataPoolId;
+	}
+	/**
+	 * @brief This operation sets the data pool id of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId) {
+		dataPoolId = poolId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return readWriteMode;
+	}
+
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid != INVALID)
+			return true;
+		else
+			return false;
+	}
+	void setValid(bool valid) {this->valid = valid;}
+	uint8_t getValid() {return valid;}
+
+	T &operator [](int i) {return value[i];}
+	const T &operator [](int i) const {return value[i];}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t max_size, Endianness streamEndianness) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies all array values
+	 * and the valid information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The commit call is protected by a lock of the global data pool.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#include "../datapoolglob/GlobalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using gp_vec_t = GlobPoolVector<T, vectorSize>;
+
+#endif /* POOLVECTOR_H_ */
diff --git a/datapoolglob/PIDReader.h b/datapoolglob/PIDReader.h
index 7d12a0fd..9431e1d4 100644
--- a/datapoolglob/PIDReader.h
+++ b/datapoolglob/PIDReader.h
@@ -1,164 +1,164 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
+#ifndef PIDREADER_H_
+#define PIDREADER_H_
+#include "../datapool/DataSetIF.h"
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+template<typename U, uint8_t n_var> class PIDReaderList;
+
+template<typename T>
+class PIDReader: public PoolVariableIF {
+	template<typename U, uint8_t n_var> friend class PIDReaderList;
+protected:
+	uint32_t parameterId;
+	uint8_t valid;
+	ReturnValue_t readWithoutLock() {
+		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
+		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
+				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
+		if (read_out != NULL) {
+			valid = read_out->valid;
+			value = read_out->address[arrayIndex];
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			value = 0;
+			valid = false;
+			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
+					<< std::dec << " failed." << std::endl;
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	/**
+	 * Never commit, is read-only.
+	 * Reason is the possibility to access a single DP vector element, but if we commit,
+	 * we set validity of the whole vector.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t commitWithoutLock() override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	/**
+	 * Empty ctor for List initialization
+	 */
+	PIDReader() :
+			parameterId(PoolVariableIF::NO_PARAMETER), valid(
+					PoolVariableIF::INVALID), value(0) {
+
+	}
+public:
+	/**
+	 * \brief	This is the local copy of the data pool entry.
+	 */
+	T value;
+	/**
+	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
+	 * 			passed).
+	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
+	 * 			attribute to default (0). The value is fetched within the read() operation.
+	 * \param set_id	This is the id in the global data pool this instance of the access class
+	 * 					corresponds to.
+	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
+	 * 					the variable is not registered.
+	 * \param setWritable If this flag is set to true, changes in the value attribute can be
+	 * 					written back to the data pool, otherwise not.
+	 */
+	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
+			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
+					0) {
+		if (dataSet != NULL) {
+			dataSet->registerVariable(this);
+		}
+	}
+
+	ReturnValue_t read(uint32_t lockTimeout) override {
+		ReturnValue_t result = glob::dataPool.lockDataPool();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = readWithoutLock();
+		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "PIDReader::read: Could not unlock data pool!"
+					<< std::endl;
+		}
+		return result;
+	}
+	/**
+	 * Copy ctor to copy classes containing Pool Variables.
+	 */
+	PIDReader(const PIDReader &rhs) :
+			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
+	}
+
+	/**
+	 * \brief	The classes destructor is empty.
+	 */
+	~PIDReader() {
+
+	}
+	/**
+	 * \brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const {
+		return GlobalDataPool::PIDToDataPoolId(parameterId);
+	}
+	uint32_t getParameterId() const {
+		return parameterId;
+	}
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const {
+		return VAR_READ;
+	}
+	/**
+	 * \brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const {
+		if (valid)
+			return true;
+		else
+			return false;
+	}
+
+	uint8_t getValid() {
+		return valid;
+	}
+
+	void setValid(bool valid) {
+		this->valid = valid;
+	}
+
+	operator T() {
+		return value;
+	}
+
+	PIDReader<T>& operator=(T newValue) {
+		value = newValue;
+		return *this;
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	virtual size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&value);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&value, buffer, size,
+				streamEndianness);
+	}
+};
+
+#endif /* PIDREADER_H_ */
diff --git a/datapoolglob/PIDReaderList.h b/datapoolglob/PIDReaderList.h
index b167feaa..ae99f3aa 100644
--- a/datapoolglob/PIDReaderList.h
+++ b/datapoolglob/PIDReaderList.h
@@ -1,27 +1,27 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/PIDReader.h"
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
+#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
+
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoolglob/PIDReader.h"
+template <class T, uint8_t n_var>
+class PIDReaderList {
+private:
+	PIDReader<T> variables[n_var];
+public:
+	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
+		//I really should have a look at the new init list c++ syntax.
+		if (dataSet == NULL) {
+			return;
+		}
+		for (uint8_t count = 0; count < n_var; count++) {
+			variables[count].parameterId = setPid[count];
+			dataSet->registerVariable(&variables[count]);
+		}
+	}
+
+	PIDReader<T> &operator [](int i) { return variables[i]; }
+};
+
+
+
+#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/datapoolglob/PoolRawAccess.cpp b/datapoolglob/PoolRawAccess.cpp
index 09093cd6..53706c6d 100644
--- a/datapoolglob/PoolRawAccess.cpp
+++ b/datapoolglob/PoolRawAccess.cpp
@@ -1,239 +1,239 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
+#include "../datapoolglob/GlobalDataPool.h"
+#include "../datapoolglob/PoolRawAccess.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/EndianConverter.h"
+
+#include <cstring>
+
+PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
+		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
+		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
+		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
+		readWriteMode(setReadWriteMode) {
+	memset(value, 0, sizeof(value));
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
+}
+
+PoolRawAccess::~PoolRawAccess() {}
+
+ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = readWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::readWithoutLock() {
+	ReturnValue_t result = RETURN_FAILED;
+	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
+	if (readOut != nullptr) {
+		result = handleReadOut(readOut);
+		if(result == RETURN_OK) {
+			return result;
+		}
+	} else {
+		result = READ_ENTRY_NON_EXISTENT;
+	}
+	handleReadError(result);
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
+	ReturnValue_t result = RETURN_FAILED;
+	valid = readOut->getValid();
+	if (readOut->getSize() > arrayEntry) {
+		arraySize = readOut->getSize();
+		typeSize = readOut->getByteSize() / readOut->getSize();
+		type = readOut->getType();
+		if (typeSize <= sizeof(value)) {
+			uint16_t arrayPosition = arrayEntry * typeSize;
+			sizeTillEnd = readOut->getByteSize() - arrayPosition;
+			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
+			memcpy(value, ptr, typeSize);
+			return RETURN_OK;
+		} else {
+			result = READ_TYPE_TOO_LARGE;
+		}
+	} else {
+		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
+		result = READ_INDEX_TOO_LARGE;
+	}
+	return result;
+}
+
+void PoolRawAccess::handleReadError(ReturnValue_t result) {
+	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
+			<< std::dec << " failed, ";
+	if(result == READ_TYPE_TOO_LARGE) {
+		sif::error << "type too large." << std::endl;
+	}
+	else if(result == READ_INDEX_TOO_LARGE) {
+		sif::error << "index too large." << std::endl;
+	}
+	else if(result == READ_ENTRY_NON_EXISTENT) {
+		sif::error << "entry does not exist." << std::endl;
+	}
+
+	valid = INVALID;
+	typeSize = 0;
+	sizeTillEnd = 0;
+	memset(value, 0, sizeof(value));
+}
+
+ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
+	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = commitWithoutLock();
+	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
+	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
+				<< std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t PoolRawAccess::commitWithoutLock() {
+	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
+	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
+		write_back->setValid(valid);
+		uint8_t array_position = arrayEntry * typeSize;
+		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
+		memcpy(ptr, value, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t* PoolRawAccess::getEntry() {
+	return value;
+}
+
+ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
+		size_t* writtenBytes, size_t max_size) {
+	uint8_t* data_ptr = getEntry();
+	// debug << "PoolRawAccess::getEntry: Array position: " <<
+	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
+	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
+	if (typeSize == 0)
+		return DATA_POOL_ACCESS_FAILED;
+	if (typeSize > max_size)
+		return INCORRECT_SIZE;
+	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
+	*writtenBytes = typeSize;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
+        size_t maxSize, Endianness streamEndianness) const {
+    if (typeSize + *size <= maxSize) {
+    	switch(streamEndianness) {
+    	case(Endianness::BIG):
+    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
+    		break;
+    	case(Endianness::MACHINE):
+    	default:
+            memcpy(*buffer, value, typeSize);
+            break;
+        }
+        *size += typeSize;
+        (*buffer) += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+}
+
+
+Type PoolRawAccess::getType() {
+	return type;
+}
+
+size_t PoolRawAccess::getSizeOfType() {
+	return typeSize;
+}
+
+size_t PoolRawAccess::getArraySize(){
+	return arraySize;
+}
+
+uint32_t PoolRawAccess::getDataPoolId() const {
+	return dataPoolId;
+}
+
+PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
+	return readWriteMode;
+}
+
+ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
+		size_t setSize) {
+	if (typeSize == setSize) {
+		EndianConverter::convertBigEndian(value, buffer, typeSize);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
+				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
+				<< std::endl;
+		return INCORRECT_SIZE;
+	}
+}
+
+bool PoolRawAccess::isValid() const {
+	if (valid != INVALID)
+		return true;
+	else
+		return false;
+}
+
+void PoolRawAccess::setValid(bool valid) {
+	this->valid = valid;
+}
+
+size_t PoolRawAccess::getSizeTillEnd() const {
+	return sizeTillEnd;
+}
+
+
+size_t PoolRawAccess::getSerializedSize() const {
+	return typeSize;
+}
+
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
+        Endianness streamEndianness) {
+
+    if (*size >= typeSize) {
+        switch(streamEndianness) {
+        case(Endianness::BIG):
+			EndianConverter::convertBigEndian(value, *buffer, typeSize);
+		    break;
+        case(Endianness::LITTLE):
+			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
+		   	break;
+        case(Endianness::MACHINE):
+        default:
+            memcpy(value, *buffer, typeSize);
+            break;
+        }
+    	*size -= typeSize;
+        *buffer += typeSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    else {
+    	return SerializeIF::STREAM_TOO_SHORT;
+    }
+}
diff --git a/datapoolglob/PoolRawAccess.h b/datapoolglob/PoolRawAccess.h
index a1bed466..15643a41 100644
--- a/datapoolglob/PoolRawAccess.h
+++ b/datapoolglob/PoolRawAccess.h
@@ -1,220 +1,220 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntryIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */
+#ifndef POOLRAWACCESS_H_
+#define POOLRAWACCESS_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntryIF.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief This class allows accessing Data Pool variables as raw bytes.
+ * @details
+ * This is necessary to have an access method for HK data, as the PID's alone
+ * do not provide type information. Please note that the the raw pool access
+ * read() and commit() calls are not thread-safe.
+ *
+ * Please supply a data set and use the data set read(), commit() calls for
+ * thread-safe data pool access.
+ * @ingroup data_pool
+ */
+class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
+public:
+	/**
+	 * This constructor is used to access a data pool entry with a
+	 * given ID if the target type is not known. A DataSet object is supplied
+	 * and the data pool entry with the given ID is registered to that data set.
+	 * Please note that a pool raw access buffer only has a buffer
+	 * with a size of double. As such, for vector entries which have
+	 * @param data_pool_id Target data pool entry ID
+	 * @param arrayEntry
+	 * @param data_set Dataset to register data pool entry to
+	 * @param setReadWriteMode
+	 * @param registerVectors If set to true, the constructor checks if
+	 *                        there are multiple vector entries to registers
+	 *                        and registers all of them recursively into the data_set
+	 *
+	 */
+	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
+			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
+					PoolVariableIF::VAR_READ);
+
+	/**
+	 * @brief	This operation returns a pointer to the entry fetched.
+	 * @details	Return pointer to the buffer containing the raw data
+	 *          Size and number of data can be retrieved by other means.
+	 */
+	uint8_t* getEntry();
+	/**
+	 * @brief 	This operation returns the fetched entry from the data pool and
+	 * 			flips the bytes, if necessary.
+	 * @details	It makes use of the getEntry call of this function, but additionally flips the
+	 * 			bytes to big endian, which is the default for external communication (as House-
+	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
+	 * 			buffer, if it fits in the given max_size.
+	 * @param buffer	A pointer to a buffer to write to
+	 * @param writtenBytes	The number of bytes written is returned with this value.
+	 * @param max_size	The maximum size that the function may write to buffer.
+	 * @return	- @c RETURN_OK if entry could be acquired
+	 * 			- @c RETURN_FAILED else.
+	 */
+	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
+			size_t maxSize);
+
+	/**
+	 * @brief 	Serialize raw pool entry into provided buffer directly
+	 * @param buffer Provided buffer. Raw pool data will be copied here
+	 * @param size [out] Increment provided size value by serialized size
+	 * @param max_size Maximum allowed serialization size
+	 * @param bigEndian Specify endianess
+	 * @return - @c RETURN_OK if serialization was successfull
+	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
+	 */
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+	        size_t maxSize, Endianness streamEndianness) const override;
+
+    size_t getSerializedSize() const override;
+
+    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+            Endianness streamEndianness) override;
+
+	/**
+	 * With this method, the content can be set from a big endian buffer safely.
+	 * @param buffer	Pointer to the data to set
+	 * @param size		Size of the data to write. Must fit this->size.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
+			size_t setSize);
+	/**
+	 *  @brief This operation returns the type of the entry currently stored.
+	 */
+	Type getType();
+	/**
+	 *  @brief This operation returns the size of the entry currently stored.
+	 */
+	size_t getSizeOfType();
+	/**
+	 *
+	 * @return the size of the datapool array
+	 */
+	size_t getArraySize();
+	/**
+	 * @brief	This operation returns the data pool id of the variable.
+	 */
+	uint32_t getDataPoolId() const;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
+	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
+	static const uint8_t RAW_MAX_SIZE = sizeof(double);
+	uint8_t value[RAW_MAX_SIZE];
+
+
+	/**
+	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~PoolRawAccess();
+
+	/**
+	 * This method returns if the variable is read-write or read-only.
+	 */
+	ReadWriteMode_t getReadWriteMode() const;
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const;
+
+	void setValid(bool valid);
+	/**
+	 * Getter for the remaining size.
+	 */
+	size_t getSizeTillEnd() const;
+
+	/**
+	 * @brief	This is a call to read the value from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the global data pool and copies the value and the valid
+	 * information to its local attributes. In case of a failure (wrong type or
+	 * pool id not found), the variable is set to zero and invalid.
+	 * The call is protected by a lock of the global data pool.
+	 * @return -@c RETURN_OK Read successfull
+	 * 		   -@c READ_TYPE_TOO_LARGE
+	 * 		   -@c READ_INDEX_TOO_LARGE
+	 * 		   -@c READ_ENTRY_NON_EXISTENT
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call writes back the variable's value to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the valid flag is automatically set to "valid".
+	 * The call is protected by a lock of the global data pool.
+	 *
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
+	void handleReadError(ReturnValue_t result);
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
+	 * 			is stored.
+	 */
+	uint32_t dataPoolId;
+	/**
+	 * @brief	The array entry that is fetched from the data pool.
+	 */
+	uint8_t arrayEntry;
+	/**
+	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
+	 */
+	uint8_t valid;
+	/**
+	 * @brief	This value contains the type of the data pool entry.
+	 */
+	Type type;
+	/**
+	 * @brief	This value contains the size of the data pool entry type in bytes.
+	 */
+	size_t typeSize;
+	/**
+	 * The size of the DP array (single values return 1)
+	 */
+	size_t arraySize;
+	/**
+	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
+	 */
+	size_t sizeTillEnd;
+	/**
+	 * @brief	The information whether the class is read-write or read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+};
+
+#endif /* POOLRAWACCESS_H_ */
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 8c3c50db..86705bb0 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,200 +1,200 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
-public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
-	T& operator [](int i);
-	const T &operator [](int i) const;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
-
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
-
-
-};
-
-#include "../datapoollocal/LocalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using lp_vec_t = LocalPoolVector<T, vectorSize>;
-
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+
+#include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
+#include "../datapool/PoolVariableIF.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+/**
+ * @brief	This is the access class for array-type data pool entries.
+ * @details
+ * To ensure safe usage of the data pool, operation is not done directly on the
+ * data pool entries, but on local copies. This class provides simple type-
+ * and length-safe access to vector-style data pool entries (i.e. entries with
+ * length > 1). The class can be instantiated as read-write and read only.
+ *
+ * It provides a commit-and-roll-back semantic, which means that no array
+ * entry in the data pool is changed until the commit call is executed.
+ * There are two template parameters:
+ * @tparam	T
+ * This template parameter specifies the data type of an array entry. Currently,
+ * all plain data types are supported, but in principle any type is possible.
+ * @tparam  vector_size
+ * This template parameter specifies the vector size of this entry. Using a
+ * template parameter for this is not perfect, but avoids
+ * dynamic memory allocation.
+ * @ingroup data_pool
+ */
+template<typename T, uint16_t vectorSize>
+class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+public:
+	LocalPoolVector() = delete;
+	/**
+	 * This constructor is used by the data creators to have pool variable
+	 * instances which can also be stored in datasets.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * This constructor is used by data users like controllers to have
+	 * access to the local pool variables of data creators by supplying
+	 * the respective creator object ID.
+	 * It does not fetch the current value from the data pool. This is performed
+	 * by the read() operation (which is not thread-safe).
+	 * Datasets can be used to access local pool entires in a thread-safe way.
+	 * @param poolId ID of the local pool entry.
+	 * @param hkOwner Pointer of the owner. This will generally be the calling
+	 * class itself which passes "this".
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 * @param dataSet The data set in which the variable shall register itself.
+	 * If nullptr, the variable is not registered.
+	 */
+	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
+			DataSetIF* dataSet = nullptr);
+
+	/**
+	 * @brief	This is the local copy of the data pool entry.
+	 * @details
+	 * The user can work on this attribute just like he would on a local
+	 * array of this type.
+	 */
+	T value[vectorSize];
+	/**
+	 * @brief	The classes destructor is empty.
+	 * @details	If commit() was not called, the local value is
+	 * 			discarded and not written back to the data pool.
+	 */
+	~LocalPoolVector() {};
+	/**
+	 * @brief	The operation returns the number of array entries
+	 * 			in this variable.
+	 */
+	uint8_t getSize() {
+		return vectorSize;
+	}
+
+	uint32_t getDataPoolId() const override;
+	/**
+	 * @brief This operation sets the data pool ID of the variable.
+	 * @details
+	 * The method is necessary to set id's of data pool member variables
+	 * with bad initialization.
+	 */
+	void setDataPoolId(uint32_t poolId);
+
+	/**
+	 * This method returns if the variable is write-only, read-write or read-only.
+	 */
+	pool_rwm_t getReadWriteMode() const;
+
+	/**
+	 * @brief	With this call, the valid information of the variable is returned.
+	 */
+	bool isValid() const override;
+	void setValid(bool valid) override;
+	uint8_t getValid() const;
+
+	T& operator [](int i);
+	const T &operator [](int i) const;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t maxSize,
+			SerializeIF::Endianness streamEndiannes) const override;
+	virtual size_t getSerializedSize() const override;
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override;
+
+	/**
+	 * @brief	This is a call to read the array's values
+	 * 			from the global data pool.
+	 * @details
+	 * When executed, this operation tries to fetch the pool entry with matching
+	 * data pool id from the data pool and copies all array values and the valid
+	 * information to its local attributes.
+	 * In case of a failure (wrong type, size or pool id not found), the
+	 * variable is set to zero and invalid.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	/**
+	 * @brief	The commit call copies the array values back to the data pool.
+	 * @details
+	 * It checks type and size, as well as if the variable is writable. If so,
+	 * the value is copied and the local valid flag is written back as well.
+	 * The read call is protected with a lock.
+	 * It is recommended to use DataSets to read and commit multiple variables
+	 * at once to avoid the overhead of unnecessary lock und unlock operations.
+	 */
+	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+
+protected:
+	/**
+	 * @brief	Like #read, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t readWithoutLock() override;
+	/**
+	 * @brief	Like #commit, but without a lock protection of the global pool.
+	 * @details
+	 * The operation does NOT provide any mutual exclusive protection by itself.
+	 * This can be used if the lock is handled externally to avoid the overhead
+	 * of consecutive lock und unlock operations.
+	 * Declared protected to discourage free public usage.
+	 */
+	ReturnValue_t commitWithoutLock() override;
+
+private:
+	/**
+	 * @brief	To access the correct data pool entry on read and commit calls,
+	 * 			the data pool id is stored.
+	 */
+	uint32_t localPoolId;
+	/**
+	 * @brief	The valid information as it was stored in the data pool
+	 * 			is copied to this attribute.
+	 */
+	bool valid;
+	/**
+	 * @brief	The information whether the class is read-write or
+	 * 			read-only is stored here.
+	 */
+	ReadWriteMode_t readWriteMode;
+	//! @brief	Pointer to the class which manages the HK pool.
+	LocalDataPoolManager* hkManager;
+
+	// std::ostream is the type for object std::cout
+	template <typename U, uint16_t otherSize>
+	friend std::ostream& operator<< (std::ostream &out,
+	        const LocalPoolVector<U, otherSize> &var);
+
+
+};
+
+#include "../datapoollocal/LocalPoolVector.tpp"
+
+template<typename T, uint16_t vectorSize>
+using lp_vec_t = LocalPoolVector<T, vectorSize>;
+
+#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.cpp b/datapoollocal/SharedLocalDataSet.cpp
index 73e0e1fb..dd1bdcc4 100644
--- a/datapoollocal/SharedLocalDataSet.cpp
+++ b/datapoollocal/SharedLocalDataSet.cpp
@@ -1,16 +1,16 @@
-#include "SharedLocalDataSet.h"
-
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
-        const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(sid, nullptr, maxSize) {
-    this->setContainer(poolVarVector.data());
-    datasetLock = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
-}
-
-ReturnValue_t SharedLocalDataSet::unlockDataset() {
-    return datasetLock->unlockMutex();
-}
+#include "SharedLocalDataSet.h"
+
+SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
+        const size_t maxSize): SystemObject(objectId),
+        LocalPoolDataSetBase(sid, nullptr, maxSize) {
+    this->setContainer(poolVarVector.data());
+    datasetLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
+    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
+}
+
+ReturnValue_t SharedLocalDataSet::unlockDataset() {
+    return datasetLock->unlockMutex();
+}
diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index d7e11714..eb7780db 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,19 +1,19 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * This interface is used by the device handler to send a device response
- * to the queue ID, which is returned in the implemented abstract method.
- */
-class AcceptsDeviceResponsesIF {
-public:
-	/**
-	 * Default empty virtual destructor.
-	 */
-	virtual ~AcceptsDeviceResponsesIF() {}
-	virtual MessageQueueId_t getDeviceQueue() = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This interface is used by the device handler to send a device response
+ * to the queue ID, which is returned in the implemented abstract method.
+ */
+class AcceptsDeviceResponsesIF {
+public:
+	/**
+	 * Default empty virtual destructor.
+	 */
+	virtual ~AcceptsDeviceResponsesIF() {}
+	virtual MessageQueueId_t getDeviceQueue() = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index c98a9f67..3bcb8a11 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,273 +1,273 @@
-#include "../devicehandlers/AssemblyBase.h"
-
-AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
-		uint16_t commandQueueDepth) :
-		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
-		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
-		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
-		targetSubmode(SUBMODE_NONE) {
-	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
-}
-
-AssemblyBase::~AssemblyBase() {
-}
-
-ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
-	return handleHealthReply(message);
-}
-
-void AssemblyBase::performChildOperation() {
-	if (isInTransition()) {
-		handleChildrenTransition();
-	} else {
-		handleChildrenChanged();
-	}
-}
-
-void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
-	doStartTransition(mode, submode);
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, mode, submode);
-	} else {
-		triggerEvent(CHANGING_MODE, mode, submode);
-	}
-}
-
-void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
-	targetMode = mode;
-	targetSubmode = submode;
-	internalState = STATE_SINGLE_STEP;
-	ReturnValue_t result = commandChildren(mode, submode);
-	if (result == NEED_SECOND_STEP) {
-		internalState = STATE_NEED_SECOND_STEP;
-	}
-}
-
-bool AssemblyBase::isInTransition() {
-	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
-}
-
-bool AssemblyBase::handleChildrenChanged() {
-	if (childrenChangedMode) {
-		ReturnValue_t result = checkChildrenState();
-		if (result != RETURN_OK) {
-			handleChildrenLostMode(result);
-		}
-		return true;
-	} else {
-		return handleChildrenChangedHealth();
-	}
-}
-
-void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
-	triggerEvent(CANT_KEEP_MODE, mode, submode);
-	startTransition(MODE_OFF, SUBMODE_NONE);
-}
-
-bool AssemblyBase::handleChildrenChangedHealth() {
-	auto iter = childrenMap.begin();
-	for (; iter != childrenMap.end(); iter++) {
-		if (iter->second.healthChanged) {
-			iter->second.healthChanged = false;
-			break;
-		}
-	}
-	if (iter == childrenMap.end()) {
-		return false;
-	}
-	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
-	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-		triggerEvent(TRYING_RECOVERY);
-		recoveryState = RECOVERY_STARTED;
-		recoveringDevice = iter;
-		doStartTransition(targetMode, targetSubmode);
-	} else {
-		triggerEvent(CHILD_CHANGED_HEALTH);
-		doStartTransition(mode, submode);
-	}
-	if (modeHelper.isForced()) {
-		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
-	}
-	return true;
-}
-
-void AssemblyBase::handleChildrenTransition() {
-	if (commandsOutstanding <= 0) {
-		switch (internalState) {
-		case STATE_NEED_SECOND_STEP:
-			internalState = STATE_SECOND_STEP;
-			commandChildren(targetMode, targetSubmode);
-			return;
-		case STATE_OVERWRITE_HEALTH: {
-			internalState = STATE_SINGLE_STEP;
-			ReturnValue_t result = commandChildren(mode, submode);
-			if (result == NEED_SECOND_STEP) {
-				internalState = STATE_NEED_SECOND_STEP;
-			}
-			return;
-		}
-		case STATE_NONE:
-			//Valid state, used in recovery.
-		case STATE_SINGLE_STEP:
-		case STATE_SECOND_STEP:
-			if (checkAndHandleRecovery()) {
-				return;
-			}
-			break;
-		}
-		ReturnValue_t result = checkChildrenState();
-		if (result == RETURN_OK) {
-			handleModeReached();
-		} else {
-			handleModeTransitionFailed(result);
-		}
-	}
-}
-
-void AssemblyBase::handleModeReached() {
-	internalState = STATE_NONE;
-	setMode(targetMode, targetSubmode);
-}
-
-void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
-//always accept transition to OFF, there is nothing we can do except sending an info event
-//In theory this should never happen, but we would risk an infinite loop otherwise
-	if (targetMode == MODE_OFF) {
-		triggerEvent(CHILD_PROBLEMS, result);
-		internalState = STATE_NONE;
-		setMode(targetMode, targetSubmode);
-	} else {
-		if (handleChildrenChangedHealth()) {
-			//If any health change is pending, handle that first.
-			return;
-		}
-		triggerEvent(MODE_TRANSITION_FAILED, result);
-		startTransition(MODE_OFF, SUBMODE_NONE);
-	}
-}
-
-void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
-		HealthState health) {
-	CommandMessage command;
-	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
-			health);
-	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
-		commandsOutstanding++;
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenState() {
-	if (targetMode == MODE_OFF) {
-		return checkChildrenStateOff();
-	} else {
-		return checkChildrenStateOn(targetMode, targetSubmode);
-	}
-}
-
-ReturnValue_t AssemblyBase::checkChildrenStateOff() {
-	for (const auto& childIter: childrenMap) {
-		if (checkChildOff(childIter.first) != RETURN_OK) {
-			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
-	ChildInfo childInfo = childrenMap.find(objectId)->second;
-	if (healthHelper.healthTable->isCommandable(objectId)) {
-		if (childInfo.submode != SUBMODE_NONE) {
-			return RETURN_FAILED;
-		} else {
-			if ((childInfo.mode != MODE_OFF)
-					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
-				return RETURN_FAILED;
-			}
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
-		uint32_t* msToReachTheMode) {
-
-//always accept transition to OFF
-	if (mode == MODE_OFF) {
-		if (submode != SUBMODE_NONE) {
-			return INVALID_SUBMODE;
-		}
-		return RETURN_OK;
-	}
-
-	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
-		return INVALID_MODE;
-	}
-
-	if (internalState != STATE_NONE) {
-		return IN_TRANSITION;
-	}
-
-	return isModeCombinationValid(mode, submode);
-}
-
-ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
-	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
-		HealthState health = HealthMessage::getHealth(message);
-		if (health != EXTERNAL_CONTROL) {
-			updateChildChangedHealth(message->getSender(), true);
-		}
-		return RETURN_OK;
-	}
-	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
-			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
-					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
-		if (isInTransition()) {
-			commandsOutstanding--;
-		}
-		return RETURN_OK;
-	}
-	return RETURN_FAILED;
-}
-
-bool AssemblyBase::checkAndHandleRecovery() {
-	switch (recoveryState) {
-	case RECOVERY_STARTED:
-		recoveryState = RECOVERY_WAIT;
-		recoveryOffTimer.resetTimer();
-		return true;
-	case RECOVERY_WAIT:
-		if (recoveryOffTimer.isBusy()) {
-			return true;
-		}
-		triggerEvent(RECOVERY_STEP, 0);
-		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
-		internalState = STATE_NONE;
-		recoveryState = RECOVERY_ONGOING;
-		//Don't check state!
-		return true;
-	case RECOVERY_ONGOING:
-		triggerEvent(RECOVERY_STEP, 1);
-		recoveryState = RECOVERY_ONGOING_2;
-		recoveringDevice->second.healthChanged = false;
-		//Device should be healthy again, so restart a transition.
-		//Might be including second step, but that's already handled.
-		doStartTransition(targetMode, targetSubmode);
-		return true;
-	case RECOVERY_ONGOING_2:
-		triggerEvent(RECOVERY_DONE);
-		//Now we're through, but not sure if it was successful.
-		recoveryState = RECOVERY_IDLE;
-		return false;
-	case RECOVERY_IDLE:
-	default:
-		return false;
-	}
-}
-
-void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
-		HasHealthIF::HealthState oldHealth) {
-	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
-	internalState = STATE_OVERWRITE_HEALTH;
-	modeHelper.setForced(true);
-	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
-}
+#include "../devicehandlers/AssemblyBase.h"
+
+AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
+		uint16_t commandQueueDepth) :
+		SubsystemBase(objectId, parentId, MODE_OFF, commandQueueDepth),
+		internalState(STATE_NONE), recoveryState(RECOVERY_IDLE),
+		recoveringDevice(childrenMap.end()), targetMode(MODE_OFF),
+		targetSubmode(SUBMODE_NONE) {
+	recoveryOffTimer.setTimeout(POWER_OFF_TIME_MS);
+}
+
+AssemblyBase::~AssemblyBase() {
+}
+
+ReturnValue_t AssemblyBase::handleCommandMessage(CommandMessage* message) {
+	return handleHealthReply(message);
+}
+
+void AssemblyBase::performChildOperation() {
+	if (isInTransition()) {
+		handleChildrenTransition();
+	} else {
+		handleChildrenChanged();
+	}
+}
+
+void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
+	doStartTransition(mode, submode);
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, mode, submode);
+	} else {
+		triggerEvent(CHANGING_MODE, mode, submode);
+	}
+}
+
+void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
+	targetMode = mode;
+	targetSubmode = submode;
+	internalState = STATE_SINGLE_STEP;
+	ReturnValue_t result = commandChildren(mode, submode);
+	if (result == NEED_SECOND_STEP) {
+		internalState = STATE_NEED_SECOND_STEP;
+	}
+}
+
+bool AssemblyBase::isInTransition() {
+	return (internalState != STATE_NONE) || (recoveryState != RECOVERY_IDLE);
+}
+
+bool AssemblyBase::handleChildrenChanged() {
+	if (childrenChangedMode) {
+		ReturnValue_t result = checkChildrenState();
+		if (result != RETURN_OK) {
+			handleChildrenLostMode(result);
+		}
+		return true;
+	} else {
+		return handleChildrenChangedHealth();
+	}
+}
+
+void AssemblyBase::handleChildrenLostMode(ReturnValue_t result) {
+	triggerEvent(CANT_KEEP_MODE, mode, submode);
+	startTransition(MODE_OFF, SUBMODE_NONE);
+}
+
+bool AssemblyBase::handleChildrenChangedHealth() {
+	auto iter = childrenMap.begin();
+	for (; iter != childrenMap.end(); iter++) {
+		if (iter->second.healthChanged) {
+			iter->second.healthChanged = false;
+			break;
+		}
+	}
+	if (iter == childrenMap.end()) {
+		return false;
+	}
+	HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
+	if (healthState == HasHealthIF::NEEDS_RECOVERY) {
+		triggerEvent(TRYING_RECOVERY);
+		recoveryState = RECOVERY_STARTED;
+		recoveringDevice = iter;
+		doStartTransition(targetMode, targetSubmode);
+	} else {
+		triggerEvent(CHILD_CHANGED_HEALTH);
+		doStartTransition(mode, submode);
+	}
+	if (modeHelper.isForced()) {
+		triggerEvent(FORCING_MODE, targetMode, targetSubmode);
+	}
+	return true;
+}
+
+void AssemblyBase::handleChildrenTransition() {
+	if (commandsOutstanding <= 0) {
+		switch (internalState) {
+		case STATE_NEED_SECOND_STEP:
+			internalState = STATE_SECOND_STEP;
+			commandChildren(targetMode, targetSubmode);
+			return;
+		case STATE_OVERWRITE_HEALTH: {
+			internalState = STATE_SINGLE_STEP;
+			ReturnValue_t result = commandChildren(mode, submode);
+			if (result == NEED_SECOND_STEP) {
+				internalState = STATE_NEED_SECOND_STEP;
+			}
+			return;
+		}
+		case STATE_NONE:
+			//Valid state, used in recovery.
+		case STATE_SINGLE_STEP:
+		case STATE_SECOND_STEP:
+			if (checkAndHandleRecovery()) {
+				return;
+			}
+			break;
+		}
+		ReturnValue_t result = checkChildrenState();
+		if (result == RETURN_OK) {
+			handleModeReached();
+		} else {
+			handleModeTransitionFailed(result);
+		}
+	}
+}
+
+void AssemblyBase::handleModeReached() {
+	internalState = STATE_NONE;
+	setMode(targetMode, targetSubmode);
+}
+
+void AssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
+//always accept transition to OFF, there is nothing we can do except sending an info event
+//In theory this should never happen, but we would risk an infinite loop otherwise
+	if (targetMode == MODE_OFF) {
+		triggerEvent(CHILD_PROBLEMS, result);
+		internalState = STATE_NONE;
+		setMode(targetMode, targetSubmode);
+	} else {
+		if (handleChildrenChangedHealth()) {
+			//If any health change is pending, handle that first.
+			return;
+		}
+		triggerEvent(MODE_TRANSITION_FAILED, result);
+		startTransition(MODE_OFF, SUBMODE_NONE);
+	}
+}
+
+void AssemblyBase::sendHealthCommand(MessageQueueId_t sendTo,
+		HealthState health) {
+	CommandMessage command;
+	HealthMessage::setHealthMessage(&command, HealthMessage::HEALTH_SET,
+			health);
+	if (commandQueue->sendMessage(sendTo, &command) == RETURN_OK) {
+		commandsOutstanding++;
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenState() {
+	if (targetMode == MODE_OFF) {
+		return checkChildrenStateOff();
+	} else {
+		return checkChildrenStateOn(targetMode, targetSubmode);
+	}
+}
+
+ReturnValue_t AssemblyBase::checkChildrenStateOff() {
+	for (const auto& childIter: childrenMap) {
+		if (checkChildOff(childIter.first) != RETURN_OK) {
+			return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
+	ChildInfo childInfo = childrenMap.find(objectId)->second;
+	if (healthHelper.healthTable->isCommandable(objectId)) {
+		if (childInfo.submode != SUBMODE_NONE) {
+			return RETURN_FAILED;
+		} else {
+			if ((childInfo.mode != MODE_OFF)
+					&& (childInfo.mode != DeviceHandlerIF::MODE_ERROR_ON)) {
+				return RETURN_FAILED;
+			}
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AssemblyBase::checkModeCommand(Mode_t mode, Submode_t submode,
+		uint32_t* msToReachTheMode) {
+
+//always accept transition to OFF
+	if (mode == MODE_OFF) {
+		if (submode != SUBMODE_NONE) {
+			return INVALID_SUBMODE;
+		}
+		return RETURN_OK;
+	}
+
+	if ((mode != MODE_ON) && (mode != DeviceHandlerIF::MODE_NORMAL)) {
+		return INVALID_MODE;
+	}
+
+	if (internalState != STATE_NONE) {
+		return IN_TRANSITION;
+	}
+
+	return isModeCombinationValid(mode, submode);
+}
+
+ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
+	if (message->getCommand() == HealthMessage::HEALTH_INFO) {
+		HealthState health = HealthMessage::getHealth(message);
+		if (health != EXTERNAL_CONTROL) {
+			updateChildChangedHealth(message->getSender(), true);
+		}
+		return RETURN_OK;
+	}
+	if (message->getCommand() == HealthMessage::REPLY_HEALTH_SET
+			|| (message->getCommand() == CommandMessage::REPLY_REJECTED
+					&& message->getParameter2() == HealthMessage::HEALTH_SET)) {
+		if (isInTransition()) {
+			commandsOutstanding--;
+		}
+		return RETURN_OK;
+	}
+	return RETURN_FAILED;
+}
+
+bool AssemblyBase::checkAndHandleRecovery() {
+	switch (recoveryState) {
+	case RECOVERY_STARTED:
+		recoveryState = RECOVERY_WAIT;
+		recoveryOffTimer.resetTimer();
+		return true;
+	case RECOVERY_WAIT:
+		if (recoveryOffTimer.isBusy()) {
+			return true;
+		}
+		triggerEvent(RECOVERY_STEP, 0);
+		sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
+		internalState = STATE_NONE;
+		recoveryState = RECOVERY_ONGOING;
+		//Don't check state!
+		return true;
+	case RECOVERY_ONGOING:
+		triggerEvent(RECOVERY_STEP, 1);
+		recoveryState = RECOVERY_ONGOING_2;
+		recoveringDevice->second.healthChanged = false;
+		//Device should be healthy again, so restart a transition.
+		//Might be including second step, but that's already handled.
+		doStartTransition(targetMode, targetSubmode);
+		return true;
+	case RECOVERY_ONGOING_2:
+		triggerEvent(RECOVERY_DONE);
+		//Now we're through, but not sure if it was successful.
+		recoveryState = RECOVERY_IDLE;
+		return false;
+	case RECOVERY_IDLE:
+	default:
+		return false;
+	}
+}
+
+void AssemblyBase::overwriteDeviceHealth(object_id_t objectId,
+		HasHealthIF::HealthState oldHealth) {
+	triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
+	internalState = STATE_OVERWRITE_HEALTH;
+	modeHelper.setForced(true);
+	sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
+}
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index 7c66b21d..b67c551e 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,163 +1,163 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-
-#include "../container/FixedArrayList.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-#include "../subsystem/SubsystemBase.h"
-
-/**
- * @brief   Base class to implement reconfiguration and failure handling for
- *          redundant devices by monitoring their modes health states.
- * @details
- * Documentation: Dissertation Baetz p.156, 157.
- *
- * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices.
- *
- * The template class monitors mode and health state of its children
- * and checks availability of devices on every detected change.
- * AssemblyBase does not implement any redundancy logic by itself, but provides
- * adaptation points for implementations to do so. Since most monitoring
- * activities rely on mode and health state only and are therefore
- * generic, it is sufficient for subclasses to provide:
- *
- * 1. check logic when active-> checkChildrenStateOn
- * 2. transition logic to change the mode -> commandChildren
- *
- */
-class AssemblyBase: public SubsystemBase {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
-	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
-			MAKE_RETURN_CODE(0xa1);
-
-	AssemblyBase(object_id_t objectId, object_id_t parentId,
-	        uint16_t commandQueueDepth = 8);
-	virtual ~AssemblyBase();
-
-protected:
-
-    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
-    // (or return internalState directly?)
-    /**
-     * Command children to reach [mode,submode] combination
-     * Can be done by setting #commandsOutstanding correctly,
-     * or using executeTable()
-     * @param mode
-     * @param submode
-     * @return
-     *    - @c RETURN_OK if ok
-     *    - @c NEED_SECOND_STEP if children need to be commanded again
-     */
-    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
-
-    /**
-     * Check whether desired assembly mode was achieved by checking the modes
-     * or/and health states of child device handlers.
-     * The assembly template class will also call this function if a health
-     * or mode change of a child device handler was detected.
-     * @param wantedMode
-     * @param wantedSubmode
-     * @return
-     */
-    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-            Submode_t wantedSubmode) = 0;
-
-    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
-            Submode_t submode) = 0;
-
-	enum InternalState {
-		STATE_NONE,
-		STATE_OVERWRITE_HEALTH,
-		STATE_NEED_SECOND_STEP,
-		STATE_SINGLE_STEP,
-		STATE_SECOND_STEP,
-	} internalState;
-
-	enum RecoveryState {
-		RECOVERY_IDLE,
-		RECOVERY_STARTED,
-		RECOVERY_ONGOING,
-		RECOVERY_ONGOING_2,
-		RECOVERY_WAIT
-	} recoveryState; //!< Indicates if one of the children requested a recovery.
-	ChildrenMap::iterator recoveringDevice;
-
-	/**
-	 * the mode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedMode!
-	 */
-	Mode_t targetMode;
-
-	/**
-	 * the submode the current transition is trying to achieve.
-	 * Can be different from the modehelper.commandedSubmode!
-	 */
-	Submode_t targetSubmode;
-
-	Countdown recoveryOffTimer;
-
-	static const uint32_t POWER_OFF_TIME_MS = 1000;
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
-
-	virtual void performChildOperation();
-
-	bool handleChildrenChanged();
-
-	/**
-	 * This method is called if the children changed its mode in a way that
-	 * the current mode can't be kept.
-	 * Default behavior is to go to MODE_OFF.
-	 * @param result The failure code which was returned by checkChildrenState.
-	 */
-	virtual void handleChildrenLostMode(ReturnValue_t result);
-
-	bool handleChildrenChangedHealth();
-
-	virtual void handleChildrenTransition();
-
-	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	virtual void doStartTransition(Mode_t mode, Submode_t submode);
-
-	virtual bool isInTransition();
-
-	virtual void handleModeReached();
-
-	virtual void handleModeTransitionFailed(ReturnValue_t result);
-
-	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
-
-	virtual ReturnValue_t checkChildrenStateOff();
-
-	ReturnValue_t checkChildrenState();
-
-	virtual ReturnValue_t checkChildOff(uint32_t objectId);
-
-	/**
-	 * Manages recovery of a device
-	 * @return true if recovery is still ongoing, false else.
-	 */
-	bool checkAndHandleRecovery();
-
-	/**
-	 * Helper method to overwrite health state of one of the children.
-	 * Also sets state to STATE_OVERWRITE_HEATH.
-	 * @param objectId Must be a registered child.
-	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+
+#include "../container/FixedArrayList.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+/**
+ * @brief   Base class to implement reconfiguration and failure handling for
+ *          redundant devices by monitoring their modes health states.
+ * @details
+ * Documentation: Dissertation Baetz p.156, 157.
+ *
+ * This class reduces the complexity of controller components which would
+ * otherwise be needed for the handling of redundant devices.
+ *
+ * The template class monitors mode and health state of its children
+ * and checks availability of devices on every detected change.
+ * AssemblyBase does not implement any redundancy logic by itself, but provides
+ * adaptation points for implementations to do so. Since most monitoring
+ * activities rely on mode and health state only and are therefore
+ * generic, it is sufficient for subclasses to provide:
+ *
+ * 1. check logic when active-> checkChildrenStateOn
+ * 2. transition logic to change the mode -> commandChildren
+ *
+ */
+class AssemblyBase: public SubsystemBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASSEMBLY_BASE;
+	static const ReturnValue_t NEED_SECOND_STEP = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t NEED_TO_RECONFIGURE = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t MODE_FALLBACK = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CHILD_NOT_COMMANDABLE = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t NEED_TO_CHANGE_HEALTH = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE =
+			MAKE_RETURN_CODE(0xa1);
+
+	AssemblyBase(object_id_t objectId, object_id_t parentId,
+	        uint16_t commandQueueDepth = 8);
+	virtual ~AssemblyBase();
+
+protected:
+
+    // SHOULDDO: Change that OVERWRITE_HEALTH may be returned
+    // (or return internalState directly?)
+    /**
+     * Command children to reach [mode,submode] combination
+     * Can be done by setting #commandsOutstanding correctly,
+     * or using executeTable()
+     * @param mode
+     * @param submode
+     * @return
+     *    - @c RETURN_OK if ok
+     *    - @c NEED_SECOND_STEP if children need to be commanded again
+     */
+    virtual ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) = 0;
+
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+    virtual ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+            Submode_t wantedSubmode) = 0;
+
+    virtual ReturnValue_t isModeCombinationValid(Mode_t mode,
+            Submode_t submode) = 0;
+
+	enum InternalState {
+		STATE_NONE,
+		STATE_OVERWRITE_HEALTH,
+		STATE_NEED_SECOND_STEP,
+		STATE_SINGLE_STEP,
+		STATE_SECOND_STEP,
+	} internalState;
+
+	enum RecoveryState {
+		RECOVERY_IDLE,
+		RECOVERY_STARTED,
+		RECOVERY_ONGOING,
+		RECOVERY_ONGOING_2,
+		RECOVERY_WAIT
+	} recoveryState; //!< Indicates if one of the children requested a recovery.
+	ChildrenMap::iterator recoveringDevice;
+
+	/**
+	 * the mode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedMode!
+	 */
+	Mode_t targetMode;
+
+	/**
+	 * the submode the current transition is trying to achieve.
+	 * Can be different from the modehelper.commandedSubmode!
+	 */
+	Submode_t targetSubmode;
+
+	Countdown recoveryOffTimer;
+
+	static const uint32_t POWER_OFF_TIME_MS = 1000;
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	virtual ReturnValue_t handleHealthReply(CommandMessage *message);
+
+	virtual void performChildOperation();
+
+	bool handleChildrenChanged();
+
+	/**
+	 * This method is called if the children changed its mode in a way that
+	 * the current mode can't be kept.
+	 * Default behavior is to go to MODE_OFF.
+	 * @param result The failure code which was returned by checkChildrenState.
+	 */
+	virtual void handleChildrenLostMode(ReturnValue_t result);
+
+	bool handleChildrenChangedHealth();
+
+	virtual void handleChildrenTransition();
+
+	ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	virtual void doStartTransition(Mode_t mode, Submode_t submode);
+
+	virtual bool isInTransition();
+
+	virtual void handleModeReached();
+
+	virtual void handleModeTransitionFailed(ReturnValue_t result);
+
+	void sendHealthCommand(MessageQueueId_t sendTo, HealthState health);
+
+	virtual ReturnValue_t checkChildrenStateOff();
+
+	ReturnValue_t checkChildrenState();
+
+	virtual ReturnValue_t checkChildOff(uint32_t objectId);
+
+	/**
+	 * Manages recovery of a device
+	 * @return true if recovery is still ongoing, false else.
+	 */
+	bool checkAndHandleRecovery();
+
+	/**
+	 * Helper method to overwrite health state of one of the children.
+	 * Also sets state to STATE_OVERWRITE_HEATH.
+	 * @param objectId Must be a registered child.
+	 */
+	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index acc1b5a0..976c252a 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,47 +1,47 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../devicehandlers/ChildHandlerBase.h"
-#include "../subsystem/SubsystemBase.h"
-
-ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
-		object_id_t deviceCommunication, CookieIF * cookie,
-		object_id_t hkDestination, uint32_t thermalStatePoolId,
-		uint32_t thermalRequestPoolId,
-		object_id_t parent,
-		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
-		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
-			(customFdir == nullptr? &childHandlerFdir : customFdir),
-			cmdQueueSize),
-		parentId(parent), childHandlerFdir(setObjectId) {
-	this->setHkDestination(hkDestination);
-	this->setThermalStateRequestPoolIds(thermalStatePoolId,
-			thermalRequestPoolId);
-
-}
-
-ChildHandlerBase::~ChildHandlerBase() {
-}
-
-ReturnValue_t ChildHandlerBase::initialize() {
-	ReturnValue_t result = DeviceHandlerBase::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	healthHelper.setParentQueue(parentQueue);
-
-	modeHelper.setParentQueue(parentQueue);
-
-	return RETURN_OK;
-}
+#include "../subsystem/SubsystemBase.h"
+#include "../devicehandlers/ChildHandlerBase.h"
+#include "../subsystem/SubsystemBase.h"
+
+ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
+		object_id_t deviceCommunication, CookieIF * cookie,
+		object_id_t hkDestination, uint32_t thermalStatePoolId,
+		uint32_t thermalRequestPoolId,
+		object_id_t parent,
+		FailureIsolationBase* customFdir, size_t cmdQueueSize) :
+		DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
+			(customFdir == nullptr? &childHandlerFdir : customFdir),
+			cmdQueueSize),
+		parentId(parent), childHandlerFdir(setObjectId) {
+	this->setHkDestination(hkDestination);
+	this->setThermalStateRequestPoolIds(thermalStatePoolId,
+			thermalRequestPoolId);
+
+}
+
+ChildHandlerBase::~ChildHandlerBase() {
+}
+
+ReturnValue_t ChildHandlerBase::initialize() {
+	ReturnValue_t result = DeviceHandlerBase::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	MessageQueueId_t parentQueue = 0;
+
+	if (parentId != objects::NO_OBJECT) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	healthHelper.setParentQueue(parentQueue);
+
+	modeHelper.setParentQueue(parentQueue);
+
+	return RETURN_OK;
+}
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 625955f0..19e0fc80 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,24 +1,24 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
-
-#include "../devicehandlers/ChildHandlerFDIR.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-class ChildHandlerBase: public DeviceHandlerBase {
-public:
-	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
-			CookieIF * cookie, object_id_t hkDestination,
-			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
-			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
-	virtual ~ChildHandlerBase();
-
-	virtual ReturnValue_t initialize();
-
-protected:
-	const uint32_t parentId;
-	ChildHandlerFDIR childHandlerFdir;
-
-};
-
-#endif /* PAYLOADHANDLERBASE_H_ */
+#ifndef PAYLOADHANDLERBASE_H_
+#define PAYLOADHANDLERBASE_H_
+
+#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+class ChildHandlerBase: public DeviceHandlerBase {
+public:
+	ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
+			CookieIF * cookie, object_id_t hkDestination,
+			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
+			object_id_t parent = objects::NO_OBJECT,
+			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+	virtual ~ChildHandlerBase();
+
+	virtual ReturnValue_t initialize();
+
+protected:
+	const uint32_t parentId;
+	ChildHandlerFDIR childHandlerFdir;
+
+};
+
+#endif /* PAYLOADHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index bab5a7e5..9589b44f 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,10 +1,10 @@
-#include "../devicehandlers/ChildHandlerFDIR.h"
-
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
-		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
-	recoveryCounter.setFailureThreshold(recoveryCount);
-}
-
-ChildHandlerFDIR::~ChildHandlerFDIR() {
-}
-
+#include "../devicehandlers/ChildHandlerFDIR.h"
+
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
+	recoveryCounter.setFailureThreshold(recoveryCount);
+}
+
+ChildHandlerFDIR::~ChildHandlerFDIR() {
+}
+
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 83f79a63..203fc944 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-
-/**
- * Very simple extension to normal FDIR.
- * Does not have a default fault tree parent and
- * allows to make the recovery count settable to 0.
- */
-class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
-public:
-	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
-			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
-	virtual ~ChildHandlerFDIR();
-protected:
-	static const object_id_t NO_FAULT_TREE_PARENT = 0;
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
+#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
+/**
+ * Very simple extension to normal FDIR.
+ * Does not have a default fault tree parent and
+ * allows to make the recovery count settable to 0.
+ */
+class ChildHandlerFDIR: public DeviceHandlerFailureIsolation {
+public:
+	ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent =
+			NO_FAULT_TREE_PARENT, uint32_t recoveryCount = 0);
+	virtual ~ChildHandlerFDIR();
+protected:
+	static const object_id_t NO_FAULT_TREE_PARENT = 0;
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ */
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index aacf5580..abdfd3a8 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -1,201 +1,201 @@
-/**
- * @file CommunicationMessage.cpp
- *
- * @date 28.02.2020
- */
-
-#include "../devicehandlers/CommunicationMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-CommunicationMessage::CommunicationMessage(): uninitialized(true) {
-}
-
-CommunicationMessage::~CommunicationMessage() {}
-
-void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
-		uint32_t dataLen, const uint8_t * data) {
-	setMessageType(SEND_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(SEND_DATA_FROM_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
-		uint16_t sendBufferPosition) {
-	setMessageType(SEND_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(sendBufferPosition != 0) {
-		setBufferPosition(sendBufferPosition);
-	}
-}
-
-void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(REPLY_DATA_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
-		uint32_t dataLen, uint8_t *data) {
-	setMessageType(REPLY_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setDataReplyRaw(uint32_t address,
-		uint32_t length, uint16_t receiveBufferPosition) {
-	setMessageType(REPLY_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(receiveBufferPosition != 0) {
-		setBufferPosition(receiveBufferPosition);
-	}
-}
-
-void CommunicationMessage::setMessageType(messageType status) {
-	uint8_t status_uint8 = status;
-	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
-}
-
-void CommunicationMessage::setAddress(address_t address) {
-	memcpy(getData(),&address,sizeof(address));
-}
-
-address_t CommunicationMessage::getAddress() const {
-	address_t address;
-	memcpy(&address,getData(),sizeof(address));
-	return address;
-}
-
-void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
-			&bufferPosition, sizeof(bufferPosition));
-}
-
-uint16_t CommunicationMessage::getBufferPosition() const {
-	uint16_t bufferPosition;
-	memcpy(&bufferPosition,
-			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
-	return bufferPosition;
-}
-
-void CommunicationMessage::setDataPointer(const void * data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
-}
-
-void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
-}
-
-store_address_t CommunicationMessage::getStoreId() const{
-	store_address_t temp;
-	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
-	return temp;
-}
-
-void CommunicationMessage::setDataLen(uint32_t length) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
-}
-
-uint32_t CommunicationMessage::getDataLen() const {
-	uint32_t len;
-	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
-	return len;
-}
-
-void CommunicationMessage::setUint32Data(uint32_t data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
-}
-
-uint32_t CommunicationMessage::getUint32Data() const{
-	uint32_t data;
-	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
-	return data;
-}
-
-void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(0 <= position && position <= 3) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(0 <= position && position <= 3) {
-		uint8_t byte;
-		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
-		return byte;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
-	if(position == 0 || position == 1) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-
-}
-
-uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
-	if(position == 0 || position == 1) {
-		uint16_t data;
-		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
-		return data;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
-	messageType messageType;
-	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
-	return messageType;
-}
-
-void CommunicationMessage::setMessageId(uint8_t messageId) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
-}
-
-uint8_t CommunicationMessage::getMessageId() const {
-	uint8_t messageId;
-	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
-	return messageId;
-}
-
-void CommunicationMessage::clearCommunicationMessage() {
-	messageType messageType = getMessageType();
-	switch(messageType) {
-	case(messageType::REPLY_DATA_IPC_STORE):
-	case(messageType::SEND_DATA_FROM_IPC_STORE): {
-		store_address_t storeId = getStoreId();
-		StorageManagerIF *ipcStore = objectManager->
-				get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(storeId);
-		}
-	}
-	/* NO BREAK falls through*/
-	default:
-		memset(getData(),0,4*sizeof(uint32_t));
-		break;
-	}
-}
-
+/**
+ * @file CommunicationMessage.cpp
+ *
+ * @date 28.02.2020
+ */
+
+#include "../devicehandlers/CommunicationMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+CommunicationMessage::CommunicationMessage(): uninitialized(true) {
+}
+
+CommunicationMessage::~CommunicationMessage() {}
+
+void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
+		uint32_t dataLen, const uint8_t * data) {
+	setMessageType(SEND_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(SEND_DATA_FROM_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId.raw);
+}
+
+void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
+		uint16_t sendBufferPosition) {
+	setMessageType(SEND_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(sendBufferPosition != 0) {
+		setBufferPosition(sendBufferPosition);
+	}
+}
+
+void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
+	setMessageType(REPLY_DATA_IPC_STORE);
+	setAddress(address);
+	setStoreId(storeId.raw);
+}
+void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
+		uint32_t dataLen, uint8_t *data) {
+	setMessageType(REPLY_DATA_FROM_POINTER);
+	setAddress(address);
+	setDataLen(dataLen);
+	setDataPointer(data);
+}
+
+void CommunicationMessage::setDataReplyRaw(uint32_t address,
+		uint32_t length, uint16_t receiveBufferPosition) {
+	setMessageType(REPLY_DATA_RAW);
+	setAddress(address);
+	setDataLen(length);
+	if(receiveBufferPosition != 0) {
+		setBufferPosition(receiveBufferPosition);
+	}
+}
+
+void CommunicationMessage::setMessageType(messageType status) {
+	uint8_t status_uint8 = status;
+	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
+}
+
+void CommunicationMessage::setAddress(address_t address) {
+	memcpy(getData(),&address,sizeof(address));
+}
+
+address_t CommunicationMessage::getAddress() const {
+	address_t address;
+	memcpy(&address,getData(),sizeof(address));
+	return address;
+}
+
+void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
+			&bufferPosition, sizeof(bufferPosition));
+}
+
+uint16_t CommunicationMessage::getBufferPosition() const {
+	uint16_t bufferPosition;
+	memcpy(&bufferPosition,
+			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
+	return bufferPosition;
+}
+
+void CommunicationMessage::setDataPointer(const void * data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
+}
+
+void CommunicationMessage::setStoreId(store_address_t storeId) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
+}
+
+store_address_t CommunicationMessage::getStoreId() const{
+	store_address_t temp;
+	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
+	return temp;
+}
+
+void CommunicationMessage::setDataLen(uint32_t length) {
+	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
+}
+
+uint32_t CommunicationMessage::getDataLen() const {
+	uint32_t len;
+	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
+	return len;
+}
+
+void CommunicationMessage::setUint32Data(uint32_t data) {
+	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
+}
+
+uint32_t CommunicationMessage::getUint32Data() const{
+	uint32_t data;
+	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
+	return data;
+}
+
+void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
+	if(0 <= position && position <= 3) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
+	}
+	else {
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
+	if(0 <= position && position <= 3) {
+		uint8_t byte;
+		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
+		return byte;
+	}
+	else {
+		return 0;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
+	if(position == 0 || position == 1) {
+		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
+	}
+	else {
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+
+}
+
+uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
+	if(position == 0 || position == 1) {
+		uint16_t data;
+		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
+		return data;
+	}
+	else {
+		return 0;
+		sif::error << "Comm Message: Invalid byte position" << std::endl;
+	}
+}
+
+CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
+	messageType messageType;
+	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
+	return messageType;
+}
+
+void CommunicationMessage::setMessageId(uint8_t messageId) {
+	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
+}
+
+uint8_t CommunicationMessage::getMessageId() const {
+	uint8_t messageId;
+	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
+	return messageId;
+}
+
+void CommunicationMessage::clearCommunicationMessage() {
+	messageType messageType = getMessageType();
+	switch(messageType) {
+	case(messageType::REPLY_DATA_IPC_STORE):
+	case(messageType::SEND_DATA_FROM_IPC_STORE): {
+		store_address_t storeId = getStoreId();
+		StorageManagerIF *ipcStore = objectManager->
+				get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(storeId);
+		}
+	}
+	/* NO BREAK falls through*/
+	default:
+		memset(getData(),0,4*sizeof(uint32_t));
+		break;
+	}
+}
+
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
index a31e270c..5b429d9a 100644
--- a/devicehandlers/CommunicationMessage.h
+++ b/devicehandlers/CommunicationMessage.h
@@ -1,173 +1,173 @@
-/**
- * @file CommunicationMessage.h
- *
- * @date 28.02.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include "../devicehandlers/CommunicationMessage.h"
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-/**
- * @brief Message type to send larger messages
- *
- * @details
- * Can be used to pass information like data pointers and
- * data sizes between communication tasks.
- *
- */
-class CommunicationMessage: public MessageQueueMessage {
-public:
-	enum messageType {
-		NONE,
-		SEND_DATA_FROM_POINTER,
-		SEND_DATA_FROM_IPC_STORE,
-		SEND_DATA_RAW,
-		REPLY_DATA_FROM_POINTER,
-		REPLY_DATA_IPC_STORE,
-		REPLY_DATA_RAW,
-		FAULTY,
-	};
-
-	//Add other messageIDs here if necessary.
-	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
-
-	CommunicationMessage();
-	virtual ~CommunicationMessage();
-
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-	messageType getMessageType() const;
-
-	/**
-	 * This is a unique ID which can be used to handle different kinds of messages.
-	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
-	 * (e.g. sensor values) and data stored in the IPC store.
-	 * The ID can be used to distinguish the messages in child implementations.
-	 * The message ID is stored as the sixth byte of the message data.
-	 * @param messageId
-	 */
-	void setMessageId(uint8_t messageId);
-	uint8_t getMessageId() const;
-
-	/**
-	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
-
-	/**
-	 * Send requests with a store ID, using the IPC store
-	 * @param address Target Address, first four bytes
-	 * @param storeId Store ID in the IPC store
-	 *
-	 */
-	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Send requests with data length and data in message (max. 4 bytes)
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length,
-			uint16_t sendBufferPosition = 0);
-
-	/**
-	 * Data message with data stored in IPC store
-	 * @param address Target Address, first four bytes
-	 * @param length
-	 * @param storeId
-	 */
-	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Data reply with data stored in buffer, passing the pointer to
-	 * the buffer and the data size
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to the data
-	 */
-	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
-
-	/**
-	 * Data message with data stored in actual message.
-	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions below.
-	 * Can also be used to supply information at which position the raw data should be stored
-	 * in a receive buffer.
-	 */
-	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(address_t address);
-
-	address_t getAddress() const;
-	/**
-	 * Set byte as position of 4 byte data field
-	 * @param byte
-	 * @param position Position, 0 to 3 possible
-	 */
-	void setDataByte(uint8_t byte, uint8_t position);
-	uint8_t getDataByte(uint8_t position) const;
-
-	/**
-	 * Set 2 byte value at position 1 or 2 of data field
-	 * @param data
-	 * @param position 0 or 1 possible
-	 */
-	void setDataUint16(uint16_t data, uint8_t position);
-	uint16_t getDataUint16(uint8_t position) const;
-
-	void setUint32Data(uint32_t data);
-	uint32_t getUint32Data() const;
-
-	/**
-	 * Stored in Bytes 13-16 of message data
-	 * @param length
-	 */
-	void setDataLen(uint32_t length);
-
-	uint32_t getDataLen() const;
-
-	/**
-	 * Stored in last four bytes (Bytes 17-20) of message data
-	 * @param sendData
-	 */
-	void setDataPointer(const void * data);
-
-	/**
-	 * In case the send request data or reply data is to be stored in a buffer,
-	 * a buffer Position can be stored here as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
-	 */
-	void setBufferPosition(uint16_t bufferPosition);
-	uint16_t getBufferPosition() const;
-	void setStoreId(store_address_t storeId);
-	store_address_t getStoreId() const;
-
-	/**
-	 * Clear the message. Deletes IPC Store data
-	 * and sets all data to 0. Also sets message type to NONE
-	 */
-	void clearCommunicationMessage();
-private:
-	bool uninitialized; //!< Could be used to warn if data has not been set.
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
+/**
+ * @file CommunicationMessage.h
+ *
+ * @date 28.02.2020
+ */
+
+#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
+#include "../devicehandlers/CommunicationMessage.h"
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerBase.h"
+
+/**
+ * @brief Message type to send larger messages
+ *
+ * @details
+ * Can be used to pass information like data pointers and
+ * data sizes between communication tasks.
+ *
+ */
+class CommunicationMessage: public MessageQueueMessage {
+public:
+	enum messageType {
+		NONE,
+		SEND_DATA_FROM_POINTER,
+		SEND_DATA_FROM_IPC_STORE,
+		SEND_DATA_RAW,
+		REPLY_DATA_FROM_POINTER,
+		REPLY_DATA_IPC_STORE,
+		REPLY_DATA_RAW,
+		FAULTY,
+	};
+
+	//Add other messageIDs here if necessary.
+	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
+
+	CommunicationMessage();
+	virtual ~CommunicationMessage();
+
+	/**
+	 * Message Type is stored as the fifth byte of the message data
+	 * @param status
+	 */
+	void setMessageType(messageType status);
+	messageType getMessageType() const;
+
+	/**
+	 * This is a unique ID which can be used to handle different kinds of messages.
+	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
+	 * (e.g. sensor values) and data stored in the IPC store.
+	 * The ID can be used to distinguish the messages in child implementations.
+	 * The message ID is stored as the sixth byte of the message data.
+	 * @param messageId
+	 */
+	void setMessageId(uint8_t messageId);
+	uint8_t getMessageId() const;
+
+	/**
+	 * Send requests with pointer to the data to be sent and send data length
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
+
+	/**
+	 * Send requests with a store ID, using the IPC store
+	 * @param address Target Address, first four bytes
+	 * @param storeId Store ID in the IPC store
+	 *
+	 */
+	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Send requests with data length and data in message (max. 4 bytes)
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to data to send
+	 *
+	 */
+	void setSendRequestRaw(uint32_t address, uint32_t length,
+			uint16_t sendBufferPosition = 0);
+
+	/**
+	 * Data message with data stored in IPC store
+	 * @param address Target Address, first four bytes
+	 * @param length
+	 * @param storeId
+	 */
+	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
+
+	/**
+	 * Data reply with data stored in buffer, passing the pointer to
+	 * the buffer and the data size
+	 * @param address Target Address, first four bytes
+	 * @param dataLen Length of data to send, next four bytes
+	 * @param data Pointer to the data
+	 */
+	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
+
+	/**
+	 * Data message with data stored in actual message.
+	 * 4 byte datafield is intialized with 0.
+	 * Set data with specific setter functions below.
+	 * Can also be used to supply information at which position the raw data should be stored
+	 * in a receive buffer.
+	 */
+	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
+
+	/**
+	 * First four bytes of message data
+	 * @param address
+	 */
+	void setAddress(address_t address);
+
+	address_t getAddress() const;
+	/**
+	 * Set byte as position of 4 byte data field
+	 * @param byte
+	 * @param position Position, 0 to 3 possible
+	 */
+	void setDataByte(uint8_t byte, uint8_t position);
+	uint8_t getDataByte(uint8_t position) const;
+
+	/**
+	 * Set 2 byte value at position 1 or 2 of data field
+	 * @param data
+	 * @param position 0 or 1 possible
+	 */
+	void setDataUint16(uint16_t data, uint8_t position);
+	uint16_t getDataUint16(uint8_t position) const;
+
+	void setUint32Data(uint32_t data);
+	uint32_t getUint32Data() const;
+
+	/**
+	 * Stored in Bytes 13-16 of message data
+	 * @param length
+	 */
+	void setDataLen(uint32_t length);
+
+	uint32_t getDataLen() const;
+
+	/**
+	 * Stored in last four bytes (Bytes 17-20) of message data
+	 * @param sendData
+	 */
+	void setDataPointer(const void * data);
+
+	/**
+	 * In case the send request data or reply data is to be stored in a buffer,
+	 * a buffer Position can be stored here as the seventh and eigth byte of
+	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
+	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
+	 */
+	void setBufferPosition(uint16_t bufferPosition);
+	uint16_t getBufferPosition() const;
+	void setStoreId(store_address_t storeId);
+	store_address_t getStoreId() const;
+
+	/**
+	 * Clear the message. Deletes IPC Store data
+	 * and sets all data to 0. Also sets message type to NONE
+	 */
+	void clearCommunicationMessage();
+private:
+	bool uninitialized; //!< Could be used to warn if data has not been set.
+};
+
+#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index cbff5411..db37eade 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,127 +1,127 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-
-#include "../devicehandlers/CookieIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- * @defgroup interfaces Interfaces
- * @brief Interfaces for flight software objects
- */
-
-/**
- * @defgroup comm Communication
- * @brief Communication software components.
- */
-
-/**
- * @brief This is an interface to decouple device communication from
- * the device handler to allow reuse of these components.
- * @details
- * Documentation: Dissertation Baetz p.138.
- * It works with the assumption that received data  is polled by a component.
- * There are four generic steps of device communication:
- *
- *   1. Send data to a device
- *   2. Get acknowledgement for sending
- *   3. Request reading data from a device
- *   4. Read received data
- *
- *  To identify different connection over a single interface can return
- *  so-called cookies to components.
- *  The CommunicationMessage message type can be used to extend the
- *  functionality of the ComIF if a separate polling task is required.
- *  @ingroup interfaces
- *  @ingroup comm
- */
-class DeviceCommunicationIF: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
-
-	//! This is returned in readReceivedMessage() if no reply was reived.
-	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
-
-	//! General protocol error. Define more concrete errors in child handler
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
-	//! If cookie is a null pointer
-	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
-	// is this needed if there is no open/close call?
-	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
-
-	virtual ~DeviceCommunicationIF() {}
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return
-	 *  - @c RETURN_OK if initialization was successfull
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len If this is 0, nothing shall be sent.
-	 * @return
-	 *  - @c RETURN_OK for successfull send
-	 *  - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie,
-	        const uint8_t * sendData, size_t sendLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return - @c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with
-	 * 		     returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
-	 * and communication specific action should be taken (e.g. read nothing
-	 * or read everything).
-	 *
-	 * @param cookie
-	 * @param requestLen Size of data to read
-	 * @return - @c RETURN_OK to confirm the request for data has been sent.
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) = 0;
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param buffer [out] Set reply here (by using *buffer = ...)
-	 * @param size [out] size pointer to set (by using *size = ...).
-	 * 	           Set to 0 if no reply was received
-	 * @return - @c RETURN_OK for successfull receive
-	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
-	 * 		   	   0 has the same effect
-	 *         - Everything else triggers failure event with
-	 *           returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-	        uint8_t **buffer, size_t *size) = 0;
-};
-
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ * @defgroup interfaces Interfaces
+ * @brief Interfaces for flight software objects
+ */
+
+/**
+ * @defgroup comm Communication
+ * @brief Communication software components.
+ */
+
+/**
+ * @brief This is an interface to decouple device communication from
+ * the device handler to allow reuse of these components.
+ * @details
+ * Documentation: Dissertation Baetz p.138.
+ * It works with the assumption that received data  is polled by a component.
+ * There are four generic steps of device communication:
+ *
+ *   1. Send data to a device
+ *   2. Get acknowledgement for sending
+ *   3. Request reading data from a device
+ *   4. Read received data
+ *
+ *  To identify different connection over a single interface can return
+ *  so-called cookies to components.
+ *  The CommunicationMessage message type can be used to extend the
+ *  functionality of the ComIF if a separate polling task is required.
+ *  @ingroup interfaces
+ *  @ingroup comm
+ */
+class DeviceCommunicationIF: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_COMMUNICATION_IF;
+
+	//! This is returned in readReceivedMessage() if no reply was reived.
+	static const ReturnValue_t NO_REPLY_RECEIVED = MAKE_RETURN_CODE(0x01);
+
+	//! General protocol error. Define more concrete errors in child handler
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0x02);
+	//! If cookie is a null pointer
+	static const ReturnValue_t NULLPOINTER = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_COOKIE_TYPE = MAKE_RETURN_CODE(0x04);
+	// is this needed if there is no open/close call?
+	static const ReturnValue_t NOT_ACTIVE = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TOO_MUCH_DATA = MAKE_RETURN_CODE(0x06);
+
+	virtual ~DeviceCommunicationIF() {}
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len If this is 0, nothing shall be sent.
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie,
+	        const uint8_t * sendData, size_t sendLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device. If a requestLen of 0 is supplied, no reply was enabled
+	 * and communication specific action should be taken (e.g. read nothing
+	 * or read everything).
+	 *
+	 * @param cookie
+	 * @param requestLen Size of data to read
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) = 0;
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param buffer [out] Set reply here (by using *buffer = ...)
+	 * @param size [out] size pointer to set (by using *size = ...).
+	 * 	           Set to 0 if no reply was received
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * 		   	   0 has the same effect
+	 *         - Everything else triggers failure event with
+	 *           returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+	        uint8_t **buffer, size_t *size) = 0;
+};
+
+#endif /* DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 67ab37f7..e3fa3b88 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,155 +1,155 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
-
-#include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../events/Event.h"
-#include "../modes/HasModesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * @brief 	This is the Interface used to communicate with a device handler.
- * @details Includes all expected return values, events and modes.
- *
- */
-class DeviceHandlerIF {
-public:
-
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
-
-	/**
-	 * @brief This is the mode the <strong>device handler</strong> is in.
-	 *
-	 * @details The mode of the device handler must not be confused with the mode the device is in.
-	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
-	 * MODE_ON and MODE_OFF are included in hasModesIF.h
-	 */
-
-	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	//! The device is powered on and the device handler periodically sends
-	//! commands. The commands to be sent are selected by the handler
-	//! according to the submode.
-	static const Mode_t MODE_NORMAL = 2;
-	//! The device is powered on and ready to perform operations. In this mode,
-	//! raw commands can be sent. The device handler will send all replies
-	//! received from the command back to the commanding object.
-	static const Mode_t MODE_RAW = 3;
-	//! The device is shut down but the switch could not be turned off, so the
-	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
-	//! can be commanded, which tries to switch off the device again.
-	static const Mode_t MODE_ERROR_ON = 4;
-	//! This is a transitional state which can not be commanded. The device
-	//! handler performs all commands to get the device in a state ready to
-	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
-	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
-	//! This is a transitional state which can not be commanded.
-	//! The device handler performs all actions and commands to get the device
-	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
-	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-	//! transition if available.
-	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
-	//! It is possible to set the mode to _MODE_TO_ON to use the to on
-	//! transition if available.
-	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
-	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
-	//! transition if available.
-	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
-	//! transition if available.
-	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-	//! This is a transitional state which can not be commanded.
-	//! The device is shut down and ready to be switched off.
-	//! After the command to set the switch off has been sent,
-	//! the mode changes to @c MODE_WAIT_OFF
-	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
-	//! This is a transitional state which can not be commanded. The device
-	//! will be switched on in this state. After the command to set the switch
-	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
-	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and the handler waits for it to be off.
-	//! When the switch is off, the mode changes to @c MODE_OFF.
-	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
-	//! This is a transitional state which can not be commanded. The switch
-	//! has been commanded on and the handler waits for it to be on.
-	//! When the switch is on, the mode changes to @c MODE_TO_ON.
-	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
-	//! This is a transitional state which can not be commanded. The switch has
-	//! been commanded off and is off now. This state is only to do an RMAP
-	//! cycle once more where the doSendRead() function will set the mode to
-	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
-	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
-
-	// Standard codes used when building commands.
-	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
-	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
-	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
-	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
-	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
-	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
-	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
-
-	// Standard codes used in scanForReply
-	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
-	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
-	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
-
-	// Standard codes used in  interpretDeviceReply
-	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
-	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
-	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
-
-	// Standard codes used in buildCommandFromCommand
-	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
-	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
-
-	/**
-	 * Communication action that will be executed.
-	 *
-	 * This is used by the child class to tell the base class what to do.
-	 */
-	enum CommunicationAction_t: uint8_t {
-		SEND_WRITE,//!< Send write
-		GET_WRITE, //!< Get write
-		SEND_READ, //!< Send read
-		GET_READ,  //!< Get read
-		NOTHING    //!< Do nothing.
-	};
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerIF() {}
-
-	/**
-	 * This MessageQueue is used to command the device handler.
-	 * @return the id of the MessageQueue
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-};
-
-#endif /* DEVICEHANDLERIF_H_ */
+#ifndef DEVICEHANDLERIF_H_
+#define DEVICEHANDLERIF_H_
+
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../events/Event.h"
+#include "../modes/HasModesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This is the Interface used to communicate with a device handler.
+ * @details Includes all expected return values, events and modes.
+ *
+ */
+class DeviceHandlerIF {
+public:
+
+	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+
+	/**
+	 * @brief This is the mode the <strong>device handler</strong> is in.
+	 *
+	 * @details The mode of the device handler must not be confused with the mode the device is in.
+	 * The mode of the device itself is transparent to the user but related to the mode of the handler.
+	 * MODE_ON and MODE_OFF are included in hasModesIF.h
+	 */
+
+	// MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	// MODE_OFF = 1, //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	//! The device is powered on and the device handler periodically sends
+	//! commands. The commands to be sent are selected by the handler
+	//! according to the submode.
+	static const Mode_t MODE_NORMAL = 2;
+	//! The device is powered on and ready to perform operations. In this mode,
+	//! raw commands can be sent. The device handler will send all replies
+	//! received from the command back to the commanding object.
+	static const Mode_t MODE_RAW = 3;
+	//! The device is shut down but the switch could not be turned off, so the
+	//! device still is powered. In this mode, only a mode change to @c MODE_OFF
+	//! can be commanded, which tries to switch off the device again.
+	static const Mode_t MODE_ERROR_ON = 4;
+	//! This is a transitional state which can not be commanded. The device
+	//! handler performs all commands to get the device in a state ready to
+	//! perform commands. When this is completed, the mode changes to @c MODE_ON.
+	static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+	//! This is a transitional state which can not be commanded.
+	//! The device handler performs all actions and commands to get the device
+	//! shut down. When the device is off, the mode changes to @c MODE_OFF.
+	//! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+	//! transition if available.
+	static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+	//! It is possible to set the mode to _MODE_TO_ON to use the to on
+	//! transition if available.
+	static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+	//! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+	//! transition if available.
+	static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+	//! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+	//! transition if available.
+	static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+	//! This is a transitional state which can not be commanded.
+	//! The device is shut down and ready to be switched off.
+	//! After the command to set the switch off has been sent,
+	//! the mode changes to @c MODE_WAIT_OFF
+	static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+	//! This is a transitional state which can not be commanded. The device
+	//! will be switched on in this state. After the command to set the switch
+	//! on has been sent, the mode changes to @c MODE_WAIT_ON.
+	static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and the handler waits for it to be off.
+	//! When the switch is off, the mode changes to @c MODE_OFF.
+	static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+	//! This is a transitional state which can not be commanded. The switch
+	//! has been commanded on and the handler waits for it to be on.
+	//! When the switch is on, the mode changes to @c MODE_TO_ON.
+	static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+	//! This is a transitional state which can not be commanded. The switch has
+	//! been commanded off and is off now. This state is only to do an RMAP
+	//! cycle once more where the doSendRead() function will set the mode to
+	//! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
+
+	// Standard codes used when building commands.
+	static const ReturnValue_t NO_COMMAND_DATA = MAKE_RETURN_CODE(0xA0); //!< If no command data was given when expected.
+	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1); //!< Command ID not in commandMap. Checked in DHB
+	static const ReturnValue_t COMMAND_ALREADY_SENT = MAKE_RETURN_CODE(0xA2); //!< Command was already executed. Checked in DHB
+	static const ReturnValue_t COMMAND_WAS_NOT_SENT = MAKE_RETURN_CODE(0xA3);
+	static const ReturnValue_t CANT_SWITCH_ADDRESS = MAKE_RETURN_CODE(0xA4);
+	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
+	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
+	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
+
+	// Standard codes used in scanForReply
+	static const ReturnValue_t CHECKSUM_ERROR = MAKE_RETURN_CODE(0xB0);
+	static const ReturnValue_t LENGTH_MISSMATCH = MAKE_RETURN_CODE(0xB1);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(0xB2);
+	static const ReturnValue_t PROTOCOL_ERROR = MAKE_RETURN_CODE(0xB3);
+
+	// Standard codes used in  interpretDeviceReply
+	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
+	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
+	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
+
+	// Standard codes used in buildCommandFromCommand
+	static const ReturnValue_t INVALID_COMMAND_PARAMETER = MAKE_RETURN_CODE(0xD0);
+	static const ReturnValue_t INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS = MAKE_RETURN_CODE(0xD1);
+
+	/**
+	 * Communication action that will be executed.
+	 *
+	 * This is used by the child class to tell the base class what to do.
+	 */
+	enum CommunicationAction_t: uint8_t {
+		SEND_WRITE,//!< Send write
+		GET_WRITE, //!< Get write
+		SEND_READ, //!< Send read
+		GET_READ,  //!< Get read
+		NOTHING    //!< Do nothing.
+	};
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerIF() {}
+
+	/**
+	 * This MessageQueue is used to command the device handler.
+	 * @return the id of the MessageQueue
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+};
+
+#endif /* DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index 95e5ae0c..b4963dbf 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,101 +1,101 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
-
-store_address_t DeviceHandlerMessage::getStoreAddress(
-		const CommandMessage* message) {
-	return store_address_t(message->getParameter2());
-}
-
-uint32_t DeviceHandlerMessage::getDeviceCommandId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-object_id_t DeviceHandlerMessage::getIoBoardObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-uint8_t DeviceHandlerMessage::getWiretappingMode(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
-void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
-		CommandMessage* message, store_address_t rawPacketStoreId) {
-	message->setCommand(CMD_RAW);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
-		CommandMessage* message, uint8_t wiretappingMode) {
-	message->setCommand(CMD_WIRETAPPING);
-	message->setParameter(wiretappingMode);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
-		CommandMessage* message, uint32_t ioBoardIdentifier) {
-	message->setCommand(CMD_SWITCH_ADDRESS);
-	message->setParameter(ioBoardIdentifier);
-}
-
-object_id_t DeviceHandlerMessage::getDeviceObjectId(
-		const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t rawPacketStoreId, bool isCommand) {
-	if (isCommand) {
-		message->setCommand(REPLY_RAW_COMMAND);
-	} else {
-		message->setCommand(REPLY_RAW_REPLY);
-	}
-	message->setParameter(deviceObjectid);
-	message->setParameter2(rawPacketStoreId.raw);
-}
-
-void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
-		CommandMessage* message, object_id_t deviceObjectid,
-		store_address_t commandParametersStoreId) {
-	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
-	message->setParameter(deviceObjectid);
-	message->setParameter2(commandParametersStoreId.raw);
-}
-
-void DeviceHandlerMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_RAW:
-//	case CMD_DIRECT:
-	case REPLY_RAW_COMMAND:
-	case REPLY_RAW_REPLY:
-	case REPLY_DIRECT_COMMAND_DATA: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreAddress(message));
-		}
-	}
-		/* NO BREAK falls through*/
-	case CMD_SWITCH_ADDRESS:
-	case CMD_WIRETAPPING:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+DeviceHandlerMessage::DeviceHandlerMessage() {
+}
+
+store_address_t DeviceHandlerMessage::getStoreAddress(
+		const CommandMessage* message) {
+	return store_address_t(message->getParameter2());
+}
+
+uint32_t DeviceHandlerMessage::getDeviceCommandId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+object_id_t DeviceHandlerMessage::getIoBoardObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+uint8_t DeviceHandlerMessage::getWiretappingMode(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
+//		CommandMessage* message, DeviceCommandId_t deviceCommand,
+//		store_address_t commandParametersStoreId) {
+//	message->setCommand(CMD_DIRECT);
+//	message->setParameter(deviceCommand);
+//	message->setParameter2(commandParametersStoreId.raw);
+//}
+
+void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
+		CommandMessage* message, store_address_t rawPacketStoreId) {
+	message->setCommand(CMD_RAW);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(
+		CommandMessage* message, uint8_t wiretappingMode) {
+	message->setCommand(CMD_WIRETAPPING);
+	message->setParameter(wiretappingMode);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerSwitchIoBoardMessage(
+		CommandMessage* message, uint32_t ioBoardIdentifier) {
+	message->setCommand(CMD_SWITCH_ADDRESS);
+	message->setParameter(ioBoardIdentifier);
+}
+
+object_id_t DeviceHandlerMessage::getDeviceObjectId(
+		const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void DeviceHandlerMessage::setDeviceHandlerRawReplyMessage(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t rawPacketStoreId, bool isCommand) {
+	if (isCommand) {
+		message->setCommand(REPLY_RAW_COMMAND);
+	} else {
+		message->setCommand(REPLY_RAW_REPLY);
+	}
+	message->setParameter(deviceObjectid);
+	message->setParameter2(rawPacketStoreId.raw);
+}
+
+void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
+		CommandMessage* message, object_id_t deviceObjectid,
+		store_address_t commandParametersStoreId) {
+	message->setCommand(REPLY_DIRECT_COMMAND_DATA);
+	message->setParameter(deviceObjectid);
+	message->setParameter2(commandParametersStoreId.raw);
+}
+
+void DeviceHandlerMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_RAW:
+//	case CMD_DIRECT:
+	case REPLY_RAW_COMMAND:
+	case REPLY_RAW_REPLY:
+	case REPLY_DIRECT_COMMAND_DATA: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreAddress(message));
+		}
+	}
+		/* NO BREAK falls through*/
+	case CMD_SWITCH_ADDRESS:
+	case CMD_WIRETAPPING:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 6b54392b..5f4583d2 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,91 +1,91 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
-
-#include "../action/ActionMessage.h"
-#include "../ipc/CommandMessage.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
-
-/**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
- */
-class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
-public:
-
-	/**
-	 * These are the commands that can be sent to a DeviceHandlerBase
-	 */
-	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
-//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
-
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
-	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
-
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
-	static store_address_t getStoreAddress(const CommandMessage* message);
-	static uint32_t getDeviceCommandId(const CommandMessage* message);
-	static object_id_t getDeviceObjectId(const CommandMessage *message);
-	static object_id_t getIoBoardObjectId(const CommandMessage* message);
-	static uint8_t getWiretappingMode(const CommandMessage* message);
-
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
-			object_id_t deviceObjectid,
-			store_address_t commandParametersStoreId);
-
-	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
-			store_address_t rawPacketStoreId);
-
-	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
-			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
-			bool isCommand);
-
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
-	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
-			uint8_t wiretappingMode);
-	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
-			object_id_t ioBoardIdentifier);
-
-	static void clear(CommandMessage* message);
-};
-
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#ifndef DEVICEHANDLERMESSAGE_H_
+#define DEVICEHANDLERMESSAGE_H_
+
+#include "../action/ActionMessage.h"
+#include "../ipc/CommandMessage.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ *
+ * The values are defined in the device-specific implementations
+ */
+typedef uint32_t DeviceCommandId_t;
+
+/**
+ * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ */
+class DeviceHandlerMessage {
+private:
+	DeviceHandlerMessage();
+public:
+
+	/**
+	 * These are the commands that can be sent to a DeviceHandlerBase
+	 */
+	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
+//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+
+	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
+	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
+	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
+
+	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
+	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
+
+	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
+	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
+	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
+	 */
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
+
+	/**
+	 * Default Destructor
+	 */
+	virtual ~DeviceHandlerMessage() {
+	}
+
+	static store_address_t getStoreAddress(const CommandMessage* message);
+	static uint32_t getDeviceCommandId(const CommandMessage* message);
+	static object_id_t getDeviceObjectId(const CommandMessage *message);
+	static object_id_t getIoBoardObjectId(const CommandMessage* message);
+	static uint8_t getWiretappingMode(const CommandMessage* message);
+
+//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
+//			DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
+			object_id_t deviceObjectid,
+			store_address_t commandParametersStoreId);
+
+	static void setDeviceHandlerRawCommandMessage(CommandMessage* message,
+			store_address_t rawPacketStoreId);
+
+	static void setDeviceHandlerRawReplyMessage(CommandMessage* message,
+			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
+			bool isCommand);
+
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, DeviceCommandId_t deviceCommand,
+//			store_address_t commandParametersStoreId);
+//	static void setDeviceHandlerMessage(CommandMessage* message,
+//			Command_t command, store_address_t rawPacketStoreId);
+	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
+			uint8_t wiretappingMode);
+	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
+			object_id_t ioBoardIdentifier);
+
+	static void clear(CommandMessage* message);
+};
+
+#endif /* DEVICEHANDLERMESSAGE_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index f19b02e9..25d8932f 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,46 +1,46 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
-#include "../serialize/SerializeAdapter.h"
-
-DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
-		ActionId_t actionId, SerializeIF* data) :
-		objectId(objectId), actionId(actionId), data(data) {
-}
-
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
-
-}
-
-ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&actionId, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->serialize(buffer, size, maxSize, streamEndianness);
-}
-
-size_t DeviceTmReportingWrapper::getSerializedSize() const {
-	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
-}
-
-ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&actionId, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return data->deSerialize(buffer, size, streamEndianness);
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "../serialize/SerializeAdapter.h"
+
+DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
+		ActionId_t actionId, SerializeIF* data) :
+		objectId(objectId), actionId(actionId), data(data) {
+}
+
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
+
+}
+
+ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&objectId,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&actionId, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->serialize(buffer, size, maxSize, streamEndianness);
+}
+
+size_t DeviceTmReportingWrapper::getSerializedSize() const {
+	return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
+}
+
+ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&actionId, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return data->deSerialize(buffer, size, streamEndianness);
+}
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index ecf7089a..a14c4261 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,27 +1,27 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
-
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../serialize/SerializeIF.h"
-
-class DeviceTmReportingWrapper: public SerializeIF {
-public:
-	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-			SerializeIF *data);
-	virtual ~DeviceTmReportingWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-private:
-	object_id_t objectId;
-	ActionId_t actionId;
-	SerializeIF *data;
-};
-
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#ifndef DEVICETMREPORTINGWRAPPER_H_
+#define DEVICETMREPORTINGWRAPPER_H_
+
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"
+
+class DeviceTmReportingWrapper: public SerializeIF {
+public:
+	DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
+			SerializeIF *data);
+	virtual ~DeviceTmReportingWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+private:
+	object_id_t objectId;
+	ActionId_t actionId;
+	SerializeIF *data;
+};
+
+#endif /* DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index de7e4d8c..666f86bb 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,59 +1,59 @@
-#include "../devicehandlers/HealthDevice.h"
-#include "../ipc/QueueFactory.h"
-
-HealthDevice::HealthDevice(object_id_t setObjectId,
-		MessageQueueId_t parentQueue) :
-		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
-				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
-}
-
-HealthDevice::~HealthDevice() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		healthHelper.handleHealthCommand(&command);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t HealthDevice::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (parentQueue != 0) {
-		return healthHelper.initialize(parentQueue);
-	} else {
-		return healthHelper.initialize();
-	}
-}
-
-MessageQueueId_t HealthDevice::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQueue(parentQueue);
-}
-
-bool HealthDevice::hasHealthChanged() {
-	bool changed;
-	HealthState currentHealth = healthHelper.getHealth();
-	changed = currentHealth != lastHealth;
-	lastHealth = currentHealth;
-	return changed;
-}
-
-ReturnValue_t HealthDevice::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState HealthDevice::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "../devicehandlers/HealthDevice.h"
+#include "../ipc/QueueFactory.h"
+
+HealthDevice::HealthDevice(object_id_t setObjectId,
+		MessageQueueId_t parentQueue) :
+		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
+				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+}
+
+HealthDevice::~HealthDevice() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		healthHelper.handleHealthCommand(&command);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t HealthDevice::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (parentQueue != 0) {
+		return healthHelper.initialize(parentQueue);
+	} else {
+		return healthHelper.initialize();
+	}
+}
+
+MessageQueueId_t HealthDevice::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
+	healthHelper.setParentQueue(parentQueue);
+}
+
+bool HealthDevice::hasHealthChanged() {
+	bool changed;
+	HealthState currentHealth = healthHelper.getHealth();
+	changed = currentHealth != lastHealth;
+	lastHealth = currentHealth;
+	return changed;
+}
+
+ReturnValue_t HealthDevice::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState HealthDevice::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index fb38584e..53b0ab09 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,40 +1,40 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class HealthDevice: public SystemObject,
-		public ExecutableObjectIF,
-		public HasHealthIF {
-public:
-	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
-	virtual ~HealthDevice();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	bool hasHealthChanged();
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HealthState getHealth();
-
-protected:
-	HealthState lastHealth;
-
-	MessageQueueId_t parentQueue;
-	MessageQueueIF* commandQueue;
-public:
-	HealthHelper healthHelper;
-};
-
-#endif /* HEALTHDEVICE_H_ */
+#ifndef HEALTHDEVICE_H_
+#define HEALTHDEVICE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class HealthDevice: public SystemObject,
+		public ExecutableObjectIF,
+		public HasHealthIF {
+public:
+	HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue);
+	virtual ~HealthDevice();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	bool hasHealthChanged();
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HealthState getHealth();
+
+protected:
+	HealthState lastHealth;
+
+	MessageQueueId_t parentQueue;
+	MessageQueueIF* commandQueue;
+public:
+	HealthHelper healthHelper;
+};
+
+#endif /* HEALTHDEVICE_H_ */
diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 1896d24a..6cb2c47d 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -1,20 +1,20 @@
-#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-// TODO: Documentation.
-class ConfirmsFailuresIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
-	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
-	virtual ~ConfirmsFailuresIF() {}
-	virtual MessageQueueId_t getEventReceptionQueue() = 0;
-};
-
-
-
-#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
+#ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+#define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+// TODO: Documentation.
+class ConfirmsFailuresIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
+	static const ReturnValue_t YOUR_FAULT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t MY_FAULT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t CONFIRM_LATER = MAKE_RETURN_CODE(2);
+	virtual ~ConfirmsFailuresIF() {}
+	virtual MessageQueueId_t getEventReceptionQueue() = 0;
+};
+
+
+
+#endif /* FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ */
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index dea6a569..f98d2223 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,44 +1,44 @@
-#include "../fdir/EventCorrelation.h"
-
-EventCorrelation::EventCorrelation(uint32_t timeout) :
-		eventPending(false) {
-	correlationTimer.setTimeout(timeout);
-}
-
-EventCorrelation::~EventCorrelation() {
-}
-
-EventCorrelation::State EventCorrelation::doesEventCorrelate() {
-	if (correlationTimer.isBusy()) {
-		eventPending = false;
-		return CORRELATED;
-	} else {
-		if (eventPending) {
-			return ALREADY_STARTED;
-		} else {
-			eventPending = true;
-			correlationTimer.resetTimer();
-			return CORRELATION_STARTED;
-		}
-	}
-}
-
-bool EventCorrelation::isEventPending() {
-	if (eventPending) {
-		eventPending = false;
-		return true;
-	} else {
-		correlationTimer.resetTimer();
-		return false;
-	}
-}
-
-bool EventCorrelation::hasPendingEventTimedOut() {
-	if (correlationTimer.hasTimedOut()) {
-		bool temp = eventPending;
-		eventPending = false;
-		return temp;
-	} else {
-		return false;
-	}
-}
+#include "../fdir/EventCorrelation.h"
+
+EventCorrelation::EventCorrelation(uint32_t timeout) :
+		eventPending(false) {
+	correlationTimer.setTimeout(timeout);
+}
+
+EventCorrelation::~EventCorrelation() {
+}
+
+EventCorrelation::State EventCorrelation::doesEventCorrelate() {
+	if (correlationTimer.isBusy()) {
+		eventPending = false;
+		return CORRELATED;
+	} else {
+		if (eventPending) {
+			return ALREADY_STARTED;
+		} else {
+			eventPending = true;
+			correlationTimer.resetTimer();
+			return CORRELATION_STARTED;
+		}
+	}
+}
+
+bool EventCorrelation::isEventPending() {
+	if (eventPending) {
+		eventPending = false;
+		return true;
+	} else {
+		correlationTimer.resetTimer();
+		return false;
+	}
+}
+
+bool EventCorrelation::hasPendingEventTimedOut() {
+	if (correlationTimer.hasTimedOut()) {
+		bool temp = eventPending;
+		eventPending = false;
+		return temp;
+	} else {
+		return false;
+	}
+}
diff --git a/fdir/EventCorrelation.h b/fdir/EventCorrelation.h
index bbfe92c1..b8793edf 100644
--- a/fdir/EventCorrelation.h
+++ b/fdir/EventCorrelation.h
@@ -1,23 +1,23 @@
-#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
-#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
-
-#include "../timemanager/Countdown.h"
-
-class EventCorrelation {
-public:
-	enum State {
-		CORRELATION_STARTED,
-		CORRELATED,
-		ALREADY_STARTED
-	};
-	EventCorrelation(uint32_t timeout);
-	~EventCorrelation();
-	EventCorrelation::State doesEventCorrelate();
-	bool isEventPending();
-	bool hasPendingEventTimedOut();
-	Countdown correlationTimer;
-private:
-	bool eventPending;
-};
-
-#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
+#ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_
+#define FRAMEWORK_FDIR_EVENTCORRELATION_H_
+
+#include "../timemanager/Countdown.h"
+
+class EventCorrelation {
+public:
+	enum State {
+		CORRELATION_STARTED,
+		CORRELATED,
+		ALREADY_STARTED
+	};
+	EventCorrelation(uint32_t timeout);
+	~EventCorrelation();
+	EventCorrelation::State doesEventCorrelate();
+	bool isEventPending();
+	bool hasPendingEventTimedOut();
+	Countdown correlationTimer;
+private:
+	bool eventPending;
+};
+
+#endif /* FRAMEWORK_FDIR_EVENTCORRELATION_H_ */
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index b9994dc3..ab462a97 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,164 +1,164 @@
-#include "../events/EventManagerIF.h"
-#include "../fdir/FailureIsolationBase.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-FailureIsolationBase::FailureIsolationBase(object_id_t owner,
-		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
-		ownerId(owner), faultTreeParent(parent),
-		parameterDomainBase(parameterDomainBase) {
-	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
-			EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-FailureIsolationBase::~FailureIsolationBase() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t FailureIsolationBase::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == nullptr) {
-		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
-				" been initialized!" << std::endl;
-		return RETURN_FAILED;
-	}
-	ReturnValue_t result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (ownerId != objects::NO_OBJECT) {
-		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		owner = objectManager->get<HasHealthIF>(ownerId);
-		if (owner == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Owner object "
-					"invalid. Make sure it implements HasHealthIF" << std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-		}
-	}
-	if (faultTreeParent != objects::NO_OBJECT) {
-		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
-				faultTreeParent);
-		if (parentIF == nullptr) {
-			sif::error << "FailureIsolationBase::intialize: Parent object"
-					<< "invalid." << std::endl;
-			sif::error << "Make sure it implements ConfirmsFailuresIF."
-					<< std::endl;
-			return ObjectManagerIF::CHILD_INIT_FAILED;
-			return RETURN_FAILED;
-		}
-		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
-	}
-	return RETURN_OK;
-}
-
-void FailureIsolationBase::checkForFailures() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
-		if (event.getSender() == eventQueue->getId()) {
-			//We already got this event, because we sent it.
-			continue;
-		}
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			if (isFdirDisabledForSeverity(event.getSeverity())) {
-				//We do not handle events when disabled.
-				continue;
-			}
-			eventReceived(&event);
-			break;
-		case EventMessage::CONFIRMATION_REQUEST:
-			doConfirmFault(&event);
-			break;
-		case EventMessage::YOUR_FAULT:
-			eventConfirmed(&event);
-			break;
-		case EventMessage::MY_FAULT:
-			wasParentsFault(&event);
-			break;
-		default:
-			break;
-		}
-	}
-	decrementFaultCounters();
-}
-
-void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
-	if (owner != NULL) {
-		owner->setHealth(health);
-	}
-	//else: owner has no health.
-
-}
-
-MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
-	return eventQueue->getId();
-}
-
-ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
-		MessageQueueId_t destination) {
-	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
-	if (destination != MessageQueueIF::NO_QUEUE) {
-		return eventQueue->sendMessage(destination, event);
-	} else if (faultTreeParent != objects::NO_OBJECT) {
-		return eventQueue->sendToDefault(event);
-	}
-	return RETURN_FAILED;
-}
-
-void FailureIsolationBase::eventConfirmed(EventMessage* event) {
-}
-
-void FailureIsolationBase::wasParentsFault(EventMessage* event) {
-}
-
-void FailureIsolationBase::doConfirmFault(EventMessage* event) {
-	ReturnValue_t result = confirmFault(event);
-	if (result == YOUR_FAULT) {
-		event->setMessageId(EventMessage::YOUR_FAULT);
-		eventQueue->reply(event);
-	} else if (result == MY_FAULT) {
-		event->setMessageId(EventMessage::MY_FAULT);
-		eventQueue->reply(event);
-	} else {
-
-	}
-}
-
-ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
-	return YOUR_FAULT;
-}
-
-void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	//With this mechanism, all events are disabled for a certain device.
-	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
-		return;
-	}
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-	eventReceived(&message);
-}
-
-bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
-		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
-			//External control disables handling of fault messages.
-			return true;
-		}
-	}
-	return false;
-}
-
-void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventMessage message(event, ownerId, parameter1, parameter2);
-	EventManagerIF::triggerEvent(&message, eventQueue->getId());
-}
+#include "../events/EventManagerIF.h"
+#include "../fdir/FailureIsolationBase.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+FailureIsolationBase::FailureIsolationBase(object_id_t owner,
+		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
+		ownerId(owner), faultTreeParent(parent),
+		parameterDomainBase(parameterDomainBase) {
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+			EventMessage::EVENT_MESSAGE_SIZE);
+}
+
+FailureIsolationBase::~FailureIsolationBase() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t FailureIsolationBase::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == nullptr) {
+		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
+				" been initialized!" << std::endl;
+		return RETURN_FAILED;
+	}
+	ReturnValue_t result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (ownerId != objects::NO_OBJECT) {
+		result = manager->subscribeToAllEventsFrom(eventQueue->getId(), ownerId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		owner = objectManager->get<HasHealthIF>(ownerId);
+		if (owner == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Owner object "
+					"invalid. Make sure it implements HasHealthIF" << std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+		}
+	}
+	if (faultTreeParent != objects::NO_OBJECT) {
+		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+				faultTreeParent);
+		if (parentIF == nullptr) {
+			sif::error << "FailureIsolationBase::intialize: Parent object"
+					<< "invalid." << std::endl;
+			sif::error << "Make sure it implements ConfirmsFailuresIF."
+					<< std::endl;
+			return ObjectManagerIF::CHILD_INIT_FAILED;
+			return RETURN_FAILED;
+		}
+		eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
+	}
+	return RETURN_OK;
+}
+
+void FailureIsolationBase::checkForFailures() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == RETURN_OK; result = eventQueue->receiveMessage(&event)) {
+		if (event.getSender() == eventQueue->getId()) {
+			//We already got this event, because we sent it.
+			continue;
+		}
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			if (isFdirDisabledForSeverity(event.getSeverity())) {
+				//We do not handle events when disabled.
+				continue;
+			}
+			eventReceived(&event);
+			break;
+		case EventMessage::CONFIRMATION_REQUEST:
+			doConfirmFault(&event);
+			break;
+		case EventMessage::YOUR_FAULT:
+			eventConfirmed(&event);
+			break;
+		case EventMessage::MY_FAULT:
+			wasParentsFault(&event);
+			break;
+		default:
+			break;
+		}
+	}
+	decrementFaultCounters();
+}
+
+void FailureIsolationBase::setOwnerHealth(HasHealthIF::HealthState health) {
+	if (owner != NULL) {
+		owner->setHealth(health);
+	}
+	//else: owner has no health.
+
+}
+
+MessageQueueId_t FailureIsolationBase::getEventReceptionQueue() {
+	return eventQueue->getId();
+}
+
+ReturnValue_t FailureIsolationBase::sendConfirmationRequest(EventMessage* event,
+		MessageQueueId_t destination) {
+	event->setMessageId(EventMessage::CONFIRMATION_REQUEST);
+	if (destination != MessageQueueIF::NO_QUEUE) {
+		return eventQueue->sendMessage(destination, event);
+	} else if (faultTreeParent != objects::NO_OBJECT) {
+		return eventQueue->sendToDefault(event);
+	}
+	return RETURN_FAILED;
+}
+
+void FailureIsolationBase::eventConfirmed(EventMessage* event) {
+}
+
+void FailureIsolationBase::wasParentsFault(EventMessage* event) {
+}
+
+void FailureIsolationBase::doConfirmFault(EventMessage* event) {
+	ReturnValue_t result = confirmFault(event);
+	if (result == YOUR_FAULT) {
+		event->setMessageId(EventMessage::YOUR_FAULT);
+		eventQueue->reply(event);
+	} else if (result == MY_FAULT) {
+		event->setMessageId(EventMessage::MY_FAULT);
+		eventQueue->reply(event);
+	} else {
+
+	}
+}
+
+ReturnValue_t FailureIsolationBase::confirmFault(EventMessage* event) {
+	return YOUR_FAULT;
+}
+
+void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	//With this mechanism, all events are disabled for a certain device.
+	//That's not so good for visibility.
+	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+		return;
+	}
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+	eventReceived(&message);
+}
+
+bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
+	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
+			//External control disables handling of fault messages.
+			return true;
+		}
+	}
+	return false;
+}
+
+void FailureIsolationBase::throwFdirEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventMessage message(event, ownerId, parameter1, parameter2);
+	EventManagerIF::triggerEvent(&message, eventQueue->getId());
+}
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index b2735e6d..f8a307b3 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -1,56 +1,56 @@
-#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
-
-#include "../events/EventMessage.h"
-#include "../fdir/ConfirmsFailuresIF.h"
-#include "../fdir/FaultCounter.h"
-#include "../health/HealthMessage.h"
-#include "../parameters/HasParametersIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class FailureIsolationBase: public HasReturnvaluesIF,
-		public ConfirmsFailuresIF,
-		public HasParametersIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
-	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
-
-	FailureIsolationBase(object_id_t owner,
-			object_id_t parent = objects::NO_OBJECT,
-			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
-
-	virtual ~FailureIsolationBase();
-	virtual ReturnValue_t initialize();
-
-	/**
-	 * This is called by the DHB in performOperation()
-	 */
-	void checkForFailures();
-	MessageQueueId_t getEventReceptionQueue() override;
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-protected:
-	MessageQueueIF* eventQueue = nullptr;
-	object_id_t ownerId;
-	HasHealthIF* owner = nullptr;
-	object_id_t faultTreeParent;
-	uint8_t parameterDomainBase;
-	void setOwnerHealth(HasHealthIF::HealthState health);
-	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
-	virtual void eventConfirmed(EventMessage* event);
-	virtual void wasParentsFault(EventMessage* event);
-	virtual ReturnValue_t confirmFault(EventMessage* event);
-	virtual void decrementFaultCounters() = 0;
-	ReturnValue_t sendConfirmationRequest(EventMessage* event,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0);
-private:
-	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
-			EventSeverity_t severity);
-};
-
-#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
+#ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+#define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
+
+#include "../events/EventMessage.h"
+#include "../fdir/ConfirmsFailuresIF.h"
+#include "../fdir/FaultCounter.h"
+#include "../health/HealthMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class FailureIsolationBase: public HasReturnvaluesIF,
+		public ConfirmsFailuresIF,
+		public HasParametersIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
+	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
+	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
+	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
+
+	FailureIsolationBase(object_id_t owner,
+			object_id_t parent = objects::NO_OBJECT,
+			uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
+
+	virtual ~FailureIsolationBase();
+	virtual ReturnValue_t initialize();
+
+	/**
+	 * This is called by the DHB in performOperation()
+	 */
+	void checkForFailures();
+	MessageQueueId_t getEventReceptionQueue() override;
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+protected:
+	MessageQueueIF* eventQueue = nullptr;
+	object_id_t ownerId;
+	HasHealthIF* owner = nullptr;
+	object_id_t faultTreeParent;
+	uint8_t parameterDomainBase;
+	void setOwnerHealth(HasHealthIF::HealthState health);
+	virtual ReturnValue_t eventReceived(EventMessage* event) = 0;
+	virtual void eventConfirmed(EventMessage* event);
+	virtual void wasParentsFault(EventMessage* event);
+	virtual ReturnValue_t confirmFault(EventMessage* event);
+	virtual void decrementFaultCounters() = 0;
+	ReturnValue_t sendConfirmationRequest(EventMessage* event,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+	void throwFdirEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
+private:
+	void doConfirmFault(EventMessage* event);bool isFdirDisabledForSeverity(
+			EventSeverity_t severity);
+};
+
+#endif /* FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ */
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 674d278a..b75bd48f 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,86 +1,86 @@
-#include "../fdir/FaultCounter.h"
-
-FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-		uint8_t setParameterDomain) :
-		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
-				failureThreshold) {
-	timer.setTimeout(decrementAfterMs);
-}
-
-FaultCounter::~FaultCounter() {
-}
-
-void FaultCounter::increment(uint32_t amount) {
-	if (faultCount == 0) {
-		timer.resetTimer();
-	}
-	faultCount += amount;
-}
-
-bool FaultCounter::checkForDecrement() {
-	if (timer.hasTimedOut()) {
-		timer.resetTimer();
-		if (faultCount > 0) {
-			faultCount--;
-			return true;
-		}
-	}
-	return false;
-}
-
-bool FaultCounter::incrementAndCheck(uint32_t amount) {
-	increment(amount);
-	return aboveThreshold();
-}
-
-bool FaultCounter::aboveThreshold() {
-	if (faultCount > failureThreshold) {
-		faultCount = 0;
-		return true;
-	} else {
-		return false;
-	}
-}
-
-void FaultCounter::clear() {
-	faultCount = 0;
-}
-
-void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
-	this->failureThreshold = failureThreshold;
-}
-
-void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
-	timer.setTimeout(timeMs);
-}
-
-FaultCounter::FaultCounter() :
-		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
-}
-
-ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != parameterDomain) {
-		return INVALID_DOMAIN_ID;
-	}
-
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(failureThreshold);
-		break;
-	case 1:
-		parameterWrapper->set(faultCount);
-		break;
-	case 2:
-		parameterWrapper->set(timer.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FaultCounter::setParameterDomain(uint8_t domain) {
-	parameterDomain = domain;
-}
+#include "../fdir/FaultCounter.h"
+
+FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+		uint8_t setParameterDomain) :
+		parameterDomain(setParameterDomain), timer(), faultCount(0), failureThreshold(
+				failureThreshold) {
+	timer.setTimeout(decrementAfterMs);
+}
+
+FaultCounter::~FaultCounter() {
+}
+
+void FaultCounter::increment(uint32_t amount) {
+	if (faultCount == 0) {
+		timer.resetTimer();
+	}
+	faultCount += amount;
+}
+
+bool FaultCounter::checkForDecrement() {
+	if (timer.hasTimedOut()) {
+		timer.resetTimer();
+		if (faultCount > 0) {
+			faultCount--;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool FaultCounter::incrementAndCheck(uint32_t amount) {
+	increment(amount);
+	return aboveThreshold();
+}
+
+bool FaultCounter::aboveThreshold() {
+	if (faultCount > failureThreshold) {
+		faultCount = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void FaultCounter::clear() {
+	faultCount = 0;
+}
+
+void FaultCounter::setFailureThreshold(uint32_t failureThreshold) {
+	this->failureThreshold = failureThreshold;
+}
+
+void FaultCounter::setFaultDecrementTimeMs(uint32_t timeMs) {
+	timer.setTimeout(timeMs);
+}
+
+FaultCounter::FaultCounter() :
+		parameterDomain(0), timer(), faultCount(0), failureThreshold(0) {
+}
+
+ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != parameterDomain) {
+		return INVALID_DOMAIN_ID;
+	}
+
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(failureThreshold);
+		break;
+	case 1:
+		parameterWrapper->set(faultCount);
+		break;
+	case 2:
+		parameterWrapper->set(timer.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FaultCounter::setParameterDomain(uint8_t domain) {
+	parameterDomain = domain;
+}
diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h
index 17e2a3df..dc929deb 100644
--- a/fdir/FaultCounter.h
+++ b/fdir/FaultCounter.h
@@ -1,38 +1,38 @@
-#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
-#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
-
-#include "../parameters/HasParametersIF.h"
-#include "../timemanager/Countdown.h"
-
-class FaultCounter: public HasParametersIF {
-public:
-	FaultCounter();
-	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
-			uint8_t setParameterDomain = 0);
-	virtual ~FaultCounter();
-
-	bool incrementAndCheck(uint32_t amount = 1);
-
-	void increment(uint32_t amount = 1);
-
-	bool checkForDecrement();
-
-	bool aboveThreshold();
-
-	void clear();
-	void setFailureThreshold(uint32_t failureThreshold);
-	void setFaultDecrementTimeMs(uint32_t timeMs);
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	void setParameterDomain(uint8_t domain);
-private:
-	uint8_t parameterDomain;
-	Countdown timer;
-	uint32_t faultCount;
-	uint32_t failureThreshold;
-};
-
-#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
+#ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_
+#define FRAMEWORK_FDIR_FAULTCOUNTER_H_
+
+#include "../parameters/HasParametersIF.h"
+#include "../timemanager/Countdown.h"
+
+class FaultCounter: public HasParametersIF {
+public:
+	FaultCounter();
+	FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
+			uint8_t setParameterDomain = 0);
+	virtual ~FaultCounter();
+
+	bool incrementAndCheck(uint32_t amount = 1);
+
+	void increment(uint32_t amount = 1);
+
+	bool checkForDecrement();
+
+	bool aboveThreshold();
+
+	void clear();
+	void setFailureThreshold(uint32_t failureThreshold);
+	void setFaultDecrementTimeMs(uint32_t timeMs);
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+	void setParameterDomain(uint8_t domain);
+private:
+	uint8_t parameterDomain;
+	Countdown timer;
+	uint32_t faultCount;
+	uint32_t failureThreshold;
+};
+
+#endif /* FRAMEWORK_FDIR_FAULTCOUNTER_H_ */
diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index f54af6a8..c57125e2 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,230 +1,230 @@
-#include "../globalfunctions/AsciiConverter.h"
-#include <limits>
-#include <cmath>
-
-template<typename T>
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
-		uint8_t len, T* value) {
-	if (len > std::numeric_limits<T>().digits10) {
-		return TOO_LONG_FOR_TARGET_TYPE;
-	}
-
-	double temp;
-
-	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
-
-	*value = temp;
-
-	return result;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
-		uint8_t* value) {
-	int8_t tmp;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp == -2) {
-		tmp = 0;
-	}
-
-	*value = tmp << 4;
-
-	tmp = convertHexChar(*dataPtr);
-	(*dataPtr)++;
-	if (tmp == -1) {
-		return INVALID_CHARACTERS;
-	}
-	if (tmp != -2) {
-		*value += tmp;
-	} else {
-		*value = *value >> 4;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
-		uint8_t len, double* value) {
-
-	uint8_t const *ptr = *dataPtr;
-	int8_t sign = 1;
-	float decimal = 0;
-	bool abort = false;
-
-	*value = 0;
-
-	//ignore leading space
-	ptr = clearSpace(ptr, len);
-
-	while ((ptr - *dataPtr < len) && !abort) {
-		switch (*ptr) {
-		case '+':
-			sign = 1;
-			break;
-		case '-':
-			sign = -1;
-			break;
-		case '.':
-			decimal = 1;
-			break;
-		case ' ':
-		case 0x0d:
-		case 0x0a:
-			//ignore trailing space
-			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
-			abort = true;
-			break;
-		default:
-			if ((*ptr < 0x30) || (*ptr > 0x39)) {
-				return INVALID_CHARACTERS;
-			}
-			*value = *value * 10 + (*ptr - 0x30);
-			if (decimal > 0) {
-				decimal *= 10;
-			}
-			break;
-		}
-		ptr++;
-	}
-
-	if (decimal == 0) {
-		decimal = 1;
-	}
-
-	*value = *value / (decimal) * sign;
-
-	*dataPtr = ptr;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
-		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
-	*printedSize = 0;
-	uint32_t streamposition = 0, integerSize;
-	bool negative = (value < 0);
-	int32_t digits = bufferLength - decimalPlaces - 1;
-	if (digits <= 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	if (negative) {
-		digits -= 1;
-		buffer[streamposition++] = '-';
-		value = -value;
-	}
-	float maximumNumber = pow(10, digits);
-	if (value >= maximumNumber) {
-		return BUFFER_TOO_SMALL;
-	}
-	//print the numbers before the decimal point;
-	ReturnValue_t result = printInteger(buffer + streamposition,
-			bufferLength - streamposition - decimalPlaces - 1, value,
-			&integerSize);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	streamposition += integerSize;
-	//The decimal Point
-	buffer[streamposition++] = '.';
-
-	//Print the decimals
-	uint32_t integerValue = value;
-	value -= integerValue;
-	value = value * pow(10, decimalPlaces);
-	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
-			&integerSize, true);
-	*printedSize = integerSize + streamposition;
-	return result;
-}
-
-ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
-		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
-		bool leadingZeros) {
-	*printedSize = 0;
-	if (bufferLength == 0) {
-		return BUFFER_TOO_SMALL;
-	}
-	uint32_t maximumNumber = -1;
-	if (bufferLength < 10) {
-		maximumNumber = pow(10, bufferLength);
-		if (value >= maximumNumber) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber /= 10;
-	} else {
-		if (!(value <= maximumNumber)) {
-			return BUFFER_TOO_SMALL;
-		}
-		maximumNumber = 1000000000;
-	}
-	if (!leadingZeros && (value == 0)) {
-		buffer[(*printedSize)++] = '0';
-		return RETURN_OK;
-	}
-	while (maximumNumber >= 1) {
-		uint8_t number = value / maximumNumber;
-		value = value - (number * maximumNumber);
-		if (!leadingZeros && number == 0) {
-			maximumNumber /= 10;
-		} else {
-			leadingZeros = true;
-			buffer[(*printedSize)++] = '0' + number;
-			maximumNumber /= 10;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
-		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
-	bool negative = false;
-	if ((bufferLength > 0) && (value < 0)) {
-		*buffer++ = '-';
-		bufferLength--;
-		value = -value;
-		negative = true;
-	}
-	ReturnValue_t result = printInteger(buffer, bufferLength, value,
-			printedSize);
-	if (negative) {
-		(*printedSize)++;
-	}
-	return result;
-}
-
-int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
-	if ((*character > 0x60) && (*character < 0x67)) {
-		return *character - 0x61 + 10;
-	} else if ((*character > 0x40) && (*character < 0x47)) {
-		return *character - 0x41 + 10;
-	} else if ((*character > 0x2F) && (*character < 0x3A)) {
-		return *character - 0x30;
-	} else if (*character == ' ') {
-		return -2;
-	}
-	return -1;
-}
-
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
-		const uint8_t** dataPtr, uint8_t len, float* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
-		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
-		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
-template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
-		const uint8_t** dataPtr, uint8_t len, double* value);
-
-const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
-	while (len > 0) {
-		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
-			return data;
-		}
-		data++;
-		len--;
-	}
-	return data;
-}
+#include "../globalfunctions/AsciiConverter.h"
+#include <limits>
+#include <cmath>
+
+template<typename T>
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber(const uint8_t** dataPtr,
+		uint8_t len, T* value) {
+	if (len > std::numeric_limits<T>().digits10) {
+		return TOO_LONG_FOR_TARGET_TYPE;
+	}
+
+	double temp;
+
+	ReturnValue_t result = scanAsciiDecimalNumber_(dataPtr, len, &temp);
+
+	*value = temp;
+
+	return result;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiHexByte(const uint8_t** dataPtr,
+		uint8_t* value) {
+	int8_t tmp;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp == -2) {
+		tmp = 0;
+	}
+
+	*value = tmp << 4;
+
+	tmp = convertHexChar(*dataPtr);
+	(*dataPtr)++;
+	if (tmp == -1) {
+		return INVALID_CHARACTERS;
+	}
+	if (tmp != -2) {
+		*value += tmp;
+	} else {
+		*value = *value >> 4;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::scanAsciiDecimalNumber_(uint8_t const ** dataPtr,
+		uint8_t len, double* value) {
+
+	uint8_t const *ptr = *dataPtr;
+	int8_t sign = 1;
+	float decimal = 0;
+	bool abort = false;
+
+	*value = 0;
+
+	//ignore leading space
+	ptr = clearSpace(ptr, len);
+
+	while ((ptr - *dataPtr < len) && !abort) {
+		switch (*ptr) {
+		case '+':
+			sign = 1;
+			break;
+		case '-':
+			sign = -1;
+			break;
+		case '.':
+			decimal = 1;
+			break;
+		case ' ':
+		case 0x0d:
+		case 0x0a:
+			//ignore trailing space
+			ptr = clearSpace(ptr, len - (ptr - *dataPtr)) - 1; //before aborting the loop, ptr will be incremented
+			abort = true;
+			break;
+		default:
+			if ((*ptr < 0x30) || (*ptr > 0x39)) {
+				return INVALID_CHARACTERS;
+			}
+			*value = *value * 10 + (*ptr - 0x30);
+			if (decimal > 0) {
+				decimal *= 10;
+			}
+			break;
+		}
+		ptr++;
+	}
+
+	if (decimal == 0) {
+		decimal = 1;
+	}
+
+	*value = *value / (decimal) * sign;
+
+	*dataPtr = ptr;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printFloat(uint8_t* buffer, uint32_t bufferLength,
+		float value, uint8_t decimalPlaces, uint32_t *printedSize) {
+	*printedSize = 0;
+	uint32_t streamposition = 0, integerSize;
+	bool negative = (value < 0);
+	int32_t digits = bufferLength - decimalPlaces - 1;
+	if (digits <= 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	if (negative) {
+		digits -= 1;
+		buffer[streamposition++] = '-';
+		value = -value;
+	}
+	float maximumNumber = pow(10, digits);
+	if (value >= maximumNumber) {
+		return BUFFER_TOO_SMALL;
+	}
+	//print the numbers before the decimal point;
+	ReturnValue_t result = printInteger(buffer + streamposition,
+			bufferLength - streamposition - decimalPlaces - 1, value,
+			&integerSize);
+	if (result != RETURN_OK) {
+		return result;
+	}
+	streamposition += integerSize;
+	//The decimal Point
+	buffer[streamposition++] = '.';
+
+	//Print the decimals
+	uint32_t integerValue = value;
+	value -= integerValue;
+	value = value * pow(10, decimalPlaces);
+	result = printInteger(buffer + streamposition, decimalPlaces, round(value),
+			&integerSize, true);
+	*printedSize = integerSize + streamposition;
+	return result;
+}
+
+ReturnValue_t AsciiConverter::printInteger(uint8_t* buffer,
+		uint32_t bufferLength, uint32_t value, uint32_t *printedSize,
+		bool leadingZeros) {
+	*printedSize = 0;
+	if (bufferLength == 0) {
+		return BUFFER_TOO_SMALL;
+	}
+	uint32_t maximumNumber = -1;
+	if (bufferLength < 10) {
+		maximumNumber = pow(10, bufferLength);
+		if (value >= maximumNumber) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber /= 10;
+	} else {
+		if (!(value <= maximumNumber)) {
+			return BUFFER_TOO_SMALL;
+		}
+		maximumNumber = 1000000000;
+	}
+	if (!leadingZeros && (value == 0)) {
+		buffer[(*printedSize)++] = '0';
+		return RETURN_OK;
+	}
+	while (maximumNumber >= 1) {
+		uint8_t number = value / maximumNumber;
+		value = value - (number * maximumNumber);
+		if (!leadingZeros && number == 0) {
+			maximumNumber /= 10;
+		} else {
+			leadingZeros = true;
+			buffer[(*printedSize)++] = '0' + number;
+			maximumNumber /= 10;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t AsciiConverter::printSignedInteger(uint8_t* buffer,
+		uint32_t bufferLength, int32_t value, uint32_t *printedSize) {
+	bool negative = false;
+	if ((bufferLength > 0) && (value < 0)) {
+		*buffer++ = '-';
+		bufferLength--;
+		value = -value;
+		negative = true;
+	}
+	ReturnValue_t result = printInteger(buffer, bufferLength, value,
+			printedSize);
+	if (negative) {
+		(*printedSize)++;
+	}
+	return result;
+}
+
+int8_t AsciiConverter::convertHexChar(const uint8_t* character) {
+	if ((*character > 0x60) && (*character < 0x67)) {
+		return *character - 0x61 + 10;
+	} else if ((*character > 0x40) && (*character < 0x47)) {
+		return *character - 0x41 + 10;
+	} else if ((*character > 0x2F) && (*character < 0x3A)) {
+		return *character - 0x30;
+	} else if (*character == ' ') {
+		return -2;
+	}
+	return -1;
+}
+
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<float>(
+		const uint8_t** dataPtr, uint8_t len, float* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint8_t>(
+		const uint8_t** dataPtr, uint8_t len, uint8_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<uint16_t>(
+		const uint8_t** dataPtr, uint8_t len, uint16_t* value);
+template ReturnValue_t AsciiConverter::scanAsciiDecimalNumber<double>(
+		const uint8_t** dataPtr, uint8_t len, double* value);
+
+const uint8_t* AsciiConverter::clearSpace(const uint8_t* data, uint8_t len) {
+	while (len > 0) {
+		if ((*data != ' ') && (*data != 0x0a) && (*data != 0x0d)) {
+			return data;
+		}
+		data++;
+		len--;
+	}
+	return data;
+}
diff --git a/globalfunctions/AsciiConverter.h b/globalfunctions/AsciiConverter.h
index 27bed4e7..7af3cb3d 100644
--- a/globalfunctions/AsciiConverter.h
+++ b/globalfunctions/AsciiConverter.h
@@ -1,39 +1,39 @@
-#ifndef ASCIICONVERTER_H_
-#define ASCIICONVERTER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class AsciiConverter: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
-	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
-
-	template<typename T>
-	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
-			uint8_t len, T *value);
-
-	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
-			uint8_t *value);
-
-	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
-			float value, uint8_t decimalPlaces, uint32_t *printedSize);
-
-	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
-			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
-
-	static ReturnValue_t printSignedInteger(uint8_t *buffer,
-			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
-
-private:
-	AsciiConverter();
-	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
-			uint8_t len, double *value);
-
-	static int8_t convertHexChar(const uint8_t *character);
-
-	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
-};
-
-#endif /* ASCIICONVERTER_H_ */
+#ifndef ASCIICONVERTER_H_
+#define ASCIICONVERTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class AsciiConverter: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ASCII_CONVERTER;
+	static const ReturnValue_t TOO_LONG_FOR_TARGET_TYPE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_CHARACTERS = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t BUFFER_TOO_SMALL = MAKE_RETURN_CODE(0x3);
+
+	template<typename T>
+	static ReturnValue_t scanAsciiDecimalNumber(const uint8_t **dataPtr,
+			uint8_t len, T *value);
+
+	static ReturnValue_t scanAsciiHexByte(const uint8_t **dataPtr,
+			uint8_t *value);
+
+	static ReturnValue_t printFloat(uint8_t *buffer, uint32_t bufferLength,
+			float value, uint8_t decimalPlaces, uint32_t *printedSize);
+
+	static ReturnValue_t printInteger(uint8_t *buffer, uint32_t bufferLength,
+			uint32_t value, uint32_t *printedSize, bool leadingZeros = false);
+
+	static ReturnValue_t printSignedInteger(uint8_t *buffer,
+			uint32_t bufferLength, int32_t value, uint32_t *printedSize);
+
+private:
+	AsciiConverter();
+	static ReturnValue_t scanAsciiDecimalNumber_(const uint8_t **dataPtr,
+			uint8_t len, double *value);
+
+	static int8_t convertHexChar(const uint8_t *character);
+
+	static const uint8_t *clearSpace(const uint8_t *data, uint8_t len);
+};
+
+#endif /* ASCIICONVERTER_H_ */
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index 6156b558..1258b698 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,139 +1,139 @@
-#include "../globalfunctions/CRC.h"
-#include <math.h>
-
-const uint16_t CRC::crc16ccitt_table[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-};
-
-
-// CRC implementation
-uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
-{
-	uint8_t *data = (uint8_t *)input;
-	unsigned int tbl_idx;
-
-    while (length--) {
-        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
-        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
-
-        data++;
-    }
-    return startingCrc & 0xffff;
-
-    //The part below is not used!
-//	bool temr[16];
-//	bool xor_out[16];
-//	bool r[16];
-//	bool d[8];
-//	uint16_t crc_value = 0;
-//
-//
-//	for (int i=0; i<16 ;i++) {
-//		temr[i] = false;
-//		xor_out[i] = false;
-//	}
-//
-//
-//	for (int i=0; i<16 ;i++)
-//			r[i] = true;    // initialize with 0xFFFF
-//
-//
-//
-//	for (int j=0; j<length ;j++)
-//	{
-//
-//	for (int i=0; i<8 ;i++)
-//		if ((input[j] & 1<<i) == 1<<i)
-//			d[7-i]=true;			// reverse   input data
-//		else
-//			d[7-i]=false;			// reverse input data
-//
-//
-//
-//		  temr[0] = d[4] ^ d[0];
-//		  temr[1] = d[5] ^ d[1];
-//		  temr[2] = d[6] ^ d[2];
-//		  temr[3] = d[7] ^ d[3];
-//		  temr[4] = r[12] ^ r[8];
-//		  temr[5] = r[13] ^ r[9];
-//		  temr[6] = r[14] ^ r[10];
-//		  temr[7] = r[15] ^ r[11];
-//		  temr[8] = d[4] ^ r[12];
-//		  temr[9] = d[5] ^ r[13];
-//		  temr[10] = d[6] ^ r[14];
-//		  temr[11] = d[7] ^ r[15];
-//		  temr[12] = temr[0] ^ temr[4];
-//		  temr[13] = temr[1] ^ temr[5];
-//		  temr[14] = temr[2] ^ temr[6];
-//		  temr[15] = temr[3] ^ temr[7];
-//
-//
-//		  xor_out[0] = temr[12];
-//		  xor_out[1] = temr[13];
-//		  xor_out[2] = temr[14];
-//		  xor_out[3] = temr[15];
-//		  xor_out[4] = temr[8];
-//		  xor_out[5] = temr[9] ^ temr[12];
-//		  xor_out[6] = temr[10] ^ temr[13];
-//		  xor_out[7] = temr[11] ^ temr[14];
-//		  xor_out[8] = temr[15] ^ r[0];
-//		  xor_out[9] = temr[8] ^ r[1];
-//		  xor_out[10] = temr[9] ^ r[2];
-//		  xor_out[11] = temr[10] ^ r[3];
-//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
-//		  xor_out[13] = temr[13] ^ r[5];
-//		  xor_out[14] = temr[14] ^ r[6];
-//		  xor_out[15] = temr[15] ^ r[7];
-//
-//	 for (int i=0; i<16 ;i++)
-//	 {
-//		  r[i]= xor_out[i] ;
-//	 }
-//
-//	}
-//
-//
-//
-//	for (int i=0; i<16 ;i++)
-//	{
-//		 if  (xor_out[i] == true)
-//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
-//	}
-//
-//	crc_value = 0;// for debug mode
-//	return (crc_value);
-
-}   /* Calculate_CRC() */
-
-
+#include "../globalfunctions/CRC.h"
+#include <math.h>
+
+const uint16_t CRC::crc16ccitt_table[256] = {
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+};
+
+
+// CRC implementation
+uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t startingCrc)
+{
+	uint8_t *data = (uint8_t *)input;
+	unsigned int tbl_idx;
+
+    while (length--) {
+        tbl_idx = ((startingCrc >> 8) ^ *data) & 0xff;
+        startingCrc = (crc16ccitt_table[tbl_idx] ^ (startingCrc << 8)) & 0xffff;
+
+        data++;
+    }
+    return startingCrc & 0xffff;
+
+    //The part below is not used!
+//	bool temr[16];
+//	bool xor_out[16];
+//	bool r[16];
+//	bool d[8];
+//	uint16_t crc_value = 0;
+//
+//
+//	for (int i=0; i<16 ;i++) {
+//		temr[i] = false;
+//		xor_out[i] = false;
+//	}
+//
+//
+//	for (int i=0; i<16 ;i++)
+//			r[i] = true;    // initialize with 0xFFFF
+//
+//
+//
+//	for (int j=0; j<length ;j++)
+//	{
+//
+//	for (int i=0; i<8 ;i++)
+//		if ((input[j] & 1<<i) == 1<<i)
+//			d[7-i]=true;			// reverse   input data
+//		else
+//			d[7-i]=false;			// reverse input data
+//
+//
+//
+//		  temr[0] = d[4] ^ d[0];
+//		  temr[1] = d[5] ^ d[1];
+//		  temr[2] = d[6] ^ d[2];
+//		  temr[3] = d[7] ^ d[3];
+//		  temr[4] = r[12] ^ r[8];
+//		  temr[5] = r[13] ^ r[9];
+//		  temr[6] = r[14] ^ r[10];
+//		  temr[7] = r[15] ^ r[11];
+//		  temr[8] = d[4] ^ r[12];
+//		  temr[9] = d[5] ^ r[13];
+//		  temr[10] = d[6] ^ r[14];
+//		  temr[11] = d[7] ^ r[15];
+//		  temr[12] = temr[0] ^ temr[4];
+//		  temr[13] = temr[1] ^ temr[5];
+//		  temr[14] = temr[2] ^ temr[6];
+//		  temr[15] = temr[3] ^ temr[7];
+//
+//
+//		  xor_out[0] = temr[12];
+//		  xor_out[1] = temr[13];
+//		  xor_out[2] = temr[14];
+//		  xor_out[3] = temr[15];
+//		  xor_out[4] = temr[8];
+//		  xor_out[5] = temr[9] ^ temr[12];
+//		  xor_out[6] = temr[10] ^ temr[13];
+//		  xor_out[7] = temr[11] ^ temr[14];
+//		  xor_out[8] = temr[15] ^ r[0];
+//		  xor_out[9] = temr[8] ^ r[1];
+//		  xor_out[10] = temr[9] ^ r[2];
+//		  xor_out[11] = temr[10] ^ r[3];
+//		  xor_out[12] = temr[11] ^ temr[12] ^ r[4];
+//		  xor_out[13] = temr[13] ^ r[5];
+//		  xor_out[14] = temr[14] ^ r[6];
+//		  xor_out[15] = temr[15] ^ r[7];
+//
+//	 for (int i=0; i<16 ;i++)
+//	 {
+//		  r[i]= xor_out[i] ;
+//	 }
+//
+//	}
+//
+//
+//
+//	for (int i=0; i<16 ;i++)
+//	{
+//		 if  (xor_out[i] == true)
+//			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final XOR
+//	}
+//
+//	crc_value = 0;// for debug mode
+//	return (crc_value);
+
+}   /* Calculate_CRC() */
+
+
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 21dbd2e6..6bd402d7 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -1,124 +1,124 @@
-#include "../globalfunctions/DleEncoder.h"
-
-DleEncoder::DleEncoder() {}
-
-DleEncoder::~DleEncoder() {}
-
-ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
-		size_t* encodedLen, bool addStxEtx) {
-	if (maxDestLen < 2) {
-		return STREAM_TOO_SHORT;
-	}
-	size_t encodedIndex = 0, sourceIndex = 0;
-	uint8_t nextByte;
-	if (addStxEtx) {
-		destStream[0] = STX_CHAR;
-		++encodedIndex;
-	}
-
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
-	{
-		nextByte = sourceStream[sourceIndex];
-		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				/* Escaped byte will be actual byte + 0x40. This prevents
-				 * STX, ETX, and carriage return characters from appearing
-				 * in the encoded data stream at all, so when polling an
-				 * encoded stream, the transmission can be stopped at ETX.
-				 * 0x40 was chosen at random with special requirements:
-				 *  - Prevent going from one control char to another
-				 *  - Prevent overflow for common characters */
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
-		}
-		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE_CHAR) {
-			if (encodedIndex + 1 >= maxDestLen) {
-			    return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE_CHAR;
-			}
-		}
-		else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
-
-	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
-		if (addStxEtx) {
-			destStream[encodedIndex] = ETX_CHAR;
-			++encodedIndex;
-		}
-		*encodedLen = encodedIndex;
-		return RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-		size_t maxDestStreamlen, size_t *decodedLen) {
-	size_t encodedIndex = 0, decodedIndex = 0;
-	uint8_t nextByte;
-	if (*sourceStream != STX_CHAR) {
-		return DECODING_ERROR;
-	}
-	++encodedIndex;
-
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX_CHAR)
-			&& (sourceStream[encodedIndex] != STX_CHAR)) {
-		if (sourceStream[encodedIndex] == DLE_CHAR) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// The next byte is a DLE character that was escaped by another
-			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE_CHAR) {
-				destStream[decodedIndex] = nextByte;
-			}
-			else {
-			    /* The next byte is a STX, DTX or 0x0D character which
-			     * was escaped by a DLE character. The actual byte was
-				 * also encoded by adding + 0x40 to preven having control chars,
-				 * in the stream at all, so we convert it back. */
-				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				}
-				else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX_CHAR) {
-		*readLen = ++encodedIndex;
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-
+#include "../globalfunctions/DleEncoder.h"
+
+DleEncoder::DleEncoder() {}
+
+DleEncoder::~DleEncoder() {}
+
+ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
+		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
+		size_t* encodedLen, bool addStxEtx) {
+	if (maxDestLen < 2) {
+		return STREAM_TOO_SHORT;
+	}
+	size_t encodedIndex = 0, sourceIndex = 0;
+	uint8_t nextByte;
+	if (addStxEtx) {
+		destStream[0] = STX_CHAR;
+		++encodedIndex;
+	}
+
+	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
+	{
+		nextByte = sourceStream[sourceIndex];
+		// STX, ETX and CR characters in the stream need to be escaped with DLE
+		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
+			if (encodedIndex + 1 >= maxDestLen) {
+				return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE_CHAR;
+				++encodedIndex;
+				/* Escaped byte will be actual byte + 0x40. This prevents
+				 * STX, ETX, and carriage return characters from appearing
+				 * in the encoded data stream at all, so when polling an
+				 * encoded stream, the transmission can be stopped at ETX.
+				 * 0x40 was chosen at random with special requirements:
+				 *  - Prevent going from one control char to another
+				 *  - Prevent overflow for common characters */
+				destStream[encodedIndex] = nextByte + 0x40;
+			}
+		}
+		// DLE characters are simply escaped with DLE.
+		else if (nextByte == DLE_CHAR) {
+			if (encodedIndex + 1 >= maxDestLen) {
+			    return STREAM_TOO_SHORT;
+			}
+			else {
+				destStream[encodedIndex] = DLE_CHAR;
+				++encodedIndex;
+				destStream[encodedIndex] = DLE_CHAR;
+			}
+		}
+		else {
+			destStream[encodedIndex] = nextByte;
+		}
+		++encodedIndex;
+		++sourceIndex;
+	}
+
+	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
+		if (addStxEtx) {
+			destStream[encodedIndex] = ETX_CHAR;
+			++encodedIndex;
+		}
+		*encodedLen = encodedIndex;
+		return RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
+		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+		size_t maxDestStreamlen, size_t *decodedLen) {
+	size_t encodedIndex = 0, decodedIndex = 0;
+	uint8_t nextByte;
+	if (*sourceStream != STX_CHAR) {
+		return DECODING_ERROR;
+	}
+	++encodedIndex;
+
+	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
+			&& (sourceStream[encodedIndex] != ETX_CHAR)
+			&& (sourceStream[encodedIndex] != STX_CHAR)) {
+		if (sourceStream[encodedIndex] == DLE_CHAR) {
+			nextByte = sourceStream[encodedIndex + 1];
+			// The next byte is a DLE character that was escaped by another
+			// DLE character, so we can write it to the destination stream.
+			if (nextByte == DLE_CHAR) {
+				destStream[decodedIndex] = nextByte;
+			}
+			else {
+			    /* The next byte is a STX, DTX or 0x0D character which
+			     * was escaped by a DLE character. The actual byte was
+				 * also encoded by adding + 0x40 to preven having control chars,
+				 * in the stream at all, so we convert it back. */
+				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
+					destStream[decodedIndex] = nextByte - 0x40;
+				}
+				else {
+				    return DECODING_ERROR;
+				}
+			}
+			++encodedIndex;
+		}
+		else {
+			destStream[decodedIndex] = sourceStream[encodedIndex];
+		}
+
+		++encodedIndex;
+		++decodedIndex;
+	}
+
+	if (sourceStream[encodedIndex] != ETX_CHAR) {
+		*readLen = ++encodedIndex;
+		return DECODING_ERROR;
+	}
+	else {
+		*readLen = ++encodedIndex;
+		*decodedLen = decodedIndex;
+		return RETURN_OK;
+	}
+}
+
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 3c327a55..3c535d1f 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -1,79 +1,79 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-/**
- * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
- *          decode arbitrary data with ASCII control characters
- * @details
- * List of control codes:
- * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
- *
- * This encoder can be used to achieve a basic transport layer when using
- * char based transmission systems.
- * The passed source strean is converted into a encoded stream by adding
- * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
- * escaped by a DLE character. The encoder also replaces escaped control chars
- * by another char, so STX, ETX and CR should not appear anywhere in the actual
- * encoded data stream.
- *
- * When using a strictly char based reception of packets enoded with DLE,
- * STX can be used to notify a reader that actual data will start to arrive
- * while ETX can be used to notify the reader that the data has ended.
- */
-class DleEncoder: public HasReturnvaluesIF {
-private:
-	DleEncoder();
-	virtual ~DleEncoder();
-
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
-	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
-	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
-
-	//! Start Of Text character. First character is encoded stream
-	static constexpr uint8_t STX_CHAR = 0x02;
-	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX_CHAR = 0x03;
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
-	//! in the source stream.
-	static constexpr uint8_t DLE_CHAR = 0x10;
-	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
-
-    /**
-     * Encodes the give data stream by preceding it with the STX marker
-     * and ending it with an ETX marker. STX, ETX and DLE characters inside
-     * the stream are escaped by DLE characters and also replaced by adding
-     * 0x40 (which is reverted in the decoing process).
-     * @param sourceStream
-     * @param sourceLen
-     * @param destStream
-     * @param maxDestLen
-     * @param encodedLen
-     * @param addStxEtx
-     * Adding STX and ETX can be omitted, if they are added manually.
-     * @return
-     */
-    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
-            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
-            bool addStxEtx = true);
-
-    /**
-     * Converts an encoded stream back.
-     * @param sourceStream
-     * @param sourceStreamLen
-     * @param readLen
-     * @param destStream
-     * @param maxDestStreamlen
-     * @param decodedLen
-     * @return
-     */
-	static ReturnValue_t decode(const uint8_t *sourceStream,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
+ *          decode arbitrary data with ASCII control characters
+ * @details
+ * List of control codes:
+ * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * This encoder can be used to achieve a basic transport layer when using
+ * char based transmission systems.
+ * The passed source strean is converted into a encoded stream by adding
+ * a STX marker at the start of the stream and an ETX marker at the end of
+ * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
+ * escaped by a DLE character. The encoder also replaces escaped control chars
+ * by another char, so STX, ETX and CR should not appear anywhere in the actual
+ * encoded data stream.
+ *
+ * When using a strictly char based reception of packets enoded with DLE,
+ * STX can be used to notify a reader that actual data will start to arrive
+ * while ETX can be used to notify the reader that the data has ended.
+ */
+class DleEncoder: public HasReturnvaluesIF {
+private:
+	DleEncoder();
+	virtual ~DleEncoder();
+
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
+	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
+	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
+
+	//! Start Of Text character. First character is encoded stream
+	static constexpr uint8_t STX_CHAR = 0x02;
+	//! End Of Text character. Last character in encoded stream
+	static constexpr uint8_t ETX_CHAR = 0x03;
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! in the source stream.
+	static constexpr uint8_t DLE_CHAR = 0x10;
+	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
+
+    /**
+     * Encodes the give data stream by preceding it with the STX marker
+     * and ending it with an ETX marker. STX, ETX and DLE characters inside
+     * the stream are escaped by DLE characters and also replaced by adding
+     * 0x40 (which is reverted in the decoing process).
+     * @param sourceStream
+     * @param sourceLen
+     * @param destStream
+     * @param maxDestLen
+     * @param encodedLen
+     * @param addStxEtx
+     * Adding STX and ETX can be omitted, if they are added manually.
+     * @return
+     */
+    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
+            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
+            bool addStxEtx = true);
+
+    /**
+     * Converts an encoded stream back.
+     * @param sourceStream
+     * @param sourceStreamLen
+     * @param readLen
+     * @param destStream
+     * @param maxDestStreamlen
+     * @param decodedLen
+     * @return
+     */
+	static ReturnValue_t decode(const uint8_t *sourceStream,
+			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
+			size_t maxDestStreamlen, size_t *decodedLen);
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */
diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 9589bed3..97f38473 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,181 +1,181 @@
-#include "../globalfunctions/Type.h"
-#include "../serialize/SerializeAdapter.h"
-
-Type::Type() :
-		actualType(UNKNOWN_TYPE) {
-}
-
-Type::Type(ActualType_t actualType) :
-		actualType(actualType) {
-}
-
-Type::Type(const Type& type) :
-		actualType(type.actualType) {
-}
-
-Type& Type::operator =(Type rhs) {
-	this->actualType = rhs.actualType;
-	return *this;
-}
-
-Type& Type::operator =(ActualType_t actualType) {
-	this->actualType = actualType;
-	return *this;
-}
-
-Type::operator Type::ActualType_t() const {
-	return actualType;
-}
-
-bool Type::operator ==(const Type& rhs) {
-	return this->actualType == rhs.actualType;
-}
-
-bool Type::operator !=(const Type& rhs) {
-	return !operator==(rhs);
-}
-
-uint8_t Type::getSize() const {
-	switch (actualType) {
-	case UINT8_T:
-		return sizeof(uint8_t);
-	case INT8_T:
-		return sizeof(int8_t);
-	case UINT16_T:
-		return sizeof(uint16_t);
-	case INT16_T:
-		return sizeof(int16_t);
-	case UINT32_T:
-		return sizeof(uint32_t);
-	case INT32_T:
-		return sizeof(int32_t);
-	case FLOAT:
-		return sizeof(float);
-	case DOUBLE:
-		return sizeof(double);
-	default:
-		return 0;
-	}
-}
-
-ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
-			streamEndianness);
-
-	return result;
-
-}
-
-size_t Type::getSerializedSize() const {
-	uint8_t dontcare = 0;
-	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
-}
-
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	uint8_t ptc;
-	uint8_t pfc;
-	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	actualType = getActualType(ptc, pfc);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
-	switch (actualType) {
-	case UINT8_T:
-		*ptc = 3;
-		*pfc = 4;
-		break;
-	case INT8_T:
-		*ptc = 4;
-		*pfc = 4;
-		break;
-	case UINT16_T:
-		*ptc = 3;
-		*pfc = 12;
-		break;
-	case INT16_T:
-		*ptc = 4;
-		*pfc = 12;
-		break;
-	case UINT32_T:
-		*ptc = 3;
-		*pfc = 14;
-		break;
-	case INT32_T:
-		*ptc = 4;
-		*pfc = 14;
-		break;
-	case FLOAT:
-		*ptc = 5;
-		*pfc = 1;
-		break;
-	case DOUBLE:
-		*ptc = 5;
-		*pfc = 2;
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
-	switch (ptc) {
-	case 3:
-		switch (pfc) {
-		case 4:
-			return UINT8_T;
-		case 12:
-			return UINT16_T;
-		case 14:
-			return UINT32_T;
-		}
-		break;
-	case 4:
-		switch (pfc) {
-		case 4:
-			return INT8_T;
-		case 12:
-			return INT16_T;
-		case 14:
-			return INT32_T;
-		}
-		break;
-	case 5:
-		switch (pfc) {
-		case 1:
-			return FLOAT;
-		case 2:
-			return DOUBLE;
-		}
-		break;
-	}
-	return UNKNOWN_TYPE;
-}
+#include "../globalfunctions/Type.h"
+#include "../serialize/SerializeAdapter.h"
+
+Type::Type() :
+		actualType(UNKNOWN_TYPE) {
+}
+
+Type::Type(ActualType_t actualType) :
+		actualType(actualType) {
+}
+
+Type::Type(const Type& type) :
+		actualType(type.actualType) {
+}
+
+Type& Type::operator =(Type rhs) {
+	this->actualType = rhs.actualType;
+	return *this;
+}
+
+Type& Type::operator =(ActualType_t actualType) {
+	this->actualType = actualType;
+	return *this;
+}
+
+Type::operator Type::ActualType_t() const {
+	return actualType;
+}
+
+bool Type::operator ==(const Type& rhs) {
+	return this->actualType == rhs.actualType;
+}
+
+bool Type::operator !=(const Type& rhs) {
+	return !operator==(rhs);
+}
+
+uint8_t Type::getSize() const {
+	switch (actualType) {
+	case UINT8_T:
+		return sizeof(uint8_t);
+	case INT8_T:
+		return sizeof(int8_t);
+	case UINT16_T:
+		return sizeof(uint16_t);
+	case INT16_T:
+		return sizeof(int16_t);
+	case UINT32_T:
+		return sizeof(uint32_t);
+	case INT32_T:
+		return sizeof(int32_t);
+	case FLOAT:
+		return sizeof(float);
+	case DOUBLE:
+		return sizeof(double);
+	default:
+		return 0;
+	}
+}
+
+ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = getPtcPfc(&ptc, &pfc);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
+			streamEndianness);
+
+	return result;
+
+}
+
+size_t Type::getSerializedSize() const {
+	uint8_t dontcare = 0;
+	return 2 * SerializeAdapter::getSerializedSize(&dontcare);
+}
+
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	uint8_t ptc;
+	uint8_t pfc;
+	ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&pfc, buffer, size,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	actualType = getActualType(ptc, pfc);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Type::getPtcPfc(uint8_t* ptc, uint8_t* pfc) const {
+	switch (actualType) {
+	case UINT8_T:
+		*ptc = 3;
+		*pfc = 4;
+		break;
+	case INT8_T:
+		*ptc = 4;
+		*pfc = 4;
+		break;
+	case UINT16_T:
+		*ptc = 3;
+		*pfc = 12;
+		break;
+	case INT16_T:
+		*ptc = 4;
+		*pfc = 12;
+		break;
+	case UINT32_T:
+		*ptc = 3;
+		*pfc = 14;
+		break;
+	case INT32_T:
+		*ptc = 4;
+		*pfc = 14;
+		break;
+	case FLOAT:
+		*ptc = 5;
+		*pfc = 1;
+		break;
+	case DOUBLE:
+		*ptc = 5;
+		*pfc = 2;
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+Type::ActualType_t Type::getActualType(uint8_t ptc, uint8_t pfc) {
+	switch (ptc) {
+	case 3:
+		switch (pfc) {
+		case 4:
+			return UINT8_T;
+		case 12:
+			return UINT16_T;
+		case 14:
+			return UINT32_T;
+		}
+		break;
+	case 4:
+		switch (pfc) {
+		case 4:
+			return INT8_T;
+		case 12:
+			return INT16_T;
+		case 14:
+			return INT32_T;
+		}
+		break;
+	case 5:
+		switch (pfc) {
+		case 1:
+			return FLOAT;
+		case 2:
+			return DOUBLE;
+		}
+		break;
+	}
+	return UNKNOWN_TYPE;
+}
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index c10511f8..6910f909 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,94 +1,94 @@
-#ifndef TYPE_H_
-#define TYPE_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-
-/**
- * @brief 	Type definition for CCSDS or ECSS.
- */
-class Type: public SerializeIF {
-public:
-	enum ActualType_t {
-		UINT8_T,
-		INT8_T,
-		UINT16_T,
-		INT16_T,
-		UINT32_T,
-		INT32_T,
-		FLOAT,
-		DOUBLE,
-		UNKNOWN_TYPE
-	};
-
-	Type();
-
-	Type(ActualType_t actualType);
-
-	Type(const Type &type);
-
-	Type& operator=(Type rhs);
-
-	Type& operator=(ActualType_t actualType);
-
-	operator ActualType_t() const;
-
-	bool operator==(const Type &rhs);
-	bool operator!=(const Type &rhs);
-
-	uint8_t getSize() const;
-
-	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
-
-	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override;
-
-private:
-	ActualType_t actualType;
-};
-
-template<typename T>
-struct PodTypeConversion {
-	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
-};
-template<>
-struct PodTypeConversion<uint8_t> {
-	static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
-struct PodTypeConversion<uint16_t> {
-	static const Type::ActualType_t type = Type::UINT16_T;
-};
-template<>
-struct PodTypeConversion<uint32_t> {
-	static const Type::ActualType_t type = Type::UINT32_T;
-};
-template<>
-struct PodTypeConversion<int8_t> {
-	static const Type::ActualType_t type = Type::INT8_T;
-};
-template<>
-struct PodTypeConversion<int16_t> {
-	static const Type::ActualType_t type = Type::INT16_T;
-};
-template<>
-struct PodTypeConversion<int32_t> {
-	static const Type::ActualType_t type = Type::INT32_T;
-};
-template<>
-struct PodTypeConversion<float> {
-	static const Type::ActualType_t type = Type::FLOAT;
-};
-template<>
-struct PodTypeConversion<double> {
-	static const Type::ActualType_t type = Type::DOUBLE;
-};
-
-#endif /* TYPE_H_ */
+#ifndef TYPE_H_
+#define TYPE_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+
+/**
+ * @brief 	Type definition for CCSDS or ECSS.
+ */
+class Type: public SerializeIF {
+public:
+	enum ActualType_t {
+		UINT8_T,
+		INT8_T,
+		UINT16_T,
+		INT16_T,
+		UINT32_T,
+		INT32_T,
+		FLOAT,
+		DOUBLE,
+		UNKNOWN_TYPE
+	};
+
+	Type();
+
+	Type(ActualType_t actualType);
+
+	Type(const Type &type);
+
+	Type& operator=(Type rhs);
+
+	Type& operator=(ActualType_t actualType);
+
+	operator ActualType_t() const;
+
+	bool operator==(const Type &rhs);
+	bool operator!=(const Type &rhs);
+
+	uint8_t getSize() const;
+
+	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;
+
+	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override;
+
+private:
+	ActualType_t actualType;
+};
+
+template<typename T>
+struct PodTypeConversion {
+	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
+};
+template<>
+struct PodTypeConversion<uint8_t> {
+	static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
+struct PodTypeConversion<uint16_t> {
+	static const Type::ActualType_t type = Type::UINT16_T;
+};
+template<>
+struct PodTypeConversion<uint32_t> {
+	static const Type::ActualType_t type = Type::UINT32_T;
+};
+template<>
+struct PodTypeConversion<int8_t> {
+	static const Type::ActualType_t type = Type::INT8_T;
+};
+template<>
+struct PodTypeConversion<int16_t> {
+	static const Type::ActualType_t type = Type::INT16_T;
+};
+template<>
+struct PodTypeConversion<int32_t> {
+	static const Type::ActualType_t type = Type::INT32_T;
+};
+template<>
+struct PodTypeConversion<float> {
+	static const Type::ActualType_t type = Type::FLOAT;
+};
+template<>
+struct PodTypeConversion<double> {
+	static const Type::ActualType_t type = Type::DOUBLE;
+};
+
+#endif /* TYPE_H_ */
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index 1e58ca75..fa89c0dc 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,61 +1,61 @@
-#include "../globalfunctions/arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <bitset>
-
-void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
-}
-
-void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << "\r\n" << std::flush;
-			}
-		}
-
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-}
-
-void arrayprinter::printBin(const uint8_t *data, size_t size) {
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-}
+#include "../globalfunctions/arrayprinter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <bitset>
+
+void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
+		bool printInfo, size_t maxCharPerLine) {
+	if(printInfo) {
+		sif::info << "Printing data with size " << size << ": ";
+	}
+	sif::info << "[";
+	if(type == OutputType::HEX) {
+		arrayprinter::printHex(data, size, maxCharPerLine);
+	}
+	else if (type == OutputType::DEC) {
+		arrayprinter::printDec(data, size, maxCharPerLine);
+	}
+	else if(type == OutputType::BIN) {
+	    arrayprinter::printBin(data, size);
+	}
+}
+
+void arrayprinter::printHex(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::hex;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << "0x" << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << "\r\n" << std::flush;
+			}
+		}
+
+	}
+	sif::info << std::dec;
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printDec(const uint8_t *data, size_t size,
+		size_t maxCharPerLine) {
+	sif::info << std::dec;
+	for(size_t i = 0; i < size; i++) {
+		sif::info << static_cast<int>(data[i]);
+		if(i < size - 1){
+			sif::info << " , ";
+			if(i > 0 and i % maxCharPerLine == 0) {
+				sif::info << std::endl;
+			}
+		}
+	}
+	sif::info << "]" << std::endl;
+}
+
+void arrayprinter::printBin(const uint8_t *data, size_t size) {
+    sif::info << "\n" << std::flush;
+    for(size_t i = 0; i < size; i++) {
+        sif::info << "Byte " << i + 1 << ": 0b"<<
+                std::bitset<8>(data[i]) << ",\n" << std::flush;
+    }
+    sif::info << "]" << std::endl;
+}
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index 60e055a1..550439ab 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,41 +1,41 @@
-#ifndef BINARYMATCHER_H_
-#define BINARYMATCHER_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-
-template<typename T>
-class BinaryMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	BinaryMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	BinaryMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-
-	bool doMatch(T input, T mask, T match) {
-		match = match & mask;
-		input = input & mask;
-		if (input == match) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-};
-
-#endif /* BINARYMATCHER_H_ */
+#ifndef BINARYMATCHER_H_
+#define BINARYMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class BinaryMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	BinaryMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	BinaryMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+
+	bool doMatch(T input, T mask, T match) {
+		match = match & mask;
+		input = input & mask;
+		if (input == match) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+};
+
+#endif /* BINARYMATCHER_H_ */
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index 24f399ef..3c765cd7 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,50 +1,50 @@
-#ifndef DECIMALMATCHER_H_
-#define DECIMALMATCHER_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-
-template<typename T>
-class DecimalMatcher: public MatcherIF<T> {
-public:
-	bool inverted;
-	T mask, matchField;
-
-	DecimalMatcher() :
-			inverted(false), mask(0), matchField(0) {
-	}
-
-	DecimalMatcher(T mask, T match, bool inverted = false) :
-			inverted(inverted), mask(mask), matchField(match) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return ~doMatch(input, mask, matchField);
-		} else {
-			return doMatch(input, mask, matchField);
-		}
-	}
-
-protected:
-	bool doMatch(T input, T mask, T match) {
-		T decimal = 1, remainderMask, remainderMatch, remainderInput;
-
-		while (mask != 0) {
-			remainderMask = mask % (decimal * 10);
-			remainderMatch = match % (decimal * 10);
-			remainderInput = input % (decimal * 10);
-			if (remainderMask != 0) {
-				if (remainderMatch != remainderInput) {
-					return false;
-				}
-			}
-			mask -= remainderMask;
-			match -= remainderMatch;
-			input -= remainderInput;
-			decimal *= 10;
-		}
-		return true;
-	}
-};
-
-#endif /* DECIMALMATCHER_H_ */
+#ifndef DECIMALMATCHER_H_
+#define DECIMALMATCHER_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+
+template<typename T>
+class DecimalMatcher: public MatcherIF<T> {
+public:
+	bool inverted;
+	T mask, matchField;
+
+	DecimalMatcher() :
+			inverted(false), mask(0), matchField(0) {
+	}
+
+	DecimalMatcher(T mask, T match, bool inverted = false) :
+			inverted(inverted), mask(mask), matchField(match) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return ~doMatch(input, mask, matchField);
+		} else {
+			return doMatch(input, mask, matchField);
+		}
+	}
+
+protected:
+	bool doMatch(T input, T mask, T match) {
+		T decimal = 1, remainderMask, remainderMatch, remainderInput;
+
+		while (mask != 0) {
+			remainderMask = mask % (decimal * 10);
+			remainderMatch = match % (decimal * 10);
+			remainderInput = input % (decimal * 10);
+			if (remainderMask != 0) {
+				if (remainderMatch != remainderInput) {
+					return false;
+				}
+			}
+			mask -= remainderMask;
+			match -= remainderMatch;
+			input -= remainderInput;
+			decimal *= 10;
+		}
+		return true;
+	}
+};
+
+#endif /* DECIMALMATCHER_H_ */
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 2d380bbb..46245c25 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -1,216 +1,216 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
-
-#include "../../container/BinaryTree.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-
-template<typename T>
-class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
-		SerializeableMatcherIF<T>> {
-public:
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
-	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
-
-	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
-	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
-	static const bool AND = true; //LEFT
-	static const bool OR = false; //RIGHT
-	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
-			uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
-	}
-	MatchTree(iterator root, uint8_t maxDepth = -1) :
-			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
-					maxDepth) {
-	}
-	MatchTree() :
-			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
-	}
-	virtual ~MatchTree() {
-	}
-	virtual bool match(T number) {
-		return matchesTree(number);
-	}
-	bool matchesTree(T number) {
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter, number);
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
-		iterator iter = this->begin();
-		uint8_t count = this->countRight(iter);
-		ReturnValue_t result = SerializeAdapter::serialize(&count,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (iter == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		result = iter->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			result = temp.serialize(buffer, size, maxSize, streamEndianness);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		iter = iter.right();
-		while (iter != this->end()) {
-			result = iter->serialize(buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			if (maxDepth > 0) {
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				result = temp.serialize(buffer, size, maxSize, streamEndianness);
-			}
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-			iter = iter.right();
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const override {
-		//Analogous to serialize!
-		uint32_t size = 1; //One for count
-		iterator iter = this->begin();
-		if (iter == this->end()) {
-			return size;
-		}
-		//Count object itself
-		size += iter->getSerializedSize();
-		//Handle everything below on AND side
-		if (maxDepth > 0) {
-			MatchTree<T> temp(iter.left(), maxDepth - 1);
-			size += temp.getSerializedSize();
-		}
-		//Handle everything on OR side
-		iter = iter.right();
-		//Iterate over every object on the OR branch
-		while (iter != this->end()) {
-			size += iter->getSerializedSize();
-			if (maxDepth > 0) {
-				//If we are allowed to go deeper, handle AND elements.
-				MatchTree<T> temp(iter.left(), maxDepth - 1);
-				size += temp.getSerializedSize();
-			}
-			iter = iter.right();
-		}
-		return size;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-
-	bool isOnAndBranch(iterator position) {
-		if ((position == this->end()) || (position.up() == this->end())) {
-			return false;
-		}
-		if (position.up().left() == position) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
-	ReturnValue_t removeElementAndAllChildren(iterator position) {
-		auto children = this->erase(position);
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (children.first != this->end()) {
-			result = removeElementAndAllChildren(children.first);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (children.second != this->end()) {
-			result = removeElementAndAllChildren(children.second);
-		}
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
-		if (position == this->end()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-		//Delete everything from the AND branch.
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if (position.left() != this->end()) {
-			result = removeElementAndAllChildren(position.left());
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-
-		if (position.right() != this->end()) {
-			//There's something at the OR branch, reconnect to parent.
-			if (isOnAndBranch(position)) {
-				//Either one hierarchy up AND branch...
-				this->insert(AND, position.up(), position.right().element);
-			} else {
-				//or on another OR'ed element (or install new root node).
-				this->insert(OR, position.up(), position.right().element);
-			}
-		} else {
-			if (isOnAndBranch(position)) {
-				//Recursively delete parent node as well, because it is not expected to be there anymore.
-				return removeElementAndReconnectChildren(position.up());
-			} else {
-				//simply delete self.
-				this->erase(position);
-			}
-
-		}
-		//Delete element itself.
-		return cleanUpElement(position);
-	}
-
-	virtual ReturnValue_t cleanUpElement(iterator position) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	bool matchSubtree(iterator iter, T number) {
-		bool isMatch = iter->match(number);
-		if (isMatch) {
-			if (iter.left() == this->end()) {
-				return true;
-			}
-			isMatch = matchSubtree(iter.left(), number);
-			if (isMatch) {
-				return true;
-			}
-		}
-		if (iter.right() == this->end()) {
-			return false;
-		}
-		return matchSubtree(iter.right(), number);
-	}
-private:
-	uint8_t maxDepth;
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
+
+#include "../../container/BinaryTree.h"
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class MatchTree: public SerializeableMatcherIF<T>, public BinaryTree<
+		SerializeableMatcherIF<T>> {
+public:
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MATCH_TREE_CLASS;
+	static const ReturnValue_t TOO_DETAILED_REQUEST = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t TOO_GENERAL_REQUEST = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t NO_MATCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t NEW_NODE_CREATED = MAKE_RETURN_CODE(5);
+
+	typedef typename BinaryTree<SerializeableMatcherIF<T>>::iterator iterator;
+	typedef BinaryNode<SerializeableMatcherIF<T>> Node;
+	static const bool AND = true; //LEFT
+	static const bool OR = false; //RIGHT
+	MatchTree(BinaryNode<SerializeableMatcherIF<T>>* root,
+			uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root), maxDepth(maxDepth) {
+	}
+	MatchTree(iterator root, uint8_t maxDepth = -1) :
+			BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(
+					maxDepth) {
+	}
+	MatchTree() :
+			BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {
+	}
+	virtual ~MatchTree() {
+	}
+	virtual bool match(T number) {
+		return matchesTree(number);
+	}
+	bool matchesTree(T number) {
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter, number);
+	}
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
+		iterator iter = this->begin();
+		uint8_t count = this->countRight(iter);
+		ReturnValue_t result = SerializeAdapter::serialize(&count,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (iter == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		result = iter->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			result = temp.serialize(buffer, size, maxSize, streamEndianness);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		iter = iter.right();
+		while (iter != this->end()) {
+			result = iter->serialize(buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			if (maxDepth > 0) {
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				result = temp.serialize(buffer, size, maxSize, streamEndianness);
+			}
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+			iter = iter.right();
+		}
+		return result;
+	}
+
+	size_t getSerializedSize() const override {
+		//Analogous to serialize!
+		uint32_t size = 1; //One for count
+		iterator iter = this->begin();
+		if (iter == this->end()) {
+			return size;
+		}
+		//Count object itself
+		size += iter->getSerializedSize();
+		//Handle everything below on AND side
+		if (maxDepth > 0) {
+			MatchTree<T> temp(iter.left(), maxDepth - 1);
+			size += temp.getSerializedSize();
+		}
+		//Handle everything on OR side
+		iter = iter.right();
+		//Iterate over every object on the OR branch
+		while (iter != this->end()) {
+			size += iter->getSerializedSize();
+			if (maxDepth > 0) {
+				//If we are allowed to go deeper, handle AND elements.
+				MatchTree<T> temp(iter.left(), maxDepth - 1);
+				size += temp.getSerializedSize();
+			}
+			iter = iter.right();
+		}
+		return size;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+
+	bool isOnAndBranch(iterator position) {
+		if ((position == this->end()) || (position.up() == this->end())) {
+			return false;
+		}
+		if (position.up().left() == position) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	//SHOULDDO: What to do if insertion/deletion fails. Throw event?
+	ReturnValue_t removeElementAndAllChildren(iterator position) {
+		auto children = this->erase(position);
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (children.first != this->end()) {
+			result = removeElementAndAllChildren(children.first);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (children.second != this->end()) {
+			result = removeElementAndAllChildren(children.second);
+		}
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	ReturnValue_t removeElementAndReconnectChildren(iterator position) {
+		if (position == this->end()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+		//Delete everything from the AND branch.
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		if (position.left() != this->end()) {
+			result = removeElementAndAllChildren(position.left());
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+
+		if (position.right() != this->end()) {
+			//There's something at the OR branch, reconnect to parent.
+			if (isOnAndBranch(position)) {
+				//Either one hierarchy up AND branch...
+				this->insert(AND, position.up(), position.right().element);
+			} else {
+				//or on another OR'ed element (or install new root node).
+				this->insert(OR, position.up(), position.right().element);
+			}
+		} else {
+			if (isOnAndBranch(position)) {
+				//Recursively delete parent node as well, because it is not expected to be there anymore.
+				return removeElementAndReconnectChildren(position.up());
+			} else {
+				//simply delete self.
+				this->erase(position);
+			}
+
+		}
+		//Delete element itself.
+		return cleanUpElement(position);
+	}
+
+	virtual ReturnValue_t cleanUpElement(iterator position) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	bool matchSubtree(iterator iter, T number) {
+		bool isMatch = iter->match(number);
+		if (isMatch) {
+			if (iter.left() == this->end()) {
+				return true;
+			}
+			isMatch = matchSubtree(iter.left(), number);
+			if (isMatch) {
+				return true;
+			}
+		}
+		if (iter.right() == this->end()) {
+			return false;
+		}
+		return matchSubtree(iter.right(), number);
+	}
+private:
+	uint8_t maxDepth;
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ */
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index ac67e8b8..04c9c3fa 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,70 +1,70 @@
-#ifndef RANGEMATCHER_H_
-#define RANGEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-
-template<typename T>
-class RangeMatcher: public SerializeableMatcherIF<T> {
-public:
-	bool inverted;
-	T lowerBound;
-	T upperBound;
-
-	RangeMatcher() :
-			inverted(true), lowerBound(1), upperBound(0) {
-	}
-	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
-			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
-	}
-
-	bool match(T input) {
-		if (inverted) {
-			return !doMatch(input);
-		} else {
-			return doMatch(input);
-		}
-	}
-
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&upperBound, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&inverted, buffer, size,
-				streamEndianness);
-	}
-protected:
-	bool doMatch(T input) {
-		return (input >= lowerBound) && (input <= upperBound);
-	}
-};
-
-#endif /* RANGEMATCHER_H_ */
+#ifndef RANGEMATCHER_H_
+#define RANGEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+
+template<typename T>
+class RangeMatcher: public SerializeableMatcherIF<T> {
+public:
+	bool inverted;
+	T lowerBound;
+	T upperBound;
+
+	RangeMatcher() :
+			inverted(true), lowerBound(1), upperBound(0) {
+	}
+	RangeMatcher(T lowerBound, T upperBound, bool inverted = false) :
+			inverted(inverted), lowerBound(lowerBound), upperBound(upperBound) {
+	}
+
+	bool match(T input) {
+		if (inverted) {
+			return !doMatch(input);
+		} else {
+			return doMatch(input);
+		}
+	}
+
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&upperBound, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&inverted, buffer, size,
+				streamEndianness);
+	}
+protected:
+	bool doMatch(T input) {
+		return (input >= lowerBound) && (input <= upperBound);
+	}
+};
+
+#endif /* RANGEMATCHER_H_ */
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index 0d2873ef..f99c6964 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
-
-#include "../../globalfunctions/matching/MatcherIF.h"
-#include "../../serialize/SerializeIF.h"
-
-template<typename T>
-class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
-public:
-	virtual ~SerializeableMatcherIF() {}
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
+#ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+#define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
+
+#include "../../globalfunctions/matching/MatcherIF.h"
+#include "../../serialize/SerializeIF.h"
+
+template<typename T>
+class SerializeableMatcherIF : public MatcherIF<T>, public SerializeIF {
+public:
+	virtual ~SerializeableMatcherIF() {}
+};
+
+#endif /* FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ */
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index 448d30f1..c6778de4 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,156 +1,156 @@
-#include "QuaternionOperations.h"
-#include "../../globalfunctions/math/VectorOperations.h"
-
-#include <cmath>
-#include <cstring>
-#include <stdint.h>
-
-QuaternionOperations::~QuaternionOperations() {
-}
-
-void QuaternionOperations::multiply(const double* q1, const double* q2,
-		double* q) {
-	double out[4];
-
-	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
-	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
-	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
-	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
-
-	memcpy(q, out, 4 * sizeof(*q));
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::inverse(const double* quaternion,
-		double* inverseQuaternion) {
-	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
-	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
-			inverseQuaternion, 3);
-}
-
-QuaternionOperations::QuaternionOperations() {
-
-}
-
-void QuaternionOperations::normalize(const double* quaternion,
-		double* unitQuaternion) {
-	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
-}
-
-float QuaternionOperations::norm(const double* quaternion) {
-	return VectorOperations<double>::norm(quaternion, 4);
-}
-
-void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
-		uint8_t *index) {
-
-	double a[4];
-
-	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
-	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
-	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
-	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
-
-	uint8_t maxAIndex = 0;
-
-	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
-
-	if (index != 0) {
-		*index = maxAIndex;
-	}
-
-	switch (maxAIndex) {
-	case 0:
-		quaternion[0] = 0.5 * sqrt(a[0]);
-		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
-		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
-		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
-		break;
-	case 1:
-		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
-		quaternion[1] = 0.5 * sqrt(a[1]);
-		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
-		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
-		break;
-	case 2:
-		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
-		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
-		quaternion[2] = 0.5 * sqrt(a[2]);
-		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
-		break;
-	case 3:
-		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
-		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
-		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
-		quaternion[3] = 0.5 * sqrt(a[3]);
-		break;
-	}
-
-}
-
-void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
-	dcm[0][0] = 2
-			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[0][1] = 2
-			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
-	dcm[0][2] = 2
-			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
-
-	dcm[1][0] = 2
-			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
-	dcm[1][1] = 2
-			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
-			- 1;
-	dcm[1][2] = 2
-			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
-
-	dcm[2][0] = 2
-			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
-	dcm[2][1] = 2
-			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
-	dcm[2][2] = 2
-			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
-			- 1;
-}
-
-void QuaternionOperations::normalize(double* quaternion) {
-	normalize(quaternion, quaternion);
-}
-
-double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
-	if (quaternion[3] >= 0) {
-		return 2 * acos(quaternion[3]);
-	} else {
-		if (abs) {
-			return 2 * acos(-quaternion[3]);
-		} else {
-			return -2 * acos(-quaternion[3]);
-		}
-	}
-}
+#include "QuaternionOperations.h"
+#include "../../globalfunctions/math/VectorOperations.h"
+
+#include <cmath>
+#include <cstring>
+#include <stdint.h>
+
+QuaternionOperations::~QuaternionOperations() {
+}
+
+void QuaternionOperations::multiply(const double* q1, const double* q2,
+		double* q) {
+	double out[4];
+
+	out[0] = q1[3] * q2[0] + q1[2] * q2[1] - q1[1] * q2[2] + q1[0] * q2[3];
+	out[1] = -q1[2] * q2[0] + q1[3] * q2[1] + q1[0] * q2[2] + q1[1] * q2[3];
+	out[2] = q1[1] * q2[0] - q1[0] * q2[1] + q1[3] * q2[2] + q1[2] * q2[3];
+	out[3] = -q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] + q1[3] * q2[3];
+
+	memcpy(q, out, 4 * sizeof(*q));
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, double dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::inverse(const double* quaternion,
+		double* inverseQuaternion) {
+	memcpy(inverseQuaternion, quaternion, 4 * sizeof(*quaternion));
+	VectorOperations<double>::mulScalar(inverseQuaternion, -1,
+			inverseQuaternion, 3);
+}
+
+QuaternionOperations::QuaternionOperations() {
+
+}
+
+void QuaternionOperations::normalize(const double* quaternion,
+		double* unitQuaternion) {
+	VectorOperations<double>::normalize(quaternion, unitQuaternion, 4);
+}
+
+float QuaternionOperations::norm(const double* quaternion) {
+	return VectorOperations<double>::norm(quaternion, 4);
+}
+
+void QuaternionOperations::fromDcm(const double dcm[][3], double* quaternion,
+		uint8_t *index) {
+
+	double a[4];
+
+	a[0] = 1 + dcm[0][0] - dcm[1][1] - dcm[2][2];
+	a[1] = 1 - dcm[0][0] + dcm[1][1] - dcm[2][2];
+	a[2] = 1 - dcm[0][0] - dcm[1][1] + dcm[2][2];
+	a[3] = 1 + dcm[0][0] + dcm[1][1] + dcm[2][2];
+
+	uint8_t maxAIndex = 0;
+
+	VectorOperations<double>::maxValue(a, 4, &maxAIndex);
+
+	if (index != 0) {
+		*index = maxAIndex;
+	}
+
+	switch (maxAIndex) {
+	case 0:
+		quaternion[0] = 0.5 * sqrt(a[0]);
+		quaternion[1] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[0]));
+		quaternion[2] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[0]));
+		quaternion[3] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[0]));
+		break;
+	case 1:
+		quaternion[0] = (dcm[0][1] + dcm[1][0]) / (2 * sqrt(a[1]));
+		quaternion[1] = 0.5 * sqrt(a[1]);
+		quaternion[2] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[1]));
+		quaternion[3] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[1]));
+		break;
+	case 2:
+		quaternion[0] = (dcm[0][2] + dcm[2][0]) / (2 * sqrt(a[2]));
+		quaternion[1] = (dcm[1][2] + dcm[2][1]) / (2 * sqrt(a[2]));
+		quaternion[2] = 0.5 * sqrt(a[2]);
+		quaternion[3] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[2]));
+		break;
+	case 3:
+		quaternion[0] = (dcm[1][2] - dcm[2][1]) / (2 * sqrt(a[3]));
+		quaternion[1] = (dcm[2][0] - dcm[0][2]) / (2 * sqrt(a[3]));
+		quaternion[2] = (dcm[0][1] - dcm[1][0]) / (2 * sqrt(a[3]));
+		quaternion[3] = 0.5 * sqrt(a[3]);
+		break;
+	}
+
+}
+
+void QuaternionOperations::toDcm(const double* quaternion, float dcm[][3]) {
+	dcm[0][0] = 2
+			* (quaternion[0] * quaternion[0] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[0][1] = 2
+			* (quaternion[0] * quaternion[1] + quaternion[2] * quaternion[3]);
+	dcm[0][2] = 2
+			* (quaternion[0] * quaternion[2] - quaternion[1] * quaternion[3]);
+
+	dcm[1][0] = 2
+			* (quaternion[0] * quaternion[1] - quaternion[2] * quaternion[3]);
+	dcm[1][1] = 2
+			* (quaternion[1] * quaternion[1] + quaternion[3] * quaternion[3])
+			- 1;
+	dcm[1][2] = 2
+			* (quaternion[1] * quaternion[2] + quaternion[0] * quaternion[3]);
+
+	dcm[2][0] = 2
+			* (quaternion[0] * quaternion[2] + quaternion[1] * quaternion[3]);
+	dcm[2][1] = 2
+			* (quaternion[1] * quaternion[2] - quaternion[0] * quaternion[3]);
+	dcm[2][2] = 2
+			* (quaternion[2] * quaternion[2] + quaternion[3] * quaternion[3])
+			- 1;
+}
+
+void QuaternionOperations::normalize(double* quaternion) {
+	normalize(quaternion, quaternion);
+}
+
+double QuaternionOperations::getAngle(const double* quaternion, bool abs) {
+	if (quaternion[3] >= 0) {
+		return 2 * acos(quaternion[3]);
+	} else {
+		if (abs) {
+			return 2 * acos(-quaternion[3]);
+		} else {
+			return -2 * acos(-quaternion[3]);
+		}
+	}
+}
diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp
index ae49ef21..1228da04 100644
--- a/globalfunctions/timevalOperations.cpp
+++ b/globalfunctions/timevalOperations.cpp
@@ -1,99 +1,99 @@
-#include "timevalOperations.h"
-
-timeval& operator+=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator+(timeval lhs, const timeval& rhs) {
-	lhs += rhs;
-	return lhs;
-}
-
-timeval& operator-=(timeval& lhs, const timeval& rhs) {
-	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
-	lhs.tv_sec = sum / 1000000;
-	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator-(timeval lhs, const timeval& rhs) {
-	lhs -= rhs;
-	return lhs;
-}
-
-double operator/(const timeval& lhs, const timeval& rhs) {
-	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 / rhs64;
-}
-
-timeval& operator/=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product /= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator/(timeval lhs, double scalar) {
-	lhs /= scalar;
-	return lhs;
-}
-
-timeval& operator*=(timeval& lhs, double scalar) {
-	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	product *= scalar;
-	lhs.tv_sec = product / 1000000;
-	lhs.tv_usec = product - lhs.tv_sec * 1000000;
-	return lhs;
-}
-
-timeval operator*(timeval lhs, double scalar) {
-	lhs *= scalar;
-	return lhs;
-}
-
-timeval operator*(double scalar, timeval rhs) {
-	rhs *= scalar;
-	return rhs;
-}
-
-bool operator==(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 == rhs64;
-}
-bool operator!=(const timeval& lhs, const timeval& rhs) {
-	return !operator==(lhs, rhs);
-}
-bool operator<(const timeval& lhs, const timeval& rhs) {
-	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
-	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
-	return lhs64 < rhs64;
-}
-bool operator>(const timeval& lhs, const timeval& rhs) {
-	return operator<(rhs, lhs);
-}
-bool operator<=(const timeval& lhs, const timeval& rhs) {
-	return !operator>(lhs, rhs);
-}
-bool operator>=(const timeval& lhs, const timeval& rhs) {
-	return !operator<(lhs, rhs);
-}
-
-double timevalOperations::toDouble(const timeval timeval) {
-	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
-	return result / 1000000.;
-}
-
-timeval timevalOperations::toTimeval(const double seconds) {
-	timeval tval;
-	tval.tv_sec = seconds;
-	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
-	return tval;
-}
+#include "timevalOperations.h"
+
+timeval& operator+=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum += rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator+(timeval lhs, const timeval& rhs) {
+	lhs += rhs;
+	return lhs;
+}
+
+timeval& operator-=(timeval& lhs, const timeval& rhs) {
+	int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	sum -= rhs.tv_sec * 1000000. + rhs.tv_usec;
+	lhs.tv_sec = sum / 1000000;
+	lhs.tv_usec = sum - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator-(timeval lhs, const timeval& rhs) {
+	lhs -= rhs;
+	return lhs;
+}
+
+double operator/(const timeval& lhs, const timeval& rhs) {
+	double lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	double rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 / rhs64;
+}
+
+timeval& operator/=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product /= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator/(timeval lhs, double scalar) {
+	lhs /= scalar;
+	return lhs;
+}
+
+timeval& operator*=(timeval& lhs, double scalar) {
+	int64_t product = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	product *= scalar;
+	lhs.tv_sec = product / 1000000;
+	lhs.tv_usec = product - lhs.tv_sec * 1000000;
+	return lhs;
+}
+
+timeval operator*(timeval lhs, double scalar) {
+	lhs *= scalar;
+	return lhs;
+}
+
+timeval operator*(double scalar, timeval rhs) {
+	rhs *= scalar;
+	return rhs;
+}
+
+bool operator==(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 == rhs64;
+}
+bool operator!=(const timeval& lhs, const timeval& rhs) {
+	return !operator==(lhs, rhs);
+}
+bool operator<(const timeval& lhs, const timeval& rhs) {
+	int64_t lhs64 = lhs.tv_sec * 1000000. + lhs.tv_usec;
+	int64_t rhs64 = rhs.tv_sec * 1000000. + rhs.tv_usec;
+	return lhs64 < rhs64;
+}
+bool operator>(const timeval& lhs, const timeval& rhs) {
+	return operator<(rhs, lhs);
+}
+bool operator<=(const timeval& lhs, const timeval& rhs) {
+	return !operator>(lhs, rhs);
+}
+bool operator>=(const timeval& lhs, const timeval& rhs) {
+	return !operator<(lhs, rhs);
+}
+
+double timevalOperations::toDouble(const timeval timeval) {
+	double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
+	return result / 1000000.;
+}
+
+timeval timevalOperations::toTimeval(const double seconds) {
+	timeval tval;
+	tval.tv_sec = seconds;
+	tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
+	return tval;
+}
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index 9ef8c1e9..ac404300 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,50 +1,50 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class HasHealthIF {
-public:
-
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
-
-	virtual ~HasHealthIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	virtual ReturnValue_t setHealth(HealthState health) = 0;
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	virtual HasHealthIF::HealthState getHealth() = 0;
-};
-
-#endif /* HASHEALTHIF_H_ */
+#ifndef HASHEALTHIF_H_
+#define HASHEALTHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasHealthIF {
+public:
+
+	typedef enum {
+		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
+	} HealthState;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
+	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+
+	virtual ~HasHealthIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	virtual ReturnValue_t setHealth(HealthState health) = 0;
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	virtual HasHealthIF::HealthState getHealth() = 0;
+};
+
+#endif /* HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 800d6e36..61718f99 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,105 +1,105 @@
-#include "../health/HealthHelper.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
-		objectId(objectId), owner(owner) {
-}
-
-HealthHelper::~HealthHelper() {
-}
-
-ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case HealthMessage::HEALTH_SET:
-		handleSetHealthCommand(message);
-		return HasReturnvaluesIF::RETURN_OK;
-	case HealthMessage::HEALTH_ANNOUNCE: {
-		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
-				getHealth());
-	}
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-HasHealthIF::HealthState HealthHelper::getHealth() {
-	return healthTable->getHealth(objectId);
-}
-
-ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQueue(parentQueue);
-	return initialize();
-}
-
-void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
-	this->parentQueue = parentQueue;
-}
-
-ReturnValue_t HealthHelper::initialize() {
-	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
-
-	if (healthTable == nullptr) {
-	    sif::error << "HealthHelper::initialize: Health table object needs"
-	            "to be created in factory." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	if(eventSender == nullptr) {
-	    sif::error << "HealthHelper::initialize: Owner has to implement "
-	            "ReportingProxyIF." << std::endl;
-	    return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	ReturnValue_t result = healthTable->registerObject(objectId,
-			HasHealthIF::HEALTHY);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthHelper::setHealth(HasHealthIF::HealthState health) {
-	HasHealthIF::HealthState oldHealth = getHealth();
-	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
-	if (health != oldHealth) {
-		healthTable->setHealth(objectId, health);
-		informParent(health, oldHealth);
-	}
-}
-
-void HealthHelper::informParent(HasHealthIF::HealthState health,
-		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage information;
-	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
-			health, oldHealth);
-	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::informParent: sending health reply failed."
-				<< std::endl;
-	}
-}
-
-void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
-	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
-		return;
-	}
-	CommandMessage reply;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		HealthMessage::setHealthMessage(&reply,
-				HealthMessage::REPLY_HEALTH_SET);
-	} else {
-		reply.setReplyRejected(result, command->getCommand());
-	}
-	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "HealthHelper::handleHealthCommand: sending health "
-		        "reply failed." << std::endl;
-
-	}
-}
+#include "../health/HealthHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
+		objectId(objectId), owner(owner) {
+}
+
+HealthHelper::~HealthHelper() {
+}
+
+ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case HealthMessage::HEALTH_SET:
+		handleSetHealthCommand(message);
+		return HasReturnvaluesIF::RETURN_OK;
+	case HealthMessage::HEALTH_ANNOUNCE: {
+		eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
+				getHealth());
+	}
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+HasHealthIF::HealthState HealthHelper::getHealth() {
+	return healthTable->getHealth(objectId);
+}
+
+ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
+	setParentQueue(parentQueue);
+	return initialize();
+}
+
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
+	this->parentQueue = parentQueue;
+}
+
+ReturnValue_t HealthHelper::initialize() {
+	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+
+	if (healthTable == nullptr) {
+	    sif::error << "HealthHelper::initialize: Health table object needs"
+	            "to be created in factory." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	if(eventSender == nullptr) {
+	    sif::error << "HealthHelper::initialize: Owner has to implement "
+	            "ReportingProxyIF." << std::endl;
+	    return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	ReturnValue_t result = healthTable->registerObject(objectId,
+			HasHealthIF::HEALTHY);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthHelper::setHealth(HasHealthIF::HealthState health) {
+	HasHealthIF::HealthState oldHealth = getHealth();
+	eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
+	if (health != oldHealth) {
+		healthTable->setHealth(objectId, health);
+		informParent(health, oldHealth);
+	}
+}
+
+void HealthHelper::informParent(HasHealthIF::HealthState health,
+		HasHealthIF::HealthState oldHealth) {
+	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage information;
+	HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
+			health, oldHealth);
+	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::informParent: sending health reply failed."
+				<< std::endl;
+	}
+}
+
+void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
+	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
+	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+		return;
+	}
+	CommandMessage reply;
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		HealthMessage::setHealthMessage(&reply,
+				HealthMessage::REPLY_HEALTH_SET);
+	} else {
+		reply.setReplyRejected(result, command->getCommand());
+	}
+	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "HealthHelper::handleHealthCommand: sending health "
+		        "reply failed." << std::endl;
+
+	}
+}
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 99bb501f..d8b81ca9 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
-
-#include "../events/EventManagerIF.h"
-#include "../events/EventReportingProxyIF.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../health/HealthTableIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * Helper class for Objects that implement HasHealthIF
- *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
- * changes, not for all @c HEALTH_SET commands received.
- *
- * It does NOT handle @c HEALTH_INFO messages
- */
-class HealthHelper {
-public:
-
-	/**
-	 * ctor
-	 *
-	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
-	 */
-	HealthHelper(HasHealthIF* owner, object_id_t objectId);
-
-	virtual ~HealthHelper();
-
-	/**
-	 * Pointer to the Health Table
-	 *
-	 * only valid after initialize() has been called
-	 */
-	HealthTableIF *healthTable = nullptr;
-
-	/**
-	 * Proxy to forward events.
-	 */
-	EventReportingProxyIF* eventSender = nullptr;
-
-	/**
-	 * Try to handle the message.
-	 *
-	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
-	 * it updates the Health Table and generates a reply to the sender.
-	 *
-	 * @param message
-	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
-	 */
-	ReturnValue_t handleHealthCommand(CommandMessage *message);
-
-	/**
-	 * set the Health State
-	 *
-	 * The parent will be informed, if the Health changes
-	 *
-	 * @param health
-	 */
-	void setHealth(HasHealthIF::HealthState health);
-
-	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
-	 */
-	HasHealthIF::HealthState getHealth();
-
-	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueue);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
-	 */
-	ReturnValue_t initialize(MessageQueueId_t parentQueue );
-
-	ReturnValue_t initialize();
-
-private:
-	/**
-	 * the object id to use when communicating with the Health Table
-	 */
-	object_id_t objectId;
-
-	/**
-	 * The Queue of the parent
-	 */
-	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
-
-	/**
-	 * The one using the healthHelper.
-	 */
-	HasHealthIF* owner;
-
-	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
-	 * @param oldHealth information of the previous health state.
-	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
-
-	void handleSetHealthCommand(CommandMessage *message);
-};
-
-#endif /* HEALTHHELPER_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../events/EventReportingProxyIF.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthMessage.h"
+#include "../health/HealthTableIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * Helper class for Objects that implement HasHealthIF
+ *
+ * It takes care of registering with the Health Table as well as handling health commands
+ * (including replying to the sender) and updating the Health Table.
+ *
+ * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
+ * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * changes, not for all @c HEALTH_SET commands received.
+ *
+ * It does NOT handle @c HEALTH_INFO messages
+ */
+class HealthHelper {
+public:
+
+	/**
+	 * ctor
+	 *
+	 * @param owner
+	 * @param objectId the object Id to use when communication with the HealthTable
+	 */
+	HealthHelper(HasHealthIF* owner, object_id_t objectId);
+
+	virtual ~HealthHelper();
+
+	/**
+	 * Pointer to the Health Table
+	 *
+	 * only valid after initialize() has been called
+	 */
+	HealthTableIF *healthTable = nullptr;
+
+	/**
+	 * Proxy to forward events.
+	 */
+	EventReportingProxyIF* eventSender = nullptr;
+
+	/**
+	 * Try to handle the message.
+	 *
+	 * This function handles @c HEALTH_SET and @c HEALTH_READ commands.
+	 * it updates the Health Table and generates a reply to the sender.
+	 *
+	 * @param message
+	 * @return
+	 * 			-@c RETURN_OK if the message was handled
+	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 */
+	ReturnValue_t handleHealthCommand(CommandMessage *message);
+
+	/**
+	 * set the Health State
+	 *
+	 * The parent will be informed, if the Health changes
+	 *
+	 * @param health
+	 */
+	void setHealth(HasHealthIF::HealthState health);
+
+	/**
+	 * get Health State
+	 *
+	 * @return Health State of the object
+	 */
+	HasHealthIF::HealthState getHealth();
+
+	/**
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueue);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @return
+	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
+	 * 			-@c RETURN_FAILED else
+	 */
+	ReturnValue_t initialize(MessageQueueId_t parentQueue );
+
+	ReturnValue_t initialize();
+
+private:
+	/**
+	 * the object id to use when communicating with the Health Table
+	 */
+	object_id_t objectId;
+
+	/**
+	 * The Queue of the parent
+	 */
+	MessageQueueId_t parentQueue = MessageQueueIF::NO_QUEUE;
+
+	/**
+	 * The one using the healthHelper.
+	 */
+	HasHealthIF* owner;
+
+	/**
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
+	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * @param oldHealth information of the previous health state.
+	 */
+	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+
+	void handleSetHealthCommand(CommandMessage *message);
+};
+
+#endif /* HEALTHHELPER_H_ */
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index c5f5b733..39c53fb1 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,28 +1,28 @@
-#include "../health/HealthMessage.h"
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
-		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
-	message->setCommand(command);
-	message->setParameter(health);
-	message->setParameter2(oldHealth);
-}
-
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
-	message->setCommand(command);
-}
-
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter();
-}
-
-void HealthMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-HealthMessage::HealthMessage() {
-}
-
-HasHealthIF::HealthState HealthMessage::getOldHealth(
-		const CommandMessage* message) {
-	return (HasHealthIF::HealthState) message->getParameter2();
-}
+#include "../health/HealthMessage.h"
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
+		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
+	message->setCommand(command);
+	message->setParameter(health);
+	message->setParameter2(oldHealth);
+}
+
+void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+	message->setCommand(command);
+}
+
+HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter();
+}
+
+void HealthMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+HealthMessage::HealthMessage() {
+}
+
+HasHealthIF::HealthState HealthMessage::getOldHealth(
+		const CommandMessage* message) {
+	return (HasHealthIF::HealthState) message->getParameter2();
+}
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index d16c65db..fa773d42 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,30 +1,30 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../ipc/CommandMessage.h"
-
-class HealthMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
-	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
-	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
-	static void setHealthMessage(CommandMessage *message, Command_t command);
-
-	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
-
-	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	HealthMessage();
-};
-
-#endif /* HEALTHMESSAGE_H_ */
+#ifndef HEALTHMESSAGE_H_
+#define HEALTHMESSAGE_H_
+
+#include "../health/HasHealthIF.h"
+#include "../ipc/CommandMessage.h"
+
+class HealthMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
+	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
+	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
+	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command,
+			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+
+	static void setHealthMessage(CommandMessage *message, Command_t command);
+
+	static HasHealthIF::HealthState getHealth(const CommandMessage *message);
+
+	static HasHealthIF::HealthState getOldHealth(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	HealthMessage();
+};
+
+#endif /* HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 88db89b1..1aa5a3ae 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,100 +1,100 @@
-#include "../health/HealthTable.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../ipc/MutexFactory.h"
-
-HealthTable::HealthTable(object_id_t objectid) :
-		SystemObject(objectid) {
-	mutex = MutexFactory::instance()->createMutex();;
-
-	mapIterator = healthMap.begin();
-}
-
-HealthTable::~HealthTable() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t HealthTable::registerObject(object_id_t object,
-		HasHealthIF::HealthState initilialState) {
-	if (healthMap.count(object) != 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HealthTable::setHealth(object_id_t object,
-		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		iter->second = newState;
-	}
-	mutex->unlockMutex();
-}
-
-HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
-	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		state = iter->second;
-	}
-	mutex->unlockMutex();
-	return state;
-}
-
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
-
-bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	HealthMap::iterator iter = healthMap.find(object);
-	if (iter != healthMap.end()) {
-		exits = true;
-	}
-	mutex->unlockMutex();
-	return exits;
-}
-
-void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	size_t size = 0;
-	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
-			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
-				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
-				maxSize, SerializeIF::Endianness::BIG);
-	}
-	mutex->unlockMutex();
-}
-
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	if (reset) {
-		mapIterator = healthMap.begin();
-	}
-	if (mapIterator == healthMap.end()) {
-		result = HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*value = *mapIterator;
-	mapIterator++;
-	mutex->unlockMutex();
-
-	return result;
-}
+#include "../health/HealthTable.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../ipc/MutexFactory.h"
+
+HealthTable::HealthTable(object_id_t objectid) :
+		SystemObject(objectid) {
+	mutex = MutexFactory::instance()->createMutex();;
+
+	mapIterator = healthMap.begin();
+}
+
+HealthTable::~HealthTable() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t HealthTable::registerObject(object_id_t object,
+		HasHealthIF::HealthState initilialState) {
+	if (healthMap.count(object) != 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	healthMap.insert(
+			std::pair<object_id_t, HasHealthIF::HealthState>(object,
+					initilialState));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void HealthTable::setHealth(object_id_t object,
+		HasHealthIF::HealthState newState) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		iter->second = newState;
+	}
+	mutex->unlockMutex();
+}
+
+HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
+	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		state = iter->second;
+	}
+	mutex->unlockMutex();
+	return state;
+}
+
+uint32_t HealthTable::getPrintSize() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	uint32_t size = healthMap.size() * 5 + 2;
+	mutex->unlockMutex();
+	return size;
+}
+
+bool HealthTable::hasHealth(object_id_t object) {
+	bool exits = false;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	HealthMap::iterator iter = healthMap.find(object);
+	if (iter != healthMap.end()) {
+		exits = true;
+	}
+	mutex->unlockMutex();
+	return exits;
+}
+
+void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	size_t size = 0;
+	uint16_t count = healthMap.size();
+	ReturnValue_t result = SerializeAdapter::serialize(&count,
+			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+	HealthMap::iterator iter;
+	for (iter = healthMap.begin();
+			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
+			++iter) {
+		result = SerializeAdapter::serialize(&iter->first,
+				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
+		uint8_t health = iter->second;
+		result = SerializeAdapter::serialize(&health, &pointer, &size,
+				maxSize, SerializeIF::Endianness::BIG);
+	}
+	mutex->unlockMutex();
+}
+
+ReturnValue_t HealthTable::iterate(
+		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	if (reset) {
+		mapIterator = healthMap.begin();
+	}
+	if (mapIterator == healthMap.end()) {
+		result = HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*value = *mapIterator;
+	mapIterator++;
+	mutex->unlockMutex();
+
+	return result;
+}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 5ed45041..0f54a264 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,35 +1,35 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
-
-#include "../health/HealthTableIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-
-class HealthTable: public HealthTableIF, public SystemObject {
-public:
-	HealthTable(object_id_t objectid);
-	virtual ~HealthTable();
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
-
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
-
-protected:
-	MutexIF* mutex;
-	HealthMap healthMap;
-
-	HealthMap::iterator mapIterator;
-
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
-};
-
-#endif /* HEALTHTABLE_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+
+#include "../health/HealthTableIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+#include <map>
+
+typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+
+class HealthTable: public HealthTableIF, public SystemObject {
+public:
+	HealthTable(object_id_t objectid);
+	virtual ~HealthTable();
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+
+	virtual bool hasHealth(object_id_t object);
+	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
+	virtual HasHealthIF::HealthState getHealth(object_id_t);
+
+	virtual uint32_t getPrintSize();
+	virtual void printAll(uint8_t *pointer, size_t maxSize);
+
+protected:
+	MutexIF* mutex;
+	HealthMap healthMap;
+
+	HealthMap::iterator mapIterator;
+
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+};
+
+#endif /* HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index bc4a8cfb..f18f0315 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-
-#include "../health/ManagesHealthIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <map>
-
-
-class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
-public:
-	virtual ~HealthTableIF() {
-	}
-
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
-
-	virtual uint32_t getPrintSize() = 0;
-	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
-
-protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
-};
-
-#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
+#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+
+#include "../health/ManagesHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <map>
+
+
+class HealthTableIF: public ManagesHealthIF {
+	// TODO: This is in the mission folder and not in the framework folder.
+	// delete it?
+	friend class HealthCommandingService;
+public:
+	virtual ~HealthTableIF() {
+	}
+
+	virtual ReturnValue_t registerObject(object_id_t object,
+			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
+
+	virtual uint32_t getPrintSize() = 0;
+	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
+
+protected:
+	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+};
+
+#endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index 57996dda..8ca17012 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,52 +1,52 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-
-#include "../health/HasHealthIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-class ManagesHealthIF {
-public:
-	virtual ~ManagesHealthIF() {
-	}
-	virtual bool hasHealth(object_id_t object) = 0;
-	virtual void setHealth(object_id_t object,
-			HasHealthIF::HealthState newState) = 0;
-	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
-
-	virtual bool isHealthy(object_id_t object) {
-		return (getHealth(object) == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isHealthy(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::HEALTHY);
-	}
-
-	virtual bool isFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(object_id_t object) {
-		HasHealthIF::HealthState health = getHealth(object);
-		return isPermanentFaulty(health);
-	}
-
-	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
-		return (health == HasHealthIF::PERMANENT_FAULTY);
-	}
-
-	static bool isFaulty(HasHealthIF::HealthState health) {
-		return ((health == HasHealthIF::FAULTY)
-				|| (health == HasHealthIF::PERMANENT_FAULTY)
-				|| (health == HasHealthIF::NEEDS_RECOVERY));
-	}
-
-	virtual bool isCommandable(object_id_t object) {
-		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
-	}
-
-	virtual bool isCommandable(HasHealthIF::HealthState health) {
-		return (health != HasHealthIF::EXTERNAL_CONTROL);
-	}
-};
-
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+
+#include "../health/HasHealthIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+class ManagesHealthIF {
+public:
+	virtual ~ManagesHealthIF() {
+	}
+	virtual bool hasHealth(object_id_t object) = 0;
+	virtual void setHealth(object_id_t object,
+			HasHealthIF::HealthState newState) = 0;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) = 0;
+
+	virtual bool isHealthy(object_id_t object) {
+		return (getHealth(object) == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isHealthy(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::HEALTHY);
+	}
+
+	virtual bool isFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(object_id_t object) {
+		HasHealthIF::HealthState health = getHealth(object);
+		return isPermanentFaulty(health);
+	}
+
+	virtual bool isPermanentFaulty(HasHealthIF::HealthState health) {
+		return (health == HasHealthIF::PERMANENT_FAULTY);
+	}
+
+	static bool isFaulty(HasHealthIF::HealthState health) {
+		return ((health == HasHealthIF::FAULTY)
+				|| (health == HasHealthIF::PERMANENT_FAULTY)
+				|| (health == HasHealthIF::NEEDS_RECOVERY));
+	}
+
+	virtual bool isCommandable(object_id_t object) {
+		return (getHealth(object) != HasHealthIF::EXTERNAL_CONTROL);
+	}
+
+	virtual bool isCommandable(HasHealthIF::HealthState health) {
+		return (health != HasHealthIF::EXTERNAL_CONTROL);
+	}
+};
+
+#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index 879aaf8e..b3ba6e7c 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
-#include "../ipc/MessageQueueMessageIF.h"
-
-class AcceptsHkPacketsIF {
-public:
-    virtual~ AcceptsHkPacketsIF() {};
-    virtual MessageQueueId_t getHkQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
+#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+#include "../ipc/MessageQueueMessageIF.h"
+
+class AcceptsHkPacketsIF {
+public:
+    virtual~ AcceptsHkPacketsIF() {};
+    virtual MessageQueueId_t getHkQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index ed064da6..3424266b 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,125 +1,125 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "InternalErrorReporter.h"
-
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../ipc/MutexFactory.h"
-
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-InternalErrorReporter::~InternalErrorReporter() {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-
-	uint32_t newQueueHits = getAndResetQueueHits();
-	uint32_t newTmHits = getAndResetTmHits();
-	uint32_t newStoreHits = getAndResetStoreHits();
-
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
-
-	mySet.commit(PoolVariableIF::VALID);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void InternalErrorReporter::queueMessageNotSent() {
-	incrementQueueHits();
-}
-
-void InternalErrorReporter::lostTm() {
-	incrementTmHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	queueHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getQueueHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = queueHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	queueHits++;
-	mutex->unlockMutex();
-}
-
-uint32_t InternalErrorReporter::getAndResetTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	tmHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getTmHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = tmHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	tmHits++;
-	mutex->unlockMutex();
-}
-
-void InternalErrorReporter::storeFull() {
-	incrementStoreHits();
-}
-
-uint32_t InternalErrorReporter::getAndResetStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	storeHits = 0;
-	mutex->unlockMutex();
-	return value;
-}
-
-uint32_t InternalErrorReporter::getStoreHits() {
-	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
-	value = storeHits;
-	mutex->unlockMutex();
-	return value;
-}
-
-void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	storeHits++;
-	mutex->unlockMutex();
-}
+#include "../datapoolglob/GlobalDataSet.h"
+#include "InternalErrorReporter.h"
+
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../ipc/MutexFactory.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
+		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
+		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
+		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
+		storeHits(0) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+InternalErrorReporter::~InternalErrorReporter() {
+	MutexFactory::instance()->deleteMutex(mutex);
+}
+
+ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
+
+	GlobDataSet mySet;
+	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+
+	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
+			PoolVariableIF::VAR_READ_WRITE);
+	mySet.read();
+
+	uint32_t newQueueHits = getAndResetQueueHits();
+	uint32_t newTmHits = getAndResetTmHits();
+	uint32_t newStoreHits = getAndResetStoreHits();
+
+	queueHitsInPool.value += newQueueHits;
+	tmHitsInPool.value += newTmHits;
+	storeHitsInPool.value += newStoreHits;
+
+	mySet.commit(PoolVariableIF::VALID);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void InternalErrorReporter::queueMessageNotSent() {
+	incrementQueueHits();
+}
+
+void InternalErrorReporter::lostTm() {
+	incrementTmHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	queueHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getQueueHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = queueHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementQueueHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	queueHits++;
+	mutex->unlockMutex();
+}
+
+uint32_t InternalErrorReporter::getAndResetTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	tmHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getTmHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = tmHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementTmHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	tmHits++;
+	mutex->unlockMutex();
+}
+
+void InternalErrorReporter::storeFull() {
+	incrementStoreHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	storeHits = 0;
+	mutex->unlockMutex();
+	return value;
+}
+
+uint32_t InternalErrorReporter::getStoreHits() {
+	uint32_t value;
+	mutex->lockMutex(MutexIF::BLOCKING);
+	value = storeHits;
+	mutex->unlockMutex();
+	return value;
+}
+
+void InternalErrorReporter::incrementStoreHits() {
+	mutex->lockMutex(MutexIF::BLOCKING);
+	storeHits++;
+	mutex->unlockMutex();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1fe7426d..9aa24a0f 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,50 +1,50 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
-
-#include "InternalErrorReporterIF.h"
-
-#include "../tasks/ExecutableObjectIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MutexIF.h"
-
-class InternalErrorReporter: public SystemObject,
-		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
-public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
-	virtual ~InternalErrorReporter();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual void queueMessageNotSent();
-
-	virtual void lostTm();
-
-	virtual void storeFull();
-protected:
-	MutexIF* mutex;
-
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
-
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
-
-	uint32_t getAndResetQueueHits();
-	uint32_t getQueueHits();
-	void incrementQueueHits();
-
-	uint32_t getAndResetTmHits();
-	uint32_t getTmHits();
-	void incrementTmHits();
-
-	uint32_t getAndResetStoreHits();
-	uint32_t getStoreHits();
-	void incrementStoreHits();
-
-};
-
-#endif /* INTERNALERRORREPORTER_H_ */
+#ifndef INTERNALERRORREPORTER_H_
+#define INTERNALERRORREPORTER_H_
+
+#include "InternalErrorReporterIF.h"
+
+#include "../tasks/ExecutableObjectIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MutexIF.h"
+
+class InternalErrorReporter: public SystemObject,
+		public ExecutableObjectIF,
+		public InternalErrorReporterIF {
+public:
+	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
+			uint32_t tmPoolId, uint32_t storePoolId);
+	virtual ~InternalErrorReporter();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual void queueMessageNotSent();
+
+	virtual void lostTm();
+
+	virtual void storeFull();
+protected:
+	MutexIF* mutex;
+
+	uint32_t queuePoolId;
+	uint32_t tmPoolId;
+	uint32_t storePoolId;
+
+	uint32_t queueHits;
+	uint32_t tmHits;
+	uint32_t storeHits;
+
+	uint32_t getAndResetQueueHits();
+	uint32_t getQueueHits();
+	void incrementQueueHits();
+
+	uint32_t getAndResetTmHits();
+	uint32_t getTmHits();
+	void incrementTmHits();
+
+	uint32_t getAndResetStoreHits();
+	uint32_t getStoreHits();
+	void incrementStoreHits();
+
+};
+
+#endif /* INTERNALERRORREPORTER_H_ */
diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp
index 16293608..513debd3 100644
--- a/ipc/CommandMessage.cpp
+++ b/ipc/CommandMessage.cpp
@@ -1,111 +1,111 @@
-#include "CommandMessage.h"
-#include "CommandMessageCleaner.h"
-#include <cstring>
-
-CommandMessage::CommandMessage() {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(CMD_NONE);
-}
-
-CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
-        uint32_t parameter2) {
-    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
-    setCommand(command);
-    setParameter(parameter1);
-    setParameter2(parameter2);
-}
-
-Command_t CommandMessage::getCommand() const {
-    Command_t command;
-    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
-    return command;
-}
-
-void CommandMessage::setCommand(Command_t command) {
-    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
-}
-
-uint8_t CommandMessage::getMessageType() const {
-    // first byte of command ID.
-    return getCommand() >> 8 & 0xff;
-}
-
-uint32_t CommandMessage::getParameter() const {
-    uint32_t parameter1;
-    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
-    return parameter1;
-}
-
-void CommandMessage::setParameter(uint32_t parameter1) {
-    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
-}
-
-uint32_t CommandMessage::getParameter2() const {
-    uint32_t parameter2;
-    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
-            sizeof(parameter2));
-    return parameter2;
-}
-
-void CommandMessage::setParameter2(uint32_t parameter2) {
-    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
-            sizeof(parameter2));
-}
-
-uint32_t CommandMessage::getParameter3() const {
-    uint32_t parameter3;
-    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
-            sizeof(parameter3));
-    return parameter3;
-}
-
-void CommandMessage::setParameter3(uint32_t parameter3) {
-    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
-            sizeof(parameter3));
-}
-
-size_t CommandMessage::getMinimumMessageSize() const {
-    return MINIMUM_COMMAND_MESSAGE_SIZE;
-}
-
-void CommandMessage::clearCommandMessage() {
-    clear();
-}
-
-void CommandMessage::clear() {
-    CommandMessageCleaner::clearCommandMessage(this);
-}
-
-bool CommandMessage::isClearedCommandMessage() {
-    return getCommand() == CMD_NONE;
-}
-
-void CommandMessage::setToUnknownCommand() {
-    Command_t initialCommand = getCommand();
-    this->clear();
-    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
-}
-
-void CommandMessage::setReplyRejected(ReturnValue_t reason,
-        Command_t initialCommand) {
-	setCommand(REPLY_REJECTED);
-    setParameter(reason);
-    setParameter2(initialCommand);
-}
-
-ReturnValue_t CommandMessage::getReplyRejectedReason(
-        Command_t *initialCommand) const {
-    ReturnValue_t reason = getParameter();
-    if(initialCommand != nullptr) {
-        *initialCommand = getParameter2();
-    }
-    return reason;
-}
-
-uint8_t* CommandMessage::getData() {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
-
-const uint8_t* CommandMessage::getData() const {
-    return MessageQueueMessage::getData() + sizeof(Command_t);
-}
+#include "CommandMessage.h"
+#include "CommandMessageCleaner.h"
+#include <cstring>
+
+CommandMessage::CommandMessage() {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(CMD_NONE);
+}
+
+CommandMessage::CommandMessage(Command_t command, uint32_t parameter1,
+        uint32_t parameter2) {
+    MessageQueueMessage::setMessageSize(DEFAULT_COMMAND_MESSAGE_SIZE);
+    setCommand(command);
+    setParameter(parameter1);
+    setParameter2(parameter2);
+}
+
+Command_t CommandMessage::getCommand() const {
+    Command_t command;
+    std::memcpy(&command, MessageQueueMessage::getData(), sizeof(Command_t));
+    return command;
+}
+
+void CommandMessage::setCommand(Command_t command) {
+    std::memcpy(MessageQueueMessage::getData(), &command, sizeof(Command_t));
+}
+
+uint8_t CommandMessage::getMessageType() const {
+    // first byte of command ID.
+    return getCommand() >> 8 & 0xff;
+}
+
+uint32_t CommandMessage::getParameter() const {
+    uint32_t parameter1;
+    std::memcpy(&parameter1, this->getData(), sizeof(parameter1));
+    return parameter1;
+}
+
+void CommandMessage::setParameter(uint32_t parameter1) {
+    std::memcpy(this->getData(), &parameter1, sizeof(parameter1));
+}
+
+uint32_t CommandMessage::getParameter2() const {
+    uint32_t parameter2;
+    std::memcpy(&parameter2, this->getData() + sizeof(uint32_t),
+            sizeof(parameter2));
+    return parameter2;
+}
+
+void CommandMessage::setParameter2(uint32_t parameter2) {
+    std::memcpy(this->getData()  + sizeof(uint32_t), &parameter2,
+            sizeof(parameter2));
+}
+
+uint32_t CommandMessage::getParameter3() const {
+    uint32_t parameter3;
+    std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
+            sizeof(parameter3));
+    return parameter3;
+}
+
+void CommandMessage::setParameter3(uint32_t parameter3) {
+    std::memcpy(this->getData()  + 2 * sizeof(uint32_t), &parameter3,
+            sizeof(parameter3));
+}
+
+size_t CommandMessage::getMinimumMessageSize() const {
+    return MINIMUM_COMMAND_MESSAGE_SIZE;
+}
+
+void CommandMessage::clearCommandMessage() {
+    clear();
+}
+
+void CommandMessage::clear() {
+    CommandMessageCleaner::clearCommandMessage(this);
+}
+
+bool CommandMessage::isClearedCommandMessage() {
+    return getCommand() == CMD_NONE;
+}
+
+void CommandMessage::setToUnknownCommand() {
+    Command_t initialCommand = getCommand();
+    this->clear();
+    setReplyRejected(UNKNOWN_COMMAND, initialCommand);
+}
+
+void CommandMessage::setReplyRejected(ReturnValue_t reason,
+        Command_t initialCommand) {
+	setCommand(REPLY_REJECTED);
+    setParameter(reason);
+    setParameter2(initialCommand);
+}
+
+ReturnValue_t CommandMessage::getReplyRejectedReason(
+        Command_t *initialCommand) const {
+    ReturnValue_t reason = getParameter();
+    if(initialCommand != nullptr) {
+        *initialCommand = getParameter2();
+    }
+    return reason;
+}
+
+uint8_t* CommandMessage::getData() {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
+
+const uint8_t* CommandMessage::getData() const {
+    return MessageQueueMessage::getData() + sizeof(Command_t);
+}
diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 3be9a120..ca7b817f 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -1,129 +1,129 @@
-#ifndef FSFW_IPC_COMMANDMESSAGE_H_
-#define FSFW_IPC_COMMANDMESSAGE_H_
-
-#include "CommandMessageIF.h"
-#include "MessageQueueMessage.h"
-#include "FwMessageTypes.h"
-
-/**
- * @brief 	Default command message used to pass command messages between tasks.
- * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
- * @details
- * It operates on an external memory which is contained inside a
- * class implementing MessageQueueMessageIF by taking its address.
- * This allows for a more flexible designs of message implementations.
- * The pointer can be passed to different message implementations without
- * the need of unnecessary copying.
- *
- * The command message is based of the generic MessageQueueMessage which
- * currently has an internal message size of 28 bytes.
- * @author	Bastian Baetz
- */
-class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
-public:
-    /**
-     * Default size can accomodate 2 4-byte parameters.
-     */
-    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
-
-	/**
-	 * @brief   Default Constructor, does not initialize anything.
-	 * @details
-	 * This constructor should be used when receiving a Message, as the
-	 * content is filled by the MessageQueue.
-	 */
-	CommandMessage();
-	/**
-	 * This constructor creates a new message with all message content
-	 * initialized
-	 *
-	 * @param command	The DeviceHandlerCommand_t that will be sent
-	 * @param parameter1	The first parameter
-	 * @param parameter2	The second parameter
-	 */
-	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
-
-	/**
-	 * @brief 	Default Destructor
-	 */
-	virtual ~CommandMessage() {}
-
-    /**
-     * Read the DeviceHandlerCommand_t that is stored in the message,
-     * usually used after receiving.
-     *
-     * @return the Command stored in the Message
-     */
-    virtual Command_t getCommand() const override;
-    /**
-     * Set the command type of the message. Default implementation also
-     * sets the message type, which will be the first byte of the command ID.
-     * @param the Command to be sent
-     */
-    virtual void setCommand(Command_t command);
-
-    virtual uint8_t* getData() override;
-    virtual const uint8_t* getData() const override;
-
-	/**
-	 * Get the first parameter of the message
-	 * @return the first Parameter of the message
-	 */
-	uint32_t getParameter() const;
-	/**
-	 * Set the first parameter of the message
-	 * @param the first parameter of the message
-	 */
-	void setParameter(uint32_t parameter1);
-	uint32_t getParameter2() const;
-	void setParameter2(uint32_t parameter2);
-	uint32_t getParameter3() const;
-	void setParameter3(uint32_t parameter3);
-
-	/**
-	 * check if a message was cleared
-	 *
-	 * @return if the command is CMD_NONE
-	 */
-	bool isClearedCommandMessage();
-
-	/**
-	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
-	 * Is needed quite often, so we better code it once only.
-	 */
-	void setToUnknownCommand() override;
-
-    /**
-     * A command message can be rejected and needs to offer a function
-     * to set a rejected reply
-     * @param reason
-     * @param initialCommand
-     */
-    void setReplyRejected(ReturnValue_t reason,
-            Command_t initialCommand) override;
-    /**
-     * Corrensonding getter function.
-     * @param initialCommand
-     * @return
-     */
-    ReturnValue_t getReplyRejectedReason(
-            Command_t* initialCommand = nullptr) const override;
-
-
-    virtual void clear() override;
-    void clearCommandMessage();
-
-    /**
-     * Extract message ID, which is the first byte of the command ID for the
-     * default implementation.
-     * @return
-     */
-    virtual uint8_t getMessageType() const override;
-
-    /** MessageQueueMessageIF functions used for minimum size check. */
-    size_t getMinimumMessageSize() const override;
-};
-
-#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
+#ifndef FSFW_IPC_COMMANDMESSAGE_H_
+#define FSFW_IPC_COMMANDMESSAGE_H_
+
+#include "CommandMessageIF.h"
+#include "MessageQueueMessage.h"
+#include "FwMessageTypes.h"
+
+/**
+ * @brief 	Default command message used to pass command messages between tasks.
+ * 			Primary message type for IPC. Contains sender, 2-byte command ID
+ * 			field, and 2 4-byte parameters.
+ * @details
+ * It operates on an external memory which is contained inside a
+ * class implementing MessageQueueMessageIF by taking its address.
+ * This allows for a more flexible designs of message implementations.
+ * The pointer can be passed to different message implementations without
+ * the need of unnecessary copying.
+ *
+ * The command message is based of the generic MessageQueueMessage which
+ * currently has an internal message size of 28 bytes.
+ * @author	Bastian Baetz
+ */
+class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
+public:
+    /**
+     * Default size can accomodate 2 4-byte parameters.
+     */
+    static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+
+	/**
+	 * @brief   Default Constructor, does not initialize anything.
+	 * @details
+	 * This constructor should be used when receiving a Message, as the
+	 * content is filled by the MessageQueue.
+	 */
+	CommandMessage();
+	/**
+	 * This constructor creates a new message with all message content
+	 * initialized
+	 *
+	 * @param command	The DeviceHandlerCommand_t that will be sent
+	 * @param parameter1	The first parameter
+	 * @param parameter2	The second parameter
+	 */
+	CommandMessage(Command_t command, uint32_t parameter1, uint32_t parameter2);
+
+	/**
+	 * @brief 	Default Destructor
+	 */
+	virtual ~CommandMessage() {}
+
+    /**
+     * Read the DeviceHandlerCommand_t that is stored in the message,
+     * usually used after receiving.
+     *
+     * @return the Command stored in the Message
+     */
+    virtual Command_t getCommand() const override;
+    /**
+     * Set the command type of the message. Default implementation also
+     * sets the message type, which will be the first byte of the command ID.
+     * @param the Command to be sent
+     */
+    virtual void setCommand(Command_t command);
+
+    virtual uint8_t* getData() override;
+    virtual const uint8_t* getData() const override;
+
+	/**
+	 * Get the first parameter of the message
+	 * @return the first Parameter of the message
+	 */
+	uint32_t getParameter() const;
+	/**
+	 * Set the first parameter of the message
+	 * @param the first parameter of the message
+	 */
+	void setParameter(uint32_t parameter1);
+	uint32_t getParameter2() const;
+	void setParameter2(uint32_t parameter2);
+	uint32_t getParameter3() const;
+	void setParameter3(uint32_t parameter3);
+
+	/**
+	 * check if a message was cleared
+	 *
+	 * @return if the command is CMD_NONE
+	 */
+	bool isClearedCommandMessage();
+
+	/**
+	 * Sets the command to REPLY_REJECTED with parameter UNKNOWN_COMMAND.
+	 * Is needed quite often, so we better code it once only.
+	 */
+	void setToUnknownCommand() override;
+
+    /**
+     * A command message can be rejected and needs to offer a function
+     * to set a rejected reply
+     * @param reason
+     * @param initialCommand
+     */
+    void setReplyRejected(ReturnValue_t reason,
+            Command_t initialCommand) override;
+    /**
+     * Corrensonding getter function.
+     * @param initialCommand
+     * @return
+     */
+    ReturnValue_t getReplyRejectedReason(
+            Command_t* initialCommand = nullptr) const override;
+
+
+    virtual void clear() override;
+    void clearCommandMessage();
+
+    /**
+     * Extract message ID, which is the first byte of the command ID for the
+     * default implementation.
+     * @return
+     */
+    virtual uint8_t getMessageType() const override;
+
+    /** MessageQueueMessageIF functions used for minimum size check. */
+    size_t getMinimumMessageSize() const override;
+};
+
+#endif /* FSFW_IPC_COMMANDMESSAGE_H_ */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index a4dec78d..6a99b4d2 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,45 +1,45 @@
-#include "../ipc/CommandMessageCleaner.h"
-
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../health/HealthMessage.h"
-#include "../memory/MemoryMessage.h"
-#include "../modes/ModeMessage.h"
-#include "../monitoring/MonitoringMessage.h"
-#include "../subsystem/modes/ModeSequenceMessage.h"
-#include "../tmstorage/TmStoreMessage.h"
-#include "../parameters/ParameterMessage.h"
-
-void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
-	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
-		ModeMessage::clear(message);
-		break;
-	case messagetypes::HEALTH_COMMAND:
-		HealthMessage::clear(message);
-		break;
-	case messagetypes::MODE_SEQUENCE:
-		ModeSequenceMessage::clear(message);
-		break;
-	case messagetypes::ACTION:
-		ActionMessage::clear(message);
-		break;
-	case messagetypes::DEVICE_HANDLER_COMMAND:
-		DeviceHandlerMessage::clear(message);
-		break;
-	case messagetypes::MEMORY:
-		MemoryMessage::clear(message);
-		break;
-	case messagetypes::MONITORING:
-		MonitoringMessage::clear(message);
-		break;
-	case messagetypes::TM_STORE:
-		TmStoreMessage::clear(message);
-		break;
-	case messagetypes::PARAMETER:
-		ParameterMessage::clear(message);
-		break;
-	default:
-		messagetypes::clearMissionMessage(message);
-		break;
-	}
-}
+#include "../ipc/CommandMessageCleaner.h"
+
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../health/HealthMessage.h"
+#include "../memory/MemoryMessage.h"
+#include "../modes/ModeMessage.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../subsystem/modes/ModeSequenceMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
+#include "../parameters/ParameterMessage.h"
+
+void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
+	switch(message->getMessageType()){
+	case  messagetypes::MODE_COMMAND:
+		ModeMessage::clear(message);
+		break;
+	case messagetypes::HEALTH_COMMAND:
+		HealthMessage::clear(message);
+		break;
+	case messagetypes::MODE_SEQUENCE:
+		ModeSequenceMessage::clear(message);
+		break;
+	case messagetypes::ACTION:
+		ActionMessage::clear(message);
+		break;
+	case messagetypes::DEVICE_HANDLER_COMMAND:
+		DeviceHandlerMessage::clear(message);
+		break;
+	case messagetypes::MEMORY:
+		MemoryMessage::clear(message);
+		break;
+	case messagetypes::MONITORING:
+		MonitoringMessage::clear(message);
+		break;
+	case messagetypes::TM_STORE:
+		TmStoreMessage::clear(message);
+		break;
+	case messagetypes::PARAMETER:
+		ParameterMessage::clear(message);
+		break;
+	default:
+		messagetypes::clearMissionMessage(message);
+		break;
+	}
+}
diff --git a/ipc/CommandMessageCleaner.h b/ipc/CommandMessageCleaner.h
index f17bf282..2bf4a193 100644
--- a/ipc/CommandMessageCleaner.h
+++ b/ipc/CommandMessageCleaner.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
-#include "../ipc/CommandMessage.h"
-
-namespace messagetypes {
-// Implemented in config.
-void clearMissionMessage(CommandMessage* message);
-}
-
-class CommandMessageCleaner {
-public:
-	static void clearCommandMessage(CommandMessage* message);
-};
-
-
-#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
+#ifndef FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#define FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_
+#include "../ipc/CommandMessage.h"
+
+namespace messagetypes {
+// Implemented in config.
+void clearMissionMessage(CommandMessage* message);
+}
+
+class CommandMessageCleaner {
+public:
+	static void clearCommandMessage(CommandMessage* message);
+};
+
+
+#endif /* FRAMEWORK_IPC_COMMANDMESSAGECLEANER_H_ */
diff --git a/ipc/CommandMessageIF.h b/ipc/CommandMessageIF.h
index 68a8d956..aafa40ef 100644
--- a/ipc/CommandMessageIF.h
+++ b/ipc/CommandMessageIF.h
@@ -1,73 +1,73 @@
-#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
-#define FSFW_IPC_COMMANDMESSAGEIF_H_
-
-#include "MessageQueueMessageIF.h"
-#include "FwMessageTypes.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
-typedef uint16_t Command_t;
-
-class CommandMessageIF {
-public:
-    /**
-     * Header consists of sender ID and command ID.
-     */
-	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
-			sizeof(Command_t);
-	/**
-	 * This minimum size is derived from the interface requirement to be able
-     * to set a rejected reply, which contains a returnvalue and the initial
-     * command.
-	 */
-	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
-	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
-	        sizeof(Command_t);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
-	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
-
-	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
-	//! Used internally, shall be ignored
-	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
-	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
-	//! Reply indicating that the current command was rejected,
-	//! par1 should contain the error code
-	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
-
-	virtual ~CommandMessageIF() {};
-
-	/**
-	 * A command message shall have a uint16_t command ID field.
-	 * @return
-	 */
-	virtual Command_t getCommand() const = 0;
-	/**
-	 * A command message shall have a uint8_t message type ID field.
-	 * @return
-	 */
-	virtual uint8_t getMessageType() const = 0;
-
-	/**
-	 * A command message can be rejected and needs to offer a function
-	 * to set a rejected reply
-	 * @param reason
-	 * @param initialCommand
-	 */
-	virtual void setReplyRejected(ReturnValue_t reason,
-			Command_t initialCommand) = 0;
-	/**
-	 * Corrensonding getter function.
-	 * @param initialCommand
-	 * @return
-	 */
-	virtual ReturnValue_t getReplyRejectedReason(
-			Command_t* initialCommand = nullptr) const  = 0;
-
-	virtual void setToUnknownCommand() = 0;
-
-	virtual void clear() = 0;
-
-};
-
-#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
+#ifndef FSFW_IPC_COMMANDMESSAGEIF_H_
+#define FSFW_IPC_COMMANDMESSAGEIF_H_
+
+#include "MessageQueueMessageIF.h"
+#include "FwMessageTypes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#define MAKE_COMMAND_ID( number )	((MESSAGE_ID << 8) + (number))
+typedef uint16_t Command_t;
+
+class CommandMessageIF {
+public:
+    /**
+     * Header consists of sender ID and command ID.
+     */
+	static constexpr size_t HEADER_SIZE = MessageQueueMessageIF::HEADER_SIZE +
+			sizeof(Command_t);
+	/**
+	 * This minimum size is derived from the interface requirement to be able
+     * to set a rejected reply, which contains a returnvalue and the initial
+     * command.
+	 */
+	static constexpr size_t MINIMUM_COMMAND_MESSAGE_SIZE =
+	        CommandMessageIF::HEADER_SIZE + sizeof(ReturnValue_t) +
+	        sizeof(Command_t);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_MESSAGE;
+	static const ReturnValue_t UNKNOWN_COMMAND = MAKE_RETURN_CODE(0x01);
+
+	static const uint8_t MESSAGE_ID = messagetypes::COMMAND;
+	//! Used internally, shall be ignored
+	static const Command_t CMD_NONE = MAKE_COMMAND_ID( 0 );
+	static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID( 1 );
+	//! Reply indicating that the current command was rejected,
+	//! par1 should contain the error code
+	static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID( 2 );
+
+	virtual ~CommandMessageIF() {};
+
+	/**
+	 * A command message shall have a uint16_t command ID field.
+	 * @return
+	 */
+	virtual Command_t getCommand() const = 0;
+	/**
+	 * A command message shall have a uint8_t message type ID field.
+	 * @return
+	 */
+	virtual uint8_t getMessageType() const = 0;
+
+	/**
+	 * A command message can be rejected and needs to offer a function
+	 * to set a rejected reply
+	 * @param reason
+	 * @param initialCommand
+	 */
+	virtual void setReplyRejected(ReturnValue_t reason,
+			Command_t initialCommand) = 0;
+	/**
+	 * Corrensonding getter function.
+	 * @param initialCommand
+	 * @return
+	 */
+	virtual ReturnValue_t getReplyRejectedReason(
+			Command_t* initialCommand = nullptr) const  = 0;
+
+	virtual void setToUnknownCommand() = 0;
+
+	virtual void clear() = 0;
+
+};
+
+#endif /* FSFW_IPC_COMMANDMESSAGEIF_H_ */
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 1e80f7bd..96bd379f 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,171 +1,171 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
-#define FSFW_IPC_MESSAGEQUEUEIF_H_
-
-// COULDDO: We could support blocking calls
-// semaphores are being implemented, which makes this idea even more iteresting.
-
-
-/**
- * @defgroup message_queue Message Queue
- * @brief Message Queue related software components
- */
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-class MessageQueueIF {
-public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
-	//! No new messages on the queue
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
-	//! No space left for more messages
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	//! Returned if a reply method was called without partner
-	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
-	//! Returned if the target destination is invalid.
-	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
-
-	virtual ~MessageQueueIF() {}
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details
-	 * This operation simplifies answering an incoming message by using the
-	 * stored lastParnter information as destination. If there was no message
-	 * received yet (i.e. lastPartner is zero), an error code is returned.
-	 * @param message
-	 * A pointer to a previously created message, which is sent.
-	 * @return
-	 * -@c RETURN_OK if ok
-	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
-	 */
-	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
-
-	/**
-	 * @brief	This function reads available messages from the message queue
-	 *          and returns the sender.
-	 * @details
-	 * It works identically to the other receiveMessage call, but in addition
-	 * returns the sender's queue id.
-	 * @param message
-	 * A pointer to a message in which the received data is stored.
-	 * @param receivedFrom
-	 * A pointer to a queue id in which the sender's id is stored.
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) = 0;
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details
-	 * If data is available it is stored in the passed message pointer.
-	 * The message's original content is overwritten and the sendFrom
-	 * information is stored in theblastPartner attribute. Else, the lastPartner
-	 * information remains untouched, the message's content is cleared and the
-	 * function returns immediately.
-	 * @param message
-	 * A pointer to a message in which the received data is stored.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::EMPTY if queue is empty
-	 */
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	virtual ReturnValue_t flush(uint32_t* count) = 0;
-	/**
-	 * @brief	This method returns the message queue
-	 *          id of the last communication partner.
-	 */
-	virtual MessageQueueId_t getLastPartner() const = 0;
-	/**
-	 * @brief	This method returns the message queue
-	 *          id of this class's message queue.
-	 */
-	virtual MessageQueueId_t getId() const = 0;
-
-	/**
-	 * @brief	With the sendMessage call, a queue message
-	 *          is sent to a receiving queue.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information
-	 * and passes it on to the destination provided with an operating system
-	 * call. The OS's returnvalue is returned.
-	 * @param sendTo
-	 * This parameter specifies the message queue id to send the message to.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id
-	 * into the message. This variable is set to zero by default.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter is not incremented
-	 * if queue is full (if implemented).
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details
-	 * It directly uses the sendMessage call of the MessageQueueSender parent,
-	 * but passes its queue id as "sentFrom" parameter.
-	 * @param sendTo
-	 * This parameter specifies the message queue id of the destination
-	 * message queue.
-	 * @param message
-	 * A pointer to a previously created message, which is sent.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter is not incremented
-	 * if queue is full.
-	 */
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
-
-	/**
-	 * @brief	The sendToDefaultFrom method sends a queue message
-	 *          to the default destination.
-	 * @details
-	 * In all other aspects, it works identical to the sendMessage method.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id
-	 * into the message. This variable is set to zero by default.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details
-	 * As in the sendMessage method, this function uses the sendToDefault
-	 * call of the Implementation class and adds its queue id as
-	 * "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @return -@c RETURN_OK on success
-	 *         -@c MessageQueueIF::FULL if queue is full
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	virtual MessageQueueId_t getDefaultDestination() const = 0;
-
-	virtual bool isDefaultDestinationSet() const = 0;
-};
-
-
-
-#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
+#define FSFW_IPC_MESSAGEQUEUEIF_H_
+
+// COULDDO: We could support blocking calls
+// semaphores are being implemented, which makes this idea even more iteresting.
+
+
+/**
+ * @defgroup message_queue Message Queue
+ * @brief Message Queue related software components
+ */
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+class MessageQueueIF {
+public:
+	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
+	//! No new messages on the queue
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(1);
+	//! No space left for more messages
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	//! Returned if a reply method was called without partner
+	static const ReturnValue_t NO_REPLY_PARTNER = MAKE_RETURN_CODE(3);
+	//! Returned if the target destination is invalid.
+	static constexpr ReturnValue_t DESTINVATION_INVALID = MAKE_RETURN_CODE(4);
+
+	virtual ~MessageQueueIF() {}
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details
+	 * This operation simplifies answering an incoming message by using the
+	 * stored lastParnter information as destination. If there was no message
+	 * received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message
+	 * A pointer to a previously created message, which is sent.
+	 * @return
+	 * -@c RETURN_OK if ok
+	 * -@c NO_REPLY_PARTNER Should return NO_REPLY_PARTNER if partner was found.
+	 */
+	virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
+
+	/**
+	 * @brief	This function reads available messages from the message queue
+	 *          and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in addition
+	 * returns the sender's queue id.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
+	 * @param receivedFrom
+	 * A pointer to a queue id in which the sender's id is stored.
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) = 0;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in theblastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message
+	 * A pointer to a message in which the received data is stored.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::EMPTY if queue is empty
+	 */
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	virtual ReturnValue_t flush(uint32_t* count) = 0;
+	/**
+	 * @brief	This method returns the message queue
+	 *          id of the last communication partner.
+	 */
+	virtual MessageQueueId_t getLastPartner() const = 0;
+	/**
+	 * @brief	This method returns the message queue
+	 *          id of this class's message queue.
+	 */
+	virtual MessageQueueId_t getId() const = 0;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message
+	 *          is sent to a receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information
+	 * and passes it on to the destination provided with an operating system
+	 * call. The OS's returnvalue is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full (if implemented).
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details
+	 * It directly uses the sendMessage call of the MessageQueueSender parent,
+	 * but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo
+	 * This parameter specifies the message queue id of the destination
+	 * message queue.
+	 * @param message
+	 * A pointer to a previously created message, which is sent.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter is not incremented
+	 * if queue is full.
+	 */
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) = 0;
+
+	/**
+	 * @brief	The sendToDefaultFrom method sends a queue message
+	 *          to the default destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id
+	 * into the message. This variable is set to zero by default.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) = 0;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details
+	 * As in the sendMessage method, this function uses the sendToDefault
+	 * call of the Implementation class and adds its queue id as
+	 * "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @return -@c RETURN_OK on success
+	 *         -@c MessageQueueIF::FULL if queue is full
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message )  = 0;
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) = 0;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	virtual MessageQueueId_t getDefaultDestination() const = 0;
+
+	virtual bool isDefaultDestinationSet() const = 0;
+};
+
+
+
+#endif /* FSFW_IPC_MESSAGEQUEUEIF_H_ */
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index 2f79cb3b..dcd4def3 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -1,84 +1,84 @@
-#include "MessageQueueMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-#include <cstring>
-
-MessageQueueMessage::MessageQueueMessage() :
-		messageSize(getMinimumMessageSize()) {
-	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-}
-
-MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
-		messageSize(this->HEADER_SIZE + size) {
-	if (size <= this->MAX_DATA_SIZE) {
-		memcpy(this->getData(), data, size);
-		this->messageSize = this->HEADER_SIZE + size;
-	}
-	else {
-		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
-				"allowed size! Setting content to 0" << std::endl;
-		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-		this->messageSize = this->HEADER_SIZE;
-	}
-}
-
-MessageQueueMessage::~MessageQueueMessage() {
-}
-
-const uint8_t* MessageQueueMessage::getBuffer() const {
-	return this->internalBuffer;
-}
-
-uint8_t* MessageQueueMessage::getBuffer() {
-	return this->internalBuffer;
-}
-
-const uint8_t* MessageQueueMessage::getData() const {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-uint8_t* MessageQueueMessage::getData() {
-	return this->internalBuffer + this->HEADER_SIZE;
-}
-
-MessageQueueId_t MessageQueueMessage::getSender() const {
-	MessageQueueId_t temp_id;
-	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
-	return temp_id;
-}
-
-void MessageQueueMessage::setSender(MessageQueueId_t setId) {
-	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
-}
-
-void MessageQueueMessage::print(bool printWholeMessage) {
-	sif::debug << "MessageQueueMessage content: " << std::endl;
-	if(printWholeMessage) {
-	    arrayprinter::print(getData(), getMaximumMessageSize());
-	}
-	else {
-	    arrayprinter::print(getData(), getMessageSize());
-	}
-
-}
-
-void MessageQueueMessage::clear() {
-	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
-}
-
-size_t MessageQueueMessage::getMessageSize() const {
-	return this->messageSize;
-}
-
-void MessageQueueMessage::setMessageSize(size_t messageSize) {
-	this->messageSize = messageSize;
-}
-
-size_t MessageQueueMessage::getMinimumMessageSize() const {
-    return this->MIN_MESSAGE_SIZE;
-}
-
-size_t MessageQueueMessage::getMaximumMessageSize() const {
-    return this->MAX_MESSAGE_SIZE;
-}
-
+#include "MessageQueueMessage.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+#include <cstring>
+
+MessageQueueMessage::MessageQueueMessage() :
+		messageSize(getMinimumMessageSize()) {
+	memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+}
+
+MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
+		messageSize(this->HEADER_SIZE + size) {
+	if (size <= this->MAX_DATA_SIZE) {
+		memcpy(this->getData(), data, size);
+		this->messageSize = this->HEADER_SIZE + size;
+	}
+	else {
+		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+				"allowed size! Setting content to 0" << std::endl;
+		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
+		this->messageSize = this->HEADER_SIZE;
+	}
+}
+
+MessageQueueMessage::~MessageQueueMessage() {
+}
+
+const uint8_t* MessageQueueMessage::getBuffer() const {
+	return this->internalBuffer;
+}
+
+uint8_t* MessageQueueMessage::getBuffer() {
+	return this->internalBuffer;
+}
+
+const uint8_t* MessageQueueMessage::getData() const {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+uint8_t* MessageQueueMessage::getData() {
+	return this->internalBuffer + this->HEADER_SIZE;
+}
+
+MessageQueueId_t MessageQueueMessage::getSender() const {
+	MessageQueueId_t temp_id;
+	memcpy(&temp_id, this->internalBuffer, sizeof(MessageQueueId_t));
+	return temp_id;
+}
+
+void MessageQueueMessage::setSender(MessageQueueId_t setId) {
+	memcpy(this->internalBuffer, &setId, sizeof(MessageQueueId_t));
+}
+
+void MessageQueueMessage::print(bool printWholeMessage) {
+	sif::debug << "MessageQueueMessage content: " << std::endl;
+	if(printWholeMessage) {
+	    arrayprinter::print(getData(), getMaximumMessageSize());
+	}
+	else {
+	    arrayprinter::print(getData(), getMessageSize());
+	}
+
+}
+
+void MessageQueueMessage::clear() {
+	memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE);
+}
+
+size_t MessageQueueMessage::getMessageSize() const {
+	return this->messageSize;
+}
+
+void MessageQueueMessage::setMessageSize(size_t messageSize) {
+	this->messageSize = messageSize;
+}
+
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+    return this->MIN_MESSAGE_SIZE;
+}
+
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+    return this->MAX_MESSAGE_SIZE;
+}
+
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index da5c78cb..f68e9b9f 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -1,150 +1,150 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
-#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
-
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include <cstddef>
-
-/**
- *	@brief		This class is the representation and data organizer
- *				for interprocess messages.
- *	@details
- *	To facilitate and standardize interprocess communication, this class was
- *	created to handle a lightweight "interprocess message protocol".
- *
- *	It adds a header with the sender's queue id to every sent message and
- *	defines the maximum total message size. Specialized messages, such as
- *	device commanding messages, can be created by inheriting from this class
- *	and filling the buffer provided by getData with additional content.
- *
- *	If larger amounts of data must be sent between processes, the data shall
- *	be stored in the IPC Store object and only the storage id is passed in a
- *	queue message.The class is used both to generate and send messages and to
- *	receive messages from other tasks.
- *	@ingroup message_queue
- */
-class MessageQueueMessage: public MessageQueueMessageIF {
-public:
-	/**
-	 * @brief	The class is initialized empty with this constructor.
-	 * @details
-	 * The messageSize attribute is set to the header's size and the whole
-	 * content is set to zero.
-	 */
-	MessageQueueMessage();
-	/**
-	 * @brief	With this constructor the class is initialized with
-	 * 			the given content.
-	 * @details
-	 * If the passed message size fits into the buffer, the passed data is
-	 * copied to the internal buffer and the messageSize information is set.
-	 * Otherwise, messageSize is set to the header's size and the whole
-	 * content is set to zero.
-	 * @param data	The data to be put in the message.
-	 * @param size	Size of the data to be copied. Must be smaller than
-	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
-	 */
-	MessageQueueMessage(uint8_t* data, size_t size);
-
-	/**
-	 * @brief	As no memory is allocated in this class,
-	 * 		    the destructor is empty.
-	 */
-	virtual ~MessageQueueMessage();
-
-	/**
-	 * @brief	The size information of each message is stored in
-	 *  			this attribute.
-	 * @details
-	 * It is public to simplify usage and to allow for passing the size
-	 * address as a pointer. Care must be taken when inheriting from this class,
-	 * as every child class is responsible for managing the size information by
-	 * itself. When using the class to receive a message, the size information
-	 * is updated automatically.
-	 *
-	 * Please note that the minimum size is limited by the size of the header
-	 * while the maximum size is limited by the maximum allowed message size.
-	 */
-	size_t messageSize;
-	/**
-	 * @brief	This constant defines the maximum size of the data content,
-	 * 			excluding the header.
-	 * @details
-	 * It may be changed if necessary, but in general should be kept
-	 * as small as possible.
-	 */
-	static const size_t MAX_DATA_SIZE = 24;
-
-	/**
-	 * @brief	This constant defines the maximum total size in bytes
-	 * 			of a sent message.
-	 * @details
-	 * It is the sum of the maximum data and the header size. Be aware that
-	 * this constant is used to define the buffer sizes for every message
-	 * queue in the system. So, a change here may have significant impact on
-	 * the required resources.
-	 */
-	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
-	/**
-	 * @brief Defines the minimum size of a message where only the
-	 * 		  header is included
-	 */
-	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
-private:
-	/**
-	 * @brief	This is the internal buffer that contains the
-	 * 			actual message data.
-	 */
-	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
-public:
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	const uint8_t* getBuffer() const override;
-	/**
-	 * @brief	This method is used to get the complete data of the message.
-	 */
-	uint8_t* getBuffer() override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	const uint8_t* getData() const override;
-	/**
-	 * @brief	This method is used to fetch the data content of the message.
-	 * @details
-	 * It shall be used by child classes to add data at the right position.
-	 */
-	uint8_t* getData() override;
-	/**
-	 * @brief	This method is used to extract the sender's message
-	 * 			queue id information from a received message.
-	 */
-	MessageQueueId_t getSender() const override;
-	/**
-	 * @brief	With this method, the whole content
-	 * 			and the message size is set to zero.
-	 */
-	void clear() override;
-
-	/**
-	 * @brief	This method is used to set the sender's message queue id
-	 * 			information prior to ing the message.
-	 * @param setId
-	 * The message queue id that identifies the sending message queue.
-	 */
-	void setSender(MessageQueueId_t setId) override;
-
-	virtual size_t getMessageSize() const override;
-	virtual void setMessageSize(size_t messageSize) override;
-	virtual size_t getMinimumMessageSize() const override;
-	virtual size_t getMaximumMessageSize() const override;
-
-	/**
-	 * @brief	This is a debug method that prints the content.
-	 */
-	void print(bool printWholeMessage);
-};
-
-#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+#define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+#include <cstddef>
+
+/**
+ *	@brief		This class is the representation and data organizer
+ *				for interprocess messages.
+ *	@details
+ *	To facilitate and standardize interprocess communication, this class was
+ *	created to handle a lightweight "interprocess message protocol".
+ *
+ *	It adds a header with the sender's queue id to every sent message and
+ *	defines the maximum total message size. Specialized messages, such as
+ *	device commanding messages, can be created by inheriting from this class
+ *	and filling the buffer provided by getData with additional content.
+ *
+ *	If larger amounts of data must be sent between processes, the data shall
+ *	be stored in the IPC Store object and only the storage id is passed in a
+ *	queue message.The class is used both to generate and send messages and to
+ *	receive messages from other tasks.
+ *	@ingroup message_queue
+ */
+class MessageQueueMessage: public MessageQueueMessageIF {
+public:
+	/**
+	 * @brief	The class is initialized empty with this constructor.
+	 * @details
+	 * The messageSize attribute is set to the header's size and the whole
+	 * content is set to zero.
+	 */
+	MessageQueueMessage();
+	/**
+	 * @brief	With this constructor the class is initialized with
+	 * 			the given content.
+	 * @details
+	 * If the passed message size fits into the buffer, the passed data is
+	 * copied to the internal buffer and the messageSize information is set.
+	 * Otherwise, messageSize is set to the header's size and the whole
+	 * content is set to zero.
+	 * @param data	The data to be put in the message.
+	 * @param size	Size of the data to be copied. Must be smaller than
+	 * 				MAX_MESSAGE_SIZE and larger than MIN_MESSAGE_SIZE.
+	 */
+	MessageQueueMessage(uint8_t* data, size_t size);
+
+	/**
+	 * @brief	As no memory is allocated in this class,
+	 * 		    the destructor is empty.
+	 */
+	virtual ~MessageQueueMessage();
+
+	/**
+	 * @brief	The size information of each message is stored in
+	 *  			this attribute.
+	 * @details
+	 * It is public to simplify usage and to allow for passing the size
+	 * address as a pointer. Care must be taken when inheriting from this class,
+	 * as every child class is responsible for managing the size information by
+	 * itself. When using the class to receive a message, the size information
+	 * is updated automatically.
+	 *
+	 * Please note that the minimum size is limited by the size of the header
+	 * while the maximum size is limited by the maximum allowed message size.
+	 */
+	size_t messageSize;
+	/**
+	 * @brief	This constant defines the maximum size of the data content,
+	 * 			excluding the header.
+	 * @details
+	 * It may be changed if necessary, but in general should be kept
+	 * as small as possible.
+	 */
+	static const size_t MAX_DATA_SIZE = 24;
+
+	/**
+	 * @brief	This constant defines the maximum total size in bytes
+	 * 			of a sent message.
+	 * @details
+	 * It is the sum of the maximum data and the header size. Be aware that
+	 * this constant is used to define the buffer sizes for every message
+	 * queue in the system. So, a change here may have significant impact on
+	 * the required resources.
+	 */
+	static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+	/**
+	 * @brief Defines the minimum size of a message where only the
+	 * 		  header is included
+	 */
+	static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+private:
+	/**
+	 * @brief	This is the internal buffer that contains the
+	 * 			actual message data.
+	 */
+	uint8_t internalBuffer[MAX_MESSAGE_SIZE];
+public:
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	const uint8_t* getBuffer() const override;
+	/**
+	 * @brief	This method is used to get the complete data of the message.
+	 */
+	uint8_t* getBuffer() override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	const uint8_t* getData() const override;
+	/**
+	 * @brief	This method is used to fetch the data content of the message.
+	 * @details
+	 * It shall be used by child classes to add data at the right position.
+	 */
+	uint8_t* getData() override;
+	/**
+	 * @brief	This method is used to extract the sender's message
+	 * 			queue id information from a received message.
+	 */
+	MessageQueueId_t getSender() const override;
+	/**
+	 * @brief	With this method, the whole content
+	 * 			and the message size is set to zero.
+	 */
+	void clear() override;
+
+	/**
+	 * @brief	This method is used to set the sender's message queue id
+	 * 			information prior to ing the message.
+	 * @param setId
+	 * The message queue id that identifies the sending message queue.
+	 */
+	void setSender(MessageQueueId_t setId) override;
+
+	virtual size_t getMessageSize() const override;
+	virtual void setMessageSize(size_t messageSize) override;
+	virtual size_t getMinimumMessageSize() const override;
+	virtual size_t getMaximumMessageSize() const override;
+
+	/**
+	 * @brief	This is a debug method that prints the content.
+	 */
+	void print(bool printWholeMessage);
+};
+
+#endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 80623157..b967bbdf 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,25 +1,25 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-
-#include "../ipc/MessageQueueMessageIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-class MessageQueueSenderIF {
-public:
-
-	virtual ~MessageQueueSenderIF() {}
-
-	/**
-	 * Allows sending messages without actually "owning" a message queue.
-	 * Not sure whether this is actually a good idea.
-	 */
-	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
-			bool ignoreFault = false);
-private:
-	MessageQueueSenderIF() {}
-};
-
-
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+
+#include "../ipc/MessageQueueMessageIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+class MessageQueueSenderIF {
+public:
+
+	virtual ~MessageQueueSenderIF() {}
+
+	/**
+	 * Allows sending messages without actually "owning" a message queue.
+	 * Not sure whether this is actually a good idea.
+	 */
+	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			bool ignoreFault = false);
+private:
+	MessageQueueSenderIF() {}
+};
+
+
+#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index 91e90907..f34d3b04 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
-
-#include "../ipc/MutexIF.h"
-/**
- * Creates Mutex.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class MutexFactory {
-public:
-	virtual ~MutexFactory();
-	/**
-	 * Returns the single instance of MutexFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static MutexFactory* instance();
-
-	MutexIF* createMutex();
-
-	void deleteMutex(MutexIF* mutex);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	MutexFactory();
-	static MutexFactory* factoryInstance;
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
+#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+
+#include "../ipc/MutexIF.h"
+/**
+ * Creates Mutex.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class MutexFactory {
+public:
+	virtual ~MutexFactory();
+	/**
+	 * Returns the single instance of MutexFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static MutexFactory* instance();
+
+	MutexIF* createMutex();
+
+	void deleteMutex(MutexIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	MutexFactory();
+	static MutexFactory* factoryInstance;
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 97e28007..97001ade 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -1,30 +1,30 @@
-#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
-#define FRAMEWORK_IPC_MUTEXHELPER_H_
-
-#include "MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-class MutexHelper {
-public:
-	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
-			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutType,
-		        timeoutMs);
-		if(status == MutexIF::MUTEX_TIMEOUT) {
-			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
-					<< timeoutMs << " milliseconds!" << std::endl;
-		}
-		else if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed with code "
-			        << status << std::endl;
-		}
-	}
-
-	~MutexHelper() {
-		internalMutex->unlockMutex();
-	}
-private:
-	MutexIF* internalMutex;
-};
-#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXHELPER_H_
+#define FRAMEWORK_IPC_MUTEXHELPER_H_
+
+#include "MutexFactory.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+class MutexHelper {
+public:
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
+			internalMutex(mutex) {
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
+		        timeoutMs);
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code "
+			        << status << std::endl;
+		}
+	}
+
+	~MutexHelper() {
+		internalMutex->unlockMutex();
+	}
+private:
+	MutexIF* internalMutex;
+};
+#endif /* FRAMEWORK_IPC_MUTEXHELPER_H_ */
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 7bca4c9d..5673e4d7 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -1,89 +1,89 @@
-#ifndef FRAMEWORK_IPC_MUTEXIF_H_
-#define FRAMEWORK_IPC_MUTEXIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
- * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
- * @ingroup osal
- * @ingroup interface
- */
-class MutexIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-    /**
-     * Lock the mutex. The timeout value will only be used for
-     * TimeoutType::WAITING
-     * @param timeoutType
-     * @param timeoutMs
-     * @return
-     */
-    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-    virtual ReturnValue_t unlockMutex() = 0;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
-	/**
-	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
-	 */
-	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
-	/**
-	 * Insufficient memory to create or init Mutex
-	 */
-	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
-	/**
-	 * Caller does not have enough or right privilege
-	 */
-	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
-	/**
-	 * Wrong Attribute Setting
-	 */
-	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
-	/**
-	 * The mutex is already locked
-	 */
-	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
-	/**
-	 * Mutex object not found
-	 */
-	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
-	/**
-	 * Mutex could not be locked because max amount of recursive locks
-	 */
-	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
-	/**
-	 * The current thread already owns this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
-	/**
-	 * Current thread does not own this mutex
-	 */
-	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
-	/**
-	 * The Mutex could not be blocked before timeout
-	 */
-	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
-	/**
-	 * Invalid Mutex ID
-	 */
-	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
-	/**
-	 * Mutex destroyed while waiting
-	 */
-	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
-
-    virtual ~MutexIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
+#ifndef FRAMEWORK_IPC_MUTEXIF_H_
+#define FRAMEWORK_IPC_MUTEXIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
+class MutexIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
+	/**
+	 * The system lacked the necessary resources (other than memory) to initialize another mutex.
+	 */
+	static const ReturnValue_t NOT_ENOUGH_RESOURCES = MAKE_RETURN_CODE(1);
+	/**
+	 * Insufficient memory to create or init Mutex
+	 */
+	static const ReturnValue_t INSUFFICIENT_MEMORY = MAKE_RETURN_CODE(2);
+	/**
+	 * Caller does not have enough or right privilege
+	 */
+	static const ReturnValue_t NO_PRIVILEGE =  MAKE_RETURN_CODE(3);
+	/**
+	 * Wrong Attribute Setting
+	 */
+	static const ReturnValue_t WRONG_ATTRIBUTE_SETTING = MAKE_RETURN_CODE(4);
+	/**
+	 * The mutex is already locked
+	 */
+	static const ReturnValue_t MUTEX_ALREADY_LOCKED = MAKE_RETURN_CODE(5);
+	/**
+	 * Mutex object not found
+	 */
+	static const ReturnValue_t MUTEX_NOT_FOUND = MAKE_RETURN_CODE(6);
+	/**
+	 * Mutex could not be locked because max amount of recursive locks
+	 */
+	static const ReturnValue_t MUTEX_MAX_LOCKS = MAKE_RETURN_CODE(7);
+	/**
+	 * The current thread already owns this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_ALREADY_OWNS_MUTEX = MAKE_RETURN_CODE(8);
+	/**
+	 * Current thread does not own this mutex
+	 */
+	static const ReturnValue_t CURR_THREAD_DOES_NOT_OWN_MUTEX = MAKE_RETURN_CODE(9);
+	/**
+	 * The Mutex could not be blocked before timeout
+	 */
+	static const ReturnValue_t MUTEX_TIMEOUT = MAKE_RETURN_CODE(10);
+	/**
+	 * Invalid Mutex ID
+	 */
+	static const ReturnValue_t MUTEX_INVALID_ID = MAKE_RETURN_CODE(11);
+	/**
+	 * Mutex destroyed while waiting
+	 */
+	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
+
+    virtual ~MutexIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_IPC_MUTEXIF_H_ */
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index e9891987..be554406 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
-
-#include "MessageQueueIF.h"
-#include <cstdint>
-/**
- * Creates message queues.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class QueueFactory {
-public:
-	virtual ~QueueFactory();
-	/**
-	 * Returns the single instance of QueueFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static QueueFactory* instance();
-
-	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	void deleteMessageQueue(MessageQueueIF* queue);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	QueueFactory();
-	static QueueFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
+#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+
+#include "MessageQueueIF.h"
+#include <cstdint>
+/**
+ * Creates message queues.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class QueueFactory {
+public:
+	virtual ~QueueFactory();
+	/**
+	 * Returns the single instance of QueueFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static QueueFactory* instance();
+
+	MessageQueueIF* createMessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	void deleteMessageQueue(MessageQueueIF* queue);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	QueueFactory();
+	static QueueFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 044f2236..4c222dec 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,21 +1,21 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
-
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../memory/MemoryMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsMemoryMessagesIF : public HasMemoryIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+/**
+ * @file	AcceptsMemoryMessagesIF.h
+ * @brief	This file defines the AcceptsMemoryMessagesIF class.
+ * @date	11.07.2013
+ * @author	baetz
+ */
+
+#ifndef ACCEPTSMEMORYMESSAGESIF_H_
+#define ACCEPTSMEMORYMESSAGESIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../memory/MemoryMessage.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsMemoryMessagesIF : public HasMemoryIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index a1c3955f..30437a62 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,28 +1,28 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
-	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
-}
-
+/*
+ * FileSystemMessage.cpp
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
+		MessageQueueId_t replyQueueId, store_address_t storageID) {
+	message->setCommand(WRITE_TO_FILE);
+	message->setParameter(replyQueueId);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
+	return message->getParameter();
+}
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 9ef9a2f4..da5b3181 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,30 +1,30 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-
-class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
-
-};
-
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+/*
+ * FileSystemMessage.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+class FileSystemMessage {
+private:
+	FileSystemMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
+
+	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+
+};
+
+#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 49a2ae54..b6d43981 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,36 +1,36 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class HasFileSystemIF {
-public:
-
-	virtual ~HasFileSystemIF() {}
-	/**
-	 * Function to get the MessageQueueId_t of the implementing object
-	 * @return MessageQueueId_t of the object
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	/**
-	 * Function to write to a file
-	 * @param dirname Directory of the file
-	 * @param filename The filename of the file
-	 * @param data The data to write to the file
-	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
-	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
-};
-
-
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+/*
+ * HasFileSystemIF.h
+ *
+ *  Created on: 19.01.2020
+ *      Author: Jakob Meier
+ */
+
+#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasFileSystemIF {
+public:
+
+	virtual ~HasFileSystemIF() {}
+	/**
+	 * Function to get the MessageQueueId_t of the implementing object
+	 * @return MessageQueueId_t of the object
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	/**
+	 * Function to write to a file
+	 * @param dirname Directory of the file
+	 * @param filename The filename of the file
+	 * @param data The data to write to the file
+	 * @param size The size of the data to write
+	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 */
+	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+};
+
+
+#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
diff --git a/memory/HasMemoryIF.h b/memory/HasMemoryIF.h
index 788a86b6..4096d1b7 100644
--- a/memory/HasMemoryIF.h
+++ b/memory/HasMemoryIF.h
@@ -1,47 +1,47 @@
-#ifndef HASMEMORYIF_H_
-#define HASMEMORYIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class HasMemoryIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
-	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
-	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
-//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
-	virtual ~HasMemoryIF() {}
-	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
-	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
-	/**
-	 * Sets the address of the memory, if possible.
-	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
-	 */
-	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
-	static bool memAccessWasSuccessful(ReturnValue_t result) {
-		switch (result) {
-		case DO_IT_MYSELF:
-		case POINTS_TO_MEMORY:
-		case POINTS_TO_VARIABLE:
-		case HasReturnvaluesIF::RETURN_OK:
-		case ACTIVITY_COMPLETED:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-
-#endif /* HASMEMORYIF_H_ */
+#ifndef HASMEMORYIF_H_
+#define HASMEMORYIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class HasMemoryIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MEMORY_IF;
+	static const ReturnValue_t DO_IT_MYSELF = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t POINTS_TO_VARIABLE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t POINTS_TO_MEMORY =  MAKE_RETURN_CODE(3);
+	static const ReturnValue_t ACTIVITY_COMPLETED  =  MAKE_RETURN_CODE(4);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT8 = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT16 = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t POINTS_TO_VECTOR_UINT32 = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t POINTS_TO_VECTOR_FLOAT = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t DUMP_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_CONTENT = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t UNALIGNED_ACCESS = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t WRITE_PROTECTED = MAKE_RETURN_CODE(0xE4);
+//	static const ReturnValue_t TARGET_BUSY = MAKE_RETURN_CODE(0xE5);
+	virtual ~HasMemoryIF() {}
+	virtual ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data, uint32_t size, uint8_t** dataPointer) = 0;
+	virtual ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size, uint8_t** dataPointer, uint8_t* dumpTarget ) = 0;
+	/**
+	 * Sets the address of the memory, if possible.
+	 * startAddress is a proposal for an address, or the base address if multiple addresses are set.
+	 */
+	virtual ReturnValue_t setAddress( uint32_t* startAddress ) { return HasReturnvaluesIF::RETURN_FAILED; }
+	static bool memAccessWasSuccessful(ReturnValue_t result) {
+		switch (result) {
+		case DO_IT_MYSELF:
+		case POINTS_TO_MEMORY:
+		case POINTS_TO_VARIABLE:
+		case HasReturnvaluesIF::RETURN_OK:
+		case ACTIVITY_COMPLETED:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+
+#endif /* HASMEMORYIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index c74b7d9f..2daddf63 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,193 +1,193 @@
-#include "../globalfunctions/CRC.h"
-#include "../memory/MemoryHelper.h"
-#include "../memory/MemoryMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
-		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
-}
-
-ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
-	lastSender = message->getSender();
-	lastCommand = message->getCommand();
-	if (busy) {
-		sif::debug << "MemHelper: Busy!" << std::endl;
-	}
-	switch (lastCommand) {
-	case MemoryMessage::CMD_MEMORY_DUMP:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_LOAD:
-		handleMemoryLoad(message);
-		return RETURN_OK;
-	case MemoryMessage::CMD_MEMORY_CHECK:
-		handleMemoryCheckOrDump(message);
-		return RETURN_OK;
-	default:
-		lastCommand = CommandMessage::CMD_NONE;
-		return UNKNOWN_CMD;
-	}
-}
-
-void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
-	busy = false;
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasMemoryIF::POINTS_TO_MEMORY:
-		memcpy(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
-		break;
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-	case RETURN_OK:
-		break;
-	default:
-		ipcStore->deleteData(ipcAddress);
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-		return;
-	}
-	//Only reached on success
-	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
-	queueToUse->sendMessage(lastSender, &reply);
-	ipcStore->deleteData(ipcAddress);
-}
-
-void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
-	busy = false;
-	CommandMessage reply;
-	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
-	switch (errorCode) {
-	case HasMemoryIF::DO_IT_MYSELF:
-		busy = true;
-		return;
-	case HasReturnvaluesIF::RETURN_OK:
-	case HasMemoryIF::POINTS_TO_MEMORY:
-	case HasMemoryIF::POINTS_TO_VARIABLE:
-		//"data" must be valid pointer!
-		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
-			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
-		} else {
-			memcpy(reservedSpaceInIPC, dataToCopy, size);
-		}
-		/* NO BREAK falls through*/
-	case HasMemoryIF::ACTIVITY_COMPLETED:
-		switch (lastCommand) {
-		case MemoryMessage::CMD_MEMORY_DUMP: {
-			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
-			break;
-		}
-		case MemoryMessage::CMD_MEMORY_CHECK: {
-			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
-			//Delete data immediately, was temporary.
-			ipcStore->deleteData(ipcAddress);
-			MemoryMessage::setMemoryCheckReply(&reply, crc);
-			break;
-		}
-		default:
-			//This should never happen!
-			//Is it ok to send message? Otherwise: return;
-			ipcStore->deleteData(ipcAddress);
-			reply.setParameter(STATE_MISMATCH);
-			break;
-		}
-		break;
-	case HasMemoryIF::DUMP_NOT_SUPPORTED:
-		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
-			MemoryMessage::setMemoryCheckReply(&reply, 0);
-			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
-		}
-		ipcStore->deleteData(ipcAddress);
-		break;
-	default:
-		//Reply is already set to REJECTED.
-		ipcStore->deleteData(ipcAddress);
-		break;
-	}
-	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
-		reply.clear();
-	}
-}
-
-void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
-	if (totalSize % datatypeSize != 0){
-		return;
-	}
-
-	while (totalSize > 0){
-		EndianConverter::convertBigEndian(out,in,datatypeSize);
-		out += datatypeSize;
-		in += datatypeSize;
-		totalSize -= datatypeSize;
-	}
-}
-
-MemoryHelper::~MemoryHelper() {
-	//Nothing to destroy
-}
-
-void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	ipcAddress = MemoryMessage::getStoreID(message);
-	const uint8_t* p_data = NULL;
-	uint8_t* dataPointer = NULL;
-	size_t size = 0;
-	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
-				&dataPointer);
-		completeLoad(returnCode, p_data, size, dataPointer);
-	} else {
-		//At least inform sender.
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
-				MemoryMessage::CMD_MEMORY_LOAD);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
-	uint32_t address = MemoryMessage::getAddress(message);
-	uint32_t size = MemoryMessage::getLength(message);
-	uint8_t* dataPointer = NULL;
-	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
-			&reservedSpaceInIPC);
-	if (returnCode == RETURN_OK) {
-		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
-				reservedSpaceInIPC);
-		completeDump(returnCode, dataPointer, size);
-	} else {
-		CommandMessage reply;
-		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
-		queueToUse->sendMessage(lastSender, &reply);
-	}
-}
-
-ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
-	if(queueToUse_ == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	this->queueToUse = queueToUse_;
-	return initialize();
-}
-
-ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore != nullptr) {
-		return RETURN_OK;
-	} else {
-		return RETURN_FAILED;
-	}
-}
+#include "../globalfunctions/CRC.h"
+#include "../memory/MemoryHelper.h"
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
+		MessageQueueIF* useThisQueue):
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
+		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+}
+
+ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
+	lastSender = message->getSender();
+	lastCommand = message->getCommand();
+	if (busy) {
+		sif::debug << "MemHelper: Busy!" << std::endl;
+	}
+	switch (lastCommand) {
+	case MemoryMessage::CMD_MEMORY_DUMP:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_LOAD:
+		handleMemoryLoad(message);
+		return RETURN_OK;
+	case MemoryMessage::CMD_MEMORY_CHECK:
+		handleMemoryCheckOrDump(message);
+		return RETURN_OK;
+	default:
+		lastCommand = CommandMessage::CMD_NONE;
+		return UNKNOWN_CMD;
+	}
+}
+
+void MemoryHelper::completeLoad(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+	busy = false;
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasMemoryIF::POINTS_TO_MEMORY:
+		memcpy(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
+		break;
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+	case RETURN_OK:
+		break;
+	default:
+		ipcStore->deleteData(ipcAddress);
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, errorCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+		return;
+	}
+	//Only reached on success
+	CommandMessage reply( CommandMessage::REPLY_COMMAND_OK, 0, 0);
+	queueToUse->sendMessage(lastSender, &reply);
+	ipcStore->deleteData(ipcAddress);
+}
+
+void MemoryHelper::completeDump(ReturnValue_t errorCode,
+		const uint8_t* dataToCopy, const uint32_t size) {
+	busy = false;
+	CommandMessage reply;
+	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
+	switch (errorCode) {
+	case HasMemoryIF::DO_IT_MYSELF:
+		busy = true;
+		return;
+	case HasReturnvaluesIF::RETURN_OK:
+	case HasMemoryIF::POINTS_TO_MEMORY:
+	case HasMemoryIF::POINTS_TO_VARIABLE:
+		//"data" must be valid pointer!
+		if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
+			EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
+		} else {
+			memcpy(reservedSpaceInIPC, dataToCopy, size);
+		}
+		/* NO BREAK falls through*/
+	case HasMemoryIF::ACTIVITY_COMPLETED:
+		switch (lastCommand) {
+		case MemoryMessage::CMD_MEMORY_DUMP: {
+			MemoryMessage::setMemoryDumpReply(&reply, ipcAddress);
+			break;
+		}
+		case MemoryMessage::CMD_MEMORY_CHECK: {
+			uint16_t crc = CRC::crc16ccitt(reservedSpaceInIPC, size);
+			//Delete data immediately, was temporary.
+			ipcStore->deleteData(ipcAddress);
+			MemoryMessage::setMemoryCheckReply(&reply, crc);
+			break;
+		}
+		default:
+			//This should never happen!
+			//Is it ok to send message? Otherwise: return;
+			ipcStore->deleteData(ipcAddress);
+			reply.setParameter(STATE_MISMATCH);
+			break;
+		}
+		break;
+	case HasMemoryIF::DUMP_NOT_SUPPORTED:
+		if (lastCommand == MemoryMessage::CMD_MEMORY_CHECK){
+			MemoryMessage::setMemoryCheckReply(&reply, 0);
+			MemoryMessage::setCrcReturnValue(&reply,HasMemoryIF::DUMP_NOT_SUPPORTED);
+		}
+		ipcStore->deleteData(ipcAddress);
+		break;
+	default:
+		//Reply is already set to REJECTED.
+		ipcStore->deleteData(ipcAddress);
+		break;
+	}
+	if (queueToUse->sendMessage(lastSender, &reply) != RETURN_OK) {
+		reply.clear();
+	}
+}
+
+void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
+		uint32_t totalSize, uint8_t datatypeSize) {
+	if (totalSize % datatypeSize != 0){
+		return;
+	}
+
+	while (totalSize > 0){
+		EndianConverter::convertBigEndian(out,in,datatypeSize);
+		out += datatypeSize;
+		in += datatypeSize;
+		totalSize -= datatypeSize;
+	}
+}
+
+MemoryHelper::~MemoryHelper() {
+	//Nothing to destroy
+}
+
+void MemoryHelper::handleMemoryLoad(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	ipcAddress = MemoryMessage::getStoreID(message);
+	const uint8_t* p_data = NULL;
+	uint8_t* dataPointer = NULL;
+	size_t size = 0;
+	ReturnValue_t returnCode = ipcStore->getData(ipcAddress, &p_data, &size);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryLoad(address, p_data, size,
+				&dataPointer);
+		completeLoad(returnCode, p_data, size, dataPointer);
+	} else {
+		//At least inform sender.
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode,
+				MemoryMessage::CMD_MEMORY_LOAD);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+void MemoryHelper::handleMemoryCheckOrDump(CommandMessage* message) {
+	uint32_t address = MemoryMessage::getAddress(message);
+	uint32_t size = MemoryMessage::getLength(message);
+	uint8_t* dataPointer = NULL;
+	ReturnValue_t returnCode = ipcStore->getFreeElement(&ipcAddress, size,
+			&reservedSpaceInIPC);
+	if (returnCode == RETURN_OK) {
+		returnCode = workOnThis->handleMemoryDump(address, size, &dataPointer,
+				reservedSpaceInIPC);
+		completeDump(returnCode, dataPointer, size);
+	} else {
+		CommandMessage reply;
+		MemoryMessage::setMemoryReplyFailed(&reply, returnCode, lastCommand);
+		queueToUse->sendMessage(lastSender, &reply);
+	}
+}
+
+ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
+	if(queueToUse_ == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	this->queueToUse = queueToUse_;
+	return initialize();
+}
+
+ReturnValue_t MemoryHelper::initialize() {
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (ipcStore != nullptr) {
+		return RETURN_OK;
+	} else {
+		return RETURN_FAILED;
+	}
+}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 90dbafb4..418cf50d 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#include "../ipc/CommandMessage.h"
-#include "../memory/AcceptsMemoryMessagesIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class MemoryHelper : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
-	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
-private:
-	HasMemoryIF* workOnThis;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore = nullptr;
-	store_address_t ipcAddress;
-	Command_t lastCommand;
-	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
-	uint8_t* reservedSpaceInIPC = nullptr;
-	bool busy;
-	void handleMemoryLoad(CommandMessage* message);
-	void handleMemoryCheckOrDump(CommandMessage* message);
-	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
-};
-#endif /* MEMORYHELPER_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#include "../ipc/CommandMessage.h"
+#include "../memory/AcceptsMemoryMessagesIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueIF.h"
+
+class MemoryHelper : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
+	static const ReturnValue_t UNKNOWN_CMD = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+private:
+	HasMemoryIF* workOnThis;
+	MessageQueueIF* queueToUse;
+	StorageManagerIF* ipcStore = nullptr;
+	store_address_t ipcAddress;
+	Command_t lastCommand;
+	MessageQueueId_t lastSender = MessageQueueIF::NO_QUEUE;
+	uint8_t* reservedSpaceInIPC = nullptr;
+	bool busy;
+	void handleMemoryLoad(CommandMessage* message);
+	void handleMemoryCheckOrDump(CommandMessage* message);
+	ReturnValue_t initialize();
+public:
+	ReturnValue_t handleMemoryCommand(CommandMessage* message);
+	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
+	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
+	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
+	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
+	~MemoryHelper();
+};
+#endif /* MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index 16a60502..4e077dee 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,112 +1,112 @@
-#include "../memory/MemoryMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-MemoryMessage::MemoryMessage() {
-}
-
-uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-uint32_t MemoryMessage::getLength(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_DUMP);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
-	message->setCommand(REPLY_MEMORY_DUMP);
-	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
-		uint32_t address, store_address_t storageID) {
-	message->setCommand(CMD_MEMORY_LOAD);
-	message->setParameter( address );
-	message->setParameter2( storageID.raw );
-}
-
-ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void MemoryMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_MEMORY_LOAD:
-	case REPLY_MEMORY_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreID(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case CMD_MEMORY_DUMP:
-	case CMD_MEMORY_CHECK:
-	case REPLY_MEMORY_CHECK:
-	case END_OF_MEMORY_COPY:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-		}
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
-		uint32_t address, uint32_t length) {
-	message->setCommand(CMD_MEMORY_CHECK);
-	message->setParameter( address );
-	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
-		uint16_t crc) {
-	message->setCommand(REPLY_MEMORY_CHECK);
-	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
-	message->setParameter(returnValue<<16);
-};
-
-uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
-	return (uint16_t)(message->getParameter());
-}
-
-ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
-	return (message->getParameter()>>16);
-}
-
-Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
-		ReturnValue_t errorCode, Command_t initialCommand) {
-	message->setCommand(REPLY_MEMORY_FAILED);
-	message->setParameter(errorCode);
-	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
-	message->setCommand(END_OF_MEMORY_COPY);
-	message->setParameter(0);
-	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
+#include "../memory/MemoryMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+MemoryMessage::MemoryMessage() {
+}
+
+uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t MemoryMessage::getStoreID(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+uint32_t MemoryMessage::getLength(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_DUMP);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+	message->setCommand(REPLY_MEMORY_DUMP);
+	message->setParameter2( storageID.raw );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
+		uint32_t address, store_address_t storageID) {
+	message->setCommand(CMD_MEMORY_LOAD);
+	message->setParameter( address );
+	message->setParameter2( storageID.raw );
+}
+
+ReturnValue_t MemoryMessage::getErrorCode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void MemoryMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_MEMORY_LOAD:
+	case REPLY_MEMORY_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreID(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case CMD_MEMORY_DUMP:
+	case CMD_MEMORY_CHECK:
+	case REPLY_MEMORY_CHECK:
+	case END_OF_MEMORY_COPY:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+		}
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+		uint32_t address, uint32_t length) {
+	message->setCommand(CMD_MEMORY_CHECK);
+	message->setParameter( address );
+	message->setParameter2( length );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+		uint16_t crc) {
+	message->setCommand(REPLY_MEMORY_CHECK);
+	message->setParameter( crc );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+	message->setParameter(returnValue<<16);
+};
+
+uint16_t MemoryMessage::getCrc(const CommandMessage* message) {
+	return (uint16_t)(message->getParameter());
+}
+
+ReturnValue_t MemoryMessage::getCrcReturnValue(const CommandMessage* message){
+	return (message->getParameter()>>16);
+}
+
+Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+		ReturnValue_t errorCode, Command_t initialCommand) {
+	message->setCommand(REPLY_MEMORY_FAILED);
+	message->setParameter(errorCode);
+	message->setParameter2(initialCommand);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+	message->setCommand(END_OF_MEMORY_COPY);
+	message->setParameter(0);
+	message->setParameter2(0);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index af936c1f..a366eb9a 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,39 +1,39 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-
-class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
-	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );
-	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
-	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
-	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
-	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
-
-	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
-	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MEMORYMESSAGE_H_ */
+#ifndef MEMORYMESSAGE_H_
+#define MEMORYMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+
+class MemoryMessage {
+private:
+	MemoryMessage(); //A private ctor inhibits instantiation
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
+	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t CMD_MEMORY_CHECK = MAKE_COMMAND_ID( 0x03 );
+	static const Command_t REPLY_MEMORY_DUMP = MAKE_COMMAND_ID( 0x10 );
+	static const Command_t REPLY_MEMORY_CHECK = MAKE_COMMAND_ID( 0x30 );
+	static const Command_t REPLY_MEMORY_FAILED = MAKE_COMMAND_ID( 0xE0 );
+	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
+
+	static uint32_t getAddress( const CommandMessage* message );
+	static store_address_t getStoreID( const CommandMessage* message );
+	static uint32_t getLength( const CommandMessage* message );
+	static ReturnValue_t getErrorCode( const CommandMessage* message );
+	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
+	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
+	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
+	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
+	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
+	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
+	static uint16_t getCrc( const CommandMessage* message );
+	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+	static Command_t getInitialCommand( const CommandMessage* message );
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MEMORYMESSAGE_H_ */
diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
index a30165c3..31045d3f 100644
--- a/memory/MemoryProxyIF.h
+++ b/memory/MemoryProxyIF.h
@@ -1,22 +1,22 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include "../memory/AcceptsMemoryMessagesIF.h"
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
+#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
+
+#include "../memory/AcceptsMemoryMessagesIF.h"
+
+/**
+ * This was a nice idea to transparently forward incoming messages to another object.
+ * But it doesn't work like that.
+ */
+class MemoryProxyIF : public AcceptsMemoryMessagesIF {
+public:
+	virtual MessageQueueId_t getProxyQueue() const = 0;
+	MessageQueueId_t getCommandQueue() const {
+		return getProxyQueue();
+	}
+	virtual ~MemoryProxyIF() {}
+
+};
+
+
+
+#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index eade3613..c3abaaaf 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,57 +1,57 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
-
-#include "../events/Event.h"
-#include "../modes/ModeHelper.h"
-#include "../modes/ModeMessage.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
-
-
-class HasModesIF {
-	friend class ModeHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
-	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-
-	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
-	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
-	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
-protected:
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
-};
-
-#endif /* HASMODESIF_H_ */
+/**
+ * @file	HasModesIF.h
+ * @brief	This file defines the HasModesIF class.
+ * @date	20.06.2013
+ * @author	baetz
+ */
+
+#ifndef HASMODESIF_H_
+#define HASMODESIF_H_
+
+#include "../events/Event.h"
+#include "../modes/ModeHelper.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+
+class HasModesIF {
+	friend class ModeHelper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_MODES_IF;
+	static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TRANS_NOT_ALLOWED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t IN_TRANSITION = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
+	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+
+	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
+	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
+	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
+	virtual ~HasModesIF() {
+	}
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+protected:
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	virtual void startTransition(Mode_t mode, Submode_t submode) {
+	}
+	virtual void setToExternalControl() {
+	}
+	virtual void announceMode(bool recursive) {
+	}
+};
+
+#endif /* HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index d6cbf2c9..e7fc0bcb 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,135 +1,135 @@
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-ModeHelper::ModeHelper(HasModesIF *owner) :
-		commandedMode(HasModesIF::MODE_OFF),
-		commandedSubmode(HasModesIF::SUBMODE_NONE),
-		owner(owner), forced(false) {}
-
-ModeHelper::~ModeHelper() {
-
-}
-
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
-	CommandMessage reply;
-	Mode_t mode;
-	Submode_t submode;
-	switch (command->getCommand()) {
-	case ModeMessage::CMD_MODE_COMMAND_FORCED:
-		forced = true;
-		/* NO BREAK falls through*/
-	case ModeMessage::CMD_MODE_COMMAND: {
-		mode = ModeMessage::getMode(command);
-		submode = ModeMessage::getSubmode(command);
-		uint32_t timeout;
-		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
-			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-			        owner->getCommandQueue());
-			break;
-		}
-		//Free to start transition
-		theOneWhoCommandedAMode = command->getSender();
-		commandedMode = mode;
-		commandedSubmode = submode;
-
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-				&& (theOneWhoCommandedAMode != parentQueueId)) {
-			owner->setToExternalControl();
-		}
-
-		countdown.setTimeout(timeout);
-		owner->startTransition(mode, submode);
-	}
-		break;
-	case ModeMessage::CMD_MODE_READ: {
-		owner->getMode(&mode, &submode);
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
-				submode);
-		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
-		       owner->getCommandQueue());
-	}
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE:
-		owner->announceMode(false);
-		break;
-	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-		owner->announceMode(true);
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
-	setParentQueue(parentQueueId);
-	return initialize();
-}
-
-void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
-	forced = false;
-	sendModeReplyMessage(ownerMode, ownerSubmode);
-	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
-}
-
-void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
-	{
-		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
-		{
-			ModeMessage::setModeMessage(&reply,
-					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
-					ownerSubmode);
-		}
-		else
-		{
-			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
-					ownerMode, ownerSubmode);
-		}
-		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
-		Submode_t ownerSubmode) {
-	CommandMessage reply;
-	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
-	{
-		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
-				ownerMode, ownerSubmode);
-		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
-		        owner->getCommandQueue());
-	}
-}
-
-void ModeHelper::startTimer(uint32_t timeoutMs) {
-	countdown.setTimeout(timeoutMs);
-}
-
-void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
-	this->parentQueueId = parentQueueId;
-}
-
-ReturnValue_t ModeHelper::initialize(void) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-bool ModeHelper::isTimedOut() {
-	return countdown.hasTimedOut();
-}
-
-bool ModeHelper::isForced() {
-	return forced;
-}
-
-void ModeHelper::setForced(bool forced) {
-	this->forced = forced;
-}
+#include "../modes/HasModesIF.h"
+#include "../modes/ModeHelper.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ModeHelper::ModeHelper(HasModesIF *owner) :
+		commandedMode(HasModesIF::MODE_OFF),
+		commandedSubmode(HasModesIF::SUBMODE_NONE),
+		owner(owner), forced(false) {}
+
+ModeHelper::~ModeHelper() {
+
+}
+
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+	CommandMessage reply;
+	Mode_t mode;
+	Submode_t submode;
+	switch (command->getCommand()) {
+	case ModeMessage::CMD_MODE_COMMAND_FORCED:
+		forced = true;
+		/* NO BREAK falls through*/
+	case ModeMessage::CMD_MODE_COMMAND: {
+		mode = ModeMessage::getMode(command);
+		submode = ModeMessage::getSubmode(command);
+		uint32_t timeout;
+		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			ModeMessage::cantReachMode(&reply, result);
+			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+			        owner->getCommandQueue());
+			break;
+		}
+		//Free to start transition
+		theOneWhoCommandedAMode = command->getSender();
+		commandedMode = mode;
+		commandedSubmode = submode;
+
+		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+				&& (theOneWhoCommandedAMode != parentQueueId)) {
+			owner->setToExternalControl();
+		}
+
+		countdown.setTimeout(timeout);
+		owner->startTransition(mode, submode);
+	}
+		break;
+	case ModeMessage::CMD_MODE_READ: {
+		owner->getMode(&mode, &submode);
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY, mode,
+				submode);
+		MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
+		       owner->getCommandQueue());
+	}
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE:
+		owner->announceMode(false);
+		break;
+	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+		owner->announceMode(true);
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeHelper::initialize(MessageQueueId_t parentQueueId) {
+	setParentQueue(parentQueueId);
+	return initialize();
+}
+
+void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
+	forced = false;
+	sendModeReplyMessage(ownerMode, ownerSubmode);
+	sendModeInfoMessage(ownerMode, ownerSubmode);
+	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+}
+
+void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	{
+		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
+		{
+			ModeMessage::setModeMessage(&reply,
+					ModeMessage::REPLY_WRONG_MODE_REPLY, ownerMode,
+					ownerSubmode);
+		}
+		else
+		{
+			ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_REPLY,
+					ownerMode, ownerSubmode);
+		}
+		MessageQueueSenderIF::sendMessage(theOneWhoCommandedAMode, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
+		Submode_t ownerSubmode) {
+	CommandMessage reply;
+	if (theOneWhoCommandedAMode != parentQueueId
+			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+	{
+		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
+				ownerMode, ownerSubmode);
+		MessageQueueSenderIF::sendMessage(parentQueueId, &reply,
+		        owner->getCommandQueue());
+	}
+}
+
+void ModeHelper::startTimer(uint32_t timeoutMs) {
+	countdown.setTimeout(timeoutMs);
+}
+
+void ModeHelper::setParentQueue(MessageQueueId_t parentQueueId) {
+	this->parentQueueId = parentQueueId;
+}
+
+ReturnValue_t ModeHelper::initialize(void) {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+bool ModeHelper::isTimedOut() {
+	return countdown.hasTimedOut();
+}
+
+bool ModeHelper::isForced() {
+	return forced;
+}
+
+void ModeHelper::setForced(bool forced) {
+	this->forced = forced;
+}
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 1e51bce5..02cf5799 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,53 +1,53 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
-
-#include "../ipc/MessageQueueIF.h"
-#include "../modes/ModeMessage.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-
-class HasModesIF;
-
-class ModeHelper {
-public:
-	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
-	Mode_t commandedMode;
-	Submode_t commandedSubmode;
-
-	ModeHelper(HasModesIF *owner);
-	virtual ~ModeHelper();
-
-	ReturnValue_t handleModeCommand(CommandMessage *message);
-
-	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
-	 */
-	void setParentQueue(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
-
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
-
-	void modeChanged(Mode_t mode, Submode_t submode);
-
-	void startTimer(uint32_t timeoutMs);
-
-	bool isTimedOut();
-
-	bool isForced();
-
-	void setForced(bool forced);
-protected:
-	HasModesIF *owner;
-	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
-
-	Countdown countdown;
-
-	bool forced;
-private:
-	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
-};
-
-#endif /* MODEHELPER_H_ */
+#ifndef MODEHELPER_H_
+#define MODEHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../modes/ModeMessage.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class HasModesIF;
+
+class ModeHelper {
+public:
+	MessageQueueId_t theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
+	Mode_t commandedMode;
+	Submode_t commandedSubmode;
+
+	ModeHelper(HasModesIF *owner);
+	virtual ~ModeHelper();
+
+	ReturnValue_t handleModeCommand(CommandMessage *message);
+
+	/**
+	 *
+	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 */
+	void setParentQueue(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
+
+	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+
+	void modeChanged(Mode_t mode, Submode_t submode);
+
+	void startTimer(uint32_t timeoutMs);
+
+	bool isTimedOut();
+
+	bool isForced();
+
+	void setForced(bool forced);
+protected:
+	HasModesIF *owner;
+	MessageQueueId_t parentQueueId = MessageQueueIF::NO_QUEUE;
+
+	Countdown countdown;
+
+	bool forced;
+private:
+	void sendModeReplyMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
+};
+
+#endif /* MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index de3fc69c..7ad7d06f 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,31 +1,31 @@
-#include "../modes/ModeMessage.h"
-
-Mode_t ModeMessage::getMode(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
-	message->setCommand( command );
-	message->setParameter( mode );
-	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-void ModeMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-}
-
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
-	message->setCommand(REPLY_CANT_REACH_MODE);
-	message->setParameter(reason);
-	message->setParameter2(0);
-}
+#include "../modes/ModeMessage.h"
+
+Mode_t ModeMessage::getMode(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
+		Mode_t mode, Submode_t submode) {
+	message->setCommand( command );
+	message->setParameter( mode );
+	message->setParameter2( submode );
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+void ModeMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+}
+
+void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+	message->setCommand(REPLY_CANT_REACH_MODE);
+	message->setParameter(reason);
+	message->setParameter2(0);
+}
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 63624b1d..925f3fc1 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,40 +1,40 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-
-typedef uint32_t Mode_t;
-typedef uint8_t Submode_t;
-
-class ModeMessage {
-private:
-	ModeMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
-	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
-	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
-	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
-	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
-	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
-	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
-	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
-	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
-
-	static Mode_t getMode(const CommandMessage* message);
-	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
-			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* MODEMESSAGE_H_ */
+/**
+ * @file	ModeMessage.h
+ * @brief	This file defines the ModeMessage class.
+ * @date	17.07.2013
+ * @author	baetz
+ */
+
+#ifndef MODEMESSAGE_H_
+#define MODEMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+
+typedef uint32_t Mode_t;
+typedef uint8_t Submode_t;
+
+class ModeMessage {
+private:
+	ModeMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
+	static const Command_t CMD_MODE_COMMAND = MAKE_COMMAND_ID(0x01);//!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
+	static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(0xF1);//!> Command to set the specified Mode, regardless of external control flag, replies are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies, as this will break the subsystem mode machine!!
+	static const Command_t REPLY_MODE_REPLY = MAKE_COMMAND_ID(0x02);//!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+	static const Command_t REPLY_MODE_INFO = MAKE_COMMAND_ID(0x03);	//!> Unrequested info about the current mode (used for composites to inform their container of a changed mode)
+	static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(0x04); //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
+	static const Command_t REPLY_WRONG_MODE_REPLY = MAKE_COMMAND_ID(0x05);//!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded and a transition started but was aborted; the parameters contain the mode that was reached
+	static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(0x06);//!> Command to read the current mode and reply with a REPLY_MODE_REPLY
+	static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(0x07);//!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
+	static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY = MAKE_COMMAND_ID(0x08);//!> Command to trigger an ModeInfo Event and to send this command to every child. This command does NOT have a reply.
+
+	static Mode_t getMode(const CommandMessage* message);
+	static Submode_t getSubmode(const CommandMessage* message);
+	static ReturnValue_t setModeMessage(CommandMessage* message,
+			Command_t command, Mode_t mode, Submode_t submode);
+	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
+	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void clear(CommandMessage* message);
+};
+
+#endif /* MODEMESSAGE_H_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 6b546bd0..c32c63ef 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-
-#include "../monitoring/MonitorBase.h"
-#include <cmath>
-
-template<typename T>
-class AbsLimitMonitor: public MonitorBase<T> {
-public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
-	}
-	virtual ~AbsLimitMonitor() {
-	}
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = limit;
-		if (aboveIsViolation) {
-			if ((std::abs(sample) > limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		} else {
-			if ((std::abs(sample) < limit)) {
-				return MonitoringIF::OUT_OF_RANGE;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->limit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	void setLimit(T value) {
-		limit = value;
-	}
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T limit;
-	const Event violationEvent;
-	const bool aboveIsViolation;
-};
-
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+#include <cmath>
+
+template<typename T>
+class AbsLimitMonitor: public MonitorBase<T> {
+public:
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	}
+	virtual ~AbsLimitMonitor() {
+	}
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = limit;
+		if (aboveIsViolation) {
+			if ((std::abs(sample) > limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		} else {
+			if ((std::abs(sample) < limit)) {
+				return MonitoringIF::OUT_OF_RANGE;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK; //We're not out of range.
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->limit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::OUT_OF_RANGE) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	void setLimit(T value) {
+		limit = value;
+	}
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::OUT_OF_RANGE:
+			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T limit;
+	const Event violationEvent;
+	const bool aboveIsViolation;
+};
+
+#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index be561efd..85d92b6b 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,30 +1,30 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
-
-#include "../events/EventReportingProxyIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class HasMonitorsIF {
-public:
-	static const uint8_t MAX_N_PARAMETER = 10;
-//	static const uint8_t MAX_N_LIMIT_ID = 10;
-	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
-			bool forOnePid = false, uint32_t parameterId = 0) = 0;
-	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
-			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
-			const uint8_t* data, const uint32_t size) = 0;
-	virtual void setAllMonitorsToUnchecked() = 0;
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~HasMonitorsIF() {
-	}
-};
-
-#endif /* HASMONITORSIF_H_ */
+/**
+ * @file	HasMonitorsIF.h
+ * @brief	This file defines the HasMonitorsIF class.
+ * @date	28.07.2014
+ * @author	baetz
+ */
+#ifndef HASMONITORSIF_H_
+#define HASMONITORSIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class HasMonitorsIF {
+public:
+	static const uint8_t MAX_N_PARAMETER = 10;
+//	static const uint8_t MAX_N_LIMIT_ID = 10;
+	virtual ReturnValue_t setCheckingOfParameters(uint8_t checkingStrategy,
+			bool forOnePid = false, uint32_t parameterId = 0) = 0;
+	virtual ReturnValue_t modifyParameterMonitor(uint8_t limitType,
+			uint32_t parameterId, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t modifyObjectMonitor(uint32_t objectId,
+			const uint8_t* data, const uint32_t size) = 0;
+	virtual void setAllMonitorsToUnchecked() = 0;
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~HasMonitorsIF() {
+	}
+};
+
+#endif /* HASMONITORSIF_H_ */
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 465d72e8..4aec8669 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
-
-#include "../monitoring/MonitorBase.h"
-
-/**
- * Variant of a limit checking class.
- * Newer version as compared to LimitCheckMonitor.
- * Functionality is more or less the same, but does not use
- * heavy weight MonitoringIF.
- */
-template<typename T>
-class LimitMonitor: public MonitorBase<T> {
-public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
-	}
-
-	virtual ~LimitMonitor() {}
-
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
-		*crossedLimit = 0.0;
-		if (sample > upperLimit) {
-			*crossedLimit = upperLimit;
-			return MonitoringIF::ABOVE_HIGH_LIMIT;
-		} else if (sample < lowerLimit) {
-			*crossedLimit = lowerLimit;
-			return MonitoringIF::BELOW_LOW_LIMIT;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK; //Within limits.
-		}
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
-				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
-			return result;
-		}
-		switch (parameterId) {
-		case 10:
-			parameterWrapper->set(this->lowerLimit);
-			break;
-		case 11:
-			parameterWrapper->set(this->upperLimit);
-			break;
-		default:
-			return this->INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	T getLowerLimit() const {
-		return lowerLimit;
-	}
-
-	T getUpperLimit() const {
-		return upperLimit;
-	}
-
-protected:
-	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch (state) {
-		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
-			break;
-		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
-			break;
-		default:
-			break;
-		}
-	}
-	T lowerLimit;
-	T upperLimit;
-	const Event belowLowEvent;
-	const Event aboveHighEvent;
-};
-
-#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_LIMITMONITOR_H_
+
+#include "../monitoring/MonitorBase.h"
+
+/**
+ * Variant of a limit checking class.
+ * Newer version as compared to LimitCheckMonitor.
+ * Functionality is more or less the same, but does not use
+ * heavy weight MonitoringIF.
+ */
+template<typename T>
+class LimitMonitor: public MonitorBase<T> {
+public:
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
+			aboveHighEvent(aboveHighEvent) {
+	}
+
+	virtual ~LimitMonitor() {}
+
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
+		*crossedLimit = 0.0;
+		if (sample > upperLimit) {
+			*crossedLimit = upperLimit;
+			return MonitoringIF::ABOVE_HIGH_LIMIT;
+		} else if (sample < lowerLimit) {
+			*crossedLimit = lowerLimit;
+			return MonitoringIF::BELOW_LOW_LIMIT;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK; //Within limits.
+		}
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
+				parameterId, parameterWrapper, newValues, startAtIndex);
+		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		if (result != this->INVALID_MATRIX_ID) {
+			return result;
+		}
+		switch (parameterId) {
+		case 10:
+			parameterWrapper->set(this->lowerLimit);
+			break;
+		case 11:
+			parameterWrapper->set(this->upperLimit);
+			break;
+		default:
+			return this->INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	bool isOutOfLimits() {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	T getLowerLimit() const {
+		return lowerLimit;
+	}
+
+	T getUpperLimit() const {
+		return upperLimit;
+	}
+
+protected:
+	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch (state) {
+		case MonitoringIF::BELOW_LOW_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			break;
+		case MonitoringIF::ABOVE_HIGH_LIMIT:
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			break;
+		default:
+			break;
+		}
+	}
+	T lowerLimit;
+	T upperLimit;
+	const Event belowLowEvent;
+	const Event aboveHighEvent;
+};
+
+#endif /* FRAMEWORK_MONITORING_LIMITMONITOR_H_ */
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 7869dc2b..87278f4e 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -1,60 +1,60 @@
-/**
- * @file	LimitViolationReporter.cpp
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/ReceivesMonitoringReportsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerializeAdapter.h"
-
-ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
-	ReturnValue_t result = checkClassLoaded();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	store_address_t storeId;
-	uint8_t* dataTarget = NULL;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
-		return MonitoringIF::INVALID_SIZE;
-	}
-	result = ipcStore->getFreeElement(&storeId, maxSize,
-			&dataTarget);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	CommandMessage report;
-	MonitoringMessage::setLimitViolationReport(&report, storeId);
-	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
-}
-
-ReturnValue_t LimitViolationReporter::checkClassLoaded() {
-	if (reportQueue == 0) {
-		ReceivesMonitoringReportsIF* receiver = objectManager->get<
-				ReceivesMonitoringReportsIF>(reportingTarget);
-		if (receiver == NULL) {
-			return ObjectManagerIF::NOT_FOUND;
-		}
-		reportQueue = receiver->getCommandQueue();
-	}
-	if (ipcStore == NULL) {
-		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//Lazy initialization.
-MessageQueueId_t LimitViolationReporter::reportQueue = 0;
-StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
-object_id_t LimitViolationReporter::reportingTarget = 0;
+/**
+ * @file	LimitViolationReporter.cpp
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
+	ReturnValue_t result = checkClassLoaded();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	store_address_t storeId;
+	uint8_t* dataTarget = NULL;
+	size_t maxSize = data->getSerializedSize();
+	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
+		return MonitoringIF::INVALID_SIZE;
+	}
+	result = ipcStore->getFreeElement(&storeId, maxSize,
+			&dataTarget);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t size = 0;
+	result = data->serialize(&dataTarget, &size, maxSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	CommandMessage report;
+	MonitoringMessage::setLimitViolationReport(&report, storeId);
+	return MessageQueueSenderIF::sendMessage(reportQueue, &report);
+}
+
+ReturnValue_t LimitViolationReporter::checkClassLoaded() {
+	if (reportQueue == 0) {
+		ReceivesMonitoringReportsIF* receiver = objectManager->get<
+				ReceivesMonitoringReportsIF>(reportingTarget);
+		if (receiver == NULL) {
+			return ObjectManagerIF::NOT_FOUND;
+		}
+		reportQueue = receiver->getCommandQueue();
+	}
+	if (ipcStore == NULL) {
+		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+//Lazy initialization.
+MessageQueueId_t LimitViolationReporter::reportQueue = 0;
+StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
+object_id_t LimitViolationReporter::reportingTarget = 0;
diff --git a/monitoring/LimitViolationReporter.h b/monitoring/LimitViolationReporter.h
index 53d67b9d..a71b972f 100644
--- a/monitoring/LimitViolationReporter.h
+++ b/monitoring/LimitViolationReporter.h
@@ -1,31 +1,31 @@
-/**
- * @file	LimitViolationReporter.h
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
-#ifndef LIMITVIOLATIONREPORTER_H_
-#define LIMITVIOLATIONREPORTER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-class LimitViolationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
-private:
-	static object_id_t reportingTarget;
-	static MessageQueueId_t reportQueue;
-	static StorageManagerIF* ipcStore;
-	static ReturnValue_t checkClassLoaded();
-	LimitViolationReporter();
-};
-
-#endif /* LIMITVIOLATIONREPORTER_H_ */
+/**
+ * @file	LimitViolationReporter.h
+ * @brief	This file defines the LimitViolationReporter class.
+ * @date	17.07.2014
+ * @author	baetz
+ */
+#ifndef LIMITVIOLATIONREPORTER_H_
+#define LIMITVIOLATIONREPORTER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+class LimitViolationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static ReturnValue_t sendLimitViolationReport(const SerializeIF* data);
+private:
+	static object_id_t reportingTarget;
+	static MessageQueueId_t reportQueue;
+	static StorageManagerIF* ipcStore;
+	static ReturnValue_t checkClassLoaded();
+	LimitViolationReporter();
+};
+
+#endif /* LIMITVIOLATIONREPORTER_H_ */
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 45fe22ec..5173c479 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,62 +1,62 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../monitoring/MonitorReporter.h"
-
-/**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
- */
-template<typename T>
-class MonitorBase: public MonitorReporter<T> {
-public:
-	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
-	}
-	virtual ~MonitorBase() {
-	}
-	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
-		T sample = 0;
-		ReturnValue_t validity = fetchSample(&sample);
-
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
-		if (validity != HasReturnvaluesIF::RETURN_OK) {
-			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
-		} else {
-			this->oldState = doCheck(sample);
-		}
-		return this->oldState;
-	}
-	virtual ReturnValue_t doCheck(T sample) {
-		T crossedLimit = 0.0;
-		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
-		return this->monitorStateIs(currentState,sample, crossedLimit);
-	}
-	//Abstract or default.
-	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
-
-protected:
-	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* MONITORBASE_H_ */
+#ifndef MONITORBASE_H_
+#define MONITORBASE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../monitoring/MonitorReporter.h"
+
+/**
+ * Base class for monitoring of parameters.
+ * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and forwarding of transition
+ * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
+ * the data pool and a simple confirmation counter.
+ */
+template<typename T>
+class MonitorBase: public MonitorReporter<T> {
+public:
+	MonitorBase(object_id_t reporterId, uint8_t monitorId,
+			uint32_t parameterId, uint16_t confirmationLimit) :
+			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+	}
+	virtual ~MonitorBase() {
+	}
+	virtual ReturnValue_t check() {
+		//1. Fetch sample of type T, return validity.
+		T sample = 0;
+		ReturnValue_t validity = fetchSample(&sample);
+
+		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		if (validity != HasReturnvaluesIF::RETURN_OK) {
+			this->monitorStateIs(validity, sample, 0);
+			//3. Otherwise, check sample.
+		} else {
+			this->oldState = doCheck(sample);
+		}
+		return this->oldState;
+	}
+	virtual ReturnValue_t doCheck(T sample) {
+		T crossedLimit = 0.0;
+		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
+		return this->monitorStateIs(currentState,sample, crossedLimit);
+	}
+	//Abstract or default.
+	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
+
+protected:
+	virtual ReturnValue_t fetchSample(T* sample) {
+		GlobDataSet mySet;
+		PIDReader<T> parameter(this->parameterId, &mySet);
+		mySet.read();
+		if (!parameter.isValid()) {
+			return MonitoringIF::INVALID;
+		}
+		*sample = parameter.value;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 69bb00ea..9823cde0 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,178 +1,178 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
-
-#include "../events/EventManagerIF.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../parameters/HasParametersIF.h"
-
-template<typename T>
-class MonitorReporter: public HasParametersIF {
-public:
-
-	static const uint8_t ENABLED = 1;
-	static const uint8_t DISABLED = 0;
-
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
-	}
-
-	virtual ~MonitorReporter() {
-	}
-
-	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
-			T crossedLimit = 0) {
-		if (state != oldState) {
-			if (isConfirmed(state)) {
-				if (eventEnabled == ENABLED) {
-					sendTransitionEvent(parameterValue, state);
-				}
-				if (reportingEnabled == ENABLED) {
-					sendTransitionReport(parameterValue, crossedLimit, state);
-				}
-				oldState = state;
-			} else {
-				//This is to ensure confirmation works.
-				//Needs to be reset to be able to confirm against oldState again next time.
-				return oldState;
-			}
-		} else {
-			resetConfirmation();
-		}
-		return state;
-	}
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != monitorId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(this->confirmationLimit);
-			break;
-		case 1:
-			parameterWrapper->set(this->reportingEnabled);
-			break;
-		case 2:
-			parameterWrapper->set(this->eventEnabled);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t setToUnchecked() {
-		return setToState(MonitoringIF::UNCHECKED);
-	}
-	virtual ReturnValue_t setToInvalid() {
-		return setToState(MonitoringIF::INVALID);
-	}
-	object_id_t getReporterId() const {
-		return reportingId;
-	}
-
-	void setEventEnabled(uint8_t eventEnabled) {
-		this->eventEnabled = eventEnabled;
-	}
-
-	void setReportingEnabled(uint8_t reportingEnabled) {
-		this->reportingEnabled = reportingEnabled;
-	}
-
-	bool isEventEnabled() const {
-		return (eventEnabled == ENABLED);
-	}
-
-protected:
-	const uint8_t monitorId;
-	const uint32_t parameterId;
-	object_id_t reportingId;
-	ReturnValue_t oldState;
-
-	uint8_t reportingEnabled;
-
-	uint8_t eventEnabled;
-
-	uint16_t currentCounter;
-	uint16_t confirmationLimit;
-
-	bool isConfirmed(ReturnValue_t state) {
-		//Confirm INVALID and UNCHECKED immediately.
-		if (state == MonitoringIF::INVALID
-				|| state == MonitoringIF::UNCHECKED) {
-			currentCounter = 0;
-			return true;
-		}
-		return doesChildConfirm(state);
-	}
-
-	/**
-	 * This is the most simple form of confirmation.
-	 * A counter counts any violation and compares the number to maxCounter.
-	 * @param state The state, indicating the type of violation. Not used here.
-	 * @return true if counter > maxCounter, else false.
-	 */
-	virtual bool doesChildConfirm(ReturnValue_t state) {
-		currentCounter += 1;
-		if (currentCounter > confirmationLimit) {
-			currentCounter = 0;
-			return true;
-		} else {
-			return false;
-		}
-	}
-	/**
-	 * This method needs to reset the confirmation in case a valid sample was found.
-	 * Here, simply resets the current counter.
-	 */
-	virtual void resetConfirmation() {
-		currentCounter = 0;
-	}
-	/**
-	 * Default version of sending transitional events.
-	 * Should be overridden from specialized monitors.
-	 * @param currentValue The current value which was monitored.
-	 * @param state The state the monitor changed to.
-	 */
-	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
-		switch(state) {
-		case MonitoringIF::UNCHECKED:
-		case MonitoringIF::UNSELECTED:
-		case MonitoringIF::INVALID:
-		case HasReturnvaluesIF::RETURN_OK:
-			break;
-		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
-			break;
-		}
-	}
-	/**
-	 * Default implementation for sending transition report.
-	 * May be overridden, but is seldom necessary.
-	 * @param parameterValue Current value of the parameter
-	 * @param crossedLimit The limit crossed (if applicable).
-	 * @param state Current state the monitor is in.
-	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
-				parameterValue, crossedLimit, oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-	ReturnValue_t setToState(ReturnValue_t state) {
-		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
-					state);
-			LimitViolationReporter::sendLimitViolationReport(&report);
-			oldState = state;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+
+#include "../events/EventManagerIF.h"
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../parameters/HasParametersIF.h"
+
+template<typename T>
+class MonitorReporter: public HasParametersIF {
+public:
+
+	static const uint8_t ENABLED = 1;
+	static const uint8_t DISABLED = 0;
+
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId), reportingId(
+					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
+			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
+					confirmationLimit) {
+	}
+
+	virtual ~MonitorReporter() {
+	}
+
+	ReturnValue_t monitorStateIs(ReturnValue_t state, T parameterValue = 0,
+			T crossedLimit = 0) {
+		if (state != oldState) {
+			if (isConfirmed(state)) {
+				if (eventEnabled == ENABLED) {
+					sendTransitionEvent(parameterValue, state);
+				}
+				if (reportingEnabled == ENABLED) {
+					sendTransitionReport(parameterValue, crossedLimit, state);
+				}
+				oldState = state;
+			} else {
+				//This is to ensure confirmation works.
+				//Needs to be reset to be able to confirm against oldState again next time.
+				return oldState;
+			}
+		} else {
+			resetConfirmation();
+		}
+		return state;
+	}
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != monitorId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(this->confirmationLimit);
+			break;
+		case 1:
+			parameterWrapper->set(this->reportingEnabled);
+			break;
+		case 2:
+			parameterWrapper->set(this->eventEnabled);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t setToUnchecked() {
+		return setToState(MonitoringIF::UNCHECKED);
+	}
+	virtual ReturnValue_t setToInvalid() {
+		return setToState(MonitoringIF::INVALID);
+	}
+	object_id_t getReporterId() const {
+		return reportingId;
+	}
+
+	void setEventEnabled(uint8_t eventEnabled) {
+		this->eventEnabled = eventEnabled;
+	}
+
+	void setReportingEnabled(uint8_t reportingEnabled) {
+		this->reportingEnabled = reportingEnabled;
+	}
+
+	bool isEventEnabled() const {
+		return (eventEnabled == ENABLED);
+	}
+
+protected:
+	const uint8_t monitorId;
+	const uint32_t parameterId;
+	object_id_t reportingId;
+	ReturnValue_t oldState;
+
+	uint8_t reportingEnabled;
+
+	uint8_t eventEnabled;
+
+	uint16_t currentCounter;
+	uint16_t confirmationLimit;
+
+	bool isConfirmed(ReturnValue_t state) {
+		//Confirm INVALID and UNCHECKED immediately.
+		if (state == MonitoringIF::INVALID
+				|| state == MonitoringIF::UNCHECKED) {
+			currentCounter = 0;
+			return true;
+		}
+		return doesChildConfirm(state);
+	}
+
+	/**
+	 * This is the most simple form of confirmation.
+	 * A counter counts any violation and compares the number to maxCounter.
+	 * @param state The state, indicating the type of violation. Not used here.
+	 * @return true if counter > maxCounter, else false.
+	 */
+	virtual bool doesChildConfirm(ReturnValue_t state) {
+		currentCounter += 1;
+		if (currentCounter > confirmationLimit) {
+			currentCounter = 0;
+			return true;
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * This method needs to reset the confirmation in case a valid sample was found.
+	 * Here, simply resets the current counter.
+	 */
+	virtual void resetConfirmation() {
+		currentCounter = 0;
+	}
+	/**
+	 * Default version of sending transitional events.
+	 * Should be overridden from specialized monitors.
+	 * @param currentValue The current value which was monitored.
+	 * @param state The state the monitor changed to.
+	 */
+	virtual void sendTransitionEvent(T currentValue, ReturnValue_t state) {
+		switch(state) {
+		case MonitoringIF::UNCHECKED:
+		case MonitoringIF::UNSELECTED:
+		case MonitoringIF::INVALID:
+		case HasReturnvaluesIF::RETURN_OK:
+			break;
+		default:
+			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			break;
+		}
+	}
+	/**
+	 * Default implementation for sending transition report.
+	 * May be overridden, but is seldom necessary.
+	 * @param parameterValue Current value of the parameter
+	 * @param crossedLimit The limit crossed (if applicable).
+	 * @param state Current state the monitor is in.
+	 */
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+		MonitoringReportContent<T> report(parameterId,
+				parameterValue, crossedLimit, oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+	ReturnValue_t setToState(ReturnValue_t state) {
+		if (oldState != state && reportingEnabled) {
+			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+					state);
+			LimitViolationReporter::sendLimitViolationReport(&report);
+			oldState = state;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index a4c0666c..d9ea339f 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,67 +1,67 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../monitoring/MonitoringMessage.h"
-#include "../serialize/SerializeIF.h"
-
-class MonitoringIF : public SerializeIF {
-public:
-	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
-	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
-	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
-	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
-	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
-	static const uint8_t LIMIT_TYPE_OBJECT = 128;
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
-	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
-//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
-
-
-	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
-	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
-	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
-	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
-	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
-	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
-
-	static const uint8_t REPORT_NONE = 0;
-	static const uint8_t REPORT_EVENTS_ONLY = 1;
-	static const uint8_t REPORT_REPORTS_ONLY = 2;
-	static const uint8_t REPORT_ALL = 3;
-
-//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
-//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
-//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
-//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
-//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
-//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
-//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
-	virtual ReturnValue_t check() = 0;
-	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
-	virtual ReturnValue_t setToUnchecked() = 0;
-	virtual uint8_t getLimitType() const = 0;
-	virtual uint32_t getLimitId() const = 0;
-//	virtual ReturnValue_t setEventReporting(bool active) = 0;
-	virtual ~MonitoringIF() {
-	}
-};
-
-
-
-#endif /* MONITORINGIF_H_ */
+#ifndef MONITORINGIF_H_
+#define MONITORINGIF_H_
+
+#include "../memory/HasMemoryIF.h"
+#include "../monitoring/MonitoringMessage.h"
+#include "../serialize/SerializeIF.h"
+
+class MonitoringIF : public SerializeIF {
+public:
+	static const uint8_t VIOLATION_REPORT_MAX_SIZE = 32;
+	static const uint8_t LIMIT_TYPE_NO_TYPE = 0xFF;
+	static const uint8_t LIMIT_TYPE_LIMIT_CHECK = 0;
+	static const uint8_t LIMIT_TYPE_DELTA_CHECK = 1;
+	static const uint8_t LIMIT_TYPE_ABSOLUTE_CHECK = 2;
+	static const uint8_t LIMIT_TYPE_OBJECT = 128;
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
+	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t INVALID = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t UNSELECTED = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BELOW_LOW_LIMIT = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_BELOW_LOW_THRESHOLD = MAKE_RETURN_CODE(4);
+//	static const ReturnValue_t CHECKING_STATUS_ABOVE_HIGH_THRESHOLD = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t ABOVE_HIGH_LIMIT = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t UNEXPECTED_VALUE = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t OUT_OF_RANGE = MAKE_RETURN_CODE(7);
+
+
+	static const ReturnValue_t FIRST_SAMPLE = MAKE_RETURN_CODE(0xA0);
+	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE0);
+	static const ReturnValue_t WRONG_TYPE = MAKE_RETURN_CODE(0xE1);
+	static const ReturnValue_t WRONG_PID = MAKE_RETURN_CODE(0xE2);
+	static const ReturnValue_t WRONG_LIMIT_ID = MAKE_RETURN_CODE(0xE3);
+	static const ReturnValue_t MONITOR_NOT_FOUND = MAKE_RETURN_CODE(0xEE);
+
+	static const uint8_t REPORT_NONE = 0;
+	static const uint8_t REPORT_EVENTS_ONLY = 1;
+	static const uint8_t REPORT_REPORTS_ONLY = 2;
+	static const uint8_t REPORT_ALL = 3;
+
+//	static const ReturnValue_t STILL_IN_LOW_WARNING = MAKE_RETURN_CODE(0x11);
+//	static const ReturnValue_t STILL_IN_LOW_LIMIT = MAKE_RETURN_CODE(0x12);
+//	static const ReturnValue_t STILL_IN_HIGH_WARNING = MAKE_RETURN_CODE(0x13);
+//	static const ReturnValue_t STILL_IN_HIGH_LIMIT = MAKE_RETURN_CODE(0x14);
+//	static const ReturnValue_t VARIABLE_IS_INVALID = MAKE_RETURN_CODE(0xE0);
+//	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE1);
+//	static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xE2);
+	virtual ReturnValue_t check() = 0;
+	virtual ReturnValue_t setLimits( uint8_t type, const uint8_t* data, uint32_t size) = 0;
+	virtual ReturnValue_t setChecking(uint8_t strategy) = 0;
+	virtual ReturnValue_t setToUnchecked() = 0;
+	virtual uint8_t getLimitType() const = 0;
+	virtual uint32_t getLimitId() const = 0;
+//	virtual ReturnValue_t setEventReporting(bool active) = 0;
+	virtual ~MonitoringIF() {
+	}
+};
+
+
+
+#endif /* MONITORINGIF_H_ */
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 9edf16d5..2cfe1ece 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,38 +1,38 @@
-#include "../monitoring/MonitoringMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-MonitoringMessage::~MonitoringMessage() {
-}
-
-void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
-		store_address_t storeId) {
-	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
-}
-
-void MonitoringMessage::setTypicalMessage(CommandMessage* message,
-		Command_t type, store_address_t storeId) {
-	message->setCommand(type);
-	message->setParameter2(storeId.raw);
-}
-
-store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void MonitoringMessage::clear(CommandMessage* message) {
-	message->setCommand(CommandMessage::CMD_NONE);
-	switch (message->getCommand()) {
-	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../monitoring/MonitoringMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+MonitoringMessage::~MonitoringMessage() {
+}
+
+void MonitoringMessage::setLimitViolationReport(CommandMessage* message,
+		store_address_t storeId) {
+	setTypicalMessage(message, LIMIT_VIOLATION_REPORT, storeId);
+}
+
+void MonitoringMessage::setTypicalMessage(CommandMessage* message,
+		Command_t type, store_address_t storeId) {
+	message->setCommand(type);
+	message->setParameter2(storeId.raw);
+}
+
+store_address_t MonitoringMessage::getStoreId(const CommandMessage* message) {
+	store_address_t temp;
+	temp.raw = message->getParameter2();
+	return temp;
+}
+
+void MonitoringMessage::clear(CommandMessage* message) {
+	message->setCommand(CommandMessage::CMD_NONE);
+	switch (message->getCommand()) {
+	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h
index 55d3ea5c..84b02750 100644
--- a/monitoring/MonitoringMessage.h
+++ b/monitoring/MonitoringMessage.h
@@ -1,21 +1,21 @@
-#ifndef MONITORINGMESSAGE_H_
-#define MONITORINGMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-class MonitoringMessage: public CommandMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
-	//Object id could be useful, but we better manage that on service level (register potential reporters).
-	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
-	virtual ~MonitoringMessage();
-	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
-	static void clear(CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
-
-};
-
-
-#endif /* MONITORINGMESSAGE_H_ */
+#ifndef MONITORINGMESSAGE_H_
+#define MONITORINGMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class MonitoringMessage: public CommandMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MONITORING;
+	//Object id could be useful, but we better manage that on service level (register potential reporters).
+	static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
+	virtual ~MonitoringMessage();
+	static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
+	static void clear(CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
+
+};
+
+
+#endif /* MONITORINGMESSAGE_H_ */
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index a0934c14..ea52962b 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,77 +1,77 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
-
-#include "../monitoring/HasMonitorsIF.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../timemanager/TimeStamperIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
-template<typename T>
-class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
-	SerializeElement<T> parameterValue;
-	SerializeElement<T> limitValue;
-	SerializeElement<ReturnValue_t> oldState;
-	SerializeElement<ReturnValue_t> newState;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-	TimeStamperIF* timeStamper;
-	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
-					sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
-			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
-		setAllNext();
-		if (checkAndSetStamper()) {
-			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
-		}
-	}
-private:
-
-	static object_id_t timeStamperId;
-	void setAllNext() {
-		parameterId.setNext(&parameterValue);
-		parameterValue.setNext(&limitValue);
-		limitValue.setNext(&oldState);
-		oldState.setNext(&newState);
-		newState.setNext(&timestampSerializer);
-	}
-	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
-			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
-				sif::error << "MonitoringReportContent::checkAndSetStamper: "
-				        "Stamper not found!" << std::endl;
-				return false;
-			}
-		}
-		return true;
-	}
-};
-template<typename T>
-object_id_t MonitoringReportContent<T>::timeStamperId = 0;
-
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#ifndef MONITORINGMESSAGECONTENT_H_
+#define MONITORINGMESSAGECONTENT_H_
+
+#include "../monitoring/HasMonitorsIF.h"
+#include "../monitoring/MonitoringIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../timemanager/TimeStamperIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+//PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+template<typename T>
+class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	SerializeElement<uint8_t> monitorId;
+	SerializeElement<uint32_t> parameterId;
+	SerializeElement<T> parameterValue;
+	SerializeElement<T> limitValue;
+	SerializeElement<ReturnValue_t> oldState;
+	SerializeElement<ReturnValue_t> newState;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
+	TimeStamperIF* timeStamper;
+	MonitoringReportContent() :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					0), parameterValue(0), limitValue(0), oldState(0), newState(
+					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+					sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+	}
+	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+			ReturnValue_t oldState, ReturnValue_t newState) :
+			SerialLinkedListAdapter<SerializeIF>(
+					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
+					setPID), parameterValue(value), limitValue(limitValue), oldState(
+					oldState), newState(newState), timestampSerializer(rawTimestamp,
+							sizeof(rawTimestamp)), timeStamper(NULL) {
+		setAllNext();
+		if (checkAndSetStamper()) {
+			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
+		}
+	}
+private:
+
+	static object_id_t timeStamperId;
+	void setAllNext() {
+		parameterId.setNext(&parameterValue);
+		parameterValue.setNext(&limitValue);
+		limitValue.setNext(&oldState);
+		oldState.setNext(&newState);
+		newState.setNext(&timestampSerializer);
+	}
+	bool checkAndSetStamper() {
+		if (timeStamper == NULL) {
+			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
+			if ( timeStamper == NULL ) {
+				sif::error << "MonitoringReportContent::checkAndSetStamper: "
+				        "Stamper not found!" << std::endl;
+				return false;
+			}
+		}
+		return true;
+	}
+};
+template<typename T>
+object_id_t MonitoringReportContent<T>::timeStamperId = 0;
+
+#endif /* MONITORINGMESSAGECONTENT_H_ */
diff --git a/monitoring/ReceivesMonitoringReportsIF.h b/monitoring/ReceivesMonitoringReportsIF.h
index 16595f33..fb37c16c 100644
--- a/monitoring/ReceivesMonitoringReportsIF.h
+++ b/monitoring/ReceivesMonitoringReportsIF.h
@@ -1,15 +1,15 @@
-#ifndef RECEIVESMONITORINGREPORTSIF_H_
-#define RECEIVESMONITORINGREPORTSIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-class ReceivesMonitoringReportsIF {
-public:
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ~ReceivesMonitoringReportsIF() {
-	}
-};
-
-
-
-#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
+#ifndef RECEIVESMONITORINGREPORTSIF_H_
+#define RECEIVESMONITORINGREPORTSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesMonitoringReportsIF {
+public:
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ~ReceivesMonitoringReportsIF() {
+	}
+};
+
+
+
+#endif /* RECEIVESMONITORINGREPORTSIF_H_ */
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 6f190361..9b60aeb6 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
-
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReaderList.h"
-#include "../health/HealthTableIF.h"
-#include "../parameters/HasParametersIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-
-//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
-template<typename T>
-class TriplexMonitor : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
-	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
-
-	static const uint8_t THREE = 3;
-
-	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
-			Event eventTripleCheck, Event eventDualCheck) :
-			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
-					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
-					NULL), domainId(domainId) {
-
-	}
-	virtual ~TriplexMonitor() {
-	}
-	ReturnValue_t check() {
-		dataSet.read();
-		//check health and validity
-		uint8_t availableIndex[2] = { 0, 0 };
-		bool first = true;
-		uint8_t nAvailable = 0;
-		for (uint8_t count = 0; count < THREE; count++) {
-			if (values[count].isValid() && checkObjectHealthState(count)) {
-				if (first) {
-					availableIndex[0] = count;
-					first = false;
-				} else {
-					//Might be filled twice, but then it's not needed anyway.
-					availableIndex[1] = count;
-				}
-				nAvailable++;
-			}
-		}
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-		switch (nAvailable) {
-		case 3:
-			result = doTriplexMonitoring();
-			break;
-		case 2:
-			result = doDuplexMonitoring(availableIndex);
-			break;
-		default:
-			result = NOT_ENOUGH_SENSORS;
-			break;
-		}
-		dataSet.commit();
-		return result;
-	}
-	ReturnValue_t initialize() {
-		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
-		if (healthTable == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		if (domainId != this->domainId) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case 0:
-			parameterWrapper->set(limit);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-protected:
-	DataSet dataSet;
-	PIDReaderList<T, THREE> values;
-	T limit;
-	Event eventTripleCheck;
-	Event eventDualCheck;
-	HealthTableIF* healthTable;
-	uint8_t domainId;
-	ReturnValue_t doTriplexMonitoring() {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		//Find middle value, by ordering indices
-		uint8_t index[3] = { 0, 1, 2 };
-		if (values[index[0]].value > values[index[1]].value) {
-			std::swap(index[0], index[1]);
-		}
-		if (values[index[0]].value > values[index[2]].value) {
-			std::swap(index[0], index[2]);
-		}
-		if (values[index[1]].value > values[index[2]].value) {
-			std::swap(index[1], index[2]);
-		}
-		//Test if smallest value is out-of-limit.
-		if (values[index[0]] < (values[index[1]] - limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-					eventTripleCheck, LOWEST_VALUE_OOL, 0);
-			result = LOWEST_VALUE_OOL;
-		}
-		//Test if largest value is out-of-limit.
-		if (values[index[2]] > (values[index[1]] + limit)) {
-			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
-					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
-			if (result == HasReturnvaluesIF::RETURN_OK) {
-				result = HIGHEST_VALUE_OOL;
-			} else {
-				result = BOTH_VALUES_OOL;
-			}
-		}
-		return result;
-	}
-
-	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
-		T mean = (values[index[0]] + values[index[1]]) / 2;
-		if (values[index[0]] > values[index[1]]) {
-			if (values[index[0]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		} else {
-			if (values[index[1]] > (mean + limit)) {
-				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
-						eventDualCheck, 0, 0);
-				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
-						eventDualCheck, 0, 0);
-				return DUPLEX_OOL;
-			}
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
-	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
-};
-
-#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+#define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_
+
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReaderList.h"
+#include "../health/HealthTableIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+
+//SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
+template<typename T>
+class TriplexMonitor : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TRIPLE_REDUNDACY_CHECK;
+	static const ReturnValue_t NOT_ENOUGH_SENSORS = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LOWEST_VALUE_OOL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t HIGHEST_VALUE_OOL = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BOTH_VALUES_OOL = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t DUPLEX_OOL = MAKE_RETURN_CODE(5);
+
+	static const uint8_t THREE = 3;
+
+	TriplexMonitor(const uint32_t parameterIds[3], uint8_t domainId, const T initialLimit,
+			Event eventTripleCheck, Event eventDualCheck) :
+			values(parameterIds, &dataSet), limit(initialLimit), eventTripleCheck(
+					eventTripleCheck), eventDualCheck(eventDualCheck), healthTable(
+					NULL), domainId(domainId) {
+
+	}
+	virtual ~TriplexMonitor() {
+	}
+	ReturnValue_t check() {
+		dataSet.read();
+		//check health and validity
+		uint8_t availableIndex[2] = { 0, 0 };
+		bool first = true;
+		uint8_t nAvailable = 0;
+		for (uint8_t count = 0; count < THREE; count++) {
+			if (values[count].isValid() && checkObjectHealthState(count)) {
+				if (first) {
+					availableIndex[0] = count;
+					first = false;
+				} else {
+					//Might be filled twice, but then it's not needed anyway.
+					availableIndex[1] = count;
+				}
+				nAvailable++;
+			}
+		}
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+		switch (nAvailable) {
+		case 3:
+			result = doTriplexMonitoring();
+			break;
+		case 2:
+			result = doDuplexMonitoring(availableIndex);
+			break;
+		default:
+			result = NOT_ENOUGH_SENSORS;
+			break;
+		}
+		dataSet.commit();
+		return result;
+	}
+	ReturnValue_t initialize() {
+		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+		if (healthTable == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		if (domainId != this->domainId) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case 0:
+			parameterWrapper->set(limit);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+protected:
+	DataSet dataSet;
+	PIDReaderList<T, THREE> values;
+	T limit;
+	Event eventTripleCheck;
+	Event eventDualCheck;
+	HealthTableIF* healthTable;
+	uint8_t domainId;
+	ReturnValue_t doTriplexMonitoring() {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		//Find middle value, by ordering indices
+		uint8_t index[3] = { 0, 1, 2 };
+		if (values[index[0]].value > values[index[1]].value) {
+			std::swap(index[0], index[1]);
+		}
+		if (values[index[0]].value > values[index[2]].value) {
+			std::swap(index[0], index[2]);
+		}
+		if (values[index[1]].value > values[index[2]].value) {
+			std::swap(index[1], index[2]);
+		}
+		//Test if smallest value is out-of-limit.
+		if (values[index[0]] < (values[index[1]] - limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+					eventTripleCheck, LOWEST_VALUE_OOL, 0);
+			result = LOWEST_VALUE_OOL;
+		}
+		//Test if largest value is out-of-limit.
+		if (values[index[2]] > (values[index[1]] + limit)) {
+			EventManagerIF::triggerEvent(getRefereneceObject(index[2]),
+					eventTripleCheck, HIGHEST_VALUE_OOL, 0);
+			if (result == HasReturnvaluesIF::RETURN_OK) {
+				result = HIGHEST_VALUE_OOL;
+			} else {
+				result = BOTH_VALUES_OOL;
+			}
+		}
+		return result;
+	}
+
+	ReturnValue_t doDuplexMonitoring(uint8_t index[2]) {
+		T mean = (values[index[0]] + values[index[1]]) / 2;
+		if (values[index[0]] > values[index[1]]) {
+			if (values[index[0]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		} else {
+			if (values[index[1]] > (mean + limit)) {
+				EventManagerIF::triggerEvent(getRefereneceObject(index[0]),
+						eventDualCheck, 0, 0);
+				EventManagerIF::triggerEvent(getRefereneceObject(index[1]),
+						eventDualCheck, 0, 0);
+				return DUPLEX_OOL;
+			}
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual bool checkObjectHealthState(uint8_t valueIndex) = 0;
+	virtual object_id_t getRefereneceObject(uint8_t valueIndex) = 0;
+};
+
+#endif /* FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ */
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index ac0ef1ee..74934828 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,44 +1,44 @@
-#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
-
-#include "../monitoring/LimitMonitor.h"
-
-template<typename T>
-class TwoValueLimitMonitor: public LimitMonitor<T> {
-public:
-	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-			uint32_t lowParameterId, uint32_t highParameterId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
-			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
-					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
-					aboveHighEvent), highValueParameterId(highParameterId) {
-	}
-	virtual ~TwoValueLimitMonitor() {
-	}
-	ReturnValue_t doCheck(T lowSample, T highSample) {
-		T crossedLimit;
-		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
-		if (currentState != HasReturnvaluesIF::RETURN_OK) {
-			return this->monitorStateIs(currentState, lowSample, crossedLimit);
-		}
-		currentState = this->checkSample(highSample, &crossedLimit);
-		return this->monitorStateIs(currentState, highSample, crossedLimit);
-	}
-protected:
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
-			ReturnValue_t state) {
-		uint32_t usedParameterId = this->parameterId;
-		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			usedParameterId = this->highValueParameterId;
-		}
-		MonitoringReportContent<T> report(usedParameterId, parameterValue,
-				crossedLimit, this->oldState, state);
-		LimitViolationReporter::sendLimitViolationReport(&report);
-	}
-private:
-	const uint32_t highValueParameterId;
-};
-
-#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
+#ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+#define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
+
+#include "../monitoring/LimitMonitor.h"
+
+template<typename T>
+class TwoValueLimitMonitor: public LimitMonitor<T> {
+public:
+	TwoValueLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+			uint32_t lowParameterId, uint32_t highParameterId,
+			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
+			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
+			LimitMonitor<T>(reporterId, monitorId, lowParameterId,
+					confirmationLimit, lowerLimit, upperLimit, belowLowEvent,
+					aboveHighEvent), highValueParameterId(highParameterId) {
+	}
+	virtual ~TwoValueLimitMonitor() {
+	}
+	ReturnValue_t doCheck(T lowSample, T highSample) {
+		T crossedLimit;
+		ReturnValue_t currentState = this->checkSample(lowSample, &crossedLimit);
+		if (currentState != HasReturnvaluesIF::RETURN_OK) {
+			return this->monitorStateIs(currentState, lowSample, crossedLimit);
+		}
+		currentState = this->checkSample(highSample, &crossedLimit);
+		return this->monitorStateIs(currentState, highSample, crossedLimit);
+	}
+protected:
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+			ReturnValue_t state) {
+		uint32_t usedParameterId = this->parameterId;
+		if (state == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			usedParameterId = this->highValueParameterId;
+		}
+		MonitoringReportContent<T> report(usedParameterId, parameterValue,
+				crossedLimit, this->oldState, state);
+		LimitViolationReporter::sendLimitViolationReport(&report);
+	}
+private:
+	const uint32_t highValueParameterId;
+};
+
+#endif /* FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ */
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 467eed4b..a8c84415 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,107 +1,107 @@
-#include "../objectmanager/ObjectManager.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <iomanip>
-#include <cstdlib>
-
-ObjectManager::ObjectManager( void (*setProducer)() ):
-		produceObjects(setProducer) {
-	//There's nothing special to do in the constructor.
-}
-
-
-ObjectManager::~ObjectManager() {
-	for (auto const& iter : objectList) {
-		delete iter.second;
-	}
-}
-
-ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
-	auto returnPair = objectList.emplace(id, object);
-	if (returnPair.second) {
-	    // sif::debug << "ObjectManager::insert: Object " << std::hex
-	    //            << (int)id << std::dec << " inserted." << std::endl;
-		return this->RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
-		sif::error << "Terminating program." << std::endl;
-		//This is very severe and difficult to handle in other places.
-		std::exit(INSERTION_FAILED);
-	}
-}
-
-ReturnValue_t ObjectManager::remove( object_id_t id ) {
-	if ( this->getSystemObject(id) != NULL ) {
-		this->objectList.erase( id );
-		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
-		//           << (int)id << std::dec << " removed." << std::endl;
-		return RETURN_OK;
-	} else {
-		sif::error << "ObjectManager::removeObject: Requested object "
-		        << std::hex << (int)id << std::dec << " not found." << std::endl;
-		return NOT_FOUND;
-	}
-}
-
-
-
-SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
-	auto listIter = this->objectList.find( id );
-	if (listIter == this->objectList.end() ) {
-		return nullptr;
-	} else {
-		return listIter->second;
-	}
-}
-
-ObjectManager::ObjectManager() : produceObjects(nullptr) {
-
-}
-
-void ObjectManager::initialize() {
-	if(produceObjects == nullptr) {
-		sif::error << "ObjectManager::initialize: Passed produceObjects "
-				"functions is nullptr!" << std::endl;
-		return;
-	}
-	this->produceObjects();
-	ReturnValue_t result = RETURN_FAILED;
-	uint32_t errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->initialize();
-		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
-			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
-					std::setw(8) << std::setfill('0')<< var << " failed to "
-					"initialize with code 0x" << result << std::dec <<
-					std::setfill(' ') << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed initializations." << std::endl;
-	}
-	//Init was successful. Now check successful interconnections.
-	errorCount = 0;
-	for (auto const& it : objectList) {
-		result = it.second->checkObjectConnections();
-		if ( result != RETURN_OK ) {
-			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
-					(int) it.first  << " connection check failed with code 0x"
-					<< result << std::dec << std::endl;
-			errorCount++;
-		}
-	}
-	if (errorCount > 0) {
-		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
-		           << " failed connection checks." << std::endl;
-	}
-}
-
-void ObjectManager::printList() {
-	sif::debug << "ObjectManager: Object List contains:" << std::endl;
-	for (auto const& it : objectList) {
-		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
-	}
-}
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+#include <cstdlib>
+
+ObjectManager::ObjectManager( void (*setProducer)() ):
+		produceObjects(setProducer) {
+	//There's nothing special to do in the constructor.
+}
+
+
+ObjectManager::~ObjectManager() {
+	for (auto const& iter : objectList) {
+		delete iter.second;
+	}
+}
+
+ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
+	auto returnPair = objectList.emplace(id, object);
+	if (returnPair.second) {
+	    // sif::debug << "ObjectManager::insert: Object " << std::hex
+	    //            << (int)id << std::dec << " inserted." << std::endl;
+		return this->RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::insert: Object id " << std::hex
+		           << (int)id << std::dec << " is already in use!" << std::endl;
+		sif::error << "Terminating program." << std::endl;
+		//This is very severe and difficult to handle in other places.
+		std::exit(INSERTION_FAILED);
+	}
+}
+
+ReturnValue_t ObjectManager::remove( object_id_t id ) {
+	if ( this->getSystemObject(id) != NULL ) {
+		this->objectList.erase( id );
+		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
+		//           << (int)id << std::dec << " removed." << std::endl;
+		return RETURN_OK;
+	} else {
+		sif::error << "ObjectManager::removeObject: Requested object "
+		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+		return NOT_FOUND;
+	}
+}
+
+
+
+SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
+	auto listIter = this->objectList.find( id );
+	if (listIter == this->objectList.end() ) {
+		return nullptr;
+	} else {
+		return listIter->second;
+	}
+}
+
+ObjectManager::ObjectManager() : produceObjects(nullptr) {
+
+}
+
+void ObjectManager::initialize() {
+	if(produceObjects == nullptr) {
+		sif::error << "ObjectManager::initialize: Passed produceObjects "
+				"functions is nullptr!" << std::endl;
+		return;
+	}
+	this->produceObjects();
+	ReturnValue_t result = RETURN_FAILED;
+	uint32_t errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->initialize();
+		if ( result != RETURN_OK ) {
+			object_id_t var = it.first;
+			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
+					std::setw(8) << std::setfill('0')<< var << " failed to "
+					"initialize with code 0x" << result << std::dec <<
+					std::setfill(' ') << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed initializations." << std::endl;
+	}
+	//Init was successful. Now check successful interconnections.
+	errorCount = 0;
+	for (auto const& it : objectList) {
+		result = it.second->checkObjectConnections();
+		if ( result != RETURN_OK ) {
+			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
+					(int) it.first  << " connection check failed with code 0x"
+					<< result << std::dec << std::endl;
+			errorCount++;
+		}
+	}
+	if (errorCount > 0) {
+		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+		           << " failed connection checks." << std::endl;
+	}
+}
+
+void ObjectManager::printList() {
+	sif::debug << "ObjectManager: Object List contains:" << std::endl;
+	for (auto const& it : objectList) {
+		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
+	}
+}
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index 0bc525be..e582584c 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,67 +1,67 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include <map>
-
-/**
- * @brief	This class implements a global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. Objects can
- * 			be inserted, removed and retrieved from the list. In addition, the
- * 			class holds a so-called factory, that creates and inserts new
- * 			objects if they are not already in the list. This feature automates
- * 			most of the system initialization.
- * 			As the system is static after initialization, no new objects are
- * 			created or inserted into the list after startup.
- * \ingroup system_objects
- */
-class ObjectManager : public ObjectManagerIF {
-private:
-	//comparison?
-	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
-	 */
-	std::map<object_id_t, SystemObjectIF*> objectList;
-protected:
-	SystemObjectIF* getSystemObject( object_id_t id );
-	/**
-	 * @brief	This attribute is initialized with the factory function
-	 * 			that creates new objects.
-	 * @details	The function is called if an object was requested with
-	 * 			getSystemObject, but not found in objectList.
-	 * @param 	The id of the object to be created.
-	 * @return	Returns a pointer to the newly created object or NULL.
-	 */
-	void (*produceObjects)();
-public:
-	/**
-	 * @brief	Apart from setting the producer function, nothing special
-	 * 			happens in the constructor.
-	 * @param setProducer	A pointer to a factory function.
-	 */
-	ObjectManager( void (*produce)() );
-	ObjectManager();
-	/**
-	 *	@brief	In the class's destructor, all objects in the list are deleted.
-	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
-	virtual ~ObjectManager( void );
-	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
-	ReturnValue_t remove( object_id_t id );
-	void initialize();
-	void printList();
-};
-
-
-
-#endif /* OBJECTMANAGER_H_ */
+/**
+ * @file	ObjectManager.h
+ * @brief	This file contains the implementation of the ObjectManager class
+ * @date	18.09.2012
+ * @author	Bastian Baetz
+ */
+
+#ifndef OBJECTMANAGER_H_
+#define OBJECTMANAGER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include <map>
+
+/**
+ * @brief	This class implements a global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. Objects can
+ * 			be inserted, removed and retrieved from the list. In addition, the
+ * 			class holds a so-called factory, that creates and inserts new
+ * 			objects if they are not already in the list. This feature automates
+ * 			most of the system initialization.
+ * 			As the system is static after initialization, no new objects are
+ * 			created or inserted into the list after startup.
+ * \ingroup system_objects
+ */
+class ObjectManager : public ObjectManagerIF {
+private:
+	//comparison?
+	/**
+	 * \brief	This is the map of all initialized objects in the manager.
+	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 */
+	std::map<object_id_t, SystemObjectIF*> objectList;
+protected:
+	SystemObjectIF* getSystemObject( object_id_t id );
+	/**
+	 * @brief	This attribute is initialized with the factory function
+	 * 			that creates new objects.
+	 * @details	The function is called if an object was requested with
+	 * 			getSystemObject, but not found in objectList.
+	 * @param 	The id of the object to be created.
+	 * @return	Returns a pointer to the newly created object or NULL.
+	 */
+	void (*produceObjects)();
+public:
+	/**
+	 * @brief	Apart from setting the producer function, nothing special
+	 * 			happens in the constructor.
+	 * @param setProducer	A pointer to a factory function.
+	 */
+	ObjectManager( void (*produce)() );
+	ObjectManager();
+	/**
+	 *	@brief	In the class's destructor, all objects in the list are deleted.
+	 */
+	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	virtual ~ObjectManager( void );
+	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
+	ReturnValue_t remove( object_id_t id );
+	void initialize();
+	void printList();
+};
+
+
+
+#endif /* OBJECTMANAGER_H_ */
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 5dfe8e4e..16619e23 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,95 +1,95 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-
-#include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This class provides an interface to the global object manager.
- * @details	This manager handles a list of available objects with system-wide
- * 			relevance, such as device handlers, and TM/TC services. They can be
- * 			inserted, removed and retrieved from the list. On getting the
- * 			object, the call checks if the object implements the requested
- * 			interface.
- * @author	Bastian Baetz
- * @ingroup system_objects
- */
-class ObjectManagerIF : public HasReturnvaluesIF {
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
-	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
-	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
-	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
-
-protected:
-	/**
-	 * @brief	This method is used to hide the template-based get call from
-	 * 			a specific implementation.
-	 * @details	So, an implementation only has to implement this call.
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing (at
-	 * 			least) the SystemObjectIF, or NULL.
-	 */
-	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
-	 */
-	virtual ~ObjectManagerIF( void ) {};
-	/**
-	 * @brief	With this call, new objects are inserted to the list.
-	 * @details	The implementation shall return an error code in case the
-	 * 			object can't be added (e.g. the id is already in use).
-	 * @param id		The new id to be added to the list.
-	 * @param object	A pointer to the object to be added.
-	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
-	 * 			@li RETURN_OK in case the object was successfully inserted
-	 */
-	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
-	/**
-	 * @brief	With the get call, interfaces of an object can be retrieved in
-	 * 			a type-safe manner.
-	 * @details With the template-based call, the object list is searched with the
-	 * 			getSystemObject method and afterwards it is checked, if the object
-	 * 			implements the requested interface (with a dynamic_cast).
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing the
-	 * 			requested interface, or NULL.
-	 */
-	template <typename T> T* get( object_id_t id );
-	/**
-	 * @brief	With this call, an object is removed from the list.
-	 * @param id	The object id of the object to be removed.
-	 * @return	\li NOT_FOUND in case the object was not found
-	 * 			\li RETURN_OK in case the object was successfully removed
-	 */
-	virtual ReturnValue_t remove( object_id_t id ) = 0;
-	virtual void initialize() = 0;
-	/**
-	 * @brief	This is a debug function, that prints the current content of the
-	 * 			object list.
-	 */
-	virtual void printList() = 0;
-};
-
-
-/**
- * @brief	This is the forward declaration of the global objectManager instance.
- */
-extern ObjectManagerIF *objectManager;
-
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	if(objectManager == nullptr) {
-		sif::error << "ObjectManagerIF: Global object manager has not "
-				"been initialized yet!" << std::endl;
-	}
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
-#endif /* OBJECTMANAGERIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+
+#include "../objectmanager/frameworkObjects.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief	This class provides an interface to the global object manager.
+ * @details	This manager handles a list of available objects with system-wide
+ * 			relevance, such as device handlers, and TM/TC services. They can be
+ * 			inserted, removed and retrieved from the list. On getting the
+ * 			object, the call checks if the object implements the requested
+ * 			interface.
+ * @author	Bastian Baetz
+ * @ingroup system_objects
+ */
+class ObjectManagerIF : public HasReturnvaluesIF {
+public:
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
+	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
+
+protected:
+	/**
+	 * @brief	This method is used to hide the template-based get call from
+	 * 			a specific implementation.
+	 * @details	So, an implementation only has to implement this call.
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing (at
+	 * 			least) the SystemObjectIF, or NULL.
+	 */
+	virtual  SystemObjectIF* getSystemObject( object_id_t id ) = 0;
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as requested by C++ interfaces.
+	 */
+	virtual ~ObjectManagerIF( void ) {};
+	/**
+	 * @brief	With this call, new objects are inserted to the list.
+	 * @details	The implementation shall return an error code in case the
+	 * 			object can't be added (e.g. the id is already in use).
+	 * @param id		The new id to be added to the list.
+	 * @param object	A pointer to the object to be added.
+	 * @return	@li INSERTION_FAILED in case the object could not be inserted.
+	 * 			@li RETURN_OK in case the object was successfully inserted
+	 */
+	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
+	/**
+	 * @brief	With the get call, interfaces of an object can be retrieved in
+	 * 			a type-safe manner.
+	 * @details With the template-based call, the object list is searched with the
+	 * 			getSystemObject method and afterwards it is checked, if the object
+	 * 			implements the requested interface (with a dynamic_cast).
+	 * @param id	The object id of the requested object.
+	 * @return	The method returns a pointer to an object implementing the
+	 * 			requested interface, or NULL.
+	 */
+	template <typename T> T* get( object_id_t id );
+	/**
+	 * @brief	With this call, an object is removed from the list.
+	 * @param id	The object id of the object to be removed.
+	 * @return	\li NOT_FOUND in case the object was not found
+	 * 			\li RETURN_OK in case the object was successfully removed
+	 */
+	virtual ReturnValue_t remove( object_id_t id ) = 0;
+	virtual void initialize() = 0;
+	/**
+	 * @brief	This is a debug function, that prints the current content of the
+	 * 			object list.
+	 */
+	virtual void printList() = 0;
+};
+
+
+/**
+ * @brief	This is the forward declaration of the global objectManager instance.
+ */
+extern ObjectManagerIF *objectManager;
+
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManagerIF::get( object_id_t id ) {
+	if(objectManager == nullptr) {
+		sif::error << "ObjectManagerIF: Global object manager has not "
+				"been initialized yet!" << std::endl;
+	}
+	SystemObjectIF* temp = this->getSystemObject(id);
+	return dynamic_cast<T*>(temp);
+}
+
+#endif /* OBJECTMANAGERIF_H_ */
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index e3eb22ee..61eaf90a 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,37 +1,37 @@
-#include "../events/EventManagerIF.h"
-#include "../objectmanager/ObjectManager.h"
-#include "../objectmanager/SystemObject.h"
-
-SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
-		objectId(setObjectId), registered(doRegister) {
-	if (registered) {
-		objectManager->insert(objectId, this);
-	}
-}
-
-SystemObject::~SystemObject() {
-	if (registered) {
-		objectManager->remove(objectId);
-	}
-}
-
-object_id_t SystemObject::getObjectId() const {
-	return objectId;
-}
-
-void SystemObject::triggerEvent(Event event, uint32_t parameter1,
-		uint32_t parameter2) {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
-
-ReturnValue_t SystemObject::initialize() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SystemObject::checkObjectConnections() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
-	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
-}
+#include "../events/EventManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../objectmanager/SystemObject.h"
+
+SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
+		objectId(setObjectId), registered(doRegister) {
+	if (registered) {
+		objectManager->insert(objectId, this);
+	}
+}
+
+SystemObject::~SystemObject() {
+	if (registered) {
+		objectManager->remove(objectId);
+	}
+}
+
+object_id_t SystemObject::getObjectId() const {
+	return objectId;
+}
+
+void SystemObject::triggerEvent(Event event, uint32_t parameter1,
+		uint32_t parameter2) {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
+
+ReturnValue_t SystemObject::initialize() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SystemObject::checkObjectConnections() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SystemObject::forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const {
+	EventManagerIF::triggerEvent(objectId, event, parameter1, parameter2);
+}
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 54a2e866..108717af 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,62 +1,62 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-
-#include "../events/EventReportingProxyIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstdint>
-/**
- * @defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are
- * contained in this group. System Objects are software elements that can be
- * controlled externally. They all have a unique object identifier.
- */
-
-/**
- * This is the typedef for object identifiers.
- * @ingroup system_objects
- */
-typedef uint32_t object_id_t;
-
-/**
- * This interface allows a class to be included in the object manager
- * list.
- * It does not provide any method definitions, still it is required to
- * perform a type check with dynamic_cast.
- * @author  Bastian Baetz
- * @ingroup system_objects
- */
-class SystemObjectIF : public EventReportingProxyIF {
-public:
-	/**
-	 * This is a simple getter to return the object identifier.
-	 * @return	Returns the object id of this object.
-	 */
-	virtual object_id_t getObjectId() const = 0;
-	/**
-	 * The empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~SystemObjectIF() {}
-	/**
-	 * @brief   Initializes the object.
-	 * There are initialization steps which can also be done in the constructor.
-	 * However, there is no clean way to get a returnvalue from a constructor.
-	 * Furthermore some components require other system object to be created
-	 * which might not have been built yet.
-	 * Therefore, a two-step initialization resolves this problem and prevents
-	 * circular dependencies of not-fully initialized objects on start up.
-	 * @return	- @c RETURN_OK in case the initialization was successful
-	 * 			- @c RETURN_FAILED otherwise
-	 */
-	virtual ReturnValue_t initialize() = 0;
-	/**
-	 * @brief   Checks if all object-object interconnections are satisfying
-	 *          for operation.
-	 * Some objects need certain other objects (or a certain number), to be
-	 * registered as children. These checks can be done in this method.
-	 * @return	- @c RETURN_OK in case the check was successful
-	 * 			- @c any other code otherwise
-	 */
-	virtual ReturnValue_t checkObjectConnections() = 0;
-};
-
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+
+#include "../events/EventReportingProxyIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+/**
+ * @defgroup system_objects Software System Object Management
+ * The classes to create System Objects and classes to manage these are
+ * contained in this group. System Objects are software elements that can be
+ * controlled externally. They all have a unique object identifier.
+ */
+
+/**
+ * This is the typedef for object identifiers.
+ * @ingroup system_objects
+ */
+typedef uint32_t object_id_t;
+
+/**
+ * This interface allows a class to be included in the object manager
+ * list.
+ * It does not provide any method definitions, still it is required to
+ * perform a type check with dynamic_cast.
+ * @author  Bastian Baetz
+ * @ingroup system_objects
+ */
+class SystemObjectIF : public EventReportingProxyIF {
+public:
+	/**
+	 * This is a simple getter to return the object identifier.
+	 * @return	Returns the object id of this object.
+	 */
+	virtual object_id_t getObjectId() const = 0;
+	/**
+	 * The empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~SystemObjectIF() {}
+	/**
+	 * @brief   Initializes the object.
+	 * There are initialization steps which can also be done in the constructor.
+	 * However, there is no clean way to get a returnvalue from a constructor.
+	 * Furthermore some components require other system object to be created
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
+	 */
+	virtual ReturnValue_t initialize() = 0;
+	/**
+	 * @brief   Checks if all object-object interconnections are satisfying
+	 *          for operation.
+	 * Some objects need certain other objects (or a certain number), to be
+	 * registered as children. These checks can be done in this method.
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
+	 */
+	virtual ReturnValue_t checkObjectConnections() = 0;
+};
+
+#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8c831bbe..dd1e48ca 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,95 +1,95 @@
-#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
-	handle = TaskManagement::getCurrentTaskHandle();
-	if(handle == nullptr) {
-		sif::error << "Could not retrieve task handle. Please ensure the"
-				"constructor was called inside a task." << std::endl;
-	}
-	xTaskNotifyGive(handle);
-}
-
-BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
-	// Clear notification value on destruction.
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-    TickType_t timeout = 0;
-    if(timeoutType == TimeoutType::POLLING) {
-        timeout = 0;
-    }
-    else if(timeoutType == TimeoutType::WAITING){
-        timeout = pdMS_TO_TICKS(timeoutMs);
-    }
-    else {
-        timeout = portMAX_DELAY;
-    }
-	return acquireWithTickTimeout(timeoutType, timeout);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
-        TimeoutType timeoutType, TickType_t timeoutTicks) {
-	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release() {
-	return release(this->handle);
-}
-
-ReturnValue_t BinarySemaphoreUsingTask::release(
-		TaskHandle_t taskHandle) {
-	if(getSemaphoreCounter(taskHandle) == 1) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	BaseType_t returncode = xTaskNotifyGive(taskHandle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		// This should never happen.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
-	return getSemaphoreCounter(this->handle);
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
-		TaskHandle_t taskHandle) {
-	uint32_t notificationValue;
-	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-// Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
-		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
-	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
-	uint32_t notificationValue = 0;
-	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
-			higherPriorityTaskWoken);
-	return notificationValue;
-}
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "Could not retrieve task handle. Please ensure the"
+				"constructor was called inside a task." << std::endl;
+	}
+	xTaskNotifyGive(handle);
+}
+
+BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+	return acquireWithTickTimeout(timeoutType, timeout);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::acquireWithTickTimeout(
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
+	BaseType_t returncode = ulTaskNotifyTake(pdTRUE, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release() {
+	return release(this->handle);
+}
+
+ReturnValue_t BinarySemaphoreUsingTask::release(
+		TaskHandle_t taskHandle) {
+	if(getSemaphoreCounter(taskHandle) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	BaseType_t returncode = xTaskNotifyGive(taskHandle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+TaskHandle_t BinarySemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter() const {
+	return getSemaphoreCounter(this->handle);
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounter(
+		TaskHandle_t taskHandle) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQuery(taskHandle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskHandle, BaseType_t * higherPriorityTaskWoken) {
+	if(getSemaphoreCounterFromISR(taskHandle, higherPriorityTaskWoken) == 1) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	vTaskNotifyGiveFromISR(taskHandle, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t taskHandle, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQueryFromISR(taskHandle, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 0b30c094..4317e0b2 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,79 +1,79 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../tasks/SemaphoreIF.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-/**
- * @brief 	Binary Semaphore implementation using the task notification value.
- * 			The notification value should therefore not be used
- * 			for other purposes.
- * @details
- * Additional information: https://www.freertos.org/RTOS-task-notifications.html
- * and general semaphore documentation.
- * This semaphore is bound to the task it is created in!
- * Take care of calling this function with the correct executing task,
- * (for example in the initializeAfterTaskCreation() function).
- */
-class BinarySemaphoreUsingTask: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphoreUsingTask();
-	//! @brief Default dtor
-	virtual~ BinarySemaphoreUsingTask();
-
-	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-	        uint32_t timeoutMs = portMAX_DELAY) override;
-	ReturnValue_t release() override;
-	uint8_t getSemaphoreCounter() const override;
-	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
-			BaseType_t* higherPriorityTaskWoken);
-
-	/**
-	 * Same as acquire() with timeout in FreeRTOS ticks.
-	 * @param timeoutTicks
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t acquireWithTickTimeout(
-	        TimeoutType timeoutType = TimeoutType::BLOCKING,
-	        TickType_t timeoutTicks = portMAX_DELAY);
-
-	/**
-	 * Get handle to the task related to the semaphore.
-	 * @return
-	 */
-	TaskHandle_t getTaskHandle();
-
-	 /**
-	 * Wrapper function to give back semaphore from handle
-	 * @param semaphore
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t release(TaskHandle_t taskToNotify);
-
-	/**
-	 * Wrapper function to give back semaphore from handle when called from an ISR
-	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return - @c RETURN_OK on success
-	 *         - @c RETURN_FAILED on failure
-	 */
-	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
-
-protected:
-	TaskHandle_t handle;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+/**
+ * @brief 	Binary Semaphore implementation using the task notification value.
+ * 			The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ * Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ * and general semaphore documentation.
+ * This semaphore is bound to the task it is created in!
+ * Take care of calling this function with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function).
+ */
+class BinarySemaphoreUsingTask: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphoreUsingTask();
+	//! @brief Default dtor
+	virtual~ BinarySemaphoreUsingTask();
+
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
+	ReturnValue_t release() override;
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t taskHandle,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Same as acquire() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	TaskHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index f1c78473..8cc3c495 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,108 +1,108 @@
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-BinarySemaphore::BinarySemaphore() {
-	handle = xSemaphoreCreateBinary();
-	if(handle == nullptr) {
-		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
-	}
-	// Initiated semaphore must be given before it can be taken.
-	xSemaphoreGive(handle);
-}
-
-BinarySemaphore::~BinarySemaphore() {
-	vSemaphoreDelete(handle);
-}
-
-BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-    handle = xSemaphoreCreateBinary();
-    if(handle == nullptr) {
-        sif::error << "Binary semaphore creation failure" << std::endl;
-    }
-    xSemaphoreGive(handle);
-}
-
-BinarySemaphore& BinarySemaphore::operator =(
-        BinarySemaphore&& s) {
-    if(&s != this) {
-        handle = xSemaphoreCreateBinary();
-        if(handle == nullptr) {
-            sif::error << "Binary semaphore creation failure" << std::endl;
-        }
-        xSemaphoreGive(handle);
-    }
-    return *this;
-}
-
-ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-    TickType_t timeout = 0;
-	if(timeoutType == TimeoutType::POLLING) {
-	    timeout = 0;
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-	    timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-	else {
-	    timeout = portMAX_DELAY;
-	}
-	return acquireWithTickTimeout(timeoutType, timeout);
-}
-
-ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TimeoutType timeoutType,
-        TickType_t timeoutTicks) {
-	if(handle == nullptr) {
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return release(handle);
-}
-
-ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
-	if (semaphore == nullptr) {
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	}
-	BaseType_t returncode = xSemaphoreGive(semaphore);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() const {
-	return uxSemaphoreGetCount(handle);
-}
-
-SemaphoreHandle_t BinarySemaphore::getSemaphore() {
-	return handle;
-}
-
-
-// Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::releaseFromISR(
-		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
-	if (semaphore == nullptr) {
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	}
-	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
-			higherPriorityTaskWoken);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-}
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+BinarySemaphore::BinarySemaphore() {
+	handle = xSemaphoreCreateBinary();
+	if(handle == nullptr) {
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
+	}
+	// Initiated semaphore must be given before it can be taken.
+	xSemaphoreGive(handle);
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	vSemaphoreDelete(handle);
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+    handle = xSemaphoreCreateBinary();
+    if(handle == nullptr) {
+        sif::error << "Binary semaphore creation failure" << std::endl;
+    }
+    xSemaphoreGive(handle);
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+    if(&s != this) {
+        handle = xSemaphoreCreateBinary();
+        if(handle == nullptr) {
+            sif::error << "Binary semaphore creation failure" << std::endl;
+        }
+        xSemaphoreGive(handle);
+    }
+    return *this;
+}
+
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+	    timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+	    timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+	else {
+	    timeout = portMAX_DELAY;
+	}
+	return acquireWithTickTimeout(timeoutType, timeout);
+}
+
+ReturnValue_t BinarySemaphore::acquireWithTickTimeout(TimeoutType timeoutType,
+        TickType_t timeoutTicks) {
+	if(handle == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeoutTicks);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return release(handle);
+}
+
+ReturnValue_t BinarySemaphore::release(SemaphoreHandle_t semaphore) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+	BaseType_t returncode = xSemaphoreGive(semaphore);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
+	return uxSemaphoreGetCount(handle);
+}
+
+SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+	return handle;
+}
+
+
+// Be careful with the stack size here. This is called from an ISR!
+ReturnValue_t BinarySemaphore::releaseFromISR(
+		SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) {
+	if (semaphore == nullptr) {
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	}
+	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore,
+			higherPriorityTaskWoken);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+}
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 5a32088a..c6cedc53 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,107 +1,107 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../tasks/SemaphoreIF.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @brief 	OS Tool to achieve synchronization of between tasks or between
- * 			task and ISR. The default semaphore implementation creates a
- * 			binary semaphore, which can only be taken once.
- * @details
- * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
- *
- * Please note that if the semaphore implementation is only related to
- * the synchronization of one task, the new task notifications can be used,
- * also see the BinSemaphUsingTask and CountingSemaphUsingTask classes.
- * These use the task notification value instead of a queue and are
- * faster and more efficient.
- *
- * @author 	R. Mueller
- * @ingroup osal
- */
-class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphore();
-	//! @brief Copy ctor, deleted explicitely.
-	BinarySemaphore(const BinarySemaphore&) = delete;
-	//! @brief Copy assignment, deleted explicitely.
-	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
-	//! @brief Move ctor
-	BinarySemaphore (BinarySemaphore &&);
-	//! @brief Move assignment
-	BinarySemaphore & operator=(BinarySemaphore &&);
-	//! @brief Destructor
-	virtual ~BinarySemaphore();
-
-	uint8_t getSemaphoreCounter() const override;
-
-	/**
-	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked
-	 * for a maximum of #timeoutMs or until the semaphore is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquire(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = portMAX_DELAY) override;
-
-	/**
-	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
-	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t  acquireWithTickTimeout(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, TickType_t timeoutTicks = portMAX_DELAY);
-
-	/**
-	 * Release the binary semaphore.
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
-	 *         	already available.
-	 */
-	ReturnValue_t release() override;
-
-	/**
-	 * Get Handle to the semaphore.
-	 * @return
-	 */
-	SemaphoreHandle_t getSemaphore();
-
-	 /**
-	 * Wrapper function to give back semaphore from handle
-	 * @param semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
-	 *         	already available.
-	 */
-	static ReturnValue_t release(SemaphoreHandle_t semaphore);
-
-	/**
-	 * Wrapper function to give back semaphore from handle when called from an ISR
-	 * @param semaphore
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch from an ISR should
-	 * then be requested (see TaskManagement functions)
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
-	 *         	already available.
-	 */
-	static ReturnValue_t releaseFromISR(SemaphoreHandle_t semaphore,
-				BaseType_t * higherPriorityTaskWoken);
-
-protected:
-	SemaphoreHandle_t handle;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
+ * @details
+ * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
+ *
+ * Please note that if the semaphore implementation is only related to
+ * the synchronization of one task, the new task notifications can be used,
+ * also see the BinSemaphUsingTask and CountingSemaphUsingTask classes.
+ * These use the task notification value instead of a queue and are
+ * faster and more efficient.
+ *
+ * @author 	R. Mueller
+ * @ingroup osal
+ */
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
+	//! @brief Move ctor
+	BinarySemaphore (BinarySemaphore &&);
+	//! @brief Move assignment
+	BinarySemaphore & operator=(BinarySemaphore &&);
+	//! @brief Destructor
+	virtual ~BinarySemaphore();
+
+	uint8_t getSemaphoreCounter() const override;
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = portMAX_DELAY) override;
+
+	/**
+	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t  acquireWithTickTimeout(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	/**
+	 * Get Handle to the semaphore.
+	 * @return
+	 */
+	SemaphoreHandle_t getSemaphore();
+
+	 /**
+	 * Wrapper function to give back semaphore from handle
+	 * @param semaphore
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	static ReturnValue_t release(SemaphoreHandle_t semaphore);
+
+	/**
+	 * Wrapper function to give back semaphore from handle when called from an ISR
+	 * @param semaphore
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch from an ISR should
+	 * then be requested (see TaskManagement functions)
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	static ReturnValue_t releaseFromISR(SemaphoreHandle_t semaphore,
+				BaseType_t * higherPriorityTaskWoken);
+
+protected:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 48d7bc07..d556444c 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,196 +1,196 @@
-#include "../../timemanager/Clock.h"
-#include "../../globalfunctions/timevalOperations.h"
-#include "../../osal/FreeRTOS/Timekeeper.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <stdlib.h>
-#include <time.h>
-
-//TODO sanitize input?
-//TODO much of this code can be reused for tick-only systems
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
-uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-
-	timeval time_timeval;
-
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-
-	return setClock(&time_timeval);
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = *time - uptime;
-
-	Timekeeper::instance()->setOffset(offset);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
-
-	timeval offset = Timekeeper::instance()->getOffset();
-
-	*time = offset + uptime;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
-
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
-
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
-
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
-
-	time->usecond = time_timeval.tv_usec;
-
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
-
-		time_tm.tm_year = from->year - 1900;
-		time_tm.tm_mon = from->month - 1;
-		time_tm.tm_mday = from->day;
-
-		time_tm.tm_hour = from->hour;
-		time_tm.tm_min = from->minute;
-		time_tm.tm_sec = from->second;
-
-		time_t seconds = mktime(&time_tm);
-
-		to->tv_sec = seconds;
-		to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex() {
-	if (timeMutex == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "../../globalfunctions/timevalOperations.h"
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include <stdlib.h>
+#include <time.h>
+
+//TODO sanitize input?
+//TODO much of this code can be reused for tick-only systems
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+
+uint32_t Clock::getTicksPerSecond(void) {
+	return 1000;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+
+	timeval time_timeval;
+
+	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+
+	return setClock(&time_timeval);
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = *time - uptime;
+
+	Timekeeper::instance()->setOffset(offset);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timeval uptime = getUptime();
+
+	timeval offset = Timekeeper::instance()->getOffset();
+
+	*time = offset + uptime;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	TickType_t ticksSinceStart = xTaskGetTickCount();
+	return Timekeeper::ticksToTimeval(ticksSinceStart);
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timeval time_timeval;
+	ReturnValue_t result = getClock_timeval(&time_timeval);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	struct tm time_tm;
+
+	gmtime_r(&time_timeval.tv_sec,&time_tm);
+
+	time->year = time_tm.tm_year + 1900;
+	time->month = time_tm.tm_mon + 1;
+	time->day = time_tm.tm_mday;
+
+	time->hour = time_tm.tm_hour;
+	time->minute = time_tm.tm_min;
+	time->second = time_tm.tm_sec;
+
+	time->usecond = time_timeval.tv_usec;
+
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+		time_tm.tm_year = from->year - 1900;
+		time_tm.tm_mon = from->month - 1;
+		time_tm.tm_mday = from->day;
+
+		time_tm.tm_hour = from->hour;
+		time_tm.tm_min = from->minute;
+		time_tm.tm_sec = from->second;
+
+		time_t seconds = mktime(&time_tm);
+
+		to->tv_sec = seconds;
+		to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex() {
+	if (timeMutex == NULL) {
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index e66671ac..a47341bc 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,114 +1,114 @@
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
-		uint8_t initCount): maxCount(maxCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	handle = TaskManagement::getCurrentTaskHandle();
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
-				"handle. Please ensure the constructor was called inside a "
-				"task." << std::endl;
-	}
-
-	uint32_t oldNotificationValue;
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
-			&oldNotificationValue);
-	if(oldNotificationValue != 0) {
-		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
-				"current notification value is not 0. Please ensure the "
-				"notification value is not used for other purposes!" << std::endl;
-	}
-	for(int i = 0; i < initCount; i++) {
-		xTaskNotifyGive(handle);
-	}
-}
-
-CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
-	// Clear notification value on destruction.
-	// If this is not desired, don't call the destructor
-	// (or implement a boolean which disables the reset)
-	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::acquire(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-    TickType_t timeout = 0;
-    if(timeoutType == TimeoutType::POLLING) {
-        timeout = 0;
-    }
-    else if(timeoutType == TimeoutType::WAITING){
-        timeout = pdMS_TO_TICKS(timeoutMs);
-    }
-    else {
-        timeout = portMAX_DELAY;
-    }
-    return acquireWithTickTimeout(timeoutType, timeout);
-
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
-        TimeoutType timeoutType, TickType_t timeoutTicks) {
-	// Decrement notfication value without resetting it.
-	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
-	if (getSemaphoreCounter() == oldCount - 1) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	}
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::release() {
-	if(getSemaphoreCounter() == maxCount) {
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	return release(handle);
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::release(
-		TaskHandle_t taskToNotify) {
-	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		// This should never happen.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
-	uint32_t notificationValue = 0;
-	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
-	return notificationValue;
-}
-
-TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
-	return handle;
-}
-
-ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
-		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
-	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
-		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
-	uint32_t notificationValue;
-	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
-			higherPriorityTaskWoken);
-	return notificationValue;
-}
-
-uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
-	return maxCount;
-}
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
+		uint8_t initCount): maxCount(maxCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = TaskManagement::getCurrentTaskHandle();
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
+				"handle. Please ensure the constructor was called inside a "
+				"task." << std::endl;
+	}
+
+	uint32_t oldNotificationValue;
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
+			&oldNotificationValue);
+	if(oldNotificationValue != 0) {
+		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
+				"current notification value is not 0. Please ensure the "
+				"notification value is not used for other purposes!" << std::endl;
+	}
+	for(int i = 0; i < initCount; i++) {
+		xTaskNotifyGive(handle);
+	}
+}
+
+CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
+	// Clear notification value on destruction.
+	// If this is not desired, don't call the destructor
+	// (or implement a boolean which disables the reset)
+	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquire(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    TickType_t timeout = 0;
+    if(timeoutType == TimeoutType::POLLING) {
+        timeout = 0;
+    }
+    else if(timeoutType == TimeoutType::WAITING){
+        timeout = pdMS_TO_TICKS(timeoutMs);
+    }
+    else {
+        timeout = portMAX_DELAY;
+    }
+    return acquireWithTickTimeout(timeoutType, timeout);
+
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::acquireWithTickTimeout(
+        TimeoutType timeoutType, TickType_t timeoutTicks) {
+	// Decrement notfication value without resetting it.
+	BaseType_t oldCount = ulTaskNotifyTake(pdFALSE, timeoutTicks);
+	if (getSemaphoreCounter() == oldCount - 1) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	}
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release() {
+	if(getSemaphoreCounter() == maxCount) {
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return release(handle);
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::release(
+		TaskHandle_t taskToNotify) {
+	BaseType_t returncode = xTaskNotifyGive(taskToNotify);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		// This should never happen.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounter() const {
+	uint32_t notificationValue = 0;
+	xTaskNotifyAndQuery(handle, 0, eNoAction, &notificationValue);
+	return notificationValue;
+}
+
+TaskHandle_t CountingSemaphoreUsingTask::getTaskHandle() {
+	return handle;
+}
+
+ReturnValue_t CountingSemaphoreUsingTask::releaseFromISR(
+		TaskHandle_t taskToNotify, BaseType_t* higherPriorityTaskWoken) {
+	vTaskNotifyGiveFromISR(taskToNotify, higherPriorityTaskWoken);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
+		TaskHandle_t task, BaseType_t* higherPriorityTaskWoken) {
+	uint32_t notificationValue;
+	xTaskNotifyAndQueryFromISR(task, 0, eNoAction, &notificationValue,
+			higherPriorityTaskWoken);
+	return notificationValue;
+}
+
+uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index d3b23ebe..49ff3ee5 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,105 +1,105 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../tasks/SemaphoreIF.h"
-
-extern "C" {
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-}
-
-/**
- * @brief 	Couting Semaphore implementation which uses the notification value
- * 			of the task. The notification value should therefore not be used
- * 			for other purposes.
- * @details
- *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
- *  and general semaphore documentation.
- *  This semaphore is bound to the task it is created in!
- *  Take care of calling this function with the correct executing task,
- *  (for example in the initializeAfterTaskCreation() function).
- */
-class CountingSemaphoreUsingTask: public SemaphoreIF {
-public:
-	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
-	virtual ~CountingSemaphoreUsingTask();
-
-	/**
-	 * Acquire the counting semaphore.
-	 * If no semaphores are available, the task will be blocked
-	 * for a maximum of #timeoutMs or until one is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-	        uint32_t timeoutMs = portMAX_DELAY) override;
-
-	/**
-	 * Release a semaphore, increasing the number of available counting
-	 * semaphores up to the #maxCount value.
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	ReturnValue_t release() override;
-
-	uint8_t getSemaphoreCounter() const override;
-	/**
-	 * Get the semaphore counter from an ISR.
-	 * @param task
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return
-	 */
-	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
-			BaseType_t* higherPriorityTaskWoken);
-
-	/**
-	 * Acquire with a timeout value in ticks
-	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquireWithTickTimeout(
-	        TimeoutType timeoutType = TimeoutType::BLOCKING,
-			TickType_t timeoutTicks = portMAX_DELAY);
-
-	/**
-	 * Get handle to the task related to the semaphore.
-	 * @return
-	 */
-	TaskHandle_t getTaskHandle();
-
-	/**
-	 * Release semaphore of task by supplying task handle
-	 * @param taskToNotify
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	static ReturnValue_t release(TaskHandle_t taskToNotify);
-	/**
-	 * Release seamphore of a task from an ISR.
-	 * @param taskToNotify
-	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
-	 * a higher priority was unblocked. A context switch should be requested
-	 * from an ISR if this is the case (see TaskManagement functions)
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
-	 *         	already available.
-	 */
-	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-			BaseType_t* higherPriorityTaskWoken);
-
-	uint8_t getMaxCount() const;
-
-private:
-	TaskHandle_t handle;
-	const uint8_t maxCount;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreIF.h"
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+
+/**
+ * @brief 	Couting Semaphore implementation which uses the notification value
+ * 			of the task. The notification value should therefore not be used
+ * 			for other purposes.
+ * @details
+ *  Additional information: https://www.freertos.org/RTOS-task-notifications.html
+ *  and general semaphore documentation.
+ *  This semaphore is bound to the task it is created in!
+ *  Take care of calling this function with the correct executing task,
+ *  (for example in the initializeAfterTaskCreation() function).
+ */
+class CountingSemaphoreUsingTask: public SemaphoreIF {
+public:
+	CountingSemaphoreUsingTask(const uint8_t maxCount, uint8_t initCount);
+	virtual ~CountingSemaphoreUsingTask();
+
+	/**
+	 * Acquire the counting semaphore.
+	 * If no semaphores are available, the task will be blocked
+	 * for a maximum of #timeoutMs or until one is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+	        uint32_t timeoutMs = portMAX_DELAY) override;
+
+	/**
+	 * Release a semaphore, increasing the number of available counting
+	 * semaphores up to the #maxCount value.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	ReturnValue_t release() override;
+
+	uint8_t getSemaphoreCounter() const override;
+	/**
+	 * Get the semaphore counter from an ISR.
+	 * @param task
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return
+	 */
+	static uint8_t getSemaphoreCounterFromISR(TaskHandle_t task,
+			BaseType_t* higherPriorityTaskWoken);
+
+	/**
+	 * Acquire with a timeout value in ticks
+	 * @param timeoutTicks
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquireWithTickTimeout(
+	        TimeoutType timeoutType = TimeoutType::BLOCKING,
+			TickType_t timeoutTicks = portMAX_DELAY);
+
+	/**
+	 * Get handle to the task related to the semaphore.
+	 * @return
+	 */
+	TaskHandle_t getTaskHandle();
+
+	/**
+	 * Release semaphore of task by supplying task handle
+	 * @param taskToNotify
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t release(TaskHandle_t taskToNotify);
+	/**
+	 * Release seamphore of a task from an ISR.
+	 * @param taskToNotify
+	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with
+	 * a higher priority was unblocked. A context switch should be requested
+	 * from an ISR if this is the case (see TaskManagement functions)
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if #maxCount semaphores are
+	 *         	already available.
+	 */
+	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
+			BaseType_t* higherPriorityTaskWoken);
+
+	uint8_t getMaxCount() const;
+
+private:
+	TaskHandle_t handle;
+	const uint8_t maxCount;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 0b218e54..d1310a6a 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,43 +1,43 @@
-#include "../../osal/FreeRTOS/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-
-#include <freertos/semphr.h>
-
-// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
-// free FreeRTOSConfig.h file.
-CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
-		maxCount(maxCount), initCount(initCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	handle = xSemaphoreCreateCounting(maxCount, initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-}
-
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
-		maxCount(other.maxCount), initCount(other.initCount) {
-	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-}
-
-CountingSemaphore& CountingSemaphore::operator =(
-		CountingSemaphore&& other) {
-	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
-	if(handle == nullptr) {
-		sif::error << "CountingSemaphore: Creation failure" << std::endl;
-	}
-	return * this;
-}
-
-
-uint8_t CountingSemaphore::getMaxCount() const {
-	return maxCount;
-}
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/semphr.h>
+
+// Make sure #define configUSE_COUNTING_SEMAPHORES 1 is set in
+// free FreeRTOSConfig.h file.
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	handle = xSemaphoreCreateCounting(maxCount, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}
+
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index 9432ed81..ae2f62ae 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,34 +1,34 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-
-/**
- * @brief 	Counting semaphores, which can be acquire more than once.
- * @details
- * See: https://www.freertos.org/CreateCounting.html
- * API of counting semaphores is almost identical to binary semaphores,
- * so we just inherit from binary semaphore and provide the respective
- * constructors.
- */
-class CountingSemaphore: public BinarySemaphore {
-public:
-	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
-	//! @brief Copy ctor, disabled
-	CountingSemaphore(const CountingSemaphore&) = delete;
-	//! @brief Copy assignment, disabled
-	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
-	//! @brief Move ctor
-	CountingSemaphore (CountingSemaphore &&);
-	//! @brief Move assignment
-	CountingSemaphore & operator=(CountingSemaphore &&);
-
-	/* Same API as binary semaphore otherwise. acquire() can be called
-	 * until there are not semaphores left and release() can be called
-	 * until maxCount is reached. */
-	uint8_t getMaxCount() const;
-private:
-	const uint8_t maxCount;
-	uint8_t initCount = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquire more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 772c4bca..404c3c05 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,166 +1,166 @@
-#include "FixedTimeslotTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
-
-FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod overallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), handle(nullptr), pst(overallPeriod * 1000) {
-	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
-	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-
-	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
-    // global, so it is found from any place.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	/* Task should not start until explicitly requested,
-	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
-	 * is running but not if the scheduler is not running.
-	 * To be able to accommodate both cases we check a member which is set in
-	 * #startTask(). If it is not set and we get here, the scheduler was started
-	 * before #startTask() was called and we need to suspend if it is set,
-	 * the scheduler was not running before #startTask() was called and we
-	 * can continue */
-
-	if (not originalTask->started) {
-		vTaskSuspend(NULL);
-	}
-
-	originalTask->taskFunctionality();
-	sif::debug << "Polling task " << originalTask->handle
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-
-	// We must not call resume if scheduler is not started yet
-	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-		vTaskResume(handle);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-    ExecutableObjectIF* handler =
-            objectManager->get<ExecutableObjectIF>(componentId);
-	if (handler != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the
-    // start time for the first entry.
-	auto slotListIter = pst.current;
-
-	pst.intializeSequenceAfterTaskCreation();
-
-	//The start time for the first entry is read.
-	uint32_t intervalMs = slotListIter->pollingTimeMs;
-	TickType_t interval = pdMS_TO_TICKS(intervalMs);
-
-	TickType_t xLastWakeTime;
-	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to
-	 explicitly. After this assignment, xLastWakeTime is updated automatically
-	 internally within vTaskDelayUntil(). */
-	xLastWakeTime = xTaskGetTickCount();
-
-	// wait for first entry's start time
-	if(interval > 0) {
-	    vTaskDelayUntil(&xLastWakeTime, interval);
-	}
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		//The component for this slot is executed and the next one is chosen.
-	    this->pst.executeAndAdvance();
-	    if (not pst.slotFollowsImmediately()) {
-	        // Get the interval till execution of the next slot.
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
-
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
-	    }
-	}
-}
-
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
-void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
-    if(deadlineMissedFunc != nullptr) {
-        this->deadlineMissedFunc();
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	vTaskDelay(pdMS_TO_TICKS(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskHandle_t FixedTimeslotTask::getTaskHandle() {
-    return handle;
-}
+#include "FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
+
+FixedTimeslotTask::FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod overallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), handle(nullptr), pst(overallPeriod * 1000) {
+	configSTACK_DEPTH_TYPE stackSize = setStack / sizeof(configSTACK_DEPTH_TYPE);
+	xTaskCreate(taskEntryPoint, name, stackSize, this, setPriority, &handle);
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
+
+	if (not originalTask->started) {
+		vTaskSuspend(NULL);
+	}
+
+	originalTask->taskFunctionality();
+	sif::debug << "Polling task " << originalTask->handle
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+
+	// We must not call resume if scheduler is not started yet
+	if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+		vTaskResume(handle);
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+    ExecutableObjectIF* handler =
+            objectManager->get<ExecutableObjectIF>(componentId);
+	if (handler != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	auto slotListIter = pst.current;
+
+	pst.intializeSequenceAfterTaskCreation();
+
+	//The start time for the first entry is read.
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
+	TickType_t interval = pdMS_TO_TICKS(intervalMs);
+
+	TickType_t xLastWakeTime;
+	/* The xLastWakeTime variable needs to be initialized with the current tick
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
+	xLastWakeTime = xTaskGetTickCount();
+
+	// wait for first entry's start time
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		//The component for this slot is executed and the next one is chosen.
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
+	        checkMissedDeadline(xLastWakeTime, interval);
+
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
+	}
+}
+
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Time to wake has not overflown.
+    if(timeToWake > xLastWakeTime) {
+        /* If the current time has overflown exclusively or the current
+         * tick count is simply larger than the time to wake, a deadline was
+         * missed */
+        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
+            handleMissedDeadline();
+        }
+    }
+    /* Time to wake has overflown. A deadline was missed if the current time
+     * is larger than the time to wake */
+    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	vTaskDelay(pdMS_TO_TICKS(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskHandle_t FixedTimeslotTask::getTaskHandle() {
+    return handle;
+}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 42af14b8..c46de5b7 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,101 +1,101 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
-public:
-
-	/**
-	 * Keep in mind that you need to call before vTaskStartScheduler()!
-	 * A lot of task parameters are set in "FreeRTOSConfig.h".
-	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
-	 * @param setPriority Number of priorities specified by
-	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
-	 * @param setStack	Stack size in words (not bytes!).
-	 * Lower limit specified by configMINIMAL_STACK_SIZE
-	 * @param overallPeriod		Period in seconds.
-	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
-	 * @return Pointer to the newly created task.
-	 */
-	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
-			TaskStackSize setStack, TaskPeriod overallPeriod,
-			void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 * @details
-	 * The destructor frees all heap memory that was allocated on thread
-	 * initialization for the PST and the device handlers. This is done by
-	 * calling the PST's destructor.
-	 */
-	virtual ~FixedTimeslotTask(void);
-
-	ReturnValue_t startTask(void);
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines
-	 * every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t checkSequence() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-	TaskHandle_t getTaskHandle() override;
-
-protected:
-	bool started;
-	TaskHandle_t handle;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when
-	 *          a deadline was missed.
-	 * @details
-	 * Another function may be announced to determine the actions to perform
-	 * when a deadline was missed. Currently, only one function for missing
-	 * any deadline is allowed. If not used, it shall be declared NULL.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the entry point for a new task.
-	 * @details
-	 * This method starts the task by calling taskFunctionality(), as soon as
-	 * all requirements (task scheduler has started and startTask()
-	 * has been called) are met.
-	 */
-	static void taskEntryPoint(void* argument);
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Core function holding the main functionality of the task
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	void taskFunctionality(void);
-
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
-	void handleMissedDeadline();
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+
+#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public FreeRTOSTaskIF {
+public:
+
+	/**
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
+	 */
+	FixedTimeslotTask(TaskName name, TaskPriority setPriority,
+			TaskStackSize setStack, TaskPeriod overallPeriod,
+			void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
+	 */
+	virtual ~FixedTimeslotTask(void);
+
+	ReturnValue_t startTask(void);
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t checkSequence() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+	TaskHandle_t getTaskHandle() override;
+
+protected:
+	bool started;
+	TaskHandle_t handle;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
+	 */
+	static void taskEntryPoint(void* argument);
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index 11986751..e953ec34 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,149 +1,149 @@
-#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
-#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessageIF.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-
-// TODO: this class assumes that MessageQueueId_t is the same size as void*
-// (the FreeRTOS handle type), compiler will catch this but it might be nice
-// to have something checking or even an always working solution
-// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
-
-/**
- * @brief		This class manages sending and receiving of
- * 				message queue messages.
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- * For creating the queue, as well as sending and receiving messages, the class
- * makes use of the operating system calls provided.
- *
- * Please keep in mind that FreeRTOS offers different calls for message queue
- * operations if called from an ISR.
- * For now, the system context needs to be switched manually.
- * @ingroup osal
- * @ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details
-	 * By making use of the according operating system call, a message queue
-	 * is created and initialized. The message depth - the maximum number of
-	 * messages to be buffered - may be set with the help of a parameter,
-	 * whereas the message size is automatically set to the maximum message
-	 * queue message size. The operating system sets the message queue id, or
-	 * in case of failure, it is set to zero.
-	 * @param message_depth
-	 * The number of messages to be buffered before passing an error to the
-	 * sender. Default is three.
-	 * @param max_message_size
-	 * With this parameter, the maximum message size can be adjusted.
-	 * This should be left default.
-	 */
-	MessageQueue( size_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-
-	/** Copying message queues forbidden */
-	MessageQueue(const MessageQueue&) = delete;
-	MessageQueue& operator=(const MessageQueue&) = delete;
-
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided
-	 * 			by the operating system.
-	 */
-	virtual ~MessageQueue();
-
-	/**
-	 * This function is used to switch the call context. This has to be called
-	 * if a message is sent or received from an ISR!
-	 * @param callContext
-	 */
-	void switchSystemContext(CallContext callContext);
-
-	/** MessageQueueIF implementation */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) override;
-
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-
-	ReturnValue_t flush(uint32_t* count) override;
-
-	MessageQueueId_t getLastPartner() const override;
-
-	MessageQueueId_t getId() const override;
-
-	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-
-	MessageQueueId_t getDefaultDestination() const override;
-
-	bool isDefaultDestinationSet() const override;
-
-protected:
-	/**
-	 * @brief 	Implementation to be called from any send Call within
-	 * 			MessageQueue and MessageQueueSenderIF.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 * The OS's return value is returned.
-	 * @param sendTo
-	 * This parameter specifies the message queue id to send the message to.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id into
-	 * the message. This variable is set to zero by default.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter  is not incremented
-	 * if queue is full.
-	 * @param context Specify whether call is made from task or from an ISR.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
-
-	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	bool defaultDestinationSet = false;
-	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-	const size_t maxMessageSize;
-	//! Stores the current system context
-	CallContext callContext =  CallContext::TASK;
-};
-
-#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */
+#ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+// TODO: this class assumes that MessageQueueId_t is the same size as void*
+// (the FreeRTOS handle type), compiler will catch this but it might be nice
+// to have something checking or even an always working solution
+// https://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue
+	 * is created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue( size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * This function is used to switch the call context. This has to be called
+	 * if a message is sent or received from an ISR!
+	 * @param callContext
+	 */
+	void switchSystemContext(CallContext callContext);
+
+	/** MessageQueueIF implementation */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+	virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+
+	ReturnValue_t flush(uint32_t* count) override;
+
+	MessageQueueId_t getLastPartner() const override;
+
+	MessageQueueId_t getId() const override;
+
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false, CallContext callContext = CallContext::TASK);
+
+	static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	bool defaultDestinationSet = false;
+	QueueHandle_t handle;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+	const size_t maxMessageSize;
+	//! Stores the current system context
+	CallContext callContext =  CallContext::TASK;
+};
+
+#endif /* FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_ */
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 8d2e43b8..82f23ff9 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,51 +1,51 @@
-#include "../../osal/FreeRTOS/Mutex.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-Mutex::Mutex() {
-	handle = xSemaphoreCreateMutex();
-	if(handle == nullptr) {
-		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	if (handle != nullptr) {
-		vSemaphoreDelete(handle);
-	}
-
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
-        uint32_t timeoutMs) {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	// If the timeout type is BLOCKING, this will be the correct value.
-	uint32_t timeout = portMAX_DELAY;
-	if(timeoutType == TimeoutType::POLLING) {
-		timeout = 0;
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-		timeout = pdMS_TO_TICKS(timeoutMs);
-	}
-
-	BaseType_t returncode = xSemaphoreTake(handle, timeout);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::MUTEX_TIMEOUT;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if (handle == nullptr) {
-		return MutexIF::MUTEX_NOT_FOUND;
-	}
-	BaseType_t returncode = xSemaphoreGive(handle);
-	if (returncode == pdPASS) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-}
+#include "../../osal/FreeRTOS/Mutex.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+Mutex::Mutex() {
+	handle = xSemaphoreCreateMutex();
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	if (handle != nullptr) {
+		vSemaphoreDelete(handle);
+	}
+
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timeout = pdMS_TO_TICKS(timeoutMs);
+	}
+
+	BaseType_t returncode = xSemaphoreTake(handle, timeout);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::MUTEX_TIMEOUT;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
+	}
+	BaseType_t returncode = xSemaphoreGive(handle);
+	if (returncode == pdPASS) {
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+}
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 5cbc6a72..156d431c 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,29 +1,29 @@
-#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
-#define FRAMEWORK_FREERTOS_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @brief OS component to implement MUTual EXclusion
- *
- * @details
- * Mutexes are binary semaphores which include a priority inheritance mechanism.
- * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
- * @ingroup osal
- */
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(TimeoutType timeoutType,
-	        uint32_t timeoutMs) override;
-	ReturnValue_t unlockMutex() override;
-
-private:
-	SemaphoreHandle_t handle;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
+private:
+	SemaphoreHandle_t handle;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index 9dcd8536..1f34cc18 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/FreeRTOS/Mutex.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory.
-//What's better and why? -> one is on heap the other on bss/data
-//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = nullptr;
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new MutexFactory();
-	}
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/FreeRTOS/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 05091733..cd99afd9 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,36 +1,36 @@
-#include "../../ipc/QueueFactory.h"
-
-#include "../../osal/FreeRTOS/MessageQueue.h"
-
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+
+#include "../../osal/FreeRTOS/MessageQueue.h"
+
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 8575cf4a..beb0d096 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -1,59 +1,59 @@
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/CountingSemaphore.h"
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-
-static const uint32_t USE_REGULAR_SEMAPHORES = 0;
-static const uint32_t USE_TASK_NOTIFICATIONS = 1;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new BinarySemaphore();
-	}
-	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new BinarySemaphoreUsingTask();
-	}
-	else {
-		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
-				"binary semaphore" << std::endl;
-		return new BinarySemaphore();
-	}
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
-		uint8_t initCount, uint32_t argument) {
-	if(argument == USE_REGULAR_SEMAPHORES) {
-		return new CountingSemaphore(maxCount, initCount);
-	}
-	else if(argument == USE_TASK_NOTIFICATIONS) {
-		return new CountingSemaphoreUsingTask(maxCount, initCount);
-	}
-	else {
-		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
-						"binary semaphore" << std::endl;
-		return new CountingSemaphore(maxCount, initCount);
-	}
-
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../osal/FreeRTOS/BinarySemaphore.h"
+#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
+#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+static const uint32_t USE_REGULAR_SEMAPHORES = 0;
+static const uint32_t USE_TASK_NOTIFICATIONS = 1;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new BinarySemaphore();
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new BinarySemaphoreUsingTask();
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+				"binary semaphore" << std::endl;
+		return new BinarySemaphore();
+	}
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
+		uint8_t initCount, uint32_t argument) {
+	if(argument == USE_REGULAR_SEMAPHORES) {
+		return new CountingSemaphore(maxCount, initCount);
+	}
+	else if(argument == USE_TASK_NOTIFICATIONS) {
+		return new CountingSemaphoreUsingTask(maxCount, initCount);
+	}
+	else {
+		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
+						"binary semaphore" << std::endl;
+		return new CountingSemaphore(maxCount, initCount);
+	}
+
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp
index b68b05b3..3ac5cb49 100644
--- a/osal/FreeRTOS/TaskFactory.cpp
+++ b/osal/FreeRTOS/TaskFactory.cpp
@@ -1,53 +1,53 @@
-#include "../../tasks/TaskFactory.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include "PeriodicTask.h"
-#include "FixedTimeslotTask.h"
-
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
-			stackSize_, period_, deadLineMissedFunction_));
-}
-
-/**
- * Keep in Mind that you need to call before this vTaskStartScheduler()!
- */
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_, TaskStackSize stackSize_,
-		TaskPeriod period_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
-			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	if (task == nullptr) {
-		//delete self
-		vTaskDelete(nullptr);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		//TODO not implemented
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
-	vTaskDelay(pdMS_TO_TICKS(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+#include "PeriodicTask.h"
+#include "FixedTimeslotTask.h"
+
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<PeriodicTaskIF*>(new PeriodicTask(name_, taskPriority_,
+			stackSize_, period_, deadLineMissedFunction_));
+}
+
+/**
+ * Keep in Mind that you need to call before this vTaskStartScheduler()!
+ */
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_, TaskStackSize stackSize_,
+		TaskPeriod period_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return dynamic_cast<FixedTimeslotTaskIF*>(new FixedTimeslotTask(name_,
+			taskPriority_,stackSize_, period_, deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	if (task == nullptr) {
+		//delete self
+		vTaskDelete(nullptr);
+		return HasReturnvaluesIF::RETURN_OK;
+	} else {
+		//TODO not implemented
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs) {
+	vTaskDelay(pdMS_TO_TICKS(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 16682d36..b77f12a9 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,24 +1,24 @@
-#include "../../osal/FreeRTOS/TaskManagement.h"
-
-void TaskManagement::vRequestContextSwitchFromTask() {
-	vTaskDelay(0);
-}
-
-void TaskManagement::requestContextSwitch(
-		CallContext callContext = CallContext::TASK) {
-	if(callContext == CallContext::ISR) {
-		// This function depends on the partmacro.h definition for the specific device
-		vRequestContextSwitchFromISR();
-	} else {
-		vRequestContextSwitchFromTask();
-	}
-}
-
-TaskHandle_t TaskManagement::getCurrentTaskHandle() {
-	return xTaskGetCurrentTaskHandle();
-}
-
-size_t TaskManagement::getTaskStackHighWatermark(
-        TaskHandle_t task) {
-	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
-}
+#include "../../osal/FreeRTOS/TaskManagement.h"
+
+void TaskManagement::vRequestContextSwitchFromTask() {
+	vTaskDelay(0);
+}
+
+void TaskManagement::requestContextSwitch(
+		CallContext callContext = CallContext::TASK) {
+	if(callContext == CallContext::ISR) {
+		// This function depends on the partmacro.h definition for the specific device
+		vRequestContextSwitchFromISR();
+	} else {
+		vRequestContextSwitchFromTask();
+	}
+}
+
+TaskHandle_t TaskManagement::getCurrentTaskHandle() {
+	return xTaskGetCurrentTaskHandle();
+}
+
+size_t TaskManagement::getTaskStackHighWatermark(
+        TaskHandle_t task) {
+	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
+}
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 43003d76..4b7fe3eb 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -1,64 +1,64 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
-#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-extern "C" {
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-}
-#include <cstdint>
-
-/**
- * Architecture dependant portmacro.h function call.
- * Should be implemented in bsp.
- */
-extern void vRequestContextSwitchFromISR();
-
-/*!
- * Used by functions to tell if they are being called from
- * within an ISR or from a regular task. This is required because FreeRTOS
- * has different functions for handling semaphores and messages from within
- * an ISR and task.
- */
-enum class CallContext {
-	TASK = 0x00,//!< task_context
-	ISR = 0xFF  //!< isr_context
-};
-
-
-class TaskManagement {
-public:
-	/**
-	 * @brief	In this function, a function dependant on the portmacro.h header
-	 * 			function calls to request a context switch can be specified.
-	 * This can be used if sending to the queue from an ISR caused a task
-	 * to unblock and a context switch is required.
-	 */
-	static void requestContextSwitch(CallContext callContext);
-
-	/**
-	 * If task preemption in FreeRTOS is disabled, a context switch
-	 * can be requested manually by calling this function.
-	 */
-	static void vRequestContextSwitchFromTask(void);
-
-	/**
-	 * @return The current task handle
-	 */
-	static TaskHandle_t getCurrentTaskHandle();
-
-	/**
-	 * Get returns the minimum amount of remaining stack space in words
-	 * that was a available to the task since the task started executing.
-	 * Please note that the actual value in bytes depends
-	 * on the stack depth type.
-	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
-	 * @return Smallest value of stack remaining since the task was started in
-	 * 		   words.
-	 */
-	static size_t getTaskStackHighWatermark(
-	        TaskHandle_t task = nullptr);
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+#define FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+extern "C" {
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+}
+#include <cstdint>
+
+/**
+ * Architecture dependant portmacro.h function call.
+ * Should be implemented in bsp.
+ */
+extern void vRequestContextSwitchFromISR();
+
+/*!
+ * Used by functions to tell if they are being called from
+ * within an ISR or from a regular task. This is required because FreeRTOS
+ * has different functions for handling semaphores and messages from within
+ * an ISR and task.
+ */
+enum class CallContext {
+	TASK = 0x00,//!< task_context
+	ISR = 0xFF  //!< isr_context
+};
+
+
+class TaskManagement {
+public:
+	/**
+	 * @brief	In this function, a function dependant on the portmacro.h header
+	 * 			function calls to request a context switch can be specified.
+	 * This can be used if sending to the queue from an ISR caused a task
+	 * to unblock and a context switch is required.
+	 */
+	static void requestContextSwitch(CallContext callContext);
+
+	/**
+	 * If task preemption in FreeRTOS is disabled, a context switch
+	 * can be requested manually by calling this function.
+	 */
+	static void vRequestContextSwitchFromTask(void);
+
+	/**
+	 * @return The current task handle
+	 */
+	static TaskHandle_t getCurrentTaskHandle();
+
+	/**
+	 * Get returns the minimum amount of remaining stack space in words
+	 * that was a available to the task since the task started executing.
+	 * Please note that the actual value in bytes depends
+	 * on the stack depth type.
+	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
+	 * @return Smallest value of stack remaining since the task was started in
+	 * 		   words.
+	 */
+	static size_t getTaskStackHighWatermark(
+	        TaskHandle_t task = nullptr);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index f7a3c8f8..836f0b21 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,41 +1,41 @@
-#include "../../osal/FreeRTOS/Timekeeper.h"
-
-#include "FreeRTOSConfig.h"
-
-Timekeeper * Timekeeper::myinstance = nullptr;
-
-Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
-
-Timekeeper::~Timekeeper() {}
-
-const timeval& Timekeeper::getOffset() const {
-	return offset;
-}
-
-Timekeeper* Timekeeper::instance() {
-	if (myinstance == nullptr) {
-		myinstance = new Timekeeper();
-	}
-	return myinstance;
-}
-
-void Timekeeper::setOffset(const timeval& offset) {
-	this->offset = offset;
-}
-
-timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
-	timeval uptime;
-	uptime.tv_sec = ticks / configTICK_RATE_HZ;
-
-	//TODO explain, think about overflow
-	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
-	uint64_t usecondTicks = subsecondTicks * 1000000;
-
-	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
-
-	return uptime;
-}
-
-TickType_t Timekeeper::getTicks() {
-    return xTaskGetTickCount();
-}
+#include "../../osal/FreeRTOS/Timekeeper.h"
+
+#include "FreeRTOSConfig.h"
+
+Timekeeper * Timekeeper::myinstance = nullptr;
+
+Timekeeper::Timekeeper() : offset( { 0, 0 } ) {}
+
+Timekeeper::~Timekeeper() {}
+
+const timeval& Timekeeper::getOffset() const {
+	return offset;
+}
+
+Timekeeper* Timekeeper::instance() {
+	if (myinstance == nullptr) {
+		myinstance = new Timekeeper();
+	}
+	return myinstance;
+}
+
+void Timekeeper::setOffset(const timeval& offset) {
+	this->offset = offset;
+}
+
+timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
+	timeval uptime;
+	uptime.tv_sec = ticks / configTICK_RATE_HZ;
+
+	//TODO explain, think about overflow
+	uint32_t subsecondTicks = ticks % configTICK_RATE_HZ;
+	uint64_t usecondTicks = subsecondTicks * 1000000;
+
+	uptime.tv_usec = usecondTicks / configTICK_RATE_HZ;
+
+	return uptime;
+}
+
+TickType_t Timekeeper::getTicks() {
+    return xTaskGetTickCount();
+}
diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h
index fc1664e2..7d583f7d 100644
--- a/osal/FreeRTOS/Timekeeper.h
+++ b/osal/FreeRTOS/Timekeeper.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
-
-#include "../../timemanager/Clock.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-
-/**
- * A Class to basically store the time difference between uptime and UTC
- * so the "time-agnostic" FreeRTOS can keep an UTC Time
- *
- * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
- * can use it without having a member.
- */
-
-class Timekeeper {
-private:
-	Timekeeper();
-
-	timeval offset;
-
-	static Timekeeper * myinstance;
-public:
-	static Timekeeper * instance();
-	virtual ~Timekeeper();
-
-	static timeval ticksToTimeval(TickType_t ticks);
-    /**
-     * Get elapsed time in system ticks.
-     * @return
-     */
-    static TickType_t getTicks();
-
-	const timeval& getOffset() const;
-	void setOffset(const timeval& offset);
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+#define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
+
+#include "../../timemanager/Clock.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+
+/**
+ * A Class to basically store the time difference between uptime and UTC
+ * so the "time-agnostic" FreeRTOS can keep an UTC Time
+ *
+ * Implemented as Singleton, so the FSFW Clock Implementation (see Clock.cpp)
+ * can use it without having a member.
+ */
+
+class Timekeeper {
+private:
+	Timekeeper();
+
+	timeval offset;
+
+	static Timekeeper * myinstance;
+public:
+	static Timekeeper * instance();
+	virtual ~Timekeeper();
+
+	static timeval ticksToTimeval(TickType_t ticks);
+    /**
+     * Get elapsed time in system ticks.
+     * @return
+     */
+    static TickType_t getTicks();
+
+	const timeval& getOffset() const;
+	void setOffset(const timeval& offset);
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
diff --git a/osal/InternalErrorCodes.h b/osal/InternalErrorCodes.h
index d89eb230..1da116fa 100644
--- a/osal/InternalErrorCodes.h
+++ b/osal/InternalErrorCodes.h
@@ -1,39 +1,39 @@
-#ifndef INTERNALERRORCODES_H_
-#define INTERNALERRORCODES_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-class InternalErrorCodes {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
-
-static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
-static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
-static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
-static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
-static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
-static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
-static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
-static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
-static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
-static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
-static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
-static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
-static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
-static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
-static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
-static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
-static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
-static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
-static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
-static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
-static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
-
-	virtual ~InternalErrorCodes();
-
-	static ReturnValue_t translate(uint8_t code);
-private:
-	InternalErrorCodes();
-};
-
-#endif /* INTERNALERRORCODES_H_ */
+#ifndef INTERNALERRORCODES_H_
+#define INTERNALERRORCODES_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+class InternalErrorCodes {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::INTERNAL_ERROR_CODES;
+
+static const ReturnValue_t NO_CONFIGURATION_TABLE = MAKE_RETURN_CODE(0x01 );
+static const ReturnValue_t NO_CPU_TABLE = MAKE_RETURN_CODE(0x02 );
+static const ReturnValue_t INVALID_WORKSPACE_ADDRESS = MAKE_RETURN_CODE(0x03 );
+static const ReturnValue_t TOO_LITTLE_WORKSPACE = MAKE_RETURN_CODE(0x04 );
+static const ReturnValue_t WORKSPACE_ALLOCATION = MAKE_RETURN_CODE(0x05 );
+static const ReturnValue_t INTERRUPT_STACK_TOO_SMALL = MAKE_RETURN_CODE(0x06 );
+static const ReturnValue_t THREAD_EXITTED = MAKE_RETURN_CODE(0x07 );
+static const ReturnValue_t INCONSISTENT_MP_INFORMATION = MAKE_RETURN_CODE(0x08 );
+static const ReturnValue_t INVALID_NODE = MAKE_RETURN_CODE(0x09 );
+static const ReturnValue_t NO_MPCI = MAKE_RETURN_CODE(0x0a );
+static const ReturnValue_t BAD_PACKET = MAKE_RETURN_CODE(0x0b );
+static const ReturnValue_t OUT_OF_PACKETS = MAKE_RETURN_CODE(0x0c );
+static const ReturnValue_t OUT_OF_GLOBAL_OBJECTS = MAKE_RETURN_CODE(0x0d );
+static const ReturnValue_t OUT_OF_PROXIES = MAKE_RETURN_CODE(0x0e );
+static const ReturnValue_t INVALID_GLOBAL_ID = MAKE_RETURN_CODE(0x0f );
+static const ReturnValue_t BAD_STACK_HOOK = MAKE_RETURN_CODE(0x10 );
+static const ReturnValue_t BAD_ATTRIBUTES = MAKE_RETURN_CODE(0x11 );
+static const ReturnValue_t IMPLEMENTATION_KEY_CREATE_INCONSISTENCY = MAKE_RETURN_CODE(0x12 );
+static const ReturnValue_t IMPLEMENTATION_BLOCKING_OPERATION_CANCEL = MAKE_RETURN_CODE(0x13 );
+static const ReturnValue_t MUTEX_OBTAIN_FROM_BAD_STATE = MAKE_RETURN_CODE(0x14 );
+static const ReturnValue_t UNLIMITED_AND_MAXIMUM_IS_0 = MAKE_RETURN_CODE(0x15 );
+
+	virtual ~InternalErrorCodes();
+
+	static ReturnValue_t translate(uint8_t code);
+private:
+	InternalErrorCodes();
+};
+
+#endif /* INTERNALERRORCODES_H_ */
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 52d0d5f0..41321eeb 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -1,227 +1,227 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Clock.h"
-
-#include <chrono>
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <fstream>
-#endif
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-using SystemClock = std::chrono::system_clock;
-
-uint32_t Clock::getTicksPerSecond(void){
-	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
-	return 0;
-	//return CLOCKS_PER_SEC;
-	//uint32_t ticks = sysconf(_SC_CLK_TCK);
-	//return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	// do some magic with chrono
-	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	// do some magic with chrono
-#if defined(WIN32)
-	return HasReturnvaluesIF::RETURN_OK;
-#elif defined(LINUX)
-	return HasReturnvaluesIF::RETURN_OK;
-#else
-
-#endif
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-#if defined(WIN32)
-	auto now  = std::chrono::system_clock::now();
-	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
-	auto epoch = now.time_since_epoch();
-	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
-	auto fraction = now - secondsChrono;
-	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
-	        fraction).count();
-	return HasReturnvaluesIF::RETURN_OK;
-#elif defined(LINUX)
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	time->tv_sec = timeUnix.tv_sec;
-	time->tv_usec = timeUnix.tv_nsec / 1000.0;
-	return HasReturnvaluesIF::RETURN_OK;
-#else
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-#endif
-
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	// do some magic with chrono
-	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval timeval;
-#if defined(WIN32)
-	auto uptime  = std::chrono::milliseconds(GetTickCount64());
-	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
-	timeval.tv_sec = secondsChrono.count();
-	auto fraction = uptime - secondsChrono;
-	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
-	            fraction).count();
-#elif defined(LINUX)
-	double uptimeSeconds;
-	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
-	{
-		// value is rounded down automatically
-		timeval.tv_sec = uptimeSeconds;
-		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
-	}
-#else
-	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
-#endif
-	return timeval;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	// do some magic with chrono (C++20!)
-	// Right now, the library doesn't have the new features yet.
-	// so we work around that for now.
-	auto now = SystemClock::now();
-	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
-	auto fraction = now - seconds;
-	time_t tt = SystemClock::to_time_t(now);
-	struct tm* timeInfo;
-	timeInfo = gmtime(&tt);
-	time->year = timeInfo->tm_year + 1900;
-	time->month = timeInfo->tm_mon+1;
-	time->day = timeInfo->tm_mday;
-	time->hour = timeInfo->tm_hour;
-	time->minute = timeInfo->tm_min;
-	time->second = timeInfo->tm_sec;
-	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
-	time->usecond = usecond.count();
-
-	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
-
-	time_tm.tm_year = from->year - 1900;
-	time_tm.tm_mon = from->month - 1;
-	time_tm.tm_mday = from->day;
-
-	time_tm.tm_hour = from->hour;
-	time_tm.tm_min = from->minute;
-	time_tm.tm_sec = from->second;
-
-	time_t seconds = mktime(&time_tm);
-
-	to->tv_sec = seconds;
-	to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
-	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex == nullptr){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex == nullptr){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == nullptr) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == nullptr) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <chrono>
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <fstream>
+#endif
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+using SystemClock = std::chrono::system_clock;
+
+uint32_t Clock::getTicksPerSecond(void){
+	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+	return 0;
+	//return CLOCKS_PER_SEC;
+	//uint32_t ticks = sysconf(_SC_CLK_TCK);
+	//return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	// do some magic with chrono
+#if defined(WIN32)
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+
+#endif
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+#if defined(WIN32)
+	auto now  = std::chrono::system_clock::now();
+	auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto epoch = now.time_since_epoch();
+	time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
+	auto fraction = now - secondsChrono;
+	time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	        fraction).count();
+	return HasReturnvaluesIF::RETURN_OK;
+#elif defined(LINUX)
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+#endif
+
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	// do some magic with chrono
+	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval timeval;
+#if defined(WIN32)
+	auto uptime  = std::chrono::milliseconds(GetTickCount64());
+	auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
+	timeval.tv_sec = secondsChrono.count();
+	auto fraction = uptime - secondsChrono;
+	timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(
+	            fraction).count();
+#elif defined(LINUX)
+	double uptimeSeconds;
+	if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds)
+	{
+		// value is rounded down automatically
+		timeval.tv_sec = uptimeSeconds;
+		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
+	}
+#else
+	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
+	return timeval;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	*uptime = getUptime();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime = getUptime();
+	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// do some magic with chrono (C++20!)
+	// Right now, the library doesn't have the new features yet.
+	// so we work around that for now.
+	auto now = SystemClock::now();
+	auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
+	auto fraction = now - seconds;
+	time_t tt = SystemClock::to_time_t(now);
+	struct tm* timeInfo;
+	timeInfo = gmtime(&tt);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
+	time->usecond = usecond.count();
+
+	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	struct tm time_tm;
+
+	time_tm.tm_year = from->year - 1900;
+	time_tm.tm_mon = from->month - 1;
+	time_tm.tm_mday = from->day;
+
+	time_tm.tm_hour = from->hour;
+	time_tm.tm_min = from->minute;
+	time_tm.tm_sec = from->second;
+
+	time_t seconds = mktime(&time_tm);
+
+	to->tv_sec = seconds;
+	to->tv_usec = from->usecond;
+	//Fails in 2038..
+	return HasReturnvaluesIF::RETURN_OK;
+	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex == nullptr){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex == nullptr){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 2bb0f84d..1139badb 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,191 +1,191 @@
-#include "../../osal/host/FixedTimeslotTask.h"
-
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/FixedTimeslotTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-#include <thread>
-#include <chrono>
-
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <pthread.h>
-#endif
-
-FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
-        TaskStackSize setStack, TaskPeriod setPeriod,
-        void (*setDeadlineMissedFunc)()) :
-        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
-        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
-    // It is propably possible to set task priorities by using the native
-    // task handles for Windows / Linux
-    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
-#endif
-}
-
-FixedTimeslotTask::~FixedTimeslotTask(void) {
-    //Do not delete objects, we were responsible for ptrs only.
-    terminateThread = true;
-    if(mainThread.joinable()) {
-        mainThread.join();
-    }
-    delete this;
-}
-
-void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-
-    if (not originalTask->started) {
-        // we have to suspend/block here until the task is started.
-        // if semaphores are implemented, use them here.
-        std::unique_lock<std::mutex> lock(initMutex);
-        initCondition.wait(lock);
-    }
-
-    this->taskFunctionality();
-    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
-            "Returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-    started = true;
-
-    // Notify task to start.
-    std::lock_guard<std::mutex> lock(initMutex);
-    initCondition.notify_one();
-
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-    // A local iterator for the Polling Sequence Table is created to
-    // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
-    // Get start time for first entry.
-    chron_ms interval(slotListIter->pollingTimeMs);
-    auto currentStartTime {
-            std::chrono::duration_cast<chron_ms>(
-            std::chrono::system_clock::now().time_since_epoch())
-    };
-    if(interval.count() > 0) {
-        delayForInterval(&currentStartTime, interval);
-    }
-
-    /* Enter the loop that defines the task behavior. */
-    for (;;) {
-        if(terminateThread.load()) {
-            break;
-        }
-        //The component for this slot is executed and the next one is chosen.
-        this->pollingSeqTable.executeAndAdvance();
-        if (not pollingSeqTable.slotFollowsImmediately()) {
-            // we need to wait before executing the current slot
-            //this gives us the time to wait:
-            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
-            delayForInterval(&currentStartTime, interval);
-            //TODO deadline missed check
-        }
-    }
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-        uint32_t slotTimeMs, int8_t executionStep) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    sif::error << "Component " << std::hex << componentId <<
-            " not found, not adding it to pst" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
-    return pollingSeqTable.checkSequence();
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-    return period * 1000;
-}
-
-bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
-        const chron_ms interval) {
-    bool shouldDelay = false;
-    //Get current wakeup time
-    auto currentStartTime =
-            std::chrono::duration_cast<chron_ms>(
-            std::chrono::system_clock::now().time_since_epoch());
-    /* Generate the tick time at which the task wants to wake. */
-    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
-
-    if (currentStartTime < *previousWakeTimeMs) {
-        /* The tick count has overflowed since this function was
-         lasted called.  In this case the only time we should ever
-         actually delay is if the wake time has also    overflowed,
-         and the wake time is greater than the tick time.  When this
-         is the case it is as if neither time had overflowed. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                && (nextTimeToWake_ms > currentStartTime)) {
-            shouldDelay = true;
-        }
-    } else {
-        /* The tick time has not overflowed.  In this case we will
-         delay if either the wake time has overflowed, and/or the
-         tick time is less than the wake time. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                || (nextTimeToWake_ms >  currentStartTime)) {
-            shouldDelay = true;
-        }
-    }
-
-    /* Update the wake time ready for the next call. */
-
-    (*previousWakeTimeMs) =  nextTimeToWake_ms;
-
-    if (shouldDelay) {
-        auto sleepTime = std::chrono::duration_cast<chron_ms>(
-                nextTimeToWake_ms - currentStartTime);
-        std::this_thread::sleep_for(sleepTime);
-        return true;
-    }
-    //We are shifting the time in case the deadline was missed like rtems
-    (*previousWakeTimeMs) = currentStartTime;
-    return false;
-
-}
-
-
-
-
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/FixedTimeslotTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
+        TaskStackSize setStack, TaskPeriod setPeriod,
+        void (*setDeadlineMissedFunc)()) :
+        started(false), pollingSeqTable(setPeriod*1000), taskName(name),
+        period(setPeriod), deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+    mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+FixedTimeslotTask::~FixedTimeslotTask(void) {
+    //Do not delete objects, we were responsible for ptrs only.
+    terminateThread = true;
+    if(mainThread.joinable()) {
+        mainThread.join();
+    }
+    delete this;
+}
+
+void FixedTimeslotTask::taskEntryPoint(void* argument) {
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+
+    if (not originalTask->started) {
+        // we have to suspend/block here until the task is started.
+        // if semaphores are implemented, use them here.
+        std::unique_lock<std::mutex> lock(initMutex);
+        initCondition.wait(lock);
+    }
+
+    this->taskFunctionality();
+    sif::debug << "FixedTimeslotTask::taskEntryPoint: "
+            "Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+    started = true;
+
+    // Notify task to start.
+    std::lock_guard<std::mutex> lock(initMutex);
+    initCondition.notify_one();
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+    // A local iterator for the Polling Sequence Table is created to
+    // find the start time for the first entry.
+    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
+    // Get start time for first entry.
+    chron_ms interval(slotListIter->pollingTimeMs);
+    auto currentStartTime {
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch())
+    };
+    if(interval.count() > 0) {
+        delayForInterval(&currentStartTime, interval);
+    }
+
+    /* Enter the loop that defines the task behavior. */
+    for (;;) {
+        if(terminateThread.load()) {
+            break;
+        }
+        //The component for this slot is executed and the next one is chosen.
+        this->pollingSeqTable.executeAndAdvance();
+        if (not pollingSeqTable.slotFollowsImmediately()) {
+            // we need to wait before executing the current slot
+            //this gives us the time to wait:
+            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
+            delayForInterval(&currentStartTime, interval);
+            //TODO deadline missed check
+        }
+    }
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+        uint32_t slotTimeMs, int8_t executionStep) {
+    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "Component " << std::hex << componentId <<
+            " not found, not adding it to pst" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+    return pollingSeqTable.checkSequence();
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+    return period * 1000;
+}
+
+bool FixedTimeslotTask::delayForInterval(chron_ms * previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<chron_ms>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<chron_ms>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
+
+
+
+
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 861a072e..3ea97b97 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -1,130 +1,130 @@
-#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
-
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-#include <vector>
-#include <thread>
-#include <condition_variable>
-#include <atomic>
-
-class ExecutableObjectIF;
-
-/**
- * @brief   This class represents a task for periodic activities with multiple
- *          steps and strict timeslot requirements for these steps.
- * @details
- * @ingroup task_handling
- */
-class FixedTimeslotTask: public FixedTimeslotTaskIF {
-public:
-    /**
-     * @brief   Standard constructor of the class.
-     * @details
-     * The class is initialized without allocated objects. These need to be
-     * added with #addComponent.
-     * @param priority
-     * @param stack_size
-     * @param setPeriod
-     * @param setDeadlineMissedFunc
-     * The function pointer to the deadline missed function that shall be
-     * assigned.
-     */
-    FixedTimeslotTask(const char *name, TaskPriority setPriority,
-            TaskStackSize setStack, TaskPeriod setPeriod,
-            void (*setDeadlineMissedFunc)());
-    /**
-     * @brief   Currently, the executed object's lifetime is not coupled with
-     *          the task object's lifetime, so the destructor is empty.
-     */
-    virtual ~FixedTimeslotTask(void);
-
-    /**
-     * @brief   The method to start the task.
-     * @details The method starts the task with the respective system call.
-     *          Entry point is the taskEntryPoint method described below.
-     *          The address of the task object is passed as an argument
-     *          to the system call.
-     */
-    ReturnValue_t startTask(void);
-
-    /**
-     * Add timeslot to the polling sequence table.
-     * @param componentId
-     * @param slotTimeMs
-     * @param executionStep
-     * @return
-     */
-    ReturnValue_t addSlot(object_id_t componentId,
-                   uint32_t slotTimeMs, int8_t executionStep);
-
-    ReturnValue_t checkAndInitializeSequence() const;
-
-    uint32_t getPeriodMs() const;
-
-    ReturnValue_t sleepFor(uint32_t ms);
-
-protected:
-    using chron_ms = std::chrono::milliseconds;
-
-    bool started;
-    //!< Typedef for the List of objects.
-    typedef std::vector<ExecutableObjectIF*> ObjectList;
-    std::thread mainThread;
-    std::atomic<bool> terminateThread = false;
-
-    //! Polling sequence table which contains the object to execute
-    //! and information like the timeslots and the passed execution step.
-    FixedSlotSequence pollingSeqTable;
-
-    std::condition_variable initCondition;
-    std::mutex initMutex;
-    std::string taskName;
-    /**
-     * @brief   The period of the task.
-     * @details
-     * The period determines the frequency of the task's execution.
-     * It is expressed in clock ticks.
-     */
-    TaskPeriod period;
-
-    /**
-     * @brief   The pointer to the deadline-missed function.
-     * @details
-     * This pointer stores the function that is executed if the task's deadline
-     * is missed. So, each may react individually on a timing failure.
-     * The pointer may be NULL, then nothing happens on missing the deadline.
-     * The deadline is equal to the next execution of the periodic task.
-     */
-    void (*deadlineMissedFunc)(void);
-    /**
-     * @brief   This is the function executed in the new task's context.
-     * @details
-     * It converts the argument back to the thread object type and copies the
-     * class instance to the task context.
-     * The taskFunctionality method is called afterwards.
-     * @param   A pointer to the task object itself is passed as argument.
-     */
-
-    void taskEntryPoint(void* argument);
-    /**
-     * @brief   The function containing the actual functionality of the task.
-     * @details
-     * The method sets and starts the task's period, then enters a loop that is
-     * repeated as long as the isRunning attribute is true. Within the loop,
-     * all performOperation methods of the added objects are called. Afterwards
-     * the checkAndRestartPeriod system call blocks the task until the next
-     *  period. On missing the deadline, the deadlineMissedFunction is executed.
-     */
-    void taskFunctionality(void);
-
-    bool delayForInterval(chron_ms * previousWakeTimeMs,
-            const chron_ms interval);
-};
-
-
-
-#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief   This class represents a task for periodic activities with multiple
+ *          steps and strict timeslot requirements for these steps.
+ * @details
+ * @ingroup task_handling
+ */
+class FixedTimeslotTask: public FixedTimeslotTaskIF {
+public:
+    /**
+     * @brief   Standard constructor of the class.
+     * @details
+     * The class is initialized without allocated objects. These need to be
+     * added with #addComponent.
+     * @param priority
+     * @param stack_size
+     * @param setPeriod
+     * @param setDeadlineMissedFunc
+     * The function pointer to the deadline missed function that shall be
+     * assigned.
+     */
+    FixedTimeslotTask(const char *name, TaskPriority setPriority,
+            TaskStackSize setStack, TaskPeriod setPeriod,
+            void (*setDeadlineMissedFunc)());
+    /**
+     * @brief   Currently, the executed object's lifetime is not coupled with
+     *          the task object's lifetime, so the destructor is empty.
+     */
+    virtual ~FixedTimeslotTask(void);
+
+    /**
+     * @brief   The method to start the task.
+     * @details The method starts the task with the respective system call.
+     *          Entry point is the taskEntryPoint method described below.
+     *          The address of the task object is passed as an argument
+     *          to the system call.
+     */
+    ReturnValue_t startTask(void);
+
+    /**
+     * Add timeslot to the polling sequence table.
+     * @param componentId
+     * @param slotTimeMs
+     * @param executionStep
+     * @return
+     */
+    ReturnValue_t addSlot(object_id_t componentId,
+                   uint32_t slotTimeMs, int8_t executionStep);
+
+    ReturnValue_t checkAndInitializeSequence() const;
+
+    uint32_t getPeriodMs() const;
+
+    ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+    using chron_ms = std::chrono::milliseconds;
+
+    bool started;
+    //!< Typedef for the List of objects.
+    typedef std::vector<ExecutableObjectIF*> ObjectList;
+    std::thread mainThread;
+    std::atomic<bool> terminateThread = false;
+
+    //! Polling sequence table which contains the object to execute
+    //! and information like the timeslots and the passed execution step.
+    FixedSlotSequence pollingSeqTable;
+
+    std::condition_variable initCondition;
+    std::mutex initMutex;
+    std::string taskName;
+    /**
+     * @brief   The period of the task.
+     * @details
+     * The period determines the frequency of the task's execution.
+     * It is expressed in clock ticks.
+     */
+    TaskPeriod period;
+
+    /**
+     * @brief   The pointer to the deadline-missed function.
+     * @details
+     * This pointer stores the function that is executed if the task's deadline
+     * is missed. So, each may react individually on a timing failure.
+     * The pointer may be NULL, then nothing happens on missing the deadline.
+     * The deadline is equal to the next execution of the periodic task.
+     */
+    void (*deadlineMissedFunc)(void);
+    /**
+     * @brief   This is the function executed in the new task's context.
+     * @details
+     * It converts the argument back to the thread object type and copies the
+     * class instance to the task context.
+     * The taskFunctionality method is called afterwards.
+     * @param   A pointer to the task object itself is passed as argument.
+     */
+
+    void taskEntryPoint(void* argument);
+    /**
+     * @brief   The function containing the actual functionality of the task.
+     * @details
+     * The method sets and starts the task's period, then enters a loop that is
+     * repeated as long as the isRunning attribute is true. Within the loop,
+     * all performOperation methods of the added objects are called. Afterwards
+     * the checkAndRestartPeriod system call blocks the task until the next
+     *  period. On missing the deadline, the deadlineMissedFunction is executed.
+     */
+    void taskFunctionality(void);
+
+    bool delayForInterval(chron_ms * previousWakeTimeMs,
+            const chron_ms interval);
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 6fd42849..8a34282c 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,155 +1,155 @@
-#include "../../osal/host/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/host/QueueMapManager.h"
-#include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
-
-MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
-		messageSize(maxMessageSize), messageDepth(messageDepth) {
-	queueLock = MutexFactory::instance()->createMutex();
-	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "MessageQueue: Could not be created" << std::endl;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	MutexFactory::instance()->deleteMutex(queueLock);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return MessageQueueIF::NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
-			ignoreFault);
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	if(status == HasReturnvaluesIF::RETURN_OK) {
-		*receivedFrom = this->lastPartner;
-	}
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(messageQueue.empty()) {
-		return MessageQueueIF::EMPTY;
-	}
-	// not sure this will work..
-	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, 20);
-	MessageQueueMessage* currentMessage = &messageQueue.front();
-	std::copy(currentMessage->getBuffer(),
-			currentMessage->getBuffer() + messageSize, message->getBuffer());
-	messageQueue.pop();
-	// The last partner is the first uint32_t field in the message
-	this->lastPartner = message->getSender();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	*count = messageQueue.size();
-	// Clears the queue.
-	messageQueue = std::queue<MessageQueueMessage>();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return mqId;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	defaultDestinationSet = true;
-	this->defaultDestination = defaultDestination;
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return defaultDestinationSet;
-}
-
-
-// static core function to send messages.
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-        bool ignoreFault) {
-	if(message->getMessageSize() > message->getMaximumMessageSize()) {
-		// Actually, this should never happen or an error will be emitted
-		// in MessageQueueMessage.
-		// But I will still return a failure here.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
-			QueueMapManager::instance()->getMessageQueue(sendTo));
-	if(targetQueue == nullptr) {
-		if(not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-							objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != nullptr) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		// TODO: Better returnvalue
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock, 20);
-		// not ideal, works for now though.
-		MessageQueueMessage* mqmMessage =
-				dynamic_cast<MessageQueueMessage*>(message);
-		if(message != nullptr) {
-			targetQueue->messageQueue.push(*mqmMessage);
-		}
-		else {
-			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
-					"is not MessageQueueMessage!" << std::endl;
-		}
-
-	}
-	else {
-		return MessageQueueIF::FULL;
-	}
-    message->setSender(sentFrom);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
-}
-
-ReturnValue_t MessageQueue::unlockQueue() {
-	return queueLock->unlockMutex();
-}
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/host/QueueMapManager.h"
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+
+MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
+		messageSize(maxMessageSize), messageDepth(messageDepth) {
+	queueLock = MutexFactory::instance()->createMutex();
+	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "MessageQueue: Could not be created" << std::endl;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	MutexFactory::instance()->deleteMutex(queueLock);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination,message,sentFrom,ignoreFault);
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return MessageQueueIF::NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo, message, sentFrom,
+			ignoreFault);
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	if(status == HasReturnvaluesIF::RETURN_OK) {
+		*receivedFrom = this->lastPartner;
+	}
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(messageQueue.empty()) {
+		return MessageQueueIF::EMPTY;
+	}
+	// not sure this will work..
+	//*message = std::move(messageQueue.front());
+	MutexHelper mutexLock(queueLock, 20);
+	MessageQueueMessage* currentMessage = &messageQueue.front();
+	std::copy(currentMessage->getBuffer(),
+			currentMessage->getBuffer() + messageSize, message->getBuffer());
+	messageQueue.pop();
+	// The last partner is the first uint32_t field in the message
+	this->lastPartner = message->getSender();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	*count = messageQueue.size();
+	// Clears the queue.
+	messageQueue = std::queue<MessageQueueMessage>();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return mqId;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	defaultDestinationSet = true;
+	this->defaultDestination = defaultDestination;
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return defaultDestinationSet;
+}
+
+
+// static core function to send messages.
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+        MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+        bool ignoreFault) {
+	if(message->getMessageSize() > message->getMaximumMessageSize()) {
+		// Actually, this should never happen or an error will be emitted
+		// in MessageQueueMessage.
+		// But I will still return a failure here.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	MessageQueue* targetQueue = dynamic_cast<MessageQueue*>(
+			QueueMapManager::instance()->getMessageQueue(sendTo));
+	if(targetQueue == nullptr) {
+		if(not ignoreFault) {
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+							objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != nullptr) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		// TODO: Better returnvalue
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
+		MutexHelper mutexLock(targetQueue->queueLock, 20);
+		// not ideal, works for now though.
+		MessageQueueMessage* mqmMessage =
+				dynamic_cast<MessageQueueMessage*>(message);
+		if(message != nullptr) {
+			targetQueue->messageQueue.push(*mqmMessage);
+		}
+		else {
+			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
+					"is not MessageQueueMessage!" << std::endl;
+		}
+
+	}
+	else {
+		return MessageQueueIF::FULL;
+	}
+    message->setSender(sentFrom);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(lockTimeout);
+}
+
+ReturnValue_t MessageQueue::unlockQueue() {
+	return queueLock->unlockMutex();
+}
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index d2da2402..21a01663 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -1,230 +1,230 @@
-#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
-#include "../../ipc/MutexIF.h"
-#include "../../timemanager/Clock.h"
-
-#include <queue>
-#include <memory>
-
-/**
- * @brief		This class manages sending and receiving of
- * 				message queue messages.
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- * For creating the queue, as well as sending and receiving messages, the class
- * makes use of the operating system calls provided.
- *
- * Please keep in mind that FreeRTOS offers different calls for message queue
- * operations if called from an ISR.
- * For now, the system context needs to be switched manually.
- * @ingroup osal
- * @ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details
-	 * By making use of the according operating system call, a message queue is
-	 * created and initialized. The message depth - the maximum number of
-	 * messages to be buffered - may be set with the help of a parameter,
-	 * whereas the message size is automatically set to the maximum message
-	 * queue message size. The operating system sets the message queue id, or
-	 * in case of failure, it is set to zero.
-	 * @param message_depth
-	 * The number of messages to be buffered before passing an error to the
-	 * sender. Default is three.
-	 * @param max_message_size
-	 * With this parameter, the maximum message size can be adjusted.
-	 * This should be left default.
-	 */
-	MessageQueue(size_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
-
-	/** Copying message queues forbidden */
-	MessageQueue(const MessageQueue&) = delete;
-	MessageQueue& operator=(const MessageQueue&) = delete;
-
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided
-	 * 			by the operating system.
-	 */
-	virtual ~MessageQueue();
-
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender
-	 * parent, but passes its queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the
-	 *  destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter
-	 * is not incremented if queue is full.
-	 */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false) override;
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the
-	 * sendToDefault call of the MessageQueueSender parent class and adds its
-	 * queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using
-	 * the stored lastPartner information as destination. If there was no
-	 * message received yet (i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply(MessageQueueMessageIF* message) override;
-
-	/**
-	 * @brief	With the sendMessage call, a queue message is sent to a
-	 * 			receiving queue.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 *  The OS's return value is returned.
-	 * @param sendTo	This parameter specifies the message queue id to send
-	 * the message to.
-	 * @param message	This is a pointer to a previously created message,
-	 * which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the
-	 * sender's queue id into the message. This variable is set to zero by
-	 * default.
-	 * @param ignoreFault If set to true, the internal software fault counter
-	 * is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	The sendToDefault method sends a queue message to the default
-	 * 			destination.
-	 * @details
-	 * In all other aspects, it works identical to the sendMessage method.
-	 * @param message	This is a pointer to a previously created message,
-	 * which is sent.
-	 * @param sentFrom	The sentFrom information can be set to inject the
-	 * sender's queue id into the message. This variable is set to zero by
-	 * default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault = false) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue
-	 * 			and returns the sender.
-	 * @details
-	 * It works identically to the other receiveMessage call, but in  addition
-	 * returns the sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) override;
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details
-	 * If data is available it is stored in the passed message pointer.
-	 * The message's original content is overwritten and the sendFrom
-	 * information is stored in the lastPartner attribute. Else, the lastPartner
-	 * information remains untouched, the message's content is cleared and the
-	 * function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count) override;
-	/**
-	 * @brief	This method returns the message queue id of the last
-	 * 			communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const override;
-	/**
-	 * @brief	This method returns the message queue id of this class's
-	 * 			message queue.
-	 */
-	MessageQueueId_t getId() const override;
-
-	/**
-	 * @brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-	/**
-	 * @brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const override;
-
-	bool isDefaultDestinationSet() const override;
-
-	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
-	ReturnValue_t unlockQueue();
-protected:
-	/**
-	 * @brief 	Implementation to be called from any send Call within
-	 * 			MessageQueue and MessageQueueSenderIF.
-	 * @details
-	 * This method takes the message provided, adds the sentFrom information and
-	 * passes it on to the destination provided with an operating system call.
-	 * The OS's return value is returned.
-	 * @param sendTo
-	 * This parameter specifies the message queue id to send the message to.
-	 * @param message
-	 * This is a pointer to a previously created message, which is sent.
-	 * @param sentFrom
-	 * The sentFrom information can be set to inject the sender's queue id into
-	 * the message. This variable is set to zero by default.
-	 * @param ignoreFault
-	 * If set to true, the internal software fault counter  is not incremented
-	 * if queue is full.
-	 * @param context Specify whether call is made from task or from an ISR.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-
-	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
-
-private:
-	std::queue<MessageQueueMessage> messageQueue;
-	/**
-	 * @brief	The class stores the queue id it got assigned.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t mqId = 0;
-	size_t messageSize = 0;
-	size_t messageDepth = 0;
-
-	MutexIF* queueLock;
-
-	bool defaultDestinationSet = false;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+#define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "../../ipc/MutexIF.h"
+#include "../../timemanager/Clock.h"
+
+#include <queue>
+#include <memory>
+
+/**
+ * @brief		This class manages sending and receiving of
+ * 				message queue messages.
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ * For creating the queue, as well as sending and receiving messages, the class
+ * makes use of the operating system calls provided.
+ *
+ * Please keep in mind that FreeRTOS offers different calls for message queue
+ * operations if called from an ISR.
+ * For now, the system context needs to be switched manually.
+ * @ingroup osal
+ * @ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details
+	 * By making use of the according operating system call, a message queue is
+	 * created and initialized. The message depth - the maximum number of
+	 * messages to be buffered - may be set with the help of a parameter,
+	 * whereas the message size is automatically set to the maximum message
+	 * queue message size. The operating system sets the message queue id, or
+	 * in case of failure, it is set to zero.
+	 * @param message_depth
+	 * The number of messages to be buffered before passing an error to the
+	 * sender. Default is three.
+	 * @param max_message_size
+	 * With this parameter, the maximum message size can be adjusted.
+	 * This should be left default.
+	 */
+	MessageQueue(size_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE);
+
+	/** Copying message queues forbidden */
+	MessageQueue(const MessageQueue&) = delete;
+	MessageQueue& operator=(const MessageQueue&) = delete;
+
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided
+	 * 			by the operating system.
+	 */
+	virtual ~MessageQueue();
+
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender
+	 * parent, but passes its queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the
+	 *  destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false) override;
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the
+	 * sendToDefault call of the MessageQueueSender parent class and adds its
+	 * queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using
+	 * the stored lastPartner information as destination. If there was no
+	 * message received yet (i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+	/**
+	 * @brief	With the sendMessage call, a queue message is sent to a
+	 * 			receiving queue.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 *  The OS's return value is returned.
+	 * @param sendTo	This parameter specifies the message queue id to send
+	 * the message to.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 * @param ignoreFault If set to true, the internal software fault counter
+	 * is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	The sendToDefault method sends a queue message to the default
+	 * 			destination.
+	 * @details
+	 * In all other aspects, it works identical to the sendMessage method.
+	 * @param message	This is a pointer to a previously created message,
+	 * which is sent.
+	 * @param sentFrom	The sentFrom information can be set to inject the
+	 * sender's queue id into the message. This variable is set to zero by
+	 * default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault = false) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue
+	 * 			and returns the sender.
+	 * @details
+	 * It works identically to the other receiveMessage call, but in  addition
+	 * returns the sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) override;
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details
+	 * If data is available it is stored in the passed message pointer.
+	 * The message's original content is overwritten and the sendFrom
+	 * information is stored in the lastPartner attribute. Else, the lastPartner
+	 * information remains untouched, the message's content is cleared and the
+	 * function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count) override;
+	/**
+	 * @brief	This method returns the message queue id of the last
+	 * 			communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const override;
+	/**
+	 * @brief	This method returns the message queue id of this class's
+	 * 			message queue.
+	 */
+	MessageQueueId_t getId() const override;
+
+	/**
+	 * @brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+	/**
+	 * @brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const override;
+
+	bool isDefaultDestinationSet() const override;
+
+	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
+	ReturnValue_t unlockQueue();
+protected:
+	/**
+	 * @brief 	Implementation to be called from any send Call within
+	 * 			MessageQueue and MessageQueueSenderIF.
+	 * @details
+	 * This method takes the message provided, adds the sentFrom information and
+	 * passes it on to the destination provided with an operating system call.
+	 * The OS's return value is returned.
+	 * @param sendTo
+	 * This parameter specifies the message queue id to send the message to.
+	 * @param message
+	 * This is a pointer to a previously created message, which is sent.
+	 * @param sentFrom
+	 * The sentFrom information can be set to inject the sender's queue id into
+	 * the message. This variable is set to zero by default.
+	 * @param ignoreFault
+	 * If set to true, the internal software fault counter  is not incremented
+	 * if queue is full.
+	 * @param context Specify whether call is made from task or from an ISR.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+
+	//static ReturnValue_t handleSendResult(BaseType_t result, bool ignoreFault);
+
+private:
+	std::queue<MessageQueueMessage> messageQueue;
+	/**
+	 * @brief	The class stores the queue id it got assigned.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t mqId = 0;
+	size_t messageSize = 0;
+	size_t messageDepth = 0;
+
+	MutexIF* queueLock;
+
+	bool defaultDestinationSet = false;
+	MessageQueueId_t defaultDestination = 0;
+	MessageQueueId_t lastPartner = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 28768507..2718f2b9 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,40 +1,40 @@
-#include "../../osal/host/Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::BLOCKING) {
-		mutex.lock();
-		locked = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else if(timeoutMs == MutexIF::POLLING) {
-		if(mutex.try_lock()) {
-			locked = true;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-	else if(timeoutMs > MutexIF::POLLING){
-		auto chronoMs = std::chrono::milliseconds(timeoutMs);
-		if(mutex.try_lock_for(chronoMs)) {
-			locked = true;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-	return MutexIF::MUTEX_TIMEOUT;
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	if(not locked) {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
-	mutex.unlock();
-	locked = false;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-std::timed_mutex* Mutex::getMutexHandle() {
-	return &mutex;
-}
+#include "../../osal/host/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = 0xffffffff;
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::BLOCKING) {
+		mutex.lock();
+		locked = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else if(timeoutMs == MutexIF::POLLING) {
+		if(mutex.try_lock()) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	else if(timeoutMs > MutexIF::POLLING){
+		auto chronoMs = std::chrono::milliseconds(timeoutMs);
+		if(mutex.try_lock_for(chronoMs)) {
+			locked = true;
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	}
+	return MutexIF::MUTEX_TIMEOUT;
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	if(not locked) {
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	}
+	mutex.unlock();
+	locked = false;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::timed_mutex* Mutex::getMutexHandle() {
+	return &mutex;
+}
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 4d49bac7..4461e5f2 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,28 +1,28 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-
-#include <mutex>
-
-/**
- * @brief OS component to implement MUTual EXclusion
- *
- * @details
- * Mutexes are binary semaphores which include a priority inheritance mechanism.
- * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
- * @ingroup osal
- */
-class Mutex : public MutexIF {
-public:
-	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
-	ReturnValue_t unlockMutex() override;
-
-	std::timed_mutex* getMutexHandle();
-private:
-	bool locked = false;
-	std::timed_mutex mutex;
-};
-
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+#include <mutex>
+
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
+class Mutex : public MutexIF {
+public:
+	Mutex() = default;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	ReturnValue_t unlockMutex() override;
+
+	std::timed_mutex* getMutexHandle();
+private:
+	bool locked = false;
+	std::timed_mutex mutex;
+};
+
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/host/MutexFactory.cpp b/osal/host/MutexFactory.cpp
index 284ce59f..bf7707d1 100644
--- a/osal/host/MutexFactory.cpp
+++ b/osal/host/MutexFactory.cpp
@@ -1,28 +1,28 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory.
-//What's better and why? -> one is on heap the other on bss/data
-//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = nullptr;
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new MutexFactory();
-	}
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
+//MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+MutexFactory* MutexFactory::factoryInstance = nullptr;
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new MutexFactory();
+	}
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index c4cf9f56..0b5f8bbe 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,176 +1,176 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/PeriodicTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-#include <thread>
-#include <chrono>
-
-#if defined(WIN32)
-#include <windows.h>
-#elif defined(LINUX)
-#include <pthread.h>
-#endif
-
-PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
-		TaskStackSize setStack, TaskPeriod setPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		started(false), taskName(name), period(setPeriod),
-		deadlineMissedFunc(setDeadlineMissedFunc) {
-    // It is propably possible to set task priorities by using the native
-    // task handles for Windows / Linux
-	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
-#endif
-}
-
-PeriodicTask::~PeriodicTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	terminateThread = true;
-	if(mainThread.joinable()) {
-		mainThread.join();
-	}
-	delete this;
-}
-
-void PeriodicTask::taskEntryPoint(void* argument) {
-	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
-
-
-	if (not originalTask->started) {
-		// we have to suspend/block here until the task is started.
-		// if semaphores are implemented, use them here.
-		std::unique_lock<std::mutex> lock(initMutex);
-		initCondition.wait(lock);
-	}
-
-	this->taskFunctionality();
-	sif::debug << "PeriodicTask::taskEntryPoint: "
-			"Returned from taskFunctionality." << std::endl;
-}
-
-ReturnValue_t PeriodicTask::startTask() {
-	started = true;
-
-	// Notify task to start.
-	std::lock_guard<std::mutex> lock(initMutex);
-	initCondition.notify_one();
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
-	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicTask::taskFunctionality() {
-	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
-	auto currentStartTime {
-	    std::chrono::duration_cast<std::chrono::milliseconds>(
-	    std::chrono::system_clock::now().time_since_epoch())
-	};
-	auto nextStartTime{ currentStartTime };
-
-	/* Enter the loop that defines the task behavior. */
-	for (;;) {
-		if(terminateThread.load()) {
-			break;
-		}
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		if(not delayForInterval(&currentStartTime, periodChrono)) {
-			sif::warning << "PeriodicTask: " << taskName <<
-					" missed deadline!\n" << std::flush;
-			if(deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t PeriodicTask::getPeriodMs() const {
-	return period * 1000;
-}
-
-bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
-        const chron_ms interval) {
-    bool shouldDelay = false;
-    //Get current wakeup time
-    auto currentStartTime =
-            std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now().time_since_epoch());
-    /* Generate the tick time at which the task wants to wake. */
-    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
-
-    if (currentStartTime < *previousWakeTimeMs) {
-        /* The tick count has overflowed since this function was
-         lasted called.  In this case the only time we should ever
-         actually delay is if the wake time has also    overflowed,
-         and the wake time is greater than the tick time.  When this
-         is the case it is as if neither time had overflowed. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                && (nextTimeToWake_ms > currentStartTime)) {
-            shouldDelay = true;
-        }
-    } else {
-        /* The tick time has not overflowed.  In this case we will
-         delay if either the wake time has overflowed, and/or the
-         tick time is less than the wake time. */
-        if ((nextTimeToWake_ms < *previousWakeTimeMs)
-                || (nextTimeToWake_ms >  currentStartTime)) {
-            shouldDelay = true;
-        }
-    }
-
-    /* Update the wake time ready for the next call. */
-
-    (*previousWakeTimeMs) =  nextTimeToWake_ms;
-
-    if (shouldDelay) {
-        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
-                nextTimeToWake_ms - currentStartTime);
-        std::this_thread::sleep_for(sleepTime);
-        return true;
-    }
-    //We are shifting the time in case the deadline was missed like rtems
-    (*previousWakeTimeMs) = currentStartTime;
-    return false;
-
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/PeriodicTask.h"
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <thread>
+#include <chrono>
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(LINUX)
+#include <pthread.h>
+#endif
+
+PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
+		TaskStackSize setStack, TaskPeriod setPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		started(false), taskName(name), period(setPeriod),
+		deadlineMissedFunc(setDeadlineMissedFunc) {
+    // It is propably possible to set task priorities by using the native
+    // task handles for Windows / Linux
+	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
+#if defined(WIN32)
+    /* List of possible priority classes:
+     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
+     * nf-processthreadsapi-setpriorityclass
+     * And respective thread priority numbers:
+     * https://docs.microsoft.com/en-us/windows/
+     * win32/procthread/scheduling-priorities */
+    int result = SetPriorityClass(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            ABOVE_NORMAL_PRIORITY_CLASS);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+    result = SetThreadPriority(
+            reinterpret_cast<HANDLE>(mainThread.native_handle()),
+            THREAD_PRIORITY_NORMAL);
+    if(result != 0) {
+        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
+    }
+#elif defined(LINUX)
+    // we can just copy and paste the code from linux here.
+#endif
+}
+
+PeriodicTask::~PeriodicTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	terminateThread = true;
+	if(mainThread.joinable()) {
+		mainThread.join();
+	}
+	delete this;
+}
+
+void PeriodicTask::taskEntryPoint(void* argument) {
+	PeriodicTask *originalTask(reinterpret_cast<PeriodicTask*>(argument));
+
+
+	if (not originalTask->started) {
+		// we have to suspend/block here until the task is started.
+		// if semaphores are implemented, use them here.
+		std::unique_lock<std::mutex> lock(initMutex);
+		initCondition.wait(lock);
+	}
+
+	this->taskFunctionality();
+	sif::debug << "PeriodicTask::taskEntryPoint: "
+			"Returned from taskFunctionality." << std::endl;
+}
+
+ReturnValue_t PeriodicTask::startTask() {
+	started = true;
+
+	// Notify task to start.
+	std::lock_guard<std::mutex> lock(initMutex);
+	initCondition.notify_one();
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicTask::taskFunctionality() {
+	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
+	auto currentStartTime {
+	    std::chrono::duration_cast<std::chrono::milliseconds>(
+	    std::chrono::system_clock::now().time_since_epoch())
+	};
+	auto nextStartTime{ currentStartTime };
+
+	/* Enter the loop that defines the task behavior. */
+	for (;;) {
+		if(terminateThread.load()) {
+			break;
+		}
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(not delayForInterval(&currentStartTime, periodChrono)) {
+			sif::warning << "PeriodicTask: " << taskName <<
+					" missed deadline!\n" << std::flush;
+			if(deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t PeriodicTask::getPeriodMs() const {
+	return period * 1000;
+}
+
+bool PeriodicTask::delayForInterval(chron_ms* previousWakeTimeMs,
+        const chron_ms interval) {
+    bool shouldDelay = false;
+    //Get current wakeup time
+    auto currentStartTime =
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
+    /* Generate the tick time at which the task wants to wake. */
+    auto nextTimeToWake_ms = (*previousWakeTimeMs) + interval;
+
+    if (currentStartTime < *previousWakeTimeMs) {
+        /* The tick count has overflowed since this function was
+         lasted called.  In this case the only time we should ever
+         actually delay is if the wake time has also    overflowed,
+         and the wake time is greater than the tick time.  When this
+         is the case it is as if neither time had overflowed. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                && (nextTimeToWake_ms > currentStartTime)) {
+            shouldDelay = true;
+        }
+    } else {
+        /* The tick time has not overflowed.  In this case we will
+         delay if either the wake time has overflowed, and/or the
+         tick time is less than the wake time. */
+        if ((nextTimeToWake_ms < *previousWakeTimeMs)
+                || (nextTimeToWake_ms >  currentStartTime)) {
+            shouldDelay = true;
+        }
+    }
+
+    /* Update the wake time ready for the next call. */
+
+    (*previousWakeTimeMs) =  nextTimeToWake_ms;
+
+    if (shouldDelay) {
+        auto sleepTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+                nextTimeToWake_ms - currentStartTime);
+        std::this_thread::sleep_for(sleepTime);
+        return true;
+    }
+    //We are shifting the time in case the deadline was missed like rtems
+    (*previousWakeTimeMs) = currentStartTime;
+    return false;
+
+}
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 7eb768cb..7689788a 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -1,123 +1,123 @@
-#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
-
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../tasks/Typedef.h"
-
-#include <vector>
-#include <thread>
-#include <condition_variable>
-#include <atomic>
-
-class ExecutableObjectIF;
-
-/**
- * @brief 	This class represents a specialized task for
- * 			periodic activities of multiple objects.
- * @details
- *
- * @ingroup task_handling
- */
-class PeriodicTask: public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details
-	 * The class is initialized without allocated objects. These need to be
-	 * added with #addComponent.
-	 * @param priority
-	 * @param stack_size
-	 * @param setPeriod
-	 * @param setDeadlineMissedFunc
-	 * The function pointer to the deadline missed function that shall be
-	 * assigned.
-	 */
-	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
-			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with
-	 * 			the task object's lifetime, so the destructor is empty.
-	 */
-	virtual ~PeriodicTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void);
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return
-	 *  -@c RETURN_OK on success
-	 *  -@c RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-
-protected:
-	using chron_ms = std::chrono::milliseconds;
-	bool started;
-	//!< Typedef for the List of objects.
-	typedef std::vector<ExecutableObjectIF*> ObjectList;
-	std::thread mainThread;
-	std::atomic<bool> terminateThread = false;
-
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	std::condition_variable initCondition;
-	std::mutex initMutex;
-	std::string taskName;
-	/**
-	 * @brief	The period of the task.
-	 * @details
-	 * The period determines the frequency of the task's execution.
-	 * It is expressed in clock ticks.
-	 */
-	TaskPeriod period;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details
-	 * This pointer stores the function that is executed if the task's deadline
-	 * is missed. So, each may react individually on a timing failure.
-	 * The pointer may be NULL, then nothing happens on missing the deadline.
-	 * The deadline is equal to the next execution of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details
-	 * It converts the argument back to the thread object type and copies the
-	 * class instance to the task context.
-	 * The taskFunctionality method is called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-
-	void taskEntryPoint(void* argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details
-	 * The method sets and starts the task's period, then enters a loop that is
-	 * repeated as long as the isRunning attribute is true. Within the loop,
-	 * all performOperation methods of the added objects are called. Afterwards
-	 * the checkAndRestartPeriod system call blocks the task until the next
-	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-
-	bool delayForInterval(chron_ms * previousWakeTimeMs,
-	        const chron_ms interval);
-};
-
-#endif /* PERIODICTASK_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+#define FRAMEWORK_OSAL_HOST_PERIODICTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
+
+#include <vector>
+#include <thread>
+#include <condition_variable>
+#include <atomic>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief 	This class represents a specialized task for
+ * 			periodic activities of multiple objects.
+ * @details
+ *
+ * @ingroup task_handling
+ */
+class PeriodicTask: public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details
+	 * The class is initialized without allocated objects. These need to be
+	 * added with #addComponent.
+	 * @param priority
+	 * @param stack_size
+	 * @param setPeriod
+	 * @param setDeadlineMissedFunc
+	 * The function pointer to the deadline missed function that shall be
+	 * assigned.
+	 */
+	PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack,
+			TaskPeriod setPeriod,void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with
+	 * 			the task object's lifetime, so the destructor is empty.
+	 */
+	virtual ~PeriodicTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return
+	 *  -@c RETURN_OK on success
+	 *  -@c RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+
+protected:
+	using chron_ms = std::chrono::milliseconds;
+	bool started;
+	//!< Typedef for the List of objects.
+	typedef std::vector<ExecutableObjectIF*> ObjectList;
+	std::thread mainThread;
+	std::atomic<bool> terminateThread = false;
+
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	std::condition_variable initCondition;
+	std::mutex initMutex;
+	std::string taskName;
+	/**
+	 * @brief	The period of the task.
+	 * @details
+	 * The period determines the frequency of the task's execution.
+	 * It is expressed in clock ticks.
+	 */
+	TaskPeriod period;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details
+	 * This pointer stores the function that is executed if the task's deadline
+	 * is missed. So, each may react individually on a timing failure.
+	 * The pointer may be NULL, then nothing happens on missing the deadline.
+	 * The deadline is equal to the next execution of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details
+	 * It converts the argument back to the thread object type and copies the
+	 * class instance to the task context.
+	 * The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+
+	void taskEntryPoint(void* argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details
+	 * The method sets and starts the task's period, then enters a loop that is
+	 * repeated as long as the isRunning attribute is true. Within the loop,
+	 * all performOperation methods of the added objects are called. Afterwards
+	 * the checkAndRestartPeriod system call blocks the task until the next
+	 *  period. On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+
+	bool delayForInterval(chron_ms * previousWakeTimeMs,
+	        const chron_ms interval);
+};
+
+#endif /* PERIODICTASK_H_ */
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 052671ca..da3fea55 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,41 +1,41 @@
-#include "../../ipc/QueueFactory.h"
-#include "../../osal/host/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	// A thread-safe queue can be implemented  by using a combination
-	// of std::queue and std::mutex. This uses dynamic memory allocation
-	// which could be alleviated by using a custom allocator, external library
-	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "../../osal/host/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	// A thread-safe queue can be implemented  by using a combination
+	// of std::queue and std::mutex. This uses dynamic memory allocation
+	// which could be alleviated by using a custom allocator, external library
+	// (etl::queue) or simply using std::queue, we're on a host machine anyway.
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 35db204e..47687bc1 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,51 +1,51 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
-#include "../../osal/host/QueueMapManager.h"
-
-QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
-
-QueueMapManager::QueueMapManager() {
-    mapLock = MutexFactory::instance()->createMutex();
-}
-
-QueueMapManager* QueueMapManager::instance() {
-	if (mqManagerInstance == nullptr){
-		mqManagerInstance = new QueueMapManager();
-	}
-	return QueueMapManager::mqManagerInstance;
-}
-
-ReturnValue_t QueueMapManager::addMessageQueue(
-		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
-	// Not thread-safe, but it is assumed all message queues are created
-	// at software initialization now. If this is to be made thread-safe in
-	// the future, it propably would be sufficient to lock the increment
-	// operation here
-	uint32_t currentId = queueCounter++;
-	auto returnPair = queueMap.emplace(currentId, queueToInsert);
-	if(not returnPair.second) {
-		// this should never happen for the atomic variable.
-		sif::error << "QueueMapManager: This ID is already inside the map!"
-				<< std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if (id != nullptr) {
-		*id = currentId;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* QueueMapManager::getMessageQueue(
-		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, 50);
-	auto queueIter = queueMap.find(messageQueueId);
-	if(queueIter != queueMap.end()) {
-		return queueIter->second;
-	}
-	else {
-		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
-				messageQueueId << " does not exists in the map" << std::endl;
-		return nullptr;
-	}
-}
-
+#include "../../ipc/MutexFactory.h"
+#include "../../ipc/MutexHelper.h"
+#include "../../osal/host/QueueMapManager.h"
+
+QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
+
+QueueMapManager::QueueMapManager() {
+    mapLock = MutexFactory::instance()->createMutex();
+}
+
+QueueMapManager* QueueMapManager::instance() {
+	if (mqManagerInstance == nullptr){
+		mqManagerInstance = new QueueMapManager();
+	}
+	return QueueMapManager::mqManagerInstance;
+}
+
+ReturnValue_t QueueMapManager::addMessageQueue(
+		MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
+	// Not thread-safe, but it is assumed all message queues are created
+	// at software initialization now. If this is to be made thread-safe in
+	// the future, it propably would be sufficient to lock the increment
+	// operation here
+	uint32_t currentId = queueCounter++;
+	auto returnPair = queueMap.emplace(currentId, queueToInsert);
+	if(not returnPair.second) {
+		// this should never happen for the atomic variable.
+		sif::error << "QueueMapManager: This ID is already inside the map!"
+				<< std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if (id != nullptr) {
+		*id = currentId;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* QueueMapManager::getMessageQueue(
+		MessageQueueId_t messageQueueId) const {
+	MutexHelper(mapLock, 50);
+	auto queueIter = queueMap.find(messageQueueId);
+	if(queueIter != queueMap.end()) {
+		return queueIter->second;
+	}
+	else {
+		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
+	}
+}
+
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index acf20389..823fd4c2 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,47 +1,47 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-
-#include "../../ipc/MessageQueueSenderIF.h"
-#include "../../osal/host/MessageQueue.h"
-#include <unordered_map>
-#include <atomic>
-
-using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
-
-
-/**
- * An internal map to map message queue IDs to message queues.
- * This propably should be a singleton..
- */
-class QueueMapManager {
-public:
-	//! Returns the single instance of SemaphoreFactory.
-	static QueueMapManager* instance();
-
-	/**
-	 * Insert a message queue into the map and returns a message queue ID
-	 * @param queue The message queue to insert.
-	 * @param id The passed value will be set unless a nullptr is passed
-	 * @return
-	 */
-	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
-			id = nullptr);
-	/**
-	 * Get the message queue handle by providing a message queue ID.
-	 * @param messageQueueId
-	 * @return
-	 */
-	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
-
-private:
-	//! External instantiation is forbidden.
-	QueueMapManager();
-	uint32_t queueCounter = 1;
-	MutexIF* mapLock;
-	QueueMap queueMap;
-	static QueueMapManager* mqManagerInstance;
-};
-
-
-
-#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../osal/host/MessageQueue.h"
+#include <unordered_map>
+#include <atomic>
+
+using QueueMap = std::unordered_map<MessageQueueId_t, MessageQueueIF*>;
+
+
+/**
+ * An internal map to map message queue IDs to message queues.
+ * This propably should be a singleton..
+ */
+class QueueMapManager {
+public:
+	//! Returns the single instance of SemaphoreFactory.
+	static QueueMapManager* instance();
+
+	/**
+	 * Insert a message queue into the map and returns a message queue ID
+	 * @param queue The message queue to insert.
+	 * @param id The passed value will be set unless a nullptr is passed
+	 * @return
+	 */
+	ReturnValue_t addMessageQueue(MessageQueueIF* queue, MessageQueueId_t*
+			id = nullptr);
+	/**
+	 * Get the message queue handle by providing a message queue ID.
+	 * @param messageQueueId
+	 * @return
+	 */
+	MessageQueueIF* getMessageQueue(MessageQueueId_t messageQueueId) const;
+
+private:
+	//! External instantiation is forbidden.
+	QueueMapManager();
+	uint32_t queueCounter = 1;
+	MutexIF* mapLock;
+	QueueMap queueMap;
+	static QueueMapManager* mqManagerInstance;
+};
+
+
+
+#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 58040428..c354c47c 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -1,42 +1,42 @@
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	// Just gonna wait for full C++20 for now.
-	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
-			" Returning nullptr!\n" << std::flush;
-	return nullptr;
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
-		uint8_t initCount, uint32_t arguments) {
-	// Just gonna wait for full C++20 for now.
-	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
-				" Returning nullptr!\n" << std::flush;
-	return nullptr;
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t SemaphoreIF::POLLING = 0;
+const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
+			" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	// Just gonna wait for full C++20 for now.
+	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
+				" Returning nullptr!\n" << std::flush;
+	return nullptr;
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 3f527130..37df981a 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -1,55 +1,55 @@
-#include "../../osal/host/FixedTimeslotTask.h"
-#include "../../osal/host/PeriodicTask.h"
-#include "../../tasks/TaskFactory.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-
-#include <chrono>
-
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-// Will propably not be used for hosted implementation
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
-
-TaskFactory::TaskFactory() {
-}
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
-			deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
-	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
-	        periodInSeconds_, deadLineMissedFunction_);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	// This might block for some time!
-	delete task;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
+#include "../../osal/host/FixedTimeslotTask.h"
+#include "../../osal/host/PeriodicTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include <chrono>
+
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+// Will propably not be used for hosted implementation
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
+
+TaskFactory::TaskFactory() {
+}
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
+			deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	// This is going to be interesting. Time now learn the C++ threading library
+	// :-)
+	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
+	        periodInSeconds_, deadLineMissedFunction_);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	// This might block for some time!
+	delete task;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 5216ff37..8c0eeae7 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,149 +1,149 @@
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-extern "C" {
-#include <errno.h>
-#include <string.h>
-}
-
-BinarySemaphore::BinarySemaphore() {
-	// Using unnamed semaphores for now
-	initSemaphore();
-}
-
-BinarySemaphore::~BinarySemaphore() {
-	sem_destroy(&handle);
-}
-
-BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-	initSemaphore();
-}
-
-BinarySemaphore& BinarySemaphore::operator =(
-        BinarySemaphore&& s) {
-	initSemaphore();
-	return * this;
-}
-
-ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
-		 uint32_t timeoutMs) {
-	int result = 0;
-	if(timeoutType == TimeoutType::POLLING) {
-		result = sem_trywait(&handle);
-	}
-	else if(timeoutType == TimeoutType::BLOCKING) {
-	    result = sem_wait(&handle);
-	}
-	else if(timeoutType == TimeoutType::WAITING){
-		timespec timeOut;
-		clock_gettime(CLOCK_REALTIME, &timeOut);
-		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
-		nseconds += timeoutMs * 1000000;
-		timeOut.tv_sec = nseconds / 1000000000;
-		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
-	    result = sem_timedwait(&handle, &timeOut);
-	    if(result != 0 and errno == EINVAL) {
-	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
-	    			<< std::endl;
-	    }
-	}
-	if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	switch(errno) {
-	case(EAGAIN):
-		// Operation could not be performed without blocking (for sem_trywait)
-	case(ETIMEDOUT):
-		// Semaphore is 0
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
-	case(EINVAL):
-		// Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	case(EINTR):
-		// Call was interrupted by signal handler
-		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
-				"Code " << strerror(errno) << std::endl;
-		/* No break */
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t BinarySemaphore::release() {
-	return BinarySemaphore::release(&this->handle);
-}
-
-ReturnValue_t BinarySemaphore::release(sem_t *handle) {
-	ReturnValue_t countResult = checkCount(handle, 1);
-	if(countResult != HasReturnvaluesIF::RETURN_OK) {
-		return countResult;
-	}
-
-	int result = sem_post(handle);
-	if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	switch(errno) {
-	case(EINVAL):
-		// Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	case(EOVERFLOW):
-		// SEM_MAX_VALUE overflow. This should never happen
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter() const {
-	// And another ugly cast :-D
-	return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
-}
-
-uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
-	int value = 0;
-	int result = sem_getvalue(handle, &value);
-	if (result == 0) {
-		return value;
-	}
-	else if(result != 0 and errno == EINVAL) {
-		// Could be called from interrupt, use lightweight printf
-		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
-		return 0;
-	}
-	else {
-		// This should never happen.
-		return 0;
-	}
-}
-
-void BinarySemaphore::initSemaphore(uint8_t initCount) {
-	auto result = sem_init(&handle, true, initCount);
-	if(result == -1) {
-		switch(errno) {
-		case(EINVAL):
-			// Value exceeds SEM_VALUE_MAX
-		case(ENOSYS):
-		// System does not support process-shared semaphores
-		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-				<< std::endl;
-		}
-	}
-}
-
-ReturnValue_t BinarySemaphore::checkCount(sem_t* handle, uint8_t maxCount) {
-	int value = getSemaphoreCounter(handle);
-	if(value >= maxCount) {
-		if(maxCount == 1 and value > 1) {
-			// Binary Semaphore special case.
-			// This is a config error use lightweight printf is this is called
-			// from an interrupt
-			printf("BinarySemaphore::release: Value of binary semaphore greater"
-					" than 1!\n");
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../osal/linux/BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+extern "C" {
+#include <errno.h>
+#include <string.h>
+}
+
+BinarySemaphore::BinarySemaphore() {
+	// Using unnamed semaphores for now
+	initSemaphore();
+}
+
+BinarySemaphore::~BinarySemaphore() {
+	sem_destroy(&handle);
+}
+
+BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+	initSemaphore();
+}
+
+BinarySemaphore& BinarySemaphore::operator =(
+        BinarySemaphore&& s) {
+	initSemaphore();
+	return * this;
+}
+
+ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
+		 uint32_t timeoutMs) {
+	int result = 0;
+	if(timeoutType == TimeoutType::POLLING) {
+		result = sem_trywait(&handle);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+	    result = sem_wait(&handle);
+	}
+	else if(timeoutType == TimeoutType::WAITING){
+		timespec timeOut;
+		clock_gettime(CLOCK_REALTIME, &timeOut);
+		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+		nseconds += timeoutMs * 1000000;
+		timeOut.tv_sec = nseconds / 1000000000;
+		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+	    result = sem_timedwait(&handle, &timeOut);
+	    if(result != 0 and errno == EINVAL) {
+	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
+	    			<< std::endl;
+	    }
+	}
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EAGAIN):
+		// Operation could not be performed without blocking (for sem_trywait)
+	case(ETIMEDOUT):
+		// Semaphore is 0
+		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EINTR):
+		// Call was interrupted by signal handler
+		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
+				"Code " << strerror(errno) << std::endl;
+		/* No break */
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t BinarySemaphore::release() {
+	return BinarySemaphore::release(&this->handle);
+}
+
+ReturnValue_t BinarySemaphore::release(sem_t *handle) {
+	ReturnValue_t countResult = checkCount(handle, 1);
+	if(countResult != HasReturnvaluesIF::RETURN_OK) {
+		return countResult;
+	}
+
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter() const {
+	// And another ugly cast :-D
+	return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
+}
+
+uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
+	int value = 0;
+	int result = sem_getvalue(handle, &value);
+	if (result == 0) {
+		return value;
+	}
+	else if(result != 0 and errno == EINVAL) {
+		// Could be called from interrupt, use lightweight printf
+		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		return 0;
+	}
+	else {
+		// This should never happen.
+		return 0;
+	}
+}
+
+void BinarySemaphore::initSemaphore(uint8_t initCount) {
+	auto result = sem_init(&handle, true, initCount);
+	if(result == -1) {
+		switch(errno) {
+		case(EINVAL):
+			// Value exceeds SEM_VALUE_MAX
+		case(ENOSYS):
+		// System does not support process-shared semaphores
+		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
+				<< std::endl;
+		}
+	}
+}
+
+ReturnValue_t BinarySemaphore::checkCount(sem_t* handle, uint8_t maxCount) {
+	int value = getSemaphoreCounter(handle);
+	if(value >= maxCount) {
+		if(maxCount == 1 and value > 1) {
+			// Binary Semaphore special case.
+			// This is a config error use lightweight printf is this is called
+			// from an interrupt
+			printf("BinarySemaphore::release: Value of binary semaphore greater"
+					" than 1!\n");
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/BinarySemaphore.h b/osal/linux/BinarySemaphore.h
index 4181de85..e9bb8bb6 100644
--- a/osal/linux/BinarySemaphore.h
+++ b/osal/linux/BinarySemaphore.h
@@ -1,81 +1,81 @@
-#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../tasks/SemaphoreIF.h"
-
-extern "C" {
-#include <semaphore.h>
-}
-
-/**
- * @brief 	OS Tool to achieve synchronization of between tasks or between
- * 			task and ISR. The default semaphore implementation creates a
- * 			binary semaphore, which can only be taken once.
- * @details
- * See: http://www.man7.org/linux/man-pages/man7/sem_overview.7.html
- * @author 	R. Mueller
- * @ingroup osal
- */
-class BinarySemaphore: public SemaphoreIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-
-	//! @brief Default ctor
-	BinarySemaphore();
-	//! @brief Copy ctor, deleted explicitely.
-	BinarySemaphore(const BinarySemaphore&) = delete;
-	//! @brief Copy assignment, deleted explicitely.
-	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
-	//! @brief Move ctor
-	BinarySemaphore (BinarySemaphore &&);
-	//! @brief Move assignment
-	BinarySemaphore & operator=(BinarySemaphore &&);
-	//! @brief Destructor
-	virtual ~BinarySemaphore();
-
-	void initSemaphore(uint8_t initCount = 1);
-
-	uint8_t getSemaphoreCounter() const override;
-	static uint8_t getSemaphoreCounter(sem_t* handle);
-
-	/**
-	 * Take the binary semaphore.
-	 * If the semaphore has already been taken, the task will be blocked
-	 * for a maximum of #timeoutMs or until the semaphore is given back,
-	 * for example by an ISR or another task.
-	 * @param timeoutMs
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
-	 */
-	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-			uint32_t timeoutMs = 0) override;
-
-	/**
-	 * Release the binary semaphore.
-	 * @return -@c RETURN_OK on success
-	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
-	 *         	already available.
-	 */
-	virtual ReturnValue_t release() override;
-	/**
-	 * This static function can be used to release a semaphore  by providing
-	 * its handle.
-	 * @param handle
-	 * @return
-	 */
-	static ReturnValue_t release(sem_t* handle);
-
-	/** Checks the validity of the semaphore count against a specified
-	 * known maxCount
-	 * @param handle
-	 * @param maxCount
-	 * @return
-	 */
-	static ReturnValue_t checkCount(sem_t* handle, uint8_t maxCount);
-protected:
-	sem_t handle;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+#define FRAMEWORK_OSAL_LINUX_BINARYSEMPAHORE_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../tasks/SemaphoreIF.h"
+
+extern "C" {
+#include <semaphore.h>
+}
+
+/**
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
+ * @details
+ * See: http://www.man7.org/linux/man-pages/man7/sem_overview.7.html
+ * @author 	R. Mueller
+ * @ingroup osal
+ */
+class BinarySemaphore: public SemaphoreIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+
+	//! @brief Default ctor
+	BinarySemaphore();
+	//! @brief Copy ctor, deleted explicitely.
+	BinarySemaphore(const BinarySemaphore&) = delete;
+	//! @brief Copy assignment, deleted explicitely.
+	BinarySemaphore& operator=(const BinarySemaphore&) = delete;
+	//! @brief Move ctor
+	BinarySemaphore (BinarySemaphore &&);
+	//! @brief Move assignment
+	BinarySemaphore & operator=(BinarySemaphore &&);
+	//! @brief Destructor
+	virtual ~BinarySemaphore();
+
+	void initSemaphore(uint8_t initCount = 1);
+
+	uint8_t getSemaphoreCounter() const override;
+	static uint8_t getSemaphoreCounter(sem_t* handle);
+
+	/**
+	 * Take the binary semaphore.
+	 * If the semaphore has already been taken, the task will be blocked
+	 * for a maximum of #timeoutMs or until the semaphore is given back,
+	 * for example by an ISR or another task.
+	 * @param timeoutMs
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
+	 */
+	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
+			uint32_t timeoutMs = 0) override;
+
+	/**
+	 * Release the binary semaphore.
+	 * @return -@c RETURN_OK on success
+	 *         -@c SemaphoreIF::SEMAPHORE_NOT_OWNED if the semaphores is
+	 *         	already available.
+	 */
+	virtual ReturnValue_t release() override;
+	/**
+	 * This static function can be used to release a semaphore  by providing
+	 * its handle.
+	 * @param handle
+	 * @return
+	 */
+	static ReturnValue_t release(sem_t* handle);
+
+	/** Checks the validity of the semaphore count against a specified
+	 * known maxCount
+	 * @param handle
+	 * @param maxCount
+	 * @return
+	 */
+	static ReturnValue_t checkCount(sem_t* handle, uint8_t maxCount);
+protected:
+	sem_t handle;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 370c77f7..5f764a6f 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,220 +1,220 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Clock.h"
-
-#include <sys/time.h>
-#include <sys/sysinfo.h>
-#include <linux/sysinfo.h>
-#include <time.h>
-#include <unistd.h>
-
-//#include <fstream>
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	uint32_t ticks = sysconf(_SC_CLK_TCK);
-	return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	timespec timeUnix;
-	timeval timeTimeval;
-	convertTimeOfDayToTimeval(time,&timeTimeval);
-	timeUnix.tv_sec = timeTimeval.tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
-
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	timespec timeUnix;
-	timeUnix.tv_sec = time->tv_sec;
-	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
-	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status!=0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	time->tv_sec = timeUnix.tv_sec;
-	time->tv_usec = timeUnix.tv_nsec / 1000.0;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval timeVal;
-	ReturnValue_t result = getClock_timeval(&timeVal);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-timeval Clock::getUptime() {
-	timeval uptime;
-	auto result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-	}
-	return uptime;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime;
-	ReturnValue_t result = getUptime(&uptime);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
-	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timespec timeUnix;
-	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
-	if(status != 0){
-		//TODO errno
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	struct tm* timeInfo;
-	timeInfo = gmtime(&timeUnix.tv_sec);
-	time->year = timeInfo->tm_year + 1900;
-	time->month = timeInfo->tm_mon+1;
-	time->day = timeInfo->tm_mday;
-	time->hour = timeInfo->tm_hour;
-	time->minute = timeInfo->tm_min;
-	time->second = timeInfo->tm_sec;
-	time->usecond = timeUnix.tv_nsec / 1000.0;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-
-	tm fromTm;
-	//Note: Fails for years before AD
-	fromTm.tm_year = from->year - 1900;
-	fromTm.tm_mon = from->month - 1;
-	fromTm.tm_mday = from->day;
-	fromTm.tm_hour = from->hour;
-	fromTm.tm_min = from->minute;
-	fromTm.tm_sec = from->second;
-
-	to->tv_sec = mktime(&fromTm);
-	to->tv_usec = from->usecond;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+#include <sys/time.h>
+#include <sys/sysinfo.h>
+#include <linux/sysinfo.h>
+#include <time.h>
+#include <unistd.h>
+
+//#include <fstream>
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	uint32_t ticks = sysconf(_SC_CLK_TCK);
+	return ticks;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	timespec timeUnix;
+	timeval timeTimeval;
+	convertTimeOfDayToTimeval(time,&timeTimeval);
+	timeUnix.tv_sec = timeTimeval.tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) timeTimeval.tv_usec * 1000;
+
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	timespec timeUnix;
+	timeUnix.tv_sec = time->tv_sec;
+	timeUnix.tv_nsec = (__syscall_slong_t) time->tv_usec * 1000;
+	int status = clock_settime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status!=0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	time->tv_sec = timeUnix.tv_sec;
+	time->tv_usec = timeUnix.tv_nsec / 1000.0;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval timeVal;
+	ReturnValue_t result = getClock_timeval(&timeVal);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*time = (uint64_t)timeVal.tv_sec*1e6 + timeVal.tv_usec;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+timeval Clock::getUptime() {
+	timeval uptime;
+	auto result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+	}
+	return uptime;
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	uptime->tv_sec = sysInfo.uptime;
+	uptime->tv_usec = 0;
+
+
+	//Linux specific file read but more precise
+//	double uptimeSeconds;
+//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+//		uptime->tv_sec = uptimeSeconds;
+//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+//	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	timeval uptime;
+	ReturnValue_t result = getUptime(&uptime);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	*uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	timespec timeUnix;
+	int status = clock_gettime(CLOCK_REALTIME,&timeUnix);
+	if(status != 0){
+		//TODO errno
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	struct tm* timeInfo;
+	timeInfo = gmtime(&timeUnix.tv_sec);
+	time->year = timeInfo->tm_year + 1900;
+	time->month = timeInfo->tm_mon+1;
+	time->day = timeInfo->tm_mday;
+	time->hour = timeInfo->tm_hour;
+	time->minute = timeInfo->tm_min;
+	time->second = timeInfo->tm_sec;
+	time->usecond = timeUnix.tv_nsec / 1000.0;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+
+	tm fromTm;
+	//Note: Fails for years before AD
+	fromTm.tm_year = from->year - 1900;
+	fromTm.tm_mon = from->month - 1;
+	fromTm.tm_mday = from->day;
+	fromTm.tm_hour = from->hour;
+	fromTm.tm_min = from->minute;
+	fromTm.tm_sec = from->second;
+
+	to->tv_sec = mktime(&fromTm);
+	to->tv_usec = from->usecond;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index ef32539b..18339399 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,54 +1,54 @@
-#include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
-		maxCount(maxCount), initCount(initCount) {
-	if(initCount > maxCount) {
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
-		initCount = maxCount;
-	}
-
-	initSemaphore(initCount);
-}
-
-CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
-		maxCount(other.maxCount), initCount(other.initCount) {
-	initSemaphore(initCount);
-}
-
-CountingSemaphore& CountingSemaphore::operator =(
-		CountingSemaphore&& other) {
-	initSemaphore(other.initCount);
-	return * this;
-}
-
-ReturnValue_t CountingSemaphore::release() {
-	ReturnValue_t result = checkCount(&handle, maxCount);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return CountingSemaphore::release(&this->handle);
-}
-
-ReturnValue_t CountingSemaphore::release(sem_t* handle) {
-	int result = sem_post(handle);
-	if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	switch(errno) {
-	case(EINVAL):
-		// Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
-	case(EOVERFLOW):
-		// SEM_MAX_VALUE overflow. This should never happen
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CountingSemaphore::getMaxCount() const {
-	return maxCount;
-}
-
+#include "../../osal/linux/CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
+		maxCount(maxCount), initCount(initCount) {
+	if(initCount > maxCount) {
+		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+				"intial cout. Setting initial count to max count." << std::endl;
+		initCount = maxCount;
+	}
+
+	initSemaphore(initCount);
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
+		maxCount(other.maxCount), initCount(other.initCount) {
+	initSemaphore(initCount);
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	initSemaphore(other.initCount);
+	return * this;
+}
+
+ReturnValue_t CountingSemaphore::release() {
+	ReturnValue_t result = checkCount(&handle, maxCount);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return CountingSemaphore::release(&this->handle);
+}
+
+ReturnValue_t CountingSemaphore::release(sem_t* handle) {
+	int result = sem_post(handle);
+	if(result == 0) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	switch(errno) {
+	case(EINVAL):
+		// Semaphore invalid
+		return SemaphoreIF::SEMAPHORE_INVALID;
+	case(EOVERFLOW):
+		// SEM_MAX_VALUE overflow. This should never happen
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+uint8_t CountingSemaphore::getMaxCount() const {
+	return maxCount;
+}
+
diff --git a/osal/linux/CountingSemaphore.h b/osal/linux/CountingSemaphore.h
index afe21a61..e0fbb992 100644
--- a/osal/linux/CountingSemaphore.h
+++ b/osal/linux/CountingSemaphore.h
@@ -1,37 +1,37 @@
-#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
-#include "../../osal/linux/BinarySemaphore.h"
-
-/**
- * @brief 	Counting semaphores, which can be acquired more than once.
- * @details
- * See: https://www.freertos.org/CreateCounting.html
- * API of counting semaphores is almost identical to binary semaphores,
- * so we just inherit from binary semaphore and provide the respective
- * constructors.
- */
-class CountingSemaphore: public BinarySemaphore {
-public:
-	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
-	//! @brief Copy ctor, disabled
-	CountingSemaphore(const CountingSemaphore&) = delete;
-	//! @brief Copy assignment, disabled
-	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
-	//! @brief Move ctor
-	CountingSemaphore (CountingSemaphore &&);
-	//! @brief Move assignment
-	CountingSemaphore & operator=(CountingSemaphore &&);
-
-	ReturnValue_t release() override;
-	static ReturnValue_t release(sem_t* sem);
-	/* Same API as binary semaphore otherwise. acquire() can be called
-	 * until there are not semaphores left and release() can be called
-	 * until maxCount is reached. */
-
-	uint8_t getMaxCount() const;
-private:
-	const uint8_t maxCount;
-	uint8_t initCount = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_LINUX_COUNTINGSEMAPHORE_H_
+#include "../../osal/linux/BinarySemaphore.h"
+
+/**
+ * @brief 	Counting semaphores, which can be acquired more than once.
+ * @details
+ * See: https://www.freertos.org/CreateCounting.html
+ * API of counting semaphores is almost identical to binary semaphores,
+ * so we just inherit from binary semaphore and provide the respective
+ * constructors.
+ */
+class CountingSemaphore: public BinarySemaphore {
+public:
+	CountingSemaphore(const uint8_t maxCount, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+
+	ReturnValue_t release() override;
+	static ReturnValue_t release(sem_t* sem);
+	/* Same API as binary semaphore otherwise. acquire() can be called
+	 * until there are not semaphores left and release() can be called
+	 * until maxCount is reached. */
+
+	uint8_t getMaxCount() const;
+private:
+	const uint8_t maxCount;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 12db83b1..b634b4cf 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,96 +1,96 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/FixedTimeslotTask.h"
-
-#include <limits.h>
-
-uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
-
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t periodMs_):
-		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
-}
-
-FixedTimeslotTask::~FixedTimeslotTask() {
-
-}
-
-void* FixedTimeslotTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return nullptr;
-}
-
-ReturnValue_t FixedTimeslotTask::startTask() {
-	started = true;
-	createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-uint32_t FixedTimeslotTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	ExecutableObjectIF* executableObject =
-			objectManager->get<ExecutableObjectIF>(componentId);
-	if (executableObject != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep,
-				executableObject,this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::dec << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t FixedTimeslotTask::checkSequence() const {
-	return pst.checkSequence();
-}
-
-void FixedTimeslotTask::taskFunctionality() {
-	//Like FreeRTOS pthreads are running as soon as they are created
-	if (!started) {
-		suspend();
-	}
-
-	pst.intializeSequenceAfterTaskCreation();
-	//The start time for the first entry is read.
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	uint64_t interval = pst.getIntervalToNextSlotMs();
-
-
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = this->pst.getIntervalToPreviousSlotMs();
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
-				//No time left on timer -> we missed the deadline
-				missedDeadlineCounter();
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-void FixedTimeslotTask::missedDeadlineCounter() {
-	FixedTimeslotTask::deadlineMissedCount++;
-	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
-				   << " deadlines." << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/FixedTimeslotTask.h"
+
+#include <limits.h>
+
+uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
+
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+}
+
+FixedTimeslotTask::~FixedTimeslotTask() {
+
+}
+
+void* FixedTimeslotTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return nullptr;
+}
+
+ReturnValue_t FixedTimeslotTask::startTask() {
+	started = true;
+	createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+uint32_t FixedTimeslotTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	ExecutableObjectIF* executableObject =
+			objectManager->get<ExecutableObjectIF>(componentId);
+	if (executableObject != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep,
+				executableObject,this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::dec << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
+	return pst.checkSequence();
+}
+
+void FixedTimeslotTask::taskFunctionality() {
+	//Like FreeRTOS pthreads are running as soon as they are created
+	if (!started) {
+		suspend();
+	}
+
+	pst.intializeSequenceAfterTaskCreation();
+	//The start time for the first entry is read.
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	uint64_t interval = pst.getIntervalToNextSlotMs();
+
+
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = this->pst.getIntervalToPreviousSlotMs();
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			if(!PosixThread::delayUntil(&lastWakeTime,interval)) {
+				//No time left on timer -> we missed the deadline
+				missedDeadlineCounter();
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+void FixedTimeslotTask::missedDeadlineCounter() {
+	FixedTimeslotTask::deadlineMissedCount++;
+	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
+				   << " deadlines." << std::endl;
+	}
+}
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 83bf203e..0148922d 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../osal/linux/PosixThread.h"
-#include <pthread.h>
-
-class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t periodMs_);
-	virtual ~FixedTimeslotTask();
-
-	virtual ReturnValue_t startTask();
-
-	virtual ReturnValue_t sleepFor(uint32_t ms);
-
-	virtual uint32_t getPeriodMs() const;
-
-	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
-
-	virtual ReturnValue_t checkSequence() const;
-
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-protected:
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 * @details
-	 * Holding the main functionality of the task, this method is most important.
-	 * It links the functionalities provided by FixedSlotSequence with the
-	 * OS's System Calls to keep the timing of the periods.
-	 */
-	virtual void taskFunctionality();
-
-private:
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details
-	 * This method, that is the entry point in the new thread and calls
-	 * taskFunctionality of the child class. Needs a valid pointer to the
-	 * derived class.
-	 *
-	 * The void* returnvalue is not used yet but could be used to return
-	 * arbitrary data.
-	 */
-	static void* taskEntryPoint(void* arg);
-	FixedSlotSequence pst;
-
-	bool started;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../osal/linux/PosixThread.h"
+#include <pthread.h>
+
+class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t periodMs_);
+	virtual ~FixedTimeslotTask();
+
+	virtual ReturnValue_t startTask();
+
+	virtual ReturnValue_t sleepFor(uint32_t ms);
+
+	virtual uint32_t getPeriodMs() const;
+
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+			int8_t executionStep);
+
+	virtual ReturnValue_t checkSequence() const;
+
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+protected:
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 * @details
+	 * Holding the main functionality of the task, this method is most important.
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
+	 */
+	virtual void taskFunctionality();
+
+private:
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details
+	 * This method, that is the entry point in the new thread and calls
+	 * taskFunctionality of the child class. Needs a valid pointer to the
+	 * derived class.
+	 *
+	 * The void* returnvalue is not used yet but could be used to return
+	 * arbitrary data.
+	 */
+	static void* taskEntryPoint(void* arg);
+	FixedSlotSequence pst;
+
+	bool started;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
diff --git a/osal/linux/InternalErrorCodes.cpp b/osal/linux/InternalErrorCodes.cpp
index 724cb4bc..a01cc72a 100644
--- a/osal/linux/InternalErrorCodes.cpp
+++ b/osal/linux/InternalErrorCodes.cpp
@@ -1,14 +1,14 @@
-#include "../../osal/InternalErrorCodes.h"
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	//TODO This class can be removed
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	//TODO This class can be removed
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 97c89552..87251724 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,369 +1,369 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/MessageQueue.h"
-
-#include <fstream>
-
-#include <fcntl.h>           /* For O_* constants */
-#include <sys/stat.h>        /* For mode constants */
-#include <cstring>
-#include <errno.h>
-
-
-MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
-		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
-		defaultDestination(MessageQueueIF::NO_QUEUE),
-		maxMessageSize(maxMessageSize) {
-	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
-	mq_attr attributes;
-	this->id = 0;
-	//Set attributes
-	attributes.mq_curmsgs = 0;
-	attributes.mq_maxmsg = messageDepth;
-	attributes.mq_msgsize = maxMessageSize;
-	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
-	//Set the name of the queue. The slash is mandatory!
-	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
-
-	// Create a nonblocking queue if the name is available (the queue is read
-	// and writable for the owner as well as the group)
-	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
-	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
-	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
-	if (tempId == -1) {
-		handleError(&attributes, messageDepth);
-	}
-	else {
-		//Successful mq_open call
-		this->id = tempId;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	int status = mq_close(this->id);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
-				   << strerror(errno) <<std::endl;
-	}
-	status = mq_unlink(name);
-	if(status != 0){
-		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-				   << strerror(errno) << std::endl;
-	}
-}
-
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
-		uint32_t messageDepth) {
-	switch(errno) {
-	case(EINVAL): {
-		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
-				" for message size" << std::endl;
-		size_t defaultMqMaxMsg = 0;
-		// Not POSIX conformant, but should work for all UNIX systems.
-		// Just an additional helpful printout :-)
-		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
-				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-			/*
-			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			This happens if the msg_max value is not large enough
-			It is ignored if the executable is run in privileged mode.
-		    Run the unlockRealtime script or grant the mode manually by using:
-			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
-
-			Persistent solution for session:
-			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
-
-			Permanent solution:
-			sudo nano /etc/sysctl.conf
-			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			Apply changes with: sudo sysctl -p
-			*/
-			sif::error << "MessageQueue::MessageQueue: Default MQ size "
-					<< defaultMqMaxMsg << " is too small for requested size "
-					<< messageDepth << std::endl;
-			sif::error << "This error can be fixed by setting the maximum "
-					"allowed message size higher!" << std::endl;
-
-		}
-		break;
-	}
-	case(EEXIST): {
-		// An error occured during open
-		// We need to distinguish if it is caused by an already created queue
-		//There's another queue with the same name
-		//We unlink the other queue
-		int status = mq_unlink(name);
-		if (status != 0) {
-			sif::error << "mq_unlink Failed with status: " << strerror(errno)
-													<< std::endl;
-		}
-		else {
-			// Successful unlinking, try to open again
-			mqd_t tempId = mq_open(name,
-					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-			if (tempId != -1) {
-				//Successful mq_open
-				this->id = tempId;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		break;
-	}
-
-	default:
-		// Failed either the first time or the second time
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
-
-	}
-	return HasReturnvaluesIF::RETURN_FAILED;
-
-
-
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), false);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
-		return sendMessageFrom(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::receiveMessage: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(message->getMaximumMessageSize() < maxMessageSize) {
-		sif::error << "MessageQueue::receiveMessage: Message size "
-				<< message->getMaximumMessageSize()
-				<< " too small to receive data!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	unsigned int messagePriority = 0;
-	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
-			message->getMaximumMessageSize(),&messagePriority);
-	if (status > 0) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->getMessageSize() < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}else if(status==0){
-		//Success but no message received
-		return MessageQueueIF::EMPTY;
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send
-		//something later. But still, delete packet content.
-		memset(message->getData(), 0, message->getMaximumMessageSize());
-		switch(errno){
-		case EAGAIN:
-			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
-			//currently on the specified queue.
-			return MessageQueueIF::EMPTY;
-		case EBADF:
-			//mqdes doesn't represent a valid queue open for reading.
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - The pointer to the buffer for storing the received message,
-			 *   msg_ptr, is NULL.
-			 * - The number of bytes requested, msg_len is less than zero.
-			 * - msg_len is anything other than the mq_msgsize of the specified
-			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
-			 *   been set in the queue's mq_flags.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-					   << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			/*
-			 * This value indicates one of the following:
-			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
-			 *   and the given msg_len is shorter than the mq_msgsize for
-			 *   the given queue.
-			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
-			 *   given msg_len is too short for the message that would have
-			 *   been received.
-			 */
-			sif::error << "MessageQueue::receive: configuration error "
-			           << strerror(errno)  << std::endl;
-			/*NO BREAK*/
-		case EINTR:
-			//The operation was interrupted by a signal.
-		default:
-
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	mq_attr attrib;
-	int status = mq_getattr(id,&attrib);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			//mq_attr is NULL
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	*count = attrib.mq_curmsgs;
-	attrib.mq_curmsgs = 0;
-	status = mq_setattr(id,&attrib,NULL);
-	if(status != 0){
-		switch(errno){
-		case EBADF:
-			//mqdes doesn't represent a valid message queue.
-			sif::error << "MessageQueue::flush configuration error, "
-					"called flush with an invalid queue ID" << std::endl;
-			/*NO BREAK*/
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 *  - mq_attr is NULL.
-			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
-			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
-			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
-			 */
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
-
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-uint16_t MessageQueue::queueCounter = 0;
-
-ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-	if(message == nullptr) {
-		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
-				"nullptr!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	message->setSender(sentFrom);
-	int result = mq_send(sendTo,
-			reinterpret_cast<const char*>(message->getBuffer()),
-			message->getMessageSize(),0);
-
-	//TODO: Check if we're in ISR.
-	if (result != 0) {
-		if(!ignoreFault){
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
-						objects::INTERNAL_ERROR_REPORTER);
-			if (internalErrorReporter != NULL) {
-				internalErrorReporter->queueMessageNotSent();
-			}
-		}
-		switch(errno){
-		case EAGAIN:
-			//The O_NONBLOCK flag was set when opening the queue, or the
-			//MQ_NONBLOCK flag was set in its attributes, and the
-			//specified queue is full.
-			return MessageQueueIF::FULL;
-		case EBADF: {
-			//mq_des doesn't represent a valid message queue descriptor,
-			//or mq_des wasn't opened for writing.
-			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
-					<< " destination invalid."  << std::endl;
-			sif::error << strerror(errno) << " in "
-					<<"mq_send to: " << sendTo << " sent from "
-					<< sentFrom << std::endl;
-			return DESTINVATION_INVALID;
-		}
-		case EINTR:
-			//The call was interrupted by a signal.
-		case EINVAL:
-			/*
-			 * This value indicates one of the following:
-			 * - msg_ptr is NULL.
-			 * - msg_len is negative.
-			 * - msg_prio is greater than MQ_PRIO_MAX.
-			 * - msg_prio is less than 0.
-			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
-			 *   msg_prio is greater than the priority of the calling process.
-			 */
-			sif::error << "MessageQueue::sendMessage: Configuration error "
-			           << strerror(errno) << " in mq_send" << std::endl;
-			/*NO BREAK*/
-		case EMSGSIZE:
-			// The msg_len is greater than the msgsize associated with
-			//the specified queue.
-			sif::error << "MessageQueue::sendMessage: Size error [" <<
-					strerror(errno) << "] in mq_send" << std::endl;
-			/*NO BREAK*/
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/MessageQueue.h"
+
+#include <fstream>
+
+#include <fcntl.h>           /* For O_* constants */
+#include <sys/stat.h>        /* For mode constants */
+#include <cstring>
+#include <errno.h>
+
+
+MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
+		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
+		defaultDestination(MessageQueueIF::NO_QUEUE),
+		maxMessageSize(maxMessageSize) {
+	//debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
+	mq_attr attributes;
+	this->id = 0;
+	//Set attributes
+	attributes.mq_curmsgs = 0;
+	attributes.mq_maxmsg = messageDepth;
+	attributes.mq_msgsize = maxMessageSize;
+	attributes.mq_flags = 0; //Flags are ignored on Linux during mq_open
+	//Set the name of the queue. The slash is mandatory!
+	sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
+
+	// Create a nonblocking queue if the name is available (the queue is read
+	// and writable for the owner as well as the group)
+	int oflag = O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL;
+	mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
+	mqd_t tempId = mq_open(name, oflag, mode, &attributes);
+	if (tempId == -1) {
+		handleError(&attributes, messageDepth);
+	}
+	else {
+		//Successful mq_open call
+		this->id = tempId;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	int status = mq_close(this->id);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
+				   << strerror(errno) <<std::endl;
+	}
+	status = mq_unlink(name);
+	if(status != 0){
+		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
+				   << strerror(errno) << std::endl;
+	}
+}
+
+ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
+		uint32_t messageDepth) {
+	switch(errno) {
+	case(EINVAL): {
+		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
+				" for message size" << std::endl;
+		size_t defaultMqMaxMsg = 0;
+		// Not POSIX conformant, but should work for all UNIX systems.
+		// Just an additional helpful printout :-)
+		if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+				defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+			/*
+			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+			This happens if the msg_max value is not large enough
+			It is ignored if the executable is run in privileged mode.
+		    Run the unlockRealtime script or grant the mode manually by using:
+			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+			Persistent solution for session:
+			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+			Permanent solution:
+			sudo nano /etc/sysctl.conf
+			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+			Apply changes with: sudo sysctl -p
+			*/
+			sif::error << "MessageQueue::MessageQueue: Default MQ size "
+					<< defaultMqMaxMsg << " is too small for requested size "
+					<< messageDepth << std::endl;
+			sif::error << "This error can be fixed by setting the maximum "
+					"allowed message size higher!" << std::endl;
+
+		}
+		break;
+	}
+	case(EEXIST): {
+		// An error occured during open
+		// We need to distinguish if it is caused by an already created queue
+		//There's another queue with the same name
+		//We unlink the other queue
+		int status = mq_unlink(name);
+		if (status != 0) {
+			sif::error << "mq_unlink Failed with status: " << strerror(errno)
+													<< std::endl;
+		}
+		else {
+			// Successful unlinking, try to open again
+			mqd_t tempId = mq_open(name,
+					O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+					S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+			if (tempId != -1) {
+				//Successful mq_open
+				this->id = tempId;
+				return HasReturnvaluesIF::RETURN_OK;
+			}
+		}
+		break;
+	}
+
+	default:
+		// Failed either the first time or the second time
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		<< name << std::dec << " failed with status: "
+		<< strerror(errno) << std::endl;
+
+	}
+	return HasReturnvaluesIF::RETURN_FAILED;
+
+
+
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), false);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
+	if (this->lastPartner != 0) {
+		return sendMessageFrom(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::receiveMessage: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(message->getMaximumMessageSize() < maxMessageSize) {
+		sif::error << "MessageQueue::receiveMessage: Message size "
+				<< message->getMaximumMessageSize()
+				<< " too small to receive data!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	unsigned int messagePriority = 0;
+	int status = mq_receive(id,reinterpret_cast<char*>(message->getBuffer()),
+			message->getMaximumMessageSize(),&messagePriority);
+	if (status > 0) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}else if(status==0){
+		//Success but no message received
+		return MessageQueueIF::EMPTY;
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send
+		//something later. But still, delete packet content.
+		memset(message->getData(), 0, message->getMaximumMessageSize());
+		switch(errno){
+		case EAGAIN:
+			//O_NONBLOCK or MQ_NONBLOCK was set and there are no messages
+			//currently on the specified queue.
+			return MessageQueueIF::EMPTY;
+		case EBADF:
+			//mqdes doesn't represent a valid queue open for reading.
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - The pointer to the buffer for storing the received message,
+			 *   msg_ptr, is NULL.
+			 * - The number of bytes requested, msg_len is less than zero.
+			 * - msg_len is anything other than the mq_msgsize of the specified
+			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
+			 *   been set in the queue's mq_flags.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+					   << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			/*
+			 * This value indicates one of the following:
+			 * - the QNX extended option MQ_READBUF_DYNAMIC hasn't been set,
+			 *   and the given msg_len is shorter than the mq_msgsize for
+			 *   the given queue.
+			 * - the extended option MQ_READBUF_DYNAMIC has been set, but the
+			 *   given msg_len is too short for the message that would have
+			 *   been received.
+			 */
+			sif::error << "MessageQueue::receive: configuration error "
+			           << strerror(errno)  << std::endl;
+			/*NO BREAK*/
+		case EINTR:
+			//The operation was interrupted by a signal.
+		default:
+
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	mq_attr attrib;
+	int status = mq_getattr(id,&attrib);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			//mq_attr is NULL
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	*count = attrib.mq_curmsgs;
+	attrib.mq_curmsgs = 0;
+	status = mq_setattr(id,&attrib,NULL);
+	if(status != 0){
+		switch(errno){
+		case EBADF:
+			//mqdes doesn't represent a valid message queue.
+			sif::error << "MessageQueue::flush configuration error, "
+					"called flush with an invalid queue ID" << std::endl;
+			/*NO BREAK*/
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 *  - mq_attr is NULL.
+			 *  - MQ_MULT_NOTIFY had been set for this queue, and the given
+			 *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
+			 *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
+			 */
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	return sendMessageFromMessageQueue(sendTo,message, sentFrom,ignoreFault);
+
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+uint16_t MessageQueue::queueCounter = 0;
+
+ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+	if(message == nullptr) {
+		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+				"nullptr!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	message->setSender(sentFrom);
+	int result = mq_send(sendTo,
+			reinterpret_cast<const char*>(message->getBuffer()),
+			message->getMessageSize(),0);
+
+	//TODO: Check if we're in ISR.
+	if (result != 0) {
+		if(!ignoreFault){
+			InternalErrorReporterIF* internalErrorReporter =
+					objectManager->get<InternalErrorReporterIF>(
+						objects::INTERNAL_ERROR_REPORTER);
+			if (internalErrorReporter != NULL) {
+				internalErrorReporter->queueMessageNotSent();
+			}
+		}
+		switch(errno){
+		case EAGAIN:
+			//The O_NONBLOCK flag was set when opening the queue, or the
+			//MQ_NONBLOCK flag was set in its attributes, and the
+			//specified queue is full.
+			return MessageQueueIF::FULL;
+		case EBADF: {
+			//mq_des doesn't represent a valid message queue descriptor,
+			//or mq_des wasn't opened for writing.
+			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+					<< " destination invalid."  << std::endl;
+			sif::error << strerror(errno) << " in "
+					<<"mq_send to: " << sendTo << " sent from "
+					<< sentFrom << std::endl;
+			return DESTINVATION_INVALID;
+		}
+		case EINTR:
+			//The call was interrupted by a signal.
+		case EINVAL:
+			/*
+			 * This value indicates one of the following:
+			 * - msg_ptr is NULL.
+			 * - msg_len is negative.
+			 * - msg_prio is greater than MQ_PRIO_MAX.
+			 * - msg_prio is less than 0.
+			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
+			 *   msg_prio is greater than the priority of the calling process.
+			 */
+			sif::error << "MessageQueue::sendMessage: Configuration error "
+			           << strerror(errno) << " in mq_send" << std::endl;
+			/*NO BREAK*/
+		case EMSGSIZE:
+			// The msg_len is greater than the msgsize associated with
+			//the specified queue.
+			sif::error << "MessageQueue::sendMessage: Size error [" <<
+					strerror(errno) << "] in mq_send" << std::endl;
+			/*NO BREAK*/
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index 35d16e25..c0b77019 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,187 +1,187 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
-
-#include <mqueue.h>
-/**
- * @brief		This class manages sending and receiving of message queue messages.
- *
- * @details
- * Message queues are used to pass asynchronous messages between processes.
- * They work like post boxes, where all incoming messages are stored in FIFO
- * order. This class creates a new receiving queue and provides methods to fetch
- * received messages. Being a child of MessageQueueSender, this class also
- * provides methods to send a message to a user-defined or a default destination.
- * In addition it also provides a reply method to answer to the queue it
- * received its last message from.
- *
- * The MessageQueue should be used as "post box" for a single owning object.
- * So all message queue communication is "n-to-one".
- *
- * The creation of message queues, as well as sending and receiving messages,
- * makes use of the operating system calls provided.
- *	@ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-	friend class MessageQueueSenderIF;
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
-	 * 			and initialized. The message depth - the maximum number of messages to be
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
-	 * 			automatically set to the maximum message queue message size. The operating system
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
-	 * 						sender. Default is three.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
-	 * 							This should be left default.
-	 */
-	MessageQueue(uint32_t messageDepth = 3,
-			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
-	 */
-	virtual ~MessageQueue();
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false );
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply( MessageQueueMessageIF* message );
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-protected:
-	/**
-	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
-	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
-			bool ignoreFault=false);
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * The name of the message queue, stored for unlinking
-	 */
-	char name[16];
-
-	static uint16_t queueCounter;
-	const size_t maxMessageSize;
-
-	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+
+#include <mqueue.h>
+/**
+ * @brief		This class manages sending and receiving of message queue messages.
+ *
+ * @details
+ * Message queues are used to pass asynchronous messages between processes.
+ * They work like post boxes, where all incoming messages are stored in FIFO
+ * order. This class creates a new receiving queue and provides methods to fetch
+ * received messages. Being a child of MessageQueueSender, this class also
+ * provides methods to send a message to a user-defined or a default destination.
+ * In addition it also provides a reply method to answer to the queue it
+ * received its last message from.
+ *
+ * The MessageQueue should be used as "post box" for a single owning object.
+ * So all message queue communication is "n-to-one".
+ *
+ * The creation of message queues, as well as sending and receiving messages,
+ * makes use of the operating system calls provided.
+ *	@ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+	friend class MessageQueueSenderIF;
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details	By making use of the according operating system call, a message queue is created
+	 * 			and initialized. The message depth - the maximum number of messages to be
+	 * 			buffered - may be set with the help of a parameter, whereas the message size is
+	 * 			automatically set to the maximum message queue message size. The operating system
+	 * 			sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth	The number of messages to be buffered before passing an error to the
+	 * 						sender. Default is three.
+	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
+	 * 							This should be left default.
+	 */
+	MessageQueue(uint32_t messageDepth = 3,
+			size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 */
+	virtual ~MessageQueue();
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false );
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply( MessageQueueMessageIF* message );
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * 			message's content is cleared and the function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false );
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+protected:
+	/**
+	 * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
+	 * 	 \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE,
+			bool ignoreFault=false);
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * The name of the message queue, stored for unlinking
+	 */
+	char name[16];
+
+	static uint16_t queueCounter;
+	const size_t maxMessageSize;
+
+	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 20be8aee..2ecae0cb 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,111 +1,111 @@
-#include "../../osal/linux/Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Clock.h"
-
-uint8_t Mutex::count = 0;
-
-
-#include <cstring>
-#include <errno.h>
-
-Mutex::Mutex() {
-	pthread_mutexattr_t mutexAttr;
-	int status = pthread_mutexattr_init(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
-	}
-	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
-				<< std::endl;
-	}
-	status = pthread_mutex_init(&mutex, &mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
-				<< ", " << " failed with " << strerror(status) << std::endl;
-	}
-	// After a mutex attributes object has been used to initialize one or more
-	// mutexes, any function affecting the attributes object
-	// (including destruction) shall not affect any previously initialized mutexes.
-	status = pthread_mutexattr_destroy(&mutexAttr);
-	if (status != 0) {
-		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	//No Status check yet
-	pthread_mutex_destroy(&mutex);
-}
-
-ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	int status = 0;
-
-	if(timeoutType == TimeoutType::POLLING) {
-	    status = pthread_mutex_trylock(&mutex);
-	}
-	else if (timeoutType == TimeoutType::WAITING) {
-		timespec timeOut;
-		clock_gettime(CLOCK_REALTIME, &timeOut);
-		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
-		nseconds += timeoutMs * 1000000;
-		timeOut.tv_sec = nseconds / 1000000000;
-		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
-		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	}
-	else if(timeoutType == TimeoutType::BLOCKING) {
-		status = pthread_mutex_lock(&mutex);
-	}
-
-	switch (status) {
-	case EINVAL:
-		// The mutex was created with the protocol attribute having the value
-		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
-		// than the mutex's current priority ceiling.
-		return WRONG_ATTRIBUTE_SETTING;
-		// The process or thread would have blocked, and the abs_timeout
-		// parameter specified a nanoseconds field value less than zero or
-		// greater than or equal to 1000 million.
-		// The value specified by mutex does not refer to an initialized mutex object.
-		//return MUTEX_NOT_FOUND;
-	case EBUSY:
-		// The mutex could not be acquired because it was already locked.
-		return MUTEX_ALREADY_LOCKED;
-	case ETIMEDOUT:
-		// The mutex could not be locked before the specified timeout expired.
-		return MUTEX_TIMEOUT;
-	case EAGAIN:
-		// The mutex could not be acquired because the maximum number of
-		// recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EDEADLK:
-		// A deadlock condition was detected or the current thread
-		// already owns the mutex.
-		return CURR_THREAD_ALREADY_OWNS_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	int status = pthread_mutex_unlock(&mutex);
-	switch (status) {
-	case EINVAL:
-		//The value specified by mutex does not refer to an initialized mutex object.
-		return MUTEX_NOT_FOUND;
-	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
-		return MUTEX_MAX_LOCKS;
-	case EPERM:
-		//The current thread does not own the mutex.
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case 0:
-		//Success
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	};
-}
+#include "../../osal/linux/Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Clock.h"
+
+uint8_t Mutex::count = 0;
+
+
+#include <cstring>
+#include <errno.h>
+
+Mutex::Mutex() {
+	pthread_mutexattr_t mutexAttr;
+	int status = pthread_mutexattr_init(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+	}
+	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
+				<< std::endl;
+	}
+	status = pthread_mutex_init(&mutex, &mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
+				<< ", " << " failed with " << strerror(status) << std::endl;
+	}
+	// After a mutex attributes object has been used to initialize one or more
+	// mutexes, any function affecting the attributes object
+	// (including destruction) shall not affect any previously initialized mutexes.
+	status = pthread_mutexattr_destroy(&mutexAttr);
+	if (status != 0) {
+		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	//No Status check yet
+	pthread_mutex_destroy(&mutex);
+}
+
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
+	int status = 0;
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	else if (timeoutType == TimeoutType::WAITING) {
+		timespec timeOut;
+		clock_gettime(CLOCK_REALTIME, &timeOut);
+		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+		nseconds += timeoutMs * 1000000;
+		timeOut.tv_sec = nseconds / 1000000000;
+		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+		status = pthread_mutex_timedlock(&mutex, &timeOut);
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
+		status = pthread_mutex_lock(&mutex);
+	}
+
+	switch (status) {
+	case EINVAL:
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
+		return WRONG_ATTRIBUTE_SETTING;
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
+		//return MUTEX_NOT_FOUND;
+	case EBUSY:
+		// The mutex could not be acquired because it was already locked.
+		return MUTEX_ALREADY_LOCKED;
+	case ETIMEDOUT:
+		// The mutex could not be locked before the specified timeout expired.
+		return MUTEX_TIMEOUT;
+	case EAGAIN:
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EDEADLK:
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
+		return CURR_THREAD_ALREADY_OWNS_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	int status = pthread_mutex_unlock(&mutex);
+	switch (status) {
+	case EINVAL:
+		//The value specified by mutex does not refer to an initialized mutex object.
+		return MUTEX_NOT_FOUND;
+	case EAGAIN:
+		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		return MUTEX_MAX_LOCKS;
+	case EPERM:
+		//The current thread does not own the mutex.
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case 0:
+		//Success
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	};
+}
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 77a11fe4..3acb6d90 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,22 +1,22 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-
-extern "C" {
-#include <pthread.h>
-}
-
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
-	virtual ReturnValue_t unlockMutex();
-private:
-	pthread_mutex_t mutex;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+
+extern "C" {
+#include <pthread.h>
+}
+
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	virtual ~Mutex();
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
+	virtual ReturnValue_t unlockMutex();
+private:
+	pthread_mutex_t mutex;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index 70dc3c71..73ab10a2 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,23 +1,23 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/linux/Mutex.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "../../osal/linux/Mutex.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index c0a29f47..bbf33b01 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,83 +1,83 @@
-#include "../../tasks/ExecutableObjectIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-
-#include <errno.h>
-
-PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
-		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
-		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
-		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
-}
-
-PeriodicPosixTask::~PeriodicPosixTask() {
-	//Not Implemented
-}
-
-void* PeriodicPosixTask::taskEntryPoint(void* arg) {
-	//The argument is re-interpreted as PollingTask.
-	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	return NULL;
-}
-
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implements ExecutableObjectIF" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	newObject->setTaskIF(this);
-
-	return newObject->initializeAfterTaskCreation();
-}
-
-ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
-	return PosixThread::sleep((uint64_t)ms*1000000);
-}
-
-
-ReturnValue_t PeriodicPosixTask::startTask(void) {
-	started = true;
-	//sif::info << stackSize << std::endl;
-	PosixThread::createTask(&taskEntryPoint,this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PeriodicPosixTask::taskFunctionality(void) {
-	if(!started){
-		suspend();
-	}
-
-	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
-			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status == 0){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
-			}
-			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
-			}
-			if (this->deadlineMissedFunc != nullptr) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-uint32_t PeriodicPosixTask::getPeriodMs() const {
-	return periodMs;
-}
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+
+#include <errno.h>
+
+PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
+		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
+		periodMs(period_), deadlineMissedFunc(deadlineMissedFunc_) {
+}
+
+PeriodicPosixTask::~PeriodicPosixTask() {
+	//Not Implemented
+}
+
+void* PeriodicPosixTask::taskEntryPoint(void* arg) {
+	//The argument is re-interpreted as PollingTask.
+	PeriodicPosixTask *originalTask(reinterpret_cast<PeriodicPosixTask*>(arg));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	return NULL;
+}
+
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == nullptr) {
+	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+	            "it implements ExecutableObjectIF" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	newObject->setTaskIF(this);
+
+	return newObject->initializeAfterTaskCreation();
+}
+
+ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
+	return PosixThread::sleep((uint64_t)ms*1000000);
+}
+
+
+ReturnValue_t PeriodicPosixTask::startTask(void) {
+	started = true;
+	//sif::info << stackSize << std::endl;
+	PosixThread::createTask(&taskEntryPoint,this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PeriodicPosixTask::taskFunctionality(void) {
+	if(!started){
+		suspend();
+	}
+
+	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+			char name[20] = {0};
+			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
+			if(status == 0){
+				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
+				//		"missed." << std::endl;
+			}
+			else {
+				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+				//		status << std::endl;
+			}
+			if (this->deadlineMissedFunc != nullptr) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+uint32_t PeriodicPosixTask::getPeriodMs() const {
+	return periodMs;
+}
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 59302e43..38825bbf 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
-
-#include "../../tasks/PeriodicTaskIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../osal/linux/PosixThread.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include <vector>
-
-class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
-public:
-	/**
-	 * Create a generic periodic task.
-	 * @param name_
-	 * Name, maximum allowed size of linux is 16 chars, everything else will
-	 * be truncated.
-	 * @param priority_
-	 * Real-time priority, ranges from 1 to 99 for Linux.
-	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
-	 * @param stackSize_
-	 * @param period_
-	 * @param deadlineMissedFunc_
-	 */
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
-			uint32_t period_, void(*deadlineMissedFunc_)());
-	virtual ~PeriodicPosixTask();
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void) override;
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object) override;
-
-	uint32_t getPeriodMs() const override;
-
-	ReturnValue_t sleepFor(uint32_t ms) override;
-
-private:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-
-	/**
-	 * @brief Flag to indicate that the task was started and is allowed to run
-	 */
-	bool started;
-
-
-	/**
-	 * @brief Period of the task in milliseconds
-	 */
-	uint32_t periodMs;
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details	The method sets and starts
-	 * 			the task's period, then enters a loop that is repeated indefinitely. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the task will be blocked until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	virtual void taskFunctionality(void);
-	/**
-	 * @brief	This is the entry point in a new thread.
-	 *
-	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
-	 * 			Needs a valid pointer to the derived class.
-	 */
-	static void* taskEntryPoint(void* arg);
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
-	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
-	 * 			of the periodic task.
-	 */
-	void (*deadlineMissedFunc)();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+#define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
+
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../osal/linux/PosixThread.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include <vector>
+
+class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
+public:
+	/**
+	 * Create a generic periodic task.
+	 * @param name_
+	 * Name, maximum allowed size of linux is 16 chars, everything else will
+	 * be truncated.
+	 * @param priority_
+	 * Real-time priority, ranges from 1 to 99 for Linux.
+	 * See: https://man7.org/linux/man-pages/man7/sched.7.html
+	 * @param stackSize_
+	 * @param period_
+	 * @param deadlineMissedFunc_
+	 */
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
+	virtual ~PeriodicPosixTask();
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void) override;
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object) override;
+
+	uint32_t getPeriodMs() const override;
+
+	ReturnValue_t sleepFor(uint32_t ms) override;
+
+private:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+
+	/**
+	 * @brief Flag to indicate that the task was started and is allowed to run
+	 */
+	bool started;
+
+
+	/**
+	 * @brief Period of the task in milliseconds
+	 */
+	uint32_t periodMs;
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details	The method sets and starts
+	 * 			the task's period, then enters a loop that is repeated indefinitely. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the task will be blocked until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	virtual void taskFunctionality(void);
+	/**
+	 * @brief	This is the entry point in a new thread.
+	 *
+	 * @details	This method, that is the entry point in the new thread and calls taskFunctionality of the child class.
+	 * 			Needs a valid pointer to the derived class.
+	 */
+	static void* taskEntryPoint(void* arg);
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
+	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
+	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
+	 * 			of the periodic task.
+	 */
+	void (*deadlineMissedFunc)();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ */
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 70c63c4a..f6ace380 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,217 +1,217 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PosixThread.h"
-#include <cstring>
-#include <errno.h>
-
-PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0),priority(priority_),stackSize(stackSize_) {
-    name[0] = '\0';
-    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
-}
-
-PosixThread::~PosixThread() {
-	//No deletion and no free of Stack Pointer
-}
-
-ReturnValue_t PosixThread::sleep(uint64_t ns) {
-	//TODO sleep might be better with timer instead of sleep()
-	timespec time;
-	time.tv_sec = ns/1000000000;
-	time.tv_nsec = ns - time.tv_sec*1e9;
-
-	//Remaining Time is not set here
-	int status = nanosleep(&time,NULL);
-	if(status != 0){
-		switch(errno){
-		case EINTR:
-			//The nanosleep() function was interrupted by a signal.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or
-			// greater than or equal to 1000 million.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PosixThread::suspend() {
-	//Wait for SIGUSR1
-	int caughtSig = 0;
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	sigwait(&waitSignal, &caughtSig);
-	if (caughtSig != SIGUSR1) {
-		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
-				caughtSig << std::endl;
-	}
-}
-
-void PosixThread::resume(){
-	/* Signal the thread to start. Makes sense to call kill to start or? ;)
-	 *
-	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
-	*	but as the call must be done from the thread itsself this is not possible here
-	*/
-	pthread_kill(thread,SIGUSR1);
-}
-
-bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
-		const uint64_t delayTime_ms) {
-	uint64_t nextTimeToWake_ms;
-	bool shouldDelay = false;
-	//Get current Time
-	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
-	/* Generate the tick time at which the task wants to wake. */
-	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
-
-	if (currentTime_ms < *prevoiusWakeTime_ms) {
-		/* The tick count has overflowed since this function was
-		 lasted called.  In this case the only time we should ever
-		 actually delay is if the wake time has also	overflowed,
-		 and the wake time is greater than the tick time.  When this
-		 is the case it is as if neither time had overflowed. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				&& (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	} else {
-		/* The tick time has not overflowed.  In this case we will
-		 delay if either the wake time has overflowed, and/or the
-		 tick time is less than the wake time. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				|| (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
-		}
-	}
-
-	/* Update the wake time ready for the next call. */
-
-	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
-
-	if (shouldDelay) {
-		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
-		PosixThread::sleep(sleepTime * 1000000ull);
-		return true;
-	}
-	//We are shifting the time in case the deadline was missed like rtems
-	(*prevoiusWakeTime_ms) = currentTime_ms;
-	return false;
-
-}
-
-
-uint64_t PosixThread::getCurrentMonotonicTimeMs(){
-	timespec timeNow;
-	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
-	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
-				+ timeNow.tv_nsec / 1000000;
-
-	return currentTime_ms;
-}
-
-
-void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-	//sif::debug << "PosixThread::createTask" << std::endl;
-	/*
-	 * The attr argument points to a pthread_attr_t structure whose contents
-       are used at thread creation time to determine attributes for the new
-       thread; this structure is initialized using pthread_attr_init(3) and
-       related functions.  If attr is NULL, then the thread is created with
-       default attributes.
-	 */
-	pthread_attr_t attributes;
-	int status = pthread_attr_init(&attributes);
-	if(status != 0){
-		sif::error << "Posix Thread attribute init failed with: " <<
-				strerror(status) << std::endl;
-	}
-	void* stackPointer;
-	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: Stack init failed with: " <<
-				strerror(status) << std::endl;
-		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
-			sif::error << "PosixThread::createTask: Insufficient memory for"
-					" the requested " << stackMb << " MB" << std::endl;
-		}
-		else if(errno == EINVAL) {
-			sif::error << "PosixThread::createTask: Wrong alignment argument!"
-					<< std::endl;
-		}
-		return;
-	}
-
-	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: pthread_attr_setstack "
-				" failed with: " << strerror(status) <<  std::endl;
-		sif::error << "Make sure the specified stack size is valid and is "
-				"larger than the minimum allowed stack size." << std::endl;
-	}
-
-	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
-	if(status != 0){
-			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
-					strerror(status) << std::endl;
-	}
-
-	// TODO FIFO -> This needs root privileges for the process
-	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule policy failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	sched_param scheduleParams;
-	scheduleParams.__sched_priority = priority;
-	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-	if(status != 0){
-		sif::error << "Posix Thread attribute schedule params failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	//Set Signal Mask for suspend until startTask is called
-	sigset_t waitSignal;
-	sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
-	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
-	if(status != 0){
-		sif::error << "Posix Thread sigmask failed failed with: " <<
-				strerror(status) << " errno: " << strerror(errno) << std::endl;
-	}
-
-
-	status = pthread_create(&thread,&attributes,fnc_,arg_);
-	if(status != 0){
-		sif::error << "Posix Thread create failed with: " <<
-				strerror(status) << std::endl;
-	}
-
-	status = pthread_setname_np(thread,name);
-	if(status != 0){
-		sif::error << "PosixThread::createTask: setname failed with: " <<
-				strerror(status) << std::endl;
-		if(status == ERANGE) {
-			sif::error << "PosixThread::createTask: Task name length longer"
-					" than 16 chars. Truncating.." << std::endl;
-			name[15] = '\0';
-			status = pthread_setname_np(thread,name);
-			if(status != 0){
-				sif::error << "PosixThread::createTask: Setting name"
-						" did not work.." << std::endl;
-			}
-		}
-	}
-
-	status = pthread_attr_destroy(&attributes);
-	if(status!=0){
-		sif::error << "Posix Thread attribute destroy failed with: " <<
-				strerror(status) << std::endl;
-	}
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../osal/linux/PosixThread.h"
+#include <cstring>
+#include <errno.h>
+
+PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
+		thread(0),priority(priority_),stackSize(stackSize_) {
+    name[0] = '\0';
+    std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
+}
+
+PosixThread::~PosixThread() {
+	//No deletion and no free of Stack Pointer
+}
+
+ReturnValue_t PosixThread::sleep(uint64_t ns) {
+	//TODO sleep might be better with timer instead of sleep()
+	timespec time;
+	time.tv_sec = ns/1000000000;
+	time.tv_nsec = ns - time.tv_sec*1e9;
+
+	//Remaining Time is not set here
+	int status = nanosleep(&time,NULL);
+	if(status != 0){
+		switch(errno){
+		case EINTR:
+			//The nanosleep() function was interrupted by a signal.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case EINVAL:
+			//The rqtp argument specified a nanosecond value less than zero or
+			// greater than or equal to 1000 million.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PosixThread::suspend() {
+	//Wait for SIGUSR1
+	int caughtSig = 0;
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	sigwait(&waitSignal, &caughtSig);
+	if (caughtSig != SIGUSR1) {
+		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+				caughtSig << std::endl;
+	}
+}
+
+void PosixThread::resume(){
+	/* Signal the thread to start. Makes sense to call kill to start or? ;)
+	 *
+	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
+	*	but as the call must be done from the thread itsself this is not possible here
+	*/
+	pthread_kill(thread,SIGUSR1);
+}
+
+bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
+		const uint64_t delayTime_ms) {
+	uint64_t nextTimeToWake_ms;
+	bool shouldDelay = false;
+	//Get current Time
+	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
+	/* Generate the tick time at which the task wants to wake. */
+	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
+
+	if (currentTime_ms < *prevoiusWakeTime_ms) {
+		/* The tick count has overflowed since this function was
+		 lasted called.  In this case the only time we should ever
+		 actually delay is if the wake time has also	overflowed,
+		 and the wake time is greater than the tick time.  When this
+		 is the case it is as if neither time had overflowed. */
+		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+				&& (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	} else {
+		/* The tick time has not overflowed.  In this case we will
+		 delay if either the wake time has overflowed, and/or the
+		 tick time is less than the wake time. */
+		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+				|| (nextTimeToWake_ms > currentTime_ms)) {
+			shouldDelay = true;
+		}
+	}
+
+	/* Update the wake time ready for the next call. */
+
+	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
+
+	if (shouldDelay) {
+		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
+		PosixThread::sleep(sleepTime * 1000000ull);
+		return true;
+	}
+	//We are shifting the time in case the deadline was missed like rtems
+	(*prevoiusWakeTime_ms) = currentTime_ms;
+	return false;
+
+}
+
+
+uint64_t PosixThread::getCurrentMonotonicTimeMs(){
+	timespec timeNow;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
+	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
+				+ timeNow.tv_nsec / 1000000;
+
+	return currentTime_ms;
+}
+
+
+void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+	//sif::debug << "PosixThread::createTask" << std::endl;
+	/*
+	 * The attr argument points to a pthread_attr_t structure whose contents
+       are used at thread creation time to determine attributes for the new
+       thread; this structure is initialized using pthread_attr_init(3) and
+       related functions.  If attr is NULL, then the thread is created with
+       default attributes.
+	 */
+	pthread_attr_t attributes;
+	int status = pthread_attr_init(&attributes);
+	if(status != 0){
+		sif::error << "Posix Thread attribute init failed with: " <<
+				strerror(status) << std::endl;
+	}
+	void* stackPointer;
+	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: Stack init failed with: " <<
+				strerror(status) << std::endl;
+		if(errno == ENOMEM) {
+			uint64_t stackMb = stackSize/10e6;
+			sif::error << "PosixThread::createTask: Insufficient memory for"
+					" the requested " << stackMb << " MB" << std::endl;
+		}
+		else if(errno == EINVAL) {
+			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+					<< std::endl;
+		}
+		return;
+	}
+
+	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+				" failed with: " << strerror(status) <<  std::endl;
+		sif::error << "Make sure the specified stack size is valid and is "
+				"larger than the minimum allowed stack size." << std::endl;
+	}
+
+	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
+	if(status != 0){
+			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+					strerror(status) << std::endl;
+	}
+
+	// TODO FIFO -> This needs root privileges for the process
+	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	sched_param scheduleParams;
+	scheduleParams.__sched_priority = priority;
+	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+	if(status != 0){
+		sif::error << "Posix Thread attribute schedule params failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	//Set Signal Mask for suspend until startTask is called
+	sigset_t waitSignal;
+	sigemptyset(&waitSignal);
+	sigaddset(&waitSignal, SIGUSR1);
+	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
+	if(status != 0){
+		sif::error << "Posix Thread sigmask failed failed with: " <<
+				strerror(status) << " errno: " << strerror(errno) << std::endl;
+	}
+
+
+	status = pthread_create(&thread,&attributes,fnc_,arg_);
+	if(status != 0){
+		sif::error << "Posix Thread create failed with: " <<
+				strerror(status) << std::endl;
+	}
+
+	status = pthread_setname_np(thread,name);
+	if(status != 0){
+		sif::error << "PosixThread::createTask: setname failed with: " <<
+				strerror(status) << std::endl;
+		if(status == ERANGE) {
+			sif::error << "PosixThread::createTask: Task name length longer"
+					" than 16 chars. Truncating.." << std::endl;
+			name[15] = '\0';
+			status = pthread_setname_np(thread,name);
+			if(status != 0){
+				sif::error << "PosixThread::createTask: Setting name"
+						" did not work.." << std::endl;
+			}
+		}
+	}
+
+	status = pthread_attr_destroy(&attributes);
+	if(status!=0){
+		sif::error << "Posix Thread attribute destroy failed with: " <<
+				strerror(status) << std::endl;
+	}
+}
diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h
index 9d6097f7..7d8d349a 100644
--- a/osal/linux/PosixThread.h
+++ b/osal/linux/PosixThread.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <pthread.h>
-#include <signal.h>
-#include <cstdlib>
-#include <unistd.h>
-
-class PosixThread {
-public:
-	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-	PosixThread(const char* name_, int priority_, size_t stackSize_);
-	virtual ~PosixThread();
-	/**
-	 * Set the Thread to sleep state
-	 * @param ns Nanosecond sleep time
-	 * @return Returns Failed if sleep fails
-	 */
-	static ReturnValue_t sleep(uint64_t ns);
-	/**
-	 * @brief Function to suspend the task until SIGUSR1 was received
-	 *
-	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
-	 */
-	void suspend();
-
-	/**
-	 * @brief Function to allow a other thread to start the thread again from suspend state
-	 *
-	 * @details Restarts the Thread after suspend call
-	 */
-	void resume();
-
-
-	/**
-	 * Delay function similar to FreeRtos delayUntil function
-	 *
-	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
-	 * @param delayTime_ms Time period to delay
-	 *
-	 * @return False If deadline was missed; True if task was delayed
-	 */
-	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
-
-	/**
-	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
-	 *
-	 * @return current time in milliseconds from CLOCK_MONOTONIC
-	 */
-	static uint64_t getCurrentMonotonicTimeMs();
-
-protected:
-	pthread_t thread;
-
-	/**
-	 * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument.
-	 * @details
-	 * This function creates a pthread with the given parameters. As the
-	 * function requires a pointer to the derived object it has to be called
-	 * after the this pointer of the derived object is valid.
-	 * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param fnc_ Function which will be executed by the thread.
-	 * @param arg_
-	 * argument of the taskEntryPoint function, needs to be this pointer
-	 * of derived class
-	 */
-	void createTask(void* (*fnc_)(void*),void* arg_);
-
-private:
-	char name[PTHREAD_MAX_NAMELEN];
-	int priority;
-	size_t stackSize = 0;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+#define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <pthread.h>
+#include <signal.h>
+#include <cstdlib>
+#include <unistd.h>
+
+class PosixThread {
+public:
+	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
+	PosixThread(const char* name_, int priority_, size_t stackSize_);
+	virtual ~PosixThread();
+	/**
+	 * Set the Thread to sleep state
+	 * @param ns Nanosecond sleep time
+	 * @return Returns Failed if sleep fails
+	 */
+	static ReturnValue_t sleep(uint64_t ns);
+	/**
+	 * @brief Function to suspend the task until SIGUSR1 was received
+	 *
+	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
+	 */
+	void suspend();
+
+	/**
+	 * @brief Function to allow a other thread to start the thread again from suspend state
+	 *
+	 * @details Restarts the Thread after suspend call
+	 */
+	void resume();
+
+
+	/**
+	 * Delay function similar to FreeRtos delayUntil function
+	 *
+	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
+	 * @param delayTime_ms Time period to delay
+	 *
+	 * @return False If deadline was missed; True if task was delayed
+	 */
+	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
+
+	/**
+	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
+	 *
+	 * @return current time in milliseconds from CLOCK_MONOTONIC
+	 */
+	static uint64_t getCurrentMonotonicTimeMs();
+
+protected:
+	pthread_t thread;
+
+	/**
+	 * @brief 	Function that has to be called by derived class because the
+	 *  		derived class pointer has to be valid as argument.
+	 * @details
+	 * This function creates a pthread with the given parameters. As the
+	 * function requires a pointer to the derived object it has to be called
+	 * after the this pointer of the derived object is valid.
+	 * Sets the taskEntryPoint as function to be called by new a thread.
+	 * @param fnc_ Function which will be executed by the thread.
+	 * @param arg_
+	 * argument of the taskEntryPoint function, needs to be this pointer
+	 * of derived class
+	 */
+	void createTask(void* (*fnc_)(void*),void* arg_);
+
+private:
+	char name[PTHREAD_MAX_NAMELEN];
+	int priority;
+	size_t stackSize = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index d1332504..fb8f6df7 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,38 +1,38 @@
-#include "../../ipc/QueueFactory.h"
-#include <mqueue.h>
-#include <errno.h>
-#include "../../osal/linux/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-QueueFactory* QueueFactory::factoryInstance = nullptr;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault) {
-	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
-			sentFrom,ignoreFault);
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == nullptr) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include <mqueue.h>
+#include <errno.h>
+#include "../../osal/linux/MessageQueue.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+QueueFactory* QueueFactory::factoryInstance = nullptr;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault) {
+	return MessageQueue::sendMessageFromMessageQueue(sendTo,message,
+			sentFrom,ignoreFault);
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == nullptr) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index bcb5d16f..e4710933 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,33 +1,33 @@
-#include "../../tasks/SemaphoreFactory.h"
-#include "BinarySemaphore.h"
-#include "CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-
-SemaphoreFactory::SemaphoreFactory() {
-}
-
-SemaphoreFactory::~SemaphoreFactory() {
-	delete factoryInstance;
-}
-
-SemaphoreFactory* SemaphoreFactory::instance() {
-	if (factoryInstance == nullptr){
-		factoryInstance = new SemaphoreFactory();
-	}
-	return SemaphoreFactory::factoryInstance;
-}
-
-SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
-	return new BinarySemaphore();
-}
-
-SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
-		uint8_t initCount, uint32_t arguments) {
-	return new CountingSemaphore(maxCount, initCount);
-}
-
-void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
-	delete semaphore;
-}
+#include "../../tasks/SemaphoreFactory.h"
+#include "BinarySemaphore.h"
+#include "CountingSemaphore.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
+	return new BinarySemaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
+		uint8_t initCount, uint32_t arguments) {
+	return new CountingSemaphore(maxCount, initCount);
+}
+
+void SemaphoreFactory::deleteSemaphore(SemaphoreIF* semaphore) {
+	delete semaphore;
+}
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index 1cd0b2b1..a25b817d 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,42 +1,42 @@
-#include "../../osal/linux/FixedTimeslotTask.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-#include "../../tasks/TaskFactory.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_ * 1000, deadLineMissedFunction_);
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
-		TaskPriority taskPriority_,TaskStackSize stackSize_,
-		TaskPeriod periodInSeconds_,
-		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
-			periodInSeconds_*1000);
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	return PosixThread::sleep(delayMs*1000000ull);
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../osal/linux/FixedTimeslotTask.h"
+#include "../../osal/linux/PeriodicPosixTask.h"
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new PeriodicPosixTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_ * 1000, deadLineMissedFunction_);
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
+		TaskPriority taskPriority_,TaskStackSize stackSize_,
+		TaskPeriod periodInSeconds_,
+		TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	return new FixedTimeslotTask(name_, taskPriority_,stackSize_,
+			periodInSeconds_*1000);
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	return PosixThread::sleep(delayMs*1000000ull);
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 04c1d255..d8a39869 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,137 +1,137 @@
-#include "../../osal/linux/TcUnixUdpPollingTask.h"
-#include "../../globalfunctions/arrayprinter.h"
-
-TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
-		object_id_t tmtcUnixUdpBridge, size_t frameSize,
-		double timeoutSeconds): SystemObject(objectId),
-		tmtcBridgeId(tmtcUnixUdpBridge) {
-
-	if(frameSize > 0) {
-		this->frameSize = frameSize;
-	}
-	else {
-		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
-	}
-
-	// Set up reception buffer with specified frame size.
-	// For now, it is assumed that only one frame is held in the buffer!
-	receptionBuffer.reserve(this->frameSize);
-	receptionBuffer.resize(this->frameSize);
-
-	if(timeoutSeconds == -1) {
-		receptionTimeout = DEFAULT_TIMEOUT;
-	}
-	else {
-		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
-	}
-}
-
-TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
-
-ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
-	// Poll for new UDP datagrams in permanent loop.
-	while(1) {
-		//! Sender Address is cached here.
-		struct sockaddr_in senderAddress;
-		socklen_t senderSockLen = 0;
-		ssize_t bytesReceived = recvfrom(serverUdpSocket,
-				receptionBuffer.data(), frameSize, receptionFlags,
-				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
-		if(bytesReceived < 0) {
-			// handle error
-			sif::error << "TcSocketPollingTask::performOperation: Reception"
-					"error." << std::endl;
-			handleReadError();
-
-			continue;
-		}
-//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-//				<< " bytes received" << std::endl;
-
-		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
-		if(result != HasReturnvaluesIF::RETURN_FAILED) {
-
-		}
-		tmtcBridge->registerCommConnect();
-		tmtcBridge->checkAndSetClientAddress(senderAddress);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
-	store_address_t storeId;
-	ReturnValue_t result = tcStore->addData(&storeId,
-			receptionBuffer.data(), bytesRead);
-	// arrayprinter::print(receptionBuffer.data(), bytesRead);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
-				"storage failed" << std::endl;
-		sif::error << "Packet size: " << bytesRead << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	TmTcMessage message(storeId);
-
-	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "Serial Polling: Sending message to queue failed"
-				<< std::endl;
-		tcStore->deleteData(storeId);
-	}
-	return result;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == nullptr) {
-		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
-	if(tmtcBridge == nullptr) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
-				" TMTC bridge object!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	serverUdpSocket = tmtcBridge->serverSocket;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
-	// Initialize the destination after task creation. This ensures
-	// that the destination will be set in the TMTC bridge.
-	targetTcDestination = tmtcBridge->getRequestQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
-	timeval tval;
-	tval = timevalOperations::toTimeval(timeoutSeconds);
-	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
-			&tval, sizeof(receptionTimeout));
-	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
-				"receive timeout failed with " << strerror(errno) << std::endl;
-	}
-}
-
-void TcUnixUdpPollingTask::handleReadError() {
-	switch(errno) {
-	case(EAGAIN): {
-		// todo: When working in timeout mode, this will occur more often
-		// and is not an error.
-		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
-				<< std::endl;
-		break;
-	}
-	default: {
-		sif::error << "TcUnixUdpPollingTask::handleReadError: "
-				<< strerror(errno) << std::endl;
-	}
-	}
-}
+#include "../../osal/linux/TcUnixUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+
+TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+}
+
+TcUnixUdpPollingTask::~TcUnixUdpPollingTask() {}
+
+ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		socklen_t senderSockLen = 0;
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				receptionBuffer.data(), frameSize, receptionFlags,
+				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
+		if(bytesReceived < 0) {
+			// handle error
+			sif::error << "TcSocketPollingTask::performOperation: Reception"
+					"error." << std::endl;
+			handleReadError();
+
+			continue;
+		}
+//		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+//				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
+		tmtcBridge->registerCommConnect();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcUnixUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination will be set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
+	timeval tval;
+	tval = timevalOperations::toTimeval(timeoutSeconds);
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			&tval, sizeof(receptionTimeout));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+void TcUnixUdpPollingTask::handleReadError() {
+	switch(errno) {
+	case(EAGAIN): {
+		// todo: When working in timeout mode, this will occur more often
+		// and is not an error.
+		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
+				<< std::endl;
+		break;
+	}
+	default: {
+		sif::error << "TcUnixUdpPollingTask::handleReadError: "
+				<< strerror(errno) << std::endl;
+	}
+	}
+}
diff --git a/osal/linux/TcUnixUdpPollingTask.h b/osal/linux/TcUnixUdpPollingTask.h
index 9d678a81..cc032561 100644
--- a/osal/linux/TcUnixUdpPollingTask.h
+++ b/osal/linux/TcUnixUdpPollingTask.h
@@ -1,67 +1,67 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
-
-#include "../../objectmanager/SystemObject.h"
-#include "../../osal/linux/TmTcUnixUdpBridge.h"
-#include "../../tasks/ExecutableObjectIF.h"
-
-#include <sys/socket.h>
-#include <vector>
-
-/**
- * @brief 	This class can be used to implement the polling of a Unix socket,
- * 			using UDP for now.
- * @details
- * The task will be blocked while the specified number of bytes has not been
- * received, so TC reception is handled inside a separate task.
- * This class caches the IP address of the sender. It is assumed there
- * is only one sender for now.
- */
-class TcUnixUdpPollingTask: public SystemObject,
-		public ExecutableObjectIF {
-	friend class TmTcUnixUdpBridge;
-public:
-	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
-	//! 0.5  default milliseconds timeout for now.
-	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
-
-	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
-			size_t frameSize = 0, double timeoutSeconds = -1);
-	virtual~ TcUnixUdpPollingTask();
-
-	/**
-	 * Turn on optional timeout for UDP polling. In the default mode,
-	 * the receive function will block until a packet is received.
-	 * @param timeoutSeconds
-	 */
-	void setTimeout(double timeoutSeconds);
-
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual ReturnValue_t initialize() override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-protected:
-	StorageManagerIF* tcStore = nullptr;
-
-private:
-	//! TMTC bridge is cached.
-	object_id_t tmtcBridgeId = objects::NO_OBJECT;
-	TmTcUnixUdpBridge* tmtcBridge = nullptr;
-	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
-	//! Reception flags: https://linux.die.net/man/2/recvfrom.
-	int receptionFlags = 0;
-
-	//! Server socket, which is member of TMTC bridge and is assigned in
-	//! constructor
-	int serverUdpSocket = 0;
-
-	std::vector<uint8_t> receptionBuffer;
-
-	size_t frameSize = 0;
-	timeval receptionTimeout;
-
-	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
-	void handleReadError();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
+
+#include "../../objectmanager/SystemObject.h"
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "../../tasks/ExecutableObjectIF.h"
+
+#include <sys/socket.h>
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcUnixUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcUnixUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcUnixUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcUnixUdpPollingTask();
+
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcUnixUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	int serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
+	void handleReadError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index e4539521..b458fd90 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,42 +1,42 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <errno.h>
-#include "../../osal/linux/Timer.h"
-
-Timer::Timer() {
-	sigevent sigEvent;
-	sigEvent.sigev_notify = SIGEV_NONE;
-	sigEvent.sigev_signo = 0;
-	sigEvent.sigev_value.sival_ptr = &timerId;
-	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
-	if(status!=0){
-		sif::error << "Timer creation failed with: " << status <<
-				" errno: " << errno << std::endl;
-	}
-}
-
-Timer::~Timer() {
-	timer_delete(timerId);
-}
-
-int Timer::setTimer(uint32_t intervalMs) {
-	itimerspec timer;
-	timer.it_value.tv_sec = intervalMs / 1000;
-	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	return timer_settime(timerId, 0, &timer, NULL);
-}
-
-
-int Timer::getTimer(uint32_t* remainingTimeMs){
-	itimerspec timer;
-	timer.it_value.tv_sec = 0;
-	timer.it_value.tv_nsec = 0;
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	int status = timer_gettime(timerId, &timer);
-
-	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
-
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <errno.h>
+#include "../../osal/linux/Timer.h"
+
+Timer::Timer() {
+	sigevent sigEvent;
+	sigEvent.sigev_notify = SIGEV_NONE;
+	sigEvent.sigev_signo = 0;
+	sigEvent.sigev_value.sival_ptr = &timerId;
+	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
+	if(status!=0){
+		sif::error << "Timer creation failed with: " << status <<
+				" errno: " << errno << std::endl;
+	}
+}
+
+Timer::~Timer() {
+	timer_delete(timerId);
+}
+
+int Timer::setTimer(uint32_t intervalMs) {
+	itimerspec timer;
+	timer.it_value.tv_sec = intervalMs / 1000;
+	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	return timer_settime(timerId, 0, &timer, NULL);
+}
+
+
+int Timer::getTimer(uint32_t* remainingTimeMs){
+	itimerspec timer;
+	timer.it_value.tv_sec = 0;
+	timer.it_value.tv_nsec = 0;
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_nsec = 0;
+	int status = timer_gettime(timerId, &timer);
+
+	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
+
+	return status;
+}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 57722b3f..3e9674f3 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,168 +1,168 @@
-#include "../../osal/linux/TmTcUnixUdpBridge.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../ipc/MutexHelper.h"
-
-#include <errno.h>
-#include <arpa/inet.h>
-
-TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
-		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
-		uint16_t serverPort, uint16_t clientPort):
-		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
-	mutex = MutexFactory::instance()->createMutex();
-
-	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
-	if(serverPort != 0xFFFF) {
-		setServerPort = serverPort;
-	}
-
-	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
-	if(clientPort != 0xFFFF) {
-		setClientPort = clientPort;
-	}
-
-	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
-	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
-	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-	if(socket < 0) {
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
-				" UDP socket!" << std::endl;
-		handleSocketError();
-		return;
-	}
-
-	serverAddress.sin_family = AF_INET;
-
-	// Accept packets from any interface.
-	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
-	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	serverAddress.sin_port = htons(setServerPort);
-	serverAddressLen = sizeof(serverAddress);
-	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
-			sizeof(serverSocketOptions));
-
-	clientAddress.sin_family = AF_INET;
-	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	clientAddress.sin_port = htons(setClientPort);
-	clientAddressLen = sizeof(clientAddress);
-
-	int result = bind(serverSocket,
-			reinterpret_cast<struct sockaddr*>(&serverAddress),
-			serverAddressLen);
-	if(result == -1) {
-		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
-				"local port " << setServerPort << " to server socket!"
-				<< std::endl;
-		handleBindError();
-		return;
-	}
-}
-
-TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
-}
-
-ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
-	int flags = 0;
-
-	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
-	clientAddressLen = sizeof(serverAddress);
-
-//	char ipAddress [15];
-//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-
-	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
-			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
-	if(bytesSent < 0) {
-		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
-				<< std::endl;
-		handleSendError();
-	}
-//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
-//			" sent." << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
-	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
-
-//	char ipAddress [15];
-//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
-//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
-//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
-
-	// Set new IP address if it has changed.
-	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
-		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
-		clientAddressLen = sizeof(clientAddress);
-	}
-}
-
-void TmTcUnixUdpBridge::handleSocketError() {
-
-	// See: https://man7.org/linux/man-pages/man2/socket.2.html
-	switch(errno) {
-	case(EACCES):
-	case(EINVAL):
-	case(EMFILE):
-	case(ENFILE):
-	case(EAFNOSUPPORT):
-	case(ENOBUFS):
-	case(ENOMEM):
-	case(EPROTONOSUPPORT):
-		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-		break;
-	default:
-		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
-				<< std::endl;
-		break;
-	}
-}
-
-void TmTcUnixUdpBridge::handleBindError() {
-	// See: https://man7.org/linux/man-pages/man2/bind.2.html
-	switch(errno) {
-	case(EACCES): {
-		/*
-		 Ephermeral ports can be shown with following command:
-		 sysctl -A | grep ip_local_port_range
-		 */
-		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
-				"Ports 1-1024 are reserved on UNIX systems and require root "
-				"rights while ephermeral ports should not be used as well."
-				<< std::endl;
-	}
-	break;
-	case(EADDRINUSE):
-	case(EBADF):
-	case(EINVAL):
-	case(ENOTSOCK):
-	case(EADDRNOTAVAIL):
-	case(EFAULT):
-	case(ELOOP):
-	case(ENAMETOOLONG):
-	case(ENOENT):
-	case(ENOMEM):
-	case(ENOTDIR):
-	case(EROFS): {
-		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
-				<< " with " << strerror(errno) << std::endl;
-		break;
-	}
-	default:
-		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
-				<< std::endl;
-		break;
-	}
-}
-
-void TmTcUnixUdpBridge::handleSendError() {
-	switch(errno) {
-	default:
-		sif::error << "Error: " << strerror(errno) << std::endl;
-	}
-}
-
+#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../ipc/MutexHelper.h"
+
+#include <errno.h>
+#include <arpa/inet.h>
+
+TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
+		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+		uint16_t serverPort, uint16_t clientPort):
+		TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+	mutex = MutexFactory::instance()->createMutex();
+
+	uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+	if(serverPort != 0xFFFF) {
+		setServerPort = serverPort;
+	}
+
+	uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+	if(clientPort != 0xFFFF) {
+		setClientPort = clientPort;
+	}
+
+	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if(socket < 0) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+				" UDP socket!" << std::endl;
+		handleSocketError();
+		return;
+	}
+
+	serverAddress.sin_family = AF_INET;
+
+	// Accept packets from any interface.
+	//serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	serverAddress.sin_port = htons(setServerPort);
+	serverAddressLen = sizeof(serverAddress);
+	setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
+			sizeof(serverSocketOptions));
+
+	clientAddress.sin_family = AF_INET;
+	clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	clientAddress.sin_port = htons(setClientPort);
+	clientAddressLen = sizeof(clientAddress);
+
+	int result = bind(serverSocket,
+			reinterpret_cast<struct sockaddr*>(&serverAddress),
+			serverAddressLen);
+	if(result == -1) {
+		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+				"local port " << setServerPort << " to server socket!"
+				<< std::endl;
+		handleBindError();
+		return;
+	}
+}
+
+TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
+}
+
+ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+	int flags = 0;
+
+	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+	clientAddressLen = sizeof(serverAddress);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
+			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+	if(bytesSent < 0) {
+		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
+				<< std::endl;
+		handleSendError();
+	}
+//	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//			" sent." << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+//	char ipAddress [15];
+//	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+	// Set new IP address if it has changed.
+	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+		clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+		clientAddressLen = sizeof(clientAddress);
+	}
+}
+
+void TmTcUnixUdpBridge::handleSocketError() {
+
+	// See: https://man7.org/linux/man-pages/man2/socket.2.html
+	switch(errno) {
+	case(EACCES):
+	case(EINVAL):
+	case(EMFILE):
+	case(ENFILE):
+	case(EAFNOSUPPORT):
+	case(ENOBUFS):
+	case(ENOMEM):
+	case(EPROTONOSUPPORT):
+		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	default:
+		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleBindError() {
+	// See: https://man7.org/linux/man-pages/man2/bind.2.html
+	switch(errno) {
+	case(EACCES): {
+		/*
+		 Ephermeral ports can be shown with following command:
+		 sysctl -A | grep ip_local_port_range
+		 */
+		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
+				"Ports 1-1024 are reserved on UNIX systems and require root "
+				"rights while ephermeral ports should not be used as well."
+				<< std::endl;
+	}
+	break;
+	case(EADDRINUSE):
+	case(EBADF):
+	case(EINVAL):
+	case(ENOTSOCK):
+	case(EADDRNOTAVAIL):
+	case(EFAULT):
+	case(ELOOP):
+	case(ENAMETOOLONG):
+	case(ENOENT):
+	case(ENOMEM):
+	case(ENOTDIR):
+	case(EROFS): {
+		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
+				<< " with " << strerror(errno) << std::endl;
+		break;
+	}
+	default:
+		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
+				<< std::endl;
+		break;
+	}
+}
+
+void TmTcUnixUdpBridge::handleSendError() {
+	switch(errno) {
+	default:
+		sif::error << "Error: " << strerror(errno) << std::endl;
+	}
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index e4aa8b1a..5245c44c 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -1,48 +1,48 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
-
-#include "../../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../../tmtcservices/TmTcBridge.h"
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class TmTcUnixUdpBridge: public TmTcBridge {
-	friend class TcUnixUdpPollingTask;
-public:
-	// The ports chosen here should not be used by any other process.
-	// List of used ports on Linux: /etc/services
-	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
-	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
-
-	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
-			object_id_t tmStoreId, object_id_t tcStoreId,
-			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
-	virtual~ TmTcUnixUdpBridge();
-
-	void checkAndSetClientAddress(sockaddr_in clientAddress);
-
-protected:
-	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
-
-private:
-	int serverSocket = 0;
-
-	const int serverSocketOptions = 0;
-
-	struct sockaddr_in clientAddress;
-	socklen_t clientAddressLen = 0;
-
-	struct sockaddr_in serverAddress;
-	socklen_t serverAddressLen = 0;
-
-	//! Access to the client address is mutex protected as it is set
-	//! by another task.
-	MutexIF* mutex;
-
-	void handleSocketError();
-	void handleBindError();
-	void handleSendError();
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
+#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
+
+#include "../../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../../tmtcservices/TmTcBridge.h"
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class TmTcUnixUdpBridge: public TmTcBridge {
+	friend class TcUnixUdpPollingTask;
+public:
+	// The ports chosen here should not be used by any other process.
+	// List of used ports on Linux: /etc/services
+	static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+	static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+	TmTcUnixUdpBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId,
+			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+	virtual~ TmTcUnixUdpBridge();
+
+	void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+	int serverSocket = 0;
+
+	const int serverSocketOptions = 0;
+
+	struct sockaddr_in clientAddress;
+	socklen_t clientAddressLen = 0;
+
+	struct sockaddr_in serverAddress;
+	socklen_t serverAddressLen = 0;
+
+	//! Access to the client address is mutex protected as it is set
+	//! by another task.
+	MutexIF* mutex;
+
+	void handleSocketError();
+	void handleBindError();
+	void handleSendError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index 826d0b14..eeffd7f3 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,198 +1,198 @@
-#include "../../timemanager/Clock.h"
-#include "RtemsBasic.h"
-#include <rtems/score/todimpl.h>
-
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
-uint32_t Clock::getTicksPerSecond(void){
-	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-	return static_cast<uint32_t>(ticks_per_second);
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-	rtems_time_of_day timeRtems;
-	timeRtems.year = time->year;
-	timeRtems.month = time->month;
-	timeRtems.day = time->day;
-	timeRtems.hour = time->hour;
-	timeRtems.minute  = time->minute;
-	timeRtems.second = time->second;
-	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
-	rtems_status_code status = rtems_clock_set(&timeRtems);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_CLOCK:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
-	timespec newTime;
-	newTime.tv_sec = time->tv_sec;
-	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	//Callable from ISR
-	rtems_status_code status = rtems_clock_get_tod_timeval(time);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
-	timespec time;
-	rtems_status_code status = rtems_clock_get_uptime(&time);
-	uptime->tv_sec = time.tv_sec;
-	time.tv_nsec = time.tv_nsec / 1000;
-	uptime->tv_usec = time.tv_nsec;
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	//This counter overflows after 50 days
-	*uptimeMs = rtems_clock_get_ticks_since_boot();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval temp_time;
-	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-	switch(returnValue){
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
-	rtems_status_code status = rtems_clock_get_tod(timeRtems);
-	switch (status) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_DEFINED:
-		//system date and time is not set
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//time_buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	//Fails in 2038..
-	rtems_time_of_day timeRtems;
-	timeRtems.year = from->year;
-	timeRtems.month = from->month;
-	timeRtems.day = from->day;
-	timeRtems.hour = from->hour;
-	timeRtems.minute  = from->minute;
-	timeRtems.second = from->second;
-	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-	to->tv_sec = _TOD_To_seconds(&timeRtems);
-	to->tv_usec = from->usecond;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
-
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
-
-	timeval TAItoTT = { 32, 184000 };
-
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	leapSeconds = leapSeconds_;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	*leapSeconds_ = leapSeconds;
-
-	result = timeMutex->unlockMutex();
-	return result;
-}
-
-ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../../timemanager/Clock.h"
+#include "RtemsBasic.h"
+#include <rtems/score/todimpl.h>
+
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = NULL;
+
+uint32_t Clock::getTicksPerSecond(void){
+	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+	return static_cast<uint32_t>(ticks_per_second);
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+	rtems_time_of_day timeRtems;
+	timeRtems.year = time->year;
+	timeRtems.month = time->month;
+	timeRtems.day = time->day;
+	timeRtems.hour = time->hour;
+	timeRtems.minute  = time->minute;
+	timeRtems.second = time->second;
+	timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+	rtems_status_code status = rtems_clock_set(&timeRtems);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_CLOCK:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::setClock(const timeval* time) {
+	//TODO This routine uses _TOD_Set which is not
+	timespec newTime;
+	newTime.tv_sec = time->tv_sec;
+	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
+	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
+	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
+	//TODO Second parameter is ISR_lock_Context
+	_TOD_Set(&newTime,NULL);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_timeval(timeval* time) {
+	//Callable from ISR
+	rtems_status_code status = rtems_clock_get_tod_timeval(time);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(timeval* uptime) {
+	//According to docs.rtems.org for rtems 5 this method is more accurate than rtems_clock_get_ticks_since_boot
+	timespec time;
+	rtems_status_code status = rtems_clock_get_uptime(&time);
+	uptime->tv_sec = time.tv_sec;
+	time.tv_nsec = time.tv_nsec / 1000;
+	uptime->tv_usec = time.tv_nsec;
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
+	//This counter overflows after 50 days
+	*uptimeMs = rtems_clock_get_ticks_since_boot();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+	timeval temp_time;
+	rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
+	*time = ((uint64_t) temp_time.tv_sec * 1000000) + temp_time.tv_usec;
+	switch(returnValue){
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
+	rtems_status_code status = rtems_clock_get_tod(timeRtems);
+	switch (status) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_DEFINED:
+		//system date and time is not set
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//time_buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+		timeval* to) {
+	//Fails in 2038..
+	rtems_time_of_day timeRtems;
+	timeRtems.year = from->year;
+	timeRtems.month = from->month;
+	timeRtems.day = from->day;
+	timeRtems.hour = from->hour;
+	timeRtems.minute  = from->minute;
+	timeRtems.second = from->second;
+	timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
+	to->tv_sec = _TOD_To_seconds(&timeRtems);
+	to->tv_usec = from->usecond;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+			/ 3600.;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
+	//SHOULDDO: works not for dates in the past (might have less leap seconds)
+	if (timeMutex == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint16_t leapSeconds;
+	ReturnValue_t result = getLeapSeconds(&leapSeconds);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	timeval leapSeconds_timeval = { 0, 0 };
+	leapSeconds_timeval.tv_sec = leapSeconds;
+
+	//initial offset between UTC and TAI
+	timeval UTCtoTAI1972 = { 10, 0 };
+
+	timeval TAItoTT = { 32, 184000 };
+
+	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
+	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	leapSeconds = leapSeconds_;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+	if(timeMutex==NULL){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	*leapSeconds_ = leapSeconds;
+
+	result = timeMutex->unlockMutex();
+	return result;
+}
+
+ReturnValue_t Clock::checkOrCreateClockMutex(){
+	if(timeMutex==NULL){
+		MutexFactory* mutexFactory = MutexFactory::instance();
+		if (mutexFactory == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		timeMutex = mutexFactory->createMutex();
+		if (timeMutex == NULL) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index c5fac653..d49de4ad 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -1,183 +1,183 @@
-#include "CpuUsage.h"
-#include "../../serialize/SerialArrayListAdapter.h"
-#include "../../serialize/SerializeAdapter.h"
-#include <string.h>
-
-extern "C" {
-#include <rtems/cpuuse.h>
-}
-
-int handlePrint(void * token, const char *format, ...) {
-	CpuUsage *cpuUsage = (CpuUsage *) token;
-
-	if (cpuUsage->counter == 0) {
-		//header
-		cpuUsage->counter++;
-		return 0;
-	}
-
-	if (cpuUsage->counter % 2 == 1) {
-		{
-			//we can not tell when the last call is so we assume it be every uneven time
-			va_list vl;
-			va_start(vl, format);
-			float timeSinceLastReset = va_arg(vl,uint32_t);
-			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
-
-			timeSinceLastReset = timeSinceLastReset
-					+ (timeSinceLastResetDecimals / 1000.);
-
-			cpuUsage->timeSinceLastReset = timeSinceLastReset;
-
-			va_end(vl);
-		}
-		//task name and id
-		va_list vl;
-		va_start(vl, format);
-
-		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
-		const char *name = va_arg(vl,const char *);
-		memcpy(cpuUsage->cachedValue.name, name,
-				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
-
-		va_end(vl);
-
-	} else {
-		//statistics
-		va_list vl;
-		va_start(vl, format);
-		float run = va_arg(vl,uint32_t);
-		uint32_t runDecimals = va_arg(vl,uint32_t);
-		float percent = va_arg(vl,uint32_t);
-		uint32_t percent_decimals = va_arg(vl,uint32_t);
-
-		run = run + (runDecimals / 1000.);
-		percent = percent + (percent_decimals / 1000.);
-
-		cpuUsage->cachedValue.percentUsage = percent;
-		cpuUsage->cachedValue.timeRunning = run;
-
-		cpuUsage->threadData.insert(cpuUsage->cachedValue);
-
-		va_end(vl);
-	}
-	cpuUsage->counter++;
-
-	return 0;
-}
-
-CpuUsage::CpuUsage() :
-		counter(0), timeSinceLastReset(0) {
-
-}
-
-CpuUsage::~CpuUsage() {
-
-}
-
-void CpuUsage::resetCpuUsage() {
-	rtems_cpu_usage_reset();
-}
-
-void CpuUsage::read() {
-	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
-}
-
-void CpuUsage::clear() {
-	counter = 0;
-	timeSinceLastReset = 0;
-	threadData.clear();
-}
-
-ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(
-			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
-			size, maxSize, streamEndianness);
-}
-
-uint32_t CpuUsage::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(timeSinceLastReset);
-	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
-		Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(
-			&timeSinceLastReset, buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
-			size, streamEndianness);
-}
-
-ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
-	*size += MAX_LENGTH_OF_THREAD_NAME;
-	*buffer += MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::serialize(&timeRunning,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&percentUsage,
-			buffer, size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-	uint32_t size = 0;
-
-	size += sizeof(id);
-	size += MAX_LENGTH_OF_THREAD_NAME;
-	size += sizeof(timeRunning);
-	size += sizeof(percentUsage);
-
-	return size;
-}
-
-ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
-		return STREAM_TOO_SHORT;
-	}
-	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
-	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
-	result = SerializeAdapter::deSerialize(&timeRunning,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&percentUsage,
-			buffer, size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+#include "CpuUsage.h"
+#include "../../serialize/SerialArrayListAdapter.h"
+#include "../../serialize/SerializeAdapter.h"
+#include <string.h>
+
+extern "C" {
+#include <rtems/cpuuse.h>
+}
+
+int handlePrint(void * token, const char *format, ...) {
+	CpuUsage *cpuUsage = (CpuUsage *) token;
+
+	if (cpuUsage->counter == 0) {
+		//header
+		cpuUsage->counter++;
+		return 0;
+	}
+
+	if (cpuUsage->counter % 2 == 1) {
+		{
+			//we can not tell when the last call is so we assume it be every uneven time
+			va_list vl;
+			va_start(vl, format);
+			float timeSinceLastReset = va_arg(vl,uint32_t);
+			uint32_t timeSinceLastResetDecimals = va_arg(vl,uint32_t);
+
+			timeSinceLastReset = timeSinceLastReset
+					+ (timeSinceLastResetDecimals / 1000.);
+
+			cpuUsage->timeSinceLastReset = timeSinceLastReset;
+
+			va_end(vl);
+		}
+		//task name and id
+		va_list vl;
+		va_start(vl, format);
+
+		cpuUsage->cachedValue.id = va_arg(vl,uint32_t);
+		const char *name = va_arg(vl,const char *);
+		memcpy(cpuUsage->cachedValue.name, name,
+				CpuUsage::ThreadData::MAX_LENGTH_OF_THREAD_NAME);
+
+		va_end(vl);
+
+	} else {
+		//statistics
+		va_list vl;
+		va_start(vl, format);
+		float run = va_arg(vl,uint32_t);
+		uint32_t runDecimals = va_arg(vl,uint32_t);
+		float percent = va_arg(vl,uint32_t);
+		uint32_t percent_decimals = va_arg(vl,uint32_t);
+
+		run = run + (runDecimals / 1000.);
+		percent = percent + (percent_decimals / 1000.);
+
+		cpuUsage->cachedValue.percentUsage = percent;
+		cpuUsage->cachedValue.timeRunning = run;
+
+		cpuUsage->threadData.insert(cpuUsage->cachedValue);
+
+		va_end(vl);
+	}
+	cpuUsage->counter++;
+
+	return 0;
+}
+
+CpuUsage::CpuUsage() :
+		counter(0), timeSinceLastReset(0) {
+
+}
+
+CpuUsage::~CpuUsage() {
+
+}
+
+void CpuUsage::resetCpuUsage() {
+	rtems_cpu_usage_reset();
+}
+
+void CpuUsage::read() {
+	//rtems_cpu_usage_report_with_plugin(this, &handlePrint);
+}
+
+void CpuUsage::clear() {
+	counter = 0;
+	timeSinceLastReset = 0;
+	threadData.clear();
+}
+
+ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(
+			&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
+			size, maxSize, streamEndianness);
+}
+
+uint32_t CpuUsage::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(timeSinceLastReset);
+	size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
+		Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(
+			&timeSinceLastReset, buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
+			size, streamEndianness);
+}
+
+ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+	memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
+	*size += MAX_LENGTH_OF_THREAD_NAME;
+	*buffer += MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::serialize(&timeRunning,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&percentUsage,
+			buffer, size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t CpuUsage::ThreadData::getSerializedSize() const {
+	uint32_t size = 0;
+
+	size += sizeof(id);
+	size += MAX_LENGTH_OF_THREAD_NAME;
+	size += sizeof(timeRunning);
+	size += sizeof(percentUsage);
+
+	return size;
+}
+
+ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
+		int32_t* size, Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	if ((*size = *size - MAX_LENGTH_OF_THREAD_NAME) < 0) {
+		return STREAM_TOO_SHORT;
+	}
+	memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
+	*buffer -= MAX_LENGTH_OF_THREAD_NAME;
+	result = SerializeAdapter::deSerialize(&timeRunning,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&percentUsage,
+			buffer, size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h
index 24cbb919..f487e191 100644
--- a/osal/rtems/CpuUsage.h
+++ b/osal/rtems/CpuUsage.h
@@ -1,53 +1,53 @@
-#ifndef CPUUSAGE_H_
-#define CPUUSAGE_H_
-
-#include "../../container/FixedArrayList.h"
-#include "../../serialize/SerializeIF.h"
-#include <stdarg.h>
-
-class CpuUsage : public SerializeIF {
-public:
-	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
-
-	class ThreadData: public SerializeIF {
-	public:
-		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
-
-		uint32_t id;
-		char name[MAX_LENGTH_OF_THREAD_NAME];
-		float timeRunning;
-		float percentUsage;
-
-		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const override;
-
-		virtual size_t getSerializedSize() const override;
-
-		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness) override;
-	};
-
-	CpuUsage();
-	virtual ~CpuUsage();
-
-	uint8_t counter;
-	float timeSinceLastReset;
-	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
-	ThreadData cachedValue;
-
-	static void resetCpuUsage();
-
-	void read();
-
-	void clear();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-};
-
-#endif /* CPUUSAGE_H_ */
+#ifndef CPUUSAGE_H_
+#define CPUUSAGE_H_
+
+#include "../../container/FixedArrayList.h"
+#include "../../serialize/SerializeIF.h"
+#include <stdarg.h>
+
+class CpuUsage : public SerializeIF {
+public:
+	static const uint8_t MAXIMUM_NUMBER_OF_THREADS = 30;
+
+	class ThreadData: public SerializeIF {
+	public:
+		static const uint8_t MAX_LENGTH_OF_THREAD_NAME = 4;
+
+		uint32_t id;
+		char name[MAX_LENGTH_OF_THREAD_NAME];
+		float timeRunning;
+		float percentUsage;
+
+		virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override;
+
+		virtual size_t getSerializedSize() const override;
+
+		virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override;
+	};
+
+	CpuUsage();
+	virtual ~CpuUsage();
+
+	uint8_t counter;
+	float timeSinceLastReset;
+	FixedArrayList<ThreadData, MAXIMUM_NUMBER_OF_THREADS> threadData;
+	ThreadData cachedValue;
+
+	static void resetCpuUsage();
+
+	void read();
+
+	void clear();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+};
+
+#endif /* CPUUSAGE_H_ */
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index 3542ecce..9346cf15 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -1,60 +1,60 @@
-#include "../../osal/InternalErrorCodes.h"
-#include <rtems/score/interr.h>
-
-ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
-	switch (code) {
-	//TODO It looks like RTEMS-5 does not provide the same error codes
-//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
-//		return NO_CONFIGURATION_TABLE;
-//	case INTERNAL_ERROR_NO_CPU_TABLE:
-//		return NO_CPU_TABLE;
-//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
-//		return INVALID_WORKSPACE_ADDRESS;
-	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
-		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
-//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
-//		return INTERRUPT_STACK_TOO_SMALL;
-	case INTERNAL_ERROR_THREAD_EXITTED:
-		return THREAD_EXITTED;
-	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
-		return INCONSISTENT_MP_INFORMATION;
-	case INTERNAL_ERROR_INVALID_NODE:
-		return INVALID_NODE;
-	case INTERNAL_ERROR_NO_MPCI:
-		return NO_MPCI;
-	case INTERNAL_ERROR_BAD_PACKET:
-		return BAD_PACKET;
-	case INTERNAL_ERROR_OUT_OF_PACKETS:
-		return OUT_OF_PACKETS;
-	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
-		return OUT_OF_GLOBAL_OBJECTS;
-	case INTERNAL_ERROR_OUT_OF_PROXIES:
-		return OUT_OF_PROXIES;
-	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
-		return INVALID_GLOBAL_ID;
-	case INTERNAL_ERROR_BAD_STACK_HOOK:
-		return BAD_STACK_HOOK;
-//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
-//		return BAD_ATTRIBUTES;
-//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
-//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
-//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
-//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
-//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
-//		return MUTEX_OBTAIN_FROM_BAD_STATE;
-//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
-//		return UNLIMITED_AND_MAXIMUM_IS_0;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-InternalErrorCodes::InternalErrorCodes() {
-}
-
-InternalErrorCodes::~InternalErrorCodes() {
-	
-}
-
+#include "../../osal/InternalErrorCodes.h"
+#include <rtems/score/interr.h>
+
+ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
+	switch (code) {
+	//TODO It looks like RTEMS-5 does not provide the same error codes
+//	case INTERNAL_ERROR_NO_CONFIGURATION_TABLE:
+//		return NO_CONFIGURATION_TABLE;
+//	case INTERNAL_ERROR_NO_CPU_TABLE:
+//		return NO_CPU_TABLE;
+//	case INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS:
+//		return INVALID_WORKSPACE_ADDRESS;
+	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
+		return TOO_LITTLE_WORKSPACE;
+	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
+//		return INTERRUPT_STACK_TOO_SMALL;
+	case INTERNAL_ERROR_THREAD_EXITTED:
+		return THREAD_EXITTED;
+	case INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION:
+		return INCONSISTENT_MP_INFORMATION;
+	case INTERNAL_ERROR_INVALID_NODE:
+		return INVALID_NODE;
+	case INTERNAL_ERROR_NO_MPCI:
+		return NO_MPCI;
+	case INTERNAL_ERROR_BAD_PACKET:
+		return BAD_PACKET;
+	case INTERNAL_ERROR_OUT_OF_PACKETS:
+		return OUT_OF_PACKETS;
+	case INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS:
+		return OUT_OF_GLOBAL_OBJECTS;
+	case INTERNAL_ERROR_OUT_OF_PROXIES:
+		return OUT_OF_PROXIES;
+	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
+		return INVALID_GLOBAL_ID;
+	case INTERNAL_ERROR_BAD_STACK_HOOK:
+		return BAD_STACK_HOOK;
+//	case INTERNAL_ERROR_BAD_ATTRIBUTES:
+//		return BAD_ATTRIBUTES;
+//	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:
+//		return IMPLEMENTATION_KEY_CREATE_INCONSISTENCY;
+//	case INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL:
+//		return IMPLEMENTATION_BLOCKING_OPERATION_CANCEL;
+//	case INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE:
+//		return MUTEX_OBTAIN_FROM_BAD_STATE;
+//	case INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0:
+//		return UNLIMITED_AND_MAXIMUM_IS_0;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+InternalErrorCodes::InternalErrorCodes() {
+}
+
+InternalErrorCodes::~InternalErrorCodes() {
+	
+}
+
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
index 076a6704..2152e2f0 100644
--- a/osal/rtems/Interrupt.h
+++ b/osal/rtems/Interrupt.h
@@ -1,50 +1,50 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */
+#ifndef OS_RTEMS_INTERRUPT_H_
+#define OS_RTEMS_INTERRUPT_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <cstring>
+#include <rtems.h>
+
+typedef rtems_isr_entry IsrHandler_t;
+typedef rtems_isr IsrReturn_t;
+typedef rtems_vector_number InterruptNumber_t;
+
+class Interrupt {
+public:
+	virtual ~Interrupt(){};
+
+	/**
+	 * Establishes a new interrupt service routine.
+	 * @param handler	The service routine to establish
+	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
+	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
+			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
+	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
+	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
+	/**
+	 * Enables the interrupt given.
+	 * The function tests, if the InterruptMask register was written successfully.
+	 * @param interrupt The interrupt to enable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
+	/**
+	 * Disables the interrupt given.
+	 * @param interrupt The interrupt to disable.
+	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
+	 */
+	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
+
+
+	/**
+	 * Checks if the current executing context is an ISR.
+	 * @return true if handling an interrupt, false else.
+	 */
+	static bool isInterruptInProgress();
+
+};
+
+
+#endif /* OS_RTEMS_INTERRUPT_H_ */
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index e0752409..700db444 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,147 +1,147 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-#include <cstring>
-MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
-	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
-	rtems_status_code status = rtems_message_queue_create(name, message_depth,
-			max_message_size, 0, &(this->id));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-				<< name << std::dec << " failed with status:"
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-MessageQueue::~MessageQueue() {
-	rtems_message_queue_delete(id);
-}
-
-ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
-	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
-}
-
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
-	return sendToDefaultFrom(message, this->getId());
-}
-
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
-	if (this->lastPartner != 0) {
-		return sendMessage(this->lastPartner, message, this->getId());
-	} else {
-		return NO_REPLY_PARTNER;
-	}
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
-		MessageQueueId_t* receivedFrom) {
-	ReturnValue_t status = this->receiveMessage(message);
-	*receivedFrom = this->lastPartner;
-	return status;
-}
-
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
-	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
-			RTEMS_NO_WAIT, 1);
-	if (status == RTEMS_SUCCESSFUL) {
-		this->lastPartner = message->getSender();
-		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	} else {
-		//No message was received. Keep lastPartner anyway, I might send something later.
-		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
-	}
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getLastPartner() const {
-	return this->lastPartner;
-}
-
-ReturnValue_t MessageQueue::flush(uint32_t* count) {
-	rtems_status_code status = rtems_message_queue_flush(id, count);
-	return convertReturnCode(status);
-}
-
-MessageQueueId_t MessageQueue::getId() const {
-	return this->id;
-}
-
-void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
-	this->defaultDestination = defaultDestination;
-}
-
-ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
-		bool ignoreFault) {
-
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
-
-	//TODO: Check if we're in ISR.
-	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
-			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-					objects::INTERNAL_ERROR_REPORTER);
-		}
-		if (internalErrorReporter != NULL) {
-			internalErrorReporter->queueMessageNotSent();
-		}
-	}
-
-	ReturnValue_t returnCode = convertReturnCode(result);
-	if(result == MessageQueueIF::EMPTY){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return returnCode;
-}
-
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
-		MessageQueueId_t sentFrom, bool ignoreFault) {
-	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
-}
-
-MessageQueueId_t MessageQueue::getDefaultDestination() const {
-	return this->defaultDestination;
-}
-
-bool MessageQueue::isDefaultDestinationSet() const {
-	return (defaultDestination != NO_QUEUE);
-}
-
-ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
-		switch(inValue){
-		case RTEMS_SUCCESSFUL:
-			return HasReturnvaluesIF::RETURN_OK;
-		case  RTEMS_INVALID_ID:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TIMEOUT:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_OBJECT_WAS_DELETED:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_ADDRESS:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_INVALID_SIZE:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		case RTEMS_TOO_MANY:
-			return MessageQueueIF::FULL;
-		case RTEMS_UNSATISFIED:
-			return MessageQueueIF::EMPTY;
-		default:
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-
-}
-
-
-
-uint16_t MessageQueue::queueCounter = 0;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+#include <cstring>
+MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
+	rtems_status_code status = rtems_message_queue_create(name, message_depth,
+			max_message_size, 0, &(this->id));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+				<< name << std::dec << " failed with status:"
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+MessageQueue::~MessageQueue() {
+	rtems_message_queue_delete(id);
+}
+
+ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, bool ignoreFault) {
+	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
+}
+
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+	return sendToDefaultFrom(message, this->getId());
+}
+
+ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+	if (this->lastPartner != 0) {
+		return sendMessage(this->lastPartner, message, this->getId());
+	} else {
+		return NO_REPLY_PARTNER;
+	}
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+		MessageQueueId_t* receivedFrom) {
+	ReturnValue_t status = this->receiveMessage(message);
+	*receivedFrom = this->lastPartner;
+	return status;
+}
+
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+	rtems_status_code status = rtems_message_queue_receive(id,
+			message->getBuffer(), &(message->messageSize),
+			RTEMS_NO_WAIT, 1);
+	if (status == RTEMS_SUCCESSFUL) {
+		this->lastPartner = message->getSender();
+		//Check size of incoming message.
+		if (message->messageSize < message->getMinimumMessageSize()) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	} else {
+		//No message was received. Keep lastPartner anyway, I might send something later.
+		//But still, delete packet content.
+		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+	}
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getLastPartner() const {
+	return this->lastPartner;
+}
+
+ReturnValue_t MessageQueue::flush(uint32_t* count) {
+	rtems_status_code status = rtems_message_queue_flush(id, count);
+	return convertReturnCode(status);
+}
+
+MessageQueueId_t MessageQueue::getId() const {
+	return this->id;
+}
+
+void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
+	this->defaultDestination = defaultDestination;
+}
+
+ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
+		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		bool ignoreFault) {
+
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo,
+			message->getBuffer(), message->messageSize);
+
+	//TODO: Check if we're in ISR.
+	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
+		if (internalErrorReporter == NULL) {
+			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+					objects::INTERNAL_ERROR_REPORTER);
+		}
+		if (internalErrorReporter != NULL) {
+			internalErrorReporter->queueMessageNotSent();
+		}
+	}
+
+	ReturnValue_t returnCode = convertReturnCode(result);
+	if(result == MessageQueueIF::EMPTY){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	return returnCode;
+}
+
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+		MessageQueueId_t sentFrom, bool ignoreFault) {
+	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
+}
+
+MessageQueueId_t MessageQueue::getDefaultDestination() const {
+	return this->defaultDestination;
+}
+
+bool MessageQueue::isDefaultDestinationSet() const {
+	return (defaultDestination != NO_QUEUE);
+}
+
+ReturnValue_t MessageQueue::convertReturnCode(rtems_status_code inValue){
+		switch(inValue){
+		case RTEMS_SUCCESSFUL:
+			return HasReturnvaluesIF::RETURN_OK;
+		case  RTEMS_INVALID_ID:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TIMEOUT:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_OBJECT_WAS_DELETED:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_ADDRESS:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_INVALID_SIZE:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		case RTEMS_TOO_MANY:
+			return MessageQueueIF::FULL;
+		case RTEMS_UNSATISFIED:
+			return MessageQueueIF::EMPTY;
+		default:
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+
+}
+
+
+
+uint16_t MessageQueue::queueCounter = 0;
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index 2d1bd8db..c6fc62d5 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,181 +1,181 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
-
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/MessageQueueMessage.h"
-#include "RtemsBasic.h"
-
-/**
- *	@brief		This class manages sending and receiving of message queue messages.
- *
- *	@details	Message queues are used to pass asynchronous messages between processes.
- *				They work like post boxes, where all incoming messages are stored in FIFO
- *				order. This class creates a new receiving queue and provides methods to fetch
- *				received messages. Being a child of MessageQueueSender, this class also provides
- *				methods to send a message to a user-defined or a default destination. In addition
- *				it also provides a reply method to answer to the queue it received its last message
- *				from.
- *				The MessageQueue should be used as "post box" for a single owning object. So all
- *				message queue communication is "n-to-one".
- *				For creating the queue, as well as sending and receiving messages, the class makes
- *				use of the operating system calls provided.
- *	\ingroup message_queue
- */
-class MessageQueue : public MessageQueueIF {
-public:
-	/**
-	 * @brief	The constructor initializes and configures the message queue.
-	 * @details	By making use of the according operating system call, a message queue is created
-	 * 			and initialized. The message depth - the maximum number of messages to be
-	 * 			buffered - may be set with the help of a parameter, whereas the message size is
-	 * 			automatically set to the maximum message queue message size. The operating system
-	 * 			sets the message queue id, or i case of failure, it is set to zero.
-	 * @param message_depth	The number of messages to be buffered before passing an error to the
-	 * 						sender. Default is three.
-	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
-	 * 							This should be left default.
-	 */
-	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
-	/**
-	 * @brief	The destructor deletes the formerly created message queue.
-	 * @details	This is accomplished by using the delete call provided by the operating system.
-	 */
-	virtual ~MessageQueue();
-	/**
-	 * @brief	This operation sends a message to the given destination.
-	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
-	 * 			queue id as "sentFrom" parameter.
-	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
-	/**
-	 * @brief	This operation sends a message to the default destination.
-	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
-	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t sendToDefault( MessageQueueMessage* message );
-	/**
-	 * @brief	This operation sends a message to the last communication partner.
-	 * @details	This operation simplifies answering an incoming message by using the stored
-	 * 			lastParnter information as destination. If there was no message received yet
-	 * 			(i.e. lastPartner is zero), an error code is returned.
-	 * @param message	A pointer to a previously created message, which is sent.
-	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
-
-	/**
-	 * @brief	This function reads available messages from the message queue and returns the sender.
-	 * @details	It works identically to the other receiveMessage call, but in addition returns the
-	 * 			sender's queue id.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom);
-
-	/**
-	 * @brief	This function reads available messages from the message queue.
-	 * @details	If data is available it is stored in the passed message pointer. The message's
-	 * 			original content is overwritten and the sendFrom information is stored in the
-	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
-	 * 			message's content is cleared and the function returns immediately.
-	 * @param message	A pointer to a message in which the received data is stored.
-	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
-	/**
-	 * Deletes all pending messages in the queue.
-	 * @param count The number of flushed messages.
-	 * @return RETURN_OK on success.
-	 */
-	ReturnValue_t flush(uint32_t* count);
-	/**
-	 * @brief	This method returns the message queue id of the last communication partner.
-	 */
-	MessageQueueId_t getLastPartner() const;
-	/**
-	 * @brief	This method returns the message queue id of this class's message queue.
-	 */
-	MessageQueueId_t getId() const;
-	/**
-	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
-	 * \details	This method takes the message provided, adds the sentFrom information and passes
-	 * 			it on to the destination provided with an operating system call. The OS's return
-	 * 			value is returned.
-	 * \param sendTo	This parameter specifies the message queue id to send the message to.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
-	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	The sendToDefault method sends a queue message to the default destination.
-	 * \details	In all other aspects, it works identical to the sendMessage method.
-	 * \param message	This is a pointer to a previously created message, which is sent.
-	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
-	 * 					This variable is set to zero by default.
-	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
-	/**
-	 * \brief	This method is a simple setter for the default destination.
-	 */
-	void setDefaultDestination(MessageQueueId_t defaultDestination);
-	/**
-	 * \brief	This method is a simple getter for the default destination.
-	 */
-	MessageQueueId_t getDefaultDestination() const;
-
-	bool isDefaultDestinationSet() const;
-private:
-	/**
-	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the queue id is set to zero.
-	 */
-	MessageQueueId_t id;
-	/**
-	 * @brief	In this attribute, the queue id of the last communication partner is stored
-	 * 			to allow for replying.
-	 */
-	MessageQueueId_t lastPartner;
-	/**
-	 * @brief	The message queue's name -a user specific information for the operating system-  is
-	 * 			generated automatically with the help of this static counter.
-	 */
-	/**
-	 * \brief	This attribute stores a default destination to send messages to.
-	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
-	 * 			be set in the constructor or by a setter call to setDefaultDestination.
-	 */
-	MessageQueueId_t defaultDestination;
-
-	/**
-	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
-	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
-	 * 			by lazy loading
-	 */
-	InternalErrorReporterIF *internalErrorReporter;
-
-	static uint16_t queueCounter;
-	/**
-	 * A method to convert an OS-specific return code to the frameworks return value concept.
-	 * @param inValue The return code coming from the OS.
-	 * @return The converted return value.
-	 */
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-#endif /* MESSAGEQUEUE_H_ */
+/**
+ *	@file	MessageQueue.h
+ *
+ *  @date	10/02/2012
+ *	@author	Bastian Baetz
+ *
+ *	@brief	This file contains the definition of the MessageQueue class.
+ */
+
+#ifndef MESSAGEQUEUE_H_
+#define MESSAGEQUEUE_H_
+
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
+#include "RtemsBasic.h"
+
+/**
+ *	@brief		This class manages sending and receiving of message queue messages.
+ *
+ *	@details	Message queues are used to pass asynchronous messages between processes.
+ *				They work like post boxes, where all incoming messages are stored in FIFO
+ *				order. This class creates a new receiving queue and provides methods to fetch
+ *				received messages. Being a child of MessageQueueSender, this class also provides
+ *				methods to send a message to a user-defined or a default destination. In addition
+ *				it also provides a reply method to answer to the queue it received its last message
+ *				from.
+ *				The MessageQueue should be used as "post box" for a single owning object. So all
+ *				message queue communication is "n-to-one".
+ *				For creating the queue, as well as sending and receiving messages, the class makes
+ *				use of the operating system calls provided.
+ *	\ingroup message_queue
+ */
+class MessageQueue : public MessageQueueIF {
+public:
+	/**
+	 * @brief	The constructor initializes and configures the message queue.
+	 * @details	By making use of the according operating system call, a message queue is created
+	 * 			and initialized. The message depth - the maximum number of messages to be
+	 * 			buffered - may be set with the help of a parameter, whereas the message size is
+	 * 			automatically set to the maximum message queue message size. The operating system
+	 * 			sets the message queue id, or i case of failure, it is set to zero.
+	 * @param message_depth	The number of messages to be buffered before passing an error to the
+	 * 						sender. Default is three.
+	 * @param max_message_size	With this parameter, the maximum message size can be adjusted.
+	 * 							This should be left default.
+	 */
+	MessageQueue( size_t message_depth = 3, size_t max_message_size = MessageQueueMessage::MAX_MESSAGE_SIZE );
+	/**
+	 * @brief	The destructor deletes the formerly created message queue.
+	 * @details	This is accomplished by using the delete call provided by the operating system.
+	 */
+	virtual ~MessageQueue();
+	/**
+	 * @brief	This operation sends a message to the given destination.
+	 * @details	It directly uses the sendMessage call of the MessageQueueSender parent, but passes its
+	 * 			queue id as "sentFrom" parameter.
+	 * @param sendTo	This parameter specifies the message queue id of the destination message queue.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false );
+	/**
+	 * @brief	This operation sends a message to the default destination.
+	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
+	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	/**
+	 * @brief	This operation sends a message to the last communication partner.
+	 * @details	This operation simplifies answering an incoming message by using the stored
+	 * 			lastParnter information as destination. If there was no message received yet
+	 * 			(i.e. lastPartner is zero), an error code is returned.
+	 * @param message	A pointer to a previously created message, which is sent.
+	 */
+	ReturnValue_t reply( MessageQueueMessage* message );
+
+	/**
+	 * @brief	This function reads available messages from the message queue and returns the sender.
+	 * @details	It works identically to the other receiveMessage call, but in addition returns the
+	 * 			sender's queue id.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom);
+
+	/**
+	 * @brief	This function reads available messages from the message queue.
+	 * @details	If data is available it is stored in the passed message pointer. The message's
+	 * 			original content is overwritten and the sendFrom information is stored in the
+	 * 			lastPartner attribute. Else, the lastPartner information remains untouched, the
+	 * 			message's content is cleared and the function returns immediately.
+	 * @param message	A pointer to a message in which the received data is stored.
+	 */
+	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	/**
+	 * Deletes all pending messages in the queue.
+	 * @param count The number of flushed messages.
+	 * @return RETURN_OK on success.
+	 */
+	ReturnValue_t flush(uint32_t* count);
+	/**
+	 * @brief	This method returns the message queue id of the last communication partner.
+	 */
+	MessageQueueId_t getLastPartner() const;
+	/**
+	 * @brief	This method returns the message queue id of this class's message queue.
+	 */
+	MessageQueueId_t getId() const;
+	/**
+	 * \brief	With the sendMessage call, a queue message is sent to a receiving queue.
+	 * \details	This method takes the message provided, adds the sentFrom information and passes
+	 * 			it on to the destination provided with an operating system call. The OS's return
+	 * 			value is returned.
+	 * \param sendTo	This parameter specifies the message queue id to send the message to.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
+	 */
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	The sendToDefault method sends a queue message to the default destination.
+	 * \details	In all other aspects, it works identical to the sendMessage method.
+	 * \param message	This is a pointer to a previously created message, which is sent.
+	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
+	 * 					This variable is set to zero by default.
+	 */
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	/**
+	 * \brief	This method is a simple setter for the default destination.
+	 */
+	void setDefaultDestination(MessageQueueId_t defaultDestination);
+	/**
+	 * \brief	This method is a simple getter for the default destination.
+	 */
+	MessageQueueId_t getDefaultDestination() const;
+
+	bool isDefaultDestinationSet() const;
+private:
+	/**
+	 * @brief	The class stores the queue id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the queue id is set to zero.
+	 */
+	MessageQueueId_t id;
+	/**
+	 * @brief	In this attribute, the queue id of the last communication partner is stored
+	 * 			to allow for replying.
+	 */
+	MessageQueueId_t lastPartner;
+	/**
+	 * @brief	The message queue's name -a user specific information for the operating system-  is
+	 * 			generated automatically with the help of this static counter.
+	 */
+	/**
+	 * \brief	This attribute stores a default destination to send messages to.
+	 * \details	It is stored to simplify sending to always-the-same receiver. The attribute may
+	 * 			be set in the constructor or by a setter call to setDefaultDestination.
+	 */
+	MessageQueueId_t defaultDestination;
+
+	/**
+	 * \brief	This attribute stores a reference to the internal error reporter for reporting full queues.
+	 * \details	In the event of a full destination queue, the reporter will be notified. The reference is set
+	 * 			by lazy loading
+	 */
+	InternalErrorReporterIF *internalErrorReporter;
+
+	static uint16_t queueCounter;
+	/**
+	 * A method to convert an OS-specific return code to the frameworks return value concept.
+	 * @param inValue The return code coming from the OS.
+	 * @return The converted return value.
+	 */
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+#endif /* MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 8cec10f7..8f969a1d 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -1,87 +1,87 @@
-/**
- * @file	MultiObjectTask.cpp
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tasks/ExecutableObjectIF.h"
-#include "MultiObjectTask.h"
-
-MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodTicks(
-				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
-				setDeadlineMissedFunc) {
-}
-
-MultiObjectTask::~MultiObjectTask(void) {
-	//Do not delete objects, we were responsible for ptrs only.
-	rtems_rate_monotonic_delete(periodId);
-}
-rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
-	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
-	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
-	originalTask->taskFunctionality();
-}
-
-ReturnValue_t MultiObjectTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
-	return TaskBase::sleepFor(ms);
-}
-
-void MultiObjectTask::taskFunctionality() {
-	TaskBase::setAndStartPeriod(periodTicks,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
-		}
-		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
-		if (status == RTEMS_TIMEOUT) {
-			char nameSpace[8] = { 0 };
-			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
-					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
-				this->deadlineMissedFunc();
-			}
-		}
-	}
-}
-
-ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
-			object);
-	if (newObject == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
-}
-
-uint32_t MultiObjectTask::getPeriodMs() const {
-	return RtemsBasic::convertTicksToMs(periodTicks);
-}
+/**
+ * @file	MultiObjectTask.cpp
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "MultiObjectTask.h"
+
+MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, rtems_interval setPeriod, void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodTicks(
+				RtemsBasic::convertMsToTicks(setPeriod)), periodId(0), deadlineMissedFunc(
+				setDeadlineMissedFunc) {
+}
+
+MultiObjectTask::~MultiObjectTask(void) {
+	//Do not delete objects, we were responsible for ptrs only.
+	rtems_rate_monotonic_delete(periodId);
+}
+rtems_task MultiObjectTask::taskEntryPoint(rtems_task_argument argument) {
+	//The argument is re-interpreted as MultiObjectTask. The Task object is global, so it is found from any place.
+	MultiObjectTask *originalTask(reinterpret_cast<MultiObjectTask*>(argument));
+	originalTask->taskFunctionality();
+}
+
+ReturnValue_t MultiObjectTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "ObjectTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t MultiObjectTask::sleepFor(uint32_t ms) {
+	return TaskBase::sleepFor(ms);
+}
+
+void MultiObjectTask::taskFunctionality() {
+	TaskBase::setAndStartPeriod(periodTicks,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		for (ObjectList::iterator it = objectList.begin();
+				it != objectList.end(); ++it) {
+			(*it)->performOperation();
+		}
+		rtems_status_code status = TaskBase::restartPeriod(periodTicks,periodId);
+		if (status == RTEMS_TIMEOUT) {
+			char nameSpace[8] = { 0 };
+			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
+					nameSpace);
+			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != NULL) {
+				this->deadlineMissedFunc();
+			}
+		}
+	}
+}
+
+ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
+	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+			object);
+	if (newObject == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	objectList.push_back(newObject);
+	ReturnValue_t result = newObject->initializeAfterTaskCreation();
+	return result;
+}
+
+uint32_t MultiObjectTask::getPeriodMs() const {
+	return RtemsBasic::convertTicksToMs(periodTicks);
+}
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index b3ff66c2..28d05fb1 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,113 +1,113 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
-
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../tasks/PeriodicTaskIF.h"
-
-#include "TaskBase.h"
-#include <vector>
-
-class ExecutableObjectIF;
-
-/**
- * @brief This class represents a specialized task for periodic activities of multiple objects.
- *
- * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
- * 			added prior to starting the task.
- *
- * @ingroup task_handling
- */
-class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
-public:
-	/**
-	 * @brief	Standard constructor of the class.
-	 * @details	The class is initialized without allocated objects. These need to be added
-	 * 			with #addObject.
-	 * 			In the underlying TaskBase class, a new operating system task is created.
-	 * 			In addition to the TaskBase parameters, the period, the pointer to the
-	 * 			aforementioned initialization function and an optional "deadline-missed"
-	 * 			function pointer is passed.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param setPeriod 	The length of the period with which the task's functionality will be
-	 * 						executed. It is expressed in clock ticks.
-	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
-	 * 								that shall be assigned.
-	 */
-	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
-			void (*setDeadlineMissedFunc)());
-	/**
-	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
-	 * 			lifetime, so the destructor is empty.
-	 */
-	virtual ~MultiObjectTask(void);
-
-	/**
-	 * @brief	The method to start the task.
-	 * @details	The method starts the task with the respective system call.
-	 * 			Entry point is the taskEntryPoint method described below.
-	 * 			The address of the task object is passed as an argument
-	 * 			to the system call.
-	 */
-	ReturnValue_t startTask(void);
-	/**
-	 * Adds an object to the list of objects to be executed.
-	 * The objects are executed in the order added.
-	 * @param object Id of the object to add.
-	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
-	 */
-	ReturnValue_t addComponent(object_id_t object);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
-	/**
-	 * @brief	This attribute holds a list of objects to be executed.
-	 */
-	ObjectList objectList;
-	/**
-	 * @brief	The period of the task.
-	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
-	 */
-	rtems_interval periodTicks;
-	/**
-	 * @brief id of the associated OS period
-	 */
-	rtems_id periodId;
-	/**
-	 * @brief	The pointer to the deadline-missed function.
-	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
-	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
-	 * 			of the periodic task.
-	 */
-	void (*deadlineMissedFunc)(void);
-	/**
-	 * @brief	This is the function executed in the new task's context.
-	 * @details	It converts the argument back to the thread object type and copies the class instance
-	 * 			to the task context. The taskFunctionality method is called afterwards.
-	 * @param	A pointer to the task object itself is passed as argument.
-	 */
-	static rtems_task taskEntryPoint(rtems_task_argument argument);
-	/**
-	 * @brief	The function containing the actual functionality of the task.
-	 * @details	The method sets and starts
-	 * 			the task's period, then enters a loop that is repeated as long as the isRunning
-	 * 			attribute is true. Within the loop, all performOperation methods of the added
-	 * 			objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
-	 * 			until the next period.
-	 * 			On missing the deadline, the deadlineMissedFunction is executed.
-	 */
-	void taskFunctionality(void);
-};
-
-#endif /* MULTIOBJECTTASK_H_ */
+/**
+ * @file	MultiObjectTask.h
+ * @brief	This file defines the MultiObjectTask class.
+ * @date	30.01.2014
+ * @author	baetz
+ */
+#ifndef MULTIOBJECTTASK_H_
+#define MULTIOBJECTTASK_H_
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+#include "TaskBase.h"
+#include <vector>
+
+class ExecutableObjectIF;
+
+/**
+ * @brief This class represents a specialized task for periodic activities of multiple objects.
+ *
+ * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
+ * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
+ * 			added prior to starting the task.
+ *
+ * @ingroup task_handling
+ */
+class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
+public:
+	/**
+	 * @brief	Standard constructor of the class.
+	 * @details	The class is initialized without allocated objects. These need to be added
+	 * 			with #addObject.
+	 * 			In the underlying TaskBase class, a new operating system task is created.
+	 * 			In addition to the TaskBase parameters, the period, the pointer to the
+	 * 			aforementioned initialization function and an optional "deadline-missed"
+	 * 			function pointer is passed.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param setPeriod 	The length of the period with which the task's functionality will be
+	 * 						executed. It is expressed in clock ticks.
+	 * @param setDeadlineMissedFunc	The function pointer to the deadline missed function
+	 * 								that shall be assigned.
+	 */
+	MultiObjectTask(const char *name, rtems_task_priority setPriority, size_t setStack, rtems_interval setPeriod,
+			void (*setDeadlineMissedFunc)());
+	/**
+	 * @brief	Currently, the executed object's lifetime is not coupled with the task object's
+	 * 			lifetime, so the destructor is empty.
+	 */
+	virtual ~MultiObjectTask(void);
+
+	/**
+	 * @brief	The method to start the task.
+	 * @details	The method starts the task with the respective system call.
+	 * 			Entry point is the taskEntryPoint method described below.
+	 * 			The address of the task object is passed as an argument
+	 * 			to the system call.
+	 */
+	ReturnValue_t startTask(void);
+	/**
+	 * Adds an object to the list of objects to be executed.
+	 * The objects are executed in the order added.
+	 * @param object Id of the object to add.
+	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
+	 */
+	ReturnValue_t addComponent(object_id_t object);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
+	/**
+	 * @brief	This attribute holds a list of objects to be executed.
+	 */
+	ObjectList objectList;
+	/**
+	 * @brief	The period of the task.
+	 * @details	The period determines the frequency of the task's execution. It is expressed in clock ticks.
+	 */
+	rtems_interval periodTicks;
+	/**
+	 * @brief id of the associated OS period
+	 */
+	rtems_id periodId;
+	/**
+	 * @brief	The pointer to the deadline-missed function.
+	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
+	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
+	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
+	 * 			of the periodic task.
+	 */
+	void (*deadlineMissedFunc)(void);
+	/**
+	 * @brief	This is the function executed in the new task's context.
+	 * @details	It converts the argument back to the thread object type and copies the class instance
+	 * 			to the task context. The taskFunctionality method is called afterwards.
+	 * @param	A pointer to the task object itself is passed as argument.
+	 */
+	static rtems_task taskEntryPoint(rtems_task_argument argument);
+	/**
+	 * @brief	The function containing the actual functionality of the task.
+	 * @details	The method sets and starts
+	 * 			the task's period, then enters a loop that is repeated as long as the isRunning
+	 * 			attribute is true. Within the loop, all performOperation methods of the added
+	 * 			objects are called. Afterwards the checkAndRestartPeriod system call blocks the task
+	 * 			until the next period.
+	 * 			On missing the deadline, the deadlineMissedFunction is executed.
+	 */
+	void taskFunctionality(void);
+};
+
+#endif /* MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 7ead8851..d8babcde 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,65 +1,65 @@
-#include "Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
-uint8_t Mutex::count = 0;
-
-Mutex::Mutex() :
-		mutexId(0) {
-	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
-	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
-	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
-			&mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-Mutex::~Mutex() {
-	rtems_status_code status = rtems_semaphore_delete(mutexId);
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
-				<< " failed with " << status << std::endl;
-	}
-}
-
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_UNSATISFIED:
-		//semaphore not available
-		return MUTEX_NOT_FOUND;
-	case RTEMS_TIMEOUT:
-		//timed out waiting for semaphore
-		return MUTEX_TIMEOUT;
-	case RTEMS_OBJECT_WAS_DELETED:
-		//semaphore deleted while waiting
-		return MUTEX_DESTROYED_WHILE_WAITING;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Mutex::unlockMutex() {
-	rtems_status_code status = rtems_semaphore_release(mutexId);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//semaphore obtained successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_NOT_OWNER_OF_RESOURCE:
-		//semaphore not available
-		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	case RTEMS_INVALID_ID:
-		//invalid semaphore id
-		return MUTEX_INVALID_ID;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "Mutex.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
+uint8_t Mutex::count = 0;
+
+Mutex::Mutex() :
+		mutexId(0) {
+	rtems_name mutexName = ('M' << 24) + ('T' << 16) + ('X' << 8) + count++;
+	rtems_status_code status = rtems_semaphore_create(mutexName, 1,
+	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
+			&mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+Mutex::~Mutex() {
+	rtems_status_code status = rtems_semaphore_delete(mutexId);
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "Mutex: deletion for id " << mutexId
+				<< " failed with " << status << std::endl;
+	}
+}
+
+ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_UNSATISFIED:
+		//semaphore not available
+		return MUTEX_NOT_FOUND;
+	case RTEMS_TIMEOUT:
+		//timed out waiting for semaphore
+		return MUTEX_TIMEOUT;
+	case RTEMS_OBJECT_WAS_DELETED:
+		//semaphore deleted while waiting
+		return MUTEX_DESTROYED_WHILE_WAITING;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Mutex::unlockMutex() {
+	rtems_status_code status = rtems_semaphore_release(mutexId);
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//semaphore obtained successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_NOT_OWNER_OF_RESOURCE:
+		//semaphore not available
+		return CURR_THREAD_DOES_NOT_OWN_MUTEX;
+	case RTEMS_INVALID_ID:
+		//invalid semaphore id
+		return MUTEX_INVALID_ID;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index fd76b86a..340bb16b 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,18 +1,18 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
-
-#include "../../ipc/MutexIF.h"
-#include "RtemsBasic.h"
-
-class Mutex : public MutexIF {
-public:
-	Mutex();
-	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
-private:
-	rtems_id mutexId;
-	static uint8_t count;
-};
-
-#endif /* OS_RTEMS_MUTEX_H_ */
+#ifndef OS_RTEMS_MUTEX_H_
+#define OS_RTEMS_MUTEX_H_
+
+#include "../../ipc/MutexIF.h"
+#include "RtemsBasic.h"
+
+class Mutex : public MutexIF {
+public:
+	Mutex();
+	~Mutex();
+	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+private:
+	rtems_id mutexId;
+	static uint8_t count;
+};
+
+#endif /* OS_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index 3ffab927..ea594789 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -1,24 +1,24 @@
-#include "../../ipc/MutexFactory.h"
-#include "Mutex.h"
-#include "RtemsBasic.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-
-MutexFactory::MutexFactory() {
-}
-
-MutexFactory::~MutexFactory() {
-}
-
-MutexFactory* MutexFactory::instance() {
-	return MutexFactory::factoryInstance;
-}
-
-MutexIF* MutexFactory::createMutex() {
-	return new Mutex();
-}
-
-void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
-}
+#include "../../ipc/MutexFactory.h"
+#include "Mutex.h"
+#include "RtemsBasic.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
+
+MutexFactory::MutexFactory() {
+}
+
+MutexFactory::~MutexFactory() {
+}
+
+MutexFactory* MutexFactory::instance() {
+	return MutexFactory::factoryInstance;
+}
+
+MutexIF* MutexFactory::createMutex() {
+	return new Mutex();
+}
+
+void MutexFactory::deleteMutex(MutexIF* mutex) {
+	delete mutex;
+}
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index b53d6a5a..efb425d9 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,122 +1,122 @@
-#include "../../tasks/FixedSequenceSlot.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../osal/rtems/PollingTask.h"
-#include "../../osal/rtems/RtemsBasic.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <rtems/bspIo.h>
-#include <rtems/rtems/ratemon.h>
-#include <rtems/rtems/status.h>
-#include <rtems/rtems/tasks.h>
-#include <rtems/rtems/types.h>
-#include <stddef.h>
-#include <sys/_stdint.h>
-#include <iostream>
-#include <list>
-
-uint32_t PollingTask::deadlineMissedCount = 0;
-
-PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
-		size_t setStack, uint32_t setOverallPeriod,
-		void (*setDeadlineMissedFunc)()) :
-		TaskBase(setPriority, setStack, name), periodId(0), pst(
-				setOverallPeriod) {
-	// All additional attributes are applied to the object.
-	this->deadlineMissedFunc = setDeadlineMissedFunc;
-}
-
-PollingTask::~PollingTask() {
-}
-
-rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
-
-	//The argument is re-interpreted as PollingTask.
-	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
-	//The task's functionality is called.
-	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
-			<< " returned from taskFunctionality." << std::endl;
-}
-
-void PollingTask::missedDeadlineCounter() {
-	PollingTask::deadlineMissedCount++;
-	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
-				<< " deadlines." << std::endl;
-	}
-}
-
-ReturnValue_t PollingTask::startTask() {
-	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
-			rtems_task_argument((void *) this));
-	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
-				<< std::dec << " failed." << std::endl;
-	}
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ask started successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-/*		RTEMS_INVALID_ADDRESS - invalid task entry point
-		RTEMS_INVALID_ID - invalid task id
-		RTEMS_INCORRECT_STATE - task not in the dormant state
-		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t PollingTask::addSlot(object_id_t componentId,
-		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t PollingTask::getPeriodMs() const {
-	return pst.getLengthMs();
-}
-
-ReturnValue_t PollingTask::checkAndInitializeSequence() const {
-	return pst.checkSequence();
-}
-
-#include <rtems/io.h>
-
-void PollingTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
-
-	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
-	TaskBase::setAndStartPeriod(interval,&periodId);
-	//The task's "infinite" inner loop is entered.
-	while (1) {
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			//The interval for the next polling slot is selected.
-			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
-			//The period is checked and restarted with the new interval.
-			//If the deadline was missed, the deadlineMissedFunc is called.
-			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
-			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
-					this->deadlineMissedFunc();
-				}
-			}
-		}
-		//The device handler for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-	}
-}
-
-ReturnValue_t PollingTask::sleepFor(uint32_t ms){
-	return TaskBase::sleepFor(ms);
-};
+#include "../../tasks/FixedSequenceSlot.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../osal/rtems/PollingTask.h"
+#include "../../osal/rtems/RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <rtems/bspIo.h>
+#include <rtems/rtems/ratemon.h>
+#include <rtems/rtems/status.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/rtems/types.h>
+#include <stddef.h>
+#include <sys/_stdint.h>
+#include <iostream>
+#include <list>
+
+uint32_t PollingTask::deadlineMissedCount = 0;
+
+PollingTask::PollingTask(const char *name, rtems_task_priority setPriority,
+		size_t setStack, uint32_t setOverallPeriod,
+		void (*setDeadlineMissedFunc)()) :
+		TaskBase(setPriority, setStack, name), periodId(0), pst(
+				setOverallPeriod) {
+	// All additional attributes are applied to the object.
+	this->deadlineMissedFunc = setDeadlineMissedFunc;
+}
+
+PollingTask::~PollingTask() {
+}
+
+rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
+
+	//The argument is re-interpreted as PollingTask.
+	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
+	//The task's functionality is called.
+	originalTask->taskFunctionality();
+	debug << "Polling task " << originalTask->getId()
+			<< " returned from taskFunctionality." << std::endl;
+}
+
+void PollingTask::missedDeadlineCounter() {
+	PollingTask::deadlineMissedCount++;
+	if (PollingTask::deadlineMissedCount % 10 == 0) {
+		error << "PST missed " << PollingTask::deadlineMissedCount
+				<< " deadlines." << std::endl;
+	}
+}
+
+ReturnValue_t PollingTask::startTask() {
+	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
+			rtems_task_argument((void *) this));
+	if (status != RTEMS_SUCCESSFUL) {
+		error << "PollingTask::startTask for " << std::hex << this->getId()
+				<< std::dec << " failed." << std::endl;
+	}
+	switch(status){
+	case RTEMS_SUCCESSFUL:
+		//ask started successfully
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+/*		RTEMS_INVALID_ADDRESS - invalid task entry point
+		RTEMS_INVALID_ID - invalid task id
+		RTEMS_INCORRECT_STATE - task not in the dormant state
+		RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task */
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t PollingTask::addSlot(object_id_t componentId,
+		uint32_t slotTimeMs, int8_t executionStep) {
+	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	sif::error << "Component " << std::hex << componentId <<
+			" not found, not adding it to pst" << std::endl;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t PollingTask::getPeriodMs() const {
+	return pst.getLengthMs();
+}
+
+ReturnValue_t PollingTask::checkAndInitializeSequence() const {
+	return pst.checkSequence();
+}
+
+#include <rtems/io.h>
+
+void PollingTask::taskFunctionality() {
+	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
+	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+
+	//The start time for the first entry is read.
+	rtems_interval interval = RtemsBasic::convertMsToTicks(
+			(*it)->pollingTimeMs);
+	TaskBase::setAndStartPeriod(interval,&periodId);
+	//The task's "infinite" inner loop is entered.
+	while (1) {
+		if (pst.slotFollowsImmediately()) {
+			//Do nothing
+		} else {
+			//The interval for the next polling slot is selected.
+			interval = RtemsBasic::convertMsToTicks(this->pst.getIntervalToNextSlotMs());
+			//The period is checked and restarted with the new interval.
+			//If the deadline was missed, the deadlineMissedFunc is called.
+			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
+			if (status == RTEMS_TIMEOUT) {
+				if (this->deadlineMissedFunc != NULL) {
+					this->deadlineMissedFunc();
+				}
+			}
+		}
+		//The device handler for this slot is executed and the next one is chosen.
+		this->pst.executeAndAdvance();
+	}
+}
+
+ReturnValue_t PollingTask::sleepFor(uint32_t ms){
+	return TaskBase::sleepFor(ms);
+};
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 60ce0816..1502f0c6 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,85 +1,85 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
-
-#include "../../tasks/FixedSlotSequence.h"
-#include "../../tasks/FixedTimeslotTaskIF.h"
-#include "TaskBase.h"
-
-class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
-	public:
-	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
-	 */
-	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
-
-	/**
-	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
-	 */
-	virtual ~PollingTask( void );
-
-	ReturnValue_t startTask( void );
-	/**
-	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
-	 */
-	static void missedDeadlineCounter();
-	/**
-	 * A helper variable to count missed deadlines.
-	 */
-	static uint32_t deadlineMissedCount;
-
-	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
-
-	uint32_t getPeriodMs() const;
-
-	ReturnValue_t checkAndInitializeSequence() const;
-
-	ReturnValue_t sleepFor(uint32_t ms);
-protected:
-	/**
-	* @brief id of the associated OS period
-	*/
-	rtems_id periodId;
-
-	FixedSlotSequence pst;
-
-	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
-	 */
-	void ( *deadlineMissedFunc )( void );
-	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
-	 */
-	static rtems_task taskEntryPoint( rtems_task_argument argument );
-
-	/**
-	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
-	 */
-	void taskFunctionality( void );
-};
-
-#endif /* POLLINGTASK_H_ */
+#ifndef POLLINGTASK_H_
+#define POLLINGTASK_H_
+
+#include "../../tasks/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "TaskBase.h"
+
+class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
+	public:
+	/**
+	 * @brief	The standard constructor of the class.
+	 *
+	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
+	 * 			the following variables are passed:
+	 *
+	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
+	 *
+	 * @param	getPst The object id of the completely initialized polling sequence.
+	 */
+	PollingTask( const char *name, rtems_task_priority setPriority, size_t setStackSize, uint32_t overallPeriod, void (*setDeadlineMissedFunc)());
+
+	/**
+	 * @brief	The destructor of the class.
+	 *
+	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
+	 * 			the device handlers. This is done by calling the PST's destructor.
+	 */
+	virtual ~PollingTask( void );
+
+	ReturnValue_t startTask( void );
+	/**
+	 * This static function can be used as #deadlineMissedFunc.
+	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 */
+	static void missedDeadlineCounter();
+	/**
+	 * A helper variable to count missed deadlines.
+	 */
+	static uint32_t deadlineMissedCount;
+
+	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+
+	uint32_t getPeriodMs() const;
+
+	ReturnValue_t checkAndInitializeSequence() const;
+
+	ReturnValue_t sleepFor(uint32_t ms);
+protected:
+	/**
+	* @brief id of the associated OS period
+	*/
+	rtems_id periodId;
+
+	FixedSlotSequence pst;
+
+	/**
+	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
+	 *
+	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
+	 * 			Currently, only one function for missing any deadline is allowed.
+	 * 			If not used, it shall be declared NULL.
+	 */
+	void ( *deadlineMissedFunc )( void );
+	/**
+	 * @brief	This is the entry point in a new polling thread.
+	 *
+	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
+	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
+	 * 			on success. If operation of the task is ended for some reason,
+	 * 			the destructor is called to free allocated memory.
+	 */
+	static rtems_task taskEntryPoint( rtems_task_argument argument );
+
+	/**
+	 * @brief	This function holds the main functionality of the thread.
+	 *
+	 *
+	 * @details	Holding the main functionality of the task, this method is most important.
+	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
+	 * 			to keep the timing of the periods.
+	 */
+	void taskFunctionality( void );
+};
+
+#endif /* POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index a492d400..fce55a0e 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,59 +1,59 @@
-#include "../../ipc/QueueFactory.h"
-#include "MessageQueue.h"
-#include "RtemsBasic.h"
-
-QueueFactory* QueueFactory::factoryInstance = NULL;
-
-
-ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
-	//TODO add ignoreFault functionality
-	message->setSender(sentFrom);
-	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
-	switch(result){
-	case RTEMS_SUCCESSFUL:
-			//message sent successfully
-			return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_ID:
-			//invalid queue id
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_SIZE:
-		// invalid message size
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//buffer is NULL
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		//out of message buffers
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		//queue's limit has been reached
-		return MessageQueueIF::FULL;
-
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
-		factoryInstance = new QueueFactory;
-	}
-	return factoryInstance;
-}
-
-QueueFactory::QueueFactory() {
-}
-
-QueueFactory::~QueueFactory() {
-}
-
-MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
-		size_t maxMessageSize) {
-	return new MessageQueue(messageDepth, maxMessageSize);
-}
-
-void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
-	delete queue;
-}
+#include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+#include "RtemsBasic.h"
+
+QueueFactory* QueueFactory::factoryInstance = NULL;
+
+
+ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+	//TODO add ignoreFault functionality
+	message->setSender(sentFrom);
+	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
+			message->messageSize);
+	switch(result){
+	case RTEMS_SUCCESSFUL:
+			//message sent successfully
+			return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_INVALID_ID:
+			//invalid queue id
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_SIZE:
+		// invalid message size
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		//buffer is NULL
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		//out of message buffers
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		//queue's limit has been reached
+		return MessageQueueIF::FULL;
+
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+QueueFactory* QueueFactory::instance() {
+	if (factoryInstance == NULL) {
+		factoryInstance = new QueueFactory;
+	}
+	return factoryInstance;
+}
+
+QueueFactory::QueueFactory() {
+}
+
+QueueFactory::~QueueFactory() {
+}
+
+MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth,
+		size_t maxMessageSize) {
+	return new MessageQueue(messageDepth, maxMessageSize);
+}
+
+void QueueFactory::deleteMessageQueue(MessageQueueIF* queue) {
+	delete queue;
+}
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index b9aa33e8..78e0d46e 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,25 +1,25 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <rtems.h>
-#include <rtems/libio.h>
-#include <rtems/error.h>
-#include <rtems/stackchk.h>
-#include <stddef.h>
-
-
-class RtemsBasic {
-public:
-	static rtems_interval convertMsToTicks(uint32_t msIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticks_per_second * msIn) / 1000;
-	}
-
-	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
-		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-		return (ticksIn * 1000) / ticks_per_second;
-	}
-};
-
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#ifndef OS_RTEMS_RTEMSBASIC_H_
+#define OS_RTEMS_RTEMSBASIC_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <rtems.h>
+#include <rtems/libio.h>
+#include <rtems/error.h>
+#include <rtems/stackchk.h>
+#include <stddef.h>
+
+
+class RtemsBasic {
+public:
+	static rtems_interval convertMsToTicks(uint32_t msIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticks_per_second * msIn) / 1000;
+	}
+
+	static rtems_interval convertTicksToMs(rtems_interval ticksIn) {
+		rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
+		return (ticksIn * 1000) / ticks_per_second;
+	}
+};
+
+#endif /* OS_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index b95ab51f..adf6ee70 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -1,82 +1,82 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "TaskBase.h"
-
-const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
-
-TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
-		const char *name) {
-	rtems_name osalName = 0;
-	for (uint8_t i = 0; i < 4; i++) {
-		if (name[i] == 0) {
-			break;
-		}
-		osalName += name[i] << (8 * (3 - i));
-	}
-	//The task is created with the operating system's system call.
-	rtems_status_code status = RTEMS_UNSATISFIED;
-	if (set_priority >= 0 && set_priority <= 99) {
-		 status = rtems_task_create(osalName,
-				(0xFF - 2 * set_priority), stack_size,
-				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
-				RTEMS_FLOATING_POINT, &id);
-	}
-	ReturnValue_t result = convertReturnCode(status);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
-				<< osalName << std::dec << " failed with return code "
-				<< (uint32_t) status << std::endl;
-		this->id = 0;
-	}
-}
-
-TaskBase::~TaskBase() {
-	rtems_task_delete(id);
-}
-
-rtems_id TaskBase::getId() {
-	return this->id;
-}
-
-ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
-	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
-	return convertReturnCode(status);
-}
-
-
-ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
-	switch (inValue) {
-	case RTEMS_SUCCESSFUL:
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_MP_NOT_CONFIGURED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_NAME:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_TOO_MANY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_UNSATISFIED:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_PRIORITY:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-
-ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
-	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
-	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
-	if (status == RTEMS_SUCCESSFUL) {
-		status = restartPeriod(period,*periodId);
-	}
-	return convertReturnCode(status);
-}
-
-rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
-	//This is necessary to avoid a call with period = 0, which does not start the period.
-	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
-	return status;
-}
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "TaskBase.h"
+
+const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE;
+
+TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
+		const char *name) {
+	rtems_name osalName = 0;
+	for (uint8_t i = 0; i < 4; i++) {
+		if (name[i] == 0) {
+			break;
+		}
+		osalName += name[i] << (8 * (3 - i));
+	}
+	//The task is created with the operating system's system call.
+	rtems_status_code status = RTEMS_UNSATISFIED;
+	if (set_priority >= 0 && set_priority <= 99) {
+		 status = rtems_task_create(osalName,
+				(0xFF - 2 * set_priority), stack_size,
+				RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
+				RTEMS_FLOATING_POINT, &id);
+	}
+	ReturnValue_t result = convertReturnCode(status);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		error << "TaskBase::TaskBase: createTask with name " << std::hex
+				<< osalName << std::dec << " failed with return code "
+				<< (uint32_t) status << std::endl;
+		this->id = 0;
+	}
+}
+
+TaskBase::~TaskBase() {
+	rtems_task_delete(id);
+}
+
+rtems_id TaskBase::getId() {
+	return this->id;
+}
+
+ReturnValue_t TaskBase::sleepFor(uint32_t ms) {
+	rtems_status_code status = rtems_task_wake_after(RtemsBasic::convertMsToTicks(ms));
+	return convertReturnCode(status);
+}
+
+
+ReturnValue_t TaskBase::convertReturnCode(rtems_status_code inValue) {
+	switch (inValue) {
+	case RTEMS_SUCCESSFUL:
+		return HasReturnvaluesIF::RETURN_OK;
+	case RTEMS_MP_NOT_CONFIGURED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_NAME:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_TOO_MANY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_ADDRESS:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_UNSATISFIED:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	case RTEMS_INVALID_PRIORITY:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+}
+
+
+ReturnValue_t TaskBase::setAndStartPeriod(rtems_interval period, rtems_id *periodId) {
+	rtems_name periodName = (('P' << 24) + ('e' << 16) + ('r' << 8) + 'd');
+	rtems_status_code status = rtems_rate_monotonic_create(periodName, periodId);
+	if (status == RTEMS_SUCCESSFUL) {
+		status = restartPeriod(period,*periodId);
+	}
+	return convertReturnCode(status);
+}
+
+rtems_status_code TaskBase::restartPeriod(rtems_interval period, rtems_id periodId){
+	//This is necessary to avoid a call with period = 0, which does not start the period.
+	rtems_status_code status = rtems_rate_monotonic_period(periodId, period + 1);
+	return status;
+}
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index 3010a972..410d9110 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,47 +1,47 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
-
-#include "RtemsBasic.h"
-#include "../../tasks/PeriodicTaskIF.h"
-
-/**
- * @brief	This is the basic task handling class for rtems.
- *
- * @details Task creation base class for rtems.
- */
-class TaskBase {
-protected:
-	/**
-	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
-	 * 			If initialization fails, the id is set to zero.
-	 */
-	rtems_id id;
-public:
-	/**
-	 * @brief	The constructor creates and initializes a task.
-	 * @details	This is accomplished by using the operating system call to create a task. The name is
-	 * 			created automatically with the help od taskCounter. Priority and stack size are
-	 * 			adjustable, all other attributes are set with default values.
-	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
-	 * @param stack_size	The stack size reserved by the operating system for the task.
-	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
-	 */
-	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
-	/**
-	 * @brief	In the destructor, the created task is deleted.
-	 */
-	virtual ~TaskBase();
-	/**
-	 * @brief	This method returns the task id of this class.
-	 */
-	rtems_id getId();
-
-	ReturnValue_t sleepFor(uint32_t ms);
-	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
-	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
-private:
-	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
-};
-
-
-#endif /* TASKBASE_H_ */
+#ifndef TASKBASE_H_
+#define TASKBASE_H_
+
+#include "RtemsBasic.h"
+#include "../../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief	This is the basic task handling class for rtems.
+ *
+ * @details Task creation base class for rtems.
+ */
+class TaskBase {
+protected:
+	/**
+	 * @brief	The class stores the task id it got assigned from the operating system in this attribute.
+	 * 			If initialization fails, the id is set to zero.
+	 */
+	rtems_id id;
+public:
+	/**
+	 * @brief	The constructor creates and initializes a task.
+	 * @details	This is accomplished by using the operating system call to create a task. The name is
+	 * 			created automatically with the help od taskCounter. Priority and stack size are
+	 * 			adjustable, all other attributes are set with default values.
+	 * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
+	 * @param stack_size	The stack size reserved by the operating system for the task.
+	 * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars supported (excluding Null-terminator), rest will be truncated
+	 */
+	TaskBase( rtems_task_priority priority, size_t stack_size, const char  *name);
+	/**
+	 * @brief	In the destructor, the created task is deleted.
+	 */
+	virtual ~TaskBase();
+	/**
+	 * @brief	This method returns the task id of this class.
+	 */
+	rtems_id getId();
+
+	ReturnValue_t sleepFor(uint32_t ms);
+	static ReturnValue_t setAndStartPeriod(rtems_interval period, rtems_id *periodId);
+	static rtems_status_code restartPeriod(rtems_interval period, rtems_id periodId);
+private:
+	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
+};
+
+
+#endif /* TASKBASE_H_ */
diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp
index f79571f0..bab48a44 100644
--- a/osal/rtems/TaskFactory.cpp
+++ b/osal/rtems/TaskFactory.cpp
@@ -1,41 +1,41 @@
-#include "../../tasks/TaskFactory.h"
-#include "MultiObjectTask.h"
-#include "PollingTask.h"
-#include "InitTask.h"
-#include "RtemsBasic.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
-TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
-
-TaskFactory::~TaskFactory() {
-}
-
-TaskFactory* TaskFactory::instance() {
-	return TaskFactory::factoryInstance;
-}
-
-PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-
-	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
-	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
-}
-
-ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
-	//TODO not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
-	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
-	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-TaskFactory::TaskFactory() {
-}
+#include "../../tasks/TaskFactory.h"
+#include "MultiObjectTask.h"
+#include "PollingTask.h"
+#include "InitTask.h"
+#include "RtemsBasic.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
+TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
+
+TaskFactory::~TaskFactory() {
+}
+
+TaskFactory* TaskFactory::instance() {
+	return TaskFactory::factoryInstance;
+}
+
+PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+
+	return static_cast<PeriodicTaskIF*>(new MultiObjectTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,TaskPriority taskPriority_,TaskStackSize stackSize_,TaskPeriod periodInSeconds_,TaskDeadlineMissedFunction deadLineMissedFunction_) {
+	rtems_interval taskPeriod = periodInSeconds_ * Clock::getTicksPerSecond();
+	return static_cast<FixedTimeslotTaskIF*>(new PollingTask(name_,taskPriority_,stackSize_,taskPeriod,deadLineMissedFunction_));
+}
+
+ReturnValue_t TaskFactory::deleteTask(PeriodicTaskIF* task) {
+	//TODO not implemented
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
+	rtems_task_wake_after(RtemsBasic::convertMsToTicks(delayMs));
+	//Only return value is "RTEMS_SUCCESSFUL - always successful" so it has been neglected
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+TaskFactory::TaskFactory() {
+}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 14446e3c..0c6afc12 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,67 +1,67 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
-
-#include "../parameters/ParameterWrapper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
-
-/** Each parameter is identified with a unique parameter ID */
-typedef uint32_t ParameterId_t;
-
-/**
- * @brief	This interface is used by components which have modifiable
- * 			parameters, e.g. atittude controllers
- * @details
- * Each parameter has a unique parameter ID. The first byte of the parameter
- * ID is the domain ID which can be used to identify unqiue spacecraft domains
- * (e.g. control and sensor domain in the AOCS controller).
- *
- * The second and third byte represent the matrix ID, which can represent
- * a 8-bit row and column number and the last byte...
- *
- * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
- * of a 8 bit number now?
- */
-class HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
-
-	static uint8_t getDomain(ParameterId_t id) {
-		return id >> 24;
-	}
-
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
-	}
-
-	static uint8_t getIndex(ParameterId_t id) {
-		return id;
-	}
-
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
-	}
-
-	virtual ~HasParametersIF() {}
-
-	/**
-	 * Always set parameter before checking newValues!
-	 *
-	 * @param domainId
-	 * @param parameterId
-	 * @param parameterWrapper
-	 * @param newValues
-	 * @param startAtIndex
-	 * @return
-	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
-};
-
-#endif /* HASPARAMETERSIF_H_ */
+#ifndef HASPARAMETERSIF_H_
+#define HASPARAMETERSIF_H_
+
+#include "../parameters/ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+/** Each parameter is identified with a unique parameter ID */
+typedef uint32_t ParameterId_t;
+
+/**
+ * @brief	This interface is used by components which have modifiable
+ * 			parameters, e.g. atittude controllers
+ * @details
+ * Each parameter has a unique parameter ID. The first byte of the parameter
+ * ID is the domain ID which can be used to identify unqiue spacecraft domains
+ * (e.g. control and sensor domain in the AOCS controller).
+ *
+ * The second and third byte represent the matrix ID, which can represent
+ * a 8-bit row and column number and the last byte...
+ *
+ * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
+ * of a 8 bit number now?
+ */
+class HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
+	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
+
+	static uint8_t getDomain(ParameterId_t id) {
+		return id >> 24;
+	}
+
+	static uint16_t getMatrixId(ParameterId_t id) {
+		return id >> 8;
+	}
+
+	static uint8_t getIndex(ParameterId_t id) {
+		return id;
+	}
+
+	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
+			uint8_t index) {
+		return (domainId << 24) + (parameterId << 8) + index;
+	}
+
+	virtual ~HasParametersIF() {}
+
+	/**
+	 * Always set parameter before checking newValues!
+	 *
+	 * @param domainId
+	 * @param parameterId
+	 * @param parameterWrapper
+	 * @param newValues
+	 * @param startAtIndex
+	 * @return
+	 */
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
+};
+
+#endif /* HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 55633566..ec7ded3c 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,132 +1,132 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../parameters/ParameterMessage.h"
-
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
-
-ParameterHelper::~ParameterHelper() {
-}
-
-ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
-
-		const uint8_t *storedStream = nullptr;
-		size_t storedStreamSize = 0;
-		result = storage->getData(
-				ParameterMessage::getStoreId(message), &storedStream,
-				&storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					" store data failed for load command." << std::endl;
-			break;
-		}
-
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
-				&streamWrapper, index);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
-
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
-		}
-	}
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->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 = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
-
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
-
-	CommandMessage reply;
-
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
-
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
-
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../parameters/ParameterMessage.h"
+
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
+		owner(owner) {}
+
+ParameterHelper::~ParameterHelper() {
+}
+
+ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch (message->getCommand()) {
+	case ParameterMessage::CMD_PARAMETER_DUMP: {
+		ParameterWrapper description;
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		result = owner->getParameter(domain, parameterId,
+				&description, &description, 0);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &description);
+		}
+	}
+		break;
+	case ParameterMessage::CMD_PARAMETER_LOAD: {
+		uint8_t domain = HasParametersIF::getDomain(
+				ParameterMessage::getParameterId(message));
+		uint16_t parameterId = HasParametersIF::getMatrixId(
+				ParameterMessage::getParameterId(message));
+		uint8_t index = HasParametersIF::getIndex(
+				ParameterMessage::getParameterId(message));
+
+		const uint8_t *storedStream = nullptr;
+		size_t storedStreamSize = 0;
+		result = storage->getData(
+				ParameterMessage::getStoreId(message), &storedStream,
+				&storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			sif::error << "ParameterHelper::handleParameterMessage: Getting"
+					" store data failed for load command." << std::endl;
+			break;
+		}
+
+		ParameterWrapper streamWrapper;
+		result = streamWrapper.set(storedStream, storedStreamSize);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		ParameterWrapper ownerWrapper;
+		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+				&streamWrapper, index);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			storage->deleteData(ParameterMessage::getStoreId(message));
+			break;
+		}
+
+		result = ownerWrapper.copyFrom(&streamWrapper, index);
+
+		storage->deleteData(ParameterMessage::getStoreId(message));
+
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			result = sendParameter(message->getSender(),
+					ParameterMessage::getParameterId(message), &ownerWrapper);
+		}
+	}
+		break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		rejectCommand(message->getSender(), result, message->getCommand());
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
+		const ParameterWrapper* description) {
+	size_t serializedSize = description->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 = description->serialize(&storeElement, &storeElementSize,
+			serializedSize, SerializeIF::Endianness::BIG);
+
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		storage->deleteData(address);
+		return result;
+	}
+
+	CommandMessage reply;
+
+	ParameterMessage::setParameterDumpReply(&reply, id, address);
+
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterHelper::initialize() {
+	ownerQueueId = owner->getCommandQueue();
+
+
+	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if (storage == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	} else {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+		Command_t initialCommand) {
+	CommandMessage reply;
+	reply.setReplyRejected(reason, initialCommand);
+	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 668bb081..5dd78b64 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ParameterMessage.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-
-/**
- * @brief	Helper class to handle parameter messages
- * @details
- * This class simplfiies handling of parameter messages, which are sent
- * to a class which implements ReceivesParameterMessagesIF.
- */
-class ParameterHelper {
-public:
-	ParameterHelper(ReceivesParameterMessagesIF *owner);
-	virtual ~ParameterHelper();
-
-	ReturnValue_t handleParameterMessage(CommandMessage *message);
-
-	ReturnValue_t initialize();
-private:
-	ReceivesParameterMessagesIF *owner;
-
-	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
-
-	StorageManagerIF *storage = nullptr;
-
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const ParameterWrapper *description);
-
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* PARAMETERHELPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+
+#include "../ipc/MessageQueueIF.h"
+#include "../parameters/ParameterMessage.h"
+#include "../parameters/ReceivesParameterMessagesIF.h"
+
+/**
+ * @brief	Helper class to handle parameter messages
+ * @details
+ * This class simplfiies handling of parameter messages, which are sent
+ * to a class which implements ReceivesParameterMessagesIF.
+ */
+class ParameterHelper {
+public:
+	ParameterHelper(ReceivesParameterMessagesIF *owner);
+	virtual ~ParameterHelper();
+
+	ReturnValue_t handleParameterMessage(CommandMessage *message);
+
+	ReturnValue_t initialize();
+private:
+	ReceivesParameterMessagesIF *owner;
+
+	MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
+
+	StorageManagerIF *storage = nullptr;
+
+	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
+			const ParameterWrapper *description);
+
+	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
+			Command_t initialCommand);
+};
+
+#endif /* PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 0cc4dd90..e9f3191f 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -1,48 +1,48 @@
-#include "../parameters/ParameterMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
-	return message->getParameter();
-}
-
-store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter2();
-	return address;
-}
-
-void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
-		ParameterId_t id) {
-	message->setCommand(CMD_PARAMETER_DUMP);
-	message->setParameter(id);
-}
-
-void ParameterMessage::setParameterDumpReply(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(REPLY_PARAMETER_DUMP);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
-	message->setCommand(CMD_PARAMETER_LOAD);
-	message->setParameter(id);
-	message->setParameter2(storageID.raw);
-}
-
-void ParameterMessage::clear(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case CMD_PARAMETER_LOAD:
-	case REPLY_PARAMETER_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}
+#include "../parameters/ParameterMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
+	return message->getParameter();
+}
+
+store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter2();
+	return address;
+}
+
+void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
+		ParameterId_t id) {
+	message->setCommand(CMD_PARAMETER_DUMP);
+	message->setParameter(id);
+}
+
+void ParameterMessage::setParameterDumpReply(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(REPLY_PARAMETER_DUMP);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
+		ParameterId_t id, store_address_t storageID) {
+	message->setCommand(CMD_PARAMETER_LOAD);
+	message->setParameter(id);
+	message->setParameter2(storageID.raw);
+}
+
+void ParameterMessage::clear(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case CMD_PARAMETER_LOAD:
+	case REPLY_PARAMETER_DUMP: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(message));
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 51321f2b..de68dcfc 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,29 +1,29 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../parameters/HasParametersIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-class ParameterMessage {
-private:
-	ParameterMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
-	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
-
-	static ParameterId_t getParameterId(const CommandMessage* message);
-	static store_address_t getStoreId(const CommandMessage* message);
-	static void setParameterDumpCommand(CommandMessage* message,
-			ParameterId_t id);
-	static void setParameterDumpReply(CommandMessage* message,
-			ParameterId_t id,  store_address_t storageID);
-	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
-	static void clear(CommandMessage* message);
-
-};
-
-#endif /* PARAMETERMESSAGE_H_ */
+#ifndef PARAMETERMESSAGE_H_
+#define PARAMETERMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+class ParameterMessage {
+private:
+	ParameterMessage();
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
+	static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
+	static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
+	static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
+
+	static ParameterId_t getParameterId(const CommandMessage* message);
+	static store_address_t getStoreId(const CommandMessage* message);
+	static void setParameterDumpCommand(CommandMessage* message,
+			ParameterId_t id);
+	static void setParameterDumpReply(CommandMessage* message,
+			ParameterId_t id,  store_address_t storageID);
+	static void setParameterLoadCommand(CommandMessage* message,
+			ParameterId_t id, store_address_t storageID);
+	static void clear(CommandMessage* message);
+
+};
+
+#endif /* PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 8e6dd86c..fd36a0a9 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,280 +1,280 @@
-#include "../parameters/ParameterWrapper.h"
-
-ParameterWrapper::ParameterWrapper() :
-		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(data), readonlyData(data) {
-}
-
-ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-		const void *data) :
-		pointsToStream(false), type(type), rows(rows), columns(columns),
-		data(nullptr), readonlyData(data) {
-}
-
-ParameterWrapper::~ParameterWrapper() {
-}
-
-ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	//serialize uses readonlyData, as it is always valid
-	if (readonlyData == NULL) {
-		return NOT_SET;
-	}
-	switch (type) {
-	case Type::UINT8_T:
-		result = serializeData<uint8_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT8_T:
-		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::UINT16_T:
-		result = serializeData<uint16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT16_T:
-		result = serializeData<int16_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::UINT32_T:
-		result = serializeData<uint32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::INT32_T:
-		result = serializeData<int32_t>(buffer, size, maxSize,
-				streamEndianness);
-		break;
-	case Type::FLOAT:
-		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
-		break;
-	case Type::DOUBLE:
-		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
-		break;
-	default:
-		result = UNKNOW_DATATYPE;
-		break;
-	}
-	return result;
-}
-
-size_t ParameterWrapper::getSerializedSize() const {
-	uint32_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
-		size_t maxSize, Endianness streamEndianness) const {
-	const T *element = (const T*) readonlyData;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	uint16_t dataSize = columns * rows;
-	while (dataSize != 0) {
-		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		element++;
-		dataSize--;
-	}
-	return result;
-}
-
-template<typename T>
-ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void *from, uint8_t fromRows,
-		uint8_t fromColumns) {
-
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
-	size_t streamSize = fromRows * fromColumns * sizeof(T);
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
-
-		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
-			result = SerializeAdapter::deSerialize(
-					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
-					SerializeIF::Endianness::BIG);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-	}
-
-	return result;
-
-}
-
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness) {
-	return deSerialize(buffer, size, streamEndianness, 0);
-}
-
-ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
-		size_t *size, Endianness streamEndianness,
-		uint16_t startWritingAtIndex) {
-	ParameterWrapper streamDescription;
-
-	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return copyFrom(&streamDescription, startWritingAtIndex);
-}
-
-ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
-		const uint8_t **remainingStream, size_t *remainingSize) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
-			&streamSize, SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	size_t dataSize = type.getSize() * rows * columns;
-
-	if (streamSize < dataSize) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
-
-	data = nullptr;
-	readonlyData = stream;
-	pointsToStream = true;
-
-	stream += dataSize;
-	if (remainingStream !=  nullptr) {
-		*remainingStream = stream;
-	}
-	streamSize -= dataSize;
-	if (remainingSize != nullptr) {
-		*remainingSize = streamSize;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
-		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
-		return READONLY;
-	}
-
-	if (from->readonlyData == NULL) {
-		return SOURCE_NOT_SET;
-	}
-
-	if (type != from->type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return TOO_BIG;
-	}
-
-	uint8_t typeSize = type.getSize();
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows, from->columns);
-			break;
-		default:
-			result = UNKNOW_DATATYPE;
-			break;
-		}
-	}
-	else {
-		//need a type to do arithmetic
-		uint8_t* typedData = static_cast<uint8_t*>(data);
-		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
-			std::memcpy(typedData +  offset, from->readonlyData,
-					typeSize * from->columns);
-		}
-	}
-
-	return result;
-}
+#include "../parameters/ParameterWrapper.h"
+
+ParameterWrapper::ParameterWrapper() :
+		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(data), readonlyData(data) {
+}
+
+ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+		const void *data) :
+		pointsToStream(false), type(type), rows(rows), columns(columns),
+		data(nullptr), readonlyData(data) {
+}
+
+ParameterWrapper::~ParameterWrapper() {
+}
+
+ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result;
+
+	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
+			streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	//serialize uses readonlyData, as it is always valid
+	if (readonlyData == NULL) {
+		return NOT_SET;
+	}
+	switch (type) {
+	case Type::UINT8_T:
+		result = serializeData<uint8_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT8_T:
+		result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::UINT16_T:
+		result = serializeData<uint16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT16_T:
+		result = serializeData<int16_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::UINT32_T:
+		result = serializeData<uint32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::INT32_T:
+		result = serializeData<int32_t>(buffer, size, maxSize,
+				streamEndianness);
+		break;
+	case Type::FLOAT:
+		result = serializeData<float>(buffer, size, maxSize, streamEndianness);
+		break;
+	case Type::DOUBLE:
+		result = serializeData<double>(buffer, size, maxSize, streamEndianness);
+		break;
+	default:
+		result = UNKNOW_DATATYPE;
+		break;
+	}
+	return result;
+}
+
+size_t ParameterWrapper::getSerializedSize() const {
+	uint32_t serializedSize = 0;
+	serializedSize += type.getSerializedSize();
+	serializedSize += sizeof(rows);
+	serializedSize += sizeof(columns);
+	serializedSize += rows * columns * type.getSize();
+
+	return serializedSize;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
+		size_t maxSize, Endianness streamEndianness) const {
+	const T *element = (const T*) readonlyData;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	uint16_t dataSize = columns * rows;
+	while (dataSize != 0) {
+		result = SerializeAdapter::serialize(element, buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		element++;
+		dataSize--;
+	}
+	return result;
+}
+
+template<typename T>
+ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
+		uint8_t startingColumn, const void *from, uint8_t fromRows,
+		uint8_t fromColumns) {
+
+	//treat from as a continuous Stream as we copy all of it
+	const uint8_t *fromAsStream = (const uint8_t*) from;
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
+
+		//get the start element of this row in data
+		T *dataWithDataType = ((T*) data)
+				+ (((startingRow + fromRow) * columns) + startingColumn);
+
+		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
+			result = SerializeAdapter::deSerialize(
+					dataWithDataType + fromColumn, &fromAsStream, &streamSize,
+					SerializeIF::Endianness::BIG);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness) {
+	return deSerialize(buffer, size, streamEndianness, 0);
+}
+
+ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
+		size_t *size, Endianness streamEndianness,
+		uint16_t startWritingAtIndex) {
+	ParameterWrapper streamDescription;
+
+	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return copyFrom(&streamDescription, startWritingAtIndex);
+}
+
+ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
+			&streamSize, SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
+			SerializeIF::Endianness::BIG);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	size_t dataSize = type.getSize() * rows * columns;
+
+	if (streamSize < dataSize) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
+
+	data = nullptr;
+	readonlyData = stream;
+	pointsToStream = true;
+
+	stream += dataSize;
+	if (remainingStream !=  nullptr) {
+		*remainingStream = stream;
+	}
+	streamSize -= dataSize;
+	if (remainingSize != nullptr) {
+		*remainingSize = streamSize;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
+		uint16_t startWritingAtIndex) {
+	if (data == NULL) {
+		return READONLY;
+	}
+
+	if (from->readonlyData == NULL) {
+		return SOURCE_NOT_SET;
+	}
+
+	if (type != from->type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	//check if from fits into this
+	uint8_t startingRow = startWritingAtIndex / columns;
+	uint8_t startingColumn = startWritingAtIndex % columns;
+
+	if ((from->rows > (rows - startingRow))
+			|| (from->columns > (columns - startingColumn))) {
+		return TOO_BIG;
+	}
+
+	uint8_t typeSize = type.getSize();
+
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	//copy data
+	if (from->pointsToStream) {
+		switch (type) {
+		case Type::UINT8_T:
+			result = deSerializeData<uint8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT8_T:
+			result = deSerializeData<int8_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT16_T:
+			result = deSerializeData<uint16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT16_T:
+			result = deSerializeData<int16_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::UINT32_T:
+			result = deSerializeData<uint32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::INT32_T:
+			result = deSerializeData<int32_t>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::FLOAT:
+			result = deSerializeData<float>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		case Type::DOUBLE:
+			result = deSerializeData<double>(startingRow, startingColumn,
+					from->readonlyData, from->rows, from->columns);
+			break;
+		default:
+			result = UNKNOW_DATATYPE;
+			break;
+		}
+	}
+	else {
+		//need a type to do arithmetic
+		uint8_t* typedData = static_cast<uint8_t*>(data);
+		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
+			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			std::memcpy(typedData +  offset, from->readonlyData,
+					typeSize * from->columns);
+		}
+	}
+
+	return result;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 1f38f691..35045959 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeIF.h"
-#include <stddef.h>
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief
- * @details
- */
-class ParameterWrapper: public SerializeIF {
-	friend class DataPoolParameterWrapper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
-	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
-
-	ParameterWrapper();
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
-	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
-			const void *data);
-	virtual ~ParameterWrapper();
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
-
-	/**
-	 * Get a specific parameter value by supplying the row and the column.
-	 * @tparam T Type of target data
-	 * @param value [out] Pointer to storage location
-	 * @param row
-	 * @param column
-	 * @return
-	 * -@c RETURN_OK if element was retrieved successfully
-	 * -@c NOT_SET data has not been set yet
-	 * -@c DATATYPE_MISSMATCH Invalid supplied type
-	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
-	 */
-	template<typename T>
-	ReturnValue_t getElement(T *value, uint8_t row = 0,
-			uint8_t column = 0) const;
-
-	template<typename T>
-	void set(T *data, uint8_t rows, uint8_t columns) {
-		this->data = data;
-		this->readonlyData = data;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
-		this->readonlyData = readonlyData;
-		this->type = PodTypeConversion<T>::type;
-		this->rows = rows;
-		this->columns = columns;
-		this->pointsToStream = false;
-	}
-
-	template<typename T>
-	void set(T& member) {
-		this->set(&member, 1, 1);
-	}
-
-	template<typename T>
-	void set(const T& readonlyMember) {
-		this->set(&readonlyMember, 1, 1);
-	}
-
-	template<typename T>
-	void setVector(T& member) {
-		this->set(member, sizeof(member)/sizeof(member[0]), 1);
-	}
-
-	template<typename T>
-	void setVector(const T& member) {
-		this->set(member, 1, sizeof(member)/sizeof(member[0]));
-	}
-	template<typename T>
-	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	template<typename T>
-	void setMatrix(const T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
-	}
-
-	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
-			const uint8_t **remainingStream = nullptr,
-			size_t *remainingSize = nullptr);
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	bool pointsToStream = false;
-
-	Type type;
-	uint8_t rows = 0;
-	uint8_t columns = 0;
-	void *data = nullptr;
-	const void *readonlyData = nullptr;
-
-	template<typename T>
-	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows, uint8_t fromColumns);
-};
-
-template <typename T>
-inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
-		uint8_t column) const {
-	if (readonlyData == nullptr){
-		return NOT_SET;
-	}
-
-	if (PodTypeConversion<T>::type != type) {
-		return DATATYPE_MISSMATCH;
-	}
-
-	if ((row >= rows) or (column >= columns)) {
-		return OUT_OF_BOUNDS;
-	}
-
-	if (pointsToStream) {
-		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
-		streamWithType += (row * columns + column) * type.getSize();
-		int32_t size = type.getSize();
-		return SerializeAdapter::deSerialize(value, &streamWithType,
-				&size, true);
-	}
-	else {
-		const T *dataWithType = static_cast<const T*>(readonlyData);
-		*value = dataWithType[row * columns + column];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-}
-
-#endif /* PARAMETERWRAPPER_H_ */
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeIF.h"
+#include <stddef.h>
+#include "../globalfunctions/Type.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ParameterWrapper: public SerializeIF {
+	friend class DataPoolParameterWrapper;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
+	static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+
+	ParameterWrapper();
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
+	ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
+			const void *data);
+	virtual ~ParameterWrapper();
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	virtual size_t getSerializedSize() const override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
+
+	/**
+	 * Get a specific parameter value by supplying the row and the column.
+	 * @tparam T Type of target data
+	 * @param value [out] Pointer to storage location
+	 * @param row
+	 * @param column
+	 * @return
+	 * -@c RETURN_OK if element was retrieved successfully
+	 * -@c NOT_SET data has not been set yet
+	 * -@c DATATYPE_MISSMATCH Invalid supplied type
+	 * -@c OUT_OF_BOUNDS Invalid row and/or column.
+	 */
+	template<typename T>
+	ReturnValue_t getElement(T *value, uint8_t row = 0,
+			uint8_t column = 0) const;
+
+	template<typename T>
+	void set(T *data, uint8_t rows, uint8_t columns) {
+		this->data = data;
+		this->readonlyData = data;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
+		this->data = NULL;
+		this->readonlyData = readonlyData;
+		this->type = PodTypeConversion<T>::type;
+		this->rows = rows;
+		this->columns = columns;
+		this->pointsToStream = false;
+	}
+
+	template<typename T>
+	void set(T& member) {
+		this->set(&member, 1, 1);
+	}
+
+	template<typename T>
+	void set(const T& readonlyMember) {
+		this->set(&readonlyMember, 1, 1);
+	}
+
+	template<typename T>
+	void setVector(T& member) {
+		this->set(member, sizeof(member)/sizeof(member[0]), 1);
+	}
+
+	template<typename T>
+	void setVector(const T& member) {
+		this->set(member, 1, sizeof(member)/sizeof(member[0]));
+	}
+	template<typename T>
+	void setMatrix(T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	template<typename T>
+	void setMatrix(const T& member) {
+		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+	}
+
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = nullptr,
+			size_t *remainingSize = nullptr);
+
+	ReturnValue_t copyFrom(const ParameterWrapper *from,
+			uint16_t startWritingAtIndex);
+
+private:
+	bool pointsToStream = false;
+
+	Type type;
+	uint8_t rows = 0;
+	uint8_t columns = 0;
+	void *data = nullptr;
+	const void *readonlyData = nullptr;
+
+	template<typename T>
+	ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const;
+
+	template<typename T>
+	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
+			const void *from, uint8_t fromRows, uint8_t fromColumns);
+};
+
+template <typename T>
+inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
+		uint8_t column) const {
+	if (readonlyData == nullptr){
+		return NOT_SET;
+	}
+
+	if (PodTypeConversion<T>::type != type) {
+		return DATATYPE_MISSMATCH;
+	}
+
+	if ((row >= rows) or (column >= columns)) {
+		return OUT_OF_BOUNDS;
+	}
+
+	if (pointsToStream) {
+		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
+		streamWithType += (row * columns + column) * type.getSize();
+		int32_t size = type.getSize();
+		return SerializeAdapter::deSerialize(value, &streamWithType,
+				&size, true);
+	}
+	else {
+		const T *dataWithType = static_cast<const T*>(readonlyData);
+		*value = dataWithType[row * columns + column];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+}
+
+#endif /* PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index 9a280b4f..f8c3746e 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,19 +1,19 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
-
-
-#include "../parameters/HasParametersIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-
-class ReceivesParameterMessagesIF : public HasParametersIF {
-public:
-
-	static const uint8_t DOMAIN_ID_BASE = 0;
-	virtual ~ReceivesParameterMessagesIF() {
-	}
-
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-};
-
-
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#ifndef RECEIVESPARAMETERMESSAGESIF_H_
+#define RECEIVESPARAMETERMESSAGESIF_H_
+
+
+#include "../parameters/HasParametersIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+
+class ReceivesParameterMessagesIF : public HasParametersIF {
+public:
+
+	static const uint8_t DOMAIN_ID_BASE = 0;
+	virtual ~ReceivesParameterMessagesIF() {
+	}
+
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+};
+
+
+#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 59d60491..3ea0b18c 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,260 +1,260 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../power/Fuse.h"
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../ipc/QueueFactory.h"
-
-object_id_t Fuse::powerSwitchId = 0;
-
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Fuse::~Fuse() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-void Fuse::addDevice(PowerComponentIF* switchSet) {
-	devices.push_back(switchSet);
-}
-
-ReturnValue_t Fuse::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (powerIF == NULL) {
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void Fuse::calculatePowerLimits(float* low, float* high) {
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			*low += (*iter)->getMin();
-			*high += (*iter)->getMax();
-		}
-	}
-}
-
-ReturnValue_t Fuse::check() {
-	set.read();
-	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
-		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
-	}
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	checkFuseState();
-	calculateFusePower();
-	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
-	set.commit();
-	return result;
-}
-
-ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-size_t Fuse::getSerializedSize() const {
-	uint32_t size = 0;
-	for (DeviceList::const_iterator iter = devices.begin();
-			iter != devices.end(); iter++) {
-		size += (*iter)->getSerializedSize();
-	}
-	return size;
-}
-
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = RETURN_FAILED;
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		result = (*iter)->deSerialize(buffer, size, streamEndianness);
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-	return RETURN_OK;
-}
-
-uint8_t Fuse::getFuseId() const {
-	return fuseId;
-}
-
-void Fuse::calculateFusePower() {
-	ReturnValue_t result1 = currentLimit.check();
-	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
-		power.setValid(PoolVariableIF::INVALID);
-		return;
-	}
-	//Calculate fuse power.
-	power = current * voltage;
-	power.setValid(PoolVariableIF::VALID);
-}
-
-ReturnValue_t Fuse::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Fuse::reportEvents(Event event) {
-	if (!powerMonitor.isEventEnabled()) {
-		return;
-	}
-	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
-			iter++) {
-		if (areSwitchesOfComponentOn(iter)) {
-			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
-		}
-	}
-}
-
-MessageQueueId_t Fuse::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void Fuse::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	powerMonitor.setToUnchecked();
-}
-
-void Fuse::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void Fuse::checkFuseState() {
-	if (!state.isValid()) {
-		oldFuseState = 0;
-		return;
-	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
-}
-
-float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
-}
-
-void Fuse::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
-
-bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
-	if (powerIF->getSwitchState((*iter)->getSwitchId1())
-			!= PowerSwitchIF::SWITCH_ON) {
-		return false;
-	}
-	if ((*iter)->hasTwoSwitches()) {
-		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
-				!= PowerSwitchIF::SWITCH_ON)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool Fuse::isPowerValid() {
-	return power.isValid();
-}
-
-ReturnValue_t Fuse::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return RETURN_OK;
-}
-
-HasHealthIF::HealthState Fuse::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
-		float upperLimit) {
-	if (sample > upperLimit) {
-		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
-				upperLimit);
-	} else if (sample < lowerLimit) {
-		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
-				lowerLimit);
-	} else {
-		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/Fuse.h"
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t Fuse::powerSwitchId = 0;
+
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+		float maxCurrent, uint16_t confirmationCount) :
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
+		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
+				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
+				ids.pidCurrent, &set), state(ids.pidState, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
+				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Fuse::~Fuse() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+void Fuse::addDevice(PowerComponentIF* switchSet) {
+	devices.push_back(switchSet);
+}
+
+ReturnValue_t Fuse::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (powerIF == NULL) {
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void Fuse::calculatePowerLimits(float* low, float* high) {
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			*low += (*iter)->getMin();
+			*high += (*iter)->getMax();
+		}
+	}
+}
+
+ReturnValue_t Fuse::check() {
+	set.read();
+	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
+		setAllMonitorsToUnchecked();
+		set.commit(PoolVariableIF::INVALID);
+		return RETURN_OK;
+	}
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	checkFuseState();
+	calculateFusePower();
+	//Check if power is valid and if fuse state is off or invalid.
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
+	set.commit();
+	return result;
+}
+
+ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+size_t Fuse::getSerializedSize() const {
+	uint32_t size = 0;
+	for (DeviceList::const_iterator iter = devices.begin();
+			iter != devices.end(); iter++) {
+		size += (*iter)->getSerializedSize();
+	}
+	return size;
+}
+
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = RETURN_FAILED;
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		result = (*iter)->deSerialize(buffer, size, streamEndianness);
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+	return RETURN_OK;
+}
+
+uint8_t Fuse::getFuseId() const {
+	return fuseId;
+}
+
+void Fuse::calculateFusePower() {
+	ReturnValue_t result1 = currentLimit.check();
+	if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
+		power.setValid(PoolVariableIF::INVALID);
+		return;
+	}
+	//Calculate fuse power.
+	power = current * voltage;
+	power.setValid(PoolVariableIF::VALID);
+}
+
+ReturnValue_t Fuse::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Fuse::reportEvents(Event event) {
+	if (!powerMonitor.isEventEnabled()) {
+		return;
+	}
+	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
+			iter++) {
+		if (areSwitchesOfComponentOn(iter)) {
+			EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
+		}
+	}
+}
+
+MessageQueueId_t Fuse::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+void Fuse::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	powerMonitor.setToUnchecked();
+}
+
+void Fuse::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void Fuse::checkFuseState() {
+	if (!state.isValid()) {
+		oldFuseState = 0;
+		return;
+	}
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state;
+}
+
+float Fuse::getPower() {
+	if (power.isValid()) {
+		return power;
+	} else {
+		return 0.0;
+	}
+}
+
+void Fuse::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
+
+bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
+	if (powerIF->getSwitchState((*iter)->getSwitchId1())
+			!= PowerSwitchIF::SWITCH_ON) {
+		return false;
+	}
+	if ((*iter)->hasTwoSwitches()) {
+		if ((powerIF->getSwitchState((*iter)->getSwitchId2())
+				!= PowerSwitchIF::SWITCH_ON)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool Fuse::isPowerValid() {
+	return power.isValid();
+}
+
+ReturnValue_t Fuse::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return RETURN_OK;
+}
+
+HasHealthIF::HealthState Fuse::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
+		float upperLimit) {
+	if (sample > upperLimit) {
+		return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
+	} else if (sample < lowerLimit) {
+		return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
+	} else {
+		return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
+	}
+}
diff --git a/power/Fuse.h b/power/Fuse.h
index e6d6929c..dd8759f4 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,106 +1,106 @@
-#ifndef FUSE_H_
-#define FUSE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/AbsLimitMonitor.h"
-#include "../power/PowerComponentIF.h"
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../parameters/ParameterHelper.h"
-#include <list>
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class Fuse: public SystemObject,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SerializeIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-private:
-	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
-public:
-	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
-	};
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-
-	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
-	virtual ~Fuse();
-	void addDevice(PowerComponentIF *set);
-	float getPower();
-
-	bool isPowerValid();
-
-	ReturnValue_t check();
-	uint8_t getFuseId() const;
-	ReturnValue_t initialize();
-	DeviceList devices;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override;
-	size_t getSerializedSize() const override;
-	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			SerializeIF::Endianness streamEndianness) override;
-	void setAllMonitorsToUnchecked();
-	ReturnValue_t performOperation(uint8_t opCode);
-	MessageQueueId_t getCommandQueue() const;
-	void setDataPoolEntriesInvalid();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-private:
-	uint8_t oldFuseState;
-	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
-	AbsLimitMonitor<float> currentLimit;
-	class PowerMonitor: public MonitorReporter<float> {
-	public:
-		template<typename ... Args>
-		PowerMonitor(Args ... args) :
-				MonitorReporter<float>(std::forward<Args>(args)...) {
-		}
-		ReturnValue_t checkPower(float sample, float lowerLimit,
-				float upperLimit);
-		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
-		}
-
-	};
-	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	static object_id_t powerSwitchId;
-	void calculatePowerLimits(float *low, float *high);
-	void calculateFusePower();
-	void checkFuseState();
-	void reportEvents(Event event);
-	void checkCommandQueue();
-
-	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
-};
-
-#endif /* FUSE_H_ */
+#ifndef FUSE_H_
+#define FUSE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/AbsLimitMonitor.h"
+#include "../power/PowerComponentIF.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../parameters/ParameterHelper.h"
+#include <list>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+class Fuse: public SystemObject,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ReceivesParameterMessagesIF,
+		public SerializeIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+private:
+	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
+public:
+	struct VariableIds {
+		uint32_t pidVoltage;
+		uint32_t pidCurrent;
+		uint32_t pidState;
+		uint32_t poolIdPower;
+	};
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+
+	typedef std::list<PowerComponentIF*> DeviceList;
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+			float maxCurrent, uint16_t confirmationCount = 2);
+	virtual ~Fuse();
+	void addDevice(PowerComponentIF *set);
+	float getPower();
+
+	bool isPowerValid();
+
+	ReturnValue_t check();
+	uint8_t getFuseId() const;
+	ReturnValue_t initialize();
+	DeviceList devices;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override;
+	size_t getSerializedSize() const override;
+	ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			SerializeIF::Endianness streamEndianness) override;
+	void setAllMonitorsToUnchecked();
+	ReturnValue_t performOperation(uint8_t opCode);
+	MessageQueueId_t getCommandQueue() const;
+	void setDataPoolEntriesInvalid();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+private:
+	uint8_t oldFuseState;
+	uint8_t fuseId;
+	PowerSwitchIF *powerIF; //could be static in our case.
+	AbsLimitMonitor<float> currentLimit;
+	class PowerMonitor: public MonitorReporter<float> {
+	public:
+		template<typename ... Args>
+		PowerMonitor(Args ... args) :
+				MonitorReporter<float>(std::forward<Args>(args)...) {
+		}
+		ReturnValue_t checkPower(float sample, float lowerLimit,
+				float upperLimit);
+		void sendTransitionEvent(float currentValue, ReturnValue_t state) {
+		}
+
+	};
+	PowerMonitor powerMonitor;
+	GlobDataSet set;
+	PIDReader<float> voltage;
+	PIDReader<float> current;
+	PIDReader<uint8_t> state;
+	gp_float_t power;
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	static object_id_t powerSwitchId;
+	void calculatePowerLimits(float *low, float *high);
+	void calculateFusePower();
+	void checkFuseState();
+	void reportEvents(Event event);
+	void checkCommandQueue();
+
+	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
+};
+
+#endif /* FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index ef852e64..a3797055 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,86 +1,86 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
-
-#include "../power/PowerComponent.h"
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
-}
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
-}
-
-ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
-		size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
-			size, maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
-			streamEndianness);
-}
-
-size_t PowerComponent::getSerializedSize() const {
-	return sizeof(min) + sizeof(max);
-}
-
-object_id_t PowerComponent::getDeviceObjectId() {
-	return deviceObjectId;
-}
-
-uint8_t PowerComponent::getSwitchId1() {
-	return switchId1;
-}
-
-uint8_t PowerComponent::getSwitchId2() {
-	return switchId2;
-}
-
-bool PowerComponent::hasTwoSwitches() {
-	return doIHaveTwoSwitches;
-}
-
-float PowerComponent::getMin() {
-	return min;
-}
-
-float PowerComponent::getMax() {
-	return max;
-}
-
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
-        Endianness streamEndianness) {
-	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
-			size, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
-}
-
-ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
-		uint16_t parameterId, ParameterWrapper* parameterWrapper,
-		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	if (domainId != moduleId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set<>(min);
-		break;
-	case 1:
-		parameterWrapper->set<>(max);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
+/**
+ * @file	PowerComponent.cpp
+ * @brief	This file defines the PowerComponent class.
+ * @date	28.08.2014
+ * @author	baetz
+ */
+
+#include "../power/PowerComponent.h"
+
+PowerComponent::PowerComponent() :
+		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
+		false), min(0.0), max(0.0), moduleId(0) {
+}
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
+				twoSwitches), min(min), max(max), moduleId(moduleId) {
+}
+
+ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
+		size_t maxSize, Endianness streamEndianness) const {
+	ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
+			size, maxSize, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::serialize(&max, buffer, size, maxSize,
+			streamEndianness);
+}
+
+size_t PowerComponent::getSerializedSize() const {
+	return sizeof(min) + sizeof(max);
+}
+
+object_id_t PowerComponent::getDeviceObjectId() {
+	return deviceObjectId;
+}
+
+uint8_t PowerComponent::getSwitchId1() {
+	return switchId1;
+}
+
+uint8_t PowerComponent::getSwitchId2() {
+	return switchId2;
+}
+
+bool PowerComponent::hasTwoSwitches() {
+	return doIHaveTwoSwitches;
+}
+
+float PowerComponent::getMin() {
+	return min;
+}
+
+float PowerComponent::getMax() {
+	return max;
+}
+
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
+        Endianness streamEndianness) {
+	ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
+			size, streamEndianness);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
+}
+
+ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
+		uint16_t parameterId, ParameterWrapper* parameterWrapper,
+		const ParameterWrapper* newValues, uint16_t startAtIndex) {
+	if (domainId != moduleId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set<>(min);
+		break;
+	case 1:
+		parameterWrapper->set<>(max);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index 2e11fa82..dc5217be 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,48 +1,48 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../power/PowerComponentIF.h"
-
-class PowerComponent: public PowerComponentIF {
-public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
-
-	virtual object_id_t getDeviceObjectId();
-
-	virtual uint8_t getSwitchId1();
-	virtual uint8_t getSwitchId2();
-
-	bool hasTwoSwitches();
-
-	float getMin();
-	float getMax();
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	size_t getSerializedSize() const override;
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-				ParameterWrapper *parameterWrapper,
-				const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	const object_id_t deviceObjectId;
-	const uint8_t switchId1;
-	const uint8_t switchId2;
-
-	const bool doIHaveTwoSwitches;
-
-	float min;
-	float max;
-
-	uint8_t moduleId;
-
-	PowerComponent();
-};
-
-#endif /* POWERCOMPONENT_H_ */
+#ifndef POWERCOMPONENT_H_
+#define POWERCOMPONENT_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../power/PowerComponentIF.h"
+
+class PowerComponent: public PowerComponentIF {
+public:
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
+			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+
+	virtual object_id_t getDeviceObjectId();
+
+	virtual uint8_t getSwitchId1();
+	virtual uint8_t getSwitchId2();
+
+	bool hasTwoSwitches();
+
+	float getMin();
+	float getMax();
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override;
+
+	size_t getSerializedSize() const override;
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+				ParameterWrapper *parameterWrapper,
+				const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	const object_id_t deviceObjectId;
+	const uint8_t switchId1;
+	const uint8_t switchId2;
+
+	const bool doIHaveTwoSwitches;
+
+	float min;
+	float max;
+
+	uint8_t moduleId;
+
+	PowerComponent();
+};
+
+#endif /* POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index eeaa39fb..c2e3a6a5 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,24 +1,24 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../parameters/HasParametersIF.h"
-
-class PowerComponentIF : public SerializeIF, public HasParametersIF {
-public:
-	virtual ~PowerComponentIF() {
-
-	}
-
-	virtual object_id_t getDeviceObjectId()=0;
-
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
-
-	virtual float getMin() = 0;
-	virtual float getMax() = 0;
-
-};
-
-#endif /* POWERCOMPONENTIF_H_ */
+#ifndef POWERCOMPONENTIF_H_
+#define POWERCOMPONENTIF_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../parameters/HasParametersIF.h"
+
+class PowerComponentIF : public SerializeIF, public HasParametersIF {
+public:
+	virtual ~PowerComponentIF() {
+
+	}
+
+	virtual object_id_t getDeviceObjectId()=0;
+
+	virtual uint8_t getSwitchId1()=0;
+	virtual uint8_t getSwitchId2()=0;
+	virtual bool hasTwoSwitches()=0;
+
+	virtual float getMin() = 0;
+	virtual float getMax() = 0;
+
+};
+
+#endif /* POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 51300db7..df26fb8e 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,128 +1,128 @@
-#include "../power/PowerSensor.h"
-#include "../ipc/QueueFactory.h"
-
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
-		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
-				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
-				ids.pidVoltage, confirmationCount, limits.voltageMin,
-				limits.voltageMax, events.voltageLow, events.voltageHigh) {
-		commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-PowerSensor::~PowerSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
-	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
-	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
-	return result1;
-}
-
-ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
-	checkCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PowerSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t PowerSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return result;
-}
-
-void PowerSensor::setAllMonitorsToUnchecked() {
-	currentLimit.setToUnchecked();
-	voltageLimit.setToUnchecked();
-}
-
-void PowerSensor::checkCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = healthHelper.handleHealthCommand(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	result = parameterHelper.handleParameterMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	command.setToUnknownCommand();
-	commandQueue->reply(&command);
-}
-
-void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
-}
-
-float PowerSensor::getPower() {
-	if (power.isValid()) {
-		return power.value;
-	} else {
-		return 0.0;
-	}
-
-}
-
-ReturnValue_t PowerSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState PowerSensor::getHealth() {
-	return healthHelper.getHealth();
-}
-
-ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
-			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
-			newValues, startAtIndex);
-	return result;
-}
+#include "../power/PowerSensor.h"
+#include "../ipc/QueueFactory.h"
+
+PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
+		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
+				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
+				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
+				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+				limits.currentMin, limits.currentMax, events.currentLow,
+				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				ids.pidVoltage, confirmationCount, limits.voltageMin,
+				limits.voltageMax, events.voltageLow, events.voltageHigh) {
+		commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+PowerSensor::~PowerSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t PowerSensor::calculatePower() {
+	set.read();
+	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
+	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage);
+		result2 = currentLimit.doCheck(current);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power = current * voltage;
+	}
+	set.commit();
+	return result1;
+}
+
+ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
+	checkCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PowerSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t PowerSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+void PowerSensor::setAllMonitorsToUnchecked() {
+	currentLimit.setToUnchecked();
+	voltageLimit.setToUnchecked();
+}
+
+void PowerSensor::checkCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = healthHelper.handleHealthCommand(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	result = parameterHelper.handleParameterMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		return;
+	}
+	command.setToUnknownCommand();
+	commandQueue->reply(&command);
+}
+
+void PowerSensor::setDataPoolEntriesInvalid() {
+	set.read();
+	set.commit(PoolVariableIF::INVALID);
+}
+
+float PowerSensor::getPower() {
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
+
+}
+
+ReturnValue_t PowerSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState PowerSensor::getHealth() {
+	return healthHelper.getHealth();
+}
+
+ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
+			parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
+			newValues, startAtIndex);
+	return result;
+}
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index dc859ab3..da0bd8c7 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,71 +1,71 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/LimitMonitor.h"
-#include "../parameters/ParameterHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../ipc/MessageQueueIF.h"
-
-class PowerController;
-
-class PowerSensor: public SystemObject,
-		public ReceivesParameterMessagesIF,
-		public HasHealthIF {
-	friend class PowerController;
-public:
-	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
-	};
-	struct DefaultLimits {
-		float currentMin;
-		float currentMax;
-		float voltageMin;
-		float voltageMax;
-	};
-	struct SensorEvents {
-		Event currentLow;
-		Event currentHigh;
-		Event voltageLow;
-		Event voltageHigh;
-	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
-	virtual ~PowerSensor();
-	ReturnValue_t calculatePower();
-	ReturnValue_t performOperation(uint8_t opCode);
-	void setAllMonitorsToUnchecked();
-	MessageQueueId_t getCommandQueue() const;
-	ReturnValue_t initialize();
-	void setDataPoolEntriesInvalid();
-	float getPower();
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-private:
-	MessageQueueIF* commandQueue;
-	ParameterHelper parameterHelper;
-	HealthHelper healthHelper;
-	GlobDataSet set;
-	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
-	//Variables out
-	gp_float_t power;
-
-	static const uint8_t MODULE_ID_CURRENT = 1;
-	static const uint8_t MODULE_ID_VOLTAGE = 2;
-	void checkCommandQueue();
-protected:
-	LimitMonitor<float> currentLimit;
-	LimitMonitor<float> voltageLimit;
-};
-
-#endif /* POWERSENSOR_H_ */
+#ifndef POWERSENSOR_H_
+#define POWERSENSOR_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoolglob/PIDReader.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../monitoring/LimitMonitor.h"
+#include "../parameters/ParameterHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../ipc/MessageQueueIF.h"
+
+class PowerController;
+
+class PowerSensor: public SystemObject,
+		public ReceivesParameterMessagesIF,
+		public HasHealthIF {
+	friend class PowerController;
+public:
+	struct VariableIds {
+		uint32_t pidCurrent;
+		uint32_t pidVoltage;
+		uint32_t poolIdPower;
+	};
+	struct DefaultLimits {
+		float currentMin;
+		float currentMax;
+		float voltageMin;
+		float voltageMax;
+	};
+	struct SensorEvents {
+		Event currentLow;
+		Event currentHigh;
+		Event voltageLow;
+		Event voltageHigh;
+	};
+	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
+			SensorEvents events, uint16_t confirmationCount = 0);
+	virtual ~PowerSensor();
+	ReturnValue_t calculatePower();
+	ReturnValue_t performOperation(uint8_t opCode);
+	void setAllMonitorsToUnchecked();
+	MessageQueueId_t getCommandQueue() const;
+	ReturnValue_t initialize();
+	void setDataPoolEntriesInvalid();
+	float getPower();
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+private:
+	MessageQueueIF* commandQueue;
+	ParameterHelper parameterHelper;
+	HealthHelper healthHelper;
+	GlobDataSet set;
+	//Variables in
+	PIDReader<float> current;
+	PIDReader<float> voltage;
+	//Variables out
+	gp_float_t power;
+
+	static const uint8_t MODULE_ID_CURRENT = 1;
+	static const uint8_t MODULE_ID_VOLTAGE = 2;
+	void checkCommandQueue();
+protected:
+	LimitMonitor<float> currentLimit;
+	LimitMonitor<float> voltageLimit;
+};
+
+#endif /* POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 817c4ce1..876a82c5 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,80 +1,80 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-/**
- *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
- * @ingroup interfaces
- */
-class PowerSwitchIF : public HasReturnvaluesIF {
-public:
-	/**
-	 * Empty dtor.
-	 */
-	virtual ~PowerSwitchIF() {
-
-	}
-	/**
-	 * The Returnvalues id of this class, required by HasReturnvaluesIF
-	 */
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
-	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
-	/**
-	 * send a direct command to the Power Unit to enable/disable the specified switch.
-	 *
-	 * @param switchNr
-	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
-	 */
-	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
-	/**
-	 * Sends a command to the Power Unit to enable a certain fuse.
-	 */
-	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
-
-	/**
-	 * get the state of the Switches.
-	 * @param switchNr
-	 * @return
-	 *     - @c SWITCH_ON if the specified switch is on.
-	 *     - @c SWITCH_OFF if the specified switch is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
-	/**
-	 * get state of a fuse.
-	 * @param fuseNr
-	 * @return
-	 *     - @c FUSE_ON if the specified fuse is on.
-	 *     - @c FUSE_OFF if the specified fuse is off.
-	 *     - @c RETURN_FAILED if an error occured
-	 */
-	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
-	/**
-	 * The maximum delay that it will take to change a switch
-	 *
-	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
-	 */
-	virtual uint32_t getSwitchDelayMs(void) const = 0;
-};
-
-
-#endif /* POWERSWITCHIF_H_ */
+/**
+ * @file	PowerSwitchIF.h
+ * @brief	This file defines the PowerSwitchIF class.
+ * @date	20.03.2013
+ * @author	baetz
+ */
+
+#ifndef POWERSWITCHIF_H_
+#define POWERSWITCHIF_H_
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+/**
+ *
+ * @brief   This interface defines a connection to a device that is capable of turning on and off
+ *          switches of devices identified by a switch ID.
+ * @details The virtual functions of this interface do not allow to make any assignments
+ *          because they can be called asynchronosuly (const ending).
+ *
+ * @ingroup interfaces
+ */
+class PowerSwitchIF : public HasReturnvaluesIF {
+public:
+	/**
+	 * Empty dtor.
+	 */
+	virtual ~PowerSwitchIF() {
+
+	}
+	/**
+	 * The Returnvalues id of this class, required by HasReturnvaluesIF
+	 */
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
+	static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	/**
+	 * send a direct command to the Power Unit to enable/disable the specified switch.
+	 *
+	 * @param switchNr
+	 * @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
+	 */
+	virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
+	/**
+	 * Sends a command to the Power Unit to enable a certain fuse.
+	 */
+	virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
+
+	/**
+	 * get the state of the Switches.
+	 * @param switchNr
+	 * @return
+	 *     - @c SWITCH_ON if the specified switch is on.
+	 *     - @c SWITCH_OFF if the specified switch is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
+	/**
+	 * get state of a fuse.
+	 * @param fuseNr
+	 * @return
+	 *     - @c FUSE_ON if the specified fuse is on.
+	 *     - @c FUSE_OFF if the specified fuse is off.
+	 *     - @c RETURN_FAILED if an error occured
+	 */
+	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
+	/**
+	 * The maximum delay that it will take to change a switch
+	 *
+	 * This may take into account the time to send a command, wait for it to be executed and see the switch changed.
+	 */
+	virtual uint32_t getSwitchDelayMs(void) const = 0;
+};
+
+
+#endif /* POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 73d9f89b..1844a11a 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,127 +1,127 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../power/PowerSwitcher.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
-}
-
-ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
-	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PowerSwitcher::getStateOfSwitches() {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case ONE_SWITCH:
-		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
-			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
-			return PowerSwitchIF::SWITCH_OFF;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
-	SwitchReturn_t result = howManySwitches();
-	switch (result) {
-	case TWO_SWITCHES:
-		power->sendSwitchCommand(secondSwitch, onOff);
-		/* NO BREAK falls through*/
-	case ONE_SWITCH:
-		power->sendSwitchCommand(firstSwitch, onOff);
-		break;
-	}
-	return;
-
-}
-
-void PowerSwitcher::turnOn() {
-	commandSwitches(PowerSwitchIF::SWITCH_ON);
-	state = WAIT_ON;
-}
-
-void PowerSwitcher::turnOff() {
-	commandSwitches(PowerSwitchIF::SWITCH_OFF);
-	state = WAIT_OFF;
-}
-
-PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
-	if (secondSwitch == NO_SWITCH) {
-		return ONE_SWITCH;
-	} else {
-		return TWO_SWITCHES;
-	}
-}
-
-void PowerSwitcher::doStateMachine() {
-	switch (state) {
-	case SWITCH_IS_OFF:
-	case SWITCH_IS_ON:
-		//Do nothing.
-		break;
-	case WAIT_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			state = SWITCH_IS_OFF;
-		}
-		break;
-	case WAIT_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			state = SWITCH_IS_ON;
-		}
-		break;
-	default:
-		//Should never happen.
-		break;
-	}
-}
-
-ReturnValue_t PowerSwitcher::checkSwitchState() {
-	switch (state) {
-	case WAIT_OFF:
-	case WAIT_ON:
-		return IN_POWER_TRANSITION;
-	case SWITCH_IS_OFF:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	case SWITCH_IS_ON:
-		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
-			return RETURN_OK;
-		} else {
-			return SWITCH_STATE_MISMATCH;
-		}
-	}
-	return RETURN_FAILED;
-}
-
-PowerSwitcher::State_t PowerSwitcher::getState() {
-	return state;
-}
-
-uint32_t PowerSwitcher::getSwitchDelay() {
-	return power->getSwitchDelayMs();
-}
-
-uint8_t PowerSwitcher::getFirstSwitch() const {
-	return firstSwitch;
-}
-
-uint8_t PowerSwitcher::getSecondSwitch() const {
-	return secondSwitch;
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../power/PowerSwitcher.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
+		PowerSwitcher::State_t setStartState) :
+		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+}
+
+ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
+	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	if (power == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcher::getStateOfSwitches() {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case ONE_SWITCH:
+		return power->getSwitchState(firstSwitch);
+	case TWO_SWITCHES:
+		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+			return PowerSwitchIF::SWITCH_ON;
+		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
+				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+			return PowerSwitchIF::SWITCH_OFF;
+		} else {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
+	SwitchReturn_t result = howManySwitches();
+	switch (result) {
+	case TWO_SWITCHES:
+		power->sendSwitchCommand(secondSwitch, onOff);
+		/* NO BREAK falls through*/
+	case ONE_SWITCH:
+		power->sendSwitchCommand(firstSwitch, onOff);
+		break;
+	}
+	return;
+
+}
+
+void PowerSwitcher::turnOn() {
+	commandSwitches(PowerSwitchIF::SWITCH_ON);
+	state = WAIT_ON;
+}
+
+void PowerSwitcher::turnOff() {
+	commandSwitches(PowerSwitchIF::SWITCH_OFF);
+	state = WAIT_OFF;
+}
+
+PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
+	if (secondSwitch == NO_SWITCH) {
+		return ONE_SWITCH;
+	} else {
+		return TWO_SWITCHES;
+	}
+}
+
+void PowerSwitcher::doStateMachine() {
+	switch (state) {
+	case SWITCH_IS_OFF:
+	case SWITCH_IS_ON:
+		//Do nothing.
+		break;
+	case WAIT_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			state = SWITCH_IS_OFF;
+		}
+		break;
+	case WAIT_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			state = SWITCH_IS_ON;
+		}
+		break;
+	default:
+		//Should never happen.
+		break;
+	}
+}
+
+ReturnValue_t PowerSwitcher::checkSwitchState() {
+	switch (state) {
+	case WAIT_OFF:
+	case WAIT_ON:
+		return IN_POWER_TRANSITION;
+	case SWITCH_IS_OFF:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	case SWITCH_IS_ON:
+		if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
+			return RETURN_OK;
+		} else {
+			return SWITCH_STATE_MISMATCH;
+		}
+	}
+	return RETURN_FAILED;
+}
+
+PowerSwitcher::State_t PowerSwitcher::getState() {
+	return state;
+}
+
+uint32_t PowerSwitcher::getSwitchDelay() {
+	return power->getSwitchDelayMs();
+}
+
+uint8_t PowerSwitcher::getFirstSwitch() const {
+	return firstSwitch;
+}
+
+uint8_t PowerSwitcher::getSecondSwitch() const {
+	return secondSwitch;
+}
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 39f44f50..515ce042 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,45 +1,45 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-
-class PowerSwitcher : public HasReturnvaluesIF {
-public:
-	enum State_t {
-		WAIT_OFF,
-		WAIT_ON,
-		SWITCH_IS_OFF,
-		SWITCH_IS_ON,
-	};
-	State_t state;
-	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
-	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
-	ReturnValue_t initialize(object_id_t powerSwitchId);
-	void turnOn();
-	void turnOff();
-	void doStateMachine();
-	State_t getState();
-	ReturnValue_t checkSwitchState();
-	uint32_t getSwitchDelay();
-	uint8_t getFirstSwitch() const;
-	uint8_t getSecondSwitch() const;
-private:
-	uint8_t firstSwitch;
-	uint8_t secondSwitch;
-	PowerSwitchIF* power;
-	static const uint8_t NO_SWITCH = 0xFF;
-	enum SwitchReturn_t {
-		ONE_SWITCH = 1,
-		TWO_SWITCHES = 2
-	};
-	ReturnValue_t getStateOfSwitches();
-	void commandSwitches( ReturnValue_t onOff );
-	SwitchReturn_t howManySwitches();
-};
-
-
-
-#endif /* POWERSWITCHER_H_ */
+#ifndef POWERSWITCHER_H_
+#define POWERSWITCHER_H_
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+
+class PowerSwitcher : public HasReturnvaluesIF {
+public:
+	enum State_t {
+		WAIT_OFF,
+		WAIT_ON,
+		SWITCH_IS_OFF,
+		SWITCH_IS_ON,
+	};
+	State_t state;
+	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
+	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	ReturnValue_t initialize(object_id_t powerSwitchId);
+	void turnOn();
+	void turnOff();
+	void doStateMachine();
+	State_t getState();
+	ReturnValue_t checkSwitchState();
+	uint32_t getSwitchDelay();
+	uint8_t getFirstSwitch() const;
+	uint8_t getSecondSwitch() const;
+private:
+	uint8_t firstSwitch;
+	uint8_t secondSwitch;
+	PowerSwitchIF* power;
+	static const uint8_t NO_SWITCH = 0xFF;
+	enum SwitchReturn_t {
+		ONE_SWITCH = 1,
+		TWO_SWITCHES = 2
+	};
+	ReturnValue_t getStateOfSwitches();
+	void commandSwitches( ReturnValue_t onOff );
+	SwitchReturn_t howManySwitches();
+};
+
+
+
+#endif /* POWERSWITCHER_H_ */
diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index 8a51469f..dda58e03 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,119 +1,119 @@
-#include "../pus/CService200ModeCommanding.h"
-#include "../pus/servicepackets/Service200Packets.h"
-
-#include "../modes/HasModesIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../modes/ModeMessage.h"
-
-CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
-        CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
-
-CService200ModeCommanding::~CService200ModeCommanding() {}
-
-ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
-	switch(subservice) {
-	case(Subservice::COMMAND_MODE_COMMAND):
-	case(Subservice::COMMAND_MODE_READ):
-	case(Subservice::COMMAND_MODE_ANNCOUNCE):
-		return RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
-            SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
-        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
-    if(destination == nullptr) {
-        return CommandingServiceBase::INVALID_OBJECT;
-
-    }
-
-    *messageQueueToSet = destination->getCommandQueue();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t CService200ModeCommanding::prepareCommand(
-		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
-		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	ModePacket modeCommandPacket;
-	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-	        modeCommandPacket.getSubmode());
-	return result;
-}
-
-
-ReturnValue_t CService200ModeCommanding::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t *state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool *isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch(replyId) {
-	case(ModeMessage::REPLY_MODE_REPLY): {
-		result = prepareModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
-		result = prepareWrongModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_CANT_REACH_MODE): {
-		result = prepareCantReachModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_MODE_INFO):
-		result = INVALID_REPLY;
-		break;
-	default:
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t CService200ModeCommanding::prepareModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket modeReplyPacket(objectId,
-			ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	CantReachModePacket cantReachModePacket(objectId,
-	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
-	        &cantReachModePacket);
-}
+#include "../pus/CService200ModeCommanding.h"
+#include "../pus/servicepackets/Service200Packets.h"
+
+#include "../modes/HasModesIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../modes/ModeMessage.h"
+
+CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+        CommandingServiceBase(objectId, apid, serviceId,
+	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+
+CService200ModeCommanding::~CService200ModeCommanding() {}
+
+ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_MODE_COMMAND):
+	case(Subservice::COMMAND_MODE_READ):
+	case(Subservice::COMMAND_MODE_ANNCOUNCE):
+		return RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t CService200ModeCommanding::prepareCommand(
+		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	ModePacket modeCommandPacket;
+	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
+	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
+	        modeCommandPacket.getSubmode());
+	return result;
+}
+
+
+ReturnValue_t CService200ModeCommanding::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	switch(replyId) {
+	case(ModeMessage::REPLY_MODE_REPLY): {
+		result = prepareModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
+		result = prepareWrongModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_CANT_REACH_MODE): {
+		result = prepareCantReachModeReply(reply, objectId);
+		break;
+	}
+	case(ModeMessage::REPLY_MODE_INFO):
+		result = INVALID_REPLY;
+		break;
+	default:
+		result = RETURN_FAILED;
+	}
+	return result;
+}
+
+ReturnValue_t CService200ModeCommanding::prepareModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket modeReplyPacket(objectId,
+			ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
+			ModeMessage::getSubmode(reply));
+	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+}
+
+ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
+		const CommandMessage *reply, object_id_t objectId) {
+	CantReachModePacket cantReachModePacket(objectId,
+	        ModeMessage::getCantReachModeReason(reply));
+	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	        &cantReachModePacket);
+}
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index dfb4dfa6..89347dbd 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,85 +1,85 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief Custom PUS service to set mode of all objects implementing HasModesIF
- *
- * Examples: Device Handlers, Assemblies or Subsystems.
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * @ingroup pus_services
- */
-class CService200ModeCommanding: public CommandingServiceBase {
-public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
-
-	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
-	virtual~ CService200ModeCommanding();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) override;
-
-private:
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-			const uint8_t* tcData, uint32_t tcDataLen);
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-
-	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
-		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
-		COMMAND_MODE_COMMAND = 1,
-		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
-		//! regardless of external control flag
-		COMMAND_MODE_COMMAND_FORCED = 2,
-		//!< [EXPORT] : [COMMAND] Read the current mode and
-		//! reply with a REPLY_MODE_REPLY
-		COMMAND_MODE_READ = 3,
-		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
-		//! This command does NOT have a reply
-		COMMAND_MODE_ANNCOUNCE = 4,
-		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
-		//! command to every child. This command does NOT have a reply.
-		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-		REPLY_MODE_REPLY = 6,
-		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
-		REPLY_CANT_REACH_MODE = 7,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
-		//! mode was commanded and a transition started but was aborted,
-		//! the parameters contain the mode that was reached
-		REPLY_WRONG_MODE_REPLY = 8
-	};
-
-	enum modeParameters {
-		MODE_OFF = 0,
-		MODE_ON = 1,
-		MODE_NORMAL = 2,
-		MODE_RAW = 3
-	};
-};
-
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
+#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief Custom PUS service to set mode of all objects implementing HasModesIF
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * @ingroup pus_services
+ */
+class CService200ModeCommanding: public CommandingServiceBase {
+public:
+	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService200ModeCommanding(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId);
+	virtual~ CService200ModeCommanding();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, uint32_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
+			object_id_t objectId);
+
+	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
+		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
+		COMMAND_MODE_COMMAND = 1,
+		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
+		//! regardless of external control flag
+		COMMAND_MODE_COMMAND_FORCED = 2,
+		//!< [EXPORT] : [COMMAND] Read the current mode and
+		//! reply with a REPLY_MODE_REPLY
+		COMMAND_MODE_READ = 3,
+		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
+		//! This command does NOT have a reply
+		COMMAND_MODE_ANNCOUNCE = 4,
+		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
+		//! command to every child. This command does NOT have a reply.
+		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
+		REPLY_MODE_REPLY = 6,
+		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
+		REPLY_CANT_REACH_MODE = 7,
+		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
+		//! mode was commanded and a transition started but was aborted,
+		//! the parameters contain the mode that was reached
+		REPLY_WRONG_MODE_REPLY = 8
+	};
+
+	enum modeParameters {
+		MODE_OFF = 0,
+		MODE_ON = 1,
+		MODE_NORMAL = 2,
+		MODE_RAW = 3
+	};
+};
+
+#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index 057ff707..cc5dd640 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -1,84 +1,84 @@
-#include "CService201HealthCommanding.h"
-
-#include "../health/HasHealthIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../health/HealthMessage.h"
-#include "servicepackets/Service201Packets.h"
-
-CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
-	CommandingServiceBase(objectId, apid, serviceId,
-			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
-}
-
-CService201HealthCommanding::~CService201HealthCommanding() {
-}
-
-ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
-	switch(subservice) {
-	case(Subservice::COMMAND_SET_HEALTH):
-		return RETURN_OK;
-	default:
-		sif::error << "Invalid Subservice" << std::endl;
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
-        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-        MessageQueueId_t *id, object_id_t *objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
-            SerializeIF::Endianness::BIG);
-
-    return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
-        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
-    if(destination == nullptr) {
-        return CommandingServiceBase::INVALID_OBJECT;
-    }
-
-    *messageQueueToSet = destination->getCommandQueue();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CService201HealthCommanding::prepareCommand
-		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
-		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	HealthCommand healthCommand;
-	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	} else {
-		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
-				HealthMessage::HEALTH_SET, healthCommand.getHealth());
-		return result;
-	}
-}
-
-ReturnValue_t CService201HealthCommanding::handleReply
-		(const CommandMessage* reply, Command_t previousCommand,
-		uint32_t *state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool *isStep) {
-	Command_t replyId = reply->getCommand();
-	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		prepareHealthSetReply(reply);
-	}
-	return RETURN_OK;
-}
-
-void CService201HealthCommanding::prepareHealthSetReply(
-        const CommandMessage* reply) {
-	prepareHealthSetReply(reply);
-	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
-	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
-	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
-}
-
+#include "CService201HealthCommanding.h"
+
+#include "../health/HasHealthIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../health/HealthMessage.h"
+#include "servicepackets/Service201Packets.h"
+
+CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+	CommandingServiceBase(objectId, apid, serviceId,
+			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+}
+
+CService201HealthCommanding::~CService201HealthCommanding() {
+}
+
+ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
+	switch(subservice) {
+	case(Subservice::COMMAND_SET_HEALTH):
+		return RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
+        uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+        MessageQueueId_t *id, object_id_t *objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
+            SerializeIF::Endianness::BIG);
+
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
+        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    if(destination == nullptr) {
+        return CommandingServiceBase::INVALID_OBJECT;
+    }
+
+    *messageQueueToSet = destination->getCommandQueue();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CService201HealthCommanding::prepareCommand
+		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
+	HealthCommand healthCommand;
+	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	if (result != RETURN_OK) {
+		return result;
+	} else {
+		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
+				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		return result;
+	}
+}
+
+ReturnValue_t CService201HealthCommanding::handleReply
+		(const CommandMessage* reply, Command_t previousCommand,
+		uint32_t *state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool *isStep) {
+	Command_t replyId = reply->getCommand();
+	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
+		prepareHealthSetReply(reply);
+	}
+	return RETURN_OK;
+}
+
+void CService201HealthCommanding::prepareHealthSetReply(
+        const CommandMessage* reply) {
+	prepareHealthSetReply(reply);
+	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
+	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
+	HealthSetReply healthSetReply(health, oldHealth);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+}
+
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
index 85d2e24c..100f675e 100644
--- a/pus/CService201HealthCommanding.h
+++ b/pus/CService201HealthCommanding.h
@@ -1,58 +1,58 @@
-#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
-#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
-
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief   Custom PUS service to set health of all objects
- *          implementing hasHealthIF.
- *
- * Examples: Device Handlers, Assemblies or Subsystems.
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base template
- * class. There is constant interaction between this Service Base und a
- * child class like this service
- *
- */
-class CService201HealthCommanding: public CommandingServiceBase {
-public:
-    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
-
-	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId);
-	virtual~ CService201HealthCommanding();
-protected:
-	/* CSB abstract function implementations */
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	/** Prepare health command */
-	ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) override;
-	/** Handle health reply */
-	ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) override;
-
-private:
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-			const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
-
-	void prepareHealthSetReply(const CommandMessage *reply);
-
-	enum Subservice {
-		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
-		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
-	};
-};
-
-#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
+#ifndef FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+#define FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_
+
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Custom PUS service to set health of all objects
+ *          implementing hasHealthIF.
+ *
+ * Examples: Device Handlers, Assemblies or Subsystems.
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * child class like this service
+ *
+ */
+class CService201HealthCommanding: public CommandingServiceBase {
+public:
+    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
+    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId);
+	virtual~ CService201HealthCommanding();
+protected:
+	/* CSB abstract function implementations */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	/** Prepare health command */
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	/** Handle health reply */
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+private:
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
+
+	void prepareHealthSetReply(const CommandMessage *reply);
+
+	enum Subservice {
+		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
+		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	};
+};
+
+#endif /* FSFW_PUS_CSERVICE201HEALTHCOMMANDING_H_ */
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index fb66c160..9b17eba5 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,100 +1,100 @@
-#include "../pus/Service1TelecommandVerification.h"
-#include "../pus/servicepackets/Service1Packets.h"
-
-#include "../ipc/QueueFactory.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-
-Service1TelecommandVerification::Service1TelecommandVerification(
-        object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
-        SystemObject(objectId), apid(apid), serviceId(serviceId),
-        targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
-
-MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
-	return tmQueue->getId();
-}
-
-
-ReturnValue_t Service1TelecommandVerification::performOperation(
-		uint8_t operationCode){
-	PusVerificationMessage message;
-	ReturnValue_t status = tmQueue->receiveMessage(&message);
-	while(status == HasReturnvaluesIF::RETURN_OK) {
-		status = sendVerificationReport(&message);
-		if(status != HasReturnvaluesIF::RETURN_OK) {
-			return status;
-		}
-		status = tmQueue->receiveMessage(&message);
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return status;
-	}
-}
-
-
-ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
-		PusVerificationMessage* message) {
-	ReturnValue_t result;
-	if(message->getReportId() % 2 == 0) {
-		result = generateFailureReport(message);
-	} else {
-		result = generateSuccessReport(message);
-	}
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
-		        "Sending verification packet failed !" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateFailureReport(
-        PusVerificationMessage *message) {
-	FailureReport report(
-			message->getReportId(), message->getTcPacketId(),
-			message->getTcSequenceControl(), message->getStep(),
-			message->getErrorCode(), message->getParameter1(),
-			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
-        PusVerificationMessage *message) {
-	SuccessReport report(message->getReportId(),message->getTcPacketId(),
-			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-
-ReturnValue_t Service1TelecommandVerification::initialize() {
-	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
-			get<AcceptsTelemetryIF>(targetDestination);
-	if(funnel == nullptr){
-	    sif::error << "Service1TelecommandVerification::initialize: Specified"
-	            " TM funnel invalid. Make sure it is set up and implements"
-	            " AcceptsTelemetryIF." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
-	return SystemObject::initialize();
-}
+#include "../pus/Service1TelecommandVerification.h"
+#include "../pus/servicepackets/Service1Packets.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service1TelecommandVerification::Service1TelecommandVerification(
+        object_id_t objectId, uint16_t apid, uint8_t serviceId,
+        object_id_t targetDestination):
+        SystemObject(objectId), apid(apid), serviceId(serviceId),
+        targetDestination(targetDestination) {
+	tmQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service1TelecommandVerification::~Service1TelecommandVerification() {}
+
+MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
+	return tmQueue->getId();
+}
+
+
+ReturnValue_t Service1TelecommandVerification::performOperation(
+		uint8_t operationCode){
+	PusVerificationMessage message;
+	ReturnValue_t status = tmQueue->receiveMessage(&message);
+	while(status == HasReturnvaluesIF::RETURN_OK) {
+		status = sendVerificationReport(&message);
+		if(status != HasReturnvaluesIF::RETURN_OK) {
+			return status;
+		}
+		status = tmQueue->receiveMessage(&message);
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return status;
+	}
+}
+
+
+ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
+		PusVerificationMessage* message) {
+	ReturnValue_t result;
+	if(message->getReportId() % 2 == 0) {
+		result = generateFailureReport(message);
+	} else {
+		result = generateSuccessReport(message);
+	}
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
+		        "Sending verification packet failed !" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateFailureReport(
+        PusVerificationMessage *message) {
+	FailureReport report(
+			message->getReportId(), message->getTcPacketId(),
+			message->getTcSequenceControl(), message->getStep(),
+			message->getErrorCode(), message->getParameter1(),
+			message->getParameter2());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
+        PusVerificationMessage *message) {
+	SuccessReport report(message->getReportId(),message->getTcPacketId(),
+			message->getTcSequenceControl(),message->getStep());
+	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	        packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
+			tmQueue->getId());
+	return result;
+}
+
+
+ReturnValue_t Service1TelecommandVerification::initialize() {
+	// Get target object for TC verification messages
+	AcceptsTelemetryIF* funnel = objectManager->
+			get<AcceptsTelemetryIF>(targetDestination);
+	if(funnel == nullptr){
+	    sif::error << "Service1TelecommandVerification::initialize: Specified"
+	            " TM funnel invalid. Make sure it is set up and implements"
+	            " AcceptsTelemetryIF." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+	return SystemObject::initialize();
+}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 91275cfb..37562d1c 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,94 +1,94 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../ipc/MessageQueueIF.h"
-
-/**
- * @brief Verify TC acceptance, start, progress and execution.
- *
- * Full Documentation: ECSS-E70-41A p.51
- *
- * The telecommand verification service provides the capability for
- * explicit verification of each distinct stage of execution of a telecommand
- * packet, from on-board acceptance through to completion of execution.
- *
- * Minimum capabilities of this service:
- *
- *  - TM[1,1]: Telecommand Acceptance Report - Success.
- *  - TM[1,2]: Telecommand Acceptance Report - Failure.
- *
- * Additional capabilities of this service:
- *
- *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
- *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
- *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
- *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
- *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
- *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
- *
- * This Service is not inherited from PUSServiceBase unlike other PUS Services
- * because all services implementing PUSServiceBase use this service to
- * generate verification reports.
- * @ingroup pus_services
- */
-class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
-
-	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
-	virtual ~Service1TelecommandVerification();
-
-	/**
-	 *
-	 * @return ID of Verification Queue
-	 */
-	virtual MessageQueueId_t getVerificationQueue();
-
-	/**
-	 * Performs the service periodically as specified in init_mission().
-	 * Triggers the handlePacket function to send TC verification messages
-	 * @param operationCode
-	 * @return
-	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-	/**
-	 * Initializes the destination for TC verification messages and initializes
-	 * Service 1 as a system object
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-private:
-	uint16_t apid = 0;
-	uint8_t serviceId = 0;
-
-	object_id_t targetDestination = objects::NO_OBJECT;
-
-	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
-	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
-	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
-
-	uint16_t packetSubCounter = 0;
-
-	MessageQueueIF* tmQueue = nullptr;
-
-	enum class Subservice: uint8_t {
-		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
-		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
-		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
-		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
-		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
-		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
-	};
-};
-
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../ipc/MessageQueueIF.h"
+
+/**
+ * @brief Verify TC acceptance, start, progress and execution.
+ *
+ * Full Documentation: ECSS-E70-41A p.51
+ *
+ * The telecommand verification service provides the capability for
+ * explicit verification of each distinct stage of execution of a telecommand
+ * packet, from on-board acceptance through to completion of execution.
+ *
+ * Minimum capabilities of this service:
+ *
+ *  - TM[1,1]: Telecommand Acceptance Report - Success.
+ *  - TM[1,2]: Telecommand Acceptance Report - Failure.
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
+ *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
+ *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
+ *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
+ *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
+ *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
+ *
+ * This Service is not inherited from PUSServiceBase unlike other PUS Services
+ * because all services implementing PUSServiceBase use this service to
+ * generate verification reports.
+ * @ingroup pus_services
+ */
+class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
+
+	Service1TelecommandVerification(object_id_t objectId,
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	virtual ~Service1TelecommandVerification();
+
+	/**
+	 *
+	 * @return ID of Verification Queue
+	 */
+	virtual MessageQueueId_t getVerificationQueue();
+
+	/**
+	 * Performs the service periodically as specified in init_mission().
+	 * Triggers the handlePacket function to send TC verification messages
+	 * @param operationCode
+	 * @return
+	 */
+	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+	/**
+	 * Initializes the destination for TC verification messages and initializes
+	 * Service 1 as a system object
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+private:
+	uint16_t apid = 0;
+	uint8_t serviceId = 0;
+
+	object_id_t targetDestination = objects::NO_OBJECT;
+
+	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
+	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
+	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
+
+	uint16_t packetSubCounter = 0;
+
+	MessageQueueIF* tmQueue = nullptr;
+
+	enum class Subservice: uint8_t {
+		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
+		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
+		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
+		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
+		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
+		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
+	};
+};
+
+#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 26639de6..9529c675 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,165 +1,165 @@
-#include "../pus/Service2DeviceAccess.h"
-#include "../pus/servicepackets/Service2Packets.h"
-
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../serialize/EndianConverter.h"
-#include "../action/ActionMessage.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
-        uint16_t commandTimeoutSeconds):
-        CommandingServiceBase(objectId, apid, serviceId,
-	        numberOfParallelCommands, commandTimeoutSeconds) {}
-
-Service2DeviceAccess::~Service2DeviceAccess() {}
-
-
-ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		sif::error << "Invalid Subservice" << std::endl;
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData,
-                &tcDataLen, SerializeIF::Endianness::BIG);
-
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
-	DeviceHandlerIF* possibleTarget =
-			objectManager->get<DeviceHandlerIF>(*objectId);
-	if(possibleTarget == nullptr) {
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		uint32_t* state, object_id_t objectId) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(message, tcData, tcDataLen);
-	}
-	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(message, tcData, tcDataLen);
-	}
-	break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::prepareRawCommand(
-        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
-	RawCommand RawCommand(tcData,tcDataLen);
-	// store command into the Inter Process Communication Store
-	store_address_t storeAddress;
-	ReturnValue_t result = IPCStore->addData(&storeAddress,
-	        RawCommand.getCommand(), RawCommand.getCommandSize());
-	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
-	        storeAddress);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
-		CommandMessage *messageToSet, const uint8_t *tcData,
-		size_t tcDataLen) {
-	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	WiretappingToggle command;
-	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
-			command.getWiretappingMode());
-	return result;
-}
-
-
-ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t* state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool* isStep) {
-	switch(reply->getCommand()) {
-	case CommandMessage::REPLY_COMMAND_OK:
-		return HasReturnvaluesIF::RETURN_OK;
-	case CommandMessage::REPLY_REJECTED:
-		return reply->getReplyRejectedReason();
-	default:
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-}
-
-// All device handlers set service 2 as default raw receiver for wiretapping
-// so we have to handle those unrequested messages.
-void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
-	switch(reply->getCommand()) {
-	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
-		break;
-	case DeviceHandlerMessage::REPLY_RAW_REPLY:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
-		break;
-	default:
-		sif::error << "Unknown message in Service2DeviceAccess::"
-				"handleUnrequestedReply with command ID " <<
-				reply->getCommand() << std::endl;
-		break;
-	}
-	//Must be reached by all cases to clear message
-	reply->clear();
-}
-
-void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
-		uint8_t subservice) {
-	// Raw Wiretapping
-	// Get Address of Data from Message
-	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
-	const uint8_t* data = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
-		        "handleUnrequestedReply with failure ID "<< result
-		        << std::endl;
-		return;
-	}
-
-	// Init our dummy packet and correct endianness of object ID before
-	// sending it back.
-	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
-	        data);
-	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
-			&TmPacket.objectId), sizeof(TmPacket.objectId));
-}
-
-MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
-	return commandQueue->getId();
-}
-
+#include "../pus/Service2DeviceAccess.h"
+#include "../pus/servicepackets/Service2Packets.h"
+
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../devicehandlers/DeviceHandlerMessage.h"
+#include "../serialize/EndianConverter.h"
+#include "../action/ActionMessage.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
+        uint16_t commandTimeoutSeconds):
+        CommandingServiceBase(objectId, apid, serviceId,
+	        numberOfParallelCommands, commandTimeoutSeconds) {}
+
+Service2DeviceAccess::~Service2DeviceAccess() {}
+
+
+ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING:
+	case Subservice::TOGGLE_WIRETAPPING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		sif::error << "Invalid Subservice" << std::endl;
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+    if(tcDataLen < sizeof(object_id_t)) {
+        return CommandingServiceBase::INVALID_TC;
+    }
+    SerializeAdapter::deSerialize(objectId, &tcData,
+                &tcDataLen, SerializeIF::Endianness::BIG);
+
+	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
+	DeviceHandlerIF* possibleTarget =
+			objectManager->get<DeviceHandlerIF>(*objectId);
+	if(possibleTarget == nullptr) {
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		uint32_t* state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)){
+	case Subservice::RAW_COMMANDING: {
+		return prepareRawCommand(message, tcData, tcDataLen);
+	}
+	break;
+	case Subservice::TOGGLE_WIRETAPPING: {
+		return prepareWiretappingCommand(message, tcData, tcDataLen);
+	}
+	break;
+	default:
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+ReturnValue_t Service2DeviceAccess::prepareRawCommand(
+        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
+	RawCommand RawCommand(tcData,tcDataLen);
+	// store command into the Inter Process Communication Store
+	store_address_t storeAddress;
+	ReturnValue_t result = IPCStore->addData(&storeAddress,
+	        RawCommand.getCommand(), RawCommand.getCommandSize());
+	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
+	        storeAddress);
+	return result;
+}
+
+ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
+		CommandMessage *messageToSet, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	WiretappingToggle command;
+	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG);
+	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
+			command.getWiretappingMode());
+	return result;
+}
+
+
+ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t* state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool* isStep) {
+	switch(reply->getCommand()) {
+	case CommandMessage::REPLY_COMMAND_OK:
+		return HasReturnvaluesIF::RETURN_OK;
+	case CommandMessage::REPLY_REJECTED:
+		return reply->getReplyRejectedReason();
+	default:
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+}
+
+// All device handlers set service 2 as default raw receiver for wiretapping
+// so we have to handle those unrequested messages.
+void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
+	switch(reply->getCommand()) {
+	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+		break;
+	case DeviceHandlerMessage::REPLY_RAW_REPLY:
+		sendWiretappingTm(reply,
+				static_cast<uint8_t>(Subservice::RAW_REPLY));
+		break;
+	default:
+		sif::error << "Unknown message in Service2DeviceAccess::"
+				"handleUnrequestedReply with command ID " <<
+				reply->getCommand() << std::endl;
+		break;
+	}
+	//Must be reached by all cases to clear message
+	reply->clear();
+}
+
+void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
+		uint8_t subservice) {
+	// Raw Wiretapping
+	// Get Address of Data from Message
+	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
+		        "handleUnrequestedReply with failure ID "<< result
+		        << std::endl;
+		return;
+	}
+
+	// Init our dummy packet and correct endianness of object ID before
+	// sending it back.
+	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
+	        data);
+	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
+	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
+			&TmPacket.objectId), sizeof(TmPacket.objectId));
+}
+
+MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
+	return commandQueue->getId();
+}
+
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index 3fb9e830..f6aa8b52 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,92 +1,92 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief   Raw Commanding and Wiretapping of devices.
- * @details
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This service provides the capability to communicate with devices in their
- * native protocols with raw commands through the DeviceHandlerIF.
- *
- * This is a gateway service. It relays device commands to the software bus.
- * This service is very closely tied to the CommandingServiceBase
- * template class.
- *
- * There are 4 adaption points for component implementation through the
- * CommandingServiceBase.
- *
- * This service employs custom subservices exclusively.  This includes a
- * wiretapping subservice to monitor all traffic between target devices and
- * this service.
- *
- *   - TC[2,128]: Raw Commanding
- *   - TC[2,129]: Toggle Wiretapping
- *   - TM[2,130]: Wiretapping Packet TM
- *   - TM[2,131]: Wiretapping Packet TC
- * @ingroup pus_services
- */
-class Service2DeviceAccess : public CommandingServiceBase,
-		public AcceptsDeviceResponsesIF
-{
-public:
-	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
-	        uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service2DeviceAccess();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
-	        object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-	/**
-	 * @brief 	Generates TM packets containing either the TC wiretapping
-	 * 			packets or the TM wiretapping packets.
-	 * Note that for service 2, all telemetry will be treated as an
-	 * unrequested reply regardless of wiretapping mode.
-	 * @param reply
-	 */
-	void handleUnrequestedReply(CommandMessage* reply) override;
-
-	MessageQueueId_t getDeviceQueue() override;
-private:
-	/**
-	 * Generates TM packets for Wiretapping Service
-	 * @param reply
-	 * @param subservice
-	 */
-	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-
-	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
-	};
-};
-
-
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Raw Commanding and Wiretapping of devices.
+ * @details
+ * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
+ * Dissertation Baetz p. 115, 116, 165-167.
+ *
+ * This service provides the capability to communicate with devices in their
+ * native protocols with raw commands through the DeviceHandlerIF.
+ *
+ * This is a gateway service. It relays device commands to the software bus.
+ * This service is very closely tied to the CommandingServiceBase
+ * template class.
+ *
+ * There are 4 adaption points for component implementation through the
+ * CommandingServiceBase.
+ *
+ * This service employs custom subservices exclusively.  This includes a
+ * wiretapping subservice to monitor all traffic between target devices and
+ * this service.
+ *
+ *   - TC[2,128]: Raw Commanding
+ *   - TC[2,129]: Toggle Wiretapping
+ *   - TM[2,130]: Wiretapping Packet TM
+ *   - TM[2,131]: Wiretapping Packet TC
+ * @ingroup pus_services
+ */
+class Service2DeviceAccess : public CommandingServiceBase,
+		public AcceptsDeviceResponsesIF
+{
+public:
+	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service2DeviceAccess();
+
+protected:
+	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
+	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
+	        object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+	/**
+	 * @brief 	Generates TM packets containing either the TC wiretapping
+	 * 			packets or the TM wiretapping packets.
+	 * Note that for service 2, all telemetry will be treated as an
+	 * unrequested reply regardless of wiretapping mode.
+	 * @param reply
+	 */
+	void handleUnrequestedReply(CommandMessage* reply) override;
+
+	MessageQueueId_t getDeviceQueue() override;
+private:
+	/**
+	 * Generates TM packets for Wiretapping Service
+	 * @param reply
+	 * @param subservice
+	 */
+	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
+	        const uint8_t* tcData, size_t tcDataLen);
+
+	enum class Subservice {
+		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
+		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	};
+};
+
+
+#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 5343b318..02031df4 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,91 +1,91 @@
-#include "../pus/Service5EventReporting.h"
-#include "../pus/servicepackets/Service5Packets.h"
-
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../events/EventManagerIF.h"
-#include "../ipc/QueueFactory.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-
-
-Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
-		PusServiceBase(objectId, apid, serviceId),
-		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service5EventReporting::~Service5EventReporting(){}
-
-ReturnValue_t Service5EventReporting::performService() {
-	EventMessage message;
-	ReturnValue_t status = RETURN_OK;
-	for(uint8_t counter = 0;
-	        counter < maxNumberReportsPerCycle;
-	        counter++)
-	{
-	    // Receive messages even if reporting is disabled for now.
-	    status = eventQueue->receiveMessage(&message);
-	    if(status == MessageQueueIF::EMPTY) {
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
-
-	    if(enableEventReport) {
-	       status = generateEventReport(message);
-	       if(status != HasReturnvaluesIF::RETURN_OK) {
-	           return status;
-	       }
-	    }
-	}
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
-	        " Too many events" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service5EventReporting::generateEventReport(
-		EventMessage message)
-{
-	EventReport report(message.getEventId(),message.getReporter(),
-			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-			message.getSeverity(), packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(
-	        requestQueue->getDefaultDestination(),requestQueue->getId());
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "Service5EventReporting::generateEventReport:"
-		        " Could not send TM packet" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice) {
-	case Subservice::ENABLE: {
-		enableEventReport = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case Subservice::DISABLE: {
-		enableEventReport = false;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-// In addition to the default PUSServiceBase initialization, this service needs
-// to be registered to the event manager to listen for events.
-ReturnValue_t Service5EventReporting::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-				objects::EVENT_MANAGER);
-	if (manager == NULL) {
-			return RETURN_FAILED;
-	}
-	// register Service 5 as listener for events
-	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	     return result;
-	}
-	return PusServiceBase::initialize();
-}
+#include "../pus/Service5EventReporting.h"
+#include "../pus/servicepackets/Service5Packets.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../events/EventManagerIF.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service5EventReporting::Service5EventReporting(object_id_t objectId,
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+		PusServiceBase(objectId, apid, serviceId),
+		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Service5EventReporting::~Service5EventReporting(){}
+
+ReturnValue_t Service5EventReporting::performService() {
+	EventMessage message;
+	ReturnValue_t status = RETURN_OK;
+	for(uint8_t counter = 0;
+	        counter < maxNumberReportsPerCycle;
+	        counter++)
+	{
+	    // Receive messages even if reporting is disabled for now.
+	    status = eventQueue->receiveMessage(&message);
+	    if(status == MessageQueueIF::EMPTY) {
+	        return HasReturnvaluesIF::RETURN_OK;
+	    }
+
+	    if(enableEventReport) {
+	       status = generateEventReport(message);
+	       if(status != HasReturnvaluesIF::RETURN_OK) {
+	           return status;
+	       }
+	    }
+	}
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service5EventReporting::generateEventReport(
+		EventMessage message)
+{
+	EventReport report(message.getEventId(),message.getReporter(),
+			message.getParameter1(),message.getParameter2());
+	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+			message.getSeverity(), packetSubCounter++, &report);
+	ReturnValue_t result = tmPacket.sendPacket(
+	        requestQueue->getDefaultDestination(),requestQueue->getId());
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
+	switch(subservice) {
+	case Subservice::ENABLE: {
+		enableEventReport = true;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case Subservice::DISABLE: {
+		enableEventReport = false;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+
+// In addition to the default PUSServiceBase initialization, this service needs
+// to be registered to the event manager to listen for events.
+ReturnValue_t Service5EventReporting::initialize() {
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+				objects::EVENT_MANAGER);
+	if (manager == NULL) {
+			return RETURN_FAILED;
+	}
+	// register Service 5 as listener for events
+	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+	     return result;
+	}
+	return PusServiceBase::initialize();
+}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 3f0c8cdf..0b6ee9a8 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,86 +1,86 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-
-#include "../tmtcservices/PusServiceBase.h"
-#include "../events/EventMessage.h"
-
-/**
- * @brief Report on-board events like information or errors
- * @details
- * Full Documentation: ECSS-E70-41A p.79
- * Implements the PusServiceBase template class.
- * Documentation: Dissertation Baetz p.135,136
- *
- * This service provides for the reporting to the service user of information of
- * operational significance.
- *   1. reporting of failures or anomalies detected on-board;
- *   2. reporting of autonomous on-board actions;
- *   3. reporting of normal progress of operations and activities, e.g.
- *   detection of events which are not anomalous (such as payload events),
- *   reaching of predefined steps in an operation. Some reports can combine
- *   more than one of these events.
- *
- * Minimum capabilities of this service:
- *
- * - TM[5,1]: Normal/Progress Report
- * - TM[5,2]: Error/Anomaly Report - Low Severity
- * - TM[5,3]: Error/Anomaly Report - Medium Severity
- * - TM[5,4]: Error/Anomaly Report - High Severity
- *
- * Events can be translated by using translator files located in
- * /config/objects/ and /config/events/. Description to events can be added by
- * adding a comment behind the event definition with [//!<] as leading string
- *
- * Additional capabilities of this service:
- *
- *  - TC[5,5]: Enable Event Report Generation (Req. 6)
- *  - TC[5,6]: Disable Event Report Generation (Req. 5)
- * @author 	R. Mueller
- * @ingroup pus_services
- */
-class Service5EventReporting: public PusServiceBase {
-public:
-
-	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
-	virtual ~Service5EventReporting();
-
-	/***
-	* Check for events and generate event reports if required.
-	* @return
-	*/
-	ReturnValue_t performService() override;
-
-	/***
-	 * Turn event generation on or off.
-	 * @return
-	 */
-	ReturnValue_t handleRequest(uint8_t subservice) override;
-
-	/**
-	 * The default PusServiceBase initialize has been overridden but is still
-	 * executed. Registers this service as a listener for events at the
-	 * EventManager.
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-
-	enum Subservice: uint8_t {
-		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
-		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
-		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
-		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
-		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
-		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
-	};
-
-private:
-	uint16_t packetSubCounter = 0;
-	MessageQueueIF* eventQueue = nullptr;
-	bool enableEventReport = true;
-	const uint8_t maxNumberReportsPerCycle;
-
-	ReturnValue_t generateEventReport(EventMessage message);
-};
-
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../events/EventMessage.h"
+
+/**
+ * @brief Report on-board events like information or errors
+ * @details
+ * Full Documentation: ECSS-E70-41A p.79
+ * Implements the PusServiceBase template class.
+ * Documentation: Dissertation Baetz p.135,136
+ *
+ * This service provides for the reporting to the service user of information of
+ * operational significance.
+ *   1. reporting of failures or anomalies detected on-board;
+ *   2. reporting of autonomous on-board actions;
+ *   3. reporting of normal progress of operations and activities, e.g.
+ *   detection of events which are not anomalous (such as payload events),
+ *   reaching of predefined steps in an operation. Some reports can combine
+ *   more than one of these events.
+ *
+ * Minimum capabilities of this service:
+ *
+ * - TM[5,1]: Normal/Progress Report
+ * - TM[5,2]: Error/Anomaly Report - Low Severity
+ * - TM[5,3]: Error/Anomaly Report - Medium Severity
+ * - TM[5,4]: Error/Anomaly Report - High Severity
+ *
+ * Events can be translated by using translator files located in
+ * /config/objects/ and /config/events/. Description to events can be added by
+ * adding a comment behind the event definition with [//!<] as leading string
+ *
+ * Additional capabilities of this service:
+ *
+ *  - TC[5,5]: Enable Event Report Generation (Req. 6)
+ *  - TC[5,6]: Disable Event Report Generation (Req. 5)
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service5EventReporting: public PusServiceBase {
+public:
+
+	Service5EventReporting(object_id_t objectId, uint16_t apid,
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	virtual ~Service5EventReporting();
+
+	/***
+	* Check for events and generate event reports if required.
+	* @return
+	*/
+	ReturnValue_t performService() override;
+
+	/***
+	 * Turn event generation on or off.
+	 * @return
+	 */
+	ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	/**
+	 * The default PusServiceBase initialize has been overridden but is still
+	 * executed. Registers this service as a listener for events at the
+	 * EventManager.
+	 * @return
+	 */
+	ReturnValue_t initialize() override;
+
+	enum Subservice: uint8_t {
+		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
+		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
+		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
+		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
+		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
+		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
+	};
+
+private:
+	uint16_t packetSubCounter = 0;
+	MessageQueueIF* eventQueue = nullptr;
+	bool enableEventReport = true;
+	const uint8_t maxNumberReportsPerCycle;
+
+	ReturnValue_t generateEventReport(EventMessage message);
+};
+
+#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 7174566a..3c94071d 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,142 +1,142 @@
-#include "../pus/Service8FunctionManagement.h"
-#include "../pus/servicepackets/Service8Packets.h"
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
-		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
-		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
-		commandTimeoutSeconds) {}
-
-Service8FunctionManagement::~Service8FunctionManagement() {}
-
-
-ReturnValue_t Service8FunctionManagement::isValidSubservice(
-		uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-	if(tcDataLen < sizeof(object_id_t)) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	SerializeAdapter::deSerialize(objectId, &tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check HasActionIF property of target
-	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
-	if(possibleTarget == nullptr){
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service8FunctionManagement::prepareCommand(
-		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
-		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
-}
-
-ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
-		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
-    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
-        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
-                << " TC size smaller thant minimum size of direct command."
-                << std::endl;
-        return CommandingServiceBase::INVALID_TC;
-    }
-
-	// Create direct command instance by extracting data from Telecommand
-	DirectCommand command(tcData, tcDataLen);
-
-	// store additional parameters into the IPC Store
-	store_address_t parameterAddress;
-	ReturnValue_t result = IPCStore->addData(&parameterAddress,
-			command.getParameters(),command.getParametersSize());
-
-	// setCommand expects a Command Message, an Action ID and a store adress
-	// pointing to additional parameters
-	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
-	return result;
-}
-
-
-ReturnValue_t Service8FunctionManagement::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t* state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool* isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	ActionId_t actionId = ActionMessage::getActionId(reply);
-	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
-
-	switch(replyId)  {
-	case ActionMessage::COMPLETION_SUCCESS: {
-		DirectReply completionReply(objectId, actionId,returnCode);
-		result = CommandingServiceBase::EXECUTION_COMPLETE;
-		break;
-	}
-	case ActionMessage::STEP_SUCCESS: {
-		*isStep = true;
-		result = HasReturnvaluesIF::RETURN_OK;
-		break;
-	}
-	case ActionMessage::DATA_REPLY: {
-	    result = handleDataReply(reply, objectId, actionId);
-		break;
-	}
-	case ActionMessage::STEP_FAILED:
-		*isStep = true;
-		/*No break, falls through*/
-	case ActionMessage::COMPLETION_FAILED:
-		result = ActionMessage::getReturnCode(reply);
-		break;
-	default:
-		result = INVALID_REPLY;
-	}
-	return result;
-}
-
-ReturnValue_t Service8FunctionManagement::handleDataReply(
-        const CommandMessage* reply, object_id_t objectId,
-        ActionId_t actionId) {
-    store_address_t storeId = ActionMessage::getStoreId(reply);
-    size_t size = 0;
-    const uint8_t * buffer = nullptr;
-    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
-    if(result != RETURN_OK) {
-        sif::error << "Service 8: Could not retrieve data for data reply"
-                << std::endl;
-        return result;
-    }
-    DataReply dataReply(objectId, actionId, buffer, size);
-    result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
-
-    auto deletionResult = IPCStore->deleteData(storeId);
-    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
-                << " of data in pool failed." << std::endl;
-    }
-    return result;
-}
+#include "../pus/Service8FunctionManagement.h"
+#include "../pus/servicepackets/Service8Packets.h"
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../action/HasActionsIF.h"
+#include "../devicehandlers/DeviceHandlerIF.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+		uint16_t commandTimeoutSeconds):
+		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		commandTimeoutSeconds) {}
+
+Service8FunctionManagement::~Service8FunctionManagement() {}
+
+
+ReturnValue_t Service8FunctionManagement::isValidSubservice(
+		uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::DIRECT_COMMANDING:
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
+		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
+		MessageQueueId_t* id, object_id_t* objectId) {
+	if(tcDataLen < sizeof(object_id_t)) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	SerializeAdapter::deSerialize(objectId, &tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
+
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check HasActionIF property of target
+	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service8FunctionManagement::prepareCommand(
+		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
+		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
+	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
+				tcData, tcDataLen);
+}
+
+ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
+		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
+    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
+                << " TC size smaller thant minimum size of direct command."
+                << std::endl;
+        return CommandingServiceBase::INVALID_TC;
+    }
+
+	// Create direct command instance by extracting data from Telecommand
+	DirectCommand command(tcData, tcDataLen);
+
+	// store additional parameters into the IPC Store
+	store_address_t parameterAddress;
+	ReturnValue_t result = IPCStore->addData(&parameterAddress,
+			command.getParameters(),command.getParametersSize());
+
+	// setCommand expects a Command Message, an Action ID and a store adress
+	// pointing to additional parameters
+	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
+	return result;
+}
+
+
+ReturnValue_t Service8FunctionManagement::handleReply(
+		const CommandMessage* reply, Command_t previousCommand,
+		uint32_t* state, CommandMessage* optionalNextCommand,
+		object_id_t objectId, bool* isStep) {
+	Command_t replyId = reply->getCommand();
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	ActionId_t actionId = ActionMessage::getActionId(reply);
+	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
+
+	switch(replyId)  {
+	case ActionMessage::COMPLETION_SUCCESS: {
+		DirectReply completionReply(objectId, actionId,returnCode);
+		result = CommandingServiceBase::EXECUTION_COMPLETE;
+		break;
+	}
+	case ActionMessage::STEP_SUCCESS: {
+		*isStep = true;
+		result = HasReturnvaluesIF::RETURN_OK;
+		break;
+	}
+	case ActionMessage::DATA_REPLY: {
+	    result = handleDataReply(reply, objectId, actionId);
+		break;
+	}
+	case ActionMessage::STEP_FAILED:
+		*isStep = true;
+		/*No break, falls through*/
+	case ActionMessage::COMPLETION_FAILED:
+		result = ActionMessage::getReturnCode(reply);
+		break;
+	default:
+		result = INVALID_REPLY;
+	}
+	return result;
+}
+
+ReturnValue_t Service8FunctionManagement::handleDataReply(
+        const CommandMessage* reply, object_id_t objectId,
+        ActionId_t actionId) {
+    store_address_t storeId = ActionMessage::getStoreId(reply);
+    size_t size = 0;
+    const uint8_t * buffer = nullptr;
+    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
+    if(result != RETURN_OK) {
+        sif::error << "Service 8: Could not retrieve data for data reply"
+                << std::endl;
+        return result;
+    }
+    DataReply dataReply(objectId, actionId, buffer, size);
+    result = sendTmPacket(static_cast<uint8_t>(
+            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+
+    auto deletionResult = IPCStore->deleteData(storeId);
+    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
+                << " of data in pool failed." << std::endl;
+    }
+    return result;
+}
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 16523533..b5ebcda8 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,67 +1,67 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-
-#include "../action/ActionMessage.h"
-#include "../tmtcservices/CommandingServiceBase.h"
-
-/**
- * @brief Functional commanding.
- * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
- * Dissertation Baetz p. 115, 116, 165-167
- *
- * This service provides the capability to perform functions of an
- * application process and provides high-level commanding as opposed to the
- * Raw Access provided by Service 2. Examples for these functions can include
- * control and operation of payload or the AOCS subsystem.
- * This service will be the primary means to control the spacecraft as it is
- * considered safer than the Raw Access provided
- * by Service 2 and is generally sufficient for most tasks.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base template
- * class. There is constant interaction between this Service Base und a
- * subclass like this service.
- *
- * Service Capability:
- * 	 - TC[8,128]: Direct Commanding
- *   - TM[8,130]: Direct Commanding Data Reply
- *
- * @ingroup pus_services
- */
-class Service8FunctionManagement : public CommandingServiceBase
-{
-public:
-	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
-			uint8_t serviceId, uint8_t numParallelCommands = 4,
-			uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service8FunctionManagement();
-
-protected:
-	/* CSB abstract functions implementation . See CSB documentation. */
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-				uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-private:
-	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
-	};
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-	ReturnValue_t prepareDirectCommand(CommandMessage* message,
-			const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t handleDataReply(const CommandMessage* reply,
-	        object_id_t objectId, ActionId_t actionId);
-};
-
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
+#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+
+#include "../action/ActionMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief Functional commanding.
+ * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
+ * Dissertation Baetz p. 115, 116, 165-167
+ *
+ * This service provides the capability to perform functions of an
+ * application process and provides high-level commanding as opposed to the
+ * Raw Access provided by Service 2. Examples for these functions can include
+ * control and operation of payload or the AOCS subsystem.
+ * This service will be the primary means to control the spacecraft as it is
+ * considered safer than the Raw Access provided
+ * by Service 2 and is generally sufficient for most tasks.
+ *
+ * This is a gateway service. It relays device commands using the software bus.
+ * This service is very closely tied to the Commanding Service Base template
+ * class. There is constant interaction between this Service Base und a
+ * subclass like this service.
+ *
+ * Service Capability:
+ * 	 - TC[8,128]: Direct Commanding
+ *   - TM[8,130]: Direct Commanding Data Reply
+ *
+ * @ingroup pus_services
+ */
+class Service8FunctionManagement : public CommandingServiceBase
+{
+public:
+	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId, uint8_t numParallelCommands = 4,
+			uint16_t commandTimeoutSeconds = 60);
+	virtual ~Service8FunctionManagement();
+
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+				uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+				Command_t previousCommand, uint32_t *state,
+				CommandMessage* optionalNextCommand, object_id_t objectId,
+				bool *isStep) override;
+
+private:
+	enum class Subservice {
+		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
+		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	};
+
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+	ReturnValue_t prepareDirectCommand(CommandMessage* message,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t handleDataReply(const CommandMessage* reply,
+	        object_id_t objectId, ActionId_t actionId);
+};
+
+#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index f4acbb61..8c5cb005 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,166 +1,166 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
-/**
- * @defgroup spacepackets PUS Packet Definitions
- *  This group contains all implemented TM or TM packages that are sent to
- *  or sent by the OBC.They are exported later to display
- *  packet structures in Mission Information Base (MIB).
- */
-
-/**
- * @brief 	FailureReport class to serialize a failure report
- * @brief 	Subservice 1, 3, 5, 7
- * @ingroup spacepackets
- */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
-public:
-	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_, uint8_t stepNumber_,
-			ReturnValue_t errorCode_, uint32_t errorParameter1_,
-			uint32_t errorParameter2_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), errorCode(errorCode_),
-			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
-			failureSubtype(failureSubtype_) {}
-
-	/**
-	 * This function is called by the FSFW when calling the tm packet send
-	 * function and supplying the SerializeIF* as parameter
-	 * @param buffer Object content is serialized into the buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-	        size_t maxSize, SerializeIF::Endianness streamEndianness
-	        ) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-			        maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		result = SerializeAdapter::serialize(&errorCode, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
-		        maxSize, streamEndianness);
-		return result;
-	}
-
-
-	virtual size_t getSerializedSize() const {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		size += SerializeAdapter::getSerializedSize(&errorCode);
-		size += SerializeAdapter::getSerializedSize(&errorParameter1);
-		size += SerializeAdapter::getSerializedSize(&errorParameter2);
-		return size;
-	}
-
-	/**
-	 * Deserialization is not allowed for a report.
-	 * @param buffer
-	 * @param size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
-	uint32_t errorParameter1;
-	uint32_t errorParameter2;
-	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
-};
-
-/**
- * @brief       Subservices 2, 4, 6, 8
- * @ingroup     spacepackets
- */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
-public:
-	SuccessReport(uint8_t subtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), subtype(subtype_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness
-			) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		return size;
-
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
-};
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+/**
+ * @defgroup spacepackets PUS Packet Definitions
+ *  This group contains all implemented TM or TM packages that are sent to
+ *  or sent by the OBC.They are exported later to display
+ *  packet structures in Mission Information Base (MIB).
+ */
+
+/**
+ * @brief 	FailureReport class to serialize a failure report
+ * @brief 	Subservice 1, 3, 5, 7
+ * @ingroup spacepackets
+ */
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+public:
+	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_, uint8_t stepNumber_,
+			ReturnValue_t errorCode_, uint32_t errorParameter1_,
+			uint32_t errorParameter2_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), errorCode(errorCode_),
+			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
+			failureSubtype(failureSubtype_) {}
+
+	/**
+	 * This function is called by the FSFW when calling the tm packet send
+	 * function and supplying the SerializeIF* as parameter
+	 * @param buffer Object content is serialized into the buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+	        size_t maxSize, SerializeIF::Endianness streamEndianness
+	        ) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+			        maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		result = SerializeAdapter::serialize(&errorCode, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
+		        maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
+		        maxSize, streamEndianness);
+		return result;
+	}
+
+
+	virtual size_t getSerializedSize() const {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		size += SerializeAdapter::getSerializedSize(&errorCode);
+		size += SerializeAdapter::getSerializedSize(&errorParameter1);
+		size += SerializeAdapter::getSerializedSize(&errorParameter2);
+		return size;
+	}
+
+	/**
+	 * Deserialization is not allowed for a report.
+	 * @param buffer
+	 * @param size
+	 * @param bigEndian
+	 * @return
+	 */
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
+	uint32_t errorParameter1;
+	uint32_t errorParameter2;
+	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
+};
+
+/**
+ * @brief       Subservices 2, 4, 6, 8
+ * @ingroup     spacepackets
+ */
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+public:
+	SuccessReport(uint8_t subtype_, uint16_t packetId_,
+			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
+			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
+			stepNumber(stepNumber_), subtype(subtype_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, SerializeIF::Endianness streamEndianness
+			) const override {
+		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
+					maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		size_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&packetId);
+		size += sizeof(packetSequenceControl);
+		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+			size += SerializeAdapter::getSerializedSize(&stepNumber);
+		}
+		return size;
+
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
+	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
+	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
+	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index 6a700b50..efcf65fc 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../modes/ModeMessage.h"
-#include "../../serialize/SerializeIF.h"
-
-/**
- * @brief Subservice 1, 2, 3, 4, 5
- * @ingroup spacepackets
- */
-class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
-public:
-
-	ModePacket() {
-		setLinks();
-	}
-
-	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
-	        objectId(objectId), mode(mode), submode(submode) {
-		setLinks();
-	}
-
-	Mode_t getMode() {
-		return mode.entry;
-	}
-
-	Submode_t getSubmode() {
-		return submode.entry;
-	}
-
-	// Forbid copying, pointers are used.
-	ModePacket(const ModePacket&) = delete;
-	ModePacket& operator=(const ModePacket&) = delete;
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&mode);
-		mode.setNext(&submode);
-	}
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
-	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
-	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
-};
-
-/**
- * @brief Subservice 7
- * @ingroup spacepackets
- */
-class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
-public:
-    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
-            objectId(objectId), reason(reason) {
-        setStart(&this->objectId);
-        this->objectId.setNext(&this->reason);
-    }
-
-    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
-	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../modes/ModeMessage.h"
+#include "../../serialize/SerializeIF.h"
+
+/**
+ * @brief Subservice 1, 2, 3, 4, 5
+ * @ingroup spacepackets
+ */
+class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
+public:
+
+	ModePacket() {
+		setLinks();
+	}
+
+	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
+	        objectId(objectId), mode(mode), submode(submode) {
+		setLinks();
+	}
+
+	Mode_t getMode() {
+		return mode.entry;
+	}
+
+	Submode_t getSubmode() {
+		return submode.entry;
+	}
+
+	// Forbid copying, pointers are used.
+	ModePacket(const ModePacket&) = delete;
+	ModePacket& operator=(const ModePacket&) = delete;
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&mode);
+		mode.setNext(&submode);
+	}
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
+	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
+	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
+};
+
+/**
+ * @brief Subservice 7
+ * @ingroup spacepackets
+ */
+class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
+public:
+    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
+            objectId(objectId), reason(reason) {
+        setStart(&this->objectId);
+        this->objectId.setNext(&this->reason);
+    }
+
+    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
+	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
index 5ff5dcd5..8dce88e5 100644
--- a/pus/servicepackets/Service201Packets.h
+++ b/pus/servicepackets/Service201Packets.h
@@ -1,48 +1,48 @@
-#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
-#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
-
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeIF.h"
-#include "../../health/HasHealthIF.h"
-
-class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
-public:
-
-	HealthCommand() {
-		setLinks();
-	}
-
-	HasHealthIF::HealthState getHealth() {
-		return static_cast<HasHealthIF::HealthState>(health.entry);
-	}
-private:
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&health);
-	}
-	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
-	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
-};
-
-
-class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
-public:
-	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
-		health(health_), oldHealth(oldHealth_)
-	{
-		setLinks();
-	}
-
-private:
-	HealthSetReply(const HealthSetReply &reply);
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&health);
-		health.setNext(&oldHealth);
-	}
-	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
-	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
-	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
-};
-
-#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../health/HasHealthIF.h"
+
+class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+public:
+
+	HealthCommand() {
+		setLinks();
+	}
+
+	HasHealthIF::HealthState getHealth() {
+		return static_cast<HasHealthIF::HealthState>(health.entry);
+	}
+private:
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Target object Id
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] Health to set
+};
+
+
+class HealthSetReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 2
+public:
+	HealthSetReply(uint8_t health_, uint8_t oldHealth_):
+		health(health_), oldHealth(oldHealth_)
+	{
+		setLinks();
+	}
+
+private:
+	HealthSetReply(const HealthSetReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&health);
+		health.setNext(&oldHealth);
+	}
+	SerializeElement<uint32_t> objectId; //!< [EXPORT] : [COMMENT] Source object ID
+	SerializeElement<uint8_t> health; //!< [EXPORT] : [COMMENT] New Health
+	SerializeElement<uint8_t> oldHealth; //!< [EXPORT] : [COMMENT] Old Health
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE201PACKETS_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index a0b1305d..d4f3fb17 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,76 +1,76 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-
-#include "../../action/ActionMessage.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-	RawCommand(const uint8_t* buffer, size_t size) {
-		// Deserialize Adapter to get correct endianness
-		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
-		        SerializeIF::Endianness::BIG);
-		commandBuffer = buffer;
-		// size is decremented by AutoSerializeAdapter,
-		// remaining size is data size
-		dataSize = size;
-	}
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getCommand() {
-		return commandBuffer;
-	}
-
-	size_t getCommandSize() const {
-		return dataSize;
-	}
-private:
-	object_id_t objectId = 0;
-	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
-	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
-};
-
-
-/**
- * @brief Subservice 129: Command packet to set wiretapping mode
- * @ingroup spacepackets
- */
-class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
-public:
-	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
-	WiretappingToggle(){
-		setStart(&objectId);
-		objectId.setNext(&wiretappingMode);
-	}
-
-	uint8_t getWiretappingMode() const {
-		return wiretappingMode.entry;
-	}
-private:
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
-};
-
-
-/**
- * @brief Subservices 130 and 131: TM packets
- * @ingroup spacepackets
- */
-class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
-public:
-	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
-	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
-	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
-	    objectId(objectId), data(buffer) {
-	}
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	RawCommand(const uint8_t* buffer, size_t size) {
+		// Deserialize Adapter to get correct endianness
+		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
+		        SerializeIF::Endianness::BIG);
+		commandBuffer = buffer;
+		// size is decremented by AutoSerializeAdapter,
+		// remaining size is data size
+		dataSize = size;
+	}
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getCommand() {
+		return commandBuffer;
+	}
+
+	size_t getCommandSize() const {
+		return dataSize;
+	}
+private:
+	object_id_t objectId = 0;
+	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
+	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
+};
+
+
+/**
+ * @brief Subservice 129: Command packet to set wiretapping mode
+ * @ingroup spacepackets
+ */
+class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
+public:
+	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
+	WiretappingToggle(){
+		setStart(&objectId);
+		objectId.setNext(&wiretappingMode);
+	}
+
+	uint8_t getWiretappingMode() const {
+		return wiretappingMode.entry;
+	}
+private:
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
+};
+
+
+/**
+ * @brief Subservices 130 and 131: TM packets
+ * @ingroup spacepackets
+ */
+class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
+public:
+	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
+	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
+	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
+	    objectId(objectId), data(buffer) {
+	}
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 0b52be3c..9655608a 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,76 +1,76 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
-
-/**
- * @brief Subservice 1, 2, 3, 4
- * Structure of Event Report.
- * It consists of:
- *      1. Report ID(RID). This is the Event ID in the FSFW
- *      2. Object ID of the reporter (e.g. subsystem)
- *      2. Parameter 1
- *      3. Parameter 2
- *
- * @ingroup spacepackets
- */
-class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
-public:
-
-	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-			uint32_t parameter2_):
-			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
-			parameter2(parameter2_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override
-	{
-		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&objectId, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter1, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter2, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&reportId);
-		size += SerializeAdapter::getSerializedSize(&objectId);
-		size += SerializeAdapter::getSerializedSize(&parameter1);
-		size += SerializeAdapter::getSerializedSize(&parameter2);
-		return size;
-
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	EventId_t reportId;
-	object_id_t objectId;
-	uint32_t parameter1;
-	uint32_t parameter2;
-};
-
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
+
+/**
+ * @brief Subservice 1, 2, 3, 4
+ * Structure of Event Report.
+ * It consists of:
+ *      1. Report ID(RID). This is the Event ID in the FSFW
+ *      2. Object ID of the reporter (e.g. subsystem)
+ *      2. Parameter 1
+ *      3. Parameter 2
+ *
+ * @ingroup spacepackets
+ */
+class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
+public:
+
+	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+			uint32_t parameter2_):
+			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
+			parameter2(parameter2_) {}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize,
+			SerializeIF::Endianness streamEndianness) const override
+	{
+		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
+				size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&objectId, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter1, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&parameter2, buffer, size,
+				maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&reportId);
+		size += SerializeAdapter::getSerializedSize(&objectId);
+		size += SerializeAdapter::getSerializedSize(&parameter1);
+		size += SerializeAdapter::getSerializedSize(&parameter2);
+		return size;
+
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        SerializeIF::Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+private:
+	EventId_t reportId;
+	object_id_t objectId;
+	uint32_t parameter1;
+	uint32_t parameter2;
+};
+
+
+#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index d16309ec..14f8b6e6 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,121 +1,121 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-
-#include "../../action/ActionMessage.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerialBufferAdapter.h"
-#include "../../serialize/SerializeElement.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerialFixedArrayListAdapter.h"
-
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-
-	DirectCommand(const uint8_t* tcData, size_t size) {
-		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		parameterBuffer = tcData;
-		parametersSize = size;
-	}
-
-	ActionId_t getActionId() const {
-		return actionId;
-	}
-
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getParameters() {
-		return parameterBuffer;
-	}
-
-	uint32_t getParametersSize() const {
-		return parametersSize;
-	}
-
-private:
-	DirectCommand(const DirectCommand &command);
-	object_id_t objectId;
-	ActionId_t actionId;
-	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
-	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
-
-};
-
-
-/**
- * @brief Subservice 130
- * Data reply (subservice 130) consists of
- *   1. Target Object ID
- *   2. Action ID
- *   3. Data
- * @ingroup spacepackets
- */
-class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-	DataReply(object_id_t objectId_, ActionId_t actionId_,
-		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
-		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
-		setLinks();
-	}
-
-private:
-	DataReply(const DataReply &reply);
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&replyData);
-	}
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<ActionId_t> actionId;
-	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
-};
-
-
-/**
- * @brief Subservice 132
- * @details
- * Not used yet. Telecommand Verification takes care of this.
- * @ingroup spacepackets
- */
-class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-
-	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
-			bool isStep_ = false, uint8_t step_ = 0):
-			isStep(isStep_), objectId(objectId_), actionId(actionId_),
-			returnCode(returnCode_),step(step_)  {
-		setLinks();
-	}
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&returnCode);
-		if(isStep) {
-			returnCode.setNext(&step);
-		}
-	}
-
-	bool isStep; //!< [EXPORT] : [IGNORE]
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
-	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
-
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
+#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+
+#include "../../action/ActionMessage.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
+
+
+/**
+ * @brief Subservice 128
+ * @ingroup spacepackets
+ */
+class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+
+	DirectCommand(const uint8_t* tcData, size_t size) {
+		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
+		        SerializeIF::Endianness::BIG);
+		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
+		        SerializeIF::Endianness::BIG);
+		parameterBuffer = tcData;
+		parametersSize = size;
+	}
+
+	ActionId_t getActionId() const {
+		return actionId;
+	}
+
+	object_id_t getObjectId() const {
+		return objectId;
+	}
+
+	const uint8_t*  getParameters() {
+		return parameterBuffer;
+	}
+
+	uint32_t getParametersSize() const {
+		return parametersSize;
+	}
+
+private:
+	DirectCommand(const DirectCommand &command);
+	object_id_t objectId;
+	ActionId_t actionId;
+	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
+	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
+
+};
+
+
+/**
+ * @brief Subservice 130
+ * Data reply (subservice 130) consists of
+ *   1. Target Object ID
+ *   2. Action ID
+ *   3. Data
+ * @ingroup spacepackets
+ */
+class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+	DataReply(object_id_t objectId_, ActionId_t actionId_,
+		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
+		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
+		setLinks();
+	}
+
+private:
+	DataReply(const DataReply &reply);
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&replyData);
+	}
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<ActionId_t> actionId;
+	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
+};
+
+
+/**
+ * @brief Subservice 132
+ * @details
+ * Not used yet. Telecommand Verification takes care of this.
+ * @ingroup spacepackets
+ */
+class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
+public:
+	typedef uint16_t typeOfMaxDataSize;
+	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
+
+	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
+			bool isStep_ = false, uint8_t step_ = 0):
+			isStep(isStep_), objectId(objectId_), actionId(actionId_),
+			returnCode(returnCode_),step(step_)  {
+		setLinks();
+	}
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&actionId);
+		actionId.setNext(&returnCode);
+		if(isStep) {
+			returnCode.setNext(&step);
+		}
+	}
+
+	bool isStep; //!< [EXPORT] : [IGNORE]
+	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
+	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
+	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
+
+};
+
+#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 893ad1db..9000b23c 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,31 +1,31 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-
-#include "../returnvalues/FwClassIds.h"
-#include <config/returnvalues/classIds.h>
-#include <cstdint>
-
-#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
-typedef uint16_t ReturnValue_t;
-
-
-class HasReturnvaluesIF {
-public:
-	static const ReturnValue_t RETURN_OK = 0;
-	static const ReturnValue_t RETURN_FAILED = 1;
-	virtual ~HasReturnvaluesIF() {}
-
-	/**
-	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
-	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
-	 * @param interfaceId
-	 * @param number
-	 * @return
-	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
-			uint8_t number) {
-	    return (interfaceId << 8) + number;
-	}
-};
-
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+
+#include "../returnvalues/FwClassIds.h"
+#include <config/returnvalues/classIds.h>
+#include <cstdint>
+
+#define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
+typedef uint16_t ReturnValue_t;
+
+
+class HasReturnvaluesIF {
+public:
+	static const ReturnValue_t RETURN_OK = 0;
+	static const ReturnValue_t RETURN_FAILED = 1;
+	virtual ~HasReturnvaluesIF() {}
+
+	/**
+	 * It is discouraged to use the input parameters 0,0 and 0,1 as this
+	 * will generate the RETURN_OK and RETURN_FAILED returnvalues.
+	 * @param interfaceId
+	 * @param number
+	 * @return
+	 */
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+			uint8_t number) {
+	    return (interfaceId << 8) + number;
+	}
+};
+
+#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index 8bc91bb5..d0872c8e 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,89 +1,89 @@
-#include "../devicehandlers/DeviceCommunicationIF.h"
-#include "../rmap/rmapStructs.h"
-#include "../rmap/RMAP.h"
-#include "../rmap/RMAPChannelIF.h"
-#include <stddef.h>
-
-ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
-	return cookie->getChannel()->reset();
-}
-
-RMAP::RMAP(){
-
-}
-
-ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-		size_t length) {
-	uint8_t instruction;
-
-	if ((buffer == NULL) && (length != 0)) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
-	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
-			length);
-
-}
-
-ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return cookie->getChannel()->getReply(cookie, NULL, NULL);
-	} else {
-		return REPLY_MISSMATCH;
-	}
-}
-
-ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-		uint32_t length, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
-			NULL, NULL, timeout_us);
-
-}
-ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
-	uint8_t command;
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	command =  RMAPIds::RMAP_COMMAND_READ
-			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
-
-	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
-
-}
-
-ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-		size_t *size) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
-		return REPLY_MISSMATCH;
-	} else {
-		return cookie->getChannel()->getReply(cookie, buffer, size);
-	}
-
-}
-
-ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
-		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
-	if (cookie->getChannel() == NULL) {
-		return COMMAND_NO_CHANNEL;
-	}
-	if (buffer == NULL || size == NULL) {
-		return DeviceCommunicationIF::NULLPOINTER;
-	}
-	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
-			buffer, size, timeout_us);
-}
+#include "../devicehandlers/DeviceCommunicationIF.h"
+#include "../rmap/rmapStructs.h"
+#include "../rmap/RMAP.h"
+#include "../rmap/RMAPChannelIF.h"
+#include <stddef.h>
+
+ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
+	return cookie->getChannel()->reset();
+}
+
+RMAP::RMAP(){
+
+}
+
+ReturnValue_t RMAP::sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+		size_t length) {
+	uint8_t instruction;
+
+	if ((buffer == NULL) && (length != 0)) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	instruction = RMAPIds::RMAP_COMMAND_WRITE | cookie->getCommandMask();
+	return cookie->getChannel()->sendCommand(cookie, instruction, buffer,
+			length);
+
+}
+
+ReturnValue_t RMAP::getWriteReply(RMAPCookie *cookie) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return cookie->getChannel()->getReply(cookie, NULL, NULL);
+	} else {
+		return REPLY_MISSMATCH;
+	}
+}
+
+ReturnValue_t RMAP::writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+		uint32_t length, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, buffer, length,
+			NULL, NULL, timeout_us);
+
+}
+ReturnValue_t RMAP::sendReadCommand(RMAPCookie *cookie, uint32_t expLength) {
+	uint8_t command;
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	command =  RMAPIds::RMAP_COMMAND_READ
+			| (cookie->getCommandMask() & ~(1 <<  RMAPIds::RMAP_COMMAND_BIT_VERIFY));
+
+	return cookie->getChannel()->sendCommand(cookie, command, NULL, expLength);
+
+}
+
+ReturnValue_t RMAP::getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+		size_t *size) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	if (cookie->getHeader()->instruction & (1 <<  RMAPIds::RMAP_COMMAND_BIT_WRITE)) {
+		return REPLY_MISSMATCH;
+	} else {
+		return cookie->getChannel()->getReply(cookie, buffer, size);
+	}
+
+}
+
+ReturnValue_t RMAP::readBlocking(RMAPCookie *cookie, uint32_t expLength,
+		uint8_t** buffer, uint32_t *size, uint32_t timeout_us) {
+	if (cookie->getChannel() == NULL) {
+		return COMMAND_NO_CHANNEL;
+	}
+	if (buffer == NULL || size == NULL) {
+		return DeviceCommunicationIF::NULLPOINTER;
+	}
+	return cookie->getChannel()->sendCommandBlocking(cookie, NULL, expLength,
+			buffer, size, timeout_us);
+}
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index 9ab6b87d..e083d407 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,227 +1,227 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../rmap/RMAPCookie.h"
-
-//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
-
-/**
- * API for a Cookie/Channel based RMAP implementation.
- *
- * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
- * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
- * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
- * the calls.
- *
- * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
- * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
- * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
- * previously is returned.
- * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
- * call, but this should not be assumed generally.
- * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
- * and a Command Mask used for specifying which RMAP capabilities are used.
- * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
- * will initialize all fields which are not set by the cookie's constructor.
- *
- * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
- * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
- * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
- * a SPaceWire transport layer.
- *
- * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
- * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
- * channel to use is contained within the cookie.
- */
-class RMAP: public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
-
-	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
-	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
-			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
-	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
-	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE3); //The cookie points to an invalid channel; command was not sent
-//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
-	//command was not sent
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
-			0xE6);	//the channel has no port set
-	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
-			0xE7);	//The specified port is not valid
-	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
-	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
-	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
-	//return values for both get_write_reply and get_read_reply
-	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
-	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
-	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
-	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
-	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
-//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
-	//return values for get_reply
-	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
-			0xC0);//Interface is busy (transmission buffer still being processed)
-	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
-			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
-	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
-			0xC2);	//Invalid data (amount / value)
-	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
-			0xC3);
-
-	//return values for reset
-	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
-	//Other SpW codes:
-	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
-	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
-	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
-	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
-	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
-	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
-	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
-	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
-
-
-	//RMAP standard replies
-	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
-	// error cases or the node does not support
-	// further distinction between the errors
-	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
-			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
-	// the packet type is reserved or the command
-	// is not used by the RMAP protocol.
-	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
-	// the device key did not match that expected
-	// by the target user application
-	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
-	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
-	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
-	// command has been received
-	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
-	// header CRC or during the transfer of data
-	// and Data CRC or immediately thereafter.
-	// Indicates that there was a communication
-	// failure of some sort on the network
-	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
-	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
-			9);	// The verify before write bit of the command
-	// was set so that the data field was buffered in
-	// order to verify the Data CRC before
-	// transferring the data to target memory. The
-	// data field was longer than able to fit inside
-	// the verify buffer resulting in a buffer overrun
-	// Note that the command is not executed in
-	// this case
-	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
-			MAKE_RETURN_CODE(10);// The target user application did not authorise
-	// the requested operation. This may be because
-	// the command requested has not been
-	// implemented
-	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
-			11);	// The amount of data in a RMW command is
-	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
-	// than 0x08)
-	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
-			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
-	// the Target Logical Address was not the value
-	// expected by the target
-
-	/**
-	 * Resets the underlying channel.
-	 *
-	 * @param cookie The cookie which points to the channel to reset
-	 * @return
-	 */
-	static ReturnValue_t reset(RMAPCookie *cookie);
-
-	/**
-	 * send an RMAP write command
-	 *
-	 * datalen is only 24bit wide, rest will be ignored
-	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
-	 * write a CRC sum at data[datalen]
-	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
-	 *
-	 * @param cookie The cookie to write to
-	 * @param buffer the data to write
-	 * @param length length of data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
-			size_t length);
-
-	/**
-	 * get the reply to a write command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @return
-	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
-
-	/**
-	 * @see sendWriteCommand()
-	 * @see getWriteReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendWriteCommand()
-	 *       - All of getWriteReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
-			uint32_t length, uint32_t timeout_us);
-
-	/**
-	 * send an RMAP read command
-	 *
-	 * @param cookie to cookie to read from
-	 * @param expLength the expected maximum length of the reply
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
-	 *      - return codes of RMAPChannelIF::sendCommand()
-	 */
-	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
-			uint32_t expLength);
-
-	/**
-	 * get a reply to an RMAP read command
-	 *
-	 * @param cookie the cookie that was read from
-	 * @param[out] buffer the location of the data
-	 * @param[out] size size of the data
-	 * @return
-	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
-	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
-	 *      - return codes of RMAPChannelIF::getReply()
-	 */
-	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
-			size_t *size);
-
-	/**
-	 * @see sendReadCommand()
-	 * @see getReadReply()
-	 *
-	 * @param timeout_us the time after the function returns, if no reply was received
-	 *
-	 * @return
-	 *       - All of sendReadCommand()
-	 *       - All of getReadReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
-			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
-
-protected:
-	RMAP();
-};
-
-#endif /* RMAPpp_H_ */
+#ifndef RMAPpp_H_
+#define RMAPpp_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../rmap/RMAPCookie.h"
+
+//SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic...
+
+/**
+ * API for a Cookie/Channel based RMAP implementation.
+ *
+ * The API offers the four basic RMAP actions: sending a Read or Write command and getting the reply to each.
+ * As RMAP is an asynchronous protocol, these are implemented as four seperate calls. There are blocking
+ * calls which combine a send and get call using a timeout, but these are "real" blocking, looping in between
+ * the calls.
+ *
+ * Cookies are used to contain Information between a send[Read,Write]Command and a get[Read,Write]Reply call,
+ * one can think of them like *nix file descriptors. A cookie is valid from a sendX call until the related getX
+ * call. That means if a cookie is used in a getX call, the reply to the sendX call the cookie was used with
+ * previously is returned.
+ * Depending on the underlying RMAPChannel implementation, a cookie can also be valid for more than one getX
+ * call, but this should not be assumed generally.
+ * A cookie encapsulates information like the RMAP Channel to use, as well as the RMAP Address
+ * and a Command Mask used for specifying which RMAP capabilities are used.
+ * Cookies are created without interaction with this API, there is no open() call. The RMAP implementation
+ * will initialize all fields which are not set by the cookie's constructor.
+ *
+ * The RMAP implementation relies on Channels. A channel is used to construct the RMAP Headers and handle the
+ * protocol. It is access via the RMAPChannelIF. Thus it is possible to use different Implementations which only
+ * need to implement the RMAPChannelIF. A channel is also responsible for accessing the lower layers, for example
+ * a SPaceWire transport layer.
+ *
+ * There is one RMAP Channel per physical device. The cookie-channel as well as the device-channel assignment
+ * can be changed at runtime to allow for example redundancy switching. This API is static as the information which
+ * channel to use is contained within the cookie.
+ */
+class RMAP: public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::RMAP_CHANNEL;
+
+	//static const ReturnValue_t COMMAND_OK = MAKE_RETURN_CODE(0x00);
+	static const ReturnValue_t COMMAND_NO_DESCRIPTORS_AVAILABLE =
+			MAKE_RETURN_CODE(0xE1); //no descriptors available for sending command; command was not sent
+	static const ReturnValue_t COMMAND_BUFFER_FULL = MAKE_RETURN_CODE(0xE2); //no receiver buffer available for expected len; command was not sent
+	static const ReturnValue_t COMMAND_CHANNEL_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE3); //The cookie points to an invalid channel; command was not sent
+//Replaced by DeviceCommunicationIF::TOO_MUCH_DATA	static const ReturnValue_t COMMAND_TOO_BIG = MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command)
+	//command was not sent
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED = MAKE_RETURN_CODE(
+			0xE6);	//the channel has no port set
+	static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE = MAKE_RETURN_CODE(
+			0xE7);	//The specified port is not valid
+	static const ReturnValue_t COMMAND_PORT_IN_USE = MAKE_RETURN_CODE(0xE8);//The specified port is already in use
+	static const ReturnValue_t COMMAND_NO_CHANNEL = MAKE_RETURN_CODE(0xE9);//The cookie to work with has no channel assigned.
+	static const ReturnValue_t NO_HW_CRC = MAKE_RETURN_CODE(0xEA);//The SpW port does not support HW CRC generation, which is unsupported
+	//return values for both get_write_reply and get_read_reply
+	static const ReturnValue_t REPLY_NO_REPLY = MAKE_RETURN_CODE(0xD0);	//no reply was received
+	static const ReturnValue_t REPLY_NOT_SENT = MAKE_RETURN_CODE(0xD1);	//command was not sent, implies no reply
+	static const ReturnValue_t REPLY_NOT_YET_SENT = MAKE_RETURN_CODE(0xD2);	//command is still waiting to be sent
+	static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(0xD3);//a read command was issued, but get_write_rply called, or other way round
+	static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);//timeout
+//replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL
+	//return values for get_reply
+	static const ReturnValue_t REPLY_INTERFACE_BUSY = MAKE_RETURN_CODE(
+			0xC0);//Interface is busy (transmission buffer still being processed)
+	static const ReturnValue_t REPLY_TRANSMISSION_ERROR =
+			MAKE_RETURN_CODE(0xC1);	//Interface encountered errors during last operation, data could not be processed. (transmission error)
+	static const ReturnValue_t REPLY_INVALID_DATA = MAKE_RETURN_CODE(
+			0xC2);	//Invalid data (amount / value)
+	static const ReturnValue_t REPLY_NOT_SUPPORTED = MAKE_RETURN_CODE(
+			0xC3);
+
+	//return values for reset
+	static const ReturnValue_t LINK_DOWN = MAKE_RETURN_CODE(0xF0);//The spw link is down
+	//Other SpW codes:
+	static const ReturnValue_t SPW_CREDIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t SPW_ESCAPE = MAKE_RETURN_CODE(0xF2);
+	static const ReturnValue_t SPW_DISCONNECT = MAKE_RETURN_CODE(0xF3);
+	static const ReturnValue_t SPW_PARITY = MAKE_RETURN_CODE(0xF4);
+	static const ReturnValue_t SPW_WRITE_SYNC = MAKE_RETURN_CODE(0xF5);
+	static const ReturnValue_t SPW_INVALID_ADDRESS = MAKE_RETURN_CODE(0xF6);
+	static const ReturnValue_t SPW_EARLY_EOP = MAKE_RETURN_CODE(0xF7);
+	static const ReturnValue_t SPW_DMA = MAKE_RETURN_CODE(0xF8);
+	static const ReturnValue_t SPW_LINK_ERROR = MAKE_RETURN_CODE(0xF9);
+
+
+	//RMAP standard replies
+	static const ReturnValue_t REPLY_OK = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t REPLY_GENERAL_ERROR_CODE = MAKE_RETURN_CODE(1);// The detected error does not fit into the other
+	// error cases or the node does not support
+	// further distinction between the errors
+	static const ReturnValue_t REPLY_UNUSED_PACKET_TYPE_OR_COMMAND_CODE =
+			MAKE_RETURN_CODE(2);	// The Header CRC was decoded correctly but
+	// the packet type is reserved or the command
+	// is not used by the RMAP protocol.
+	static const ReturnValue_t REPLY_INVALID_KEY = MAKE_RETURN_CODE(3);	// The Header CRC was decoded correctly but
+	// the device key did not match that expected
+	// by the target user application
+	static const ReturnValue_t REPLY_INVALID_DATA_CRC = MAKE_RETURN_CODE(4);// Error in the CRC of the data field
+	static const ReturnValue_t REPLY_EARLY_EOP = MAKE_RETURN_CODE(5);// EOP marker detected before the end of the data
+	static const ReturnValue_t REPLY_TOO_MUCH_DATA = MAKE_RETURN_CODE(6);// More than the expected amount of data in a
+	// command has been received
+	static const ReturnValue_t REPLY_EEP = MAKE_RETURN_CODE(7);	// EEP marker detected immediately after the
+	// header CRC or during the transfer of data
+	// and Data CRC or immediately thereafter.
+	// Indicates that there was a communication
+	// failure of some sort on the network
+	static const ReturnValue_t REPLY_RESERVED = MAKE_RETURN_CODE(8);// Reserved
+	static const ReturnValue_t REPLY_VERIFY_BUFFER_OVERRUN = MAKE_RETURN_CODE(
+			9);	// The verify before write bit of the command
+	// was set so that the data field was buffered in
+	// order to verify the Data CRC before
+	// transferring the data to target memory. The
+	// data field was longer than able to fit inside
+	// the verify buffer resulting in a buffer overrun
+	// Note that the command is not executed in
+	// this case
+	static const ReturnValue_t REPLY_COMMAND_NOT_IMPLEMENTED_OR_NOT_AUTHORISED =
+			MAKE_RETURN_CODE(10);// The target user application did not authorise
+	// the requested operation. This may be because
+	// the command requested has not been
+	// implemented
+	static const ReturnValue_t REPLY_RMW_DATA_LENGTH_ERROR = MAKE_RETURN_CODE(
+			11);	// The amount of data in a RMW command is
+	// invalid (0x01	 0x03	 0x05	 0x07 or  greater
+	// than 0x08)
+	static const ReturnValue_t REPLY_INVALID_TARGET_LOGICAL_ADDRESS =
+			MAKE_RETURN_CODE(12);	// The Header CRC was decoded correctly but
+	// the Target Logical Address was not the value
+	// expected by the target
+
+	/**
+	 * Resets the underlying channel.
+	 *
+	 * @param cookie The cookie which points to the channel to reset
+	 * @return
+	 */
+	static ReturnValue_t reset(RMAPCookie *cookie);
+
+	/**
+	 * send an RMAP write command
+	 *
+	 * datalen is only 24bit wide, rest will be ignored
+	 * IMPORTANT: the data buffer must be datalen+1 large, as the driver might
+	 * write a CRC sum at data[datalen]
+	 * if you want to send an empty packet, just do datalen = 0 and data = NULL
+	 *
+	 * @param cookie The cookie to write to
+	 * @param buffer the data to write
+	 * @param length length of data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t* buffer,
+			size_t length);
+
+	/**
+	 * get the reply to a write command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @return
+	 *      - @c REPLY_MISSMATCH			a read command was issued, but getWriteReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getWriteReply(RMAPCookie *cookie);
+
+	/**
+	 * @see sendWriteCommand()
+	 * @see getWriteReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendWriteCommand()
+	 *       - All of getWriteReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t writeBlocking(RMAPCookie *cookie, uint8_t* buffer,
+			uint32_t length, uint32_t timeout_us);
+
+	/**
+	 * send an RMAP read command
+	 *
+	 * @param cookie to cookie to read from
+	 * @param expLength the expected maximum length of the reply
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write command, or nullpointer in read command
+	 *      - return codes of RMAPChannelIF::sendCommand()
+	 */
+	static ReturnValue_t sendReadCommand(RMAPCookie *cookie,
+			uint32_t expLength);
+
+	/**
+	 * get a reply to an RMAP read command
+	 *
+	 * @param cookie the cookie that was read from
+	 * @param[out] buffer the location of the data
+	 * @param[out] size size of the data
+	 * @return
+	 *      - @c COMMAND_NULLPOINTER		buffer or size was NULL
+	 *      - @c REPLY_MISSMATCH			a write command was issued, but getReadReply called
+	 *      - return codes of RMAPChannelIF::getReply()
+	 */
+	static ReturnValue_t getReadReply(RMAPCookie *cookie, uint8_t **buffer,
+			size_t *size);
+
+	/**
+	 * @see sendReadCommand()
+	 * @see getReadReply()
+	 *
+	 * @param timeout_us the time after the function returns, if no reply was received
+	 *
+	 * @return
+	 *       - All of sendReadCommand()
+	 *       - All of getReadReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	static ReturnValue_t readBlocking(RMAPCookie *cookie, uint32_t expLength,
+			uint8_t** buffer, uint32_t *size, uint32_t timeout_us);
+
+protected:
+	RMAP();
+};
+
+#endif /* RMAPpp_H_ */
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index 037d6d27..d851885b 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,116 +1,116 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
-
-#include "../rmap/RMAPCookie.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-class RMAPChannelIF {
-public:
-	virtual ~RMAPChannelIF(){};
-	/**
-	 * Reset an RMAP channel
-	 *
-	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
-	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
-	 *
-	 * @param channel to reset
-	 *
-	 * @return
-	 *      - @c LINK_DOWN	when the link is down and all replies were missed
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
-	 *      - @c RETURN_OK else
-	 */
-	virtual ReturnValue_t reset()=0;
-
-	/**
-	 * Check if a channel is active (ie has a port)
-	 *
-	 * @param channel_nr
-	 * @return
-	 *      - @c COMMAND_OK if channel is active
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
-	 */
-	virtual ReturnValue_t isActive()=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @param dest_addr	the destination address used by all packets sent from this channel
-	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
-			uint8_t src_addr)=0;
-
-	/**
-	 * Assign a SpaceWire port to the Channel
-	 *
-	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
-	 *
-	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
-	 * @return
-	 *      - @c COMMAND_OK if port was changed
-	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
-	 */
-	virtual ReturnValue_t setPort(int8_t port)=0;
-
-	/**
-	 * Send an RMAP command
-	 *
-	 * @param cookie the cookie used with this call
-	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
-	 * @param data data to be sent
-	 * @param datalen length of data
-	 * @return
-	 *      - @c RETURN_OK
-	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
-	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
-	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
-	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
-	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
-	 */
-	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
-			const uint8_t *data, size_t datalen)=0;
-
-	/**
-	 * get the reply to an rmap command
-	 *
-	 * @param cookie the cookie the command was sent with
-	 * @param databuffer a pointer to a pointer the location of the reply will be written to
-	 * @param len a pointer to the variable the length of the reply will be written to
-	 * @return
-	 *      - @c REPLY_NO_REPLY				no reply was received
-	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
-	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
-	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
-	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
-	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
-	 *      - @c WRITE_REPLY_NOT_SUPPORTED
-	 *      - all RMAP standard replies
-	 */
-	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
-			size_t *len)=0;
-
-	/**
-	 *
-	 * @param cookie
-	 * @param data
-	 * @param datalen
-	 * @param databuffer
-	 * @param len
-	 * @param timeout_us
-	 * @return
-	 *       - all replies of sendCommand() and getReply()
-	 *       - @c REPLY_TIMEOUT				timeout
-	 */
-	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
-			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
-			uint32_t timeout_us)=0;
-
-};
-
-#endif /* RMAPCHANNELIF_H_ */
+#ifndef RMAPCHANNELIF_H_
+#define RMAPCHANNELIF_H_
+
+#include "../rmap/RMAPCookie.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class RMAPChannelIF {
+public:
+	virtual ~RMAPChannelIF(){};
+	/**
+	 * Reset an RMAP channel
+	 *
+	 * Clears the receive buffer (all received messages are deleted) and resets the descriptor table.
+	 * Also checks for errors in the descriptors and submits them to FDIR (aka stdout)
+	 *
+	 * @param channel to reset
+	 *
+	 * @return
+	 *      - @c LINK_DOWN	when the link is down and all replies were missed
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if the channel's port is NULL
+	 *      - @c RETURN_OK else
+	 */
+	virtual ReturnValue_t reset()=0;
+
+	/**
+	 * Check if a channel is active (ie has a port)
+	 *
+	 * @param channel_nr
+	 * @return
+	 *      - @c COMMAND_OK if channel is active
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED if channel is deactivated
+	 */
+	virtual ReturnValue_t isActive()=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @param dest_addr	the destination address used by all packets sent from this channel
+	 * @param src_addr the source address used by all packets sent from this channel and used when checking incoming packets
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port, uint8_t dest_addr,
+			uint8_t src_addr)=0;
+
+	/**
+	 * Assign a SpaceWire port to the Channel
+	 *
+	 * same as setPort(int8_t port, uint8_t dest_addr, uint8_t src_addr), only the addresses are left unchanged
+	 *
+	 * @param port	Number of the port. SpaceWire devices are mapped to port numbers to allow checking of the validity
+	 * @return
+	 *      - @c COMMAND_OK if port was changed
+	 *      - @c COMMAND_PORT_OUT_OF_RANGE if the port is invalid
+	 */
+	virtual ReturnValue_t setPort(int8_t port)=0;
+
+	/**
+	 * Send an RMAP command
+	 *
+	 * @param cookie the cookie used with this call
+	 * @param instruction the instruction byte that will be sent (this defines if it is a read or write command)
+	 * @param data data to be sent
+	 * @param datalen length of data
+	 * @return
+	 *      - @c RETURN_OK
+	 *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command; command was not sent
+	 *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command was not sent
+	 *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to handle (write command) or the expected len was bigger than maximal expected len (read command) command was not sent
+	 *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
+	 *      - @c NOT_SUPPORTED						if you dont feel like implementing something...
+	 */
+	virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction,
+			const uint8_t *data, size_t datalen)=0;
+
+	/**
+	 * get the reply to an rmap command
+	 *
+	 * @param cookie the cookie the command was sent with
+	 * @param databuffer a pointer to a pointer the location of the reply will be written to
+	 * @param len a pointer to the variable the length of the reply will be written to
+	 * @return
+	 *      - @c REPLY_NO_REPLY				no reply was received
+	 *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
+	 *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
+	 *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being processed)
+	 *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last operation, data could not be processed. (transmission error)
+	 *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)
+	 *      - @c WRITE_REPLY_NOT_SUPPORTED
+	 *      - all RMAP standard replies
+	 */
+	virtual ReturnValue_t getReply(RMAPCookie *cookie, uint8_t **databuffer,
+			size_t *len)=0;
+
+	/**
+	 *
+	 * @param cookie
+	 * @param data
+	 * @param datalen
+	 * @param databuffer
+	 * @param len
+	 * @param timeout_us
+	 * @return
+	 *       - all replies of sendCommand() and getReply()
+	 *       - @c REPLY_TIMEOUT				timeout
+	 */
+	virtual ReturnValue_t sendCommandBlocking(RMAPCookie *cookie, uint8_t *data,
+			uint32_t datalen, uint8_t **databuffer, uint32_t *len,
+			uint32_t timeout_us)=0;
+
+};
+
+#endif /* RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index 74101ffa..c92ee433 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,124 +1,124 @@
-#include "../rmap/RMAPChannelIF.h"
-#include "../rmap/RMAPCookie.h"
-#include <stddef.h>
-
-
-RMAPCookie::RMAPCookie() {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = 0;
-	this->header.address_hh = 0;
-	this->header.address_h = 0;
-	this->header.address_l = 0;
-	this->header.address_ll = 0;
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = NULL;
-	this->command_mask = 0;
-
-	this->dataCRC = 0;
-
-	this->maxReplyLen = 0;
-}
-
-
-
-RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
-	this->header.dest_address = 0;
-	this->header.protocol = 0x01;
-	this->header.instruction = 0;
-	this->header.dest_key = 0;
-	this->header.source_address = 0;
-	this->header.tid_h = 0;
-	this->header.tid_l = 0;
-	this->header.extended_address = set_extended_address;
-	setAddress(set_address);
-	this->header.datalen_h = 0;
-	this->header.datalen_m = 0;
-	this->header.datalen_l = 0;
-	this->header.header_crc = 0;
-	this->channel = set_channel;
-	this->command_mask = set_command_mask;
-	this->dataCRC = 0;
-
-	this->maxReplyLen = maxReplyLen;
-}
-
-
-void RMAPCookie::setAddress(uint32_t address) {
-	this->header.address_hh = (address & 0xFF000000) >> 24;
-	this->header.address_h = (address & 0x00FF0000) >> 16;
-	this->header.address_l = (address & 0x0000FF00) >> 8;
-	this->header.address_ll = address & 0x000000FF;
-}
-
-void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
-	this->header.extended_address = extendedAddress;
-}
-
-void RMAPCookie::setChannel(RMAPChannelIF *channel) {
-	this->channel = channel;
-}
-
-void RMAPCookie::setCommandMask(uint8_t commandMask) {
-	this->command_mask = commandMask;
-}
-
-uint32_t RMAPCookie::getAddress() {
-	return (header.address_hh << 24) + (header.address_h << 16)
-			+ (header.address_l << 8) + (header.address_ll);
-}
-
-uint8_t RMAPCookie::getExtendedAddress() {
-	return header.extended_address;
-}
-
-RMAPChannelIF *RMAPCookie::getChannel() {
-	return channel;
-}
-
-uint8_t RMAPCookie::getCommandMask() {
-	return command_mask;
-}
-
-RMAPCookie::~RMAPCookie() {
-
-}
-
-size_t RMAPCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
-
-void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
-	this->maxReplyLen = maxReplyLen;
-}
-
-RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
-	return &this->header;
-}
-
-uint16_t RMAPCookie::getTransactionIdentifier() const {
-	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
-}
-
-void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
-	header.tid_l  = id_ & 0xFF;
-	header.tid_h = (id_ >> 8 ) & 0xFF;
-}
-
-uint32_t RMAPCookie::getDataLength() const {
-	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
-}
-void RMAPCookie::setDataLength(uint32_t length_) {
-	header.datalen_l = length_ & 0xff;
-	header.datalen_m = (length_ >> 8) & 0xff;
-	header.datalen_h = (length_ >> 16) & 0xff;
-}
+#include "../rmap/RMAPChannelIF.h"
+#include "../rmap/RMAPCookie.h"
+#include <stddef.h>
+
+
+RMAPCookie::RMAPCookie() {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = 0;
+	this->header.address_hh = 0;
+	this->header.address_h = 0;
+	this->header.address_l = 0;
+	this->header.address_ll = 0;
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = NULL;
+	this->command_mask = 0;
+
+	this->dataCRC = 0;
+
+	this->maxReplyLen = 0;
+}
+
+
+
+RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+	this->header.dest_address = 0;
+	this->header.protocol = 0x01;
+	this->header.instruction = 0;
+	this->header.dest_key = 0;
+	this->header.source_address = 0;
+	this->header.tid_h = 0;
+	this->header.tid_l = 0;
+	this->header.extended_address = set_extended_address;
+	setAddress(set_address);
+	this->header.datalen_h = 0;
+	this->header.datalen_m = 0;
+	this->header.datalen_l = 0;
+	this->header.header_crc = 0;
+	this->channel = set_channel;
+	this->command_mask = set_command_mask;
+	this->dataCRC = 0;
+
+	this->maxReplyLen = maxReplyLen;
+}
+
+
+void RMAPCookie::setAddress(uint32_t address) {
+	this->header.address_hh = (address & 0xFF000000) >> 24;
+	this->header.address_h = (address & 0x00FF0000) >> 16;
+	this->header.address_l = (address & 0x0000FF00) >> 8;
+	this->header.address_ll = address & 0x000000FF;
+}
+
+void RMAPCookie::setExtendedAddress(uint8_t extendedAddress) {
+	this->header.extended_address = extendedAddress;
+}
+
+void RMAPCookie::setChannel(RMAPChannelIF *channel) {
+	this->channel = channel;
+}
+
+void RMAPCookie::setCommandMask(uint8_t commandMask) {
+	this->command_mask = commandMask;
+}
+
+uint32_t RMAPCookie::getAddress() {
+	return (header.address_hh << 24) + (header.address_h << 16)
+			+ (header.address_l << 8) + (header.address_ll);
+}
+
+uint8_t RMAPCookie::getExtendedAddress() {
+	return header.extended_address;
+}
+
+RMAPChannelIF *RMAPCookie::getChannel() {
+	return channel;
+}
+
+uint8_t RMAPCookie::getCommandMask() {
+	return command_mask;
+}
+
+RMAPCookie::~RMAPCookie() {
+
+}
+
+size_t RMAPCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+void RMAPCookie::setMaxReplyLen(size_t maxReplyLen) {
+	this->maxReplyLen = maxReplyLen;
+}
+
+RMAPStructs::rmap_cmd_header* RMAPCookie::getHeader(){
+	return &this->header;
+}
+
+uint16_t RMAPCookie::getTransactionIdentifier() const {
+	return static_cast<uint16_t>((header.tid_h << 8) | (header.tid_l));
+}
+
+void RMAPCookie::setTransactionIdentifier(uint16_t id_) {
+	header.tid_l  = id_ & 0xFF;
+	header.tid_h = (id_ >> 8 ) & 0xFF;
+}
+
+uint32_t RMAPCookie::getDataLength() const {
+	return static_cast<uint32_t>(header.datalen_h << 16 | header.datalen_m << 8 | header.datalen_l);
+}
+void RMAPCookie::setDataLength(uint32_t length_) {
+	header.datalen_l = length_ & 0xff;
+	header.datalen_m = (length_ >> 8) & 0xff;
+	header.datalen_h = (length_ >> 16) & 0xff;
+}
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 0da03e30..8832f857 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,59 +1,59 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
-
-#include "../devicehandlers/CookieIF.h"
-#include "../rmap/rmapStructs.h"
-#include <cstddef>
-
-class RMAPChannelIF;
-
-class RMAPCookie : public CookieIF {
-public:
-	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
-	RMAPCookie();
-
-	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
-	virtual ~RMAPCookie();
-
-
-	void setAddress(uint32_t address);
-	uint32_t getAddress();
-
-	void setExtendedAddress(uint8_t);
-	uint8_t getExtendedAddress();
-
-	void setChannel(RMAPChannelIF *channel);
-	RMAPChannelIF *getChannel();
-
-	void setCommandMask(uint8_t commandMask);
-	uint8_t getCommandMask();
-
-	size_t getMaxReplyLen() const;
-	void setMaxReplyLen(size_t maxReplyLen);
-
-	uint16_t getTransactionIdentifier() const;
-	void setTransactionIdentifier(uint16_t id_);
-
-	RMAPStructs::rmap_cmd_header* getHeader();
-
-	uint32_t getDataLength() const;
-	void setDataLength(uint32_t lenght_);
-
-	uint8_t getDataCrc() const {
-		return dataCRC;
-	}
-
-	void setDataCrc(uint8_t dataCrc) {
-		dataCRC = dataCrc;
-	}
-
-protected:
-	RMAPStructs::rmap_cmd_header header;
-	RMAPChannelIF *channel;
-	uint8_t command_mask;
-	uint32_t maxReplyLen;
-	uint8_t dataCRC;
-};
-
-#endif /* RMAPCOOKIE_H_ */
+#ifndef RMAPCOOKIE_H_
+#define RMAPCOOKIE_H_
+
+#include "../devicehandlers/CookieIF.h"
+#include "../rmap/rmapStructs.h"
+#include <cstddef>
+
+class RMAPChannelIF;
+
+class RMAPCookie : public CookieIF {
+public:
+	//To Uli: Sorry, I need an empty ctor to initialize an array of cookies.
+	RMAPCookie();
+
+	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
+			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+	virtual ~RMAPCookie();
+
+
+	void setAddress(uint32_t address);
+	uint32_t getAddress();
+
+	void setExtendedAddress(uint8_t);
+	uint8_t getExtendedAddress();
+
+	void setChannel(RMAPChannelIF *channel);
+	RMAPChannelIF *getChannel();
+
+	void setCommandMask(uint8_t commandMask);
+	uint8_t getCommandMask();
+
+	size_t getMaxReplyLen() const;
+	void setMaxReplyLen(size_t maxReplyLen);
+
+	uint16_t getTransactionIdentifier() const;
+	void setTransactionIdentifier(uint16_t id_);
+
+	RMAPStructs::rmap_cmd_header* getHeader();
+
+	uint32_t getDataLength() const;
+	void setDataLength(uint32_t lenght_);
+
+	uint8_t getDataCrc() const {
+		return dataCRC;
+	}
+
+	void setDataCrc(uint8_t dataCrc) {
+		dataCRC = dataCrc;
+	}
+
+protected:
+	RMAPStructs::rmap_cmd_header header;
+	RMAPChannelIF *channel;
+	uint8_t command_mask;
+	uint32_t maxReplyLen;
+	uint8_t dataCRC;
+};
+
+#endif /* RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 36247ce6..62a3f3ef 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,47 +1,47 @@
-#include "../rmap/RmapDeviceCommunicationIF.h"
-#include "../rmap/RMAP.h"
-
-//TODO Cast here are all potential bugs
-RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
-		const uint8_t * sendData, size_t sendLen) {
-	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
-	return RMAP::getWriteReply((RMAPCookie *) cookie);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
-		CookieIF *cookie, size_t requestLen) {
-	return RMAP::sendReadCommand((RMAPCookie *) cookie,
-				((RMAPCookie *) cookie)->getMaxReplyLen());
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
-		uint8_t** buffer, size_t * size) {
-	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
-		uint32_t address) {
-
-	((RMAPCookie *) cookie)->setAddress(address);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
-	return ((RMAPCookie *) cookie)->getAddress();
-}
-
-ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
-		uint32_t parameter) {
-	//TODO Empty?
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
-	return 0;
-}
+#include "../rmap/RmapDeviceCommunicationIF.h"
+#include "../rmap/RMAP.h"
+
+//TODO Cast here are all potential bugs
+RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::sendMessage(CookieIF *cookie,
+		const uint8_t * sendData, size_t sendLen) {
+	return RMAP::sendWriteCommand((RMAPCookie *) cookie, sendData, sendLen);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::getSendSuccess(CookieIF* cookie) {
+	return RMAP::getWriteReply((RMAPCookie *) cookie);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::requestReceiveMessage(
+		CookieIF *cookie, size_t requestLen) {
+	return RMAP::sendReadCommand((RMAPCookie *) cookie,
+				((RMAPCookie *) cookie)->getMaxReplyLen());
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::readReceivedMessage(CookieIF* cookie,
+		uint8_t** buffer, size_t * size) {
+	return RMAP::getReadReply((RMAPCookie *) cookie, buffer, size);
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setAddress(CookieIF* cookie,
+		uint32_t address) {
+
+	((RMAPCookie *) cookie)->setAddress(address);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t RmapDeviceCommunicationIF::getAddress(CookieIF* cookie) {
+	return ((RMAPCookie *) cookie)->getAddress();
+}
+
+ReturnValue_t RmapDeviceCommunicationIF::setParameter(CookieIF* cookie,
+		uint32_t parameter) {
+	//TODO Empty?
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint32_t RmapDeviceCommunicationIF::getParameter(CookieIF* cookie) {
+	return 0;
+}
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index b0564193..52efa3de 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,89 +1,89 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-
-#include "../devicehandlers/DeviceCommunicationIF.h"
-
-/**
- * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
- *          It expects RMAPCookies or a derived class of RMAPCookies
- *
- * @details	The open, close and reOpen calls are mission specific
- * 			The open call might return any child of RMAPCookies
- *
- * \ingroup rmap
- */
-class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
-
-public:
-	virtual ~RmapDeviceCommunicationIF();
-
-	/**
-	 * @brief Device specific initialization, using the cookie.
-	 * @details
-	 * The cookie is already prepared in the factory. If the communication
-	 * interface needs to be set up in some way and requires cookie information,
-	 * this can be performed in this function, which is called on device handler
-	 * initialization.
-	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendWrite().
-	 * This function is used to send data to the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-			size_t sendLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetWrite().
-	 * Get send confirmation that the data in sendMessage() was sent successfully.
-	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
-	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
-
-	/**
-	 * Called by DHB in the SEND_WRITE doSendRead().
-	 * It is assumed that it is always possible to request a reply
-	 * from a device.
-	 *
-	 * @param cookie
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
-	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
-	 *         	   will not be called in the respective communication cycle.
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
-
-	/**
-	 * Called by DHB in the GET_WRITE doGetRead().
-	 * This function is used to receive data from the physical device
-	 * by implementing and calling related drivers or wrapper functions.
-	 * @param cookie
-	 * @param data
-	 * @param len
-	 * @return @c RETURN_OK for successfull receive
-	 *         - Everything else triggers failure event with returnvalue as parameter 1
-	 */
-	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size);
-
-	ReturnValue_t setAddress(CookieIF* cookie,
-			uint32_t address);
-	uint32_t getAddress(CookieIF* cookie);
-	ReturnValue_t setParameter(CookieIF* cookie,
-			uint32_t parameter);
-	uint32_t getParameter(CookieIF* cookie);
-};
-
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+
+#include "../devicehandlers/DeviceCommunicationIF.h"
+
+/**
+ * @brief	This class is a implementation of a DeviceCommunicationIF for RMAP calls.
+ *          It expects RMAPCookies or a derived class of RMAPCookies
+ *
+ * @details	The open, close and reOpen calls are mission specific
+ * 			The open call might return any child of RMAPCookies
+ *
+ * \ingroup rmap
+ */
+class RmapDeviceCommunicationIF: public DeviceCommunicationIF {
+
+public:
+	virtual ~RmapDeviceCommunicationIF();
+
+	/**
+	 * @brief Device specific initialization, using the cookie.
+	 * @details
+	 * The cookie is already prepared in the factory. If the communication
+	 * interface needs to be set up in some way and requires cookie information,
+	 * this can be performed in this function, which is called on device handler
+	 * initialization.
+	 * @param cookie
+	 * @return -@c RETURN_OK if initialization was successfull
+	 * 		   - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendWrite().
+	 * This function is used to send data to the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return -@c RETURN_OK for successfull send
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
+			size_t sendLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetWrite().
+	 * Get send confirmation that the data in sendMessage() was sent successfully.
+	 * @param cookie
+	 * @return -@c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t getSendSuccess(CookieIF *cookie);
+
+	/**
+	 * Called by DHB in the SEND_WRITE doSendRead().
+	 * It is assumed that it is always possible to request a reply
+	 * from a device.
+	 *
+	 * @param cookie
+	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 *         -@c NO_READ_REQUEST if no request shall be made. readReceivedMessage()
+	 *         	   will not be called in the respective communication cycle.
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen);
+
+	/**
+	 * Called by DHB in the GET_WRITE doGetRead().
+	 * This function is used to receive data from the physical device
+	 * by implementing and calling related drivers or wrapper functions.
+	 * @param cookie
+	 * @param data
+	 * @param len
+	 * @return @c RETURN_OK for successfull receive
+	 *         - Everything else triggers failure event with returnvalue as parameter 1
+	 */
+	virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size);
+
+	ReturnValue_t setAddress(CookieIF* cookie,
+			uint32_t address);
+	uint32_t getAddress(CookieIF* cookie);
+	ReturnValue_t setParameter(CookieIF* cookie,
+			uint32_t parameter);
+	uint32_t getParameter(CookieIF* cookie);
+};
+
+#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index fae10bca..f981751d 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -1,124 +1,124 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
-
-#include "../osal/Endiness.h"
-#include <cstring>
-#include <iostream>
-
-/**
- * Helper class to convert variables or bitstreams between machine
- * endian and either big or little endian.
- * Machine endian is the endianness used by the machine running the
- * program and is one of big or little endian. As this is portable
- * code, it is not known at coding time which it is. At compile time
- * it is however, which is why this is implemented using compiler
- * macros and translates to a copy operation at runtime.
- *
- * This changes the layout of multi-byte variables in the machine's
- * memory. In most cases, you should not need to use this class.
- * Probably what you are looking for is the SerializeAdapter.
- * If you still decide you need this class, please read and understand
- * the code first.
- *
- * The order of the individual bytes of the multi-byte variable is
- * reversed, the byte at the highest address is moved to the lowest
- * address and vice versa, same for the bytes in between.
- *
- * Note that the conversion is also its inversion, that is converting
- * from machine to a specified endianness is the same operation as
- * converting from specified to machine (I looked it up, mathematicians
- * would call it an involution):
- *
- * X == convertBigEndian(convertBigEndian(X))
- *
- * Thus, there is only one function supplied to do the conversion.
- */
-class EndianConverter {
-private:
-	EndianConverter() {};
-public:
-	/**
-	 * Convert a typed variable between big endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertBigEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		T tmp;
-		uint8_t *pointerOut = (uint8_t*) &tmp;
-		uint8_t *pointerIn = (uint8_t*) &in;
-		for (size_t count = 0; count < sizeof(T); count++) {
-			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-		}
-		return tmp;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		return in;
-#else
-#error Unknown Byte Order
-#endif
-	}
-
-	/**
-	 * convert a bytestream representing a single variable between big endian
-	 * and machine endian.
-	 */
-	static void convertBigEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-#error BYTE_ORDER_SYSTEM not defined
-#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		for (size_t count = 0; count < size; count++) {
-			out[size - count - 1] = in[count];
-		}
-		return;
-#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-
-	/**
-	 * Convert a typed variable between little endian and machine endian.
-	 * Intended for plain old datatypes.
-	 */
-	template<typename T>
-	static T convertLittleEndian(T in) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			T tmp;
-			uint8_t *pointerOut = (uint8_t *) &tmp;
-			uint8_t *pointerIn = (uint8_t *) &in;
-			for (size_t count = 0; count < sizeof(T); count++) {
-				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
-			}
-			return tmp;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		return in;
-#else
-	#error Unknown Byte Order
-	#endif
-	}
-	/**
-	 * convert a bytestream representing a single variable between little endian
-	 * and machine endian.
-	 */
-	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
-			size_t size) {
-#ifndef BYTE_ORDER_SYSTEM
-	#error BYTE_ORDER_SYSTEM not defined
-	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
-			for (size_t count = 0; count < size; count++) {
-				out[size - count - 1] = in[count];
-			}
-			return;
-	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
-		memcpy(out, in, size);
-		return;
-#endif
-	}
-};
-
-#endif /* ENDIANSWAPPER_H_ */
+#ifndef ENDIANSWAPPER_H_
+#define ENDIANSWAPPER_H_
+
+#include "../osal/Endiness.h"
+#include <cstring>
+#include <iostream>
+
+/**
+ * Helper class to convert variables or bitstreams between machine
+ * endian and either big or little endian.
+ * Machine endian is the endianness used by the machine running the
+ * program and is one of big or little endian. As this is portable
+ * code, it is not known at coding time which it is. At compile time
+ * it is however, which is why this is implemented using compiler
+ * macros and translates to a copy operation at runtime.
+ *
+ * This changes the layout of multi-byte variables in the machine's
+ * memory. In most cases, you should not need to use this class.
+ * Probably what you are looking for is the SerializeAdapter.
+ * If you still decide you need this class, please read and understand
+ * the code first.
+ *
+ * The order of the individual bytes of the multi-byte variable is
+ * reversed, the byte at the highest address is moved to the lowest
+ * address and vice versa, same for the bytes in between.
+ *
+ * Note that the conversion is also its inversion, that is converting
+ * from machine to a specified endianness is the same operation as
+ * converting from specified to machine (I looked it up, mathematicians
+ * would call it an involution):
+ *
+ * X == convertBigEndian(convertBigEndian(X))
+ *
+ * Thus, there is only one function supplied to do the conversion.
+ */
+class EndianConverter {
+private:
+	EndianConverter() {};
+public:
+	/**
+	 * Convert a typed variable between big endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertBigEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		T tmp;
+		uint8_t *pointerOut = (uint8_t*) &tmp;
+		uint8_t *pointerIn = (uint8_t*) &in;
+		for (size_t count = 0; count < sizeof(T); count++) {
+			pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+		}
+		return tmp;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		return in;
+#else
+#error Unknown Byte Order
+#endif
+	}
+
+	/**
+	 * convert a bytestream representing a single variable between big endian
+	 * and machine endian.
+	 */
+	static void convertBigEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+#error BYTE_ORDER_SYSTEM not defined
+#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		for (size_t count = 0; count < size; count++) {
+			out[size - count - 1] = in[count];
+		}
+		return;
+#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+
+	/**
+	 * Convert a typed variable between little endian and machine endian.
+	 * Intended for plain old datatypes.
+	 */
+	template<typename T>
+	static T convertLittleEndian(T in) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			T tmp;
+			uint8_t *pointerOut = (uint8_t *) &tmp;
+			uint8_t *pointerIn = (uint8_t *) &in;
+			for (size_t count = 0; count < sizeof(T); count++) {
+				pointerOut[sizeof(T) - count - 1] = pointerIn[count];
+			}
+			return tmp;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		return in;
+#else
+	#error Unknown Byte Order
+	#endif
+	}
+	/**
+	 * convert a bytestream representing a single variable between little endian
+	 * and machine endian.
+	 */
+	static void convertLittleEndian(uint8_t *out, const uint8_t *in,
+			size_t size) {
+#ifndef BYTE_ORDER_SYSTEM
+	#error BYTE_ORDER_SYSTEM not defined
+	#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
+			for (size_t count = 0; count < size; count++) {
+				out[size - count - 1] = in[count];
+			}
+			return;
+	#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
+		memcpy(out, in, size);
+		return;
+#endif
+	}
+};
+
+#endif /* ENDIANSWAPPER_H_ */
diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 19190abd..69afdd4a 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,91 +1,91 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
-
-#include "../container/ArrayList.h"
-#include "../serialize/SerializeIF.h"
-#include <utility>
-
-/**
- * Also serializes length field !
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialArrayListAdapter : public SerializeIF {
-public:
-	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
-				buffer, size, maxSize, streamEndianness);
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		return getSerializedSize(adaptee);
-	}
-
-	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
-		uint32_t printSize = sizeof(count_t);
-		count_t i = 0;
-
-		for (i = 0; i < list->size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return deSerialize(adaptee, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		count_t tempSize = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
-				buffer, size, streamEndianness);
-		if (tempSize > list->maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		list->size = tempSize;
-		count_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
-			result = SerializeAdapter::deSerialize(
-					&list->front()[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
-private:
-	ArrayList<T, count_t> *adaptee;
-};
-
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+/**
+ * @file	SerialArrayListAdapter.h
+ * @brief	This file defines the SerialArrayListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALARRAYLISTADAPTER_H_
+#define SERIALARRAYLISTADAPTER_H_
+
+#include "../container/ArrayList.h"
+#include "../serialize/SerializeIF.h"
+#include <utility>
+
+/**
+ * Also serializes length field !
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialArrayListAdapter : public SerializeIF {
+public:
+	SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
+				buffer, size, maxSize, streamEndianness);
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
+					maxSize, streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const {
+		return getSerializedSize(adaptee);
+	}
+
+	static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
+		uint32_t printSize = sizeof(count_t);
+		count_t i = 0;
+
+		for (i = 0; i < list->size; ++i) {
+			printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
+		}
+
+		return printSize;
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return deSerialize(adaptee, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		count_t tempSize = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
+				buffer, size, streamEndianness);
+		if (tempSize > list->maxSize()) {
+			return SerializeIF::TOO_MANY_ELEMENTS;
+		}
+		list->size = tempSize;
+		count_t i = 0;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
+			result = SerializeAdapter::deSerialize(
+					&list->front()[i], buffer, size,
+					streamEndianness);
+			++i;
+		}
+		return result;
+	}
+
+
+	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
+		list->swapArrayListEndianness();
+	}
+private:
+	ArrayList<T, count_t> *adaptee;
+};
+
+
+
+#endif /* SERIALARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 812cd34b..1c11afd4 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength),
-		constBuffer(buffer), buffer(nullptr),
-		bufferLength(bufferLength) {}
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
-		bufferLength(bufferLength) {}
-
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	if (serializeLength) {
-		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
-				buffer, size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	if (*size + bufferLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-
-	if (this->constBuffer != nullptr) {
-		std::memcpy(*buffer, this->constBuffer, bufferLength);
-	}
-	else if (this->buffer != nullptr) {
-		// This will propably be never reached, constBuffer should always be
-		// set if non-const buffer is set.
-		std::memcpy(*buffer, this->buffer, bufferLength);
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*size += bufferLength;
-	(*buffer) += bufferLength;
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-template<typename count_t>
-size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	if (this->buffer == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(serializeLength){
-		count_t lengthField = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
-				buffer, size, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if(lengthField > bufferLength) {
-			return TOO_MANY_ELEMENTS;
-		}
-		bufferLength = lengthField;
-	}
-
-	if (bufferLength <= *size) {
-		*size -= bufferLength;
-		std::memcpy(this->buffer, *buffer, bufferLength);
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-template<typename count_t>
-uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(buffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getConstBuffer()." << std::endl;
-		return nullptr;
-	}
-	return buffer;
-}
-
-template<typename count_t>
-const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter::getConstBuffer:"
-				" Buffers are unitialized!" << std::endl;
-		return nullptr;
-	}
-	return constBuffer;
-}
-
-template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t bufferLength) {
-	this->buffer = buffer;
-	this->constBuffer = buffer;
-	this->bufferLength = bufferLength;
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-template class SerialBufferAdapter<uint64_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index c3dfcd8f..9a89e18b 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../serialize/SerializeAdapter.h"
-
-/**
- * This adapter provides an interface for SerializeIF to serialize or deserialize
- * buffers with no length header but a known size.
- *
- * Additionally, the buffer length can be serialized too and will be put in
- * front of the serialized buffer.
- *
- * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
- * Right now, the SerialBufferAdapter must always
- * be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename count_t>
-class SerialBufferAdapter: public SerializeIF {
-public:
-
-    /**
-     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength
-     */
-    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    /**
-     * Constructor for non-constant uint8_t buffer.
-     * Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength Length field will be serialized with size count_t
-     */
-    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    virtual ~SerialBufferAdapter();
-
-    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const override;
-
-    virtual size_t getSerializedSize() const override;
-
-    /**
-     * @brief This function deserializes a buffer into the member buffer.
-     * @details
-     * If a length field is present, it is ignored, as the size should have
-     * been set in the constructor. If the size is not known beforehand,
-     * consider using SerialFixedArrayListAdapter instead.
-     * @param buffer [out] Resulting buffer
-     * @param size remaining size to deserialize, should be larger than buffer
-     *        + size field size
-     * @param bigEndian
-     * @return
-     */
-    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) override;
-
-    uint8_t * getBuffer();
-    const uint8_t * getConstBuffer();
-    void setBuffer(uint8_t* buffer, count_t bufferLength);
-private:
-	bool serializeLength = false;
-	const uint8_t *constBuffer = nullptr;
-	uint8_t *buffer = nullptr;
-	count_t bufferLength = 0;
-};
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */
diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index 7968b420..c866df86 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,63 +1,63 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
-
-#include "../container/FixedArrayList.h"
-#include "../serialize/SerialArrayListAdapter.h"
-
-/**
- * @brief 	This adapter provides an interface for SerializeIF to serialize and
- * 			deserialize buffers with a header containing the buffer length.
- * @details
- * Can be used by SerialLinkedListAdapter by declaring
- * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
- * The sequence of objects is defined in the constructor by
- * using the setStart and setNext functions.
- *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
- * @ingroup serialize
- */
-template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter :
-		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
-		public SerializeIF {
-public:
-	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor.
-	 * Refer to the fixed array list constructors for different options.
-	 * @param args
-	 */
-	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) :
-	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
-	        std::forward<Args>(args)...){}
-
-    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
-                buffer, size, maxSize, streamEndianness);
-    }
-
-    size_t getSerializedSize() const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
-    }
-
-    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
-                buffer, size, streamEndianness);
-    }
-
-};
-
-#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
+#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
+#define SERIALFIXEDARRAYLISTADAPTER_H_
+
+#include "../container/FixedArrayList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+
+/**
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
+ * @details
+ * Can be used by SerialLinkedListAdapter by declaring
+ * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
+ *
+ *  - Buffers with a size header inside that class can be declared with
+ *    @code
+ *    SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
+ *    @endcode
+ *
+ *  - MAX_SIZE: specifies the maximum allowed number of elements
+ *    in FixedArrayList.
+ *  - BUFFER_TYPE: specifies the data type of the buffer
+ *  - count_t: specifies the type/size of the length field
+ *    which defaults to one byte.
+ *
+ * @ingroup serialize
+ */
+template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
+public:
+	/**
+	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
+	 * @param args
+	 */
+	template<typename... Args>
+	SerialFixedArrayListAdapter(Args... args) :
+	        FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
+	        std::forward<Args>(args)...){}
+
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+                buffer, size, maxSize, streamEndianness);
+    }
+
+    size_t getSerializedSize() const {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+    }
+
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
+                buffer, size, streamEndianness);
+    }
+
+};
+
+#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index a4652028..987fa70e 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,133 +1,133 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
-
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerializeIF.h"
-//This is where we need the SerializeAdapter!
-
- /**
- * @brief  	Implement the conversion of object data to data streams
- * 		   	or vice-versa, using linked lists.
- * @details
- * An alternative to the AutoSerializeAdapter functions
- *   - All object members with a datatype are declared as
- *     SerializeElement<element_type> members inside the class
- *     implementing this adapter.
- *   - The element type can also be a SerialBufferAdapter to
- *     de-/serialize buffers with a known size
- *   - The element type can also be a SerialFixedArrayListAdapter to
- *     de-/serialize buffers with a size header, which is scanned automatically.
- *
- * The sequence of objects is defined in the constructor by using
- * the setStart and setNext functions.
- *
- * 1. The serialization process is done by instantiating the class and
- *    calling serialize after all SerializeElement entries have been set by
- *    using the constructor or setter functions. An additional size variable
- *    can be supplied which is calculated/incremented automatically.
- * 2. The deserialization process is done by instantiating the class and
- *    supplying a buffer with the data which is converted into an object.
- *    The size of data to serialize can be supplied and is
- *    decremented in the function. Range checking is done internally.
- *
- * @ingroup serialize
- */
-template<typename T, typename count_t = uint8_t>
-class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
-public:
-	/**
-	 * Copying is forbidden by deleting the copy constructor and the copy
-	 * assignment operator because of the pointers to the linked list members.
-	 * Unless the child class implements an own copy constructor or
-	 * copy assignment operator, these operation will throw a compiler error.
-	 * @param
-	 */
-	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
-	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
-
-	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
-			bool printCount = false) :
-			SinglyLinkedList<T>(start), printCount(printCount) {
-	}
-
-	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
-			SinglyLinkedList<T>(first), printCount(printCount) {
-
-	}
-
-	SerialLinkedListAdapter(bool printCount = false) :
-			SinglyLinkedList<T>(), printCount(printCount) {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		if (printCount) {
-			count_t mySize = SinglyLinkedList<T>::getSize();
-			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
-					buffer, size, maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	static ReturnValue_t serialize(const LinkedElement<T>* element,
-			uint8_t** buffer, size_t* size, size_t maxSize,
-			Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->serialize(buffer, size, maxSize,
-					streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		if (printCount) {
-			return SerialLinkedListAdapter<T>::getSerializedSize()
-					+ sizeof(count_t);
-		} else {
-			return getSerializedSize(SinglyLinkedList<T>::start);
-		}
-	}
-
-	static size_t getSerializedSize(const LinkedElement<T> *element) {
-		size_t size = 0;
-		while (element != NULL) {
-			size += element->value->getSerializedSize();
-			element = element->getNext();
-		}
-		return size;
-	}
-
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
-	}
-
-	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
-			result = element->value->deSerialize(buffer, size, streamEndianness);
-			element = element->getNext();
-		}
-		return result;
-	}
-
-	bool printCount;
-};
-
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+/**
+ * @file	SerialLinkedListAdapter.h
+ * @brief	This file defines the SerialLinkedListAdapter class.
+ * @date	22.07.2014
+ * @author	baetz
+ */
+#ifndef SERIALLINKEDLISTADAPTER_H_
+#define SERIALLINKEDLISTADAPTER_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerializeIF.h"
+//This is where we need the SerializeAdapter!
+
+ /**
+ * @brief  	Implement the conversion of object data to data streams
+ * 		   	or vice-versa, using linked lists.
+ * @details
+ * An alternative to the AutoSerializeAdapter functions
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers with a known size
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
+ *
+ * The sequence of objects is defined in the constructor by using
+ * the setStart and setNext functions.
+ *
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
+ *
+ * @ingroup serialize
+ */
+template<typename T, typename count_t = uint8_t>
+class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
+public:
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
+
+	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
+			bool printCount = false) :
+			SinglyLinkedList<T>(start), printCount(printCount) {
+	}
+
+	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
+			SinglyLinkedList<T>(first), printCount(printCount) {
+
+	}
+
+	SerialLinkedListAdapter(bool printCount = false) :
+			SinglyLinkedList<T>(), printCount(printCount) {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const override {
+		if (printCount) {
+			count_t mySize = SinglyLinkedList<T>::getSize();
+			ReturnValue_t result = SerializeAdapter::serialize(&mySize,
+					buffer, size, maxSize, streamEndianness);
+			if (result != HasReturnvaluesIF::RETURN_OK) {
+				return result;
+			}
+		}
+		return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	static ReturnValue_t serialize(const LinkedElement<T>* element,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			result = element->value->serialize(buffer, size, maxSize,
+					streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	virtual size_t getSerializedSize() const override {
+		if (printCount) {
+			return SerialLinkedListAdapter<T>::getSerializedSize()
+					+ sizeof(count_t);
+		} else {
+			return getSerializedSize(SinglyLinkedList<T>::start);
+		}
+	}
+
+	static size_t getSerializedSize(const LinkedElement<T> *element) {
+		size_t size = 0;
+		while (element != NULL) {
+			size += element->value->getSerializedSize();
+			element = element->getNext();
+		}
+		return size;
+	}
+
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
+	}
+
+	static ReturnValue_t deSerialize(LinkedElement<T>* element,
+			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
+		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+			result = element->value->deSerialize(buffer, size, streamEndianness);
+			element = element->getNext();
+		}
+		return result;
+	}
+
+	bool printCount;
+};
+
+#endif /* SERIALLINKEDLISTADAPTER_H_ */
diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index bcddb71a..3e84bdf9 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,175 +1,175 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
-
-#include "../container/IsDerivedFrom.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serialize/SerializeIF.h"
-#include <type_traits>
-
- /**
- * @brief These adapters provides an interface to use the SerializeIF functions
- * 		  with arbitrary template objects to facilitate and simplify the
- * 		  serialization of classes with different multiple different data types
- * 		  into buffers and vice-versa.
- * @details
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-
-class SerializeAdapter {
-public:
-	template<typename T>
-	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, maxSize,
-				streamEndianness);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	template<typename T>
-	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-			size_t *size, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, streamEndianness);
-	}
-private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
-	public:
-		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
-				T tmp;
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					tmp = EndianConverter::convertBigEndian<T>(*object);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					tmp = EndianConverter::convertLittleEndian<T>(*object);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					tmp = *object;
-					break;
-				}
-				memcpy(*buffer, &tmp, sizeof(T));
-				*size += sizeof(T);
-				(*buffer) += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::BUFFER_TOO_SHORT;
-			}
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			T tmp;
-			if (*size >= sizeof(T)) {
-				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
-				switch (streamEndianness) {
-				case SerializeIF::Endianness::BIG:
-					*object = EndianConverter::convertBigEndian<T>(tmp);
-					break;
-				case SerializeIF::Endianness::LITTLE:
-					*object = EndianConverter::convertLittleEndian<T>(tmp);
-					break;
-				default:
-				case SerializeIF::Endianness::MACHINE:
-					*object = tmp;
-					break;
-				}
-
-				*buffer += sizeof(T);
-				return HasReturnvaluesIF::RETURN_OK;
-			} else {
-				return SerializeIF::STREAM_TOO_SHORT;
-			}
-		}
-
-		uint32_t getSerializedSize(const T *object) {
-			return sizeof(T);
-		}
-
-	};
-
-	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
-	public:
-		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size,
-				SerializeIF::Endianness streamEndianness) const {
-			size_t ignoredSize = 0;
-			if (size == NULL) {
-				size = &ignoredSize;
-			}
-			return object->serialize(buffer, size, max_size, streamEndianness);
-		}
-		uint32_t getSerializedSize(const T *object) const {
-			return object->getSerializedSize();
-		}
-
-		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
-				size_t *size, SerializeIF::Endianness streamEndianness) {
-			return object->deSerialize(buffer, size, streamEndianness);
-		}
-	};
-};
-
-#endif /* SERIALIZEADAPTER_H_ */
+#ifndef SERIALIZEADAPTER_H_
+#define SERIALIZEADAPTER_H_
+
+#include "../container/IsDerivedFrom.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serialize/EndianConverter.h"
+#include "../serialize/SerializeIF.h"
+#include <type_traits>
+
+ /**
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
+ * @details
+ *
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
+ * serialization or deserialization.
+ *
+ * There are three ways to retrieve data out of a buffer to be used in the FSFW
+ * to use regular aligned (big endian) data. Examples:
+ *
+ *   1. Use the AutoSerializeAdapter::deSerialize function
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
+ *   	uint16_t data;
+ *   	int32_t dataLen = sizeof(data);
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
+ *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
+ *   	uint16_t data;
+ *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
+ *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
+ *   	uint16_t data;
+ *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
+ *
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+
+class SerializeAdapter {
+public:
+	template<typename T>
+	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, maxSize,
+				streamEndianness);
+	}
+	template<typename T>
+	static uint32_t getSerializedSize(const T *object) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
+	}
+	template<typename T>
+	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+			size_t *size, SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, streamEndianness);
+	}
+private:
+	template<typename T, int>
+	class InternalSerializeAdapter {
+	public:
+		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			//TODO check integer overflow of *size
+			if (sizeof(T) + *size <= max_size) {
+				T tmp;
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					tmp = EndianConverter::convertBigEndian<T>(*object);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					tmp = EndianConverter::convertLittleEndian<T>(*object);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					tmp = *object;
+					break;
+				}
+				memcpy(*buffer, &tmp, sizeof(T));
+				*size += sizeof(T);
+				(*buffer) += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::BUFFER_TOO_SHORT;
+			}
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			T tmp;
+			if (*size >= sizeof(T)) {
+				*size -= sizeof(T);
+				memcpy(&tmp, *buffer, sizeof(T));
+				switch (streamEndianness) {
+				case SerializeIF::Endianness::BIG:
+					*object = EndianConverter::convertBigEndian<T>(tmp);
+					break;
+				case SerializeIF::Endianness::LITTLE:
+					*object = EndianConverter::convertLittleEndian<T>(tmp);
+					break;
+				default:
+				case SerializeIF::Endianness::MACHINE:
+					*object = tmp;
+					break;
+				}
+
+				*buffer += sizeof(T);
+				return HasReturnvaluesIF::RETURN_OK;
+			} else {
+				return SerializeIF::STREAM_TOO_SHORT;
+			}
+		}
+
+		uint32_t getSerializedSize(const T *object) {
+			return sizeof(T);
+		}
+
+	};
+
+	template<typename T>
+	class InternalSerializeAdapter<T, 1> {
+	public:
+		ReturnValue_t serialize(const T *object, uint8_t **buffer,
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) const {
+			size_t ignoredSize = 0;
+			if (size == NULL) {
+				size = &ignoredSize;
+			}
+			return object->serialize(buffer, size, max_size, streamEndianness);
+		}
+		uint32_t getSerializedSize(const T *object) const {
+			return object->getSerializedSize();
+		}
+
+		ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
+				size_t *size, SerializeIF::Endianness streamEndianness) {
+			return object->deSerialize(buffer, size, streamEndianness);
+		}
+	};
+};
+
+#endif /* SERIALIZEADAPTER_H_ */
diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index e33192ca..8c3472b2 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,60 +1,60 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
-
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
-#include <utility>
-
-/**
- * @brief This class is used to mark datatypes for serialization with the
- *        SerialLinkedListAdapter
- * @details
- * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
- * inside a SerialLinkedListAdapter implementation and setting the sequence
- * of objects with setNext() and setStart().
- * Serilization and Deserialization is then performed automatically in
- * specified sequence order.
- * @ingroup serialize
- */
-template<typename T>
-class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
-public:
-	template<typename ... Args>
-	SerializeElement(Args ... args) :
-			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
-
-	}
-	SerializeElement() :
-			LinkedElement<SerializeIF>(this) {
-	}
-	T entry;
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-			Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&entry);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&entry, buffer, size,
-				streamEndianness);
-	}
-
-	operator T() {
-		return entry;
-	}
-
-	SerializeElement<T>& operator=(T newValue) {
-		entry = newValue;
-		return *this;
-	}
-	T* operator->() {
-		return &entry;
-	}
-};
-
-#endif /* SERIALIZEELEMENT_H_ */
+#ifndef SERIALIZEELEMENT_H_
+#define SERIALIZEELEMENT_H_
+
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerializeAdapter.h"
+#include <utility>
+
+/**
+ * @brief This class is used to mark datatypes for serialization with the
+ *        SerialLinkedListAdapter
+ * @details
+ * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
+ * inside a SerialLinkedListAdapter implementation and setting the sequence
+ * of objects with setNext() and setStart().
+ * Serilization and Deserialization is then performed automatically in
+ * specified sequence order.
+ * @ingroup serialize
+ */
+template<typename T>
+class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
+public:
+	template<typename ... Args>
+	SerializeElement(Args ... args) :
+			LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+
+	}
+	SerializeElement() :
+			LinkedElement<SerializeIF>(this) {
+	}
+	T entry;
+	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+			Endianness streamEndianness) const override {
+		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
+				streamEndianness);
+	}
+
+	size_t getSerializedSize() const override {
+		return SerializeAdapter::getSerializedSize(&entry);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) override {
+		return SerializeAdapter::deSerialize(&entry, buffer, size,
+				streamEndianness);
+	}
+
+	operator T() {
+		return entry;
+	}
+
+	SerializeElement<T>& operator=(T newValue) {
+		entry = newValue;
+		return *this;
+	}
+	T* operator->() {
+		return &entry;
+	}
+};
+
+#endif /* SERIALIZEELEMENT_H_ */
diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 8dc4894a..6d5a0dda 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,58 +1,58 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-/**
- * @defgroup serialize Serialization
- * Contains serialisation services.
- */
-
-/**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
- * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
- * @ingroup serialize
- */
-class SerializeIF {
-public:
-	enum class Endianness : uint8_t {
-		BIG, LITTLE, MACHINE
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
-	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
-
-	virtual ~SerializeIF() {
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const = 0;
-
-	virtual size_t getSerializedSize() const = 0;
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) = 0;
-
-};
-
-#endif /* SERIALIZEIF_H_ */
+#ifndef SERIALIZEIF_H_
+#define SERIALIZEIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+/**
+ * @defgroup serialize Serialization
+ * Contains serialisation services.
+ */
+
+/**
+ * @brief An interface for alle classes which require
+ *        translation of objects data into data streams and vice-versa.
+ * @details
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
+ *
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
+ *
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
+ *
+ * @ingroup serialize
+ */
+class SerializeIF {
+public:
+	enum class Endianness : uint8_t {
+		BIG, LITTLE, MACHINE
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
+	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
+
+	virtual ~SerializeIF() {
+	}
+
+	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+			size_t maxSize, Endianness streamEndianness) const = 0;
+
+	virtual size_t getSerializedSize() const = 0;
+
+	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+			Endianness streamEndianness) = 0;
+
+};
+
+#endif /* SERIALIZEIF_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index e7b2a43e..880f51e1 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,217 +1,217 @@
-#include "../timemanager/Clock.h"
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
-#include <cstring>
-#include <inttypes.h>
-
-// to be implemented by bsp
-extern "C" void printChar(const char*, bool errStream);
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
-		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), buffered(buffered),
-		errStream(errStream) {
-	if(buffered) {
-		// Set pointers if the stream is buffered.
-		setp( buf, buf + BUF_SIZE );
-	}
-	preamble.reserve(MAX_PREAMBLE_SIZE);
-	preamble.resize(MAX_PREAMBLE_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		if(errStream) {
-			printChar(begin, true);
-		}
-		else {
-			printChar(begin, false);
-		}
-	}
-}
-
-#endif
-
-int ServiceInterfaceBuffer::overflow(int c) {
-	if(not buffered and this->isActive) {
-		if (c != Traits::eof()) {
-			if(errStream) {
-				printChar(reinterpret_cast<const char*>(&c), true);
-			}
-			else {
-				printChar(reinterpret_cast<const char*>(&c), false);
-			}
-		}
-		return 0;
-	}
-	// Handle output
-	putChars(pbase(), pptr());
-	if (c != Traits::eof()) {
-		char c2 = c;
-		// Handle the one character that didn't fit to buffer
-		putChars(&c2, &c2 + 1);
-	}
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	// I'm not sure about this return value!
-	return 0;
-}
-
-int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive and not buffered) {
-		if(not buffered) {
-			setp(buf, buf + BUF_SIZE - 1);
-		}
-		return 0;
-	}
-	if(not buffered) {
-		return 0;
-	}
-
-	size_t preambleSize  = 0;
-	std::string* preamble = getPreamble(&preambleSize);
-	// Write logMessage and time
-	this->putChars(preamble->data(), preamble->data() + preambleSize);
-	// Handle output
-	this->putChars(pbase(), pptr());
-	// This tells that buffer is empty again
-	setp(buf, buf + BUF_SIZE - 1);
-	return 0;
-}
-
-bool ServiceInterfaceBuffer::isBuffered() const {
-	return buffered;
-}
-
-std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
-	Clock::getDateAndTime(&loggerTime);
-	size_t currentSize = 0;
-	char* parsePosition = &preamble[0];
-	if(addCrToPreamble) {
-		preamble[0] = '\r';
-		currentSize += 1;
-		parsePosition += 1;
-	}
-	int32_t charCount = sprintf(parsePosition,
-			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
-					this->logMessage.c_str(), loggerTime.hour,
-					loggerTime.minute,
-					loggerTime.second,
-					loggerTime.usecond /1000);
-	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
-		return &preamble;
-	}
-	if(charCount > MAX_PREAMBLE_SIZE) {
-		printf("ServiceInterfaceBuffer: Char count too large for maximum "
-				"preamble size");
-		return &preamble;
-	}
-	currentSize += charCount;
-	if(preambleSize != nullptr) {
-		*preambleSize = currentSize;
-	}
-	return &preamble;
-}
-
-
-
-#ifdef UT699
-#include "../osal/rtems/Interrupt.h"
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) {
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (!Interrupt::isInterruptInProgress()) {
-		std::cout << array;
-	} else {
-		//Uncomment the following line if you need ISR debug output.
-//		printk(array);
-	}
-}
-#endif //UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-		uint16_t port) :
-		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
-				sizeof(remoteAddress)) {
-	setp(buf, buf + BUF_SIZE);
-	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
-	remoteAddress.sin_family = AF_INET;
-	remoteAddress.sin_port = htons(port);
-	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	if (udpSocket <= 0) {
-		initSocket();
-	}
-
-	if (udpSocket > 0) {
-		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
-				sizeof(remoteAddress));
-	}
-
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-	sockaddr_in address;
-	memset((uint8_t*) &address, 0, sizeof(address));
-	address.sin_family = AF_INET;
-	address.sin_port = htons(0);
-	address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-	if (socket < 0) {
-		printf("Error opening socket!\n");
-		return;
-	}
-	timeval timeout = { 0, 20 };
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_RCVTIMEO socket options!\n");
-		return;
-	}
-	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
-			sizeof(timeout)) < 0) {
-		printf("Error setting SO_SNDTIMEO socket options!\n");
-		return;
-	}
-	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
-		printf("Error binding socket!\n");
-	}
-}
-
-#endif //ML505
+#include "../timemanager/Clock.h"
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <cstring>
+#include <inttypes.h>
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+	}
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+	if(not buffered and this->isActive) {
+		if (c != Traits::eof()) {
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
+		}
+		return 0;
+	}
+	// Handle output
+	putChars(pbase(), pptr());
+	if (c != Traits::eof()) {
+		char c2 = c;
+		// Handle the one character that didn't fit to buffer
+		putChars(&c2, &c2 + 1);
+	}
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	// I'm not sure about this return value!
+	return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+	if(not this->isActive and not buffered) {
+		if(not buffered) {
+			setp(buf, buf + BUF_SIZE - 1);
+		}
+		return 0;
+	}
+	if(not buffered) {
+		return 0;
+	}
+
+	size_t preambleSize  = 0;
+	std::string* preamble = getPreamble(&preambleSize);
+	// Write logMessage and time
+	this->putChars(preamble->data(), preamble->data() + preambleSize);
+	// Handle output
+	this->putChars(pbase(), pptr());
+	// This tells that buffer is empty again
+	setp(buf, buf + BUF_SIZE - 1);
+	return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
+	if(addCrToPreamble) {
+		preamble[0] = '\r';
+		currentSize += 1;
+		parsePosition += 1;
+	}
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return &preamble;
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
+		return &preamble;
+	}
+	currentSize += charCount;
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return &preamble;
+}
+
+
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
+	this->log_message = set_message;
+	this->isActive = true;
+	setp( buf, buf + BUF_SIZE );
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (!Interrupt::isInterruptInProgress()) {
+		std::cout << array;
+	} else {
+		//Uncomment the following line if you need ISR debug output.
+//		printk(array);
+	}
+}
+#endif //UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) :
+		isActive(true), log_message(set_message), udpSocket(0), remoteAddressLength(
+				sizeof(remoteAddress)) {
+	setp(buf, buf + BUF_SIZE);
+	memset((uint8_t*) &remoteAddress, 0, sizeof(remoteAddress));
+	remoteAddress.sin_family = AF_INET;
+	remoteAddress.sin_port = htons(port);
+	remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	if (udpSocket <= 0) {
+		initSocket();
+	}
+
+	if (udpSocket > 0) {
+		sendto(udpSocket, array, length, 0, (sockaddr*) &remoteAddress,
+				sizeof(remoteAddress));
+	}
+
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+	sockaddr_in address;
+	memset((uint8_t*) &address, 0, sizeof(address));
+	address.sin_family = AF_INET;
+	address.sin_port = htons(0);
+	address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+	if (socket < 0) {
+		printf("Error opening socket!\n");
+		return;
+	}
+	timeval timeout = { 0, 20 };
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_RCVTIMEO socket options!\n");
+		return;
+	}
+	if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout,
+			sizeof(timeout)) < 0) {
+		printf("Error setting SO_SNDTIMEO socket options!\n");
+		return;
+	}
+	if (bind(udpSocket, (sockaddr *) &address, sizeof(address)) < 0) {
+		printf("Error binding socket!\n");
+	}
+}
+
+#endif //ML505
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a5c135b6..c5d5b258 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,145 +1,145 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-
-#ifndef UT699
-
-/**
- * @brief 	This is the underlying stream buffer which implements the
- * 			streambuf class and overloads the overflow() and sync() methods
- * @details
- * This class is used to modify the output of the stream, for example by adding.
- * It also calls the char printing function which is implemented in the
- * board supply package (BSP).
- */
-class ServiceInterfaceBuffer:
-        public std::streambuf {
-	friend class ServiceInterfaceStream;
-public:
-	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
-
-	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
-			bool buffered, bool errStream, uint16_t port);
-
-protected:
-	bool isActive;
-	//! This is called when buffer becomes full. If
-	//! buffer is not used, then this is called every
-	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
-
-	//! This function is called when stream is flushed,
-	//! for example when std::endl is put to stream.
-	int sync(void) override;
-
-	bool isBuffered() const;
-private:
-	//! For additional message information
-	std::string logMessage;
-	std::string preamble;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	//! This is useful for some terminal programs which do not have
-	//! implicit carriage return with newline characters.
-	bool addCrToPreamble;
-
-	//! Specifies whether the stream operates in buffered or unbuffered mode.
-	bool buffered;
-	//! This specifies to print to stderr and work in unbuffered mode.
-	bool errStream;
-
-	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	//! In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	std::string* getPreamble(size_t * preambleSize = nullptr);
-};
-
-#endif
-
-
-#ifdef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-};
-#endif //UT699
-
-#ifdef ML505
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
-	friend class ServiceInterfaceStream;
-public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-protected:
-	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
-
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
-	virtual int sync(void);
-
-private:
-	// For additional message information
-	std::string log_message;
-	// For EOF detection
-	typedef std::char_traits<char> Traits;
-
-	// Work in buffer mode. It is also possible to work without buffer.
-	static size_t const BUF_SIZE = 128;
-	char buf[BUF_SIZE];
-
-	// In this function, the characters are parsed.
-	void putChars(char const* begin, char const* end);
-
-	int udpSocket;
-	sockaddr_in remoteAddress;
-	socklen_t remoteAddressLength;
-	void initSocket();
-};
-#endif //ML505
-
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer:
+        public std::streambuf {
+	friend class ServiceInterfaceStream;
+public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
+
+protected:
+	bool isActive;
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
+	int overflow(int c = Traits::eof()) override;
+
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
+	int sync(void) override;
+
+	bool isBuffered() const;
+private:
+	//! For additional message information
+	std::string logMessage;
+	std::string preamble;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
+	bool addCrToPreamble;
+
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
+
+	//! Needed for buffered mode.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	//! In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	std::string* getPreamble(size_t * preambleSize = nullptr);
+};
+
+#endif
+
+
+#ifdef UT699
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+};
+#endif //UT699
+
+#ifdef ML505
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+
+class ServiceInterfaceBuffer: public std::basic_streambuf<char,
+		std::char_traits<char> > {
+	friend class ServiceInterfaceStream;
+public:
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+protected:
+	bool isActive;
+	// This is called when buffer becomes full. If
+	// buffer is not used, then this is called every
+	// time when characters are put to stream.
+	virtual int overflow(int c = Traits::eof());
+
+	// This function is called when stream is flushed,
+	// for example when std::endl is put to stream.
+	virtual int sync(void);
+
+private:
+	// For additional message information
+	std::string log_message;
+	// For EOF detection
+	typedef std::char_traits<char> Traits;
+
+	// Work in buffer mode. It is also possible to work without buffer.
+	static size_t const BUF_SIZE = 128;
+	char buf[BUF_SIZE];
+
+	// In this function, the characters are parsed.
+	void putChars(char const* begin, char const* end);
+
+	int udpSocket;
+	sockaddr_in remoteAddress;
+	socklen_t remoteAddressLength;
+	void initSocket();
+};
+#endif //ML505
+
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 7c6676dd..8a358999 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,32 +1,32 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&streambuf),
-		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
-
-void ServiceInterfaceStream::setActive( bool myActive) {
-	this->streambuf.isActive = myActive;
-}
-
-std::string* ServiceInterfaceStream::getPreamble() {
-	return streambuf.getPreamble();
-}
-
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive( bool myActive) {
+	this->streambuf.isActive = myActive;
+}
+
+std::string* ServiceInterfaceStream::getPreamble() {
+	return streambuf.getPreamble();
+}
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not streambuf.isBuffered() and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and streambuf.isBuffered()) {
+		this->flush();
+	}
+}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index b1786a38..051500f5 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,58 +1,58 @@
-#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
-
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
-#include <iostream>
-#include <cstdio>
-
-/**
- * Generic service interface stream which can be used like std::cout or
- * std::cerr but has additional capability. Add preamble and timestamp
- * to output. Can be run in buffered or unbuffered mode.
- */
-class ServiceInterfaceStream : public std::ostream {
-public:
-	/**
-	 * This constructor is used by specifying the preamble message.
-	 * Optionally, the output can be directed to stderr and a CR character
-	 * can be prepended to the preamble.
-	 * @param setMessage message of preamble.
-	 * @param addCrToPreamble Useful for applications like Puttty.
-	 * @param buffered specify whether to use buffered mode.
-	 * @param errStream specify which output stream to use (stderr or stdout).
-	 */
-	ServiceInterfaceStream(std::string setMessage,
-			bool addCrToPreamble = false, bool buffered = true,
-			bool errStream = false, uint16_t port = 1234);
-
-	//! An inactive stream will not print anything.
-	void setActive( bool );
-
-	/**
-	 * This can be used to retrieve the preamble in case it should be printed in
-	 * the unbuffered mode.
-	 * @return Preamle consisting of log message and timestamp.
-	 */
-	std::string* getPreamble();
-
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
-protected:
-	ServiceInterfaceBuffer streambuf;
-};
-
-// Forward declaration of interface streams. These should be instantiated in
-// main. They can then be used like std::cout or std::cerr.
-namespace sif {
-extern ServiceInterfaceStream debug;
-extern ServiceInterfaceStream info;
-extern ServiceInterfaceStream warning;
-extern ServiceInterfaceStream error;
-}
-
-#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include <iostream>
+#include <cstdio>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+public:
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
+
+	//! An inactive stream will not print anything.
+	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string* getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+protected:
+	ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index ea9f2e44..4ada7f80 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,87 +1,87 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/ConstStorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../globalfunctions/arrayprinter.h"
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
-		storeId(storeId) {}
-
-ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		storeId(storeId), store(store) {
-	internalState = AccessState::ASSIGNED;
-}
-
-ConstStorageAccessor::~ConstStorageAccessor() {
-	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
-		store->deleteData(storeId);
-	}
-}
-
-ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
-		constDataPointer(other.constDataPointer), storeId(other.storeId),
-		size_(other.size_), store(other.store), deleteData(other.deleteData),
-		internalState(other.internalState) {
-	// This prevent premature deletion
-	other.store = nullptr;
-}
-
-ConstStorageAccessor& ConstStorageAccessor::operator=(
-		ConstStorageAccessor&& other) {
-	constDataPointer = other.constDataPointer;
-	storeId = other.storeId;
-	store = other.store;
-	size_ = other.size_;
-	deleteData = other.deleteData;
-	this->store = other.store;
-	// This prevents premature deletion
-	other.store = nullptr;
-	return *this;
-}
-
-const uint8_t* ConstStorageAccessor::data() const {
-	return constDataPointer;
-}
-
-size_t ConstStorageAccessor::size() const {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return size_;
-}
-
-ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
-		size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(constDataPointer, constDataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ConstStorageAccessor::release() {
-	deleteData = false;
-}
-
-store_address_t ConstStorageAccessor::getId() const {
-	return storeId;
-}
-
-void ConstStorageAccessor::print() const {
-	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return;
-	}
-	arrayprinter::print(constDataPointer, size_);
-}
-
-void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
-	internalState = AccessState::ASSIGNED;
-	this->store = store;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/ConstStorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../globalfunctions/arrayprinter.h"
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
+		storeId(storeId) {}
+
+ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		storeId(storeId), store(store) {
+	internalState = AccessState::ASSIGNED;
+}
+
+ConstStorageAccessor::~ConstStorageAccessor() {
+	if(deleteData and store != nullptr) {
+		sif::debug << "deleting store data" << std::endl;
+		store->deleteData(storeId);
+	}
+}
+
+ConstStorageAccessor::ConstStorageAccessor(ConstStorageAccessor&& other):
+		constDataPointer(other.constDataPointer), storeId(other.storeId),
+		size_(other.size_), store(other.store), deleteData(other.deleteData),
+		internalState(other.internalState) {
+	// This prevent premature deletion
+	other.store = nullptr;
+}
+
+ConstStorageAccessor& ConstStorageAccessor::operator=(
+		ConstStorageAccessor&& other) {
+	constDataPointer = other.constDataPointer;
+	storeId = other.storeId;
+	store = other.store;
+	size_ = other.size_;
+	deleteData = other.deleteData;
+	this->store = other.store;
+	// This prevents premature deletion
+	other.store = nullptr;
+	return *this;
+}
+
+const uint8_t* ConstStorageAccessor::data() const {
+	return constDataPointer;
+}
+
+size_t ConstStorageAccessor::size() const {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return size_;
+}
+
+ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
+		size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(constDataPointer, constDataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ConstStorageAccessor::release() {
+	deleteData = false;
+}
+
+store_address_t ConstStorageAccessor::getId() const {
+	return storeId;
+}
+
+void ConstStorageAccessor::print() const {
+	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return;
+	}
+	arrayprinter::print(constDataPointer, size_);
+}
+
+void ConstStorageAccessor::assignStore(StorageManagerIF* store) {
+	internalState = AccessState::ASSIGNED;
+	this->store = store;
+}
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index ec2da8ce..573892da 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,116 +1,116 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-
-#include "../storagemanager/storeAddress.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-class StorageManagerIF;
-
-/**
- * @brief 	Helper classes to facilitate safe access to storages which is also
- * 			conforming to RAII principles
- * @details
- * Accessor class which can be returned by pool manager or passed and set by
- * pool managers to have safe access to the pool resources.
- *
- * These helper can be used together with the StorageManager classes to manage
- * access to a storage. It can take care of thread-safety while also providing
- * mechanisms to automatically clear storage data.
- */
-class ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	/**
-	 * @brief	Simple constructor which takes the store ID of the storage
-	 * 			entry to access.
-	 * @param storeId
-	 */
-	ConstStorageAccessor(store_address_t storeId);
-	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief 	The destructor in default configuration takes care of
-	 * 			deleting the accessed pool entry and unlocking the mutex
-	 */
-	virtual ~ConstStorageAccessor();
-
-	/**
-	 * @brief	Returns a pointer to the read-only data
-	 * @return
-	 */
-	const uint8_t* data() const;
-
-	/**
-	 * @brief	Copies the read-only data to the supplied pointer
-	 * @param pointer
-	 */
-	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
-
-	/**
-	 * @brief   Calling this will prevent the Accessor from deleting the data
-	 *          when the destructor is called.
-	 */
-	void release();
-
-	/**
-	 * Get the size of the data
-	 * @return
-	 */
-	size_t size() const;
-
-	/**
-	 * Get the storage ID.
-	 * @return
-	 */
-	store_address_t getId() const;
-
-	void print() const;
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being free prematurely.
-	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
-	ConstStorageAccessor(ConstStorageAccessor&&);
-
-	//! The copy ctor and copy assignemnt should be deleted implicitely
-	//! according to https://foonathan.net/2019/02/special-member-functions/
-	//! but I still deleted them to make it more explicit. (remember rule of 5).
-	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
-	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
-protected:
-	const uint8_t* constDataPointer = nullptr;
-	store_address_t storeId;
-	size_t size_ = 0;
-	//! Managing pool, has to assign itself.
-	StorageManagerIF* store = nullptr;
-	bool deleteData = true;
-
-	enum class AccessState {
-		UNINIT,
-		ASSIGNED
-	};
-	//! Internal state for safety reasons.
-	AccessState internalState = AccessState::UNINIT;
-	/**
-	 * Used by the pool manager instances to assign themselves to the
-	 * accessor. This is necessary to delete the data when the acessor
-	 * exits the scope ! The internal state will be considered read
-	 * when this function is called, so take care all data is set properly as
-	 * well.
-	 * @param
-	 */
-	void assignStore(StorageManagerIF*);
-};
-
-
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+
+#include "../storagemanager/storeAddress.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+class StorageManagerIF;
+
+/**
+ * @brief 	Helper classes to facilitate safe access to storages which is also
+ * 			conforming to RAII principles
+ * @details
+ * Accessor class which can be returned by pool manager or passed and set by
+ * pool managers to have safe access to the pool resources.
+ *
+ * These helper can be used together with the StorageManager classes to manage
+ * access to a storage. It can take care of thread-safety while also providing
+ * mechanisms to automatically clear storage data.
+ */
+class ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	/**
+	 * @brief	Simple constructor which takes the store ID of the storage
+	 * 			entry to access.
+	 * @param storeId
+	 */
+	ConstStorageAccessor(store_address_t storeId);
+	ConstStorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief 	The destructor in default configuration takes care of
+	 * 			deleting the accessed pool entry and unlocking the mutex
+	 */
+	virtual ~ConstStorageAccessor();
+
+	/**
+	 * @brief	Returns a pointer to the read-only data
+	 * @return
+	 */
+	const uint8_t* data() const;
+
+	/**
+	 * @brief	Copies the read-only data to the supplied pointer
+	 * @param pointer
+	 */
+	virtual ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize);
+
+	/**
+	 * @brief   Calling this will prevent the Accessor from deleting the data
+	 *          when the destructor is called.
+	 */
+	void release();
+
+	/**
+	 * Get the size of the data
+	 * @return
+	 */
+	size_t size() const;
+
+	/**
+	 * Get the storage ID.
+	 * @return
+	 */
+	store_address_t getId() const;
+
+	void print() const;
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being free prematurely.
+	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
+	ConstStorageAccessor(ConstStorageAccessor&&);
+
+	//! The copy ctor and copy assignemnt should be deleted implicitely
+	//! according to https://foonathan.net/2019/02/special-member-functions/
+	//! but I still deleted them to make it more explicit. (remember rule of 5).
+	ConstStorageAccessor& operator=(const ConstStorageAccessor&) = delete;
+	ConstStorageAccessor(const ConstStorageAccessor&) = delete;
+protected:
+	const uint8_t* constDataPointer = nullptr;
+	store_address_t storeId;
+	size_t size_ = 0;
+	//! Managing pool, has to assign itself.
+	StorageManagerIF* store = nullptr;
+	bool deleteData = true;
+
+	enum class AccessState {
+		UNINIT,
+		ASSIGNED
+	};
+	//! Internal state for safety reasons.
+	AccessState internalState = AccessState::UNINIT;
+	/**
+	 * Used by the pool manager instances to assign themselves to the
+	 * accessor. This is necessary to delete the data when the acessor
+	 * exits the scope ! The internal state will be considered read
+	 * when this function is called, so take care all data is set properly as
+	 * well.
+	 * @param
+	 */
+	void assignStore(StorageManagerIF*);
+};
+
+
+#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 5ead7981..2a526b6a 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,189 +1,189 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../internalError/InternalErrorReporterIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include <cstring>
-
-/**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
- */
-template<uint8_t NUMBER_OF_POOLS = 5>
-class LocalPool: public SystemObject, public StorageManagerIF {
-public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
-	/**
-	 * @brief	In the LocalPool's destructor all allocated memory is freed.
-	 */
-	virtual ~LocalPool(void);
-
-	/**
-	 * Documentation: See StorageManagerIF.h
-	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
-			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
-
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
-			size_t * size) override;
-
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
-	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
-	void clearStore() override;
-	ReturnValue_t initialize() override;
-protected:
-	/**
-	 * With this helper method, a free element of @c size is reserved.
-	 * @param size	The minimum packet size that shall be reserved.
-	 * @param[out] address Storage ID of the reserved data.
-	 * @return	- #RETURN_OK on success,
-	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
-	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
-			store_address_t* address, bool ignoreFault);
-
-	InternalErrorReporterIF *internalErrorReporter;
-private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
-	/**
-	 * @brief	In this array, the element sizes of each pool is stored.
-	 * @details	The sizes are maintained for internal pool management. The sizes
-	 * 			must be set in ascending order on construction.
-	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
-	/**
-	 * @brief	n_elements stores the number of elements per pool.
-	 * @details	These numbers are maintained for internal pool management.
-	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
-	/**
-	 * @brief	store represents the actual memory pool.
-	 * @details	It is an array of pointers to memory, which was allocated with
-	 * 			a @c new call on construction.
-	 */
-	uint8_t* store[NUMBER_OF_POOLS];
-	/**
-	 * @brief	The size_list attribute stores the size values of every pool element.
-	 * @details	As the number of elements is determined on construction, the size list
-	 * 			is also dynamically allocated there.
-	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
-	//! A variable to determine whether higher n pools are used if
-	//! the store is full.
-	bool spillsToHigherPools;
-	/**
-	 * @brief	This method safely stores the given data in the given packet_id.
-	 * @details	It also sets the size in size_list. The method does not perform
-	 * 			any range checks, these are done in advance.
-	 * @param packet_id	The storage identifier in which the data shall be stored.
-	 * @param data		The data to be stored.
-	 * @param size		The size of the data to be stored.
-	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
-	/**
-	 * @brief	A helper method to read the element size of a certain pool.
-	 * @param pool_index	The pool in which to look.
-	 * @return	Returns the size of an element or 0.
-	 */
-	uint32_t getPageSize(uint16_t pool_index);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size		The size of the data to be stored.
-	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
-	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
-			uint16_t startAtIndex = 0);
-	/**
-	 * @brief	This helper method calculates the true array position in store
-	 * 			of a given packet id.
-	 * @details	The method does not perform any range checks, these are done in
-	 * 			advance.
-	 * @param packet_id	The packet id to look up.
-	 * @return	Returns the position of the data in store.
-	 */
-	uint32_t getRawPosition(store_address_t packet_id);
-	/**
-	 * @brief	This is a helper method to find an empty element in a given pool.
-	 * @details	The method searches size_list for the first empty element, so
-	 * 			duration grows with the fill level of the pool.
-	 * @param pool_index	The pool in which the search is performed.
-	 * @param[out] element	The first found element in the pool.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_STORAGE_FULL if the store is full
-	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
-};
-
-#include "../storagemanager/LocalPool.tpp"
-
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../internalError/InternalErrorReporterIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include <cstring>
+
+/**
+ * @brief	The LocalPool class provides an intermediate data storage with
+ * 			a fixed pool size policy.
+ * @details	The class implements the StorageManagerIF interface. While the
+ * 			total number of pools is fixed, the element sizes in one pool and
+ * 			the number of pool elements per pool are set on construction.
+ * 			The full amount of memory is allocated on construction.
+ * 			The overhead is 4 byte per pool element to store the size
+ * 			information of each stored element.
+ * 			To maintain an "empty" information, the pool size is limited to
+ * 			0xFFFF-1 bytes.
+ * 			It is possible to store empty packets in the pool.
+ * 			The local pool is NOT thread-safe.
+ * @author 	Bastian Baetz
+ */
+template<uint8_t NUMBER_OF_POOLS = 5>
+class LocalPool: public SystemObject, public StorageManagerIF {
+public:
+	/**
+	 * @brief	This definition generally sets the number of different sized pools.
+	 * @details This must be less than the maximum number of pools (currently 0xff).
+	 */
+	//	static const uint32_t NUMBER_OF_POOLS;
+	/**
+	 * @brief	This is the default constructor for a pool manager instance.
+	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
+	 * 			allocates memory (with @c new) for store and size_list. These
+	 * 			regions are all set to zero on start up.
+	 * @param setObjectId	The object identifier to be set. This allows for
+	 * 						multiple instances of LocalPool in the system.
+	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
+	 * 						of a single element in each pool is determined.
+	 * 						<b>The sizes must be provided in ascending order.
+	 * 						</b>
+	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
+	 * 						number of elements for each pool is determined.
+	 * 						The position of these values correspond to those in
+	 * 						element_sizes.
+	 * @param registered	Register the pool in object manager or not.
+	 * Default is false (local pool).
+	 * @param spillsToHigherPools A variable to determine whether
+	 * higher n pools are used if the store is full.
+	 */
+	LocalPool(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS],
+			bool registered = false,
+			bool spillsToHigherPools = false);
+	/**
+	 * @brief	In the LocalPool's destructor all allocated memory is freed.
+	 */
+	virtual ~LocalPool(void);
+
+	/**
+	 * Documentation: See StorageManagerIF.h
+	 */
+	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+			size_t size, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
+			uint8_t** p_data, bool ignoreFault = false) override;
+
+	ConstAccessorPair getData(store_address_t packet_id) override;
+	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
+	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+			size_t * size) override;
+
+	AccessorPair modifyData(store_address_t packet_id) override;
+	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
+	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
+			size_t * size) override;
+
+	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
+			store_address_t* storeId = NULL) override;
+	void clearStore() override;
+	ReturnValue_t initialize() override;
+protected:
+	/**
+	 * With this helper method, a free element of @c size is reserved.
+	 * @param size	The minimum packet size that shall be reserved.
+	 * @param[out] address Storage ID of the reserved data.
+	 * @return	- #RETURN_OK on success,
+	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
+	 */
+	virtual ReturnValue_t reserveSpace(const uint32_t size,
+			store_address_t* address, bool ignoreFault);
+
+	InternalErrorReporterIF *internalErrorReporter;
+private:
+	/**
+	 * Indicates that this element is free.
+	 * This value limits the maximum size of a pool. Change to larger data type
+	 * if increase is required.
+	 */
+	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+	/**
+	 * @brief	In this array, the element sizes of each pool is stored.
+	 * @details	The sizes are maintained for internal pool management. The sizes
+	 * 			must be set in ascending order on construction.
+	 */
+	uint32_t element_sizes[NUMBER_OF_POOLS];
+	/**
+	 * @brief	n_elements stores the number of elements per pool.
+	 * @details	These numbers are maintained for internal pool management.
+	 */
+	uint16_t n_elements[NUMBER_OF_POOLS];
+	/**
+	 * @brief	store represents the actual memory pool.
+	 * @details	It is an array of pointers to memory, which was allocated with
+	 * 			a @c new call on construction.
+	 */
+	uint8_t* store[NUMBER_OF_POOLS];
+	/**
+	 * @brief	The size_list attribute stores the size values of every pool element.
+	 * @details	As the number of elements is determined on construction, the size list
+	 * 			is also dynamically allocated there.
+	 */
+	uint32_t* size_list[NUMBER_OF_POOLS];
+	//! A variable to determine whether higher n pools are used if
+	//! the store is full.
+	bool spillsToHigherPools;
+	/**
+	 * @brief	This method safely stores the given data in the given packet_id.
+	 * @details	It also sets the size in size_list. The method does not perform
+	 * 			any range checks, these are done in advance.
+	 * @param packet_id	The storage identifier in which the data shall be stored.
+	 * @param data		The data to be stored.
+	 * @param size		The size of the data to be stored.
+	 */
+	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	/**
+	 * @brief	A helper method to read the element size of a certain pool.
+	 * @param pool_index	The pool in which to look.
+	 * @return	Returns the size of an element or 0.
+	 */
+	uint32_t getPageSize(uint16_t pool_index);
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size	The size of the data to be stored.
+	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
+	 */
+	/**
+	 * @brief	This helper method looks up a fitting pool for a given size.
+	 * @details	The pools are looked up in ascending order, so the first that
+	 * 			fits is used.
+	 * @param packet_size		The size of the data to be stored.
+	 * @param[out] poolIndex	The fitting pool index found.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_TOO_LARGE otherwise.
+	 */
+	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+			uint16_t startAtIndex = 0);
+	/**
+	 * @brief	This helper method calculates the true array position in store
+	 * 			of a given packet id.
+	 * @details	The method does not perform any range checks, these are done in
+	 * 			advance.
+	 * @param packet_id	The packet id to look up.
+	 * @return	Returns the position of the data in store.
+	 */
+	uint32_t getRawPosition(store_address_t packet_id);
+	/**
+	 * @brief	This is a helper method to find an empty element in a given pool.
+	 * @details	The method searches size_list for the first empty element, so
+	 * 			duration grows with the fill level of the pool.
+	 * @param pool_index	The pool in which the search is performed.
+	 * @param[out] element	The first found element in the pool.
+	 * @return	- #RETURN_OK on success,
+	 * 			- #DATA_STORAGE_FULL if the store is full
+	 */
+	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+};
+
+#include "../storagemanager/LocalPool.tpp"
+
+#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 2dc3266a..76bddb8f 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-
-#include "../storagemanager/LocalPool.h"
-#include "../ipc/MutexHelper.h"
-#include "../storagemanager/StorageAccessor.h"
-
-/**
- * @brief	The PoolManager class provides an intermediate data storage with
- * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
- * @author 	Bastian Baetz
- */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
-public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
-
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
-	virtual ~PoolManager();
-
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
-	ReturnValue_t deleteData(store_address_t) override;
-	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) override;
-
-protected:
-	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
-
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
-			bool ignoreFault) override;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking is done during searching for free slots
-	 * 			and deleting existing slots.
-	 */
-	MutexIF* mutex;
-};
-
-#include "PoolManager.tpp"
-
-#endif /* POOLMANAGER_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+
+#include "../storagemanager/LocalPool.h"
+#include "../ipc/MutexHelper.h"
+#include "../storagemanager/StorageAccessor.h"
+
+/**
+ * @brief	The PoolManager class provides an intermediate data storage with
+ * 			a fixed pool size policy for inter-process communication.
+ * @details	Uses local pool calls but is thread safe by protecting the call
+ * 			with a lock.
+ * @author 	Bastian Baetz
+ */
+template <uint8_t NUMBER_OF_POOLS = 5>
+class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+public:
+	PoolManager(object_id_t setObjectId,
+			const uint16_t element_sizes[NUMBER_OF_POOLS],
+			const uint16_t n_elements[NUMBER_OF_POOLS]);
+
+	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	virtual ~PoolManager();
+
+	//! @brief LocalPool overrides for thread-safety. Decorator function which
+	//! 	   wraps LocalPool calls with a mutex protection.
+	ReturnValue_t deleteData(store_address_t) override;
+	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) override;
+
+protected:
+	//! Default mutex timeout value to prevent permanent blocking.
+	static constexpr uint32_t mutexTimeout = 50;
+
+	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+			bool ignoreFault) override;
+
+	/**
+	 * @brief	The mutex is created in the constructor and makes
+	 * 			access mutual exclusive.
+	 * @details	Locking and unlocking is done during searching for free slots
+	 * 			and deleting existing slots.
+	 */
+	MutexIF* mutex;
+};
+
+#include "PoolManager.tpp"
+
+#endif /* POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index d4d2a54d..60bd4130 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,67 +1,67 @@
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-StorageAccessor::StorageAccessor(store_address_t storeId):
-		ConstStorageAccessor(storeId) {
-}
-
-StorageAccessor::StorageAccessor(store_address_t storeId,
-		StorageManagerIF* store):
-		ConstStorageAccessor(storeId, store) {
-}
-
-StorageAccessor& StorageAccessor::operator =(
-		StorageAccessor&& other) {
-	// Call the parent move assignment and also assign own member.
-	dataPointer = other.dataPointer;
-	StorageAccessor::operator=(std::move(other));
-	return * this;
-}
-
-// Call the parent move ctor and also transfer own member.
-StorageAccessor::StorageAccessor(StorageAccessor&& other):
-		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
-}
-
-ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large "
-				"enough" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(dataPointer, dataPointer + size_, pointer);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-uint8_t* StorageAccessor::data() {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-	}
-	return dataPointer;
-}
-
-ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
-		uint16_t offset) {
-	if(internalState == AccessState::UNINIT) {
-		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(offset + size > size_) {
-		sif::error << "StorageAccessor: Data too large for pool "
-				"entry!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	std::copy(data, data + size, dataPointer + offset);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void StorageAccessor::assignConstPointer() {
-	constDataPointer = dataPointer;
-}
-
-
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+StorageAccessor::StorageAccessor(store_address_t storeId):
+		ConstStorageAccessor(storeId) {
+}
+
+StorageAccessor::StorageAccessor(store_address_t storeId,
+		StorageManagerIF* store):
+		ConstStorageAccessor(storeId, store) {
+}
+
+StorageAccessor& StorageAccessor::operator =(
+		StorageAccessor&& other) {
+	// Call the parent move assignment and also assign own member.
+	dataPointer = other.dataPointer;
+	StorageAccessor::operator=(std::move(other));
+	return * this;
+}
+
+// Call the parent move ctor and also transfer own member.
+StorageAccessor::StorageAccessor(StorageAccessor&& other):
+		ConstStorageAccessor(std::move(other)), dataPointer(other.dataPointer) {
+}
+
+ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(size_ > maxSize) {
+		sif::error << "StorageAccessor: Supplied buffer not large "
+				"enough" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(dataPointer, dataPointer + size_, pointer);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint8_t* StorageAccessor::data() {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+	}
+	return dataPointer;
+}
+
+ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
+		uint16_t offset) {
+	if(internalState == AccessState::UNINIT) {
+		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	if(offset + size > size_) {
+		sif::error << "StorageAccessor: Data too large for pool "
+				"entry!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	std::copy(data, data + size, dataPointer + offset);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void StorageAccessor::assignConstPointer() {
+	constDataPointer = dataPointer;
+}
+
+
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 1ca5f7dd..a65427b8 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,45 +1,45 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-
-#include "../storagemanager/ConstStorageAccessor.h"
-
-class StorageManagerIF;
-
-/**
- * @brief   Child class for modifyable data. Also has a normal pointer member.
- */
-class StorageAccessor: public ConstStorageAccessor {
-	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
-	friend class LocalPool;
-public:
-	StorageAccessor(store_address_t storeId);
-	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
-
-	/**
-	 * @brief	Move ctor and move assignment allow returning accessors as
-	 * 			a returnvalue. They prevent resource being freed prematurely.
-	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
-	 * 		move-constructors-and-move-assignment-operators-cpp.md
-	 * @param
-	 * @return
-	 */
-	StorageAccessor& operator=(StorageAccessor&&);
-	StorageAccessor(StorageAccessor&&);
-
-	ReturnValue_t write(uint8_t *data, size_t size,
-		uint16_t offset = 0);
-	uint8_t* data();
-	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
-
-private:
-	//! Non-const pointer for modifyable data.
-	uint8_t* dataPointer = nullptr;
-	//! For modifyable data, the const pointer is assigned to the normal
-	//! pointer by the pool manager so both access functions can be used safely
-	void assignConstPointer();
-};
-
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+
+#include "../storagemanager/ConstStorageAccessor.h"
+
+class StorageManagerIF;
+
+/**
+ * @brief   Child class for modifyable data. Also has a normal pointer member.
+ */
+class StorageAccessor: public ConstStorageAccessor {
+	//! StorageManager classes have exclusive access to private variables.
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class PoolManager;
+	template<uint8_t NUMBER_OF_POOLS>
+	friend class LocalPool;
+public:
+	StorageAccessor(store_address_t storeId);
+	StorageAccessor(store_address_t storeId, StorageManagerIF* store);
+
+	/**
+	 * @brief	Move ctor and move assignment allow returning accessors as
+	 * 			a returnvalue. They prevent resource being freed prematurely.
+	 * See: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
+	 * 		move-constructors-and-move-assignment-operators-cpp.md
+	 * @param
+	 * @return
+	 */
+	StorageAccessor& operator=(StorageAccessor&&);
+	StorageAccessor(StorageAccessor&&);
+
+	ReturnValue_t write(uint8_t *data, size_t size,
+		uint16_t offset = 0);
+	uint8_t* data();
+	ReturnValue_t getDataCopy(uint8_t *pointer, size_t maxSize) override;
+
+private:
+	//! Non-const pointer for modifyable data.
+	uint8_t* dataPointer = nullptr;
+	//! For modifyable data, the const pointer is assigned to the normal
+	//! pointer by the pool manager so both access functions can be used safely
+	void assignConstPointer();
+};
+
+#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 85341f2e..2229cdf8 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,167 +1,167 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
-
-#include "../events/Event.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/storeAddress.h"
-#include <utility>
-#include <cstddef>
-
-using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
-using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
-
-/**
- * @brief	This class provides an interface for intermediate data storage.
- * @details	The Storage manager classes shall be used to store larger chunks of
- * 			data in RAM for exchange between tasks. This interface expects the
- * 			data to be stored in one consecutive block of memory, so tasks can
- * 			write directly to the destination pointer.
- * 			For interprocess communication, the stores must be locked during
- * 			insertion and deletion. If the receiving storage identifier is
- * 			passed token-like between tasks, a lock during read and write
- * 			operations is not necessary.
- * @author	Bastian Baetz
- * @date	18.09.2012
- */
-class StorageManagerIF : public HasReturnvaluesIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
-	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
-	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
-	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
-	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
-	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
-	/**
-	 * @brief This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~StorageManagerIF() {
-	}
-	;
-	/**
-	 * @brief	With addData, a free storage position is allocated and data
-	 * 			stored there.
-	 * @details	During the allocation, the StorageManager is blocked.
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param data	The data to be stored in the StorageManager.
-	 * @param size	The amount of data to be stored.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t addData(store_address_t* storageId,
-			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
-	/**
-	 * @brief	With deleteData, the storageManager frees the memory region
-	 * 			identified by packet_id.
-	 * @param packet_id	The identifier of the memory region to be freed.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if deletion did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
-	/**
-	 * @brief	Another deleteData which uses the pointer and size of the
-	 * 			stored data to delete the content.
-	 * @param buffer	Pointer to the data.
-	 * @param size		Size of data to be stored.
-	 * @param storeId	Store id of the deleted element (optional)
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	failure code if deletion did not work
-	 */
-	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
-			store_address_t* storeId = nullptr) = 0;
-
-
-	/**
-	 * @brief 	Access the data by supplying a store ID.
-	 * @details
-	 * A pair consisting of the retrieval result and an instance of a
-	 * ConstStorageAccessor class is returned
-	 * @param storeId
-	 * @return Pair of return value and a ConstStorageAccessor instance
-	 */
-	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
-
-	/**
-	 * @brief 	Access the data by supplying a store ID and a helper
-	 * 			instance
-	 * @param storeId
-	 * @param constAccessor Wrapper function to access store data.
-	 * @return
-	 */
-	virtual ReturnValue_t getData(store_address_t storeId,
-			ConstStorageAccessor& constAccessor) = 0;
-
-
-	/**
-	 * @brief	getData returns an address to data and the size of the data
-	 * 			for a given packet_id.
-	 * @param packet_id		The id of the data to be returned
-	 * @param packet_ptr	The passed pointer address is set to the the memory
-	 * 						position
-	 * @param size			The exact size of the stored data is returned here.
-	 * @return	@li RETURN_OK on success.
-	 * 			@li	RETURN_FAILED if fetching data did not work
-	 * 				(e.g. an illegal packet_id was passed).
-	 */
-	virtual ReturnValue_t getData(store_address_t packet_id,
-			const uint8_t** packet_ptr, size_t* size) = 0;
-
-
-	/**
-	 * Modify data by supplying a store ID
-	 * @param storeId
-	 * @return Pair of return value and StorageAccessor helper
-	 */
-	virtual AccessorPair modifyData(store_address_t storeId) = 0;
-
-	/**
-	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
-	 * @param storeId
-	 * @param accessor Helper class to access the modifiable data.
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t storeId,
-				StorageAccessor& accessor) = 0;
-
-	/**
-	 * Get pointer and size of modifiable data by supplying the storeId
-	 * @param packet_id
-	 * @param packet_ptr [out] Pointer to pointer of data to set
-	 * @param size [out] Pointer to size to set
-	 * @return
-	 */
-	virtual ReturnValue_t modifyData(store_address_t packet_id,
-			uint8_t** packet_ptr, size_t* size) = 0;
-	/**
-	 * This method reserves an element of \c size.
-	 *
-	 * It returns the packet id of this element as well as a direct pointer to the
-	 * data of the element. It must be assured that exactly \c size data is
-	 * written to p_data!
-	 * @param storageId A pointer to the storageId to retrieve.
-	 * @param size		The size of the space to be reserved.
-	 * @param p_data	A pointer to the element data is returned here.
-	 * @return	Returns @li RETURN_OK if data was added.
-	 * 					@li	RETURN_FAILED if data could not be added.
-	 * 						storageId is unchanged then.
-	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
-			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
-
-	/**
-	 * Clears the whole store.
-	 * Use with care!
-	 */
-	virtual void clearStore() = 0;
-};
-
-#endif /* STORAGEMANAGERIF_H_ */
+#ifndef STORAGEMANAGERIF_H_H
+#define STORAGEMANAGERIF_H_H
+
+#include "../events/Event.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageAccessor.h"
+#include "../storagemanager/storeAddress.h"
+#include <utility>
+#include <cstddef>
+
+using AccessorPair = std::pair<ReturnValue_t, StorageAccessor>;
+using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
+
+/**
+ * @brief	This class provides an interface for intermediate data storage.
+ * @details	The Storage manager classes shall be used to store larger chunks of
+ * 			data in RAM for exchange between tasks. This interface expects the
+ * 			data to be stored in one consecutive block of memory, so tasks can
+ * 			write directly to the destination pointer.
+ * 			For interprocess communication, the stores must be locked during
+ * 			insertion and deletion. If the receiving storage identifier is
+ * 			passed token-like between tasks, a lock during read and write
+ * 			operations is not necessary.
+ * @author	Bastian Baetz
+ * @date	18.09.2012
+ */
+class StorageManagerIF : public HasReturnvaluesIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
+	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
+	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
+	static const ReturnValue_t ILLEGAL_STORAGE_ID = MAKE_RETURN_CODE(3); //!< This return code indicates that data was requested with an illegal storage ID.
+	static const ReturnValue_t DATA_DOES_NOT_EXIST = MAKE_RETURN_CODE(4); //!< This return code indicates that the requested ID was valid, but no data is stored there.
+	static const ReturnValue_t ILLEGAL_ADDRESS = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	/**
+	 * @brief This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~StorageManagerIF() {
+	}
+	;
+	/**
+	 * @brief	With addData, a free storage position is allocated and data
+	 * 			stored there.
+	 * @details	During the allocation, the StorageManager is blocked.
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param data	The data to be stored in the StorageManager.
+	 * @param size	The amount of data to be stored.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t addData(store_address_t* storageId,
+			const uint8_t * data, size_t size, bool ignoreFault = false) = 0;
+	/**
+	 * @brief	With deleteData, the storageManager frees the memory region
+	 * 			identified by packet_id.
+	 * @param packet_id	The identifier of the memory region to be freed.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if deletion did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t deleteData(store_address_t packet_id) = 0;
+	/**
+	 * @brief	Another deleteData which uses the pointer and size of the
+	 * 			stored data to delete the content.
+	 * @param buffer	Pointer to the data.
+	 * @param size		Size of data to be stored.
+	 * @param storeId	Store id of the deleted element (optional)
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	failure code if deletion did not work
+	 */
+	virtual ReturnValue_t deleteData(uint8_t* buffer, size_t size,
+			store_address_t* storeId = nullptr) = 0;
+
+
+	/**
+	 * @brief 	Access the data by supplying a store ID.
+	 * @details
+	 * A pair consisting of the retrieval result and an instance of a
+	 * ConstStorageAccessor class is returned
+	 * @param storeId
+	 * @return Pair of return value and a ConstStorageAccessor instance
+	 */
+	virtual ConstAccessorPair getData(store_address_t storeId) = 0;
+
+	/**
+	 * @brief 	Access the data by supplying a store ID and a helper
+	 * 			instance
+	 * @param storeId
+	 * @param constAccessor Wrapper function to access store data.
+	 * @return
+	 */
+	virtual ReturnValue_t getData(store_address_t storeId,
+			ConstStorageAccessor& constAccessor) = 0;
+
+
+	/**
+	 * @brief	getData returns an address to data and the size of the data
+	 * 			for a given packet_id.
+	 * @param packet_id		The id of the data to be returned
+	 * @param packet_ptr	The passed pointer address is set to the the memory
+	 * 						position
+	 * @param size			The exact size of the stored data is returned here.
+	 * @return	@li RETURN_OK on success.
+	 * 			@li	RETURN_FAILED if fetching data did not work
+	 * 				(e.g. an illegal packet_id was passed).
+	 */
+	virtual ReturnValue_t getData(store_address_t packet_id,
+			const uint8_t** packet_ptr, size_t* size) = 0;
+
+
+	/**
+	 * Modify data by supplying a store ID
+	 * @param storeId
+	 * @return Pair of return value and StorageAccessor helper
+	 */
+	virtual AccessorPair modifyData(store_address_t storeId) = 0;
+
+	/**
+	 * Modify data by supplying a store ID and a StorageAccessor helper instance.
+	 * @param storeId
+	 * @param accessor Helper class to access the modifiable data.
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t storeId,
+				StorageAccessor& accessor) = 0;
+
+	/**
+	 * Get pointer and size of modifiable data by supplying the storeId
+	 * @param packet_id
+	 * @param packet_ptr [out] Pointer to pointer of data to set
+	 * @param size [out] Pointer to size to set
+	 * @return
+	 */
+	virtual ReturnValue_t modifyData(store_address_t packet_id,
+			uint8_t** packet_ptr, size_t* size) = 0;
+	/**
+	 * This method reserves an element of \c size.
+	 *
+	 * It returns the packet id of this element as well as a direct pointer to the
+	 * data of the element. It must be assured that exactly \c size data is
+	 * written to p_data!
+	 * @param storageId A pointer to the storageId to retrieve.
+	 * @param size		The size of the space to be reserved.
+	 * @param p_data	A pointer to the element data is returned here.
+	 * @return	Returns @li RETURN_OK if data was added.
+	 * 					@li	RETURN_FAILED if data could not be added.
+	 * 						storageId is unchanged then.
+	 */
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const size_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+
+	/**
+	 * Clears the whole store.
+	 * Use with care!
+	 */
+	virtual void clearStore() = 0;
+};
+
+#endif /* STORAGEMANAGERIF_H_ */
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index de4761fa..2b501574 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,164 +1,164 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
-
-#include "../container/FixedArrayList.h"
-#include "../container/FixedMap.h"
-#include "../container/HybridIterator.h"
-#include "../container/SinglyLinkedList.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include "../subsystem/modes/ModeDefinitions.h"
-#include "../subsystem/SubsystemBase.h"
-
-class Subsystem: public SubsystemBase, public HasModeSequenceIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
-	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x06);
-	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
-			MAKE_RETURN_CODE(0x07);
-	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
-	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
-	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
-	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
-	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
-
-	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
-	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
-
-
-
-	Subsystem(object_id_t setObjectId, object_id_t parent,
-			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
-	virtual ~Subsystem();
-
-	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
-			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
-
-	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
-			bool inStore = true, bool preInit = true);
-
-	void setInitialMode(Mode_t mode);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t checkObjectConnections();
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
-protected:
-
-	struct EntryPointer {
-		bool islinked;
-		union {
-			ModeListEntry *firstLinkedElement;
-			ArrayList<ModeListEntry> *array;
-		};
-	};
-
-	struct SequenceInfo {
-		Mode_t fallbackSequence;
-		EntryPointer entries;
-	};
-
-	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
-
-	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
-
-	bool isInTransition;
-
-	bool childrenChangedHealth;
-
-	uint32_t uptimeStartTable = 0;
-
-	HybridIterator<ModeListEntry> currentTargetTable;
-
-	Mode_t targetMode;
-
-	Submode_t targetSubmode;
-
-	Mode_t initialMode;
-
-	HybridIterator<ModeListEntry> currentSequenceIterator;
-
-	FixedMap<Mode_t, EntryPointer> modeTables;
-
-	FixedMap<Mode_t, SequenceInfo> modeSequences;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-#ifdef USE_MODESTORE
-	ModeStoreIF *modeStore = nullptr;
-#endif
-
-	bool existsModeSequence(Mode_t id);
-
-	HybridIterator<ModeListEntry> getSequence(Mode_t id);
-
-	bool existsModeTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getTable(Mode_t id);
-
-	HybridIterator<ModeListEntry> getCurrentTable();
-
-//	void startSequence(Mode_t sequence);
-
-	/**
-	 * DO NOT USE ON NON EXISTING SEQUENCE
-	 *
-	 * @param a sequence
-	 * @return the fallback sequence's Id
-	 */
-	Mode_t getFallbackSequence(Mode_t sequence);
-
-	void replyToCommand(ReturnValue_t status, uint32_t parameter);
-
-	ReturnValue_t deleteSequence(Mode_t id);
-
-	ReturnValue_t deleteTable(Mode_t id);
-
-	virtual void performChildOperation();
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
-
-	bool isFallbackSequence(Mode_t SequenceId);
-
-	bool isTableUsed(Mode_t tableId);
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode);
-
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
-
-	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
-
-	void cantKeepMode();
-
-};
-
-#endif /* SUBSYSTEM_H_ */
+#ifndef SUBSYSTEM_H_
+#define SUBSYSTEM_H_
+
+#include "../container/FixedArrayList.h"
+#include "../container/FixedMap.h"
+#include "../container/HybridIterator.h"
+#include "../container/SinglyLinkedList.h"
+#include "../serialize/SerialArrayListAdapter.h"
+#include "../subsystem/modes/ModeDefinitions.h"
+#include "../subsystem/SubsystemBase.h"
+
+class Subsystem: public SubsystemBase, public HasModeSequenceIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
+	static const ReturnValue_t SEQUENCE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t TABLE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TABLE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t TABLE_OR_SEQUENCE_LENGTH_INVALID = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t SEQUENCE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x05);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x06);
+	static const ReturnValue_t FALLBACK_SEQUENCE_DOES_NOT_EXIST =
+			MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t NO_TARGET_TABLE = MAKE_RETURN_CODE(0x08);
+	static const ReturnValue_t SEQUENCE_OR_TABLE_TOO_LONG = MAKE_RETURN_CODE(0x09);
+	static const ReturnValue_t IS_FALLBACK_SEQUENCE = MAKE_RETURN_CODE(0x0B);
+	static const ReturnValue_t ACCESS_DENIED = MAKE_RETURN_CODE(0x0C);
+	static const ReturnValue_t TABLE_IN_USE = MAKE_RETURN_CODE(0x0E);
+
+	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
+	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
+
+
+
+	Subsystem(object_id_t setObjectId, object_id_t parent,
+			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+	virtual ~Subsystem();
+
+	ReturnValue_t addSequence(ArrayList<ModeListEntry>* sequence, Mode_t id,
+			Mode_t fallbackSequence, bool inStore = true, bool preInit = true);
+
+	ReturnValue_t addTable(ArrayList<ModeListEntry> *table, Mode_t id,
+			bool inStore = true, bool preInit = true);
+
+	void setInitialMode(Mode_t mode);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t checkObjectConnections();
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const;
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 *
+	 *
+	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
+	 *
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+protected:
+
+	struct EntryPointer {
+		bool islinked;
+		union {
+			ModeListEntry *firstLinkedElement;
+			ArrayList<ModeListEntry> *array;
+		};
+	};
+
+	struct SequenceInfo {
+		Mode_t fallbackSequence;
+		EntryPointer entries;
+	};
+
+	static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
+
+	static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
+
+	bool isInTransition;
+
+	bool childrenChangedHealth;
+
+	uint32_t uptimeStartTable = 0;
+
+	HybridIterator<ModeListEntry> currentTargetTable;
+
+	Mode_t targetMode;
+
+	Submode_t targetSubmode;
+
+	Mode_t initialMode;
+
+	HybridIterator<ModeListEntry> currentSequenceIterator;
+
+	FixedMap<Mode_t, EntryPointer> modeTables;
+
+	FixedMap<Mode_t, SequenceInfo> modeSequences;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+#ifdef USE_MODESTORE
+	ModeStoreIF *modeStore = nullptr;
+#endif
+
+	bool existsModeSequence(Mode_t id);
+
+	HybridIterator<ModeListEntry> getSequence(Mode_t id);
+
+	bool existsModeTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getTable(Mode_t id);
+
+	HybridIterator<ModeListEntry> getCurrentTable();
+
+//	void startSequence(Mode_t sequence);
+
+	/**
+	 * DO NOT USE ON NON EXISTING SEQUENCE
+	 *
+	 * @param a sequence
+	 * @return the fallback sequence's Id
+	 */
+	Mode_t getFallbackSequence(Mode_t sequence);
+
+	void replyToCommand(ReturnValue_t status, uint32_t parameter);
+
+	ReturnValue_t deleteSequence(Mode_t id);
+
+	ReturnValue_t deleteTable(Mode_t id);
+
+	virtual void performChildOperation();
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message);
+
+	bool isFallbackSequence(Mode_t SequenceId);
+
+	bool isTableUsed(Mode_t tableId);
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode);
+
+	virtual void startTransition(Mode_t mode, Submode_t submode);
+
+	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+
+	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
+
+	void cantKeepMode();
+
+};
+
+#endif /* SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 2bd6c1ad..17599808 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -1,356 +1,356 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../subsystem/SubsystemBase.h"
-#include "../ipc/QueueFactory.h"
-
-SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
-		Mode_t initialMode, uint16_t commandQueueDepth) :
-		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
-		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
-}
-
-SubsystemBase::~SubsystemBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-
-}
-
-ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
-	ChildInfo info;
-
-	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
-	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
-	if (child == nullptr) {
-		if (healthChild == nullptr) {
-			return CHILD_DOESNT_HAVE_MODES;
-		} else {
-			info.commandQueue = healthChild->getCommandQueue();
-			info.mode = MODE_OFF;
-		}
-	} else {
-		info.commandQueue = child->getCommandQueue();
-		info.mode = -1;	//intentional to force an initial command during system startup
-	}
-
-	info.submode = SUBMODE_NONE;
-	info.healthChanged = false;
-
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
-		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkStateAgainstTable(
-		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
-
-	std::map<object_id_t, ChildInfo>::iterator childIter;
-
-	for (; tableIter.value != NULL; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-
-		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
-			return RETURN_FAILED;
-		}
-
-		if (childIter->second.mode != tableIter.value->getMode()) {
-			return RETURN_FAILED;
-		}
-
-		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCheckAgainst = targetSubmode;
-		}
-
-		if (childIter->second.submode != submodeToCheckAgainst) {
-			return RETURN_FAILED;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
-        Submode_t targetSubmode) {
-	CommandMessage command;
-
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	commandsOutstanding = 0;
-
-	for (; tableIter.value != nullptr; ++tableIter) {
-		object_id_t object = tableIter.value->getObject();
-		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
-			//illegal table entry, should only happen due to misconfigured mode table
-			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
-					<< std::endl;
-			continue;
-		}
-
-		Submode_t submodeToCommand = tableIter.value->getSubmode();
-		if (tableIter.value->inheritSubmode()) {
-			submodeToCommand = targetSubmode;
-		}
-
-		if (healthHelper.healthTable->hasHealth(object)) {
-			if (healthHelper.healthTable->isFaulty(object)) {
-				ModeMessage::setModeMessage(&command,
-						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
-						SUBMODE_NONE);
-			} else {
-				if (modeHelper.isForced()) {
-					ModeMessage::setModeMessage(&command,
-							ModeMessage::CMD_MODE_COMMAND_FORCED,
-							tableIter.value->getMode(), submodeToCommand);
-				} else {
-					if (healthHelper.healthTable->isCommandable(object)) {
-						ModeMessage::setModeMessage(&command,
-								ModeMessage::CMD_MODE_COMMAND,
-								tableIter.value->getMode(), submodeToCommand);
-					} else {
-						continue;
-					}
-				}
-			}
-		} else {
-			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
-					tableIter.value->getMode(), submodeToCommand);
-		}
-
-		if ((iter->second.mode == ModeMessage::getMode(&command))
-				&& (iter->second.submode == ModeMessage::getSubmode(&command))
-				&& !modeHelper.isForced()) {
-			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
-		}
-		ReturnValue_t result = commandQueue->sendMessage(
-				iter->second.commandQueue, &command);
-		if (result == RETURN_OK) {
-			++commandsOutstanding;
-		}
-	}
-
-}
-
-ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
-		Mode_t mode, Submode_t submode) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.mode = mode;
-			iter->second.submode = submode;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
-bool changedHealth) {
-	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
-		if (iter->second.commandQueue == queue) {
-			iter->second.healthChanged = changedHealth;
-			return RETURN_OK;
-		}
-	}
-	return CHILD_NOT_FOUND;
-}
-
-MessageQueueId_t SubsystemBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t SubsystemBase::initialize() {
-	MessageQueueId_t parentQueue = 0;
-	ReturnValue_t result = SystemObject::initialize();
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	if (parentId != 0) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
-
-	childrenChangedMode = false;
-
-	checkCommandQueue();
-
-	performChildOperation();
-
-	return RETURN_OK;
-}
-
-ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
-	switch (message->getCommand()) {
-	case ModeMessage::REPLY_MODE_INFO:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		return RETURN_OK;
-	case ModeMessage::REPLY_MODE_REPLY:
-	case ModeMessage::REPLY_WRONG_MODE_REPLY:
-		updateChildMode(message->getSender(), ModeMessage::getMode(message),
-				ModeMessage::getSubmode(message));
-		childrenChangedMode = true;
-		commandsOutstanding--;
-		return RETURN_OK;
-	case ModeMessage::REPLY_CANT_REACH_MODE:
-		commandsOutstanding--;
-		{
-			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
-					iter++) {
-				if (iter->second.commandQueue == message->getSender()) {
-					triggerEvent(MODE_CMD_REJECTED, iter->first,
-							message->getParameter());
-				}
-			}
-		}
-		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_COMMAND:
-//		handleCommandedMode(message);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		return RETURN_OK;
-//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
-//		triggerEvent(MODE_INFO, mode, submode);
-//		commandAllChildren(message);
-//		return RETURN_OK;
-	default:
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SubsystemBase::checkTable(
-		HybridIterator<ModeListEntry> tableIter) {
-	for (; tableIter.value != NULL; ++tableIter) {
-		if (childrenMap.find(tableIter.value->getObject())
-				== childrenMap.end()) {
-			return TABLE_CONTAINS_INVALID_OBJECT_ID;
-		}
-	}
-	return RETURN_OK;
-}
-
-void SubsystemBase::replyToCommand(CommandMessage* message) {
-	commandQueue->reply(message);
-}
-
-void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
-	modeHelper.modeChanged(newMode, newSubmode);
-	mode = newMode;
-	submode = newSubmode;
-	modeChanged();
-	announceMode(false);
-}
-
-void SubsystemBase::setMode(Mode_t newMode) {
-	setMode(newMode, submode);
-}
-
-void SubsystemBase::commandAllChildren(CommandMessage* message) {
-	std::map<object_id_t, ChildInfo>::iterator iter;
-	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
-		commandQueue->sendMessage(iter->second.commandQueue, message);
-	}
-}
-
-void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void SubsystemBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void SubsystemBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-	if (recursive) {
-		CommandMessage command;
-		ModeMessage::setModeMessage(&command,
-				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
-		commandAllChildren(&command);
-	}
-}
-
-void SubsystemBase::checkCommandQueue() {
-	ReturnValue_t result;
-	CommandMessage command;
-
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleModeReply(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = handleCommandMessage(&command);
-		if (result != RETURN_OK) {
-			CommandMessage reply;
-			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
-					command.getCommand());
-			replyToCommand(&reply);
-		}
-	}
-}
-
-ReturnValue_t SubsystemBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState SubsystemBase::getHealth() {
-	return healthHelper.getHealth();
-}
-
-void SubsystemBase::modeChanged() {
-}
-
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
+#include "../ipc/QueueFactory.h"
+
+SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
+		Mode_t initialMode, uint16_t commandQueueDepth) :
+		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
+		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+			MessageQueueMessage::MAX_MESSAGE_SIZE);
+}
+
+SubsystemBase::~SubsystemBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+
+}
+
+ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
+	ChildInfo info;
+
+	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
+	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
+	if (child == nullptr) {
+		if (healthChild == nullptr) {
+			return CHILD_DOESNT_HAVE_MODES;
+		} else {
+			info.commandQueue = healthChild->getCommandQueue();
+			info.mode = MODE_OFF;
+		}
+	} else {
+		info.commandQueue = child->getCommandQueue();
+		info.mode = -1;	//intentional to force an initial command during system startup
+	}
+
+	info.submode = SUBMODE_NONE;
+	info.healthChanged = false;
+
+	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
+			childrenMap.insert(
+					std::pair<object_id_t, ChildInfo>(objectId, info));
+	if (!(returnValue.second)) {
+		return COULD_NOT_INSERT_CHILD;
+	} else {
+		return RETURN_OK;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkStateAgainstTable(
+		HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode) {
+
+	std::map<object_id_t, ChildInfo>::iterator childIter;
+
+	for (; tableIter.value != NULL; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+
+		if ((childIter = childrenMap.find(object)) == childrenMap.end()) {
+			return RETURN_FAILED;
+		}
+
+		if (childIter->second.mode != tableIter.value->getMode()) {
+			return RETURN_FAILED;
+		}
+
+		Submode_t submodeToCheckAgainst = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCheckAgainst = targetSubmode;
+		}
+
+		if (childIter->second.submode != submodeToCheckAgainst) {
+			return RETURN_FAILED;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
+        Submode_t targetSubmode) {
+	CommandMessage command;
+
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	commandsOutstanding = 0;
+
+	for (; tableIter.value != nullptr; ++tableIter) {
+		object_id_t object = tableIter.value->getObject();
+		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
+			//illegal table entry, should only happen due to misconfigured mode table
+			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
+					<< std::endl;
+			continue;
+		}
+
+		Submode_t submodeToCommand = tableIter.value->getSubmode();
+		if (tableIter.value->inheritSubmode()) {
+			submodeToCommand = targetSubmode;
+		}
+
+		if (healthHelper.healthTable->hasHealth(object)) {
+			if (healthHelper.healthTable->isFaulty(object)) {
+				ModeMessage::setModeMessage(&command,
+						ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
+						SUBMODE_NONE);
+			} else {
+				if (modeHelper.isForced()) {
+					ModeMessage::setModeMessage(&command,
+							ModeMessage::CMD_MODE_COMMAND_FORCED,
+							tableIter.value->getMode(), submodeToCommand);
+				} else {
+					if (healthHelper.healthTable->isCommandable(object)) {
+						ModeMessage::setModeMessage(&command,
+								ModeMessage::CMD_MODE_COMMAND,
+								tableIter.value->getMode(), submodeToCommand);
+					} else {
+						continue;
+					}
+				}
+			}
+		} else {
+			ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
+					tableIter.value->getMode(), submodeToCommand);
+		}
+
+		if ((iter->second.mode == ModeMessage::getMode(&command))
+				&& (iter->second.submode == ModeMessage::getSubmode(&command))
+				&& !modeHelper.isForced()) {
+			continue; //don't send redundant mode commands (produces event spam), but still command if mode is forced to reach lower levels
+		}
+		ReturnValue_t result = commandQueue->sendMessage(
+				iter->second.commandQueue, &command);
+		if (result == RETURN_OK) {
+			++commandsOutstanding;
+		}
+	}
+
+}
+
+ReturnValue_t SubsystemBase::updateChildMode(MessageQueueId_t queue,
+		Mode_t mode, Submode_t submode) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.mode = mode;
+			iter->second.submode = submode;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+ReturnValue_t SubsystemBase::updateChildChangedHealth(MessageQueueId_t queue,
+bool changedHealth) {
+	for (auto iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
+		if (iter->second.commandQueue == queue) {
+			iter->second.healthChanged = changedHealth;
+			return RETURN_OK;
+		}
+	}
+	return CHILD_NOT_FOUND;
+}
+
+MessageQueueId_t SubsystemBase::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t SubsystemBase::initialize() {
+	MessageQueueId_t parentQueue = 0;
+	ReturnValue_t result = SystemObject::initialize();
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	if (parentId != 0) {
+		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		if (parent == NULL) {
+			return RETURN_FAILED;
+		}
+		parentQueue = parent->getCommandQueue();
+
+		parent->registerChild(getObjectId());
+	}
+
+	result = healthHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	result = modeHelper.initialize(parentQueue);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::performOperation(uint8_t opCode) {
+
+	childrenChangedMode = false;
+
+	checkCommandQueue();
+
+	performChildOperation();
+
+	return RETURN_OK;
+}
+
+ReturnValue_t SubsystemBase::handleModeReply(CommandMessage* message) {
+	switch (message->getCommand()) {
+	case ModeMessage::REPLY_MODE_INFO:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		return RETURN_OK;
+	case ModeMessage::REPLY_MODE_REPLY:
+	case ModeMessage::REPLY_WRONG_MODE_REPLY:
+		updateChildMode(message->getSender(), ModeMessage::getMode(message),
+				ModeMessage::getSubmode(message));
+		childrenChangedMode = true;
+		commandsOutstanding--;
+		return RETURN_OK;
+	case ModeMessage::REPLY_CANT_REACH_MODE:
+		commandsOutstanding--;
+		{
+			for (auto iter = childrenMap.begin(); iter != childrenMap.end();
+					iter++) {
+				if (iter->second.commandQueue == message->getSender()) {
+					triggerEvent(MODE_CMD_REJECTED, iter->first,
+							message->getParameter());
+				}
+			}
+		}
+		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_COMMAND:
+//		handleCommandedMode(message);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		return RETURN_OK;
+//	case ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY:
+//		triggerEvent(MODE_INFO, mode, submode);
+//		commandAllChildren(message);
+//		return RETURN_OK;
+	default:
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t SubsystemBase::checkTable(
+		HybridIterator<ModeListEntry> tableIter) {
+	for (; tableIter.value != NULL; ++tableIter) {
+		if (childrenMap.find(tableIter.value->getObject())
+				== childrenMap.end()) {
+			return TABLE_CONTAINS_INVALID_OBJECT_ID;
+		}
+	}
+	return RETURN_OK;
+}
+
+void SubsystemBase::replyToCommand(CommandMessage* message) {
+	commandQueue->reply(message);
+}
+
+void SubsystemBase::setMode(Mode_t newMode, Submode_t newSubmode) {
+	modeHelper.modeChanged(newMode, newSubmode);
+	mode = newMode;
+	submode = newSubmode;
+	modeChanged();
+	announceMode(false);
+}
+
+void SubsystemBase::setMode(Mode_t newMode) {
+	setMode(newMode, submode);
+}
+
+void SubsystemBase::commandAllChildren(CommandMessage* message) {
+	std::map<object_id_t, ChildInfo>::iterator iter;
+	for (iter = childrenMap.begin(); iter != childrenMap.end(); ++iter) {
+		commandQueue->sendMessage(iter->second.commandQueue, message);
+	}
+}
+
+void SubsystemBase::getMode(Mode_t* mode, Submode_t* submode) {
+	*mode = this->mode;
+	*submode = this->submode;
+}
+
+void SubsystemBase::setToExternalControl() {
+	healthHelper.setHealth(EXTERNAL_CONTROL);
+}
+
+void SubsystemBase::announceMode(bool recursive) {
+	triggerEvent(MODE_INFO, mode, submode);
+	if (recursive) {
+		CommandMessage command;
+		ModeMessage::setModeMessage(&command,
+				ModeMessage::CMD_MODE_ANNOUNCE_RECURSIVELY, 0, 0);
+		commandAllChildren(&command);
+	}
+}
+
+void SubsystemBase::checkCommandQueue() {
+	ReturnValue_t result;
+	CommandMessage command;
+
+	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&command)) {
+
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = modeHelper.handleModeCommand(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleModeReply(&command);
+		if (result == RETURN_OK) {
+			continue;
+		}
+
+		result = handleCommandMessage(&command);
+		if (result != RETURN_OK) {
+			CommandMessage reply;
+			reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND,
+					command.getCommand());
+			replyToCommand(&reply);
+		}
+	}
+}
+
+ReturnValue_t SubsystemBase::setHealth(HealthState health) {
+	switch (health) {
+	case HEALTHY:
+	case EXTERNAL_CONTROL:
+		healthHelper.setHealth(health);
+		return RETURN_OK;
+	default:
+		return INVALID_HEALTH_STATE;
+	}
+}
+
+HasHealthIF::HealthState SubsystemBase::getHealth() {
+	return healthHelper.getHealth();
+}
+
+void SubsystemBase::modeChanged() {
+}
+
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index c0abbe40..2d949b56 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,129 +1,129 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
-
-#include "../container/HybridIterator.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../modes/HasModesIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../subsystem/modes/HasModeSequenceIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include <map>
-
-/**
- * @defgroup subsystems Subsystem Objects
- * Contains all Subsystem and Assemblies
- */
-class SubsystemBase: public SystemObject,
-		public HasModesIF,
-		public HasHealthIF,
-		public HasReturnvaluesIF,
-		public ExecutableObjectIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
-	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
-			MAKE_RETURN_CODE(0x05);
-
-	SubsystemBase(object_id_t setObjectId, object_id_t parent,
-			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
-	virtual ~SubsystemBase();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t registerChild(object_id_t objectId);
-
-	virtual ReturnValue_t initialize();
-
-	virtual ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual ReturnValue_t setHealth(HealthState health);
-
-	virtual HasHealthIF::HealthState getHealth();
-
-protected:
-	struct ChildInfo {
-		MessageQueueId_t commandQueue;
-		Mode_t mode;
-		Submode_t submode;bool healthChanged;
-	};
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	bool childrenChangedMode;
-
-	/**
-	 * Always check this against <=0, so you are robust against too many replies
-	 */
-	int32_t commandsOutstanding;
-
-	MessageQueueIF* commandQueue;
-
-	HealthHelper healthHelper;
-
-	ModeHelper modeHelper;
-
-	const object_id_t parentId;
-
-	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
-	ChildrenMap childrenMap;
-
-	void checkCommandQueue();
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 */
-	ReturnValue_t checkStateAgainstTable(
-			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
-
-	/**
-	 * We need to know the target Submode, as children are able to inherit the submode
-	 * Still, we have a default for all child implementations which do not use submode inheritance
-	 */
-	void executeTable(HybridIterator<ModeListEntry> tableIter,
-			Submode_t targetSubmode = SUBMODE_NONE);
-
-	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
-			Submode_t submode);
-
-	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
-			bool changedHealth = true);
-
-	virtual ReturnValue_t handleModeReply(CommandMessage *message);
-
-	void commandAllChildren(CommandMessage *message);
-
-	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
-
-	void replyToCommand(CommandMessage *message);
-
-	void setMode(Mode_t newMode, Submode_t newSubmode);
-
-	void setMode(Mode_t newMode);
-
-	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-	virtual void performChildOperation() = 0;
-
-	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-			uint32_t *msToReachTheMode) = 0;
-
-	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
-
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-
-	virtual void setToExternalControl();
-
-	virtual void announceMode(bool recursive);
-
-	virtual void modeChanged();
-};
-
-#endif /* SUBSYSTEMBASE_H_ */
+#ifndef SUBSYSTEMBASE_H_
+#define SUBSYSTEMBASE_H_
+
+#include "../container/HybridIterator.h"
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../modes/HasModesIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../subsystem/modes/HasModeSequenceIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup subsystems Subsystem Objects
+ * Contains all Subsystem and Assemblies
+ */
+class SubsystemBase: public SystemObject,
+		public HasModesIF,
+		public HasHealthIF,
+		public HasReturnvaluesIF,
+		public ExecutableObjectIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM_BASE;
+	static const ReturnValue_t CHILD_NOT_FOUND = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t CHILD_INFO_UPDATED = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t CHILD_DOESNT_HAVE_MODES = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t COULD_NOT_INSERT_CHILD = MAKE_RETURN_CODE(0x04);
+	static const ReturnValue_t TABLE_CONTAINS_INVALID_OBJECT_ID =
+			MAKE_RETURN_CODE(0x05);
+
+	SubsystemBase(object_id_t setObjectId, object_id_t parent,
+			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
+	virtual ~SubsystemBase();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t registerChild(object_id_t objectId);
+
+	virtual ReturnValue_t initialize();
+
+	virtual ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual ReturnValue_t setHealth(HealthState health);
+
+	virtual HasHealthIF::HealthState getHealth();
+
+protected:
+	struct ChildInfo {
+		MessageQueueId_t commandQueue;
+		Mode_t mode;
+		Submode_t submode;bool healthChanged;
+	};
+
+	Mode_t mode;
+
+	Submode_t submode;
+
+	bool childrenChangedMode;
+
+	/**
+	 * Always check this against <=0, so you are robust against too many replies
+	 */
+	int32_t commandsOutstanding;
+
+	MessageQueueIF* commandQueue;
+
+	HealthHelper healthHelper;
+
+	ModeHelper modeHelper;
+
+	const object_id_t parentId;
+
+	typedef std::map<object_id_t, ChildInfo> ChildrenMap;
+	ChildrenMap childrenMap;
+
+	void checkCommandQueue();
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 */
+	ReturnValue_t checkStateAgainstTable(
+			HybridIterator<ModeListEntry> tableIter, Submode_t targetSubmode);
+
+	/**
+	 * We need to know the target Submode, as children are able to inherit the submode
+	 * Still, we have a default for all child implementations which do not use submode inheritance
+	 */
+	void executeTable(HybridIterator<ModeListEntry> tableIter,
+			Submode_t targetSubmode = SUBMODE_NONE);
+
+	ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode,
+			Submode_t submode);
+
+	ReturnValue_t updateChildChangedHealth(MessageQueueId_t queue,
+			bool changedHealth = true);
+
+	virtual ReturnValue_t handleModeReply(CommandMessage *message);
+
+	void commandAllChildren(CommandMessage *message);
+
+	ReturnValue_t checkTable(HybridIterator<ModeListEntry> tableIter);
+
+	void replyToCommand(CommandMessage *message);
+
+	void setMode(Mode_t newMode, Submode_t newSubmode);
+
+	void setMode(Mode_t newMode);
+
+	virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
+
+	virtual void performChildOperation() = 0;
+
+	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+			uint32_t *msToReachTheMode) = 0;
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
+
+	virtual void getMode(Mode_t *mode, Submode_t *submode);
+
+	virtual void setToExternalControl();
+
+	virtual void announceMode(bool recursive);
+
+	virtual void modeChanged();
+};
+
+#endif /* SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index 90007d80..06bde2aa 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,20 +1,20 @@
-#ifndef HASMODESEQUENCEIF_H_
-#define HASMODESEQUENCEIF_H_
-
-#include "../../subsystem/modes/ModeDefinitions.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
-
-
-class HasModeSequenceIF {
-public:
-	virtual ~HasModeSequenceIF() {
-
-	}
-
-	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
-
-};
-
-
-#endif /* HASMODESEQUENCEIF_H_ */
+#ifndef HASMODESEQUENCEIF_H_
+#define HASMODESEQUENCEIF_H_
+
+#include "../../subsystem/modes/ModeDefinitions.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+
+class HasModeSequenceIF {
+public:
+	virtual ~HasModeSequenceIF() {
+
+	}
+
+	virtual MessageQueueId_t getSequenceCommandQueue() const = 0;
+
+};
+
+
+#endif /* HASMODESEQUENCEIF_H_ */
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index 0514b357..a865ab0c 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,152 +1,152 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
-
-#include "../../modes/HasModesIF.h"
-#include "../../objectmanager/SystemObjectIF.h"
-#include "../../serialize/SerializeIF.h"
-#include "../../serialize/SerialLinkedListAdapter.h"
-class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
-public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
-
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-
-		ReturnValue_t result;
-
-		result = SerializeAdapter::serialize(&value1, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value2, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&value3, buffer, size,
-				maxSize, streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&value4, buffer, size,
-				maxSize, streamEndianness);
-
-		return result;
-
-	}
-
-	virtual size_t getSerializedSize() const {
-		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	Endianness streamEndianness) {
-		ReturnValue_t result;
-
-		result = SerializeAdapter::deSerialize(&value1, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value2, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value3, buffer, size,
-				streamEndianness);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&value4, buffer, size,
-				streamEndianness);
-
-		return result;
-	}
-
-	//for Sequences
-	Mode_t getTableId() const {
-		return value1;
-	}
-
-	void setTableId(Mode_t tableId) {
-		this->value1 = tableId;
-	}
-
-	uint8_t getWaitSeconds() const {
-		return value2;
-	}
-
-	void setWaitSeconds(uint8_t waitSeconds) {
-		this->value2 = waitSeconds;
-	}
-
-	bool checkSuccess() const {
-		return value3 == 1;
-	}
-
-	void setCheckSuccess(bool checkSuccess) {
-		this->value3 = checkSuccess;
-	}
-
-	//for Tables
-	object_id_t getObject() const {
-		return value1;
-	}
-
-	void setObject(object_id_t object) {
-		this->value1 = object;
-	}
-
-	Mode_t getMode() const {
-		return value2;
-	}
-
-	void setMode(Mode_t mode) {
-		this->value2 = mode;
-	}
-
-	Submode_t getSubmode() const {
-		return value3;
-	}
-
-	void setSubmode(Submode_t submode) {
-		this->value3 = submode;
-	}
-
-	bool inheritSubmode() const {
-		return value4 == 1;
-	}
-
-	void setInheritSubmode(bool inherit){
-		if (inherit){
-			value4 = 1;
-		} else {
-			value4 = 0;
-		}
-	}
-
-	bool operator==(ModeListEntry other) {
-		return ((value1 == other.value1) && (value2 == other.value2)
-				&& (value3 == other.value3));
-	}
-};
-
-#endif //MODEDEFINITIONS_H_
+#ifndef MODEDEFINITIONS_H_
+#define MODEDEFINITIONS_H_
+
+#include "../../modes/HasModesIF.h"
+#include "../../objectmanager/SystemObjectIF.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../serialize/SerialLinkedListAdapter.h"
+class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
+public:
+	ModeListEntry() :
+			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
+					0) {
+
+	}
+
+	uint32_t value1;
+	uint32_t value2;
+	uint8_t value3;
+	uint8_t value4;
+
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+
+		ReturnValue_t result;
+
+		result = SerializeAdapter::serialize(&value1, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value2, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::serialize(&value3, buffer, size,
+				maxSize, streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+
+		result = SerializeAdapter::serialize(&value4, buffer, size,
+				maxSize, streamEndianness);
+
+		return result;
+
+	}
+
+	virtual size_t getSerializedSize() const {
+		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
+	}
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	Endianness streamEndianness) {
+		ReturnValue_t result;
+
+		result = SerializeAdapter::deSerialize(&value1, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value2, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value3, buffer, size,
+				streamEndianness);
+
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&value4, buffer, size,
+				streamEndianness);
+
+		return result;
+	}
+
+	//for Sequences
+	Mode_t getTableId() const {
+		return value1;
+	}
+
+	void setTableId(Mode_t tableId) {
+		this->value1 = tableId;
+	}
+
+	uint8_t getWaitSeconds() const {
+		return value2;
+	}
+
+	void setWaitSeconds(uint8_t waitSeconds) {
+		this->value2 = waitSeconds;
+	}
+
+	bool checkSuccess() const {
+		return value3 == 1;
+	}
+
+	void setCheckSuccess(bool checkSuccess) {
+		this->value3 = checkSuccess;
+	}
+
+	//for Tables
+	object_id_t getObject() const {
+		return value1;
+	}
+
+	void setObject(object_id_t object) {
+		this->value1 = object;
+	}
+
+	Mode_t getMode() const {
+		return value2;
+	}
+
+	void setMode(Mode_t mode) {
+		this->value2 = mode;
+	}
+
+	Submode_t getSubmode() const {
+		return value3;
+	}
+
+	void setSubmode(Submode_t submode) {
+		this->value3 = submode;
+	}
+
+	bool inheritSubmode() const {
+		return value4 == 1;
+	}
+
+	void setInheritSubmode(bool inherit){
+		if (inherit){
+			value4 = 1;
+		} else {
+			value4 = 0;
+		}
+	}
+
+	bool operator==(ModeListEntry other) {
+		return ((value1 == other.value1) && (value2 == other.value2)
+				&& (value3 == other.value3));
+	}
+};
+
+#endif //MODEDEFINITIONS_H_
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index 3eb4ebe8..e092380e 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,89 +1,89 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, Mode_t sequence) {
-	message->setCommand(command);
-	message->setParameter2(sequence);
-}
-
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
-void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-		Command_t command, store_address_t storeAddress) {
-	message->setCommand(command);
-	message->setParameter(storeAddress.raw);
-}
-
-store_address_t ModeSequenceMessage::getStoreAddress(
-		const CommandMessage* message) {
-	store_address_t address;
-	address.raw = message->getParameter();
-	return address;
-}
-
-Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-
-uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
-	return message->getParameter2();
-}
-
-void ModeSequenceMessage::clear(CommandMessage *message) {
-	switch (message->getCommand()) {
-	case ADD_SEQUENCE:
-	case ADD_TABLE:
-	case SEQUENCE_LIST:
-	case TABLE_LIST:
-	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
-			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_SEQUENCE:
-	case DELETE_TABLE:
-	case READ_SEQUENCE:
-	case READ_TABLE:
-	case LIST_SEQUENCES:
-	case LIST_TABLES:
-	case READ_FREE_SEQUENCE_SLOTS:
-	case FREE_SEQUENCE_SLOTS:
-	case READ_FREE_TABLE_SLOTS:
-	case FREE_TABLE_SLOTS:
-	default:
-		message->setCommand(CommandMessage::CMD_NONE);
-		message->setParameter(0);
-		message->setParameter2(0);
-		break;
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeSequenceMessage.h"
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
+//	message->setCommand(command);
+//	message->setParameter(storeAddress.raw);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, Mode_t sequence) {
+	message->setCommand(command);
+	message->setParameter2(sequence);
+}
+
+//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+//		Command_t command, ModeTableId_t table) {
+//	message->setCommand(command);
+//	message->setParameter2(table);
+//}
+
+void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
+		Command_t command, store_address_t storeAddress) {
+	message->setCommand(command);
+	message->setParameter(storeAddress.raw);
+}
+
+store_address_t ModeSequenceMessage::getStoreAddress(
+		const CommandMessage* message) {
+	store_address_t address;
+	address.raw = message->getParameter();
+	return address;
+}
+
+Mode_t ModeSequenceMessage::getSequenceId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+Mode_t ModeSequenceMessage::getTableId(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+
+uint32_t ModeSequenceMessage::getNumber(const CommandMessage* message) {
+	return message->getParameter2();
+}
+
+void ModeSequenceMessage::clear(CommandMessage *message) {
+	switch (message->getCommand()) {
+	case ADD_SEQUENCE:
+	case ADD_TABLE:
+	case SEQUENCE_LIST:
+	case TABLE_LIST:
+	case TABLE:
+	case SEQUENCE:{
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		if (ipcStore != NULL){
+			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_SEQUENCE:
+	case DELETE_TABLE:
+	case READ_SEQUENCE:
+	case READ_TABLE:
+	case LIST_SEQUENCES:
+	case LIST_TABLES:
+	case READ_FREE_SEQUENCE_SLOTS:
+	case FREE_SEQUENCE_SLOTS:
+	case READ_FREE_TABLE_SLOTS:
+	case FREE_TABLE_SLOTS:
+	default:
+		message->setCommand(CommandMessage::CMD_NONE);
+		message->setParameter(0);
+		message->setParameter2(0);
+		break;
+	}
+}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index fcb5b2e7..61ba30f3 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,48 +1,48 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
-
-#include "../../ipc/CommandMessage.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
-
-class ModeSequenceMessage {
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
-
-	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
-	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
-	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
-	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
-	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
-	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
-	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
-	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
-	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
-	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
-	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
-	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
-	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
-	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
-	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
-	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
-
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable,
-			store_address_t storeAddress);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, Mode_t sequenceOrTable);
-	static void setModeSequenceMessage(CommandMessage *message,
-			Command_t command, store_address_t storeAddress);
-
-	static store_address_t getStoreAddress(const CommandMessage *message);
-	static Mode_t getSequenceId(const CommandMessage *message);
-	static Mode_t getTableId(const CommandMessage *message);
-	static uint32_t getNumber(const CommandMessage *message);
-
-	static void clear(CommandMessage *message);
-
-private:
-	ModeSequenceMessage();
-};
-
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#ifndef MODESEQUENCEMESSAGE_H_
+#define MODESEQUENCEMESSAGE_H_
+
+#include "../../ipc/CommandMessage.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeSequenceMessage {
+public:
+	static const uint8_t MESSAGE_ID = messagetypes::MODE_SEQUENCE;
+
+	static const Command_t ADD_SEQUENCE = MAKE_COMMAND_ID(0x01);
+	static const Command_t ADD_TABLE = MAKE_COMMAND_ID(0x02);
+	static const Command_t DELETE_SEQUENCE = MAKE_COMMAND_ID(0x03);
+	static const Command_t DELETE_TABLE = MAKE_COMMAND_ID(0x04);
+	static const Command_t READ_SEQUENCE = MAKE_COMMAND_ID(0x05);
+	static const Command_t READ_TABLE = MAKE_COMMAND_ID(0x06);
+	static const Command_t LIST_SEQUENCES = MAKE_COMMAND_ID(0x07);
+	static const Command_t LIST_TABLES = MAKE_COMMAND_ID(0x08);
+	static const Command_t SEQUENCE_LIST = MAKE_COMMAND_ID(0x09);
+	static const Command_t TABLE_LIST = MAKE_COMMAND_ID(0x0A);
+	static const Command_t TABLE = MAKE_COMMAND_ID(0x0B);
+	static const Command_t SEQUENCE = MAKE_COMMAND_ID(0x0C);
+	static const Command_t READ_FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0D);
+	static const Command_t FREE_SEQUENCE_SLOTS = MAKE_COMMAND_ID(0x0E);
+	static const Command_t READ_FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x0F);
+	static const Command_t FREE_TABLE_SLOTS = MAKE_COMMAND_ID(0x10);
+
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable,
+			store_address_t storeAddress);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, Mode_t sequenceOrTable);
+	static void setModeSequenceMessage(CommandMessage *message,
+			Command_t command, store_address_t storeAddress);
+
+	static store_address_t getStoreAddress(const CommandMessage *message);
+	static Mode_t getSequenceId(const CommandMessage *message);
+	static Mode_t getTableId(const CommandMessage *message);
+	static uint32_t getNumber(const CommandMessage *message);
+
+	static void clear(CommandMessage *message);
+
+private:
+	ModeSequenceMessage();
+};
+
+#endif /* MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 409a5f0f..dce2931c 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,126 +1,126 @@
-#include "../../subsystem/modes/ModeStore.h"
-
-#ifdef USE_MODESTORE
-
-ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
-		SystemObject(objectId), store(slots), emptySlot(store.front()) {
-	mutex = MutexFactory::instance()->createMutex();;
-	OSAL::createMutex(objectId + 1, mutex);
-	clear();
-}
-
-ModeStore::~ModeStore() {
-	delete mutex;
-}
-
-uint32_t ModeStore::getFreeSlots() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	uint32_t count = 0;
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		if (iter->getNext() == emptySlot) {
-			++count;
-		}
-	}
-	OSAL::unlockMutex(mutex);
-	return count;
-}
-
-ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
-		ModeListEntry** storedFirstEntry) {
-	if (sequence->size == 0) {
-		return CANT_STORE_EMPTY;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	*storedFirstEntry = findEmptySlotNoLock(store.front());
-
-	ModeListEntry* pointer =
-			*storedFirstEntry;
-	pointer->setNext(pointer);
-
-	ArrayList<ModeListEntry>::Iterator iter;
-	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
-		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
-		pointer = pointer->getNext()->value;
-		if (pointer == NULL) {
-			deleteListNoLock(*storedFirstEntry);
-			OSAL::unlockMutex(mutex);
-			return TOO_MANY_ELEMENTS;
-		}
-		pointer->value->value1 = iter->value1;
-		pointer->value->value2 = iter->value2;
-		pointer->value->value3 = iter->value3;
-		pointer->setNext(findEmptySlotNoLock(pointer + 1));
-	}
-	pointer->setNext(NULL);
-	OSAL::unlockMutex(mutex);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
-	ReturnValue_t result = isValidEntry(sequence);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-		deleteListNoLock(sequence);
-		OSAL::unlockMutex(mutex);
-		return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
-		ArrayList<ModeListEntry>* into) {
-	ReturnValue_t result = isValidEntry(sequence);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	result = into->insert(*sequence->value);
-	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
-		result = into->insert(*sequence->value);
-		sequence = sequence->getNext()->value;
-	}
-	OSAL::unlockMutex(mutex);
-	return result;
-}
-
-void ModeStore::clear() {
-	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
-	store.size = store.maxSize();
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
-	for (iter = store.begin(); iter != store.end(); ++iter) {
-		iter->setNext(emptySlot);
-	}
-	OSAL::unlockMutex(mutex);
-}
-
-ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
-	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
-			startFrom);
-	for (; iter != store.end(); ++iter) {
-		if (iter.value->getNext() == emptySlot) {
-			OSAL::unlockMutex(mutex);
-			return iter.value;
-		}
-	}
-	return NULL;
-}
-
-void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
-	ModeListEntry* next = sequence;
-	while (next != NULL) {
-		next = sequence->getNext()->value;
-		sequence->setNext(emptySlot);
-		sequence = next;
-	}
-}
-
-ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
-	if ((sequence < store.front()) || (sequence > store.back())
-			|| sequence->getNext() == emptySlot) {
-		return INVALID_ENTRY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-#endif
+#include "../../subsystem/modes/ModeStore.h"
+
+#ifdef USE_MODESTORE
+
+ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
+		SystemObject(objectId), store(slots), emptySlot(store.front()) {
+	mutex = MutexFactory::instance()->createMutex();;
+	OSAL::createMutex(objectId + 1, mutex);
+	clear();
+}
+
+ModeStore::~ModeStore() {
+	delete mutex;
+}
+
+uint32_t ModeStore::getFreeSlots() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	uint32_t count = 0;
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		if (iter->getNext() == emptySlot) {
+			++count;
+		}
+	}
+	OSAL::unlockMutex(mutex);
+	return count;
+}
+
+ReturnValue_t ModeStore::storeArray(ArrayList<ModeListEntry>* sequence,
+		ModeListEntry** storedFirstEntry) {
+	if (sequence->size == 0) {
+		return CANT_STORE_EMPTY;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	*storedFirstEntry = findEmptySlotNoLock(store.front());
+
+	ModeListEntry* pointer =
+			*storedFirstEntry;
+	pointer->setNext(pointer);
+
+	ArrayList<ModeListEntry>::Iterator iter;
+	for (iter = sequence->begin(); iter != sequence->end(); ++iter) {
+		//SHOULDDO: I need to check this in detail. What is the idea? Why does it not work?
+		pointer = pointer->getNext()->value;
+		if (pointer == NULL) {
+			deleteListNoLock(*storedFirstEntry);
+			OSAL::unlockMutex(mutex);
+			return TOO_MANY_ELEMENTS;
+		}
+		pointer->value->value1 = iter->value1;
+		pointer->value->value2 = iter->value2;
+		pointer->value->value3 = iter->value3;
+		pointer->setNext(findEmptySlotNoLock(pointer + 1));
+	}
+	pointer->setNext(NULL);
+	OSAL::unlockMutex(mutex);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::deleteList(ModeListEntry* sequence) {
+	ReturnValue_t result = isValidEntry(sequence);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+		deleteListNoLock(sequence);
+		OSAL::unlockMutex(mutex);
+		return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t ModeStore::readList(ModeListEntry* sequence,
+		ArrayList<ModeListEntry>* into) {
+	ReturnValue_t result = isValidEntry(sequence);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	result = into->insert(*sequence->value);
+	while ((result == HasReturnvaluesIF::RETURN_OK) && (sequence->getNext() != NULL)) {
+		result = into->insert(*sequence->value);
+		sequence = sequence->getNext()->value;
+	}
+	OSAL::unlockMutex(mutex);
+	return result;
+}
+
+void ModeStore::clear() {
+	OSAL::lockMutex(mutex, OSAL::NO_TIMEOUT);
+	store.size = store.maxSize();
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter;
+	for (iter = store.begin(); iter != store.end(); ++iter) {
+		iter->setNext(emptySlot);
+	}
+	OSAL::unlockMutex(mutex);
+}
+
+ModeListEntry* ModeStore::findEmptySlotNoLock(ModeListEntry* startFrom) {
+	ArrayList<ModeListEntry, uint32_t>::Iterator iter(
+			startFrom);
+	for (; iter != store.end(); ++iter) {
+		if (iter.value->getNext() == emptySlot) {
+			OSAL::unlockMutex(mutex);
+			return iter.value;
+		}
+	}
+	return NULL;
+}
+
+void ModeStore::deleteListNoLock(ModeListEntry* sequence) {
+	ModeListEntry* next = sequence;
+	while (next != NULL) {
+		next = sequence->getNext()->value;
+		sequence->setNext(emptySlot);
+		sequence = next;
+	}
+}
+
+ReturnValue_t ModeStore::isValidEntry(ModeListEntry* sequence) {
+	if ((sequence < store.front()) || (sequence > store.back())
+			|| sequence->getNext() == emptySlot) {
+		return INVALID_ENTRY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+#endif
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index cb340443..3d031cc8 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,45 +1,45 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
-
-#ifdef USE_MODESTORE
-
-#include "../../container/ArrayList.h"
-#include "../../container/SinglyLinkedList.h"
-#include "../../objectmanager/SystemObject.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
-
-class ModeStore: public ModeStoreIF, public SystemObject {
-public:
-	ModeStore(object_id_t objectId, uint32_t slots);
-	virtual ~ModeStore();
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry);
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence);
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into);
-
-	virtual uint32_t getFreeSlots();
-
-private:
-	MutexId_t* mutex;
-	ArrayList<ModeListEntry, uint32_t> store;
-	ModeListEntry *emptySlot;
-
-	void clear();
-	ModeListEntry* findEmptySlotNoLock(
-			ModeListEntry* startFrom);
-	void deleteListNoLock(
-			ModeListEntry *sequence);
-
-	ReturnValue_t isValidEntry(ModeListEntry *sequence);
-};
-
-#endif
-
-#endif /* MODESTORE_H_ */
-
+#ifndef MODESTORE_H_
+#define MODESTORE_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../subsystem/modes/ModeStoreIF.h"
+
+class ModeStore: public ModeStoreIF, public SystemObject {
+public:
+	ModeStore(object_id_t objectId, uint32_t slots);
+	virtual ~ModeStore();
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry);
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence);
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into);
+
+	virtual uint32_t getFreeSlots();
+
+private:
+	MutexId_t* mutex;
+	ArrayList<ModeListEntry, uint32_t> store;
+	ModeListEntry *emptySlot;
+
+	void clear();
+	ModeListEntry* findEmptySlotNoLock(
+			ModeListEntry* startFrom);
+	void deleteListNoLock(
+			ModeListEntry *sequence);
+
+	ReturnValue_t isValidEntry(ModeListEntry *sequence);
+};
+
+#endif
+
+#endif /* MODESTORE_H_ */
+
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index b9f2df70..30cca1f7 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,37 +1,37 @@
-#ifndef MODESTOREIF_H_
-#define MODESTOREIF_H_
-
-#ifdef USE_MODESTORE
-
-#include "../../container/ArrayList.h"
-#include "../../container/SinglyLinkedList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
-
-class ModeStoreIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
-	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
-
-	virtual ~ModeStoreIF() {
-
-	}
-
-	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
-			ModeListEntry **storedFirstEntry) = 0;
-
-	virtual ReturnValue_t deleteList(
-			ModeListEntry *sequence) = 0;
-
-	virtual ReturnValue_t readList(
-			ModeListEntry *sequence,
-			ArrayList<ModeListEntry> *into) = 0;
-
-	virtual uint32_t getFreeSlots() = 0;
-};
-
-#endif
-
-#endif /* MODESTOREIF_H_ */
+#ifndef MODESTOREIF_H_
+#define MODESTOREIF_H_
+
+#ifdef USE_MODESTORE
+
+#include "../../container/ArrayList.h"
+#include "../../container/SinglyLinkedList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../subsystem/modes/ModeDefinitions.h"
+
+class ModeStoreIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MODE_STORE_IF;
+	static const ReturnValue_t INVALID_ENTRY = MAKE_RETURN_CODE(0x02);
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(0x03);
+	static const ReturnValue_t CANT_STORE_EMPTY = MAKE_RETURN_CODE(0x04);
+
+	virtual ~ModeStoreIF() {
+
+	}
+
+	virtual ReturnValue_t storeArray(ArrayList<ModeListEntry> *sequence,
+			ModeListEntry **storedFirstEntry) = 0;
+
+	virtual ReturnValue_t deleteList(
+			ModeListEntry *sequence) = 0;
+
+	virtual ReturnValue_t readList(
+			ModeListEntry *sequence,
+			ArrayList<ModeListEntry> *into) = 0;
+
+	virtual uint32_t getFreeSlots() = 0;
+};
+
+#endif
+
+#endif /* MODESTOREIF_H_ */
diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 902b2e3c..06b837db 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,53 +1,53 @@
-#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
-
-class PeriodicTaskIF;
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-#include <cstring>
-/**
- * @brief	The interface provides a method to execute objects within a task.
- * @details	The performOperation method, that is required by the interface is
- * 			executed cyclically within a task context.
- * @author  Bastian Baetz
- */
-class ExecutableObjectIF {
-public:
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~ExecutableObjectIF() { }
-	/**
-	 * @brief	The performOperation method is executed in a task.
-	 * @details	There are no restrictions for calls within this method, so any
-	 * 			other member of the class can be used.
-	 * @return	Currently, the return value is ignored.
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
-
-	/**
-	 * @brief Function called during setup assignment of object to task
-	 * @details
-	 * Has to be called from the function that assigns the object to a task and
-	 * enables the object implementation to overwrite this function and get
-	 * a reference to the executing task
-	 * @param task_ Pointer to the taskIF of this task
-	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {};
-
-	/**
-	 * This function should be called after the object was assigned to a
-	 * specific task.
-	 *
-	 * Example: Can be used to get task execution frequency.
-	 * The task is created after initialize() and the object ctors have been
-	 * called so the execution frequency can't be cached in initialize()
-	 * @return
-	 */
-	virtual ReturnValue_t initializeAfterTaskCreation() {
-	    return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+
+class PeriodicTaskIF;
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstring>
+/**
+ * @brief	The interface provides a method to execute objects within a task.
+ * @details	The performOperation method, that is required by the interface is
+ * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
+ */
+class ExecutableObjectIF {
+public:
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~ExecutableObjectIF() { }
+	/**
+	 * @brief	The performOperation method is executed in a task.
+	 * @details	There are no restrictions for calls within this method, so any
+	 * 			other member of the class can be used.
+	 * @return	Currently, the return value is ignored.
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) = 0;
+
+	/**
+	 * @brief Function called during setup assignment of object to task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
+	 * @param task_ Pointer to the taskIF of this task
+	 */
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
+
+	/**
+	 * This function should be called after the object was assigned to a
+	 * specific task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index 9d290d19..a38734a2 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,17 +1,17 @@
-#include "../objectmanager/SystemObjectIF.h"
-#include "../tasks/FixedSequenceSlot.h"
-#include <cstddef>
-
-FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
-		int8_t setSequenceId, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) :
-		pollingTimeMs(setTime), opcode(setSequenceId) {
-    if(executableObject == nullptr) {
-        return;
-    }
-    this->executableObject = executableObject;
-    this->executableObject->setTaskIF(executingTask);
-}
-
-FixedSequenceSlot::~FixedSequenceSlot() {}
-
+#include "../objectmanager/SystemObjectIF.h"
+#include "../tasks/FixedSequenceSlot.h"
+#include <cstddef>
+
+FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
+		int8_t setSequenceId, ExecutableObjectIF* executableObject,
+		PeriodicTaskIF* executingTask) :
+		pollingTimeMs(setTime), opcode(setSequenceId) {
+    if(executableObject == nullptr) {
+        return;
+    }
+    this->executableObject = executableObject;
+    this->executableObject->setTaskIF(executingTask);
+}
+
+FixedSequenceSlot::~FixedSequenceSlot() {}
+
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 9cf5894c..6ec9ae13 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,57 +1,57 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-class PeriodicTaskIF;
-
-/**
- * @brief	This class is the representation of a single polling sequence
- *          table entry.
- * @details
- * The PollingSlot class is the representation of a single polling
- * sequence table entry.
- * @author  baetz
- */
-class FixedSequenceSlot {
-public:
-	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
-			int8_t setSequenceId, ExecutableObjectIF* executableObject,
-			PeriodicTaskIF* executingTask);
-	virtual ~FixedSequenceSlot();
-
-	/**
-	 * @brief	Handler identifies which object is executed in this slot.
-	 */
-	ExecutableObjectIF*	executableObject = nullptr;
-
-	/**
-	 * @brief	This attribute defines when a device handler object is executed.
-	 * @details
-	 * The pollingTime attribute identifies the time the handler is
-	 * executed in ms. It must be smaller than the period length of the
-	 * polling sequence.
-	 */
-	uint32_t pollingTimeMs;
-
-	/**
-	 * @brief	This value defines the type of device communication.
-	 *
-	 * @details	The state of this value decides what communication routine is
-	 * 			called in the PST executable or the device handler object.
-	 */
-	uint8_t	opcode;
-
-	/**
-	 * @brief 	Operator overload for the comparison operator to
-	 * 			allow sorting by polling time.
-	 * @param fixedSequenceSlot
-	 * @return
-	 */
-	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
-		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
-	}
-};
-
-
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+class PeriodicTaskIF;
+
+/**
+ * @brief	This class is the representation of a single polling sequence
+ *          table entry.
+ * @details
+ * The PollingSlot class is the representation of a single polling
+ * sequence table entry.
+ * @author  baetz
+ */
+class FixedSequenceSlot {
+public:
+	FixedSequenceSlot( object_id_t handlerId, uint32_t setTimeMs,
+			int8_t setSequenceId, ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
+	virtual ~FixedSequenceSlot();
+
+	/**
+	 * @brief	Handler identifies which object is executed in this slot.
+	 */
+	ExecutableObjectIF*	executableObject = nullptr;
+
+	/**
+	 * @brief	This attribute defines when a device handler object is executed.
+	 * @details
+	 * The pollingTime attribute identifies the time the handler is
+	 * executed in ms. It must be smaller than the period length of the
+	 * polling sequence.
+	 */
+	uint32_t pollingTimeMs;
+
+	/**
+	 * @brief	This value defines the type of device communication.
+	 *
+	 * @details	The state of this value decides what communication routine is
+	 * 			called in the PST executable or the device handler object.
+	 */
+	uint8_t	opcode;
+
+	/**
+	 * @brief 	Operator overload for the comparison operator to
+	 * 			allow sorting by polling time.
+	 * @param fixedSequenceSlot
+	 * @return
+	 */
+	bool operator <(const FixedSequenceSlot & fixedSequenceSlot) const {
+		return pollingTimeMs < fixedSequenceSlot.pollingTimeMs;
+	}
+};
+
+
+#endif /* FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index d803a419..59859ce5 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,147 +1,147 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tasks/FixedSlotSequence.h"
-#include <cstdlib>
-
-FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
-		lengthMs(setLengthMs) {
-	current = slotList.begin();
-}
-
-FixedSlotSequence::~FixedSlotSequence() {
-	// Call the destructor on each list entry.
-	slotList.clear();
-}
-
-void FixedSlotSequence::executeAndAdvance() {
-	current->executableObject->performOperation(current->opcode);
-//	if (returnValue != RETURN_OK) {
-//		this->sendErrorMessage( returnValue );
-//	}
-	//Increment the polling Sequence iterator
-	this->current++;
-	//Set it to the beginning, if the list's end is reached.
-	if (this->current == this->slotList.end()) {
-		this->current = this->slotList.begin();
-	}
-}
-
-uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
-	uint32_t oldTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	oldTime = slotListIter->pollingTimeMs;
-	// Advance to the next object.
-	slotListIter++;
-	// Find the next interval which is not 0.
-	while (slotListIter != slotList.end()) {
-		if (oldTime != slotListIter->pollingTimeMs) {
-			return slotListIter->pollingTimeMs - oldTime;
-		} else {
-			slotListIter++;
-		}
-	}
-	// If the list end is reached (this is definitely an interval != 0),
-	// the interval is calculated by subtracting the remaining time of the PST
-	// and adding the start time of the first handler in the list.
-	slotListIter = slotList.begin();
-	return lengthMs - oldTime + slotListIter->pollingTimeMs;
-}
-
-uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
-	uint32_t currentTime;
-	SlotListIter slotListIter = current;
-	// Get the pollingTimeMs of the current slot object.
-	currentTime = slotListIter->pollingTimeMs;
-
-	//if it is the first slot, calculate difference to last slot
-	if (slotListIter == slotList.begin()){
-		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
-	}
-	// get previous slot
-	slotListIter--;
-
-	return currentTime - slotListIter->pollingTimeMs;
-}
-
-bool FixedSlotSequence::slotFollowsImmediately() {
-	uint32_t currentTime = current->pollingTimeMs;
-	SlotListIter fixedSequenceIter = this->current;
-	// Get the pollingTimeMs of the current slot object.
-	if (fixedSequenceIter == slotList.begin())
-		return false;
-	fixedSequenceIter--;
-	if (fixedSequenceIter->pollingTimeMs == currentTime) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-uint32_t FixedSlotSequence::getLengthMs() const {
-	return this->lengthMs;
-}
-
-void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
-        int8_t executionStep, ExecutableObjectIF* executableObject,
-        PeriodicTaskIF* executingTask) {
-    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
-            executionStep, executableObject, executingTask));
-   this->current = slotList.begin();
-}
-
-ReturnValue_t FixedSlotSequence::checkSequence() const {
-	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t count = 0;
-	uint32_t time = 0;
-	for(const auto& slot: slotList) {
-		if (slot.executableObject == nullptr) {
-			count++;
-		}
-		else if (slot.pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
-					<< slot.pollingTimeMs << " is smaller than previous with "
-					<< time << std::endl;
-			count++;
-		}
-		else {
-			// All ok, print slot.
-			//sif::info << "Current slot polling time: " << std::endl;
-			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
-		}
-		time = slot.pollingTimeMs;
-
-	}
-	//sif::info << "Number of elements in slot list: "
-	//	   << slotList.size() << std::endl;
-	if (count > 0) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
-    std::set<ExecutableObjectIF*> uniqueObjects;
-    uint32_t count = 0;
-    for(const auto& slot: slotList) {
-        // Ensure that each unique object is initialized once.
-        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
-            ReturnValue_t result =
-                    slot.executableObject->initializeAfterTaskCreation();
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                count++;
-            }
-            uniqueObjects.emplace(slot.executableObject);
-        }
-    }
-    if (count > 0) {
-        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
-                "Counted " << count << " failed initializations!"  << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tasks/FixedSlotSequence.h"
+#include <cstdlib>
+
+FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
+		lengthMs(setLengthMs) {
+	current = slotList.begin();
+}
+
+FixedSlotSequence::~FixedSlotSequence() {
+	// Call the destructor on each list entry.
+	slotList.clear();
+}
+
+void FixedSlotSequence::executeAndAdvance() {
+	current->executableObject->performOperation(current->opcode);
+//	if (returnValue != RETURN_OK) {
+//		this->sendErrorMessage( returnValue );
+//	}
+	//Increment the polling Sequence iterator
+	this->current++;
+	//Set it to the beginning, if the list's end is reached.
+	if (this->current == this->slotList.end()) {
+		this->current = this->slotList.begin();
+	}
+}
+
+uint32_t FixedSlotSequence::getIntervalToNextSlotMs() {
+	uint32_t oldTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	oldTime = slotListIter->pollingTimeMs;
+	// Advance to the next object.
+	slotListIter++;
+	// Find the next interval which is not 0.
+	while (slotListIter != slotList.end()) {
+		if (oldTime != slotListIter->pollingTimeMs) {
+			return slotListIter->pollingTimeMs - oldTime;
+		} else {
+			slotListIter++;
+		}
+	}
+	// If the list end is reached (this is definitely an interval != 0),
+	// the interval is calculated by subtracting the remaining time of the PST
+	// and adding the start time of the first handler in the list.
+	slotListIter = slotList.begin();
+	return lengthMs - oldTime + slotListIter->pollingTimeMs;
+}
+
+uint32_t FixedSlotSequence::getIntervalToPreviousSlotMs() {
+	uint32_t currentTime;
+	SlotListIter slotListIter = current;
+	// Get the pollingTimeMs of the current slot object.
+	currentTime = slotListIter->pollingTimeMs;
+
+	//if it is the first slot, calculate difference to last slot
+	if (slotListIter == slotList.begin()){
+		return lengthMs - (--slotList.end())->pollingTimeMs + currentTime;
+	}
+	// get previous slot
+	slotListIter--;
+
+	return currentTime - slotListIter->pollingTimeMs;
+}
+
+bool FixedSlotSequence::slotFollowsImmediately() {
+	uint32_t currentTime = current->pollingTimeMs;
+	SlotListIter fixedSequenceIter = this->current;
+	// Get the pollingTimeMs of the current slot object.
+	if (fixedSequenceIter == slotList.begin())
+		return false;
+	fixedSequenceIter--;
+	if (fixedSequenceIter->pollingTimeMs == currentTime) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+uint32_t FixedSlotSequence::getLengthMs() const {
+	return this->lengthMs;
+}
+
+void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
+        int8_t executionStep, ExecutableObjectIF* executableObject,
+        PeriodicTaskIF* executingTask) {
+    this->slotList.insert(FixedSequenceSlot(componentId, slotTimeMs,
+            executionStep, executableObject, executingTask));
+   this->current = slotList.begin();
+}
+
+ReturnValue_t FixedSlotSequence::checkSequence() const {
+	if(slotList.empty()) {
+		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	uint32_t count = 0;
+	uint32_t time = 0;
+	for(const auto& slot: slotList) {
+		if (slot.executableObject == nullptr) {
+			count++;
+		}
+		else if (slot.pollingTimeMs < time) {
+			sif::error << "FixedSlotSequence::initialize: Time: "
+					<< slot.pollingTimeMs << " is smaller than previous with "
+					<< time << std::endl;
+			count++;
+		}
+		else {
+			// All ok, print slot.
+			//sif::info << "Current slot polling time: " << std::endl;
+			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+		}
+		time = slot.pollingTimeMs;
+
+	}
+	//sif::info << "Number of elements in slot list: "
+	//	   << slotList.size() << std::endl;
+	if (count > 0) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
+    std::set<ExecutableObjectIF*> uniqueObjects;
+    uint32_t count = 0;
+    for(const auto& slot: slotList) {
+        // Ensure that each unique object is initialized once.
+        if(uniqueObjects.find(slot.executableObject) == uniqueObjects.end()) {
+            ReturnValue_t result =
+                    slot.executableObject->initializeAfterTaskCreation();
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                count++;
+            }
+            uniqueObjects.emplace(slot.executableObject);
+        }
+    }
+    if (count > 0) {
+        sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
+                "Counted " << count << " failed initializations!"  << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 9ab84552..1140dd25 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/FixedSequenceSlot.h"
-
-#include <set>
-
-/**
- * @brief	This class is the representation of a Polling Sequence Table in software.
- * @details
- * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
- *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
- *
- * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
- */
-class FixedSlotSequence {
-public:
-	using SlotList = std::multiset<FixedSequenceSlot>;
-	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
-
-	/**
-	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
-	 * @param	setLength	The period length, expressed in ms.
-	 */
-	FixedSlotSequence(uint32_t setLengthMs);
-
-	/**
-	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
-	 */
-	virtual ~FixedSlotSequence();
-
-	/**
-	 * @brief	This is a method to add an PollingSlot object to slotList.
-	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
-	 * 	@param
-	 * 	@param
-	 */
-	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
-
-	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
-	 * @return 	- @c true if the slot has the same polling time as the previous
-	 * 			- @c false else
-	 */
-	bool slotFollowsImmediately();
-
-	/**
-	 * @brief	This method returns the time until the next software
-	 * 			component is invoked.
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the
-	 * next one (or the first one, if the list end is reached)
-	 * it calculates and returns the interval in milliseconds within
-	 * which the handler execution shall take place.
-	 * If the next slot has the same time as the current one, it is ignored
-	 * until a slot with different time or the end of the PST is found.
-	 */
-	uint32_t getIntervalToNextSlotMs();
-
-	/**
-	 * @brief	This method returns the time difference between the current
-	 * 			slot and the previous slot
-	 *
-	 * @details
-	 * This method is vitally important for the operation of the PST.
-	 * By fetching the polling time of the current slot and that of the previous
-	 * one (or the last one, if the slot is the first one) it calculates and
-	 * returns the interval in milliseconds that the handler execution shall
-	 * be delayed.
-	 */
-	uint32_t getIntervalToPreviousSlotMs();
-
-	/**
-	 * @brief	This method returns the length of this FixedSlotSequence instance.
-	 */
-	uint32_t getLengthMs() const;
-
-	/**
-	 * @brief	The method to execute the device handler entered in the current
-	 * 			PollingSlot object.
-	 *
-	 * @details
-	 * Within this method the device handler object to be executed is chosen by
-	 * looking up the handler address of the current slot in the handlerMap.
-	 * Either the device handler's talkToInterface or its listenToInterface
-	 * method is invoked, depending on the isTalking flag of the polling slot.
-	 * After execution the iterator current is increased or, by reaching the
-	 * end of slotList, reset to the beginning.
-	 */
-	void executeAndAdvance();
-
-	/**
-	 * @brief	An iterator that indicates the current polling slot to execute.
-	 *
-	 * @details	This is an iterator for slotList and always points to the
-	 * 			polling slot which is executed next.
-	 */
-	SlotListIter current;
-
-	/**
-	 * @brief   Check and initialize slot list.
-	 * @details
-	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * Also calls any initialization steps which are required after task
-	 * creation.
-	 * @return
-	 */
-	ReturnValue_t checkSequence() const;
-
-	ReturnValue_t intializeSequenceAfterTaskCreation() const;
-
-protected:
-
-	/**
-	 * @brief	This list contains all PollingSlot objects, defining order and
-	 * 			execution time of the device handler objects.
-	 *
-	 * @details
-	 * The slot list is a std:list object that contains all created
-	 * PollingSlot instances. They are NOT ordered automatically, so by
-	 * adding entries, the correct order needs to be ensured. By iterating
-	 * through this list the polling sequence is executed. Two entries with
-	 * identical polling times are executed immediately one after another.
-	 */
-	SlotList slotList;
-
-	uint32_t lengthMs;
-
-	bool isEmpty = false;
-};
-
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/FixedSequenceSlot.h"
+
+#include <set>
+
+/**
+ * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @details
+ * The FixedSlotSequence object maintains the dynamic execution of
+ * device handler objects.
+ *
+ * The main idea is to create a list of device handlers, to announce all
+ * handlers to thepolling sequence and to maintain a list of
+ * polling slot objects. This slot list represents the Polling Sequence Table
+ * in software.
+ *
+ * Each polling slot contains information to indicate when and
+ * which device handler shall be executed within a given polling period.
+ * The sequence is then executed by iterating through this slot list.
+ * Handlers are invoking by calling a certain function stored in the handler list.
+ */
+class FixedSlotSequence {
+public:
+	using SlotList = std::multiset<FixedSequenceSlot>;
+	using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
+
+	/**
+	 * @brief	The constructor of the FixedSlotSequence object.
+	 *
+	 * @details	The constructor takes two arguments, the period length and the init function.
+	 *
+	 * @param	setLength	The period length, expressed in ms.
+	 */
+	FixedSlotSequence(uint32_t setLengthMs);
+
+	/**
+	 * @brief	The destructor of the FixedSlotSequence object.
+	 *
+	 * @details	The destructor frees all allocated memory by iterating through the slotList
+	 *  		and deleting all allocated resources.
+	 */
+	virtual ~FixedSlotSequence();
+
+	/**
+	 * @brief	This is a method to add an PollingSlot object to slotList.
+	 *
+	 * @details	Here, a polling slot object is added to the slot list. It is appended
+	 * 			to the end of the list. The list is currently NOT reordered.
+	 * 			Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param Object ID of the object to add
+	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 				   will be called inside the slot period.
+	 * 	@param setSequenceId ID which can be used to distinguish
+	 * 	                     different task operations
+	 * 	@param
+	 * 	@param
+	 */
+	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
+			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
+
+	/**
+	 * Checks if the current slot shall be executed immediately after the one before.
+	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @return 	- @c true if the slot has the same polling time as the previous
+	 * 			- @c false else
+	 */
+	bool slotFollowsImmediately();
+
+	/**
+	 * @brief	This method returns the time until the next software
+	 * 			component is invoked.
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the
+	 * next one (or the first one, if the list end is reached)
+	 * it calculates and returns the interval in milliseconds within
+	 * which the handler execution shall take place.
+	 * If the next slot has the same time as the current one, it is ignored
+	 * until a slot with different time or the end of the PST is found.
+	 */
+	uint32_t getIntervalToNextSlotMs();
+
+	/**
+	 * @brief	This method returns the time difference between the current
+	 * 			slot and the previous slot
+	 *
+	 * @details
+	 * This method is vitally important for the operation of the PST.
+	 * By fetching the polling time of the current slot and that of the previous
+	 * one (or the last one, if the slot is the first one) it calculates and
+	 * returns the interval in milliseconds that the handler execution shall
+	 * be delayed.
+	 */
+	uint32_t getIntervalToPreviousSlotMs();
+
+	/**
+	 * @brief	This method returns the length of this FixedSlotSequence instance.
+	 */
+	uint32_t getLengthMs() const;
+
+	/**
+	 * @brief	The method to execute the device handler entered in the current
+	 * 			PollingSlot object.
+	 *
+	 * @details
+	 * Within this method the device handler object to be executed is chosen by
+	 * looking up the handler address of the current slot in the handlerMap.
+	 * Either the device handler's talkToInterface or its listenToInterface
+	 * method is invoked, depending on the isTalking flag of the polling slot.
+	 * After execution the iterator current is increased or, by reaching the
+	 * end of slotList, reset to the beginning.
+	 */
+	void executeAndAdvance();
+
+	/**
+	 * @brief	An iterator that indicates the current polling slot to execute.
+	 *
+	 * @details	This is an iterator for slotList and always points to the
+	 * 			polling slot which is executed next.
+	 */
+	SlotListIter current;
+
+	/**
+	 * @brief   Check and initialize slot list.
+	 * @details
+	 * Checks if timing is ok (must be ascending) and if all handlers were found.
+	 * Also calls any initialization steps which are required after task
+	 * creation.
+	 * @return
+	 */
+	ReturnValue_t checkSequence() const;
+
+	ReturnValue_t intializeSequenceAfterTaskCreation() const;
+
+protected:
+
+	/**
+	 * @brief	This list contains all PollingSlot objects, defining order and
+	 * 			execution time of the device handler objects.
+	 *
+	 * @details
+	 * The slot list is a std:list object that contains all created
+	 * PollingSlot instances. They are NOT ordered automatically, so by
+	 * adding entries, the correct order needs to be ensured. By iterating
+	 * through this list the polling sequence is executed. Two entries with
+	 * identical polling times are executed immediately one after another.
+	 */
+	SlotList slotList;
+
+	uint32_t lengthMs;
+
+	bool isEmpty = false;
+};
+
+#endif /* FIXEDSLOTSEQUENCE_H_ */
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index daced785..6344efa5 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,33 +1,33 @@
-#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/PeriodicTaskIF.h"
-
-/**
- * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
- */
-class FixedTimeslotTaskIF : public PeriodicTaskIF {
-public:
-	virtual ~FixedTimeslotTaskIF() {}
-
-	/**
-	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
-	 * @param componentId
-	 * @param slotTimeMs
-	 * @param executionStep
-	 * @return
-	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-
-	/**
-	 * Check whether the sequence is valid and perform all other required
-	 * initialization steps which are needed after task creation
-	 */
-	virtual ReturnValue_t checkSequence() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
+#ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+#define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tasks/PeriodicTaskIF.h"
+
+/**
+ * @brief Following the same principle as the base class IF.
+ *        This is the interface for a Fixed timeslot task
+ */
+class FixedTimeslotTaskIF : public PeriodicTaskIF {
+public:
+	virtual ~FixedTimeslotTaskIF() {}
+
+	/**
+	 * Add an object with a slot time and the execution step to the task.
+	 * The execution step shall be passed to the object.
+	 * @param componentId
+	 * @param slotTimeMs
+	 * @param executionStep
+	 * @return
+	 */
+	virtual ReturnValue_t addSlot(object_id_t componentId,
+			uint32_t slotTimeMs, int8_t executionStep) = 0;
+
+	/**
+	 * Check whether the sequence is valid and perform all other required
+	 * initialization steps which are needed after task creation
+	 */
+	virtual ReturnValue_t checkSequence() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h
index 38cf201b..4df37645 100644
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@@ -1,49 +1,49 @@
-#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
-#define FRAMEWORK_TASK_PERIODICTASKIF_H_
-
-#include "../objectmanager/SystemObjectIF.h"
-#include "../timemanager/Clock.h"
-#include <cstddef>
-class ExecutableObjectIF;
-
-/**
- * New version of TaskIF
- * Follows RAII principles, i.e. there's no create or delete method.
- * Minimalistic.
-*/
-class PeriodicTaskIF {
-public:
-	static const size_t MINIMUM_STACK_SIZE;
-	/**
-	 * @brief	A virtual destructor as it is mandatory for interfaces.
-	 */
-	virtual ~PeriodicTaskIF() { }
-	/**
-	 * @brief	With the startTask method, a created task can be started
-	 *          for the first time.
-	 */
-	virtual ReturnValue_t startTask() = 0;
-
-	/**
-	 * Add a component (object) to a periodic task. The pointer to the
-	 * task can be set optionally
-	 * @param object
-	 * Add an object to the task. The most important case is to add an
-	 * executable object with a function which will be called regularly
-	 * (see ExecutableObjectIF)
-	 * @param setTaskIF
-	 * Can be used to specify whether the task object pointer is passed
-	 * to the component.
-	 * @return
-	 */
-	virtual ReturnValue_t addComponent(object_id_t object) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-
-	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
-
-	virtual uint32_t getPeriodMs() const = 0;
-};
-
-
-#endif /* PERIODICTASKIF_H_ */
+#ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_
+#define FRAMEWORK_TASK_PERIODICTASKIF_H_
+
+#include "../objectmanager/SystemObjectIF.h"
+#include "../timemanager/Clock.h"
+#include <cstddef>
+class ExecutableObjectIF;
+
+/**
+ * New version of TaskIF
+ * Follows RAII principles, i.e. there's no create or delete method.
+ * Minimalistic.
+*/
+class PeriodicTaskIF {
+public:
+	static const size_t MINIMUM_STACK_SIZE;
+	/**
+	 * @brief	A virtual destructor as it is mandatory for interfaces.
+	 */
+	virtual ~PeriodicTaskIF() { }
+	/**
+	 * @brief	With the startTask method, a created task can be started
+	 *          for the first time.
+	 */
+	virtual ReturnValue_t startTask() = 0;
+
+	/**
+	 * Add a component (object) to a periodic task. The pointer to the
+	 * task can be set optionally
+	 * @param object
+	 * Add an object to the task. The most important case is to add an
+	 * executable object with a function which will be called regularly
+	 * (see ExecutableObjectIF)
+	 * @param setTaskIF
+	 * Can be used to specify whether the task object pointer is passed
+	 * to the component.
+	 * @return
+	 */
+	virtual ReturnValue_t addComponent(object_id_t object) {
+	    return HasReturnvaluesIF::RETURN_FAILED;
+	};
+
+	virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
+
+	virtual uint32_t getPeriodMs() const = 0;
+};
+
+
+#endif /* PERIODICTASKIF_H_ */
diff --git a/tasks/SemaphoreFactory.h b/tasks/SemaphoreFactory.h
index 2c41a135..01c09d1b 100644
--- a/tasks/SemaphoreFactory.h
+++ b/tasks/SemaphoreFactory.h
@@ -1,50 +1,50 @@
-#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
-#define FSFW_TASKS_SEMAPHOREFACTORY_H_
-
-#include "../tasks/SemaphoreIF.h"
-
-/**
- * Creates Semaphore.
- * This class is a "singleton" interface, i.e. it provides an
- * interface, but also is the base class for a singleton.
- */
-class SemaphoreFactory {
-public:
-	virtual ~SemaphoreFactory();
-	/**
-	 * Returns the single instance of SemaphoreFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static SemaphoreFactory* instance();
-
-	/**
-	 * Create a binary semaphore.
-	 * Creator function for a binary semaphore which may only be acquired once
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return Pointer to newly created semaphore class instance.
-	 */
-	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
-	/**
-	 * Create a counting semaphore.
-	 * Creator functons for a counting semaphore which may be acquired multiple
-	 * times.
-	 * @param count Semaphore can be taken count times.
-	 * @param initCount Initial count value.
-	 * @param argument Can be used to pass implementation specific information.
-	 * @return
-	 */
-	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
-			uint8_t initCount, uint32_t arguments = 0);
-
-	void deleteSemaphore(SemaphoreIF* semaphore);
-
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	SemaphoreFactory();
-	static SemaphoreFactory* factoryInstance;
-};
-
-#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */
+#ifndef FSFW_TASKS_SEMAPHOREFACTORY_H_
+#define FSFW_TASKS_SEMAPHOREFACTORY_H_
+
+#include "../tasks/SemaphoreIF.h"
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore(uint32_t arguments = 0);
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @param argument Can be used to pass implementation specific information.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(const uint8_t maxCount,
+			uint8_t initCount, uint32_t arguments = 0);
+
+	void deleteSemaphore(SemaphoreIF* semaphore);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FSFW_TASKS_SEMAPHOREFACTORY_H_ */
diff --git a/tasks/SemaphoreIF.h b/tasks/SemaphoreIF.h
index 30d4ed88..dd327e23 100644
--- a/tasks/SemaphoreIF.h
+++ b/tasks/SemaphoreIF.h
@@ -1,68 +1,68 @@
-#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
-#include "../returnvalues/FwClassIds.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstdint>
-
-/**
- * @brief 	Generic interface for semaphores, which can be used to achieve
- * 			task synchronization. This is a generic interface which can be
- * 			used for both binary semaphores and counting semaphores.
- * @details
- * A semaphore is a synchronization primitive.
- * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
- * A semaphore can be used to achieve task synchonization and track the
- * availability of resources by using either the binary or the counting
- * semaphore types.
- *
- * If mutual exlcusion of a resource is desired, a mutex should be used,
- * which is a special form of a semaphore and has an own interface.
- */
-class SemaphoreIF {
-public:
-    /**
-     * Different types of timeout for the mutex lock.
-     */
-    enum TimeoutType {
-        POLLING, //!< If mutex is not available, return immediately
-        WAITING, //!< Wait a specified time for the mutex to become available
-        BLOCKING //!< Block indefinitely until the mutex becomes available.
-    };
-
-	virtual~ SemaphoreIF() {};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
-	//! Semaphore timeout
-	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
-	//! The current semaphore can not be given, because it is not owned
-	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
-	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
-
-	/**
-	 * Generic call to acquire a semaphore.
-	 * If there are no more semaphores to be taken (for a counting semaphore,
-	 * a semaphore may be taken more than once), the taks will block
-	 * for a maximum of timeoutMs while trying to acquire the semaphore.
-	 * This can be used to achieve task synchrnization.
-	 * @param timeoutMs
-	 * @return - c RETURN_OK for successfull acquisition
-	 */
-	virtual ReturnValue_t acquire(TimeoutType timeoutType =
-            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
-
-	/**
-	 * Corrensponding call to release a semaphore.
-	 * @return -@c RETURN_OK for successfull release
-	 */
-	virtual ReturnValue_t release() = 0;
-
-	/**
-	 * If the semaphore is a counting semaphore then the semaphores current
-	 * count value is returned. If the semaphore is a binary semaphore then 1
-	 * is returned if the semaphore is available, and 0 is returned if the
-	 * semaphore is not available.
-	 */
-	virtual uint8_t getSemaphoreCounter() const = 0;
-};
-
-#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
+#ifndef FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#define FRAMEWORK_TASKS_SEMAPHOREIF_H_
+#include "../returnvalues/FwClassIds.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstdint>
+
+/**
+ * @brief 	Generic interface for semaphores, which can be used to achieve
+ * 			task synchronization. This is a generic interface which can be
+ * 			used for both binary semaphores and counting semaphores.
+ * @details
+ * A semaphore is a synchronization primitive.
+ * See: https://en.wikipedia.org/wiki/Semaphore_(programming)
+ * A semaphore can be used to achieve task synchonization and track the
+ * availability of resources by using either the binary or the counting
+ * semaphore types.
+ *
+ * If mutual exlcusion of a resource is desired, a mutex should be used,
+ * which is a special form of a semaphore and has an own interface.
+ */
+class SemaphoreIF {
+public:
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+	virtual~ SemaphoreIF() {};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
+	//! Semaphore timeout
+	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);
+	//! The current semaphore can not be given, because it is not owned
+	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
+	static constexpr ReturnValue_t SEMAPHORE_INVALID = MAKE_RETURN_CODE(3);
+
+	/**
+	 * Generic call to acquire a semaphore.
+	 * If there are no more semaphores to be taken (for a counting semaphore,
+	 * a semaphore may be taken more than once), the taks will block
+	 * for a maximum of timeoutMs while trying to acquire the semaphore.
+	 * This can be used to achieve task synchrnization.
+	 * @param timeoutMs
+	 * @return - c RETURN_OK for successfull acquisition
+	 */
+	virtual ReturnValue_t acquire(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+
+	/**
+	 * Corrensponding call to release a semaphore.
+	 * @return -@c RETURN_OK for successfull release
+	 */
+	virtual ReturnValue_t release() = 0;
+
+	/**
+	 * If the semaphore is a counting semaphore then the semaphores current
+	 * count value is returned. If the semaphore is a binary semaphore then 1
+	 * is returned if the semaphore is available, and 0 is returned if the
+	 * semaphore is not available.
+	 */
+	virtual uint8_t getSemaphoreCounter() const = 0;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index 56b3083e..fd2f4460 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,73 +1,73 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
-
-#include <cstdlib>
-#include "../tasks/FixedTimeslotTaskIF.h"
-#include "../tasks/Typedef.h"
-
-/**
- * Singleton Class that produces Tasks.
- */
-class TaskFactory {
-public:
-	virtual ~TaskFactory();
-	/**
-	 * Returns the single instance of TaskFactory.
-	 * The implementation of #instance is found in its subclasses.
-	 * Thus, we choose link-time variability of the  instance.
-	 */
-	static TaskFactory* instance();
-
-	/**
-	 * Generic interface to create a periodic task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	PeriodicTaskIF* createPeriodicTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Generic interface to create a fixed timeslot task
-	 * @param name_ Name of the task
-	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
-	 */
-	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
-			TaskPriority taskPriority_, TaskStackSize stackSize_,
-			TaskPeriod periodInSeconds_,
-			TaskDeadlineMissedFunction deadLineMissedFunction_);
-
-	/**
-	 * Function to be called to delete a task
-	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
-
-	/**
-	 * Function to be called to delay current task
-	 * @param delay The delay in milliseconds
-	 * @return Success of deletion
-	 */
-	static ReturnValue_t delayTask(uint32_t delayMs);
-private:
-	/**
-	 * External instantiation is not allowed.
-	 */
-	TaskFactory();
-	static TaskFactory* factoryInstance;
-};
-
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
+#define FRAMEWORK_TASKS_TASKFACTORY_H_
+
+#include <cstdlib>
+#include "../tasks/FixedTimeslotTaskIF.h"
+#include "../tasks/Typedef.h"
+
+/**
+ * Singleton Class that produces Tasks.
+ */
+class TaskFactory {
+public:
+	virtual ~TaskFactory();
+	/**
+	 * Returns the single instance of TaskFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static TaskFactory* instance();
+
+	/**
+	 * Generic interface to create a periodic task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	PeriodicTaskIF* createPeriodicTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Generic interface to create a fixed timeslot task
+	 * @param name_ Name of the task
+	 * @param taskPriority_ Priority of the task
+	 * @param stackSize_ Stack size if the task
+	 * @param periodInSeconds_ Period in seconds
+	 * @param deadLineMissedFunction_ This function is called if a deadline was
+	 * missed
+	 * @return Pointer to the created periodic task class
+	 */
+	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
+			TaskPriority taskPriority_, TaskStackSize stackSize_,
+			TaskPeriod periodInSeconds_,
+			TaskDeadlineMissedFunction deadLineMissedFunction_);
+
+	/**
+	 * Function to be called to delete a task
+	 * @param task The pointer to the task that shall be deleted,
+	 * 				NULL specifies current Task
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+
+	/**
+	 * Function to be called to delay current task
+	 * @param delay The delay in milliseconds
+	 * @return Success of deletion
+	 */
+	static ReturnValue_t delayTask(uint32_t delayMs);
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	TaskFactory();
+	static TaskFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 68f26d2c..dda26d7f 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,82 +1,82 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributor.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-
-CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
-		object_id_t setObjectId):
-		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
-}
-
-CCSDSDistributor::~CCSDSDistributor() {}
-
-TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
-//			this->currentMessage.getStorageId().pool_index << ", " <<
-//			this->currentMessage.getStorageId().packet_index << std::endl;
-	const uint8_t* packet = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
-			&packet, &size );
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
-	}
-	SpacePacketBase currentPacket(packet);
-
-//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
-//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
-	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
-	if ( position != this->queueMap.end() ) {
-		return position;
-	} else {
-		//The APID was not found. Forward packet to main SW-APID anyway to
-		// create acceptance failure report.
-		return this->queueMap.find( this->defaultApid );
-	}
-}
-
-MessageQueueId_t CCSDSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(
-		AcceptsTelecommandsIF* application) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-}
-
-ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
-		MessageQueueId_t id) {
-	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
-		returnValue = RETURN_FAILED;
-	}
-	return returnValue;
-
-}
-
-uint16_t CCSDSDistributor::getIdentifier() {
-	return 0;
-}
-
-ReturnValue_t CCSDSDistributor::initialize() {
-	ReturnValue_t status = this->TcDistributor::initialize();
-	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
-	return status;
-}
-
-ReturnValue_t CCSDSDistributor::callbackAfterSending(
-		ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStore->deleteData(currentMessage.getStorageId());
-	}
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributor.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {}
+
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				"store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
+	if ( position != this->queueMap.end() ) {
+		return position;
+	} else {
+		//The APID was not found. Forward packet to main SW-APID anyway to
+		// create acceptance failure report.
+		return this->queueMap.find( this->defaultApid );
+	}
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+
+}
+
+uint16_t CCSDSDistributor::getIdentifier() {
+	return 0;
+}
+
+ReturnValue_t CCSDSDistributor::initialize() {
+	ReturnValue_t status = this->TcDistributor::initialize();
+	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	if (this->tcStore == NULL) status = RETURN_FAILED;
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index e54b9fe4..6abd952b 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -1,69 +1,69 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-/**
- * @brief 	An instantiation of the CCSDSDistributorIF.
- * @details
- * It receives Space Packets, and selects a destination depending on the
- * APID of the telecommands.
- * The Secondary Header (with Service/Subservice) is ignored.
- * @ingroup tc_distribution
- */
-class CCSDSDistributor : public TcDistributor,
-		public CCSDSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * @brief	The constructor sets the default APID and calls the
-	 * 			TcDistributor ctor with a certain object id.
-	 * @details
-	 * @c tcStore is set in the @c initialize method.
-	 * @param setDefaultApid The default APID, where packets with unknown
-	 * destination are sent to.
-	 */
-	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~CCSDSDistributor();
-
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t registerApplication( uint16_t apid,
-			MessageQueueId_t id) override;
-	ReturnValue_t registerApplication(
-			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
-	ReturnValue_t initialize() override;
-
-protected:
-	/**
-	 * This implementation checks if an application with fitting APID has
-	 * registered and forwards the packet to the according message queue.
-	 * If the packet is not found, it returns the queue to @c defaultApid,
-	 * where a Acceptance Failure message should be generated.
-	 * @return Iterator to map entry of found APID or iterator to default APID.
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The default APID, where packets with unknown APID are sent to.
-	 */
-	uint16_t defaultApid;
-	/**
-	 * A reference to the TC storage must be maintained, as this class handles
-	 * pure Space Packets and there exists no SpacePacketStored class.
-	 */
-	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+/**
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * It receives Space Packets, and selects a destination depending on the
+ * APID of the telecommands.
+ * The Secondary Header (with Service/Subservice) is ignored.
+ * @ingroup tc_distribution
+ */
+class CCSDSDistributor : public TcDistributor,
+		public CCSDSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
+	 */
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~CCSDSDistributor();
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier();
+	ReturnValue_t initialize() override;
+
+protected:
+	/**
+	 * This implementation checks if an application with fitting APID has
+	 * registered and forwards the packet to the according message queue.
+	 * If the packet is not found, it returns the queue to @c defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index 32198120..be3c2811 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,40 +1,40 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
-
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
- */
-class CCSDSDistributorIF {
-public:
-	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
-	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
-	/**
-	 * With this call, other Applications can register to the CCSDS distributor.
-	 * This is done by passing an APID and a MessageQueueId to the method.
-	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
-	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~CCSDSDistributorIF() {
-	}
-};
-
-
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#ifndef CCSDSDISTRIBUTORIF_H_
+#define CCSDSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This is the Interface to a CCSDS Distributor.
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributorIF {
+public:
+	/**
+	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * distributor.
+	 * @param application A pointer to the Application to register.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	/**
+	 * With this call, other Applications can register to the CCSDS distributor.
+	 * This is done by passing an APID and a MessageQueueId to the method.
+	 * @param apid	The APID to register.
+	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~CCSDSDistributorIF() {
+	}
+};
+
+
+#endif /* CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index fee16f11..0c710ef2 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,92 +1,92 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/PUSDistributor.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-		object_id_t setPacketSource) :
-		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
-
-PUSDistributor::~PUSDistributor() {}
-
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
-
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
-
-}
-
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
-
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
-	MessageQueueId_t queue = service->getRequestQueue();
-	auto returnPair = queueMap.emplace(serviceId, queue);
-	if (not returnPair.second) {
-		//TODO Return Code
-		sif::error << "PUSDistributor::registerService: Service ID already"
-				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PUSDistributor::getRequestQueue() {
-	return tcQueue->getId();
-}
-
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	if (queueStatus != RETURN_OK) {
-		tcStatus = queueStatus;
-	}
-	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
-		return RETURN_FAILED;
-	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
-		return RETURN_OK;
-	}
-}
-
-uint16_t PUSDistributor::getIdentifier() {
-	return checker.getApid();
-}
-
-ReturnValue_t PUSDistributor::initialize() {
-	CCSDSDistributorIF* ccsdsDistributor =
-			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
-		return ccsdsDistributor->registerApplication(this);
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/PUSDistributor.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		currentPacket(), tcStatus(RETURN_FAILED),
+		packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+	TcMqMapIter queueMapIt = this->queueMap.end();
+	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
+	if (currentPacket.getWholeData() != NULL) {
+		tcStatus = checker.checkPacket(&currentPacket);
+//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
+//				<< (int)tcStatus << std::endl;
+		uint32_t queue_id = currentPacket.getService();
+		queueMapIt = this->queueMap.find(queue_id);
+	} else {
+		tcStatus = PACKET_LOST;
+	}
+	if (queueMapIt == this->queueMap.end()) {
+		tcStatus = DESTINATION_NOT_FOUND;
+	}
+
+	if (tcStatus != RETURN_OK) {
+		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
+				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
+		return this->queueMap.end();
+	} else {
+		return queueMapIt;
+	}
+
+}
+
+//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
+//	return ( service_id << 8 ) + subservice_id;
+//}
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	uint16_t serviceId = service->getIdentifier();
+	//info << "Service ID: " << (int)serviceId << std::endl;
+	MessageQueueId_t queue = service->getRequestQueue();
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
+		//TODO Return Code
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				" exists in map." << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStatus = queueStatus;
+	}
+	if (tcStatus != RETURN_OK) {
+		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+				&currentPacket, tcStatus);
+		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		currentPacket.deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+				&currentPacket);
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+	CCSDSDistributorIF* ccsdsDistributor =
+			objectManager->get<CCSDSDistributorIF>(packetSource);
+	if (ccsdsDistributor == NULL) {
+		return RETURN_FAILED;
+	} else {
+		return ccsdsDistributor->registerApplication(this);
+	}
+}
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index be84de1b..b8cff1f4 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,77 +1,77 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tcdistribution/TcPacketCheck.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationReporter.h"
-
-/**
- * This class accepts PUS Telecommands and forwards them to Application
- * services. In addition, the class performs a formal packet check and
- * sends acceptance success or failure messages.
- * @ingroup tc_distribution
- */
-class PUSDistributor: public TcDistributor,
-		public PUSDistributorIF,
-		public AcceptsTelecommandsIF {
-public:
-	/**
-	 * The ctor passes @c set_apid to the checker class and calls the
-	 * TcDistribution ctor with a certain object id.
-	 * @param setApid The APID of this receiving Application.
-	 * @param setObjectId Object ID of the distributor itself
-	 * @param setPacketSource Object ID of the source of TC packets.
-	 * Must implement CCSDSDistributorIF.
-	 */
-	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-			object_id_t setPacketSource);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PUSDistributor();
-	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-	MessageQueueId_t getRequestQueue() override;
-	ReturnValue_t initialize() override;
-	uint16_t getIdentifier() override;
-
-protected:
-	/**
-	 * This attribute contains the class, that performs a formal packet check.
-	 */
-	TcPacketCheck checker;
-	/**
-	 * With this class, verification messages are sent to the
-	 * TC Verification service.
-	 */
-	VerificationReporter verifyChannel;
-	/**
-	 * The currently handled packet is stored here.
-	 */
-	TcPacketStored currentPacket;
-	/**
-	 * With this variable, the current check status is stored to generate
-	 * acceptance messages later.
-	 */
-	ReturnValue_t tcStatus;
-
-	const object_id_t packetSource;
-	/**
-	 * This method reads the packet service, checks if such a service is
-	 * registered and forwards the packet to the destination.
-	 * It also initiates the formal packet check and sending of verification
-	 * messages.
-	 * @return Iterator to map entry of found service id
-	 * or iterator to @c map.end().
-	 */
-	TcMqMapIter selectDestination() override;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
-};
-
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationReporter.h"
+
+/**
+ * This class accepts PUS Telecommands and forwards them to Application
+ * services. In addition, the class performs a formal packet check and
+ * sends acceptance success or failure messages.
+ * @ingroup tc_distribution
+ */
+class PUSDistributor: public TcDistributor,
+		public PUSDistributorIF,
+		public AcceptsTelecommandsIF {
+public:
+	/**
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
+	 * @param setApid The APID of this receiving Application.
+	 * @param setObjectId Object ID of the distributor itself
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
+	 */
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
+protected:
+	/**
+	 * This attribute contains the class, that performs a formal packet check.
+	 */
+	TcPacketCheck checker;
+	/**
+	 * With this class, verification messages are sent to the
+	 * TC Verification service.
+	 */
+	VerificationReporter verifyChannel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored currentPacket;
+	/**
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
+	 */
+	ReturnValue_t tcStatus;
+
+	const object_id_t packetSource;
+	/**
+	 * This method reads the packet service, checks if such a service is
+	 * registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification
+	 * messages.
+	 * @return Iterator to map entry of found service id
+	 * or iterator to @c map.end().
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index 7967a74e..5e27b35c 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,26 +1,26 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
-
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
- */
-class PUSDistributorIF {
-public:
-	/**
-	 * The empty virtual destructor.
-	 */
-	virtual ~PUSDistributorIF() {
-	}
-/**
- * With this method, Services can register themselves at the PUS Distributor.
- * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
- */
-	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
-};
-
-#endif /* PUSDISTRIBUTORIF_H_ */
+#ifndef PUSDISTRIBUTORIF_H_
+#define PUSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * This interface allows PUS Services to register themselves at a PUS Distributor.
+ * \ingroup tc_distribution
+ */
+class PUSDistributorIF {
+public:
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~PUSDistributorIF() {
+	}
+/**
+ * With this method, Services can register themselves at the PUS Distributor.
+ * @param service A pointer to the registering Service.
+ * @return	- \c RETURN_OK on success,
+ * 			- \c RETURN_FAILED on failure.
+ */
+	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
+};
+
+#endif /* PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 45a20fd9..b0354558 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,54 +1,54 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
-}
-
-TcDistributor::~TcDistributor() {
-	QueueFactory::instance()->deleteMessageQueue(tcQueue);
-}
-
-ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
-	ReturnValue_t status = RETURN_OK;
-	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
-			status = tcQueue->receiveMessage(&currentMessage)) {
-		status = handlePacket();
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return RETURN_OK;
-	} else {
-		return status;
-	}
-}
-
-ReturnValue_t TcDistributor::handlePacket() {
-
-	TcMqMapIter queueMapIt = this->selectDestination();
-	ReturnValue_t returnValue = RETURN_FAILED;
-	if (queueMapIt != this->queueMap.end()) {
-		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
-				&this->currentMessage);
-	}
-	return this->callbackAfterSending(returnValue);
-}
-
-void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
-	}
-	sif::debug << std::dec;
-
-}
-
-ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-	return RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+TcDistributor::TcDistributor(object_id_t set_object_id) :
+		SystemObject(set_object_id), tcQueue(NULL) {
+	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+}
+
+TcDistributor::~TcDistributor() {
+	QueueFactory::instance()->deleteMessageQueue(tcQueue);
+}
+
+ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
+	ReturnValue_t status = RETURN_OK;
+	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue->receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	TcMqMapIter queueMapIt = this->selectDestination();
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if (queueMapIt != this->queueMap.end()) {
+		returnValue = this->tcQueue->sendMessage(queueMapIt->second,
+				&this->currentMessage);
+	}
+	return this->callbackAfterSending(returnValue);
+}
+
+void TcDistributor::print() {
+	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+			<< std::endl;
+	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
+			it++) {
+		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+				<< std::endl;
+	}
+	sif::debug << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 987f2eaa..95b7d25b 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,120 +1,120 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/MessageQueueIF.h"
-#include <map>
-
-/**
- * @defgroup tc_distribution Telecommand Distribution
- * All classes associated with Routing and Distribution of Telecommands
- * belong to this group.
- */
-
-
-/**
- * This is the base class to implement distributors for Space Packets.
- * Typically, the distribution is required to forward Telecommand packets
- * over the satellite applications and services. The class receives
- * Space Packets over a message queue and holds a map that links other
- * message queue ids to some identifier. The process of unpacking the
- * destination information from the packet is handled by the child class
- * implementations.
- * @ingroup tc_distribution
- */
-class TcDistributor : public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
-	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	/**
-	 * Within the default constructor, the SystemObject id is set and the
-	 * message queue is initialized.
-	 * Filling the map is under control of the child classes.
-	 * @param set_object_id	This id is assigned to the distributor
-	 * 		implementation.
-	 */
-	TcDistributor( object_id_t set_object_id );
-	/**
-	 * The destructor is empty, the message queues are not in the vicinity of
-	 * this class.
-	 */
-	virtual ~TcDistributor();
-	/**
-	 * The method is called cyclically and fetches new incoming packets from
-	 * the message queue.
-	 * In case a new packet is found, it calls the handlePacket method to deal
-	 * with distribution.
-	 * @return The error code of the message queue call.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode);
-	/**
-	 * A simple debug print, that prints all distribution information stored in
-	 * queueMap.
-	 */
-	void print();
-
-protected:
-	/**
-	 * This is the receiving queue for incoming Telecommands.
-	 * The child classes must make its queue id public.
-	 */
-	MessageQueueIF* tcQueue;
-	/**
-	 * The last received incoming packet information is stored in this
-	 * member.
-	 * As different child classes unpack the incoming packet differently
-	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
-	 * is not tried to unpack the packet information within this class.
-	 */
-	TmTcMessage currentMessage;
-	/**
-	 * The map that links certain packet information to a destination.
-	 * The packet information may be the APID of the packet or the service
-	 * identifier. Filling of the map is under control of the different child
-	 * classes.
-	 */
-	TcMessageQueueMap queueMap;
-	/**
-	 * This method shall unpack the routing information from the incoming
-	 * packet and select the map entry which represents the packet's target.
-	 * @return	An iterator to the map element to forward to or queuMap.end().
-	 */
-	virtual TcMqMapIter selectDestination() = 0;
-	/**
-	 * The handlePacket method calls the child class's selectDestination method
-	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
-	 * 		destination was found.
-	 */
-	ReturnValue_t handlePacket();
-	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
-	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
-	 */
-	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
-
-private:
-	/**
-	 * This constant sets the maximum number of packets distributed per call.
-	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
-};
-
-
-#endif /* TCDISTRIBUTOR_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
+ */
+
+
+/**
+ * This is the base class to implement distributors for Space Packets.
+ * Typically, the distribution is required to forward Telecommand packets
+ * over the satellite applications and services. The class receives
+ * Space Packets over a message queue and holds a map that links other
+ * message queue ids to some identifier. The process of unpacking the
+ * destination information from the packet is handled by the child class
+ * implementations.
+ * @ingroup tc_distribution
+ */
+class TcDistributor : public SystemObject,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	/**
+	 * Within the default constructor, the SystemObject id is set and the
+	 * message queue is initialized.
+	 * Filling the map is under control of the child classes.
+	 * @param set_object_id	This id is assigned to the distributor
+	 * 		implementation.
+	 */
+	TcDistributor( object_id_t set_object_id );
+	/**
+	 * The destructor is empty, the message queues are not in the vicinity of
+	 * this class.
+	 */
+	virtual ~TcDistributor();
+	/**
+	 * The method is called cyclically and fetches new incoming packets from
+	 * the message queue.
+	 * In case a new packet is found, it calls the handlePacket method to deal
+	 * with distribution.
+	 * @return The error code of the message queue call.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode);
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	TcMessageQueueMap queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual TcMqMapIter selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+};
+
+
+#endif /* TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 98dfaeb8..4701ce23 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,37 +1,37 @@
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/TcPacketCheck.h"
-#include "../tmtcservices/VerificationCodes.h"
-
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
-}
-
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
-	if ( calculated_crc != 0 ) {
-		return INCORRECT_CHECKSUM;
-	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
-	if ( condition ) {
-		return INCORRECT_PRIMARY_HEADER;
-	}
-	if ( current_packet->getAPID() != this->apid )
-		return ILLEGAL_APID;
-
-	if ( !current_packet->isSizeCorrect() ) {
-		return INCOMPLETE_PACKET;
-	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
-	if ( condition ) {
-		return INCORRECT_SECONDARY_HEADER;
-	}
-	return RETURN_OK;
-}
-
-uint16_t TcPacketCheck::getApid() const {
-	return apid;
-}
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/TcPacketCheck.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = !(current_packet->hasSecondaryHeader()) ||
+			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			!(current_packet->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( current_packet->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( !current_packet->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 9fe1db72..4ba269f5 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,59 +1,59 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/PusVerificationReport.h"
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
- */
-class TcPacketCheck : public HasReturnvaluesIF {
-protected:
-	/**
-	 * Describes the version number a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
-	/**
-	 * Describes the secondary header a packet must have to pass.
-	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-	/**
-	 * Describes the TC Packet PUS Version Number a packet must have to pass.
-	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
-	/**
-	 * The packet id each correct packet should have.
-	 * It is composed of the APID and some static fields.
-	 */
-	uint16_t apid;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
-	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
-	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
-	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
-	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
-	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
-	/**
-	 * The constructor only sets the APID attribute.
-	 * @param set_apid The APID to set.
-	 */
-	TcPacketCheck( uint16_t set_apid );
-	/**
-	 * This is the actual method to formally check a certain Telecommand Packet.
-	 * The packet's Application Data can not be checked here.
-	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
-	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
-
-	uint16_t getApid() const;
-};
-
-
-#endif /* TCPACKETCHECK_H_ */
+#ifndef TCPACKETCHECK_H_
+#define TCPACKETCHECK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * \ingroup tc_distribution
+ */
+class TcPacketCheck : public HasReturnvaluesIF {
+protected:
+	/**
+	 * Describes the version number a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static const uint8_t PUS_VERSION_NUMBER = 1;
+	/**
+	 * The packet id each correct packet should have.
+	 * It is composed of the APID and some static fields.
+	 */
+	uint16_t apid;
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t set_apid );
+	/**
+	 * This is the actual method to formally check a certain Telecommand Packet.
+	 * The packet's Application Data can not be checked here.
+	 * @param current_packet The packt to check
+	 * @return	- \c RETURN_OK on success.
+	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- \c ILLEGAL_APID if APID does not match.
+	 */
+	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* TCPACKETCHECK_H_ */
diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp
index 5d821367..40b305af 100644
--- a/thermal/AbstractTemperatureSensor.cpp
+++ b/thermal/AbstractTemperatureSensor.cpp
@@ -1,70 +1,70 @@
-#include "AbstractTemperatureSensor.h"
-#include "../ipc/QueueFactory.h"
-
-AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
-		ThermalModuleIF *thermalModule) :
-		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
-				setObjectid), parameterHelper(this) {
-	if (thermalModule != NULL) {
-		thermalModule->registerSensor(this);
-	}
-	commandQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-AbstractTemperatureSensor::~AbstractTemperatureSensor() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t AbstractTemperatureSensor::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = parameterHelper.initialize();
-	return result;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	doChildOperation();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
-	handleCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void AbstractTemperatureSensor::handleCommandQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		result = parameterHelper.handleParameterMessage(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-}
-
-ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
-	healthHelper.setHealth(health);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
-	return healthHelper.getHealth();
-}
+#include "AbstractTemperatureSensor.h"
+#include "../ipc/QueueFactory.h"
+
+AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
+		ThermalModuleIF *thermalModule) :
+		SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
+				setObjectid), parameterHelper(this) {
+	if (thermalModule != NULL) {
+		thermalModule->registerSensor(this);
+	}
+	commandQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+AbstractTemperatureSensor::~AbstractTemperatureSensor() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t AbstractTemperatureSensor::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	result = parameterHelper.initialize();
+	return result;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	doChildOperation();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
+	handleCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void AbstractTemperatureSensor::handleCommandQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		result = parameterHelper.handleParameterMessage(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		command.setToUnknownCommand();
+		commandQueue->reply(&command);
+	}
+}
+
+ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
+	healthHelper.setHealth(health);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
+	return healthHelper.getHealth();
+}
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index 462b41f2..cc064ce4 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -1,64 +1,64 @@
-#ifndef ABSTRACTSENSOR_H_
-#define ABSTRACTSENSOR_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../ipc/MessageQueueIF.h"
-#include "ThermalModuleIF.h"
-#include "tcsDefinitions.h"
-
-/**
- * @defgroup thermal Thermal Components
- * @brief Contains all components related to thermal tasks (sensors, heaters)
- */
-
-/**
- * @brief Base class for Temperature Sensor, implements all important interfaces.
- *        Please use the TemperatureSensor class to implement the actual sensors.
- * @ingroup thermal
- */
-class AbstractTemperatureSensor: public HasHealthIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public ReceivesParameterMessagesIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
-
-	static constexpr float ZERO_KELVIN_C = -273.15;
-	AbstractTemperatureSensor(object_id_t setObjectid,
-			ThermalModuleIF *thermalModule);
-	virtual ~AbstractTemperatureSensor();
-
-	virtual MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t performHealthOp();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	virtual float getTemperature() = 0;
-	virtual bool isValid() = 0;
-
-	virtual void resetOldState() = 0;
-
-	ReturnValue_t setHealth(HealthState health);
-	HasHealthIF::HealthState getHealth();
-protected:
-	MessageQueueIF* commandQueue;
-	HealthHelper healthHelper;
-	ParameterHelper parameterHelper;
-
-	virtual void doChildOperation() = 0;
-
-	void handleCommandQueue();
-};
-
-#endif /* ABSTRACTSENSOR_H_ */
+#ifndef ABSTRACTSENSOR_H_
+#define ABSTRACTSENSOR_H_
+
+#include "../health/HasHealthIF.h"
+#include "../health/HealthHelper.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../parameters/ParameterHelper.h"
+#include "../ipc/MessageQueueIF.h"
+#include "ThermalModuleIF.h"
+#include "tcsDefinitions.h"
+
+/**
+ * @defgroup thermal Thermal Components
+ * @brief Contains all components related to thermal tasks (sensors, heaters)
+ */
+
+/**
+ * @brief Base class for Temperature Sensor, implements all important interfaces.
+ *        Please use the TemperatureSensor class to implement the actual sensors.
+ * @ingroup thermal
+ */
+class AbstractTemperatureSensor: public HasHealthIF,
+		public SystemObject,
+		public ExecutableObjectIF,
+		public ReceivesParameterMessagesIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+
+	static constexpr float ZERO_KELVIN_C = -273.15;
+	AbstractTemperatureSensor(object_id_t setObjectid,
+			ThermalModuleIF *thermalModule);
+	virtual ~AbstractTemperatureSensor();
+
+	virtual MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t performHealthOp();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	virtual float getTemperature() = 0;
+	virtual bool isValid() = 0;
+
+	virtual void resetOldState() = 0;
+
+	ReturnValue_t setHealth(HealthState health);
+	HasHealthIF::HealthState getHealth();
+protected:
+	MessageQueueIF* commandQueue;
+	HealthHelper healthHelper;
+	ParameterHelper parameterHelper;
+
+	virtual void doChildOperation() = 0;
+
+	void handleCommandQueue();
+};
+
+#endif /* ABSTRACTSENSOR_H_ */
diff --git a/thermal/AcceptsThermalMessagesIF.h b/thermal/AcceptsThermalMessagesIF.h
index 9fe03499..5fbd6bb3 100644
--- a/thermal/AcceptsThermalMessagesIF.h
+++ b/thermal/AcceptsThermalMessagesIF.h
@@ -1,22 +1,22 @@
-/**
- * \file AcceptsThermalMessagesIF.h
- *
- * \date 16.02.2020
- */
-
-#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsThermalMessagesIF {
-public:
-
-	/**
-	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
-	 */
-	virtual ~AcceptsThermalMessagesIF() { }
-
-	virtual MessageQueueId_t getReceptionQueue() const = 0;
-};
-
-#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */
+/**
+ * \file AcceptsThermalMessagesIF.h
+ *
+ * \date 16.02.2020
+ */
+
+#ifndef FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#define FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsThermalMessagesIF {
+public:
+
+	/**
+	 * @brief	This is the empty virtual destructor as required for C++ interfaces.
+	 */
+	virtual ~AcceptsThermalMessagesIF() { }
+
+	virtual MessageQueueId_t getReceptionQueue() const = 0;
+};
+
+#endif /* FRAMEWORK_THERMAL_ACCEPTSTHERMALMESSAGESIF_H_ */
diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
index 87a6972e..8093711d 100644
--- a/thermal/CoreComponent.h
+++ b/thermal/CoreComponent.h
@@ -1,96 +1,96 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../thermal/ThermalModule.h"
-#include "../thermal/ThermalMonitor.h"
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
+#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../thermal/ThermalModule.h"
+#include "../thermal/ThermalMonitor.h"
+
+// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
+class CoreComponent: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
+			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
+			uint32_t requestPoolId, GlobDataSet *dataSet,
+			AbstractTemperatureSensor *sensor,
+			AbstractTemperatureSensor *firstRedundantSensor,
+			AbstractTemperatureSensor *secondRedundantSensor,
+			ThermalModuleIF *thermalModule, Parameters parameters,
+			Priority priority, StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	virtual ~CoreComponent();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor;
+	AbstractTemperatureSensor *firstRedundantSensor;
+	AbstractTemperatureSensor *secondRedundantSensor;
+	ThermalModuleIF *thermalModule;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating;
+
+	bool isSafeComponent;
+
+	float minTemp;
+
+	float maxTemp;
+
+	Parameters parameters;
+
+	ThermalMonitor temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 94dd91b5..2bee47f1 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -1,350 +1,350 @@
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
-#include "Heater.h"
-
-#include "../power/Fuse.h"
-#include "../ipc/QueueFactory.h"
-
-Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
-		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
-				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
-				false), timedOut(false), reactedToBeingFaulty(false), passive(
-				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
-				this), lastAction(CLEAR) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Heater::~Heater() {
-	QueueFactory::instance()->deleteMessageQueue(eventQueue);
-}
-
-ReturnValue_t Heater::set() {
-	passive = false;
-	//wait for clear before doing anything
-	if (internalState == STATE_WAIT) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(SET);
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		} else {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	} else {
-		if (healthHelper.healthTable->isFaulty(getObjectId())) {
-			if (!reactedToBeingFaulty) {
-				reactedToBeingFaulty = true;
-				doAction(CLEAR);
-			}
-		}
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-void Heater::clear(bool passive) {
-	this->passive = passive;
-	//Force switching off
-	if (internalState == STATE_WAIT) {
-		internalState = STATE_ON;
-	}
-	if (healthHelper.healthTable->isHealthy(getObjectId())) {
-		doAction(CLEAR);
-	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
-		if (!reactedToBeingFaulty) {
-			reactedToBeingFaulty = true;
-			doAction(CLEAR);
-		}
-	}
-}
-
-void Heater::doAction(Action action) {
-	//only act if we are not in the right state or in a transition
-	if (action == SET) {
-		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			internalState = STATE_WAIT_FOR_SWITCHES_ON;
-			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
-			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
-		}
-	} else { //clear
-		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
-				|| (internalState == STATE_EXTERNAL_CONTROL)) {
-			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-			powerSwitcher->sendSwitchCommand(switch0,
-					PowerSwitchIF::SWITCH_OFF);
-			powerSwitcher->sendSwitchCommand(switch1,
-					PowerSwitchIF::SWITCH_OFF);
-		}
-	}
-}
-
-void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
-	this->powerSwitcher = powerSwitch;
-}
-
-ReturnValue_t Heater::performOperation(uint8_t opCode) {
-	handleQueue();
-	handleEventQueue();
-
-	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
-		reactedToBeingFaulty = false;
-	}
-
-	switch (internalState) {
-	case STATE_ON:
-		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
-				|| (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_OFF)) {
-			//switch went off on its own
-			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_OFF:
-		//check if heater is on, ie both switches are on
-		//if so, just command it to off, to resolve the situation or force a switch stayed on event
-		//But, only do anything if not already faulty (state off is the stable point for being faulty)
-		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
-				&& (powerSwitcher->getSwitchState(switch0)
-						== PowerSwitchIF::SWITCH_ON)
-				&& (powerSwitcher->getSwitchState(switch1)
-						== PowerSwitchIF::SWITCH_ON)) {
-			//do not trigger FD events when under external control
-			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
-				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
-				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
-				powerSwitcher->sendSwitchCommand(switch0,
-						PowerSwitchIF::SWITCH_OFF);
-				powerSwitcher->sendSwitchCommand(switch1,
-						PowerSwitchIF::SWITCH_OFF);
-			} else {
-				internalState = STATE_EXTERNAL_CONTROL;
-			}
-		}
-		break;
-	case STATE_PASSIVE:
-		break;
-	case STATE_WAIT_FOR_SWITCHES_ON:
-		if (switchCountdown.hasTimedOut()) {
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_OFF)
-					|| (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_OFF)) {
-				triggerEvent(HEATER_STAYED_OFF);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_ON);
-				internalState = STATE_ON;
-			}
-		}
-		break;
-	case STATE_WAIT_FOR_SWITCHES_OFF:
-		if (switchCountdown.hasTimedOut()) {
-			//only check for both being on (ie heater still on)
-			if ((powerSwitcher->getSwitchState(switch0)
-					== PowerSwitchIF::SWITCH_ON)
-					&& (powerSwitcher->getSwitchState(switch1)
-							== PowerSwitchIF::SWITCH_ON)) {
-				if (healthHelper.healthTable->isFaulty(getObjectId())) {
-					if (passive) {
-						internalState = STATE_PASSIVE;
-					} else {
-						internalState = STATE_OFF; //just accept it
-					}
-					triggerEvent(HEATER_ON); //but throw an event to make it more visible
-					break;
-				}
-				triggerEvent(HEATER_STAYED_ON);
-				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
-			} else {
-				triggerEvent(HEATER_OFF);
-				if (passive) {
-					internalState = STATE_PASSIVE;
-				} else {
-					internalState = STATE_OFF;
-				}
-			}
-		}
-		break;
-	default:
-		break;
-	}
-
-	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
-			&& (powerSwitcher->getSwitchState(switch1)
-					== PowerSwitchIF::SWITCH_ON)) {
-		if (wasOn) {
-			if (heaterOnCountdown.hasTimedOut()) {
-				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
-				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
-				//it will be ok. whatcouldpossiblygowrongâ„¢
-				if (!timedOut) {
-					triggerEvent(HEATER_TIMEOUT);
-					timedOut = true;
-				}
-			}
-		} else {
-			wasOn = true;
-			heaterOnCountdown.resetTimer();
-			timedOut = false;
-		}
-	} else {
-		wasOn = false;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::setSwitch(uint8_t number, ReturnValue_t state,
-		uint32_t* uptimeOfSwitching) {
-	if (powerSwitcher == NULL) {
-		return;
-	}
-	if (powerSwitcher->getSwitchState(number) == state) {
-		*uptimeOfSwitching = INVALID_UPTIME;
-	} else {
-		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
-			powerSwitcher->sendSwitchCommand(number, state);
-			Clock::getUptime(uptimeOfSwitching);
-		} else {
-			uint32_t currentUptime;
-			Clock::getUptime(&currentUptime);
-			if (currentUptime - *uptimeOfSwitching
-					> powerSwitcher->getSwitchDelayMs()) {
-				*uptimeOfSwitching = INVALID_UPTIME;
-				if (healthHelper.healthTable->isHealthy(getObjectId())) {
-					if (state == PowerSwitchIF::SWITCH_ON) {
-						triggerEvent(HEATER_STAYED_OFF);
-					} else {
-						triggerEvent(HEATER_STAYED_ON);
-					}
-				}
-				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
-			}
-		}
-	}
-}
-
-MessageQueueId_t Heater::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-ReturnValue_t Heater::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-			objects::EVENT_MANAGER);
-	if (manager == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	result = manager->registerListener(eventQueue->getId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
-			DeviceHandlerFailureIsolation::powerConfirmationId);
-	if (pcdu == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	pcduQueueId = pcdu->getEventReceptionQueue();
-
-	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
-			getObjectId());
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = parameterHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = healthHelper.initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = commandQueue->receiveMessage(&command);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		parameterHelper.handleParameterMessage(&command);
-	}
-}
-
-ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
-		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-		uint16_t startAtIndex) {
-	if (domainId != DOMAIN_ID_BASE) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(heaterOnCountdown.timeout);
-		break;
-	default:
-		return INVALID_MATRIX_ID;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void Heater::handleEventQueue() {
-	EventMessage event;
-	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
-			result == HasReturnvaluesIF::RETURN_OK;
-			result = eventQueue->receiveMessage(&event)) {
-		switch (event.getMessageId()) {
-		case EventMessage::EVENT_MESSAGE:
-			switch (event.getEvent()) {
-			case Fuse::FUSE_WENT_OFF:
-			case HEATER_STAYED_OFF:
-			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
-				if (healthHelper.healthTable->isCommandable(getObjectId())) {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			case PowerSwitchIF::SWITCH_WENT_OFF:
-				internalState = STATE_WAIT;
-				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
-				if (pcduQueueId != 0) {
-					eventQueue->sendMessage(pcduQueueId, &event);
-				} else {
-					healthHelper.setHealth(HasHealthIF::FAULTY);
-					internalState = STATE_FAULTY;
-				}
-				break;
-			default:
-				return;
-			}
-			break;
-		case EventMessage::YOUR_FAULT:
-			healthHelper.setHealth(HasHealthIF::FAULTY);
-			internalState = STATE_FAULTY;
-			break;
-		case EventMessage::MY_FAULT:
-			//do nothing, we are already in STATE_WAIT and wait for a clear()
-			break;
-		default:
-			return;
-		}
-	}
-}
+#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "Heater.h"
+
+#include "../power/Fuse.h"
+#include "../ipc/QueueFactory.h"
+
+Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
+		HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
+				NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
+				false), timedOut(false), reactedToBeingFaulty(false), passive(
+				false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
+				this), lastAction(CLEAR) {
+	eventQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+Heater::~Heater() {
+	QueueFactory::instance()->deleteMessageQueue(eventQueue);
+}
+
+ReturnValue_t Heater::set() {
+	passive = false;
+	//wait for clear before doing anything
+	if (internalState == STATE_WAIT) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(SET);
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		} else {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
+	} else {
+		if (healthHelper.healthTable->isFaulty(getObjectId())) {
+			if (!reactedToBeingFaulty) {
+				reactedToBeingFaulty = true;
+				doAction(CLEAR);
+			}
+		}
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
+void Heater::clear(bool passive) {
+	this->passive = passive;
+	//Force switching off
+	if (internalState == STATE_WAIT) {
+		internalState = STATE_ON;
+	}
+	if (healthHelper.healthTable->isHealthy(getObjectId())) {
+		doAction(CLEAR);
+	} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
+		if (!reactedToBeingFaulty) {
+			reactedToBeingFaulty = true;
+			doAction(CLEAR);
+		}
+	}
+}
+
+void Heater::doAction(Action action) {
+	//only act if we are not in the right state or in a transition
+	if (action == SET) {
+		if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			internalState = STATE_WAIT_FOR_SWITCHES_ON;
+			powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
+			powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
+		}
+	} else { //clear
+		if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
+				|| (internalState == STATE_EXTERNAL_CONTROL)) {
+			internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+			switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+			powerSwitcher->sendSwitchCommand(switch0,
+					PowerSwitchIF::SWITCH_OFF);
+			powerSwitcher->sendSwitchCommand(switch1,
+					PowerSwitchIF::SWITCH_OFF);
+		}
+	}
+}
+
+void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
+	this->powerSwitcher = powerSwitch;
+}
+
+ReturnValue_t Heater::performOperation(uint8_t opCode) {
+	handleQueue();
+	handleEventQueue();
+
+	if (!healthHelper.healthTable->isFaulty(getObjectId())) {
+		reactedToBeingFaulty = false;
+	}
+
+	switch (internalState) {
+	case STATE_ON:
+		if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
+				|| (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_OFF)) {
+			//switch went off on its own
+			//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_OFF:
+		//check if heater is on, ie both switches are on
+		//if so, just command it to off, to resolve the situation or force a switch stayed on event
+		//But, only do anything if not already faulty (state off is the stable point for being faulty)
+		if ((!healthHelper.healthTable->isFaulty(getObjectId()))
+				&& (powerSwitcher->getSwitchState(switch0)
+						== PowerSwitchIF::SWITCH_ON)
+				&& (powerSwitcher->getSwitchState(switch1)
+						== PowerSwitchIF::SWITCH_ON)) {
+			//do not trigger FD events when under external control
+			if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
+				internalState = STATE_WAIT_FOR_SWITCHES_OFF;
+				switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
+				powerSwitcher->sendSwitchCommand(switch0,
+						PowerSwitchIF::SWITCH_OFF);
+				powerSwitcher->sendSwitchCommand(switch1,
+						PowerSwitchIF::SWITCH_OFF);
+			} else {
+				internalState = STATE_EXTERNAL_CONTROL;
+			}
+		}
+		break;
+	case STATE_PASSIVE:
+		break;
+	case STATE_WAIT_FOR_SWITCHES_ON:
+		if (switchCountdown.hasTimedOut()) {
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_OFF)
+					|| (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_OFF)) {
+				triggerEvent(HEATER_STAYED_OFF);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_ON);
+				internalState = STATE_ON;
+			}
+		}
+		break;
+	case STATE_WAIT_FOR_SWITCHES_OFF:
+		if (switchCountdown.hasTimedOut()) {
+			//only check for both being on (ie heater still on)
+			if ((powerSwitcher->getSwitchState(switch0)
+					== PowerSwitchIF::SWITCH_ON)
+					&& (powerSwitcher->getSwitchState(switch1)
+							== PowerSwitchIF::SWITCH_ON)) {
+				if (healthHelper.healthTable->isFaulty(getObjectId())) {
+					if (passive) {
+						internalState = STATE_PASSIVE;
+					} else {
+						internalState = STATE_OFF; //just accept it
+					}
+					triggerEvent(HEATER_ON); //but throw an event to make it more visible
+					break;
+				}
+				triggerEvent(HEATER_STAYED_ON);
+				internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
+			} else {
+				triggerEvent(HEATER_OFF);
+				if (passive) {
+					internalState = STATE_PASSIVE;
+				} else {
+					internalState = STATE_OFF;
+				}
+			}
+		}
+		break;
+	default:
+		break;
+	}
+
+	if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
+			&& (powerSwitcher->getSwitchState(switch1)
+					== PowerSwitchIF::SWITCH_ON)) {
+		if (wasOn) {
+			if (heaterOnCountdown.hasTimedOut()) {
+				//SHOULDDO this means if a heater fails in single mode, the timeout will start again
+				//I am not sure if this is a bug, but atm I have no idea how to fix this and think
+				//it will be ok. whatcouldpossiblygowrongâ„¢
+				if (!timedOut) {
+					triggerEvent(HEATER_TIMEOUT);
+					timedOut = true;
+				}
+			}
+		} else {
+			wasOn = true;
+			heaterOnCountdown.resetTimer();
+			timedOut = false;
+		}
+	} else {
+		wasOn = false;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::setSwitch(uint8_t number, ReturnValue_t state,
+		uint32_t* uptimeOfSwitching) {
+	if (powerSwitcher == NULL) {
+		return;
+	}
+	if (powerSwitcher->getSwitchState(number) == state) {
+		*uptimeOfSwitching = INVALID_UPTIME;
+	} else {
+		if ((*uptimeOfSwitching == INVALID_UPTIME)) {
+			powerSwitcher->sendSwitchCommand(number, state);
+			Clock::getUptime(uptimeOfSwitching);
+		} else {
+			uint32_t currentUptime;
+			Clock::getUptime(&currentUptime);
+			if (currentUptime - *uptimeOfSwitching
+					> powerSwitcher->getSwitchDelayMs()) {
+				*uptimeOfSwitching = INVALID_UPTIME;
+				if (healthHelper.healthTable->isHealthy(getObjectId())) {
+					if (state == PowerSwitchIF::SWITCH_ON) {
+						triggerEvent(HEATER_STAYED_OFF);
+					} else {
+						triggerEvent(HEATER_STAYED_ON);
+					}
+				}
+				//SHOULDDO MiniOps during switch timeout leads to a faulty switch
+			}
+		}
+	}
+}
+
+MessageQueueId_t Heater::getCommandQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Heater::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+			objects::EVENT_MANAGER);
+	if (manager == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	result = manager->registerListener(eventQueue->getId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+			DeviceHandlerFailureIsolation::powerConfirmationId);
+	if (pcdu == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	pcduQueueId = pcdu->getEventReceptionQueue();
+
+	result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
+			getObjectId());
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = parameterHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	result = healthHelper.initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleQueue() {
+	CommandMessage command;
+	ReturnValue_t result = commandQueue->receiveMessage(&command);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		result = healthHelper.handleHealthCommand(&command);
+		if (result == HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		parameterHelper.handleParameterMessage(&command);
+	}
+}
+
+ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
+		ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+		uint16_t startAtIndex) {
+	if (domainId != DOMAIN_ID_BASE) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(heaterOnCountdown.timeout);
+		break;
+	default:
+		return INVALID_MATRIX_ID;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Heater::handleEventQueue() {
+	EventMessage event;
+	for (ReturnValue_t result = eventQueue->receiveMessage(&event);
+			result == HasReturnvaluesIF::RETURN_OK;
+			result = eventQueue->receiveMessage(&event)) {
+		switch (event.getMessageId()) {
+		case EventMessage::EVENT_MESSAGE:
+			switch (event.getEvent()) {
+			case Fuse::FUSE_WENT_OFF:
+			case HEATER_STAYED_OFF:
+			case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
+				if (healthHelper.healthTable->isCommandable(getObjectId())) {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			case PowerSwitchIF::SWITCH_WENT_OFF:
+				internalState = STATE_WAIT;
+				event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
+				if (pcduQueueId != 0) {
+					eventQueue->sendMessage(pcduQueueId, &event);
+				} else {
+					healthHelper.setHealth(HasHealthIF::FAULTY);
+					internalState = STATE_FAULTY;
+				}
+				break;
+			default:
+				return;
+			}
+			break;
+		case EventMessage::YOUR_FAULT:
+			healthHelper.setHealth(HasHealthIF::FAULTY);
+			internalState = STATE_FAULTY;
+			break;
+		case EventMessage::MY_FAULT:
+			//do nothing, we are already in STATE_WAIT and wait for a clear()
+			break;
+		default:
+			return;
+		}
+	}
+}
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 8121a774..63fe2066 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -1,90 +1,90 @@
-#ifndef FRAMEWORK_THERMAL_HEATER_H_
-#define FRAMEWORK_THERMAL_HEATER_H_
-
-#include "../devicehandlers/HealthDevice.h"
-#include "../parameters/ParameterHelper.h"
-#include "../power/PowerSwitchIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../timemanager/Countdown.h"
-#include <stdint.h>
-//class RedundantHeater;
-
-class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
-	friend class RedundantHeater;
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
-
-	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
-	virtual ~Heater();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	ReturnValue_t initialize();
-
-	ReturnValue_t set();
-	void clear(bool passive);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-	static const uint32_t INVALID_UPTIME = 0;
-
-	enum InternalState {
-		STATE_ON,
-		STATE_OFF,
-		STATE_PASSIVE,
-		STATE_WAIT_FOR_SWITCHES_ON,
-		STATE_WAIT_FOR_SWITCHES_OFF,
-		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
-		STATE_FAULTY,
-		STATE_WAIT, //used when waiting for system to recover from miniops
-		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
-							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
-	} internalState;
-
-	PowerSwitchIF *powerSwitcher;
-	MessageQueueId_t pcduQueueId;
-
-	uint8_t switch0;
-	uint8_t switch1;
-
-	bool wasOn;
-
-	bool timedOut;
-
-	bool reactedToBeingFaulty;
-
-	bool passive;
-
-	MessageQueueIF* eventQueue;
-	Countdown heaterOnCountdown;
-	Countdown switchCountdown;
-	ParameterHelper parameterHelper;
-
-	enum Action {
-		SET, CLEAR
-	} lastAction;
-
-	void doAction(Action action);
-
-	void setSwitch(uint8_t number, ReturnValue_t state,
-			uint32_t *upTimeOfSwitching);
-
-	void handleQueue();
-
-	void handleEventQueue();
-};
-
-#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
+#ifndef FRAMEWORK_THERMAL_HEATER_H_
+#define FRAMEWORK_THERMAL_HEATER_H_
+
+#include "../devicehandlers/HealthDevice.h"
+#include "../parameters/ParameterHelper.h"
+#include "../power/PowerSwitchIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../timemanager/Countdown.h"
+#include <stdint.h>
+//class RedundantHeater;
+
+class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
+	friend class RedundantHeater;
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
+	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+
+	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
+	virtual ~Heater();
+
+	ReturnValue_t performOperation(uint8_t opCode);
+
+	ReturnValue_t initialize();
+
+	ReturnValue_t set();
+	void clear(bool passive);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+	MessageQueueId_t getCommandQueue() const;
+
+	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+	static const uint32_t INVALID_UPTIME = 0;
+
+	enum InternalState {
+		STATE_ON,
+		STATE_OFF,
+		STATE_PASSIVE,
+		STATE_WAIT_FOR_SWITCHES_ON,
+		STATE_WAIT_FOR_SWITCHES_OFF,
+		STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
+		STATE_FAULTY,
+		STATE_WAIT, //used when waiting for system to recover from miniops
+		STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
+							   //if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
+	} internalState;
+
+	PowerSwitchIF *powerSwitcher;
+	MessageQueueId_t pcduQueueId;
+
+	uint8_t switch0;
+	uint8_t switch1;
+
+	bool wasOn;
+
+	bool timedOut;
+
+	bool reactedToBeingFaulty;
+
+	bool passive;
+
+	MessageQueueIF* eventQueue;
+	Countdown heaterOnCountdown;
+	Countdown switchCountdown;
+	ParameterHelper parameterHelper;
+
+	enum Action {
+		SET, CLEAR
+	} lastAction;
+
+	void doAction(Action action);
+
+	void setSwitch(uint8_t number, ReturnValue_t state,
+			uint32_t *upTimeOfSwitching);
+
+	void handleQueue();
+
+	void handleEventQueue();
+};
+
+#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h
index 4a82de07..76537542 100644
--- a/thermal/RedundantHeater.h
+++ b/thermal/RedundantHeater.h
@@ -1,50 +1,50 @@
-#ifndef REDUNDANTHEATER_H_
-#define REDUNDANTHEATER_H_
-
-#include "../thermal/Heater.h"
-
-class RedundantHeater {
-public:
-
-	struct Parameters {
-		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
-				uint8_t switch0Heater0, uint8_t switch1Heater0,
-				uint8_t switch0Heater1, uint8_t switch1Heater1) :
-				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
-				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
-				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
-		}
-
-		Parameters() :
-				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
-				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
-		}
-
-		uint32_t objectIdHeater0;
-		uint32_t objectIdHeater1;
-		uint8_t switch0Heater0;
-		uint8_t switch1Heater0;
-		uint8_t switch0Heater1;
-		uint8_t switch1Heater1;
-	};
-
-	RedundantHeater(Parameters parameters);
-	virtual ~RedundantHeater();
-
-	void performOperation(uint8_t opCode);
-
-	void triggerHeaterEvent(Event event);
-
-	void set(bool on, bool both, bool passive = false);
-
-	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
-
-protected:
-
-	Heater heater0;
-	Heater heater1;
-
-};
-
-#endif /* REDUNDANTHEATER_H_ */
-
+#ifndef REDUNDANTHEATER_H_
+#define REDUNDANTHEATER_H_
+
+#include "../thermal/Heater.h"
+
+class RedundantHeater {
+public:
+
+	struct Parameters {
+		Parameters(uint32_t objectIdHeater0, uint32_t objectIdHeater1,
+				uint8_t switch0Heater0, uint8_t switch1Heater0,
+				uint8_t switch0Heater1, uint8_t switch1Heater1) :
+				objectIdHeater0(objectIdHeater0), objectIdHeater1(objectIdHeater1),
+				switch0Heater0(switch0Heater0),switch1Heater0(switch1Heater0),
+				switch0Heater1(switch0Heater1), switch1Heater1(switch1Heater1) {
+		}
+
+		Parameters() :
+				objectIdHeater0(0), objectIdHeater1(0), switch0Heater0(0),
+				switch1Heater0(0), switch0Heater1(0), switch1Heater1(0) {
+		}
+
+		uint32_t objectIdHeater0;
+		uint32_t objectIdHeater1;
+		uint8_t switch0Heater0;
+		uint8_t switch1Heater0;
+		uint8_t switch0Heater1;
+		uint8_t switch1Heater1;
+	};
+
+	RedundantHeater(Parameters parameters);
+	virtual ~RedundantHeater();
+
+	void performOperation(uint8_t opCode);
+
+	void triggerHeaterEvent(Event event);
+
+	void set(bool on, bool both, bool passive = false);
+
+	void setPowerSwitcher(PowerSwitchIF *powerSwitch);
+
+protected:
+
+	Heater heater0;
+	Heater heater1;
+
+};
+
+#endif /* REDUNDANTHEATER_H_ */
+
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index cf2dffd4..9b4f0e60 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -1,222 +1,222 @@
-#ifndef TEMPERATURESENSOR_H_
-#define TEMPERATURESENSOR_H_
-
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../monitoring/LimitMonitor.h"
-
-/**
- * @brief 	This building block handles non-linear value conversion and
- * 			range checks for analog temperature sensors.
- * @details This class can be used to perform all necessary tasks for temperature sensors.
- *          A sensor can be instantiated by calling the constructor.
- *          The temperature is calculated from an input value with
- *			the calculateOutputTemperature() function. Range checking and
- *			limit monitoring is performed automatically.
- *			The inputType specifies the type of the raw input while the
- *			limitType specifies the type of the upper and lower limit to check against.
- * @ingroup thermal
- */
-
-template<typename inputType, typename limitType = inputType>
-class TemperatureSensor: public AbstractTemperatureSensor {
-public:
-	/**
-	 * This structure contains parameters required for range checking
-	 * and the conversion from the input value to the output temperature.
-	 * a, b and c can be any parameters required to calculate the output
-	 * temperature from the input value, depending on the formula used.
-	 *
-	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
-	 *
-	 * The lower and upper limits can be specified in any type, for example float for C values
-	 * or any other type for raw values.
-	 */
-	struct Parameters {
-		float a;
-		float b;
-		float c;
-		limitType lowerLimit;
-		limitType upperLimit;
-		float maxGradient;
-	};
-
-	/**
-	 * Forward declaration for explicit instantiation of used parameters.
-	 */
-	struct UsedParameters {
-		UsedParameters(Parameters parameters) :
-			a(parameters.a), b(parameters.b), c(parameters.c),
-			gradient(parameters.maxGradient) {}
-		float a;
-		float b;
-		float c;
-		float gradient;
-	};
-
-	/**
-	 * Instantiate Temperature Sensor Object.
-	 * @param setObjectid objectId of the sensor object
-	 * @param inputValue Input value which is converted to a temperature
-	 * @param poolVariable Pool Variable to store the temperature value
-	 * @param vectorIndex Vector Index for the sensor monitor
-	 * @param parameters Calculation parameters, temperature limits, gradient limit
-	 * @param datapoolId Datapool ID of the output temperature
-	 * @param outputSet Output dataset for the output temperature to fetch it with read()
-	 * @param thermalModule respective thermal module, if it has one
-	 */
-	TemperatureSensor(object_id_t setObjectid,
-			inputType *inputValue, PoolVariableIF *poolVariable,
-			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
-			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
-			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
-			inputValue(inputValue), poolVariable(poolVariable),
-			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
-			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
-				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
-				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
-				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
-			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
-	}
-
-
-protected:
-	/**
-	 * This formula is used to calculate the temperature from an input value
-	 * with an arbitrary type.
-	 * A default implementation is provided but can be replaced depending
-	 * on the required calculation.
-	 * @param inputTemperature
-	 * @return
-	 */
-	virtual float calculateOutputTemperature(inputType inputValue) {
-		return parameters.a * inputValue * inputValue
-				+ parameters.b * inputValue + parameters.c;
-	}
-
-
-private:
-	void setInvalid() {
-		outputTemperature = INVALID_TEMPERATURE;
-		outputTemperature.setValid(false);
-		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-		sensorMonitor.setToInvalid();
-	}
-protected:
-	static const int32_t INVALID_UPTIME = 0;
-
-	UsedParameters parameters;
-
-	inputType * inputValue;
-
-	PoolVariableIF *poolVariable;
-
-	gp_float_t outputTemperature;
-
-	LimitMonitor<limitType> sensorMonitor;
-
-	float oldTemperature;
-	timeval uptimeOfOldTemperature;
-
-	void doChildOperation() {
-		if (!poolVariable->isValid()
-				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
-			setInvalid();
-			return;
-		}
-
-		outputTemperature = calculateOutputTemperature(*inputValue);
-		outputTemperature.setValid(PoolVariableIF::VALID);
-
-		timeval uptime;
-		Clock::getUptime(&uptime);
-
-		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
-			//In theory, we could use an AbsValueMonitor to monitor the gradient.
-			//But this would require storing the maxGradient in DP and quite some overhead.
-			//The concept of delta limits is a bit strange anyway.
-			float deltaTime;
-			float deltaTemp;
-
-			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
-					- (uptimeOfOldTemperature.tv_sec
-							+ uptimeOfOldTemperature.tv_usec / 1000000.);
-			deltaTemp = oldTemperature - outputTemperature;
-			if (deltaTemp < 0) {
-				deltaTemp = -deltaTemp;
-			}
-			if (parameters.gradient < deltaTemp / deltaTime) {
-				triggerEvent(TEMP_SENSOR_GRADIENT);
-				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
-			}
-		}
-
-		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
-		sensorMonitor.doCheck(outputTemperature.value);
-
-		if (sensorMonitor.isOutOfLimits()) {
-			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
-			outputTemperature.setValid(PoolVariableIF::INVALID);
-			outputTemperature = INVALID_TEMPERATURE;
-		} else {
-			oldTemperature = outputTemperature;
-			uptimeOfOldTemperature = uptime;
-		}
-	}
-
-public:
-	float getTemperature() {
-		return outputTemperature;
-	}
-
-	bool isValid() {
-		return outputTemperature.isValid();
-	}
-
-	static const uint16_t ADDRESS_A = 0;
-	static const uint16_t ADDRESS_B = 1;
-	static const uint16_t ADDRESS_C = 2;
-	static const uint16_t ADDRESS_GRADIENT = 3;
-
-	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
-
-	static const uint8_t DOMAIN_ID_SENSOR = 1;
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) {
-		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
-				parameterWrapper, newValues, startAtIndex);
-		if (result != INVALID_DOMAIN_ID) {
-			return result;
-		}
-		if (domainId != this->DOMAIN_ID_BASE) {
-			return INVALID_DOMAIN_ID;
-		}
-		switch (parameterId) {
-		case ADDRESS_A:
-			parameterWrapper->set(parameters.a);
-			break;
-		case ADDRESS_B:
-			parameterWrapper->set(parameters.b);
-			break;
-		case ADDRESS_C:
-			parameterWrapper->set(parameters.c);
-			break;
-		case ADDRESS_GRADIENT:
-			parameterWrapper->set(parameters.gradient);
-			break;
-		default:
-			return INVALID_MATRIX_ID;
-		}
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	virtual void resetOldState() {
-		sensorMonitor.setToUnchecked();
-	}
-
-};
-
-#endif /* TEMPERATURESENSOR_H_ */
+#ifndef TEMPERATURESENSOR_H_
+#define TEMPERATURESENSOR_H_
+
+#include "../thermal/AbstractTemperatureSensor.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../monitoring/LimitMonitor.h"
+
+/**
+ * @brief 	This building block handles non-linear value conversion and
+ * 			range checks for analog temperature sensors.
+ * @details This class can be used to perform all necessary tasks for temperature sensors.
+ *          A sensor can be instantiated by calling the constructor.
+ *          The temperature is calculated from an input value with
+ *			the calculateOutputTemperature() function. Range checking and
+ *			limit monitoring is performed automatically.
+ *			The inputType specifies the type of the raw input while the
+ *			limitType specifies the type of the upper and lower limit to check against.
+ * @ingroup thermal
+ */
+
+template<typename inputType, typename limitType = inputType>
+class TemperatureSensor: public AbstractTemperatureSensor {
+public:
+	/**
+	 * This structure contains parameters required for range checking
+	 * and the conversion from the input value to the output temperature.
+	 * a, b and c can be any parameters required to calculate the output
+	 * temperature from the input value, depending on the formula used.
+	 *
+	 * The parameters a,b and c are used in the calculateOutputTemperature() call.
+	 *
+	 * The lower and upper limits can be specified in any type, for example float for C values
+	 * or any other type for raw values.
+	 */
+	struct Parameters {
+		float a;
+		float b;
+		float c;
+		limitType lowerLimit;
+		limitType upperLimit;
+		float maxGradient;
+	};
+
+	/**
+	 * Forward declaration for explicit instantiation of used parameters.
+	 */
+	struct UsedParameters {
+		UsedParameters(Parameters parameters) :
+			a(parameters.a), b(parameters.b), c(parameters.c),
+			gradient(parameters.maxGradient) {}
+		float a;
+		float b;
+		float c;
+		float gradient;
+	};
+
+	/**
+	 * Instantiate Temperature Sensor Object.
+	 * @param setObjectid objectId of the sensor object
+	 * @param inputValue Input value which is converted to a temperature
+	 * @param poolVariable Pool Variable to store the temperature value
+	 * @param vectorIndex Vector Index for the sensor monitor
+	 * @param parameters Calculation parameters, temperature limits, gradient limit
+	 * @param datapoolId Datapool ID of the output temperature
+	 * @param outputSet Output dataset for the output temperature to fetch it with read()
+	 * @param thermalModule respective thermal module, if it has one
+	 */
+	TemperatureSensor(object_id_t setObjectid,
+			inputType *inputValue, PoolVariableIF *poolVariable,
+			uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
+			GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
+			AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
+			inputValue(inputValue), poolVariable(poolVariable),
+			outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
+			sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
+				GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
+				DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
+				TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
+			oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
+	}
+
+
+protected:
+	/**
+	 * This formula is used to calculate the temperature from an input value
+	 * with an arbitrary type.
+	 * A default implementation is provided but can be replaced depending
+	 * on the required calculation.
+	 * @param inputTemperature
+	 * @return
+	 */
+	virtual float calculateOutputTemperature(inputType inputValue) {
+		return parameters.a * inputValue * inputValue
+				+ parameters.b * inputValue + parameters.c;
+	}
+
+
+private:
+	void setInvalid() {
+		outputTemperature = INVALID_TEMPERATURE;
+		outputTemperature.setValid(false);
+		uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+		sensorMonitor.setToInvalid();
+	}
+protected:
+	static const int32_t INVALID_UPTIME = 0;
+
+	UsedParameters parameters;
+
+	inputType * inputValue;
+
+	PoolVariableIF *poolVariable;
+
+	gp_float_t outputTemperature;
+
+	LimitMonitor<limitType> sensorMonitor;
+
+	float oldTemperature;
+	timeval uptimeOfOldTemperature;
+
+	void doChildOperation() {
+		if (!poolVariable->isValid()
+				|| !healthHelper.healthTable->isHealthy(getObjectId())) {
+			setInvalid();
+			return;
+		}
+
+		outputTemperature = calculateOutputTemperature(*inputValue);
+		outputTemperature.setValid(PoolVariableIF::VALID);
+
+		timeval uptime;
+		Clock::getUptime(&uptime);
+
+		if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
+			//In theory, we could use an AbsValueMonitor to monitor the gradient.
+			//But this would require storing the maxGradient in DP and quite some overhead.
+			//The concept of delta limits is a bit strange anyway.
+			float deltaTime;
+			float deltaTemp;
+
+			deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.)
+					- (uptimeOfOldTemperature.tv_sec
+							+ uptimeOfOldTemperature.tv_usec / 1000000.);
+			deltaTemp = oldTemperature - outputTemperature;
+			if (deltaTemp < 0) {
+				deltaTemp = -deltaTemp;
+			}
+			if (parameters.gradient < deltaTemp / deltaTime) {
+				triggerEvent(TEMP_SENSOR_GRADIENT);
+				//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
+			}
+		}
+
+		//Check is done against raw limits. SHOULDDO: Why? Using �C would be more easy to handle.
+		sensorMonitor.doCheck(outputTemperature.value);
+
+		if (sensorMonitor.isOutOfLimits()) {
+			uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
+			outputTemperature.setValid(PoolVariableIF::INVALID);
+			outputTemperature = INVALID_TEMPERATURE;
+		} else {
+			oldTemperature = outputTemperature;
+			uptimeOfOldTemperature = uptime;
+		}
+	}
+
+public:
+	float getTemperature() {
+		return outputTemperature;
+	}
+
+	bool isValid() {
+		return outputTemperature.isValid();
+	}
+
+	static const uint16_t ADDRESS_A = 0;
+	static const uint16_t ADDRESS_B = 1;
+	static const uint16_t ADDRESS_C = 2;
+	static const uint16_t ADDRESS_GRADIENT = 3;
+
+	static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
+
+	static const uint8_t DOMAIN_ID_SENSOR = 1;
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex) {
+		ReturnValue_t result = sensorMonitor.getParameter(domainId, parameterId,
+				parameterWrapper, newValues, startAtIndex);
+		if (result != INVALID_DOMAIN_ID) {
+			return result;
+		}
+		if (domainId != this->DOMAIN_ID_BASE) {
+			return INVALID_DOMAIN_ID;
+		}
+		switch (parameterId) {
+		case ADDRESS_A:
+			parameterWrapper->set(parameters.a);
+			break;
+		case ADDRESS_B:
+			parameterWrapper->set(parameters.b);
+			break;
+		case ADDRESS_C:
+			parameterWrapper->set(parameters.c);
+			break;
+		case ADDRESS_GRADIENT:
+			parameterWrapper->set(parameters.gradient);
+			break;
+		default:
+			return INVALID_MATRIX_ID;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	virtual void resetOldState() {
+		sensorMonitor.setToUnchecked();
+	}
+
+};
+
+#endif /* TEMPERATURESENSOR_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index f5f49ba1..522d4e44 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -1,114 +1,114 @@
-#ifndef THERMALCOMPONENTIF_H_
-#define THERMALCOMPONENTIF_H_
-
-#include "../events/Event.h"
-#include "../parameters/HasParametersIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-
-class ThermalComponentIF : public HasParametersIF {
-public:
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
-	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
-	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
-
-	enum State {
-		OUT_OF_RANGE_LOW = -2,
-		NON_OPERATIONAL_LOW = -1,
-		OPERATIONAL = 0,
-		NON_OPERATIONAL_HIGH = 1,
-		OUT_OF_RANGE_HIGH = 2,
-		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
-		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
-		OPERATIONAL_IGNORED = OPERATIONAL + 10,
-		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
-		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
-		UNKNOWN = 20
-	};
-
-	enum StateRequest {
-		STATE_REQUEST_HEATING = 4,
-		STATE_REQUEST_IGNORE = 3,
-		STATE_REQUEST_OPERATIONAL = 1,
-		STATE_REQUEST_NON_OPERATIONAL = 0
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum Priority {
-		SAFE = 0,             //!< SAFE
-		IDLE,                 //!< IDLE
-		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
-	};
-
-	/**
-	 * The elements are ordered by priority, lowest have highest priority
-	 */
-	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
-	};
-
-	virtual ~ThermalComponentIF() {
-
-	}
-
-	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
-
-	virtual object_id_t getObjectId() = 0;
-
-	virtual uint8_t getDomainId() const = 0;
-
-	virtual void markStateIgnored() = 0;
-
-	virtual float getLowerOpLimit() = 0;
-
-	virtual ReturnValue_t setTargetState(int8_t state) = 0;
-
-	virtual void setOutputInvalid() = 0;
-
-	static bool isOperational(int8_t state) {
-		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
-	}
-
-	static bool isOutOfRange(State state) {
-		return ((state == OUT_OF_RANGE_HIGH)
-				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
-				|| (state == OUT_OF_RANGE_LOW)
-				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
-	}
-
-	static bool isNonOperational(State state) {
-		return !isOutOfRange(state);
-	}
-
-	static bool isIgnoredState(State state) {
-		switch (state) {
-		case OUT_OF_RANGE_LOW_IGNORED:
-		case OUT_OF_RANGE_HIGH_IGNORED:
-		case NON_OPERATIONAL_LOW_IGNORED:
-		case NON_OPERATIONAL_HIGH_IGNORED:
-		case OPERATIONAL_IGNORED:
-		case UNKNOWN:
-			return true;
-		default:
-			return false;
-		}
-	}
-};
-
-#endif /* THERMALCOMPONENTIF_H_ */
+#ifndef THERMALCOMPONENTIF_H_
+#define THERMALCOMPONENTIF_H_
+
+#include "../events/Event.h"
+#include "../parameters/HasParametersIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+
+class ThermalComponentIF : public HasParametersIF {
+public:
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
+	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t ABOVE_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF1);
+	static const ReturnValue_t BELOW_OPERATIONAL_LIMIT = MAKE_RETURN_CODE(0xF2);
+
+	enum State {
+		OUT_OF_RANGE_LOW = -2,
+		NON_OPERATIONAL_LOW = -1,
+		OPERATIONAL = 0,
+		NON_OPERATIONAL_HIGH = 1,
+		OUT_OF_RANGE_HIGH = 2,
+		OUT_OF_RANGE_LOW_IGNORED = OUT_OF_RANGE_LOW - 10,
+		NON_OPERATIONAL_LOW_IGNORED = NON_OPERATIONAL_LOW - 10,
+		OPERATIONAL_IGNORED = OPERATIONAL + 10,
+		NON_OPERATIONAL_HIGH_IGNORED = NON_OPERATIONAL_HIGH + 10,
+		OUT_OF_RANGE_HIGH_IGNORED = OUT_OF_RANGE_HIGH + 10,
+		UNKNOWN = 20
+	};
+
+	enum StateRequest {
+		STATE_REQUEST_HEATING = 4,
+		STATE_REQUEST_IGNORE = 3,
+		STATE_REQUEST_OPERATIONAL = 1,
+		STATE_REQUEST_NON_OPERATIONAL = 0
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum Priority {
+		SAFE = 0,             //!< SAFE
+		IDLE,                 //!< IDLE
+		PAYLOAD,              //!< PAYLOAD
+		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+	};
+
+	/**
+	 * The elements are ordered by priority, lowest have highest priority
+	 */
+	enum HeaterRequest {
+		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
+		HEATER_REQUEST_ON,           //!< REQUEST_ON
+		HEATER_DONT_CARE             //!< DONT_CARE
+	};
+
+	virtual ~ThermalComponentIF() {
+
+	}
+
+	virtual HeaterRequest performOperation(uint8_t opCode) = 0;
+
+	virtual object_id_t getObjectId() = 0;
+
+	virtual uint8_t getDomainId() const = 0;
+
+	virtual void markStateIgnored() = 0;
+
+	virtual float getLowerOpLimit() = 0;
+
+	virtual ReturnValue_t setTargetState(int8_t state) = 0;
+
+	virtual void setOutputInvalid() = 0;
+
+	static bool isOperational(int8_t state) {
+		return ((state == OPERATIONAL) || (state == OPERATIONAL_IGNORED));
+	}
+
+	static bool isOutOfRange(State state) {
+		return ((state == OUT_OF_RANGE_HIGH)
+				|| (state == OUT_OF_RANGE_HIGH_IGNORED)
+				|| (state == OUT_OF_RANGE_LOW)
+				|| (state == OUT_OF_RANGE_LOW_IGNORED) || (state == UNKNOWN));
+	}
+
+	static bool isNonOperational(State state) {
+		return !isOutOfRange(state);
+	}
+
+	static bool isIgnoredState(State state) {
+		switch (state) {
+		case OUT_OF_RANGE_LOW_IGNORED:
+		case OUT_OF_RANGE_HIGH_IGNORED:
+		case NON_OPERATIONAL_LOW_IGNORED:
+		case NON_OPERATIONAL_HIGH_IGNORED:
+		case OPERATIONAL_IGNORED:
+		case UNKNOWN:
+			return true;
+		default:
+			return false;
+		}
+	}
+};
+
+#endif /* THERMALCOMPONENTIF_H_ */
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 7ee6b96b..fbd6939e 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,288 +1,288 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "ThermalModule.h"
-
-#include "AbstractTemperatureSensor.h"
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
-		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
-	heater = new RedundantHeater(heaterParameters);
-}
-
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
-}
-
-ThermalModule::~ThermalModule() {
-	delete heater;
-}
-
-void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
-		heater->performOperation(0);
-	}
-}
-
-void ThermalModule::performMode(Strategy strategy) {
-	calculateTemperature();
-
-	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
-	ThermalComponentIF::HeaterRequest componentHeaterRequest =
-			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
-
-	if (heater == NULL) {
-		informComponentsAboutHeaterState(false, NONE);
-		return;
-	}
-
-	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
-
-	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
-		//Components overwrite the module request.
-		heating = ((componentHeaterRequest
-				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
-	}
-
-	bool dual = (strategy == ACTIVE_DUAL);
-
-	if (strategy == PASSIVE) {
-		informComponentsAboutHeaterState(false, NONE);
-		if (oldStrategy != PASSIVE) {
-			heater->set(false, false, true);
-		}
-	} else {
-		if (safeOnly) {
-			informComponentsAboutHeaterState(heating, SAFE);
-		} else {
-			informComponentsAboutHeaterState(heating, ALL);
-		}
-		heater->set(heating, dual);
-	}
-	oldStrategy = strategy;
-}
-
-float ThermalModule::getTemperature() {
-	return moduleTemperature;
-}
-
-void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
-	sensors.push_back(sensor);
-}
-
-void ThermalModule::registerComponent(ThermalComponentIF* component,
-		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
-}
-
-void ThermalModule::calculateTemperature() {
-	uint32_t numberOfValidSensors = 0;
-	moduleTemperature = 0;
-	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
-	for (; iter != sensors.end(); iter++) {
-		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
-			numberOfValidSensors++;
-		}
-	}
-	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
-		moduleTemperature.setValid(PoolVariableIF::VALID);
-	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
-		moduleTemperature.setValid(PoolVariableIF::INVALID);
-	}
-}
-
-ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		if (iter->component->getObjectId() == objectId) {
-			return iter->component;
-		}
-	}
-	return NULL;
-}
-
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
-
-	survivalTargetTemp = -999;
-	targetTemp = -999;
-
-	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
-		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		updateTargetTemperatures(iter->component,
-				iter->priority == ThermalComponentIF::SAFE);
-		ThermalComponentIF::HeaterRequest request =
-				iter->component->performOperation(0);
-		iter->request = request;
-		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
-			if (request < heaterRequests[iter->priority]) {
-				heaterRequests[iter->priority] = request;
-			}
-		}
-	}
-
-	if (!safeOnly) {
-		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
-				i--) {
-			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
-				heaterRequests[i - 1] = heaterRequests[i];
-			}
-		}
-	}
-	return heaterRequests[0];
-}
-
-void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
-		Informee whomToInform) {
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		switch (whomToInform) {
-		case ALL:
-			break;
-		case SAFE:
-			if (!(iter->priority == ThermalComponentIF::SAFE)) {
-				iter->component->markStateIgnored();
-				continue;
-			}
-			break;
-		case NONE:
-			iter->component->markStateIgnored();
-			continue;
-		}
-
-		if (heaterIsOn) {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
-				iter->component->markStateIgnored();
-			}
-		} else {
-			if ((iter->request
-					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
-					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
-				iter->component->markStateIgnored();
-			}
-		}
-	}
-}
-
-void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
-	if (heater != NULL) {
-		heater->setPowerSwitcher(powerSwitch);
-	}
-
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		float componentLowerOpLimit = iter->component->getLowerOpLimit();
-		if (iter->priority == ThermalComponentIF::SAFE) {
-			if (componentLowerOpLimit > survivalTargetTemp) {
-				survivalTargetTemp = componentLowerOpLimit;
-			}
-		} else {
-			if (componentLowerOpLimit > targetTemp) {
-				targetTemp = componentLowerOpLimit;
-			}
-		}
-	}
-	if (survivalTargetTemp > targetTemp) {
-		targetTemp = survivalTargetTemp;
-	}
-}
-
-bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
-		Strategy strategy) {
-	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
-		currentState = UNKNOWN;
-		return false;
-	}
-
-	float limit = targetTemp;
-	bool heaterRequest = false;
-	if (strategy == ACTIVE_SURVIVAL) {
-		limit = survivalTargetTemp;
-	}
-
-	if (moduleTemperature >= limit) {
-		currentState = OPERATIONAL;
-	} else {
-		currentState = NON_OPERATIONAL;
-	}
-
-	limit += parameters.heaterOn;
-
-	if (heating) {
-		limit += parameters.hysteresis;
-	}
-
-	if (targetState == STATE_REQUEST_HEATING) {
-		if (moduleTemperature < limit) {
-			heaterRequest = true;
-		} else {
-			heaterRequest = false;
-		}
-	}
-
-	heating = heaterRequest;
-
-	return heaterRequest;
-}
-
-void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
-}
-
-void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
-		bool isSafe) {
-	if (isSafe) {
-		if (component->getLowerOpLimit() > survivalTargetTemp) {
-			survivalTargetTemp = component->getLowerOpLimit();
-		}
-	} else {
-		if (component->getLowerOpLimit() > targetTemp) {
-			targetTemp = component->getLowerOpLimit();
-		}
-	}
-}
-
-void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
-	moduleTemperature.setValid(PoolVariableIF::INVALID);
-	currentState.setValid(PoolVariableIF::INVALID);
-	std::list<ComponentData>::iterator iter = components.begin();
-	for (; iter != components.end(); iter++) {
-		iter->component->setOutputInvalid();
-	}
-	if (heater != NULL) {
-		heater->set(false,true);
-	}
-}
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+#include "ThermalModule.h"
+
+#include "AbstractTemperatureSensor.h"
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
+		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
+		GlobDataSet *dataSet, Parameters parameters,
+		RedundantHeater::Parameters heaterParameters) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters(parameters), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
+				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
+				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+	heater = new RedundantHeater(heaterParameters);
+}
+
+ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
+				false), parameters( { 0, 0 }), moduleTemperature(
+				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
+				NULL), currentState(PoolVariableIF::INVALID, dataSet,
+				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
+				dataSet, PoolVariableIF::VAR_READ) {
+}
+
+ThermalModule::~ThermalModule() {
+	delete heater;
+}
+
+void ThermalModule::performOperation(uint8_t opCode) {
+	if (heater != NULL) {
+		heater->performOperation(0);
+	}
+}
+
+void ThermalModule::performMode(Strategy strategy) {
+	calculateTemperature();
+
+	bool safeOnly = (strategy == ACTIVE_SURVIVAL);
+	ThermalComponentIF::HeaterRequest componentHeaterRequest =
+			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
+
+	if (heater == NULL) {
+		informComponentsAboutHeaterState(false, NONE);
+		return;
+	}
+
+	bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
+
+	if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
+		//Components overwrite the module request.
+		heating = ((componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_ON)
+				|| (componentHeaterRequest
+						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+	}
+
+	bool dual = (strategy == ACTIVE_DUAL);
+
+	if (strategy == PASSIVE) {
+		informComponentsAboutHeaterState(false, NONE);
+		if (oldStrategy != PASSIVE) {
+			heater->set(false, false, true);
+		}
+	} else {
+		if (safeOnly) {
+			informComponentsAboutHeaterState(heating, SAFE);
+		} else {
+			informComponentsAboutHeaterState(heating, ALL);
+		}
+		heater->set(heating, dual);
+	}
+	oldStrategy = strategy;
+}
+
+float ThermalModule::getTemperature() {
+	return moduleTemperature;
+}
+
+void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
+	sensors.push_back(sensor);
+}
+
+void ThermalModule::registerComponent(ThermalComponentIF* component,
+		ThermalComponentIF::Priority priority) {
+	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+}
+
+void ThermalModule::calculateTemperature() {
+	uint32_t numberOfValidSensors = 0;
+	moduleTemperature = 0;
+	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
+	for (; iter != sensors.end(); iter++) {
+		if ((*iter)->isValid()) {
+			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			numberOfValidSensors++;
+		}
+	}
+	if (numberOfValidSensors != 0) {
+		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature.setValid(PoolVariableIF::VALID);
+	} else {
+		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.setValid(PoolVariableIF::INVALID);
+	}
+}
+
+ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		if (iter->component->getObjectId() == objectId) {
+			return iter->component;
+		}
+	}
+	return NULL;
+}
+
+ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
+		bool safeOnly) {
+	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+
+	survivalTargetTemp = -999;
+	targetTemp = -999;
+
+	for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
+		heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		updateTargetTemperatures(iter->component,
+				iter->priority == ThermalComponentIF::SAFE);
+		ThermalComponentIF::HeaterRequest request =
+				iter->component->performOperation(0);
+		iter->request = request;
+		if (request != ThermalComponentIF::HEATER_DONT_CARE) {
+			if (request < heaterRequests[iter->priority]) {
+				heaterRequests[iter->priority] = request;
+			}
+		}
+	}
+
+	if (!safeOnly) {
+		for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
+				i--) {
+			if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
+				heaterRequests[i - 1] = heaterRequests[i];
+			}
+		}
+	}
+	return heaterRequests[0];
+}
+
+void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
+		Informee whomToInform) {
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		switch (whomToInform) {
+		case ALL:
+			break;
+		case SAFE:
+			if (!(iter->priority == ThermalComponentIF::SAFE)) {
+				iter->component->markStateIgnored();
+				continue;
+			}
+			break;
+		case NONE:
+			iter->component->markStateIgnored();
+			continue;
+		}
+
+		if (heaterIsOn) {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
+				iter->component->markStateIgnored();
+			}
+		} else {
+			if ((iter->request
+					== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
+					|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
+				iter->component->markStateIgnored();
+			}
+		}
+	}
+}
+
+void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
+	if (heater != NULL) {
+		heater->setPowerSwitcher(powerSwitch);
+	}
+
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		float componentLowerOpLimit = iter->component->getLowerOpLimit();
+		if (iter->priority == ThermalComponentIF::SAFE) {
+			if (componentLowerOpLimit > survivalTargetTemp) {
+				survivalTargetTemp = componentLowerOpLimit;
+			}
+		} else {
+			if (componentLowerOpLimit > targetTemp) {
+				targetTemp = componentLowerOpLimit;
+			}
+		}
+	}
+	if (survivalTargetTemp > targetTemp) {
+		targetTemp = survivalTargetTemp;
+	}
+}
+
+bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
+		Strategy strategy) {
+	currentState.setValid(PoolVariableIF::VALID);
+	if (moduleTemperature == INVALID_TEMPERATURE) {
+		currentState = UNKNOWN;
+		return false;
+	}
+
+	float limit = targetTemp;
+	bool heaterRequest = false;
+	if (strategy == ACTIVE_SURVIVAL) {
+		limit = survivalTargetTemp;
+	}
+
+	if (moduleTemperature >= limit) {
+		currentState = OPERATIONAL;
+	} else {
+		currentState = NON_OPERATIONAL;
+	}
+
+	limit += parameters.heaterOn;
+
+	if (heating) {
+		limit += parameters.hysteresis;
+	}
+
+	if (targetState == STATE_REQUEST_HEATING) {
+		if (moduleTemperature < limit) {
+			heaterRequest = true;
+		} else {
+			heaterRequest = false;
+		}
+	}
+
+	heating = heaterRequest;
+
+	return heaterRequest;
+}
+
+void ThermalModule::setHeating(bool on) {
+	GlobDataSet mySet;
+	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+			&mySet, PoolVariableIF::VAR_WRITE);
+	if (on) {
+		writableTargetState = STATE_REQUEST_HEATING;
+	} else {
+		writableTargetState = STATE_REQUEST_PASSIVE;
+	}
+	mySet.commit(PoolVariableIF::VALID);
+}
+
+void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
+		bool isSafe) {
+	if (isSafe) {
+		if (component->getLowerOpLimit() > survivalTargetTemp) {
+			survivalTargetTemp = component->getLowerOpLimit();
+		}
+	} else {
+		if (component->getLowerOpLimit() > targetTemp) {
+			targetTemp = component->getLowerOpLimit();
+		}
+	}
+}
+
+void ThermalModule::setOutputInvalid() {
+	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature.setValid(PoolVariableIF::INVALID);
+	currentState.setValid(PoolVariableIF::INVALID);
+	std::list<ComponentData>::iterator iter = components.begin();
+	for (; iter != components.end(); iter++) {
+		iter->component->setOutputInvalid();
+	}
+	if (heater != NULL) {
+		heater->set(false,true);
+	}
+}
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 46692640..41be6baa 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,95 +1,95 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../events/EventReportingProxyIF.h"
-#include "ThermalModuleIF.h"
-#include <list>
-#include "tcsDefinitions.h"
-#include "RedundantHeater.h"
-class PowerSwitchIF;
-
-/**
- * @brief Allows creation of different thermal control domains within a system.
- */
-class ThermalModule: public ThermalModuleIF {
-	friend class ThermalController;
-public:
-	struct Parameters {
-		float heaterOn;
-		float hysteresis;
-	};
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
-
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
-
-	virtual ~ThermalModule();
-
-	void performOperation(uint8_t opCode);
-
-	void performMode(Strategy strategy);
-
-	float getTemperature();
-
-	void registerSensor(AbstractTemperatureSensor *sensor);
-
-	void registerComponent(ThermalComponentIF *component,
-			ThermalComponentIF::Priority priority);
-
-	ThermalComponentIF *findComponent(object_id_t objectId);
-
-	void initialize(PowerSwitchIF* powerSwitch);
-
-	void setHeating(bool on);
-
-	virtual void setOutputInvalid();
-
-protected:
-	enum Informee {
-		ALL, SAFE, NONE
-	};
-
-	struct ComponentData {
-		ThermalComponentIF *component;
-		ThermalComponentIF::Priority priority;
-		ThermalComponentIF::HeaterRequest request;
-	};
-
-	Strategy oldStrategy;
-
-	float survivalTargetTemp;
-
-	float targetTemp;
-
-	bool heating;
-
-	Parameters parameters;
-
-	gp_float_t moduleTemperature;
-
-	RedundantHeater *heater;
-
-	gp_int8_t currentState;
-	gp_int8_t targetState;
-
-	std::list<AbstractTemperatureSensor *> sensors;
-	std::list<ComponentData> components;
-
-	void calculateTemperature();
-
-	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
-
-	void informComponentsAboutHeaterState(bool heaterIsOn,
-			Informee whomToInform);
-
-	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
-
-	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
-};
-
-#endif /* THERMALMODULE_H_ */
+#ifndef THERMALMODULE_H_
+#define THERMALMODULE_H_
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+#include "ThermalModuleIF.h"
+#include <list>
+#include "tcsDefinitions.h"
+#include "RedundantHeater.h"
+class PowerSwitchIF;
+
+/**
+ * @brief Allows creation of different thermal control domains within a system.
+ */
+class ThermalModule: public ThermalModuleIF {
+	friend class ThermalController;
+public:
+	struct Parameters {
+		float heaterOn;
+		float hysteresis;
+	};
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
+			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
+			RedundantHeater::Parameters heaterParameters);
+
+	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+
+	virtual ~ThermalModule();
+
+	void performOperation(uint8_t opCode);
+
+	void performMode(Strategy strategy);
+
+	float getTemperature();
+
+	void registerSensor(AbstractTemperatureSensor *sensor);
+
+	void registerComponent(ThermalComponentIF *component,
+			ThermalComponentIF::Priority priority);
+
+	ThermalComponentIF *findComponent(object_id_t objectId);
+
+	void initialize(PowerSwitchIF* powerSwitch);
+
+	void setHeating(bool on);
+
+	virtual void setOutputInvalid();
+
+protected:
+	enum Informee {
+		ALL, SAFE, NONE
+	};
+
+	struct ComponentData {
+		ThermalComponentIF *component;
+		ThermalComponentIF::Priority priority;
+		ThermalComponentIF::HeaterRequest request;
+	};
+
+	Strategy oldStrategy;
+
+	float survivalTargetTemp;
+
+	float targetTemp;
+
+	bool heating;
+
+	Parameters parameters;
+
+	gp_float_t moduleTemperature;
+
+	RedundantHeater *heater;
+
+	gp_int8_t currentState;
+	gp_int8_t targetState;
+
+	std::list<AbstractTemperatureSensor *> sensors;
+	std::list<ComponentData> components;
+
+	void calculateTemperature();
+
+	ThermalComponentIF::HeaterRequest letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly);
+
+	void informComponentsAboutHeaterState(bool heaterIsOn,
+			Informee whomToInform);
+
+	bool calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy);
+
+	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
+};
+
+#endif /* THERMALMODULE_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp
index af0413bf..fc0823c3 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitor.cpp
@@ -1,68 +1,68 @@
-#include "../thermal/ThermalMonitor.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../monitoring/MonitoringIF.h"
-ThermalMonitor::~ThermalMonitor() {
-}
-
-void ThermalMonitor::sendTransitionEvent(float currentValue,
-		ReturnValue_t state) {
-	switch (state) {
-	case MonitoringIF::BELOW_LOW_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
-		break;
-	case MonitoringIF::ABOVE_HIGH_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
-		break;
-	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
-		break;
-	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
-		EventManagerIF::triggerEvent(reportingId,
-				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
-		break;
-	default:
-		break;
-	}
-}
-
-bool ThermalMonitor::isAboveHighLimit() {
-	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
-		float upperLimit, bool componentIsOperational) {
-	if (ThermalComponentIF::isIgnoredState(state)) {
-		setToUnchecked();
-		return MonitoringIF::UNCHECKED;
-	}
-	switch (state) {
-	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
-	case ThermalComponentIF::NON_OPERATIONAL_LOW:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OPERATIONAL:
-		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
-		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
-		} else {
-			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
-		}
-	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
-	default:
-		//Never reached, all states covered.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
+#include "../thermal/ThermalMonitor.h"
+#include "../thermal/ThermalComponentIF.h"
+#include "../monitoring/MonitoringIF.h"
+ThermalMonitor::~ThermalMonitor() {
+}
+
+void ThermalMonitor::sendTransitionEvent(float currentValue,
+		ReturnValue_t state) {
+	switch (state) {
+	case MonitoringIF::BELOW_LOW_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
+		break;
+	case MonitoringIF::ABOVE_HIGH_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
+		break;
+	case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_LOW, state);
+		break;
+	case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
+		EventManagerIF::triggerEvent(reportingId,
+				ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
+		break;
+	default:
+		break;
+	}
+}
+
+bool ThermalMonitor::isAboveHighLimit() {
+	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+		float upperLimit, bool componentIsOperational) {
+	if (ThermalComponentIF::isIgnoredState(state)) {
+		setToUnchecked();
+		return MonitoringIF::UNCHECKED;
+	}
+	switch (state) {
+	case ThermalComponentIF::OUT_OF_RANGE_LOW:
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+	case ThermalComponentIF::NON_OPERATIONAL_LOW:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OPERATIONAL:
+		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
+		if (componentIsOperational) {
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+		} else {
+			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
+		}
+	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+	default:
+		//Never reached, all states covered.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
index 69528600..680c0cb0 100644
--- a/thermal/ThermalMonitor.h
+++ b/thermal/ThermalMonitor.h
@@ -1,26 +1,26 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include "../monitoring/MonitorReporter.h"
-#include "../thermal/ThermalComponentIF.h"
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
+#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
+#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
+
+#include "../monitoring/MonitorReporter.h"
+#include "../thermal/ThermalComponentIF.h"
+
+/**
+ * What does it do. How to use it.
+ */
+class ThermalMonitor: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitor(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitor();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit, bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 7124d8bd..130b3175 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,602 +1,602 @@
-#include "../timemanager/CCSDSTime.h"
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
-
-CCSDSTime::CCSDSTime() {
-}
-
-CCSDSTime::~CCSDSTime() {
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4);
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	to->pField = (CCS << 4) + 2;
-
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
-
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		uint32_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
-
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
-
-	*foundLength = totalLength;
-
-	ReturnValue_t result = checkCcs(from, maxLength);
-
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
-
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
-
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
-
-	to->month = temp->month;
-	to->day = temp->day;
-
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
-
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
-#else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
-    //try Code A (yyyy-mm-dd)
-    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
-            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
-            &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-
-    //try Code B (yyyy-ddd)
-    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
-            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-#endif
-
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
-
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	uint8_t *additionalByte = &time_struct->secondEminus2;
-
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
-
-		if (*month == 8) {
-			continue;
-		}
-
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
-}
-
-bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
-
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
-
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
-
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
-
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
-
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
-
-	return RETURN_OK;
-
-}
-
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
-}
-
-ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
-}
-
-uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
-}
-
-ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
-
-}
+#include "../timemanager/CCSDSTime.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <math.h>
+
+CCSDSTime::CCSDSTime() {
+}
+
+CCSDSTime::~CCSDSTime() {
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4);
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
+		const Clock::TimeOfDay_t* from) {
+	ReturnValue_t result = checkTimeOfDay(from);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	to->pField = (CCS << 4) + 2;
+
+	to->yearMSB = (from->year >> 8);
+	to->yearLSB = from->year & 0xff;
+	to->month = from->month;
+	to->day = from->day;
+	to->hour = from->hour;
+	to->minute = from->minute;
+	to->second = from->second;
+	to->secondEminus2 = from->usecond / 10000;
+	to->secondEminus4 = (from->usecond % 10000) / 100;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t length) {
+	ReturnValue_t result;
+	if (length > 0xFF) {
+		return LENGTH_MISMATCH;
+	}
+	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+	if (result == RETURN_OK) {
+		return RETURN_OK;
+	}
+
+	//Seems to be no ascii, try the other formats
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+		return convertFromCUC(to, from, length);
+	case CDS:
+		return convertFromCDS(to, from, length);
+	case CCS: {
+		uint32_t temp = 0;
+		return convertFromCCS(to, from, &temp, length);
+	}
+
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	timeval time;
+	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return convertTimevalToTimeOfDay(to, &time);
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t subsecondsLength = *from & 0b111;
+	uint32_t totalLength = subsecondsLength + 8;
+	if (maxLength < totalLength) {
+		return LENGTH_MISMATCH;
+	}
+
+	*foundLength = totalLength;
+
+	ReturnValue_t result = checkCcs(from, maxLength);
+
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+
+	to->year = (temp->yearMSB << 8) + temp->yearLSB;
+	to->hour = temp->hour;
+	to->minute = temp->minute;
+	to->second = temp->second;
+
+	if (temp->pField & (1 << 3)) { //day of year variation
+		uint16_t tempDay = (temp->month << 8) + temp->day;
+		result = convertDaysOfYear(tempDay, to->year,
+				&(temp->month), &(temp->day));
+		if (result != RETURN_OK) {
+			return result;
+		}
+	}
+
+	to->month = temp->month;
+	to->day = temp->day;
+
+	to->usecond = 0;
+	if (subsecondsLength > 0) {
+		*foundLength += 1;
+		if (temp->secondEminus2 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond = temp->secondEminus2 * 10000;
+	}
+
+	if (subsecondsLength > 1) {
+		*foundLength += 1;
+		if (temp->secondEminus4 >= 100) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->usecond += temp->secondEminus4 * 100;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+		uint8_t length) {
+	if (length < 19) {
+		return RETURN_FAILED;
+	}
+// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+// Suggestion: use uint16 all the time. This should work on all systems.
+#ifdef NEWLIB_NANO_NO_C99_IO
+	uint16_t year;
+	uint16_t month;
+	uint16_t day;
+	uint16_t hour;
+	uint16_t minute;
+	float second;
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
+				&month, &day, &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+	// try Code B (yyyy-ddd)
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
+			&hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+// Warning: Compiler/Linker fails ambiguously if library does not implement
+// C99 I/O
+#else
+	uint16_t year;
+	uint8_t month;
+	uint16_t day;
+	uint8_t hour;
+	uint8_t minute;
+	float second;
+    //try Code A (yyyy-mm-dd)
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
+            "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
+            &hour, &minute, &second);
+	if (count == 6) {
+		to->year = year;
+		to->month = month;
+		to->day = day;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+
+    //try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
+            ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
+	if (count == 5) {
+		uint8_t tempDay;
+		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+				&tempDay);
+		if (result != RETURN_OK) {
+			return RETURN_FAILED;
+		}
+		to->year = year;
+		to->month = month;
+		to->day = tempDay;
+		to->hour = hour;
+		to->minute = minute;
+		to->second = second;
+		to->usecond = (second - floor(second)) * 1000000;
+		return RETURN_OK;
+	}
+#endif
+
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
+	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+
+	uint8_t additionalBytes = time_struct->pField & 0b111;
+	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time_struct->pField & (1 << 3)) { //day of year variation
+		uint16_t day = (time_struct->month << 8) + time_struct->day;
+		if (day > 366) {
+			return INVALID_TIME_FORMAT;
+		}
+	} else {
+		if (time_struct->month > 12) {
+			return INVALID_TIME_FORMAT;
+		}
+		if (time_struct->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	if (time_struct->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+	if (time_struct->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	uint8_t *additionalByte = &time_struct->secondEminus2;
+
+	for (; additionalBytes != 0; additionalBytes--) {
+		if (*additionalByte++ > 99) {
+			return INVALID_TIME_FORMAT;
+		}
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+		uint8_t* month, uint8_t* day) {
+	if (isLeapYear(year)) {
+		if (dayofYear > 366) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	} else {
+		if (dayofYear > 365) {
+			return INVALID_DAY_OF_YEAR;
+		}
+	}
+	*month = 1;
+	if (dayofYear <= 31) {
+		*day = dayofYear;
+		return RETURN_OK;
+	}
+	*month += 1;
+	dayofYear -= 31;
+	if (isLeapYear(year)) {
+		if (dayofYear <= 29) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 29;
+	} else {
+		if (dayofYear <= 28) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 28;
+	}
+	while (*month <= 12) {
+		if (dayofYear <= 31) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 31;
+
+		if (*month == 8) {
+			continue;
+		}
+
+		if (dayofYear <= 30) {
+			*day = dayofYear;
+			return RETURN_OK;
+		}
+		*month += 1;
+		dayofYear -= 30;
+	}
+	return INVALID_DAY_OF_YEAR;
+}
+
+bool CCSDSTime::isLeapYear(uint32_t year) {
+	if ((year % 400) == 0) {
+		return true;
+	}
+	if ((year % 100) == 0) {
+		return false;
+	}
+	if ((year % 4) == 0) {
+		return true;
+	}
+	return false;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
+	to->pField = (CDS << 4) + 0;
+	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			+ DAYS_CCSDS_TO_UNIX_EPOCH;
+	if (days > (1 << 16)) {
+		//Date is beyond year 2137
+		return TIME_DOES_NOT_FIT_FORMAT;
+	}
+	to->dayMSB = (days & 0xFF00) >> 8;
+	to->dayLSB = (days & 0xFF);
+	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			+ (from->tv_usec / 1000);
+	to->msDay_hh = (msDay & 0xFF000000) >> 24;
+	to->msDay_h = (msDay & 0xFF0000) >> 16;
+	to->msDay_l = (msDay & 0xFF00) >> 8;
+	to->msDay_ll = (msDay & 0xFF);
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
+	to->pFiled = (AGENCY_DEFINED << 4) + 5;
+	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+	to->seconds_h = (from->tv_sec >> 16) & 0xff;
+	to->seconds_l = (from->tv_sec >> 8) & 0xff;
+	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+
+	//convert the µs to 2E-16 seconds
+	uint64_t temp = from->tv_usec;
+	temp = temp << 16;
+	temp = temp / 1E6;
+
+	to->subsecondsMSB = (temp >> 8) & 0xff;
+	to->subsecondsLSB = temp & 0xff;
+
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	//We don't expect ascii here. SHOULDDO
+	uint8_t codeIdentification = (*from >> 4);
+	switch (codeIdentification) {
+	//unsupported, as Leap second correction would have to be applied
+//	case CUC_LEVEL1:
+//		return convertFromCUC(to, from, foundLength, maxLength);
+	case CDS:
+		return convertFromCDS(to, from, foundLength, maxLength);
+	case CCS:
+		return convertFromCCS(to, from, foundLength, maxLength);
+	default:
+		return UNSUPPORTED_TIME_FORMAT;
+	}
+
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	if (maxLength < 1) {
+		return INVALID_TIME_FORMAT;
+	}
+	uint8_t pField = *from;
+	from++;
+	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+			maxLength - 1);
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		if (foundLength != NULL) {
+			*foundLength += 1;
+		}
+	}
+	return result;
+}
+
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+	if ((time->month > 12) || (time->month == 0)) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->day == 0) {
+		return INVALID_TIME_FORMAT;
+	}
+	switch (time->month) {
+	case 2:
+		if (isLeapYear(time->year)) {
+			if (time->day > 29) {
+				return INVALID_TIME_FORMAT;
+			}
+		} else {
+			if (time->day > 28) {
+				return INVALID_TIME_FORMAT;
+			}
+		}
+		break;
+	case 4:
+	case 6:
+	case 9:
+	case 11:
+		if (time->day > 30) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	default:
+		if (time->day > 31) {
+			return INVALID_TIME_FORMAT;
+		}
+		break;
+	}
+
+	if (time->hour > 23) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->minute > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->second > 59) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	if (time->usecond > 999999) {
+		return INVALID_TIME_FORMAT;
+	}
+
+	return RETURN_OK;
+
+}
+
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+		timeval* from) {
+//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+	return UNSUPPORTED_TIME_FORMAT;
+}
+
+ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	uint8_t pField = *from;
+	from++;
+//Check epoch
+	if (pField & 0b1000) {
+		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+	}
+//Check length
+	uint8_t expectedLength = 7; //Including p-Field.
+	bool extendedDays = pField & 0b100;
+	if (extendedDays) {
+		expectedLength += 1;
+	}
+	if ((pField & 0b11) == 0b01) {
+		expectedLength += 2;
+	} else if ((pField & 0b11) == 0b10) {
+		expectedLength += 4;
+	}
+	if (foundLength != NULL) {
+		*foundLength = expectedLength;
+	}
+	if (expectedLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+//Check and count days
+	uint32_t days = 0;
+	if (extendedDays) {
+		days = (from[0] << 16) + (from[1] << 8) + from[2];
+		from += 3;
+	} else {
+		days = (from[0] << 8) + from[1];
+		from += 2;
+	}
+//Move to POSIX epoch.
+	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+		return INVALID_TIME_FORMAT;
+	}
+	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+	to->tv_sec = days * SECONDS_PER_DAY;
+	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			+ from[3];
+	from += 4;
+	to->tv_sec += (msDay / 1000);
+	to->tv_usec = (msDay % 1000) * 1000;
+	if ((pField & 0b11) == 0b01) {
+		uint16_t usecs = (from[0] << 16) + from[1];
+		from += 2;
+		if (usecs > 999) {
+			return INVALID_TIME_FORMAT;
+		}
+		to->tv_usec += usecs;
+	} else if ((pField & 0b11) == 0b10) {
+		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				+ from[3];
+		from += 4;
+		if (picosecs > 999999) {
+			return INVALID_TIME_FORMAT;
+		}
+		//Not very useful.
+		to->tv_usec += (picosecs / 1000);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
+		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+	uint32_t secs = 0;
+	uint32_t subSeconds = 0;
+	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+	uint8_t nFine = (pField & 0b11);
+	uint32_t totalLength = nCoarse + nFine;
+	if (foundLength != NULL) {
+		*foundLength = totalLength;
+	}
+	if (totalLength > maxLength) {
+		return LENGTH_MISMATCH;
+	}
+	for (int count = 0; count < nCoarse; count++) {
+		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+		from++;
+	}
+	for (int count = 0; count < nFine; count++) {
+		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+		from++;
+	}
+	//Move to POSIX epoch.
+	to->tv_sec = secs;
+	if (pField & 0b10000) {
+		//CCSDS-Epoch
+		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+	}
+	to->tv_usec = subsecondsToMicroseconds(subSeconds);
+	return RETURN_OK;
+}
+
+uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
+	uint64_t temp = (uint64_t) subseconds * 1000000
+			/ (1 << (sizeof(subseconds) * 8));
+	return temp;
+}
+
+ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
+		uint32_t* foundLength, uint32_t maxLength) {
+	Clock::TimeOfDay_t tempTime;
+	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+			maxLength);
+	if (result != RETURN_OK) {
+		return result;
+	}
+
+	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+
+}
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 6bb3a75c..b9efa49c 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,233 +1,233 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
-
-// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
-
-#include "../timemanager/Clock.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
-
-bool operator<(const timeval& lhs, const timeval& rhs);
-bool operator<=(const timeval& lhs, const timeval& rhs);
-bool operator==(const timeval& lhs, const timeval& rhs);
-/**
- * static helper class for CCSDS Time Code Formats
- *
- * as described in CCSDS 301.0-B-3
- *
- * Still work in progress
- */
-class CCSDSTime: public HasReturnvaluesIF {
-public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
-
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
-
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
-
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
-
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
-
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
-
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
-
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
-
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
-
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
-
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
-private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
-
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
-
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
-
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
-};
-
-#endif /* CCSDSTIME_H_ */
+#ifndef CCSDSTIME_H_
+#define CCSDSTIME_H_
+
+// COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
+
+#include "../timemanager/Clock.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include <stdint.h>
+
+bool operator<(const timeval& lhs, const timeval& rhs);
+bool operator<=(const timeval& lhs, const timeval& rhs);
+bool operator==(const timeval& lhs, const timeval& rhs);
+/**
+ * static helper class for CCSDS Time Code Formats
+ *
+ * as described in CCSDS 301.0-B-3
+ *
+ * Still work in progress
+ */
+class CCSDSTime: public HasReturnvaluesIF {
+public:
+	/**
+	 * The Time code identifications, bits 4-6 in the P-Field
+	 */
+	enum TimeCodeIdentification {
+		CCS = 0b101,
+		CUC_LEVEL1 = 0b001,
+		CUC_LEVEL2 = 0b010,
+		CDS = 0b100,
+		AGENCY_DEFINED = 0b110
+	};
+	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			+ 2;
+	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+	/**
+	 * Struct for CDS day-segmented format.
+	 */
+	struct CDS_short {
+		uint8_t pField;
+		uint8_t dayMSB;
+		uint8_t dayLSB;
+		uint8_t msDay_hh;
+		uint8_t msDay_h;
+		uint8_t msDay_l;
+		uint8_t msDay_ll;
+	};
+	/**
+	 * Struct for the CCS fromat in day of month variation with max resolution
+	 */
+	struct Ccs_seconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+	};
+
+	/**
+	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+	 */
+	struct Ccs_mseconds {
+		uint8_t pField;
+		uint8_t yearMSB;
+		uint8_t yearLSB;
+		uint8_t month;
+		uint8_t day;
+		uint8_t hour;
+		uint8_t minute;
+		uint8_t second;
+		uint8_t secondEminus2;
+		uint8_t secondEminus4;
+	};
+
+	struct OBT_FLP {
+		uint8_t pFiled;
+		uint8_t seconds_hh;
+		uint8_t seconds_h;
+		uint8_t seconds_l;
+		uint8_t seconds_ll;
+		uint8_t subsecondsMSB;
+		uint8_t subsecondsLSB;
+	};
+
+	struct TimevalLess {
+		bool operator()(const timeval& lhs, const timeval& rhs) const {
+			return (lhs < rhs);
+		}
+	};
+
+	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+			MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+
+	/**
+	 * convert a TimeofDay struct to ccs with seconds resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * Converts to CDS format from timeval.
+	 * @param to pointer to the CDS struct to generate
+	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+	 * @return
+	 * 		- @c RETURN_OK as it assumes a valid timeval.
+	 */
+	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+
+	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+
+	/**
+	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+	 *
+	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+	 *
+	 * @param to pointer to a CCS struct
+	 * @param from pointer to a TimeOfDay Struct
+	 * @return
+	 * 		- @c RETURN_OK if OK
+	 * 		- @c INVALID_TIMECODE if not OK
+	 */
+	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+			Clock::TimeOfDay_t const *from);
+
+	/**
+	 * SHOULDDO: can this be modified to recognize padding?
+	 * Tries to interpret a Level 1 CCSDS time code
+	 *
+	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+	 * by the lack of one.
+	 *
+	 * @param to an empty TimeOfDay struct
+	 * @param from pointer to an CCSDS Time code
+	 * @param length length of the Time code
+	 * @return
+	 * 		- @c RETURN_OK if successful
+	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+	 */
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t length);
+
+	/**
+	 * not implemented yet
+	 *
+	 * @param to
+	 * @param from
+	 * @return
+	 */
+	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint32_t* foundLength, uint32_t maxLength);
+
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+			uint8_t length);
+
+	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+private:
+	CCSDSTime();
+	virtual ~CCSDSTime();
+	/**
+	 * checks a ccs time stream for validity
+	 *
+	 * Stream may be longer than the actual timecode
+	 *
+	 * @param time pointer to an Ccs stream
+	 * @param length length of stream
+	 * @return
+	 */
+	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+
+	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+			* SECONDS_PER_DAY;
+	/**
+	 * @param dayofYear
+	 * @param year
+	 * @param month
+	 * @param day
+	 */
+	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+			uint8_t *month, uint8_t *day);
+
+	static bool isLeapYear(uint32_t year);
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+			timeval* from);
+};
+
+#endif /* CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index c7436252..9463b5a6 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,155 +1,155 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MutexFactory.h"
-#include "../globalfunctions/timevalOperations.h"
-
-#include <cstdint>
-#include <sys/time.h>
-
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
-
-class Clock {
-public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
-
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
-
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
-
-	static timeval getUptime();
-
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
-
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
-
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
-
-	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
-
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
-
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
-
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
-
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
-
-private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
-};
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexFactory.h"
+#include "../globalfunctions/timevalOperations.h"
+
+#include <cstdint>
+#include <sys/time.h>
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+using dur_seconds_t = double;
+
+class Clock {
+public:
+	typedef struct {
+	  uint32_t year; //!< Year, A.D.
+	  uint32_t month; //!< Month, 1 .. 12.
+	  uint32_t day; //!< Day, 1 .. 31.
+	  uint32_t hour; //!< Hour, 0 .. 23.
+	  uint32_t minute; //!< Minute, 0 .. 59.
+	  uint32_t second; //!< Second, 0 .. 59.
+	  uint32_t usecond; //!< Microseconds, 0 .. 999999
+	}   TimeOfDay_t;
+
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
+
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
+
+	static timeval getUptime();
+
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
+
+	/**
+	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return \c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
+
+private:
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
+};
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index 5b019f2b..95cce029 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,45 +1,45 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-
-#include "../timemanager/Countdown.h"
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
-}
-
-Countdown::~Countdown() {
-}
-
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
-	timeout = miliseconds;
-	return return_value;
-}
-
-bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-bool Countdown::isBusy() const {
-	return !hasTimedOut();
-}
-
-ReturnValue_t Countdown::resetTimer() {
-	return setTimeout(timeout);
-}
-
-void Countdown::timeOut() {
-	uint32_t current_time;
-		Clock::getUptime( &current_time );
-	startTime= current_time - timeout;
-}
+/**
+ * @file	Countdown.cpp
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+
+#include "../timemanager/Countdown.h"
+
+Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+}
+
+Countdown::~Countdown() {
+}
+
+ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+	ReturnValue_t return_value = Clock::getUptime( &startTime );
+	timeout = miliseconds;
+	return return_value;
+}
+
+bool Countdown::hasTimedOut() const {
+	uint32_t current_time;
+	Clock::getUptime( &current_time );
+	if ( uint32_t(current_time - startTime) >= timeout) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Countdown::isBusy() const {
+	return !hasTimedOut();
+}
+
+ReturnValue_t Countdown::resetTimer() {
+	return setTimeout(timeout);
+}
+
+void Countdown::timeOut() {
+	uint32_t current_time;
+		Clock::getUptime( &current_time );
+	startTime= current_time - timeout;
+}
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 741ab0f8..20380e71 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,31 +1,31 @@
-/**
- * @file	Countdown.h
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include "../timemanager/Clock.h"
-
-class Countdown {
-private:
-	uint32_t startTime;
-public:
-	uint32_t timeout;
-	Countdown(uint32_t initialTimeout = 0);
-	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
-
-	bool hasTimedOut() const;
-
-	bool isBusy() const;
-
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
-
-	void timeOut(); //!< Make hasTimedOut() return true
-};
-
-#endif /* COUNTDOWN_H_ */
+/**
+ * @file	Countdown.h
+ * @brief	This file defines the Countdown class.
+ * @date	21.03.2013
+ * @author	baetz
+ */
+
+#ifndef COUNTDOWN_H_
+#define COUNTDOWN_H_
+
+#include "../timemanager/Clock.h"
+
+class Countdown {
+private:
+	uint32_t startTime;
+public:
+	uint32_t timeout;
+	Countdown(uint32_t initialTimeout = 0);
+	~Countdown();
+	ReturnValue_t setTimeout(uint32_t miliseconds);
+
+	bool hasTimedOut() const;
+
+	bool isBusy() const;
+
+	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+
+	void timeOut(); //!< Make hasTimedOut() return true
+};
+
+#endif /* COUNTDOWN_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 09915e83..680e94f2 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,32 +1,32 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * This is a Interface for classes that receive timing information
- * with the help of a dedicated message queue.
- */
-class ReceivesTimeInfoIF {
-public:
-	/**
-	 * Returns the id of the queue which receives the timing information.
-	 * @return Queue id of the timing queue.
-	 */
-	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
-	/**
-	 * Empty virtual destructor.
-	 */
-	virtual ~ReceivesTimeInfoIF() {
-	}
-
-};
-
-
-#endif /* RECEIVESTIMEINFOIF_H_ */
+/**
+ * @file	ReceivesTimeInfoIF.h
+ * @brief	This file defines the ReceivesTimeInfoIF class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef RECEIVESTIMEINFOIF_H_
+#define RECEIVESTIMEINFOIF_H_
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * This is a Interface for classes that receive timing information
+ * with the help of a dedicated message queue.
+ */
+class ReceivesTimeInfoIF {
+public:
+	/**
+	 * Returns the id of the queue which receives the timing information.
+	 * @return Queue id of the timing queue.
+	 */
+	virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
+	/**
+	 * Empty virtual destructor.
+	 */
+	virtual ~ReceivesTimeInfoIF() {
+	}
+
+};
+
+
+#endif /* RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index bf69d3ce..637c5078 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,57 +1,57 @@
-#include "../timemanager/Stopwatch.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <iomanip>
-
-Stopwatch::Stopwatch(bool displayOnDestruction,
-        StopwatchDisplayMode displayMode): displayOnDestruction(
-        displayOnDestruction), displayMode(displayMode) {
-    // Measures start time on initialization.
-    Clock::getClock_timeval(&startTime);
-}
-
-void Stopwatch::start() {
-    Clock::getClock_timeval(&startTime);
-}
-
-dur_millis_t Stopwatch::stop() {
-    stopInternal();
-    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
-}
-
-dur_seconds_t Stopwatch::stopSeconds() {
-    stopInternal();
-    return timevalOperations::toDouble(elapsedTime);
-}
-
-void Stopwatch::display() {
-    if(displayMode == StopwatchDisplayMode::MILLIS) {
-        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
-    }
-    else if(displayMode == StopwatchDisplayMode::SECONDS) {
-        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
-             << std::fixed << timevalOperations::toDouble(elapsedTime)
-             << " seconds" << std::endl;
-    }
-}
-
-Stopwatch::~Stopwatch() {
-    if(displayOnDestruction) {
-        stopInternal();
-        display();
-    }
-}
-
-void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
-    this->displayMode = displayMode;
-}
-
-StopwatchDisplayMode Stopwatch::getDisplayMode() const {
-    return displayMode;
-}
-
-void Stopwatch::stopInternal() {
-	timeval endTime;
-	Clock::getClock_timeval(&endTime);
-    elapsedTime = endTime - startTime;
-}
+#include "../timemanager/Stopwatch.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <iomanip>
+
+Stopwatch::Stopwatch(bool displayOnDestruction,
+        StopwatchDisplayMode displayMode): displayOnDestruction(
+        displayOnDestruction), displayMode(displayMode) {
+    // Measures start time on initialization.
+    Clock::getClock_timeval(&startTime);
+}
+
+void Stopwatch::start() {
+    Clock::getClock_timeval(&startTime);
+}
+
+dur_millis_t Stopwatch::stop() {
+    stopInternal();
+    return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
+}
+
+dur_seconds_t Stopwatch::stopSeconds() {
+    stopInternal();
+    return timevalOperations::toDouble(elapsedTime);
+}
+
+void Stopwatch::display() {
+    if(displayMode == StopwatchDisplayMode::MILLIS) {
+        sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
+    }
+    else if(displayMode == StopwatchDisplayMode::SECONDS) {
+        sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
+             << std::fixed << timevalOperations::toDouble(elapsedTime)
+             << " seconds" << std::endl;
+    }
+}
+
+Stopwatch::~Stopwatch() {
+    if(displayOnDestruction) {
+        stopInternal();
+        display();
+    }
+}
+
+void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
+    this->displayMode = displayMode;
+}
+
+StopwatchDisplayMode Stopwatch::getDisplayMode() const {
+    return displayMode;
+}
+
+void Stopwatch::stopInternal() {
+	timeval endTime;
+	Clock::getClock_timeval(&endTime);
+    elapsedTime = endTime - startTime;
+}
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 30735b2c..191929dc 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,71 +1,71 @@
-#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include "../timemanager/Clock.h"
-
-enum class StopwatchDisplayMode {
-    MILLIS,
-    SECONDS
-};
-
-/**
- * @brief 	Simple Stopwatch implementation to measure elapsed time
- * @details
- * This class can be used to measure elapsed times. It also displays elapsed
- * times automatically on destruction if not explicitely deactivated in the
- * constructor. The default time format is the elapsed time in miliseconds
- * in seconds as a double.
- * @author 	R. Mueller
- */
-class Stopwatch {
-public:
-    /**
-     * Default constructor. Call "Stopwatch stopwatch" without brackets if
-     * no parameters are required!
-     * @param displayOnDestruction If set to true, displays measured time on
-     *        object destruction
-     * @param displayMode Display format is either MS rounded or MS as double
-     *        format
-     * @param outputPrecision If using double format, specify precision here.
-     */
-    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
-              = StopwatchDisplayMode::MILLIS);
-    virtual~ Stopwatch();
-
-    /**
-     * Caches the start time
-     */
-    void start();
-
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in milliseconds (rounded)
-     */
-    dur_millis_t stop();
-    /**
-     * Calculates the elapsed time since start and returns it
-     * @return elapsed time in seconds (double precision)
-     */
-    dur_seconds_t stopSeconds();
-
-    /**
-     * Displays the elapsed times on the osstream, depending on internal display
-     * mode.
-     */
-    void display();
-
-    StopwatchDisplayMode getDisplayMode() const;
-    void setDisplayMode(StopwatchDisplayMode displayMode);
-    bool displayOnDestruction = true;
-private:
-    timeval startTime {0, 0};
-    timeval elapsedTime {0, 0};
-
-    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
-
-    void stopInternal();
-};
-
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#include "../timemanager/Clock.h"
+
+enum class StopwatchDisplayMode {
+    MILLIS,
+    SECONDS
+};
+
+/**
+ * @brief 	Simple Stopwatch implementation to measure elapsed time
+ * @details
+ * This class can be used to measure elapsed times. It also displays elapsed
+ * times automatically on destruction if not explicitely deactivated in the
+ * constructor. The default time format is the elapsed time in miliseconds
+ * in seconds as a double.
+ * @author 	R. Mueller
+ */
+class Stopwatch {
+public:
+    /**
+     * Default constructor. Call "Stopwatch stopwatch" without brackets if
+     * no parameters are required!
+     * @param displayOnDestruction If set to true, displays measured time on
+     *        object destruction
+     * @param displayMode Display format is either MS rounded or MS as double
+     *        format
+     * @param outputPrecision If using double format, specify precision here.
+     */
+    Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode
+              = StopwatchDisplayMode::MILLIS);
+    virtual~ Stopwatch();
+
+    /**
+     * Caches the start time
+     */
+    void start();
+
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in milliseconds (rounded)
+     */
+    dur_millis_t stop();
+    /**
+     * Calculates the elapsed time since start and returns it
+     * @return elapsed time in seconds (double precision)
+     */
+    dur_seconds_t stopSeconds();
+
+    /**
+     * Displays the elapsed times on the osstream, depending on internal display
+     * mode.
+     */
+    void display();
+
+    StopwatchDisplayMode getDisplayMode() const;
+    void setDisplayMode(StopwatchDisplayMode displayMode);
+    bool displayOnDestruction = true;
+private:
+    timeval startTime {0, 0};
+    timeval elapsedTime {0, 0};
+
+    StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS;
+
+    void stopInternal();
+};
+
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index a60718a4..6e8dcd60 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,37 +1,37 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include "../timemanager/TimeMessage.h"
-
-TimeMessage::TimeMessage() {
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-}
-
-TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
-	memcpy (this->getData(), &setTime, sizeof(timeval));
-	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
-	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
-}
-
-TimeMessage::~TimeMessage() {
-}
-
-timeval TimeMessage::getTime() {
-	timeval temp;
-	memcpy( &temp, this->getData(), sizeof(timeval));
-	return temp;
-}
-
-uint32_t TimeMessage::getCounterValue() {
-	uint32_t temp;
-	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
-	return temp;
-}
-
-size_t TimeMessage::getMinimumMessageSize() {
-	return this->MAX_SIZE;
-}
+/**
+ * @file	TimeMessage.cpp
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#include "../timemanager/TimeMessage.h"
+
+TimeMessage::TimeMessage() {
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+}
+
+TimeMessage::TimeMessage(timeval setTime, uint32_t CounterValue) {
+	memcpy (this->getData(), &setTime, sizeof(timeval));
+	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
+	memcpy (this->getData() + sizeof(timeval), &CounterValue, sizeof(uint32_t));
+}
+
+TimeMessage::~TimeMessage() {
+}
+
+timeval TimeMessage::getTime() {
+	timeval temp;
+	memcpy( &temp, this->getData(), sizeof(timeval));
+	return temp;
+}
+
+uint32_t TimeMessage::getCounterValue() {
+	uint32_t temp;
+	memcpy ( &temp, this->getData() + sizeof(timeval), sizeof(uint32_t));
+	return temp;
+}
+
+size_t TimeMessage::getMinimumMessageSize() {
+	return this->MAX_SIZE;
+}
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index 1e440e5d..bb83708c 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,56 +1,56 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../timemanager/Clock.h"
-#include <cstring>
-
-class TimeMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-
-	/**
-	 * @ brief the size of a TimeMessage
-	 */
-	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
-
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TimeMessage();
-	/**
-	 * @brief	With this constructor, the passed time information is directly put
-	 * 			into the message.
-	 * @param 	setTime The time information to put into the message.
-	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
-	 */
-	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TimeMessage();
-	/**
-	 * @brief	This getter returns the time information in timeval format.
-	 * @return	Returns the time stored in this packet.
-	 */
-	timeval getTime();
-	/**
-	 * @brief 	This getter returns the CounterValue in uint32_t format.
-	 * @return 	Returns the CounterValue stored in this packet.
-	 */
-	uint32_t getCounterValue();
-};
-
-#endif /* TIMEMESSAGE_H_ */
+/**
+ * @file	TimeMessage.h
+ * @brief	This file defines the TimeMessage class.
+ * @date	26.02.2013
+ * @author	baetz
+ */
+
+#ifndef TIMEMESSAGE_H_
+#define TIMEMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../timemanager/Clock.h"
+#include <cstring>
+
+class TimeMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(timeval) + sizeof(uint32_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+
+	/**
+	 * @ brief the size of a TimeMessage
+	 */
+	static const uint32_t MAX_SIZE = HEADER_SIZE + sizeof(timeval) + sizeof(uint32_t);
+
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TimeMessage();
+	/**
+	 * @brief	With this constructor, the passed time information is directly put
+	 * 			into the message.
+	 * @param 	setTime The time information to put into the message.
+	 * @param 	counterValue The counterValue to put into the message (GPS PPS).
+	 */
+	TimeMessage( timeval setTime, uint32_t counterValue = 0 );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TimeMessage();
+	/**
+	 * @brief	This getter returns the time information in timeval format.
+	 * @return	Returns the time stored in this packet.
+	 */
+	timeval getTime();
+	/**
+	 * @brief 	This getter returns the CounterValue in uint32_t format.
+	 * @return 	Returns the CounterValue stored in this packet.
+	 */
+	uint32_t getCounterValue();
+};
+
+#endif /* TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 49e0ec18..bdc5e7e3 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,24 +1,24 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
-	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
-
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
-	virtual ~TimeStamperIF() {}
-};
-
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeStamperIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
+	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
+
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	virtual ~TimeStamperIF() {}
+};
+
+
+
+#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 0e20a314..bfabdd31 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,95 +1,95 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../parameters/HasParametersIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../timemanager/Clock.h"
-class TmPacketInformation;
-class TmPacketMinimal;
-class SpacePacketBase;
-class ApidSsc;
-
-class TmStoreBackendIF : public HasParametersIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
-	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
-	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
-	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
-	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
-	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
-	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
-
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
-
-	virtual ~TmStoreBackendIF() {}
-
-	/**
-	 * What do I need to implement here ?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	virtual ReturnValue_t initialize() = 0;
-
-	/**
-	 * Implement the storage of TM packets to mass memory
-	 * @param tmPacket
-	 * @return
-	 */
-	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
-	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
-	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
-	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
-	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
-
-	/**
-	 * TODO: Adapt for file management system?
-	 * @param startAddress
-	 * @param endAddress
-	 * @return
-	 */
-	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
-	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
-				uint32_t* deletedPackets) = 0;
-	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
-	virtual bool isReady() = 0;
-	virtual uint32_t availableData() = 0;
-	virtual float getPercentageFilled() const = 0;
-	virtual uint32_t getStoredPacketsCount() const = 0;
-	virtual TmPacketInformation* getOldestPacket() = 0;
-	virtual TmPacketInformation* getYoungestPacket() = 0;
-	virtual float getDataRate() = 0;
-
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../parameters/HasParametersIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../timemanager/Clock.h"
+class TmPacketInformation;
+class TmPacketMinimal;
+class SpacePacketBase;
+class ApidSsc;
+
+class TmStoreBackendIF : public HasParametersIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_BACKEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t FULL = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t NULL_REQUESTED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TOO_LARGE = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t DUMP_ERROR = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t CRC_ERROR = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(9);
+	static const ReturnValue_t IDLE_PACKET_FOUND = MAKE_RETURN_CODE(10);
+	static const ReturnValue_t TELECOMMAND_FOUND = MAKE_RETURN_CODE(11);
+	static const ReturnValue_t NO_PUS_A_TM = MAKE_RETURN_CODE(12);
+	static const ReturnValue_t TOO_SMALL = MAKE_RETURN_CODE(13);
+	static const ReturnValue_t BLOCK_NOT_FOUND = MAKE_RETURN_CODE(14);
+	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
+
+	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+
+	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * What do I need to implement here ?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
+	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
+	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
+	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
+	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
+	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * TODO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
+	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
+	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
+				uint32_t* deletedPackets) = 0;
+	virtual void resetStore(bool clearStore, bool resetWrite, bool resetRead) = 0;
+	virtual bool isReady() = 0;
+	virtual uint32_t availableData() = 0;
+	virtual float getPercentageFilled() const = 0;
+	virtual uint32_t getStoredPacketsCount() const = 0;
+	virtual TmPacketInformation* getOldestPacket() = 0;
+	virtual TmPacketInformation* getYoungestPacket() = 0;
+	virtual float getDataRate() = 0;
+
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index 7a2b3c9e..e0a7e078 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,63 +1,63 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmstorage/TmStorePackets.h"
-#include "../ipc/MessageQueueSenderIF.h"
-class TmPacketMinimal;
-class SpacePacketBase;
-class TmStoreBackendIF;
-
-class TmStoreFrontendIF {
-public:
-	virtual TmStoreBackendIF* getBackend() const = 0;
-
-	/**
-	 * What do I need to implement here?
-	 * This is propably used by PUS Service 15 so we should propably check for messages..
-	 * Provide base implementation?
-	 * @param opCode
-	 * @return
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
-	/**
-	 * Callback from the back-end to indicate a certain packet was received.
-	 * front-end takes care of discarding/downloading the packet.
-	 * @param packet	Pointer to the newly received Space Packet.
-	 * @param address	Start address of the packet found
-	 * @param isLastPacket	Indicates if no more packets can be fetched.
-	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
-	 * 			Any other code stops fetching packets.
-	 */
-	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
-	virtual void noMorePacketsInStore() = 0;
-	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
-	/**
-	 * To get the queue where commands shall be sent.
-	 * @return	Id of command queue.
-	 */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
-	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
-	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
-	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
-	virtual bool isEnabled() const = 0;
-	virtual void setEnabled(bool enabled) = 0;
-	virtual void resetDownlinkedPacketCount() = 0;
-	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
-	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
-	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
-	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
-	virtual ~TmStoreFrontendIF() {
-	}
-};
-
-
-
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../ipc/MessageQueueSenderIF.h"
+class TmPacketMinimal;
+class SpacePacketBase;
+class TmStoreBackendIF;
+
+class TmStoreFrontendIF {
+public:
+	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
+	/**
+	 * Callback from the back-end to indicate a certain packet was received.
+	 * front-end takes care of discarding/downloading the packet.
+	 * @param packet	Pointer to the newly received Space Packet.
+	 * @param address	Start address of the packet found
+	 * @param isLastPacket	Indicates if no more packets can be fetched.
+	 * @return	If more packets shall be fetched, RETURN_OK must be returned.
+	 * 			Any other code stops fetching packets.
+	 */
+	virtual ReturnValue_t packetRetrieved(TmPacketMinimal* packet, uint32_t address) = 0;
+	virtual void noMorePacketsInStore() = 0;
+	virtual void handleRetrievalFailed(ReturnValue_t errorCode, uint32_t parameter1 = 0, uint32_t parameter2 = 0) = 0;
+	/**
+	 * To get the queue where commands shall be sent.
+	 * @return	Id of command queue.
+	 */
+	virtual MessageQueueId_t getCommandQueue() const = 0;
+	virtual ReturnValue_t fetchPackets(ApidSsc start, ApidSsc end) = 0;
+	virtual ReturnValue_t deletePackets(ApidSsc upTo) = 0;
+	virtual ReturnValue_t checkPacket(SpacePacketBase* tmPacket) = 0;
+	virtual bool isEnabled() const = 0;
+	virtual void setEnabled(bool enabled) = 0;
+	virtual void resetDownlinkedPacketCount() = 0;
+	virtual ReturnValue_t setDumpTarget(object_id_t dumpTarget) = 0;
+	static const uint8_t INTERFACE_ID = CLASS_ID::TM_STORE_FRONTEND_IF;
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t LAST_PACKET_FOUND = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t STOP_FETCH = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TM_CHANNEL_FULL = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t NOT_STORED = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t ALL_DELETED = MAKE_RETURN_CODE(7);
+	static const ReturnValue_t INVALID_DATA = MAKE_RETURN_CODE(8);
+	static const ReturnValue_t NOT_READY = MAKE_RETURN_CODE(9);
+	virtual ~TmStoreFrontendIF() {
+	}
+};
+
+
+
+#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 0436442b..753ac1b7 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,165 +1,165 @@
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
-
-TmStoreMessage::~TmStoreMessage() {
-	
-}
-
-TmStoreMessage::TmStoreMessage() {
-}
-
-ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
-		bool setEnabled) {
-	cmd->setCommand(ENABLE_STORING);
-	cmd->setParameter(setEnabled);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
-		ApidSsc upTo) {
-	cmd->setCommand(DELETE_STORE_CONTENT);
-	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
-		ApidSsc fromPacket,
-		ApidSsc toPacket) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT);
-	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
-	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter() & 0xFFFF;
-	return temp;
-}
-
-ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
-	ApidSsc temp;
-	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
-	temp.ssc = cmd->getParameter2() & 0xFFFF;
-	return temp;
-}
-
-bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-void TmStoreMessage::setChangeSelectionDefinitionMessage(
-		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
-	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
-	cmd->setParameter(addDefinition);
-	cmd->setParameter2(store_id.raw);
-}
-
-void TmStoreMessage::clear(CommandMessage* cmd) {
-	switch(cmd->getCommand()) {
-	case SELECTION_DEFINITION_REPORT:
-	case STORE_CATALOGUE_REPORT:
-	case CHANGE_SELECTION_DEFINITION:
-	case INDEX_REPORT:
-	case DELETE_STORE_CONTENT_TIME:
-	case DOWNLINK_STORE_CONTENT_TIME: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(cmd));
-		}
-	}
-	/* NO BREAK falls through*/
-	case DELETE_STORE_CONTENT_BLOCKS:
-	case DOWNLINK_STORE_CONTENT_BLOCKS:
-	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
-		cmd->setParameter(0);
-		cmd->setParameter2(0);
-		break;
-	default:
-		break;
-	}
-}
-
-store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
-	store_address_t temp;
-	temp.raw = cmd->getParameter2();
-	return temp;
-}
-
-bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
-	return (bool)cmd->getParameter();
-}
-
-ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_SELECTION_DEFINITION);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setSelectionDefinitionReportMessage(
-		CommandMessage* cmd, store_address_t storeId) {
-	cmd->setCommand(SELECTION_DEFINITION_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
-		CommandMessage* cmd) {
-	cmd->setCommand(REPORT_STORE_CATALOGUE);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-		store_address_t storeId) {
-	cmd->setCommand(STORE_CATALOGUE_REPORT);
-	cmd->setParameter(objectId);
-	cmd->setParameter2(storeId.raw);
-}
-
-object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
-	return cmd->getParameter();
-}
-
-void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
-	return cmd->getParameter();
-}
-uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
-	return cmd->getParameter2();
-}
-
-void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
-		store_address_t storeId) {
-	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
-	cmd->setParameter2(storeId.raw);
-}
-
-ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
-	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
-	cmd->setParameter(addressLow);
-	cmd->setParameter2(addressHigh);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
-	cmd->setCommand(REPORT_INDEX_REQUEST);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
-	cmd->setCommand(INDEX_REPORT);
-	cmd->setParameter2(storeId.raw);
-}
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmstorage/TmStoreMessage.h"
+
+TmStoreMessage::~TmStoreMessage() {
+	
+}
+
+TmStoreMessage::TmStoreMessage() {
+}
+
+ReturnValue_t TmStoreMessage::setEnableStoringMessage(CommandMessage* cmd,
+		bool setEnabled) {
+	cmd->setCommand(ENABLE_STORING);
+	cmd->setParameter(setEnabled);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDeleteContentMessage(CommandMessage* cmd,
+		ApidSsc upTo) {
+	cmd->setCommand(DELETE_STORE_CONTENT);
+	cmd->setParameter((upTo.apid<<16) + upTo.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmStoreMessage::setDownlinkContentMessage(CommandMessage* cmd,
+		ApidSsc fromPacket,
+		ApidSsc toPacket) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT);
+	cmd->setParameter((fromPacket.apid<<16) + fromPacket.ssc);
+	cmd->setParameter2((toPacket.apid<<16) + toPacket.ssc);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ApidSsc TmStoreMessage::getPacketId1(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter() & 0xFFFF;
+	return temp;
+}
+
+ApidSsc TmStoreMessage::getPacketId2(CommandMessage* cmd) {
+	ApidSsc temp;
+	temp.apid = (cmd->getParameter2() >> 16) & 0xFFFF;
+	temp.ssc = cmd->getParameter2() & 0xFFFF;
+	return temp;
+}
+
+bool TmStoreMessage::getEnableStoring(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+void TmStoreMessage::setChangeSelectionDefinitionMessage(
+		CommandMessage* cmd, bool addDefinition, store_address_t store_id) {
+	cmd->setCommand(CHANGE_SELECTION_DEFINITION);
+	cmd->setParameter(addDefinition);
+	cmd->setParameter2(store_id.raw);
+}
+
+void TmStoreMessage::clear(CommandMessage* cmd) {
+	switch(cmd->getCommand()) {
+	case SELECTION_DEFINITION_REPORT:
+	case STORE_CATALOGUE_REPORT:
+	case CHANGE_SELECTION_DEFINITION:
+	case INDEX_REPORT:
+	case DELETE_STORE_CONTENT_TIME:
+	case DOWNLINK_STORE_CONTENT_TIME: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+				objects::IPC_STORE);
+		if (ipcStore != NULL) {
+			ipcStore->deleteData(getStoreId(cmd));
+		}
+	}
+	/* NO BREAK falls through*/
+	case DELETE_STORE_CONTENT_BLOCKS:
+	case DOWNLINK_STORE_CONTENT_BLOCKS:
+	case REPORT_INDEX_REQUEST:
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
+		cmd->setParameter(0);
+		cmd->setParameter2(0);
+		break;
+	default:
+		break;
+	}
+}
+
+store_address_t TmStoreMessage::getStoreId(const CommandMessage* cmd) {
+	store_address_t temp;
+	temp.raw = cmd->getParameter2();
+	return temp;
+}
+
+bool TmStoreMessage::getAddToSelection(CommandMessage* cmd) {
+	return (bool)cmd->getParameter();
+}
+
+ReturnValue_t TmStoreMessage::setReportSelectionDefinitionMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_SELECTION_DEFINITION);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setSelectionDefinitionReportMessage(
+		CommandMessage* cmd, store_address_t storeId) {
+	cmd->setCommand(SELECTION_DEFINITION_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setReportStoreCatalogueMessage(
+		CommandMessage* cmd) {
+	cmd->setCommand(REPORT_STORE_CATALOGUE);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmStoreMessage::setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+		store_address_t storeId) {
+	cmd->setCommand(STORE_CATALOGUE_REPORT);
+	cmd->setParameter(objectId);
+	cmd->setParameter2(storeId.raw);
+}
+
+object_id_t TmStoreMessage::getObjectId(CommandMessage* cmd) {
+	return cmd->getParameter();
+}
+
+void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd){
+	return cmd->getParameter();
+}
+uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd){
+	return cmd->getParameter2();
+}
+
+void TmStoreMessage::setDeleteContentTimeMessage(CommandMessage* cmd,
+		store_address_t storeId) {
+	cmd->setCommand(DELETE_STORE_CONTENT_TIME);
+	cmd->setParameter2(storeId.raw);
+}
+
+ReturnValue_t TmStoreMessage::setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DELETE_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh){
+	cmd->setCommand(DOWNLINK_STORE_CONTENT_BLOCKS);
+	cmd->setParameter(addressLow);
+	cmd->setParameter2(addressHigh);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t TmStoreMessage::setIndexRequestMessage(CommandMessage* cmd){
+	cmd->setCommand(REPORT_INDEX_REQUEST);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+void TmStoreMessage::setIndexReportMessage(CommandMessage* cmd, store_address_t storeId){
+	cmd->setCommand(INDEX_REPORT);
+	cmd->setParameter2(storeId.raw);
+}
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index ce10519b..59354a20 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,63 +1,63 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
-#include "../objectmanager/SystemObjectIF.h"
-class TmStoreMessage  {
-public:
-	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
-			bool setEnabled);
-	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
-			ApidSsc upTo);
-	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
-			ApidSsc fromPacket, ApidSsc toPacket);
-	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
-			bool addDefinition, store_address_t store_id);
-	static ReturnValue_t setReportSelectionDefinitionMessage(
-			CommandMessage* cmd);
-	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
-	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
-			store_address_t storeId);
-	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
-	static void setDeleteContentTimeMessage(CommandMessage* cmd,
-			store_address_t storeId);
-	static void clear(CommandMessage* cmd);
-	static object_id_t getObjectId(CommandMessage* cmd);
-	static ApidSsc getPacketId1(CommandMessage* cmd);
-	static ApidSsc getPacketId2(CommandMessage* cmd);
-	static bool getEnableStoring(CommandMessage* cmd);
-	static bool getAddToSelection(CommandMessage* cmd);
-	static uint32_t getAddressLow(CommandMessage* cmd);
-	static uint32_t getAddressHigh(CommandMessage* cmd);
-
-	static store_address_t getStoreId(const CommandMessage* cmd);
-	virtual ~TmStoreMessage();
-	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
-	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
-	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
-	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
-	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
-	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
-	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
-	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
-	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
-	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
-	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
-	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
-	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-private:
-	TmStoreMessage();
-};
-
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmstorage/TmStorePackets.h"
+#include "../objectmanager/SystemObjectIF.h"
+class TmStoreMessage  {
+public:
+	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
+			bool setEnabled);
+	static ReturnValue_t setDeleteContentMessage(CommandMessage* cmd,
+			ApidSsc upTo);
+	static ReturnValue_t setDownlinkContentMessage(CommandMessage* cmd,
+			ApidSsc fromPacket, ApidSsc toPacket);
+	static void setChangeSelectionDefinitionMessage(CommandMessage* cmd,
+			bool addDefinition, store_address_t store_id);
+	static ReturnValue_t setReportSelectionDefinitionMessage(
+			CommandMessage* cmd);
+	static void setSelectionDefinitionReportMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static ReturnValue_t setReportStoreCatalogueMessage(CommandMessage* cmd);
+	static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
+			store_address_t storeId);
+	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
+	static void setDeleteContentTimeMessage(CommandMessage* cmd,
+			store_address_t storeId);
+	static void clear(CommandMessage* cmd);
+	static object_id_t getObjectId(CommandMessage* cmd);
+	static ApidSsc getPacketId1(CommandMessage* cmd);
+	static ApidSsc getPacketId2(CommandMessage* cmd);
+	static bool getEnableStoring(CommandMessage* cmd);
+	static bool getAddToSelection(CommandMessage* cmd);
+	static uint32_t getAddressLow(CommandMessage* cmd);
+	static uint32_t getAddressHigh(CommandMessage* cmd);
+
+	static store_address_t getStoreId(const CommandMessage* cmd);
+	virtual ~TmStoreMessage();
+	static const uint8_t MESSAGE_ID = messagetypes::TM_STORE;
+	static const Command_t ENABLE_STORING = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_STORE_CONTENT = MAKE_COMMAND_ID(2);
+	static const Command_t DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(3);
+	static const Command_t CHANGE_SELECTION_DEFINITION = MAKE_COMMAND_ID(4);
+	static const Command_t REPORT_SELECTION_DEFINITION = MAKE_COMMAND_ID(5);
+	static const Command_t SELECTION_DEFINITION_REPORT = MAKE_COMMAND_ID(6);
+	static const Command_t REPORT_STORE_CATALOGUE = MAKE_COMMAND_ID(7);
+	static const Command_t STORE_CATALOGUE_REPORT = MAKE_COMMAND_ID(8);
+	static const Command_t DOWNLINK_STORE_CONTENT_TIME = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_STORE_CONTENT_TIME = MAKE_COMMAND_ID(10);
+	static const Command_t DELETE_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(11);
+	static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
+	static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
+	static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
+private:
+	TmStoreMessage();
+};
+
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 3c8e1a24..4ce64fe6 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,300 +1,300 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-
-#include "../serialize/SerialFixedArrayListAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../serialize/SerialBufferAdapter.h"
-#include "../tmtcpacket/pus/TmPacketMinimal.h"
-#include "../timemanager/TimeStamperIF.h"
-#include "../timemanager/CCSDSTime.h"
-#include "../globalfunctions/timevalOperations.h"
-
-class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint8_t> service;
-	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
-	LinkedElement<SerializeIF> linkedSubservices;
-	ServiceSubservice() :
-			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
-					&subservices) {
-		service.setNext(&linkedSubservices);
-	}
-};
-
-class ApidSsc: public SerializeIF {
-public:
-	ApidSsc() :
-			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
-	}
-	ApidSsc(uint16_t apid, uint16_t ssc) :
-			apid(apid), ssc(ssc) {
-	}
-	uint16_t apid;
-	uint16_t ssc;
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,
-				buffer, size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::serialize(&ssc, buffer, size,
-				maxSize, streamEndianness);
-
-	}
-
-	size_t getSerializedSize() const {
-		return sizeof(apid) + sizeof(ssc);
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
-				buffer, size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return SerializeAdapter::deSerialize(&ssc, buffer, size,
-				streamEndianness);
-	}
-};
-
-class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
-public:
-	SerializeElement<uint16_t> apid;
-	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
-	LinkedElement<SerializeIF> linkedServiceList;
-	ChangeSelectionDefinition() :
-			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
-					&serviceList) {
-		apid.setNext(&linkedServiceList);
-	}
-};
-
-class TmPacketInformation: public SerializeIF {
-public:
-	TmPacketInformation(TmPacketMinimal* packet){
-		setContent(packet);
-	}
-	TmPacketInformation() :apid(
-					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
-					0), serviceSubtype(0), subCounter(0) {
-	}
-	void reset() {
-		apid = SpacePacketBase::LIMIT_APID;
-		sourceSequenceCount = 0;
-		serviceType = 0;
-		serviceSubtype = 0;
-		subCounter = 0;
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-	}
-	void setContent(TmPacketMinimal* packet) {
-		apid = packet->getAPID();
-		sourceSequenceCount = packet->getPacketSequenceCount();
-		serviceType = packet->getService();
-		serviceSubtype = packet->getSubService();
-		subCounter = packet->getPacketSubcounter();
-		memset(rawTimestamp, 0, sizeof(rawTimestamp));
-		const uint8_t* pField = NULL;
-		uint32_t size = 0;
-		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
-				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
-			//Shortcut to avoid converting CDS back and forth.
-			memcpy(rawTimestamp, pField, size);
-			return;
-		}
-		timeval time = { 0, 0 };
-		result = packet->getPacketTime(&time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-
-		CCSDSTime::CDS_short cdsFormat;
-		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return;
-		}
-		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
-	}
-	void setContent(TmPacketInformation* content) {
-		apid = content->apid;
-		sourceSequenceCount = content->sourceSequenceCount;
-		serviceType = content->serviceType;
-		serviceSubtype = content->serviceSubtype;
-		subCounter = content->subCounter;
-		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
-	}
-	bool isValid() const {
-		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
-	}
-	static void reset(TmPacketInformation* packet){
-		packet->reset();
-	}
-
-	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime <= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
-		if(packet->isValid()){
-			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-			if(packetTime >= *cmpTime){
-				return true;
-			}
-		}
-		return false;
-	}
-
-	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount <= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
-		if(packet->isValid()){
-			if(packet->apid == compareSSC->apid){
-				if(packet->sourceSequenceCount >= compareSSC->ssc){
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	uint16_t getApid() const{
-		return apid;
-	}
-
-	uint16_t getSsc() const{
-		return sourceSequenceCount;
-	}
-
-	uint8_t getServiceType() const{
-		return serviceType;
-	}
-
-	uint8_t getServiceSubtype() const{
-		return serviceSubtype;
-	}
-
-	uint8_t getSubCounter() const{
-		return subCounter;
-	}
-
-	timeval getTime() const {
-		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
-		return packetTime;
-	}
-
-	bool operator==(const TmPacketInformation& other) {
-		//TODO Does not compare Raw Timestamp
-		return ((apid == other.getApid())
-				&& (sourceSequenceCount == other.getSsc())
-				&& (serviceType == other.getServiceType()) && (serviceSubtype =
-						other.getServiceSubtype()));
-	}
-
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
-		if(result!=HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.serialize(buffer,size,maxSize,streamEndianness);
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&apid);
-		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
-		size += SerializeAdapter::getSerializedSize(&serviceType);
-		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
-		size += SerializeAdapter::getSerializedSize(&subCounter);
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		size += adapter.getSerializedSize();
-		return size;
-
-	};
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
-				size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
-		return adapter.deSerialize(buffer,size,streamEndianness);
-	}
-
-private:
-	uint16_t apid;
-	uint16_t sourceSequenceCount;
-	uint8_t serviceType;
-	uint8_t serviceSubtype;
-	uint8_t subCounter;
-	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-
-};
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+
+#include "../serialize/SerialFixedArrayListAdapter.h"
+#include "../serialize/SerializeElement.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../serialize/SerialBufferAdapter.h"
+#include "../tmtcpacket/pus/TmPacketMinimal.h"
+#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/CCSDSTime.h"
+#include "../globalfunctions/timevalOperations.h"
+
+class ServiceSubservice: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint8_t> service;
+	SerialFixedArrayListAdapter<uint8_t, 16> subservices;
+	LinkedElement<SerializeIF> linkedSubservices;
+	ServiceSubservice() :
+			SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(
+					&subservices) {
+		service.setNext(&linkedSubservices);
+	}
+};
+
+class ApidSsc: public SerializeIF {
+public:
+	ApidSsc() :
+			apid(SpacePacketBase::LIMIT_APID), ssc(0) {
+	}
+	ApidSsc(uint16_t apid, uint16_t ssc) :
+			apid(apid), ssc(ssc) {
+	}
+	uint16_t apid;
+	uint16_t ssc;
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,
+				buffer, size, maxSize, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::serialize(&ssc, buffer, size,
+				maxSize, streamEndianness);
+
+	}
+
+	size_t getSerializedSize() const {
+		return sizeof(apid) + sizeof(ssc);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
+				buffer, size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return SerializeAdapter::deSerialize(&ssc, buffer, size,
+				streamEndianness);
+	}
+};
+
+class ChangeSelectionDefinition: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	SerializeElement<uint16_t> apid;
+	SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
+	LinkedElement<SerializeIF> linkedServiceList;
+	ChangeSelectionDefinition() :
+			SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(
+					&serviceList) {
+		apid.setNext(&linkedServiceList);
+	}
+};
+
+class TmPacketInformation: public SerializeIF {
+public:
+	TmPacketInformation(TmPacketMinimal* packet){
+		setContent(packet);
+	}
+	TmPacketInformation() :apid(
+					SpacePacketBase::LIMIT_APID), sourceSequenceCount(0), serviceType(
+					0), serviceSubtype(0), subCounter(0) {
+	}
+	void reset() {
+		apid = SpacePacketBase::LIMIT_APID;
+		sourceSequenceCount = 0;
+		serviceType = 0;
+		serviceSubtype = 0;
+		subCounter = 0;
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+	}
+	void setContent(TmPacketMinimal* packet) {
+		apid = packet->getAPID();
+		sourceSequenceCount = packet->getPacketSequenceCount();
+		serviceType = packet->getService();
+		serviceSubtype = packet->getSubService();
+		subCounter = packet->getPacketSubcounter();
+		memset(rawTimestamp, 0, sizeof(rawTimestamp));
+		const uint8_t* pField = NULL;
+		uint32_t size = 0;
+		ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		if (*pField == CCSDSTime::P_FIELD_CDS_SHORT
+				&& size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
+			//Shortcut to avoid converting CDS back and forth.
+			memcpy(rawTimestamp, pField, size);
+			return;
+		}
+		timeval time = { 0, 0 };
+		result = packet->getPacketTime(&time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+
+		CCSDSTime::CDS_short cdsFormat;
+		result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return;
+		}
+		memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
+	}
+	void setContent(TmPacketInformation* content) {
+		apid = content->apid;
+		sourceSequenceCount = content->sourceSequenceCount;
+		serviceType = content->serviceType;
+		serviceSubtype = content->serviceSubtype;
+		subCounter = content->subCounter;
+		memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
+	}
+	bool isValid() const {
+		return (apid < SpacePacketBase::LIMIT_APID) ? true : false;
+	}
+	static void reset(TmPacketInformation* packet){
+		packet->reset();
+	}
+
+	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime <= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
+		if(packet->isValid()){
+			timeval packetTime = {0,0};
+			uint32_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			if(packetTime >= *cmpTime){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	static bool isSmallerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount <= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	static bool isLargerSSC(const TmPacketInformation* packet,const ApidSsc* compareSSC){
+		if(packet->isValid()){
+			if(packet->apid == compareSSC->apid){
+				if(packet->sourceSequenceCount >= compareSSC->ssc){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	uint16_t getApid() const{
+		return apid;
+	}
+
+	uint16_t getSsc() const{
+		return sourceSequenceCount;
+	}
+
+	uint8_t getServiceType() const{
+		return serviceType;
+	}
+
+	uint8_t getServiceSubtype() const{
+		return serviceSubtype;
+	}
+
+	uint8_t getSubCounter() const{
+		return subCounter;
+	}
+
+	timeval getTime() const {
+		timeval packetTime = {0,0};
+		uint32_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		return packetTime;
+	}
+
+	bool operator==(const TmPacketInformation& other) {
+		//TODO Does not compare Raw Timestamp
+		return ((apid == other.getApid())
+				&& (sourceSequenceCount == other.getSsc())
+				&& (serviceType == other.getServiceType()) && (serviceSubtype =
+						other.getServiceSubtype()));
+	}
+
+
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
+		if(result!=HasReturnvaluesIF::RETURN_OK){
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.serialize(buffer,size,maxSize,streamEndianness);
+	}
+
+	size_t getSerializedSize() const {
+		uint32_t size = 0;
+		size += SerializeAdapter::getSerializedSize(&apid);
+		size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
+		size += SerializeAdapter::getSerializedSize(&serviceType);
+		size += SerializeAdapter::getSerializedSize(&serviceSubtype);
+		size += SerializeAdapter::getSerializedSize(&subCounter);
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		size += adapter.getSerializedSize();
+		return size;
+
+	};
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+	        Endianness streamEndianness) {
+		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
+				size, streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
+		return adapter.deSerialize(buffer,size,streamEndianness);
+	}
+
+private:
+	uint16_t apid;
+	uint16_t sourceSequenceCount;
+	uint8_t serviceType;
+	uint8_t serviceSubtype;
+	uint8_t subCounter;
+	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+
+};
+#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index c04e143f..2bf6e3dc 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,27 +1,27 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/ccsds_header.h"
-#include "../tmtcpacket/SpacePacket.h"
-#include <string.h>
-
-SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
-SpacePacketBase( (uint8_t*)&this->localData ) {
-	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
-	this->setPacketSequenceCount(sequenceCount);
-	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
-		this->setPacketDataLength(packetDataLength);
-	} else {
-		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
-	}
-}
-
-SpacePacket::~SpacePacket( void ) {
-}
-
-bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
-	if ( packet_size <= sizeof(this->data) ) {
-		memcpy( &this->localData.byteStream, p_Data, packet_size );
-		return true;
-	} else {
-		return false;
-	}
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/ccsds_header.h"
+#include "../tmtcpacket/SpacePacket.h"
+#include <string.h>
+
+SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
+SpacePacketBase( (uint8_t*)&this->localData ) {
+	initSpacePacketHeader(isTelecommand, false, apid, sequenceCount);
+	this->setPacketSequenceCount(sequenceCount);
+	if ( packetDataLength <= sizeof(this->localData.fields.buffer) ) {
+		this->setPacketDataLength(packetDataLength);
+	} else {
+		this->setPacketDataLength( sizeof(this->localData.fields.buffer) );
+	}
+}
+
+SpacePacket::~SpacePacket( void ) {
+}
+
+bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
+	if ( packet_size <= sizeof(this->data) ) {
+		memcpy( &this->localData.byteStream, p_Data, packet_size );
+		return true;
+	} else {
+		return false;
+	}
+}
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index a75b9ae3..ea1d0468 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,70 +1,70 @@
-#ifndef SPACEPACKET_H_
-#define SPACEPACKET_H_
-
-#include "../tmtcpacket/SpacePacketBase.h"
-
-/**
- * The SpacePacket class is a representation of a simple CCSDS Space Packet
- * without (control over) a secondary header.
- * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
- * main use is to serve as an idle packet in case no other packets are sent.
- * For the ECSS PUS part the TcPacket and TmPacket classes are used.
- * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
- * so the parent's methods are reachable.
- * @ingroup tmtcpackets
- */
-class SpacePacket: public SpacePacketBase {
-public:
-	static const uint16_t PACKET_MAX_SIZE = 1024;
-	/**
-	 * The constructor initializes the packet and sets all header information
-	 * according to the passed parameters.
-	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
-	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
-	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
-	 * @param sequenceCount ets the packet's Source Sequence Count field.
-	 */
-	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
-			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
-	/**
-	 * The class's default destructor.
-	 */
-	virtual ~SpacePacket();
-	/**
-	 * With this call, the complete data content (including the CCSDS Primary
-	 * Header) is overwritten with the byte stream given.
-	 * @param p_data		Pointer to data to overwrite the content with
-	 * @param packet_size	Size of the data
-	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
-	 * 			@li \c false else.
-	 */
-	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
-protected:
-	/**
-	 * This structure defines the data structure of a Space Packet as local data.
-	 * There's a buffer which corresponds to the Space Packet Data Field with a
-	 * maximum size of \c PACKET_MAX_SIZE.
-	 */
-	struct PacketStructured {
-		CCSDSPrimaryHeader header;
-		uint8_t buffer[PACKET_MAX_SIZE];
-	};
-	/**
-	 * This union simplifies accessing the full data content of the Space Packet.
-	 * This is achieved by putting the \c PacketStructured struct in a union with
-	 * a plain buffer.
-	 */
-	union SpacePacketData {
-		PacketStructured fields;
-		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
-	};
-	/**
-	 * This is the data representation of the class.
-	 * It is a struct of CCSDS Primary Header and a data field, which again is
-	 * packed in an union, so the data can be accessed as a byte stream without
-	 * a cast.
-	 */
-	SpacePacketData localData;
-};
-
-#endif /* SPACEPACKET_H_ */
+#ifndef SPACEPACKET_H_
+#define SPACEPACKET_H_
+
+#include "../tmtcpacket/SpacePacketBase.h"
+
+/**
+ * The SpacePacket class is a representation of a simple CCSDS Space Packet
+ * without (control over) a secondary header.
+ * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
+ * main use is to serve as an idle packet in case no other packets are sent.
+ * For the ECSS PUS part the TcPacket and TmPacket classes are used.
+ * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
+ * so the parent's methods are reachable.
+ * @ingroup tmtcpackets
+ */
+class SpacePacket: public SpacePacketBase {
+public:
+	static const uint16_t PACKET_MAX_SIZE = 1024;
+	/**
+	 * The constructor initializes the packet and sets all header information
+	 * according to the passed parameters.
+	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
+	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
+	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
+	 * @param sequenceCount ets the packet's Source Sequence Count field.
+	 */
+	SpacePacket(uint16_t packetDataLength, bool isTelecommand = false,
+			uint16_t apid = APID_IDLE_PACKET, uint16_t sequenceCount = 0);
+	/**
+	 * The class's default destructor.
+	 */
+	virtual ~SpacePacket();
+	/**
+	 * With this call, the complete data content (including the CCSDS Primary
+	 * Header) is overwritten with the byte stream given.
+	 * @param p_data		Pointer to data to overwrite the content with
+	 * @param packet_size	Size of the data
+	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
+	 * 			@li \c false else.
+	 */
+	bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
+protected:
+	/**
+	 * This structure defines the data structure of a Space Packet as local data.
+	 * There's a buffer which corresponds to the Space Packet Data Field with a
+	 * maximum size of \c PACKET_MAX_SIZE.
+	 */
+	struct PacketStructured {
+		CCSDSPrimaryHeader header;
+		uint8_t buffer[PACKET_MAX_SIZE];
+	};
+	/**
+	 * This union simplifies accessing the full data content of the Space Packet.
+	 * This is achieved by putting the \c PacketStructured struct in a union with
+	 * a plain buffer.
+	 */
+	union SpacePacketData {
+		PacketStructured fields;
+		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 * It is a struct of CCSDS Primary Header and a data field, which again is
+	 * packed in an union, so the data can be accessed as a byte stream without
+	 * a cast.
+	 */
+	SpacePacketData localData;
+};
+
+#endif /* SPACEPACKET_H_ */
diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 3d3a51e3..044ce510 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,104 +1,104 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-#include <string.h>
-
-SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
-	this->data = (SpacePacketPointer*) set_address;
-}
-
-SpacePacketBase::~SpacePacketBase() {
-};
-
-//CCSDS Methods:
-uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
-	return (this->data->header.packet_id_h & 0b11100000) >> 5;
-}
-
-void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
-		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
-	//reset header to zero:
-	memset(data,0, sizeof(this->data->header) );
-	//Set TC/TM bit.
-	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
-	//Set secondaryHeader bit
-	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
-	this->setAPID( apid );
-	//Always initialize as standalone packets.
-	data->header.sequence_control_h = 0b11000000;
-	setPacketSequenceCount(sequenceCount);
-
-}
-
-bool SpacePacketBase::isTelecommand( void ) {
-	return (this->data->header.packet_id_h & 0b00010000) >> 4;
-}
-
-bool SpacePacketBase::hasSecondaryHeader( void ) {
-	return (this->data->header.packet_id_h & 0b00001000) >> 3;
-}
-
-uint16_t SpacePacketBase::getPacketId() {
-	return ( (this->data->header.packet_id_h) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-uint16_t SpacePacketBase::getAPID( void ) const {
-	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
-			this->data->header.packet_id_l;
-}
-
-void SpacePacketBase::setAPID( uint16_t new_apid ) {
-	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
-	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
-	this->data->header.packet_id_l = ( new_apid & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
-	return ( (this->data->header.sequence_control_h) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-uint8_t SpacePacketBase::getSequenceFlags( void ) {
-	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
-}
-
-uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
-	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
-		+ this->data->header.sequence_control_l;
-}
-
-void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
-	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
-	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
-}
-
-uint16_t SpacePacketBase::getPacketDataLength( void ) {
-	return ( (this->data->header.packet_length_h) << 8 )
-		+ this->data->header.packet_length_l;
-}
-
-void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
-	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
-	this->data->header.packet_length_l = ( new_length & 0x00FF );
-}
-
-size_t SpacePacketBase::getFullSize() {
-	//+1 is done because size in packet data length field is: size of data field -1
-	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
-}
-
-uint8_t* SpacePacketBase::getWholeData() {
-	return (uint8_t*)this->data;
-}
-
-void SpacePacketBase::setData( const uint8_t* p_Data ) {
-	this->data = (SpacePacketPointer*)p_Data;
-}
-
-uint32_t SpacePacketBase::getApidAndSequenceCount() const {
-	return (getAPID() << 16) + getPacketSequenceCount();
-}
-
-uint8_t* SpacePacketBase::getPacketData() {
-	return &(data->packet_data);
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+#include <string.h>
+
+SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
+	this->data = (SpacePacketPointer*) set_address;
+}
+
+SpacePacketBase::~SpacePacketBase() {
+};
+
+//CCSDS Methods:
+uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
+	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+}
+
+void SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
+		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+	//reset header to zero:
+	memset(data,0, sizeof(this->data->header) );
+	//Set TC/TM bit.
+	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
+	//Set secondaryHeader bit
+	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
+	this->setAPID( apid );
+	//Always initialize as standalone packets.
+	data->header.sequence_control_h = 0b11000000;
+	setPacketSequenceCount(sequenceCount);
+
+}
+
+bool SpacePacketBase::isTelecommand( void ) {
+	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+}
+
+bool SpacePacketBase::hasSecondaryHeader( void ) {
+	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+}
+
+uint16_t SpacePacketBase::getPacketId() {
+	return ( (this->data->header.packet_id_h) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+uint16_t SpacePacketBase::getAPID( void ) const {
+	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+void SpacePacketBase::setAPID( uint16_t new_apid ) {
+	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
+	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
+	return ( (this->data->header.sequence_control_h) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+uint8_t SpacePacketBase::getSequenceFlags( void ) {
+	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+}
+
+uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
+	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
+	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketDataLength( void ) {
+	return ( (this->data->header.packet_length_h) << 8 )
+		+ this->data->header.packet_length_l;
+}
+
+void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
+	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+	this->data->header.packet_length_l = ( new_length & 0x00FF );
+}
+
+size_t SpacePacketBase::getFullSize() {
+	//+1 is done because size in packet data length field is: size of data field -1
+	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+}
+
+uint8_t* SpacePacketBase::getWholeData() {
+	return (uint8_t*)this->data;
+}
+
+void SpacePacketBase::setData( const uint8_t* p_Data ) {
+	this->data = (SpacePacketPointer*)p_Data;
+}
+
+uint32_t SpacePacketBase::getApidAndSequenceCount() const {
+	return (getAPID() << 16) + getPacketSequenceCount();
+}
+
+uint8_t* SpacePacketBase::getPacketData() {
+	return &(data->packet_data);
+}
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index a132bfd1..c7a63ae6 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,177 +1,177 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
-
-#include "../tmtcpacket/ccsds_header.h"
-#include <cstddef>
-
-/**
- * @defgroup tmtcpackets Space Packets
- * This is the group, where all classes associated with Telecommand and
- * Telemetry packets belong to.
- * The class hierarchy resembles the dependency between the different standards
- * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
- * Utilization Standard. Most field and structure names are taken from these
- * standards.
- */
-
-/**
- * This struct defines the data structure of a Space Packet when accessed
- * via a pointer.
- * @ingroup tmtcpackets
- */
-struct SpacePacketPointer {
-	CCSDSPrimaryHeader header;
-	uint8_t packet_data;
-};
-
-/**
- * This class is the basic data handler for any CCSDS Space Packet
- * compatible Telecommand and Telemetry packet.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * Remark: All bit numbers in this documentation are counted from
- * the most significant bit (from left).
- * @ingroup tmtcpackets
- */
-class SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet header.
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	SpacePacketPointer* data;
-public:
-	static const uint16_t LIMIT_APID = 2048; //2^1
-	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
-	static const uint16_t APID_IDLE_PACKET = 0x7FF;
-	static const uint8_t TELECOMMAND_PACKET = 1;
-	static const uint8_t TELEMETRY_PACKET = 0;
-	/**
-	 * This definition defines the CRC size in byte.
-	 */
-	static const uint8_t CRC_SIZE = 2;
-	/**
-	 * This is the minimum size of a SpacePacket.
-	 */
-	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	SpacePacketBase( const uint8_t* set_address );
-	/**
-	 * No data is allocated, so the destructor is empty.
-	 */
-	virtual ~SpacePacketBase();
-
-	//CCSDS Methods:
-	/**
-	 * Getter for the packet version number field.
-	 * @return Returns the highest three bit of the packet in one byte.
-	 */
-	uint8_t getPacketVersionNumber( void );
-	/**
-	 * This method checks the type field in the header.
-	 * This bit specifies, if the command is interpreted as Telecommand of
-	 * as Telemetry. For a Telecommand, the bit is set.
-	 * @return Returns true if the bit is set and false if not.
-	 */
-	bool isTelecommand( void );
-
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
-	/**
-	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
-	 *  which is checked with this method.
-	 * @return	Returns true if the bit is set and false if not.
-	 */
-	bool hasSecondaryHeader( void );
-	/**
-	 * Returns the complete first two bytes of the packet, which together form
-	 * the CCSDS packet id.
-	 * @return	The CCSDS packet id.
-	 */
-	uint16_t getPacketId( void );
-	/**
-	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @return The CCSDS APID.
-	 */
-	uint16_t getAPID( void ) const;
-	/**
-	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @param 	The APID to set. The highest five bits of the parameter are
-	 * 			ignored.
-	 */
-	void setAPID( uint16_t setAPID );
-	/**
-	 * Returns the CCSDS packet sequence control field, which are the third and
-	 * the fourth byte of the CCSDS primary header.
-	 * @return The CCSDS packet sequence control field.
-	 */
-	uint16_t getPacketSequenceControl( void );
-	/**
-	 * Returns the SequenceFlags, which are the highest two bit of the packet
-	 * sequence control field.
-	 * @return	The CCSDS sequence flags.
-	 */
-	uint8_t getSequenceFlags( void );
-	/**
-	 * Returns the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * @return The CCSDS sequence count.
-	 */
-	uint16_t getPacketSequenceCount( void ) const;
-	/**
-	 * Sets the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
-	 * @param setCount	The value to set the count to.
-	 */
-	void setPacketSequenceCount( uint16_t setCount );
-	/**
-	 * Returns the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header. The packet data length is the size of every kind
-	 * of data \b after the CCSDS Primary Header \b -1.
-	 * @return The CCSDS packet data length.
-	 */
-	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
-	/**
-	 * Sets the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header.
-	 * @param setLength The value of the length to set. It must fit the true
-	 * 					CCSDS packet data length . The packet data length is
-	 * 					the size of every kind of data \b after the CCSDS
-	 * 					Primary Header \b -1.
-	 */
-	void setPacketDataLength( uint16_t setLength );
-
-	//Helper methods:
-	/**
-	 * This method returns a raw uint8_t pointer to the packet.
-	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-	 */
-	virtual uint8_t* getWholeData( void );
-
-	uint8_t* getPacketData();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 * @param p_Data A pointer to another raw Space Packet.
-	 */
-	virtual void setData( const uint8_t* p_Data );
-	/**
-	 * This method returns the full raw packet size.
-	 * @return	The full size of the packet in bytes.
-	 */
-	size_t getFullSize();
-
-	uint32_t getApidAndSequenceCount() const;
-
-};
-
-#endif /* SPACEPACKETBASE_H_ */
+#ifndef SPACEPACKETBASE_H_
+#define SPACEPACKETBASE_H_
+
+#include "../tmtcpacket/ccsds_header.h"
+#include <cstddef>
+
+/**
+ * @defgroup tmtcpackets Space Packets
+ * This is the group, where all classes associated with Telecommand and
+ * Telemetry packets belong to.
+ * The class hierarchy resembles the dependency between the different standards
+ * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
+ * Utilization Standard. Most field and structure names are taken from these
+ * standards.
+ */
+
+/**
+ * This struct defines the data structure of a Space Packet when accessed
+ * via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct SpacePacketPointer {
+	CCSDSPrimaryHeader header;
+	uint8_t packet_data;
+};
+
+/**
+ * This class is the basic data handler for any CCSDS Space Packet
+ * compatible Telecommand and Telemetry packet.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * Remark: All bit numbers in this documentation are counted from
+ * the most significant bit (from left).
+ * @ingroup tmtcpackets
+ */
+class SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet header.
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	SpacePacketPointer* data;
+public:
+	static const uint16_t LIMIT_APID = 2048; //2^1
+	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+	static const uint16_t APID_IDLE_PACKET = 0x7FF;
+	static const uint8_t TELECOMMAND_PACKET = 1;
+	static const uint8_t TELEMETRY_PACKET = 0;
+	/**
+	 * This definition defines the CRC size in byte.
+	 */
+	static const uint8_t CRC_SIZE = 2;
+	/**
+	 * This is the minimum size of a SpacePacket.
+	 */
+	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	SpacePacketBase( const uint8_t* set_address );
+	/**
+	 * No data is allocated, so the destructor is empty.
+	 */
+	virtual ~SpacePacketBase();
+
+	//CCSDS Methods:
+	/**
+	 * Getter for the packet version number field.
+	 * @return Returns the highest three bit of the packet in one byte.
+	 */
+	uint8_t getPacketVersionNumber( void );
+	/**
+	 * This method checks the type field in the header.
+	 * This bit specifies, if the command is interpreted as Telecommand of
+	 * as Telemetry. For a Telecommand, the bit is set.
+	 * @return Returns true if the bit is set and false if not.
+	 */
+	bool isTelecommand( void );
+
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	/**
+	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+	 *  which is checked with this method.
+	 * @return	Returns true if the bit is set and false if not.
+	 */
+	bool hasSecondaryHeader( void );
+	/**
+	 * Returns the complete first two bytes of the packet, which together form
+	 * the CCSDS packet id.
+	 * @return	The CCSDS packet id.
+	 */
+	uint16_t getPacketId( void );
+	/**
+	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @return The CCSDS APID.
+	 */
+	uint16_t getAPID( void ) const;
+	/**
+	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @param 	The APID to set. The highest five bits of the parameter are
+	 * 			ignored.
+	 */
+	void setAPID( uint16_t setAPID );
+	/**
+	 * Returns the CCSDS packet sequence control field, which are the third and
+	 * the fourth byte of the CCSDS primary header.
+	 * @return The CCSDS packet sequence control field.
+	 */
+	uint16_t getPacketSequenceControl( void );
+	/**
+	 * Returns the SequenceFlags, which are the highest two bit of the packet
+	 * sequence control field.
+	 * @return	The CCSDS sequence flags.
+	 */
+	uint8_t getSequenceFlags( void );
+	/**
+	 * Returns the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * @return The CCSDS sequence count.
+	 */
+	uint16_t getPacketSequenceCount( void ) const;
+	/**
+	 * Sets the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+	 * @param setCount	The value to set the count to.
+	 */
+	void setPacketSequenceCount( uint16_t setCount );
+	/**
+	 * Returns the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header. The packet data length is the size of every kind
+	 * of data \b after the CCSDS Primary Header \b -1.
+	 * @return The CCSDS packet data length.
+	 */
+	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
+	/**
+	 * Sets the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header.
+	 * @param setLength The value of the length to set. It must fit the true
+	 * 					CCSDS packet data length . The packet data length is
+	 * 					the size of every kind of data \b after the CCSDS
+	 * 					Primary Header \b -1.
+	 */
+	void setPacketDataLength( uint16_t setLength );
+
+	//Helper methods:
+	/**
+	 * This method returns a raw uint8_t pointer to the packet.
+	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
+	 */
+	virtual uint8_t* getWholeData( void );
+
+	uint8_t* getPacketData();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 * @param p_Data A pointer to another raw Space Packet.
+	 */
+	virtual void setData( const uint8_t* p_Data );
+	/**
+	 * This method returns the full raw packet size.
+	 * @return	The full size of the packet in bytes.
+	 */
+	size_t getFullSize();
+
+	uint32_t getApidAndSequenceCount() const;
+
+};
+
+#endif /* SPACEPACKETBASE_H_ */
diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h
index 7b1b89ff..4f196ac9 100644
--- a/tmtcpacket/packetmatcher/ApidMatcher.h
+++ b/tmtcpacket/packetmatcher/ApidMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint16_t apid;
-public:
-	ApidMatcher(uint16_t setApid) :
-			apid(setApid) {
-	}
-	ApidMatcher(TmPacketMinimal* test) :
-			apid(test->getAPID()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getAPID() == apid) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&apid);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
-	}
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint16_t apid;
+public:
+	ApidMatcher(uint16_t setApid) :
+			apid(setApid) {
+	}
+	ApidMatcher(TmPacketMinimal* test) :
+			apid(test->getAPID()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getAPID() == apid) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&apid);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
+	}
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 356467dc..610829e5 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,195 +1,195 @@
-#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
-#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
-#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
-#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
-
-PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
-}
-
-PacketMatchTree::~PacketMatchTree() {
-}
-
-ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	//We assume adding APID is always requested.
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator lastTest;
-	iterator rollback;
-	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
-			this->begin(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		rollback = lastTest;
-	} else if (result != RETURN_OK) {
-		return result;
-	}
-	if (type == 0) {
-		//Check if lastTest has no children, otherwise, delete them,
-		//as a more general check is requested.
-		if (lastTest.left() != this->end()) {
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Type insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		if  (rollback == this->end()) {
-			rollback = lastTest;
-		}
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	if (subtype == 0) {
-		if (lastTest.left() != this->end()) {
-			//See above
-			removeElementAndAllChildren(lastTest.left());
-		}
-		return RETURN_OK;
-	}
-	//Subtype insertion required.
-	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
-			lastTest.left(), &testPacket, &lastTest);
-	if (result == NEW_NODE_CREATED) {
-		return RETURN_OK;
-	} else if (result != RETURN_OK) {
-		if (rollback != this->end()) {
-			removeElementAndAllChildren(rollback);
-		}
-		return result;
-	}
-	return RETURN_OK;
-}
-
-template<typename VALUE_T, typename INSERTION_T>
-ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
-		iterator* lastTest) {
-	bool attachToBranch = AND;
-	iterator iter = startAt;
-	while (iter != this->end()) {
-		bool isMatch = iter->match(test);
-		attachToBranch = OR;
-		*lastTest = iter;
-		if (isMatch) {
-			return RETURN_OK;
-		} else {
-			//Go down OR branch.
-			iter = iter.right();
-		}
-	}
-	//Only reached if nothing was found.
-	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
-			test);
-	if (newContent == NULL) {
-		return FULL;
-	}
-	Node* newNode = factory.generate<Node>(newContent);
-	if (newNode == NULL) {
-		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
-		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
-		return FULL;
-	}
-	*lastTest = insert(attachToBranch, *lastTest, newNode);
-	if (*lastTest == end()) {
-		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
-		return RETURN_FAILED;
-	}
-	return NEW_NODE_CREATED;
-}
-
-ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
-		uint8_t subtype) {
-	TmPacketMinimal::TmPacketMinimalPointer data;
-	data.data_field.service_type = type;
-	data.data_field.service_subtype = subtype;
-	TmPacketMinimal testPacket((uint8_t*) &data);
-	testPacket.setAPID(apid);
-	iterator foundElement = findMatch(begin(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (type == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Go down AND branch. Will abort if empty.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == this->end()) {
-		return NO_MATCH;
-	}
-	if (subtype == 0) {
-		if (foundElement.left() == end()) {
-			return removeElementAndReconnectChildren(foundElement);
-		} else {
-			return TOO_GENERAL_REQUEST;
-		}
-	}
-	//Again, go down AND branch.
-	foundElement = findMatch(foundElement.left(), &testPacket);
-	if (foundElement == end()) {
-		return NO_MATCH;
-	}
-	return removeElementAndReconnectChildren(foundElement);
-}
-
-PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
-		TmPacketMinimal* test) {
-	iterator iter = startAt;
-	while (iter != end()) {
-		bool isMatch = iter->match(test);
-		if (isMatch) {
-			break;
-		} else {
-			iter = iter.right(); //next OR element
-		}
-	}
-	return iter;
-}
-
-ReturnValue_t PacketMatchTree::initialize() {
-	return factoryBackend.initialize();
-}
-
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
-ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
-		uint8_t type, uint8_t subtype) {
-	if (addToMatch) {
-		return addMatch(apid, type, subtype);
-	} else {
-		return removeMatch(apid, type, subtype);
-	}
-}
-
-ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
-	factory.destroy(position.element->value);
-	//Go on anyway, there's nothing we can do.
-	//SHOULDDO: Throw event, or write debug message?
-	return factory.destroy(position.element);
-}
+#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
+#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
+#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
+#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+
+PacketMatchTree::PacketMatchTree(Node* root) :
+		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
+				N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree(iterator root) :
+		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree() :
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::~PacketMatchTree() {
+}
+
+ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume adding APID is always requested.
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator lastTest;
+	iterator rollback;
+	ReturnValue_t result = findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(
+			this->begin(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		rollback = lastTest;
+	} else if (result != RETURN_OK) {
+		return result;
+	}
+	if (type == 0) {
+		//Check if lastTest has no children, otherwise, delete them,
+		//as a more general check is requested.
+		if (lastTest.left() != this->end()) {
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Type insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		if  (rollback == this->end()) {
+			rollback = lastTest;
+		}
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	if (subtype == 0) {
+		if (lastTest.left() != this->end()) {
+			//See above
+			removeElementAndAllChildren(lastTest.left());
+		}
+		return RETURN_OK;
+	}
+	//Subtype insertion required.
+	result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(
+			lastTest.left(), &testPacket, &lastTest);
+	if (result == NEW_NODE_CREATED) {
+		return RETURN_OK;
+	} else if (result != RETURN_OK) {
+		if (rollback != this->end()) {
+			removeElementAndAllChildren(rollback);
+		}
+		return result;
+	}
+	return RETURN_OK;
+}
+
+template<typename VALUE_T, typename INSERTION_T>
+ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
+		iterator* lastTest) {
+	bool attachToBranch = AND;
+	iterator iter = startAt;
+	while (iter != this->end()) {
+		bool isMatch = iter->match(test);
+		attachToBranch = OR;
+		*lastTest = iter;
+		if (isMatch) {
+			return RETURN_OK;
+		} else {
+			//Go down OR branch.
+			iter = iter.right();
+		}
+	}
+	//Only reached if nothing was found.
+	SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(
+			test);
+	if (newContent == NULL) {
+		return FULL;
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		//Need to make sure partially generated content is deleted, otherwise, that's a leak.
+		factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
+		return FULL;
+	}
+	*lastTest = insert(attachToBranch, *lastTest, newNode);
+	if (*lastTest == end()) {
+		//This actaully never fails, so creating a dedicated returncode seems an overshoot.
+		return RETURN_FAILED;
+	}
+	return NEW_NODE_CREATED;
+}
+
+ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*) &data);
+	testPacket.setAPID(apid);
+	iterator foundElement = findMatch(begin(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (type == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Go down AND branch. Will abort if empty.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == this->end()) {
+		return NO_MATCH;
+	}
+	if (subtype == 0) {
+		if (foundElement.left() == end()) {
+			return removeElementAndReconnectChildren(foundElement);
+		} else {
+			return TOO_GENERAL_REQUEST;
+		}
+	}
+	//Again, go down AND branch.
+	foundElement = findMatch(foundElement.left(), &testPacket);
+	if (foundElement == end()) {
+		return NO_MATCH;
+	}
+	return removeElementAndReconnectChildren(foundElement);
+}
+
+PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt,
+		TmPacketMinimal* test) {
+	iterator iter = startAt;
+	while (iter != end()) {
+		bool isMatch = iter->match(test);
+		if (isMatch) {
+			break;
+		} else {
+			iter = iter.right(); //next OR element
+		}
+	}
+	return iter;
+}
+
+ReturnValue_t PacketMatchTree::initialize() {
+	return factoryBackend.initialize();
+}
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+		sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
+		uint8_t type, uint8_t subtype) {
+	if (addToMatch) {
+		return addMatch(apid, type, subtype);
+	} else {
+		return removeMatch(apid, type, subtype);
+	}
+}
+
+ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
+	factory.destroy(position.element->value);
+	//Go on anyway, there's nothing we can do.
+	//SHOULDDO: Throw event, or write debug message?
+	return factory.destroy(position.element);
+}
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index 0d246d21..86fb087e 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -1,36 +1,36 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
-
-#include "../../container/PlacementFactory.h"
-#include "../../globalfunctions/matching/MatchTree.h"
-#include "../../storagemanager/LocalPool.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
-public:
-	PacketMatchTree(Node* root);
-	PacketMatchTree(iterator root);
-	PacketMatchTree();
-	virtual ~PacketMatchTree();
-	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
-			uint8_t subtype = 0);
-	ReturnValue_t initialize();
-protected:
-	ReturnValue_t cleanUpElement(iterator position);
-private:
-	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
-	PlacementFactory factory;
-	static const uint16_t POOL_SIZES[N_POOLS];
-	static const uint16_t N_ELEMENTS[N_POOLS];
-	template<typename VALUE_T, typename INSERTION_T>
-	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
-	iterator findMatch(iterator startAt, TmPacketMinimal* test);
-};
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
-
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+
+#include "../../container/PlacementFactory.h"
+#include "../../globalfunctions/matching/MatchTree.h"
+#include "../../storagemanager/LocalPool.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+public:
+	PacketMatchTree(Node* root);
+	PacketMatchTree(iterator root);
+	PacketMatchTree();
+	virtual ~PacketMatchTree();
+	ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0,
+			uint8_t subtype = 0);
+	ReturnValue_t initialize();
+protected:
+	ReturnValue_t cleanUpElement(iterator position);
+private:
+	static const uint8_t N_POOLS = 4;
+	LocalPool<N_POOLS> factoryBackend;
+	PlacementFactory factory;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+	template<typename VALUE_T, typename INSERTION_T>
+	ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
+	iterator findMatch(iterator startAt, TmPacketMinimal* test);
+};
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+
diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h
index e22288f4..eba23d75 100644
--- a/tmtcpacket/packetmatcher/ServiceMatcher.h
+++ b/tmtcpacket/packetmatcher/ServiceMatcher.h
@@ -1,39 +1,39 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-private:
-	uint8_t service;
-public:
-	ServiceMatcher(uint8_t setService) :
-			service(setService) {
-	}
-	ServiceMatcher(TmPacketMinimal* test) :
-			service(test->getService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getService() == service) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&service);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
-	}
-};
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint8_t service;
+public:
+	ServiceMatcher(uint8_t setService) :
+			service(setService) {
+	}
+	ServiceMatcher(TmPacketMinimal* test) :
+			service(test->getService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getService() == service) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&service);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
+	}
+};
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */
diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h
index 1b173b1a..a9b6def8 100644
--- a/tmtcpacket/packetmatcher/SubserviceMatcher.h
+++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h
@@ -1,40 +1,40 @@
-#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
-
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-
-class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
-public:
-	SubServiceMatcher(uint8_t subService) :
-			subService(subService) {
-	}
-	SubServiceMatcher(TmPacketMinimal* test) :
-			subService(test->getSubService()) {
-	}
-	bool match(TmPacketMinimal* packet) {
-		if (packet->getSubService() == subService) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
-	}
-	size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&subService);
-	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
-	}
-private:
-	uint8_t subService;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+
+#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+
+class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+public:
+	SubServiceMatcher(uint8_t subService) :
+			subService(subService) {
+	}
+	SubServiceMatcher(TmPacketMinimal* test) :
+			subService(test->getSubService()) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getSubService() == subService) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			size_t maxSize, Endianness streamEndianness) const {
+		return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
+	}
+	size_t getSerializedSize() const {
+		return SerializeAdapter::getSerializedSize(&subService);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) {
+		return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
+	}
+private:
+	uint8_t subService;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */
diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index 9e442ed6..dd0c0328 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -1,16 +1,16 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-class TmPacketMinimal;
-
-class PacketTimestampInterpreterIF {
-public:
-	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
-	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+#define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+class TmPacketMinimal;
+
+class PacketTimestampInterpreterIF {
+public:
+	virtual ~PacketTimestampInterpreterIF() {}
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ */
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 3dc15872..b62db535 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,93 +1,93 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-#include <string.h>
-
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
-}
-
-TcPacketBase::~TcPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TcPacketBase::getService() {
-	return tcData->dataField.service_type;
-}
-
-uint8_t TcPacketBase::getSubService() {
-	return tcData->dataField.service_subtype;
-}
-
-uint8_t TcPacketBase::getAcknowledgeFlags() {
-	return tcData->dataField.version_type_ack & 0b00001111;
-}
-
-const uint8_t* TcPacketBase::getApplicationData() const {
-	return &tcData->appData;
-}
-
-uint16_t TcPacketBase::getApplicationDataSize() {
-	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
-}
-
-uint16_t TcPacketBase::getErrorControl() {
-	uint16_t size = getApplicationDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tcData->appData;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TcPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getApplicationDataSize();
-	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
-	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TcPacketBase::setData(const uint8_t* pData) {
-	SpacePacketBase::setData(pData);
-	tcData = (TcPacketPointer*) pData;
-}
-
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
-uint8_t TcPacketBase::getSecondaryHeaderFlag() {
-	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
-}
-
-uint8_t TcPacketBase::getPusVersionNumber() {
-	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
-}
-
-void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
-}
-
-void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
-	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
-	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
-	tcData->dataField.version_type_ack = 0b00010000;
-	tcData->dataField.version_type_ack |= (ack & 0x0F);
-	tcData->dataField.service_type = service;
-	tcData->dataField.service_subtype = subservice;
-}
-
-size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
-	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
-			appDataLen + TcPacketBase::CRC_SIZE;
-}
+#include "../../globalfunctions/CRC.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+#include <string.h>
+
+TcPacketBase::TcPacketBase(const uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tcData = (TcPacketPointer*) set_data;
+}
+
+TcPacketBase::~TcPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TcPacketBase::getService() {
+	return tcData->dataField.service_type;
+}
+
+uint8_t TcPacketBase::getSubService() {
+	return tcData->dataField.service_subtype;
+}
+
+uint8_t TcPacketBase::getAcknowledgeFlags() {
+	return tcData->dataField.version_type_ack & 0b00001111;
+}
+
+const uint8_t* TcPacketBase::getApplicationData() const {
+	return &tcData->appData;
+}
+
+uint16_t TcPacketBase::getApplicationDataSize() {
+	return getPacketDataLength() - sizeof(tcData->dataField) - CRC_SIZE + 1;
+}
+
+uint16_t TcPacketBase::getErrorControl() {
+	uint16_t size = getApplicationDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tcData->appData;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TcPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getApplicationDataSize();
+	(&tcData->appData)[size] = (crc & 0XFF00) >> 8;	// CRCH
+	(&tcData->appData)[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TcPacketBase::setData(const uint8_t* pData) {
+	SpacePacketBase::setData(pData);
+	tcData = (TcPacketPointer*) pData;
+}
+
+void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
+	memcpy(&tcData->appData, appData, dataLen);
+	SpacePacketBase::setPacketDataLength(dataLen +
+				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
+}
+
+uint8_t TcPacketBase::getSecondaryHeaderFlag() {
+	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
+}
+
+uint8_t TcPacketBase::getPusVersionNumber() {
+	return (tcData->dataField.version_type_ack & 0b01110000) >> 4;
+}
+
+void TcPacketBase::print() {
+	uint8_t * wholeData = getWholeData();
+	sif::debug << "TcPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < getFullSize(); ++count) {
+		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
+	}
+	sif::debug << std::dec << std::endl;
+}
+
+void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
+		uint8_t ack, uint8_t service, uint8_t subservice) {
+	initSpacePacketHeader(true, true, apid, sequenceCount);
+	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	tcData->dataField.version_type_ack = 0b00010000;
+	tcData->dataField.version_type_ack |= (ack & 0x0F);
+	tcData->dataField.service_type = service;
+	tcData->dataField.service_subtype = subservice;
+}
+
+size_t TcPacketBase::calculateFullPacketLength(size_t appDataLen) {
+	return sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) +
+			appDataLen + TcPacketBase::CRC_SIZE;
+}
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index 1cfe233b..b3ef5fe7 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,204 +1,204 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
-
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include <cstddef>
-
-/**
- * This struct defines a byte-wise structured PUS TC Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, the Source Id field is present with one byte.
- * @ingroup tmtcpackets
- */
-struct PUSTcDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t source_id;
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TcPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTcDataFieldHeader dataField;
-	uint8_t appData;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telecommand packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TC Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
-public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TcPacketBase( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
-	/**
-	 * This command returns the CCSDS Secondary Header Flag.
-	 * It shall always be zero for PUS Packets. This is the
-	 * highest bit of the first byte of the Data Field Header.
-	 * @return	the CCSDS Secondary Header Flag
-	 */
-	uint8_t getSecondaryHeaderFlag();
-	/**
-	 * This command returns the TC Packet PUS Version Number.
-	 * The version number of ECSS PUS 2003 is 1.
-	 * It consists of the second to fourth highest bits of the
-	 * first byte.
-	 * @return
-	 */
-	uint8_t getPusVersionNumber();
-	/**
-	 * This is a getter for the packet's Ack field, which are the lowest four
-	 * bits of the first byte of the Data Field Header.
-	 *
-	 * It is packed in a uint8_t variable.
-	 * @return	The packet's PUS Ack field.
-	 */
-	uint8_t getAcknowledgeFlags();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Application data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's application data.
-	 * @return	A pointer to the PUS Application Data.
-	 */
-	const uint8_t* getApplicationData() const;
-	/**
-	 * This method calculates the size of the PUS Application data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Application Data (without Error Control
-	 * 		field)
-	 */
-	uint16_t getApplicationDataSize();
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Application Data. If no
-	 * Application Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Calculate full packet length from application data length.
-	 * @param appDataLen
-	 * @return
-	 */
-	static size_t calculateFullPacketLength(size_t appDataLen);
-};
-
-
-#endif /* TCPACKETBASE_H_ */
+#ifndef TCPACKETBASE_H_
+#define TCPACKETBASE_H_
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include <cstddef>
+
+/**
+ * This struct defines a byte-wise structured PUS TC Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, the Source Id field is present with one byte.
+ * @ingroup tmtcpackets
+ */
+struct PUSTcDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t source_id;
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TcPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTcDataFieldHeader dataField;
+	uint8_t appData;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telecommand packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TC Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TcPacketBase : public SpacePacketBase {
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TcPacketPointer* tcData;
+public:
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
+	/**
+	 * With this constant for the acknowledge field responses on all levels are expected.
+	 */
+	static const uint8_t ACK_ALL = 0b1111;
+	/**
+	 * With this constant for the acknowledge field a response on acceptance is expected.
+	 */
+	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+	/**
+	 * With this constant for the acknowledge field a response on start of execution is expected.
+	 */
+	static const uint8_t ACK_START = 0b0010;
+	/**
+	 * With this constant for the acknowledge field responses on execution steps are expected.
+	 */
+	static const uint8_t ACK_STEP = 0b0100;
+	/**
+	 * With this constant for the acknowledge field a response on completion is expected.
+	 */
+	static const uint8_t ACK_COMPLETION = 0b1000;
+	/**
+	 * With this constant for the acknowledge field no responses are expected.
+	 */
+	static const uint8_t ACK_NONE = 0b000;
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TcPacketBase( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TcPacketBase();
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	/**
+	 * Initializes the Tc Packet header.
+	 * @param apid APID used.
+	 * @param sequenceCount Sequence Count in the primary header.
+	 * @param ack Which acknowledeges are expected from the receiver.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 */
+	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+			uint8_t service, uint8_t subservice);
+	/**
+	 * This command returns the CCSDS Secondary Header Flag.
+	 * It shall always be zero for PUS Packets. This is the
+	 * highest bit of the first byte of the Data Field Header.
+	 * @return	the CCSDS Secondary Header Flag
+	 */
+	uint8_t getSecondaryHeaderFlag();
+	/**
+	 * This command returns the TC Packet PUS Version Number.
+	 * The version number of ECSS PUS 2003 is 1.
+	 * It consists of the second to fourth highest bits of the
+	 * first byte.
+	 * @return
+	 */
+	uint8_t getPusVersionNumber();
+	/**
+	 * This is a getter for the packet's Ack field, which are the lowest four
+	 * bits of the first byte of the Data Field Header.
+	 *
+	 * It is packed in a uint8_t variable.
+	 * @return	The packet's PUS Ack field.
+	 */
+	uint8_t getAcknowledgeFlags();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Application data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's application data.
+	 * @return	A pointer to the PUS Application Data.
+	 */
+	const uint8_t* getApplicationData() const;
+	/**
+	 * This method calculates the size of the PUS Application data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Application Data (without Error Control
+	 * 		field)
+	 */
+	uint16_t getApplicationDataSize();
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Application Data. If no
+	 * Application Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+
+	/**
+	 * Copies the supplied data to the internal TC application data field.
+	 * @param pData
+	 * @param dataLen
+	 */
+	void setAppData(uint8_t * appData, uint16_t dataLen);
+
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telecommand Packet.
+	 */
+	void setData( const uint8_t* pData );
+
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Calculate full packet length from application data length.
+	 * @param appDataLen
+	 * @return
+	 */
+	static size_t calculateFullPacketLength(size_t appDataLen);
+};
+
+
+#endif /* TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 64b369ea..d3474569 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,118 +1,118 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketStored.h"
-
-#include <cstring>
-
-TcPacketStored::TcPacketStored(store_address_t setAddress) :
-		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
-}
-
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
-		TcPacketBase(nullptr) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
-		return;
-	}
-	uint8_t* p_data = nullptr;
-	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
-				"free element from store!" << std::endl;
-		return;
-	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
-	memcpy(&tcData->appData, data, size);
-	this->setPacketDataLength(
-			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-	this->setErrorControl();
-}
-
-ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
-		size_t* dataSize) {
-	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
-	}
-	return result;
-}
-
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->checkAndSetStore();
-
-}
-
-ReturnValue_t TcPacketStored::deletePacket() {
-	ReturnValue_t result = this->store->deleteData(this->storeAddress);
-	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
-	return result;
-}
-
-bool TcPacketStored::checkAndSetStore() {
-	if (this->store == nullptr) {
-		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-		if (this->store == nullptr) {
-			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-void TcPacketStored::setStoreAddress(store_address_t setAddress) {
-	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
-				&temp_size);
-	}
-	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
-	} else {
-		this->setData(NULL);
-		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-store_address_t TcPacketStored::getStoreAddress() {
-	return this->storeAddress;
-}
-
-bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
-	size_t temp_size;
-	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
-			&temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		if (this->getFullSize() == temp_size) {
-			return true;
-		}
-	}
-	return false;
-}
-
-StorageManagerIF* TcPacketStored::store = NULL;
-
-TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
-		TcPacketBase(data) {
-	if (getFullSize() != size) {
-		return;
-	}
-	if (this->checkAndSetStore()) {
-		ReturnValue_t status = store->addData(&storeAddress, data, size);
-		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
-		}
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TcPacketStored.h"
+
+#include <cstring>
+
+TcPacketStored::TcPacketStored(store_address_t setAddress) :
+		TcPacketBase(nullptr), storeAddress(setAddress) {
+	this->setStoreAddress(this->storeAddress);
+}
+
+TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
+		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
+		size_t size, uint8_t ack ) :
+		TcPacketBase(nullptr) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!this->checkAndSetStore()) {
+		return;
+	}
+	uint8_t* p_data = nullptr;
+	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
+			(TC_PACKET_MIN_SIZE + size), &p_data);
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
+				"free element from store!" << std::endl;
+		return;
+	}
+	this->setData(p_data);
+	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	memcpy(&tcData->appData, data, size);
+	this->setPacketDataLength(
+			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
+	this->setErrorControl();
+}
+
+ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
+		size_t* dataSize) {
+	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+	}
+	return result;
+}
+
+TcPacketStored::TcPacketStored() :
+		TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->checkAndSetStore();
+
+}
+
+ReturnValue_t TcPacketStored::deletePacket() {
+	ReturnValue_t result = this->store->deleteData(this->storeAddress);
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL);
+	return result;
+}
+
+bool TcPacketStored::checkAndSetStore() {
+	if (this->store == nullptr) {
+		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+		if (this->store == nullptr) {
+			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+void TcPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+	if (this->checkAndSetStore()) {
+		status = this->store->getData(this->storeAddress, &temp_data,
+				&temp_size);
+	}
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+store_address_t TcPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+bool TcPacketStored::isSizeCorrect() {
+	const uint8_t* temp_data = NULL;
+	size_t temp_size;
+	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
+			&temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		if (this->getFullSize() == temp_size) {
+			return true;
+		}
+	}
+	return false;
+}
+
+StorageManagerIF* TcPacketStored::store = NULL;
+
+TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
+		TcPacketBase(data) {
+	if (getFullSize() != size) {
+		return;
+	}
+	if (this->checkAndSetStore()) {
+		ReturnValue_t status = store->addData(&storeAddress, data, size);
+		if (status != HasReturnvaluesIF::RETURN_OK) {
+			this->setData(NULL);
+		}
+	}
+}
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index 90cf2fba..c81b71b7 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,110 +1,110 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
-
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-
-/**
- *	This class generates a ECSS PUS Telecommand packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TcPacketStored();
-	/**
-	 * With this constructor, the class instance is linked to an existing
-	 * packet in the packet store.
-	 * The packet content is neither checked nor changed with this call. If
-	 * the packet could not be found, the data pointer is set to NULL.
-	 */
-	TcPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telecommand Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
-	 * @param data		The data to be copied to the Application Data Field.
-	 * @param size		The amount of data to be copied.
-	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
-			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
-	/**
-	 * Another constructor to create a TcPacket from a raw packet stream.
-	 * Takes the data and adds it unchecked to the TcStore.
-	 * @param data	Pointer to the complete TC Space Packet.
-	 * @param Size size of the packet.
-	 */
-	TcPacketStored( const uint8_t* data, uint32_t size);
-
-	ReturnValue_t getData(const uint8_t ** dataPtr,
-			size_t* dataSize);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 * @return	returncode from deleting the data.
-	 */
-	ReturnValue_t deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-	/**
-	 * This method performs a size check.
-	 * It reads the stored size and compares it with the size entered in the
-	 * packet header. This class is the optimal place for such a check as it
-	 * has access to both the header data and the store.
-	 * @return	true if size is correct, false if packet is not registered in
-	 * 			store or size is incorrect.
-	 */
-	bool isSizeCorrect();
-};
-
-
-#endif /* TCPACKETSTORED_H_ */
+#ifndef TCPACKETSTORED_H_
+#define TCPACKETSTORED_H_
+
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TcPacketBase.h"
+
+/**
+ *	This class generates a ECSS PUS Telecommand packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TcPacketStored : public TcPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TC_STORE.
+	 */
+	static StorageManagerIF* store;
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TcPacketStored();
+	/**
+	 * With this constructor, the class instance is linked to an existing
+	 * packet in the packet store.
+	 * The packet content is neither checked nor changed with this call. If
+	 * the packet could not be found, the data pointer is set to NULL.
+	 */
+	TcPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telecommand Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * @param apid			Sets the packet's APID field.
+	 * @param ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the destination service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the destination sub-service.
+	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * @param data		The data to be copied to the Application Data Field.
+	 * @param size		The amount of data to be copied.
+	 */
+	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+	/**
+	 * Another constructor to create a TcPacket from a raw packet stream.
+	 * Takes the data and adds it unchecked to the TcStore.
+	 * @param data	Pointer to the complete TC Space Packet.
+	 * @param Size size of the packet.
+	 */
+	TcPacketStored( const uint8_t* data, uint32_t size);
+
+	ReturnValue_t getData(const uint8_t ** dataPtr,
+			size_t* dataSize);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 * @return	returncode from deleting the data.
+	 */
+	ReturnValue_t deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+	/**
+	 * This method performs a size check.
+	 * It reads the stored size and compares it with the size entered in the
+	 * packet header. This class is the optimal place for such a check as it
+	 * has access to both the header data and the store.
+	 * @return	true if size is correct, false if packet is not registered in
+	 * 			store or size is incorrect.
+	 */
+	bool isSizeCorrect();
+};
+
+
+#endif /* TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 630471cc..66d67600 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,119 +1,119 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
-#include "../../timemanager/CCSDSTime.h"
-#include <string.h>
-
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
-}
-
-TmPacketBase::~TmPacketBase() {
-	//Nothing to do.
-}
-
-uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
-}
-
-uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
-			- CRC_SIZE + 1;
-}
-
-uint16_t TmPacketBase::getErrorControl() {
-	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
-	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-}
-
-void TmPacketBase::setErrorControl() {
-	uint32_t full_size = getFullSize();
-	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-	uint32_t size = getSourceDataSize();
-	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
-	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
-}
-
-void TmPacketBase::setData(const uint8_t* p_Data) {
-	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
-}
-
-void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
-}
-
-bool TmPacketBase::checkAndSetStamper() {
-	if (timeStamper == NULL) {
-		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
-		if (timeStamper == NULL) {
-			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
-}
-
-uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
-
-}
-
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
-	//Set primary header:
-	initSpacePacketHeader(false, true, apid);
-	//Set data Field Header:
-	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
-	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
-	//Timestamp packet
-	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
-	}
-}
-
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
-void TmPacketBase::setSourceDataSize(uint16_t size) {
-	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
-}
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
+#include "../../globalfunctions/CRC.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../timemanager/CCSDSTime.h"
+#include <string.h>
+
+TmPacketBase::TmPacketBase(uint8_t* set_data) :
+		SpacePacketBase(set_data) {
+	tm_data = (TmPacketPointer*) set_data;
+}
+
+TmPacketBase::~TmPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TmPacketBase::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketBase::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t* TmPacketBase::getSourceData() {
+	return &tm_data->data;
+}
+
+uint16_t TmPacketBase::getSourceDataSize() {
+	return getPacketDataLength() - sizeof(tm_data->data_field)
+			- CRC_SIZE + 1;
+}
+
+uint16_t TmPacketBase::getErrorControl() {
+	uint32_t size = getSourceDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &tm_data->data;
+	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
+}
+
+void TmPacketBase::setErrorControl() {
+	uint32_t full_size = getFullSize();
+	uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+	uint32_t size = getSourceDataSize();
+	getSourceData()[size] = (crc & 0XFF00) >> 8;	// CRCH
+	getSourceData()[size + 1] = (crc) & 0X00FF; 		// CRCL
+}
+
+void TmPacketBase::setData(const uint8_t* p_Data) {
+	SpacePacketBase::setData(p_Data);
+	tm_data = (TmPacketPointer*) p_Data;
+}
+
+void TmPacketBase::print() {
+	/*uint8_t * wholeData = getWholeData();
+	 debug << "TmPacket contains: " << std::endl;
+	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
+	 debug << std::hex << (uint16_t)wholeData[count] << " ";
+	 }
+	 debug << std::dec << std::endl;*/
+}
+
+bool TmPacketBase::checkAndSetStamper() {
+	if (timeStamper == NULL) {
+		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
+		if (timeStamper == NULL) {
+			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
+	uint32_t tempSize = 0;
+	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
+			&tempSize, sizeof(tm_data->data_field.time));
+}
+
+uint8_t* TmPacketBase::getPacketTimeRaw() const{
+	return tm_data->data_field.time;
+
+}
+
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+	//Set primary header:
+	initSpacePacketHeader(false, true, apid);
+	//Set data Field Header:
+	//First, set to zero.
+	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
+	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
+	// The other 4 bits of the first byte are the spacecraft time reference status
+	// To change to PUS-C, set 0b00100000
+	tm_data->data_field.version_type_ack = 0b00010000;
+	tm_data->data_field.service_type = service;
+	tm_data->data_field.service_subtype = subservice;
+	tm_data->data_field.subcounter = packetSubcounter;
+	//Timestamp packet
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+	}
+}
+
+void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
+	memcpy(getSourceData(), sourceData, sourceSize);
+	setSourceDataSize(sourceSize);
+}
+
+void TmPacketBase::setSourceDataSize(uint16_t size) {
+	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+uint32_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tm_data->data_field.time);
+}
+
+TimeStamperIF* TmPacketBase::timeStamper = NULL;
+object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index acd08d72..96dbd5c6 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,186 +1,186 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
-
-#include "../../timemanager/TimeStamperIF.h"
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include "../../timemanager/Clock.h"
-#include "../../objectmanager/SystemObjectIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * This struct defines a byte-wise structured PUS TM Data Field Header.
- * Any optional fields in the header must be added or removed here.
- * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
- * @ingroup tmtcpackets
- */
-struct PUSTmDataFieldHeader {
-	uint8_t version_type_ack;
-	uint8_t service_type;
-	uint8_t service_subtype;
-	uint8_t subcounter;
-//	uint8_t destination;
-	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
-};
-
-/**
- * This struct defines the data structure of a PUS Telecommand Packet when
- * accessed via a pointer.
- * @ingroup tmtcpackets
- */
-struct TmPacketPointer {
-	CCSDSPrimaryHeader primary;
-	PUSTmDataFieldHeader data_field;
-	uint8_t data;
-};
-
-/**
- * This class is the basic data handler for any ECSS PUS Telemetry packet.
- *
- * In addition to \SpacePacketBase, the class provides methods to handle
- * the standardized entries of the PUS TM Packet Data Field Header.
- * It does not contain the packet data itself but a pointer to the
- * data must be set on instantiation. An invalid pointer may cause
- * damage, as no getter method checks data validity. Anyway, a NULL
- * check can be performed by making use of the getWholeData method.
- * @ingroup tmtcpackets
- */
-class TmPacketBase : public SpacePacketBase {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
-	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketBase( uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * This is a getter for a pointer to the packet's Source data.
-	 *
-	 * These are the bytes that follow after the Data Field Header. They form
-	 * the packet's source data.
-	 * @return	A pointer to the PUS Source Data.
-	 */
-	uint8_t* getSourceData();
-	/**
-	 * This method calculates the size of the PUS Source data field.
-	 *
-	 * It takes the information stored in the CCSDS Packet Data Length field
-	 * and subtracts the Data Field Header size and the CRC size.
-	 * @return	The size of the PUS Source Data (without Error Control field)
-	 */
-	uint16_t getSourceDataSize();
-
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
-	/**
-	 * This getter returns the Error Control Field of the packet.
-	 *
-	 * The field is placed after any possible Source Data. If no
-	 * Source Data is present there's still an Error Control field. It is
-	 * supposed to be a 16bit-CRC.
-	 * @return	The PUS Error Control
-	 */
-	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
-	/**
-	 * This is a debugging helper method that prints the whole packet content
-	 * to the screen.
-	 */
-	void print();
-	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
-	 * @return Converted timestamp of packet.
-	 */
-	ReturnValue_t getPacketTime(timeval* timestamp) const;
-	/**
-	 * Returns a raw pointer to the beginning of the time field.
-	 * @return Raw pointer to time field.
-	 */
-	uint8_t* getPacketTimeRaw() const;
-
-	uint32_t getTimestampSize() const;
-
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketPointer* tm_data;
-	/**
-	 * The timeStamper is responsible for adding a timestamp to the packet.
-	 * It is initialized lazy.
-	 */
-	static TimeStamperIF* timeStamper;
-
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
-};
-
-
-#endif /* TMPACKETBASE_H_ */
+#ifndef TMPACKETBASE_H_
+#define TMPACKETBASE_H_
+
+#include "../../timemanager/TimeStamperIF.h"
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../timemanager/Clock.h"
+#include "../../objectmanager/SystemObjectIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * This struct defines a byte-wise structured PUS TM Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, no Destination field is present, but an eigth-byte representation
+ * for a time tag [TBD].
+ * @ingroup tmtcpackets
+ */
+struct PUSTmDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t subcounter;
+//	uint8_t destination;
+	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TmPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTmDataFieldHeader data_field;
+	uint8_t data;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telemetry packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TM Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TmPacketBase : public SpacePacketBase {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
+	 */
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketBase( uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketBase();
+	/**
+	 * Initializes the Tm Packet header.
+	 * Does set the timestamp (to now), but not the error control field.
+	 * @param apid APID used.
+	 * @param service	PUS Service
+	 * @param subservice PUS Subservice
+	 * @param packetSubcounter Additional subcounter used.
+	 */
+	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * This is a getter for a pointer to the packet's Source data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's source data.
+	 * @return	A pointer to the PUS Source Data.
+	 */
+	uint8_t* getSourceData();
+	/**
+	 * This method calculates the size of the PUS Source data field.
+	 *
+	 * It takes the information stored in the CCSDS Packet Data Length field
+	 * and subtracts the Data Field Header size and the CRC size.
+	 * @return	The size of the PUS Source Data (without Error Control field)
+	 */
+	uint16_t getSourceDataSize();
+
+	/**
+	 * In case data was filled manually (almost never the case).
+	 * @param size Size of source data (without CRC and data filed header!).
+	 */
+	void setSourceDataSize(uint16_t size);
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Source Data. If no
+	 * Source Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * This sets the source data. It copies the provided data to
+	 * the internal TmPacketPointer source data location.
+	 * @param sourceData
+	 * @param sourceSize
+	 */
+	void setSourceData(uint8_t* sourceData, size_t sourceSize);
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telemetry Packet.
+	 */
+	void setData( const uint8_t* p_Data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * @return Converted timestamp of packet.
+	 */
+	ReturnValue_t getPacketTime(timeval* timestamp) const;
+	/**
+	 * Returns a raw pointer to the beginning of the time field.
+	 * @return Raw pointer to time field.
+	 */
+	uint8_t* getPacketTimeRaw() const;
+
+	uint32_t getTimestampSize() const;
+
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketPointer* tm_data;
+	/**
+	 * The timeStamper is responsible for adding a timestamp to the packet.
+	 * It is initialized lazy.
+	 */
+	static TimeStamperIF* timeStamper;
+
+	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
+	/**
+	 * Checks if a time stamper is available and tries to set it if not.
+	 * @return Returns false if setting failed.
+	 */
+	bool checkAndSetStamper();
+};
+
+
+#endif /* TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index ee56d46f..c7c495ae 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,45 +1,45 @@
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
-#include <stddef.h>
-#include <time.h>
-#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
-
-TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
-	this->tm_data = (TmPacketMinimalPointer*)set_data;
-}
-
-TmPacketMinimal::~TmPacketMinimal() {
-}
-
-uint8_t TmPacketMinimal::getService() {
-	return tm_data->data_field.service_type;
-}
-
-uint8_t TmPacketMinimal::getSubService() {
-	return tm_data->data_field.service_subtype;
-}
-
-uint8_t TmPacketMinimal::getPacketSubcounter() {
-	return tm_data->data_field.subcounter;
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTime(this, timestamp);
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
-	if (timestampInterpreter == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
-}
-
-void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
-	if (TmPacketMinimal::timestampInterpreter == NULL) {
-		TmPacketMinimal::timestampInterpreter = interpreter;
-	}
-}
-
-PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
+#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include <stddef.h>
+#include <time.h>
+#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+
+TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
+	this->tm_data = (TmPacketMinimalPointer*)set_data;
+}
+
+TmPacketMinimal::~TmPacketMinimal() {
+}
+
+uint8_t TmPacketMinimal::getService() {
+	return tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketMinimal::getSubService() {
+	return tm_data->data_field.service_subtype;
+}
+
+uint8_t TmPacketMinimal::getPacketSubcounter() {
+	return tm_data->data_field.subcounter;
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTime(this, timestamp);
+}
+
+ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
+	if (timestampInterpreter == NULL) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
+}
+
+void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
+	if (TmPacketMinimal::timestampInterpreter == NULL) {
+		TmPacketMinimal::timestampInterpreter = interpreter;
+	}
+}
+
+PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;
diff --git a/tmtcpacket/pus/TmPacketMinimal.h b/tmtcpacket/pus/TmPacketMinimal.h
index e7b362bf..728acb15 100644
--- a/tmtcpacket/pus/TmPacketMinimal.h
+++ b/tmtcpacket/pus/TmPacketMinimal.h
@@ -1,84 +1,84 @@
-#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
-
-
-#include "../../tmtcpacket/SpacePacketBase.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-struct timeval;
-class PacketTimestampInterpreterIF;
-/**
- * This is a minimal version of a PUS TmPacket without any variable field, or,
- * in other words with Service Type, Subtype and subcounter only.
- * This is required for handling TM packets with different APIDs with different
- * secondary headers.
- */
-class TmPacketMinimal : public SpacePacketBase {
-public:
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed and also
-	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	TmPacketMinimal( const uint8_t* set_data );
-	/**
-	 * This is the empty default destructor.
-	 */
-	virtual ~TmPacketMinimal();
-	/**
-	 * This is a getter for the packet's PUS Service ID, which is the second
-	 * byte of the Data Field Header.
-	 * @return	The packet's PUS Service ID.
-	 */
-	uint8_t getService();
-	/**
-	 * This is a getter for the packet's PUS Service Subtype, which is the
-	 * third byte of the Data Field Header.
-	 * @return	The packet's PUS Service Subtype.
-	 */
-	uint8_t getSubService();
-	/**
-	 * Returns the subcounter.
-	 * @return the subcounter of the Data Field Header.
-	 */
-	uint8_t getPacketSubcounter();
-	struct PUSTmMinimalHeader {
-		uint8_t version_type_ack;
-		uint8_t service_type;
-		uint8_t service_subtype;
-		uint8_t subcounter;
-	};
-
-	ReturnValue_t getPacketTime(timeval* timestamp);
-
-	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
-
-	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
-	/**
-	 * This struct defines the data structure of a PUS Telecommand Packet when
-	 * accessed via a pointer.
-	 * @ingroup tmtcpackets
-	 */
-	struct TmPacketMinimalPointer {
-		CCSDSPrimaryHeader primary;
-		PUSTmMinimalHeader data_field;
-		uint8_t rest;
-	};
-	//Must include a checksum and is therefore at least one larger than the above struct.
-	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TmPacketMinimalPointer* tm_data;
-
-	static PacketTimestampInterpreterIF* timestampInterpreter;
-};
-
-
-
-#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
+#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+
+
+#include "../../tmtcpacket/SpacePacketBase.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
+struct timeval;
+class PacketTimestampInterpreterIF;
+/**
+ * This is a minimal version of a PUS TmPacket without any variable field, or,
+ * in other words with Service Type, Subtype and subcounter only.
+ * This is required for handling TM packets with different APIDs with different
+ * secondary headers.
+ */
+class TmPacketMinimal : public SpacePacketBase {
+public:
+	/**
+	 * This is the default constructor.
+	 * It sets its internal data pointer to the address passed and also
+	 * forwards the data pointer to the parent SpacePacketBase class.
+	 * @param set_address	The position where the packet data lies.
+	 */
+	TmPacketMinimal( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketMinimal();
+	/**
+	 * This is a getter for the packet's PUS Service ID, which is the second
+	 * byte of the Data Field Header.
+	 * @return	The packet's PUS Service ID.
+	 */
+	uint8_t getService();
+	/**
+	 * This is a getter for the packet's PUS Service Subtype, which is the
+	 * third byte of the Data Field Header.
+	 * @return	The packet's PUS Service Subtype.
+	 */
+	uint8_t getSubService();
+	/**
+	 * Returns the subcounter.
+	 * @return the subcounter of the Data Field Header.
+	 */
+	uint8_t getPacketSubcounter();
+	struct PUSTmMinimalHeader {
+		uint8_t version_type_ack;
+		uint8_t service_type;
+		uint8_t service_subtype;
+		uint8_t subcounter;
+	};
+
+	ReturnValue_t getPacketTime(timeval* timestamp);
+
+	ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
+
+	static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
+	/**
+	 * This struct defines the data structure of a PUS Telecommand Packet when
+	 * accessed via a pointer.
+	 * @ingroup tmtcpackets
+	 */
+	struct TmPacketMinimalPointer {
+		CCSDSPrimaryHeader primary;
+		PUSTmMinimalHeader data_field;
+		uint8_t rest;
+	};
+	//Must include a checksum and is therefore at least one larger than the above struct.
+	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) +1;
+protected:
+	/**
+	 * A pointer to a structure which defines the data structure of
+	 * the packet's data.
+	 *
+	 * To be hardware-safe, all elements are of byte size.
+	 */
+	TmPacketMinimalPointer* tm_data;
+
+	static PacketTimestampInterpreterIF* timestampInterpreter;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 9476dcd6..17b49f43 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,146 +1,146 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketStored.h"
-#include "../../tmtcservices/TmTcMessage.h"
-#include <string.h>
-
-TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
-	setStoreAddress(storeAddress);
-}
-
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	uint8_t *pData = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
-
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TmPacketStored::TmPacketStored: "
-				"Issue getting free storage" << std::endl;
-		checkAndReportLostTm();
-		return;
-	}
-	setData(pData);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	memcpy(getSourceData(), headerData, headerSize);
-	memcpy(getSourceData() + headerSize, data, size);
-	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-// todo: Endianness flags as optional parameter?
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF *header) :
-		TmPacketBase(NULL) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	size_t sourceDataSize = 0;
-	if (content != NULL) {
-		sourceDataSize += content->getSerializedSize();
-	}
-	if (header != NULL) {
-		sourceDataSize += header->getSerializedSize();
-	}
-	uint8_t *p_data = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
-	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
-	}
-	setData(p_data);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t *putDataHere = getSourceData();
-	size_t size = 0;
-	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
-}
-
-store_address_t TmPacketStored::getStoreAddress() {
-	return storeAddress;
-}
-
-void TmPacketStored::deletePacket() {
-	store->deleteData(storeAddress);
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
-}
-
-void TmPacketStored::setStoreAddress(store_address_t setAddress) {
-	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
-		return;
-	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
-	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
-	} else {
-		setData(NULL);
-		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
-		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
-			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
-					<< std::endl;
-			return false;
-		}
-	}
-	return true;
-}
-
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
-ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
-		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
-		//SHOULDDO: More decent code.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-			&tmMessage, sentFrom);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		deletePacket();
-		if (doErrorReporting) {
-			checkAndReportLostTm();
-		}
-		return result;
-	}
-	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
-		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-				objects::INTERNAL_ERROR_REPORTER);
-	}
-	if (internalErrorReporter != NULL) {
-		internalErrorReporter->lostTm();
-	}
-}
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcpacket/pus/TmPacketStored.h"
+#include "../../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+TmPacketStored::TmPacketStored(store_address_t setAddress) :
+		TmPacketBase(NULL), storeAddress(setAddress) {
+	setStoreAddress(storeAddress);
+}
+
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	uint8_t *pData = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
+
+	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
+		sif::debug << "TmPacketStored::TmPacketStored: "
+				"Issue getting free storage" << std::endl;
+		checkAndReportLostTm();
+		return;
+	}
+	setData(pData);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	memcpy(getSourceData(), headerData, headerSize);
+	memcpy(getSourceData() + headerSize, data, size);
+	setPacketDataLength(
+			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+// todo: Endianness flags as optional parameter?
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+		SerializeIF *header) :
+		TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	size_t sourceDataSize = 0;
+	if (content != NULL) {
+		sourceDataSize += content->getSerializedSize();
+	}
+	if (header != NULL) {
+		sourceDataSize += header->getSerializedSize();
+	}
+	uint8_t *p_data = NULL;
+	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+			(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
+	if (returnValue != store->RETURN_OK) {
+		checkAndReportLostTm();
+	}
+	setData(p_data);
+	initializeTmPacket(apid, service, subservice, packetSubcounter);
+	uint8_t *putDataHere = getSourceData();
+	size_t size = 0;
+	if (header != NULL) {
+		header->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	if (content != NULL) {
+		content->serialize(&putDataHere, &size, sourceDataSize,
+				SerializeIF::Endianness::BIG);
+	}
+	setPacketDataLength(
+			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+}
+
+store_address_t TmPacketStored::getStoreAddress() {
+	return storeAddress;
+}
+
+void TmPacketStored::deletePacket() {
+	store->deleteData(storeAddress);
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	setData(NULL);
+}
+
+void TmPacketStored::setStoreAddress(store_address_t setAddress) {
+	storeAddress = setAddress;
+	const uint8_t *temp_data = NULL;
+	size_t temp_size;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	if (status == StorageManagerIF::RETURN_OK) {
+		setData(temp_data);
+	} else {
+		setData(NULL);
+		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+bool TmPacketStored::checkAndSetStore() {
+	if (store == NULL) {
+		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+		if (store == NULL) {
+			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
+					<< std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+StorageManagerIF *TmPacketStored::store = NULL;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
+
+ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
+		MessageQueueId_t sentFrom, bool doErrorReporting) {
+	if (getWholeData() == NULL) {
+		//SHOULDDO: More decent code.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	TmTcMessage tmMessage(getStoreAddress());
+	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+			&tmMessage, sentFrom);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		deletePacket();
+		if (doErrorReporting) {
+			checkAndReportLostTm();
+		}
+		return result;
+	}
+	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void TmPacketStored::checkAndReportLostTm() {
+	if (internalErrorReporter == NULL) {
+		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+				objects::INTERNAL_ERROR_REPORTER);
+	}
+	if (internalErrorReporter != NULL) {
+		internalErrorReporter->lostTm();
+	}
+}
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 195c3272..98e37ed5 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,96 +1,96 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
-
-#include "../../serialize/SerializeIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
-#include "../../internalError/InternalErrorReporterIF.h"
-#include "../../ipc/MessageQueueSenderIF.h"
-
-/**
- *	This class generates a ECSS PUS Telemetry packet within a given
- *	intermediate storage.
- *	As most packets are passed between tasks with the help of a storage
- *	anyway, it seems logical to create a Packet-In-Storage access class
- *	which saves the user almost all storage handling operation.
- *	Packets can both be newly created with the class and be "linked" to
- *	packets in a store with the help of a storeAddress.
- *	@ingroup tmtcpackets
- */
-class TmPacketStored : public TmPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TM_STORE.
-	 */
-	static StorageManagerIF* store;
-
-	static InternalErrorReporterIF *internalErrorReporter;
-
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
-	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
-
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
-};
-
-
-#endif /* TMPACKETSTORED_H_ */
+#ifndef TMPACKETSTORED_H_
+#define TMPACKETSTORED_H_
+
+#include "../../serialize/SerializeIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../tmtcpacket/pus/TmPacketBase.h"
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+
+/**
+ *	This class generates a ECSS PUS Telemetry packet within a given
+ *	intermediate storage.
+ *	As most packets are passed between tasks with the help of a storage
+ *	anyway, it seems logical to create a Packet-In-Storage access class
+ *	which saves the user almost all storage handling operation.
+ *	Packets can both be newly created with the class and be "linked" to
+ *	packets in a store with the help of a storeAddress.
+ *	@ingroup tmtcpackets
+ */
+class TmPacketStored : public TmPacketBase {
+private:
+	/**
+	 * This is a pointer to the store all instances of the class use.
+	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * call tries to set it and throws an error message in case of failures.
+	 * The default store is objects::TM_STORE.
+	 */
+	static StorageManagerIF* store;
+
+	static InternalErrorReporterIF *internalErrorReporter;
+
+	/**
+	 * The address where the packet data of the object instance is stored.
+	 */
+	store_address_t storeAddress;
+	/**
+	 * A helper method to check if a store is assigned to the class.
+	 * If not, the method tries to retrieve the store from the global
+	 * ObjectManager.
+	 * @return	@li	\c true if the store is linked or could be created.
+	 * 			@li \c false otherwise.
+	 */
+	bool checkAndSetStore();
+
+	void checkAndReportLostTm();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet from two separate data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+};
+
+
+#endif /* TMPACKETSTORED_H_ */
diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index 13928df5..bff0e955 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -1,43 +1,43 @@
-#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telecommands.
- * @details	Any service receiving telecommands shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelecommandsIF {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
-	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelecommandsIF() {
-
-	}
-	/**
-	 * @brief	Getter for the service id.
-	 * @details	Any receiving service (at least any PUS service) shall have a
-	 * 			service ID. If the receiver can handle Telecommands, but for
-	 * 			some reason has no service id, it shall return 0.
-	 * @return	The service ID or 0.
-	 */
-	virtual uint16_t getIdentifier() = 0;
-	/**
-	 * @brief	This method returns the message queue id of the telecommand
-	 * 			receiving message queue.
-	 * @return	The telecommand reception message queue id.
-	 */
-	virtual MessageQueueId_t getRequestQueue() = 0;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+#define FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telecommands.
+ * @details	Any service receiving telecommands shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelecommandsIF {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(5);
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelecommandsIF() {
+
+	}
+	/**
+	 * @brief	Getter for the service id.
+	 * @details	Any receiving service (at least any PUS service) shall have a
+	 * 			service ID. If the receiver can handle Telecommands, but for
+	 * 			some reason has no service id, it shall return 0.
+	 * @return	The service ID or 0.
+	 */
+	virtual uint16_t getIdentifier() = 0;
+	/**
+	 * @brief	This method returns the message queue id of the telecommand
+	 * 			receiving message queue.
+	 * @return	The telecommand reception message queue id.
+	 */
+	virtual MessageQueueId_t getRequestQueue() = 0;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_ACCEPTSTELECOMMANDSIF_H_ */
diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index bcb38666..2325dbe0 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,26 +1,26 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-/**
- * @brief 	This interface is implemented by classes that are sinks for
- * 			Telemetry.
- * @details	Any object receiving telemetry shall implement this interface
- * 			and thus make the service id and the receiving message queue public.
- */
-class AcceptsTelemetryIF {
-public:
-	/**
-	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
-	 */
-	virtual ~AcceptsTelemetryIF() {
-	}
-	/**
-	 * @brief	This method returns the message queue id of the telemetry
-	 * 			receiving message queue.
-	 * @return	The telemetry reception message queue id.
-	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
-};
-
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#ifndef ACCEPTSTELEMETRYIF_H_
+#define ACCEPTSTELEMETRYIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+/**
+ * @brief 	This interface is implemented by classes that are sinks for
+ * 			Telemetry.
+ * @details	Any object receiving telemetry shall implement this interface
+ * 			and thus make the service id and the receiving message queue public.
+ */
+class AcceptsTelemetryIF {
+public:
+	/**
+	 * @brief The virtual destructor as it is mandatory for C++ interfaces.
+	 */
+	virtual ~AcceptsTelemetryIF() {
+	}
+	/**
+	 * @brief	This method returns the message queue id of the telemetry
+	 * 			receiving message queue.
+	 * @return	The telemetry reception message queue id.
+	 */
+	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+};
+
+#endif /* ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index a312390e..c9318ab0 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,15 +1,15 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
-
-#include "../ipc/MessageQueueSenderIF.h"
-
-class AcceptsVerifyMessageIF {
-public:
-	virtual ~AcceptsVerifyMessageIF() {
-
-	}
-	virtual MessageQueueId_t getVerificationQueue() = 0;
-};
-
-
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+
+#include "../ipc/MessageQueueSenderIF.h"
+
+class AcceptsVerifyMessageIF {
+public:
+	virtual ~AcceptsVerifyMessageIF() {
+
+	}
+	virtual MessageQueueId_t getVerificationQueue() = 0;
+};
+
+
+#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3325b10b..e5a87f18 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,427 +1,427 @@
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-#include "../tmtcservices/CommandingServiceBase.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcpacket/pus/TmPacketStored.h"
-
-object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
-
-CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
-		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, size_t queueDepth) :
-		SystemObject(setObjectId), apid(apid), service(service),
-		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
-}
-
-void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
-	this->packetSource = packetSource;
-}
-
-void CommandingServiceBase::setPacketDestination(
-		object_id_t packetDestination) {
-	this->packetDestination = packetDestination;
-}
-
-
-CommandingServiceBase::~CommandingServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-
-ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
-	handleCommandQueue();
-	handleRequestQueue();
-	checkTimeout();
-	doPeriodicOperation();
-	return RETURN_OK;
-}
-
-
-uint16_t CommandingServiceBase::getIdentifier() {
-	return service;
-}
-
-
-MessageQueueId_t CommandingServiceBase::getRequestQueue() {
-	return requestQueue->getId();
-}
-
-
-ReturnValue_t CommandingServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(packetDestination == objects::NO_OBJECT) {
-	    packetDestination = defaultPacketDestination;
-	}
-	AcceptsTelemetryIF* packetForwarding =
-			objectManager->get<AcceptsTelemetryIF>(packetDestination);
-
-	if(packetSource == objects::NO_OBJECT) {
-	    packetSource = defaultPacketSource;
-	}
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-
-	if (packetForwarding == nullptr or distributor == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: Packet source or "
-	            "packet destination invalid!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	distributor->registerService(this);
-	requestQueue->setDefaultDestination(
-			packetForwarding->getReportReceptionQueue());
-
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-
-	if (IPCStore == nullptr or TCStore == nullptr) {
-	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
-	                    "not initialized yet!" << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	return RETURN_OK;
-
-}
-
-void CommandingServiceBase::handleCommandQueue() {
-	CommandMessage reply;
-	ReturnValue_t result = RETURN_FAILED;
-	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
-			result = commandQueue->receiveMessage(&reply)) {
-		handleCommandMessage(&reply);
-	}
-}
-
-
-void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
-	bool isStep = false;
-	CommandMessage nextCommand;
-	CommandMapIter iter = commandMap.find(reply->getSender());
-
-	// handle unrequested reply first
-	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
-			iter == commandMap.end()) {
-		handleUnrequestedReply(reply);
-		return;
-	}
-	nextCommand.setCommand(CommandMessage::CMD_NONE);
-
-
-	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
-
-	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
-	 * failure verification will be generated with the reason as the
-	 * return code and the initial command as failure parameter 1 */
-	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
-			(result == RETURN_FAILED or result == INVALID_REPLY)) {
-	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
-	}
-
-	switch (result) {
-	case EXECUTION_COMPLETE:
-	case RETURN_OK:
-	case NO_STEP_MESSAGE:
-		// handle result of reply handler implemented by developer.
-		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
-		break;
-	case INVALID_REPLY:
-		//might be just an unrequested reply at a bad moment
-		handleUnrequestedReply(reply);
-		break;
-	default:
-		if (isStep) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
-					failureParameter2);
-		} else {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, 0, failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-		break;
-	}
-
-}
-
-void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
-		CommandMapIter iter, CommandMessage* nextCommand,
-		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
-
-	// In case a new command is to be sent immediately, this is performed here.
-	// If no new command is sent, only analyse reply result by initializing
-	// sendResult as RETURN_OK
-	ReturnValue_t sendResult = RETURN_OK;
-	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
-		sendResult = commandQueue->sendMessage(reply->getSender(),
-				nextCommand);
-	}
-
-	if (sendResult == RETURN_OK) {
-		if (isStep and result != NO_STEP_MESSAGE) {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
-		}
-		else {
-			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
-			checkAndExecuteFifo(iter);
-		}
-	}
-	else {
-		if (isStep) {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
-		} else {
-			nextCommand->clearCommandMessage();
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
-					failureParameter1, failureParameter2);
-		}
-		failureParameter1 = 0;
-		failureParameter2 = 0;
-		checkAndExecuteFifo(iter);
-	}
-}
-
-void CommandingServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result;
-	store_address_t address;
-	TcPacketStored packet;
-	MessageQueueId_t queue;
-	object_id_t objectId;
-	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
-			result = requestQueue->receiveMessage(&message)) {
-		address = message.getStorageId();
-		packet.setStoreAddress(address);
-
-		if ((packet.getSubService() == 0)
-				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
-			continue;
-		}
-		result = getMessageQueueAndObject(packet.getSubService(),
-				packet.getApplicationData(), packet.getApplicationDataSize(),
-				&queue, &objectId);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
-			continue;
-		}
-
-		//Is a command already active for the target object?
-		CommandMapIter iter;
-		iter = commandMap.find(queue);
-
-		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
-			}
-		} else {
-			CommandInfo newInfo; //Info will be set by startExecution if neccessary
-			newInfo.objectId = objectId;
-			result = commandMap.insert(queue, newInfo, &iter);
-			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
-			} else {
-				startExecution(&packet, iter);
-			}
-		}
-
-	}
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
-		size_t headerSize) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-			this->tmPacketCounter, data, dataLen, headerData, headerSize);
-	ReturnValue_t result = tmPacketStored.sendPacket(
-			requestQueue->getDefaultDestination(), requestQueue->getId());
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		this->tmPacketCounter++;
-	}
-	return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        object_id_t objectId, const uint8_t *data, size_t dataLen) {
-    uint8_t buffer[sizeof(object_id_t)];
-    uint8_t* pBuffer = buffer;
-    size_t size = 0;
-    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
-                sizeof(object_id_t), SerializeIF::Endianness::BIG);
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, data, dataLen, buffer, size);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
-        SerializeIF* content, SerializeIF* header) {
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
-            this->tmPacketCounter, content, header);
-    ReturnValue_t result = tmPacketStored.sendPacket(
-            requestQueue->getDefaultDestination(), requestQueue->getId());
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-        this->tmPacketCounter++;
-    }
-    return result;
-}
-
-
-void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
-        CommandMapIter iter) {
-    ReturnValue_t result = RETURN_OK;
-    CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
-            storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
-
-    ReturnValue_t sendResult = RETURN_OK;
-	switch (result) {
-	case RETURN_OK:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
-					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	case EXECUTION_COMPLETE:
-		if (command.getCommand() != CommandMessage::CMD_NONE) {
-			//Fire-and-forget command.
-			sendResult = commandQueue->sendMessage(iter.value->first,
-					&command);
-		}
-		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
-					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
-			checkAndExecuteFifo(iter);
-		} else {
-			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
-			checkAndExecuteFifo(iter);
-		}
-		break;
-	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
-		checkAndExecuteFifo(iter);
-		break;
-	}
-}
-
-
-void CommandingServiceBase::rejectPacket(uint8_t report_id,
-		TcPacketStored* packet, ReturnValue_t error_code) {
-	verificationReporter.sendFailureReport(report_id, packet, error_code);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::acceptPacket(uint8_t reportId,
-		TcPacketStored* packet) {
-	verificationReporter.sendSuccessReport(reportId, packet);
-	packet->deletePacket();
-}
-
-
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
-	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
-	} else {
-		TcPacketStored newPacket(address);
-		startExecution(&newPacket, iter);
-	}
-}
-
-
-void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
-	reply->clearCommandMessage();
-}
-
-
-inline void CommandingServiceBase::doPeriodicOperation() {
-}
-
-MessageQueueId_t CommandingServiceBase::getCommandQueue() {
-	return commandQueue->getId();
-}
-
-void CommandingServiceBase::checkTimeout() {
-	uint32_t uptime;
-	Clock::getUptime(&uptime);
-	CommandMapIter iter;
-	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					TIMEOUT);
-			checkAndExecuteFifo(iter);
-		}
-	}
-}
-
-void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
-    executingTask = task_;
-}
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../tmtcservices/CommandingServiceBase.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
+		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
+		uint16_t commandTimeoutSeconds, size_t queueDepth) :
+		SystemObject(setObjectId), apid(apid), service(service),
+		timeoutSeconds(commandTimeoutSeconds),
+		commandMap(numberOfParallelCommands) {
+	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
+}
+
+void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
+	this->packetSource = packetSource;
+}
+
+void CommandingServiceBase::setPacketDestination(
+		object_id_t packetDestination) {
+	this->packetDestination = packetDestination;
+}
+
+
+CommandingServiceBase::~CommandingServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(commandQueue);
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+
+ReturnValue_t CommandingServiceBase::performOperation(uint8_t opCode) {
+	handleCommandQueue();
+	handleRequestQueue();
+	checkTimeout();
+	doPeriodicOperation();
+	return RETURN_OK;
+}
+
+
+uint16_t CommandingServiceBase::getIdentifier() {
+	return service;
+}
+
+
+MessageQueueId_t CommandingServiceBase::getRequestQueue() {
+	return requestQueue->getId();
+}
+
+
+ReturnValue_t CommandingServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+
+	if(packetDestination == objects::NO_OBJECT) {
+	    packetDestination = defaultPacketDestination;
+	}
+	AcceptsTelemetryIF* packetForwarding =
+			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+
+	if(packetSource == objects::NO_OBJECT) {
+	    packetSource = defaultPacketSource;
+	}
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+
+	if (packetForwarding == nullptr or distributor == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: Packet source or "
+	            "packet destination invalid!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	distributor->registerService(this);
+	requestQueue->setDefaultDestination(
+			packetForwarding->getReportReceptionQueue());
+
+	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+
+	if (IPCStore == nullptr or TCStore == nullptr) {
+	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
+	                    "not initialized yet!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	return RETURN_OK;
+
+}
+
+void CommandingServiceBase::handleCommandQueue() {
+	CommandMessage reply;
+	ReturnValue_t result = RETURN_FAILED;
+	for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK;
+			result = commandQueue->receiveMessage(&reply)) {
+		handleCommandMessage(&reply);
+	}
+}
+
+
+void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
+	bool isStep = false;
+	CommandMessage nextCommand;
+	CommandMapIter iter = commandMap.find(reply->getSender());
+
+	// handle unrequested reply first
+	if (reply->getSender() == MessageQueueIF::NO_QUEUE or
+			iter == commandMap.end()) {
+		handleUnrequestedReply(reply);
+		return;
+	}
+	nextCommand.setCommand(CommandMessage::CMD_NONE);
+
+
+	// Implemented by child class, specifies what to do with reply.
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);
+
+	/* If the child implementation does not implement special handling for
+	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
+	 * failure verification will be generated with the reason as the
+	 * return code and the initial command as failure parameter 1 */
+	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
+			(result == RETURN_FAILED or result == INVALID_REPLY)) {
+	    result = reply->getReplyRejectedReason();
+	    failureParameter1 = iter->command;
+	}
+
+	switch (result) {
+	case EXECUTION_COMPLETE:
+	case RETURN_OK:
+	case NO_STEP_MESSAGE:
+		// handle result of reply handler implemented by developer.
+		handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep);
+		break;
+	case INVALID_REPLY:
+		//might be just an unrequested reply at a bad moment
+		handleUnrequestedReply(reply);
+		break;
+	default:
+		if (isStep) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
+					failureParameter2);
+		} else {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, 0, failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+		break;
+	}
+
+}
+
+void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
+		CommandMapIter iter, CommandMessage* nextCommand,
+		CommandMessage* reply, bool& isStep) {
+	iter->command = nextCommand->getCommand();
+
+	// In case a new command is to be sent immediately, this is performed here.
+	// If no new command is sent, only analyse reply result by initializing
+	// sendResult as RETURN_OK
+	ReturnValue_t sendResult = RETURN_OK;
+	if (nextCommand->getCommand() != CommandMessage::CMD_NONE) {
+		sendResult = commandQueue->sendMessage(reply->getSender(),
+				nextCommand);
+	}
+
+	if (sendResult == RETURN_OK) {
+		if (isStep and result != NO_STEP_MESSAGE) {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::PROGRESS_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
+		}
+		else {
+			verificationReporter.sendSuccessReport(
+					TC_VERIFY::COMPLETION_SUCCESS,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
+			checkAndExecuteFifo(iter);
+		}
+	}
+	else {
+		if (isStep) {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
+		} else {
+			nextCommand->clearCommandMessage();
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					failureParameter1, failureParameter2);
+		}
+		failureParameter1 = 0;
+		failureParameter2 = 0;
+		checkAndExecuteFifo(iter);
+	}
+}
+
+void CommandingServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result;
+	store_address_t address;
+	TcPacketStored packet;
+	MessageQueueId_t queue;
+	object_id_t objectId;
+	for (result = requestQueue->receiveMessage(&message); result == RETURN_OK;
+			result = requestQueue->receiveMessage(&message)) {
+		address = message.getStorageId();
+		packet.setStoreAddress(address);
+
+		if ((packet.getSubService() == 0)
+				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			continue;
+		}
+		result = getMessageQueueAndObject(packet.getSubService(),
+				packet.getApplicationData(), packet.getApplicationDataSize(),
+				&queue, &objectId);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			continue;
+		}
+
+		//Is a command already active for the target object?
+		CommandMapIter iter;
+		iter = commandMap.find(queue);
+
+		if (iter != commandMap.end()) {
+			result = iter->fifo.insert(address);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+			}
+		} else {
+			CommandInfo newInfo; //Info will be set by startExecution if neccessary
+			newInfo.objectId = objectId;
+			result = commandMap.insert(queue, newInfo, &iter);
+			if (result != RETURN_OK) {
+				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+			} else {
+				startExecution(&packet, iter);
+			}
+		}
+
+	}
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
+		size_t headerSize) {
+	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+			this->tmPacketCounter, data, dataLen, headerData, headerSize);
+	ReturnValue_t result = tmPacketStored.sendPacket(
+			requestQueue->getDefaultDestination(), requestQueue->getId());
+	if (result == HasReturnvaluesIF::RETURN_OK) {
+		this->tmPacketCounter++;
+	}
+	return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        object_id_t objectId, const uint8_t *data, size_t dataLen) {
+    uint8_t buffer[sizeof(object_id_t)];
+    uint8_t* pBuffer = buffer;
+    size_t size = 0;
+    SerializeAdapter::serialize(&objectId, &pBuffer, &size,
+                sizeof(object_id_t), SerializeIF::Endianness::BIG);
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, data, dataLen, buffer, size);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
+        SerializeIF* content, SerializeIF* header) {
+    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+            this->tmPacketCounter, content, header);
+    ReturnValue_t result = tmPacketStored.sendPacket(
+            requestQueue->getDefaultDestination(), requestQueue->getId());
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        this->tmPacketCounter++;
+    }
+    return result;
+}
+
+
+void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
+        CommandMapIter iter) {
+    ReturnValue_t result = RETURN_OK;
+    CommandMessage command;
+    iter->subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->subservice,
+            storedPacket->getApplicationData(),
+            storedPacket->getApplicationDataSize(), &iter->state,
+            iter->objectId);
+
+    ReturnValue_t sendResult = RETURN_OK;
+	switch (result) {
+	case RETURN_OK:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			Clock::getUptime(&iter->uptimeOfStart);
+			iter->step = 0;
+			iter->subservice = storedPacket->getSubService();
+			iter->command = command.getCommand();
+			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->tcInfo.tcSequenceControl =
+					storedPacket->getPacketSequenceControl();
+			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	case EXECUTION_COMPLETE:
+		if (command.getCommand() != CommandMessage::CMD_NONE) {
+			//Fire-and-forget command.
+			sendResult = commandQueue->sendMessage(iter.value->first,
+					&command);
+		}
+		if (sendResult == RETURN_OK) {
+			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+					storedPacket);
+			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			checkAndExecuteFifo(iter);
+		} else {
+			command.clearCommandMessage();
+			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			checkAndExecuteFifo(iter);
+		}
+		break;
+	default:
+		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		checkAndExecuteFifo(iter);
+		break;
+	}
+}
+
+
+void CommandingServiceBase::rejectPacket(uint8_t report_id,
+		TcPacketStored* packet, ReturnValue_t error_code) {
+	verificationReporter.sendFailureReport(report_id, packet, error_code);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::acceptPacket(uint8_t reportId,
+		TcPacketStored* packet) {
+	verificationReporter.sendSuccessReport(reportId, packet);
+	packet->deletePacket();
+}
+
+
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+	store_address_t address;
+	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+		commandMap.erase(&iter);
+	} else {
+		TcPacketStored newPacket(address);
+		startExecution(&newPacket, iter);
+	}
+}
+
+
+void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) {
+	reply->clearCommandMessage();
+}
+
+
+inline void CommandingServiceBase::doPeriodicOperation() {
+}
+
+MessageQueueId_t CommandingServiceBase::getCommandQueue() {
+	return commandQueue->getId();
+}
+
+void CommandingServiceBase::checkTimeout() {
+	uint32_t uptime;
+	Clock::getUptime(&uptime);
+	CommandMapIter iter;
+	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			verificationReporter.sendFailureReport(
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TIMEOUT);
+			checkAndExecuteFifo(iter);
+		}
+	}
+}
+
+void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) {
+    executingTask = task_;
+}
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 32173d81..4a180445 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,348 +1,348 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-
-#include "../objectmanager/SystemObject.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-
-#include "../tmtcservices/VerificationReporter.h"
-#include "../ipc/CommandMessage.h"
-#include "../container/FixedMap.h"
-#include "../container/FIFO.h"
-#include "../serialize/SerializeIF.h"
-
-class TcPacketStored;
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This class is the basis for all PUS Services, which have to
- * 			relay Telecommands to software bus.
- *
- * It manages Telecommand reception and the generation of Verification Reports
- * similar to PusServiceBase. This class is used if a telecommand can't be
- * handled immediately and must be relayed to the internal software bus.
- *   - isValidSubservice
- *   - getMessageQueueAndObject
- *   - prepareCommand
- *   - handleReply
- * @author gaisser
- * @ingroup pus_services
- */
-class CommandingServiceBase: public SystemObject,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
-	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
-	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
-	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
-
-	/**
-	 * Class constructor. Initializes two important MessageQueues:
-	 * commandQueue for command reception and requestQueue for device reception
-	 * @param setObjectId
-	 * @param apid
-	 * @param service
-	 * @param numberOfParallelCommands
-	 * @param commandTimeout_seconds
-	 * @param setPacketSource
-	 * @param setPacketDestination
-	 * @param queueDepth
-	 */
-	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
-			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
-	virtual ~CommandingServiceBase();
-
-	/**
-	 * This setter can be used to set the packet source individually instead
-	 * of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetSource
-	 */
-	void setPacketSource(object_id_t packetSource);
-	/**
-	 * This setter can be used to set the packet destination individually
-	 * instead of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetDestination
-	 */
-	void setPacketDestination(object_id_t packetDestination);
-
-	/***
-	 * This is the periodically called function.
-	 * Handle request queue for external commands.
-	 * Handle command Queue for internal commands.
-	 * @param opCode is unused here at the moment
-	 * @return RETURN_OK
-	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
-	virtual uint16_t getIdentifier();
-
-	/**
-	 * Returns the requestQueue MessageQueueId_t
-	 *
-	 * The requestQueue is the queue for external commands (TC)
-	 *
-	 * @return requestQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getRequestQueue();
-
-	/**
-	 * Returns the commandQueue MessageQueueId_t
-	 *
-	 * Remember the CommandQueue is the queue for internal communication
-	 * @return commandQueue messageQueueId_t
-	 */
-	virtual MessageQueueId_t getCommandQueue();
-
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * 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) override;
-
-protected:
-	/**
-	 * Check the target subservice
-	 * @param subservice[in]
-	 * @return
-	 * -@c RETURN_OK Subservice valid, continue message handling
-     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
-	 */
-	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
-
-	/**
-	 * Once a TC Request is valid, the existence of the destination and its
-	 * target interface is checked and retrieved. The target message queue ID
-	 * can then be acquired by using the target interface.
-	 * @param subservice
-	 * @param tcData Application Data of TC Packet
-	 * @param tcDataLen
-	 * @param id MessageQueue ID is stored here
-	 * @param objectId Object ID is extracted and stored here
-	 * @return
-	 * - @c RETURN_OK Cotinue message handling
-	 * - @c RETURN_FAILED Reject the packet and generates a start failure
-	 *      verification
-	 */
-	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) = 0;
-
-	/**
-	 * After the Message Queue and Object ID are determined, the command is
-	 * prepared by using an implementation specific CommandMessage type
-	 * which is sent to the target object. It contains all necessary information
-	 * for the device to execute telecommands.
-	 * @param message [out] message which can be set and is sent to the object
-	 * @param subservice Subservice of the current communication
-	 * @param tcData Application data of command
-	 * @param tcDataLen Application data length
-	 * @param state [out/in] Setable state of the communication.
-	 * communication
-	 * @param objectId Target object ID
-	 * @return
-	 * - @c RETURN_OK to generate a verification start message
-	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
-	 *      verification message.
-	 * - @c Anything else rejects the packets and generates a start failure
-	 *      verification.
-	 */
-	virtual ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) = 0;
-
-	/**
-	 * This function is implemented by child services to specify how replies
-	 * to a command from another software component are handled.
-	 * @param reply
-	 * This is the reply in form of a generic read-only command message.
-	 * @param previousCommand
-	 * Command_t of related command
-	 * @param state [out/in]
-	 * Additional parameter which can be used to pass state information.
-	 * State of the communication
-	 * @param optionalNextCommand [out]
-	 * An optional next command which can be set in this function
-	 * @param objectId Source object ID
-	 * @param isStep Flag value to mark steps of command execution
-	 * @return
-	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
-	 *   generate TC verification success
-	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
-	 * 	 INVALID_REPLY is returned and the command ID is
-	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
-	 * 	 the reason as the error parameter and the initial command as
-	 * 	 failure parameter 1 is generated.
-	 */
-	virtual ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) = 0;
-
-	/**
-	 * This function can be overidden to handle unrequested reply,
-	 * when the reply sender ID is unknown or is not found is the command map.
-	 * The default implementation will clear the command message and all
-	 * its contents.
-	 * @param reply
-	 * Reply which is non-const so the default implementation can clear the
-	 * message.
-	 */
-	virtual void handleUnrequestedReply(CommandMessage* reply);
-
-	virtual void doPeriodicOperation();
-
-
-	struct CommandInfo {
-		struct tcInfo {
-			uint8_t ackFlags;
-			uint16_t tcPacketId;
-			uint16_t tcSequenceControl;
-		} tcInfo;
-		uint32_t uptimeOfStart;
-		uint8_t step;
-		uint8_t subservice;
-		uint32_t state;
-		Command_t command;
-		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
-	};
-
-	using CommandMapIter = FixedMap<MessageQueueId_t,
-	        CommandingServiceBase::CommandInfo>::Iterator;
-
-	const uint16_t apid;
-
-	const uint8_t service;
-
-	const uint16_t timeoutSeconds;
-
-	uint8_t tmPacketCounter = 0;
-
-	StorageManagerIF *IPCStore = nullptr;
-
-	StorageManagerIF *TCStore = nullptr;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	MessageQueueIF* requestQueue = nullptr;
-
-	VerificationReporter verificationReporter;
-
-	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
-
-	/* May be set be children to return a more precise failure condition. */
-	uint32_t failureParameter1 = 0;
-	uint32_t failureParameter2 = 0;
-
-	static object_id_t defaultPacketSource;
-	object_id_t packetSource = objects::NO_OBJECT;
-	static object_id_t defaultPacketDestination;
-	object_id_t packetDestination = objects::NO_OBJECT;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	/**
-	 * @brief   Send TM data from pointer to data.
-	 *          If a header is supplied it is added before data
-	 * @param subservice Number of subservice
-	 * @param data Pointer to the data in the Packet
-	 * @param dataLen Lenght of data in the Packet
-	 * @param headerData HeaderData will be placed before data
-	 * @param headerSize Size of HeaderData
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
-	        size_t dataLen, const uint8_t* headerData = nullptr,
-	        size_t headerSize = 0);
-
-	/**
-	 * @brief   To send TM packets of objects that still need to be serialized
-	 *          and consist of an object ID with appended data.
-	 * @param subservice Number of subservice
-	 * @param objectId ObjectId is placed before data
-	 * @param data Data to append to the packet
-	 * @param dataLen Length of Data
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
-			const uint8_t *data, size_t dataLen);
-
-	/**
-	 * @brief   To send packets which are contained inside a class implementing
-	 *          SerializeIF.
-	 * @param subservice Number of subservice
-	 * @param content This is a pointer to the serialized packet
-	 * @param header Serialize IF header which will be placed before content
-	 */
-	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
-			SerializeIF* header = nullptr);
-
-	void checkAndExecuteFifo(CommandMapIter iter);
-
-private:
-	/**
-	 * This method handles internal execution of a command,
-	 * once it has been started by @sa{startExecution()} in the request
-	 * queue handler.
-	 * It handles replies generated by the devices and relayed by the specific
-	 * service implementation. This means that it determines further course of
-	 * action depending on the return values specified in the service
-	 * implementation.
-	 * This includes the generation of TC verification messages. Note that
-	 * the static framework object ID @c VerificationReporter::messageReceiver
-	 * needs to be set.
-	 *   - TM[1,5] Step Successs
-	 *   - TM[1,6] Step Failure
-	 *   - TM[1,7] Completion Success
-	 *   - TM[1,8] Completion Failure
-	 */
-	void handleCommandQueue();
-
-	/**
-	 * @brief       Handler function for request queue
-	 * @details
-	 * Sequence of request queue handling:
-	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates a Start Success Reports TM[1,3] in subfunction
-	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
-	 * TC Verification Service.
-	 */
-	void handleRequestQueue();
-
-	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
-			ReturnValue_t errorCode);
-
-	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
-
-	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
-
-	void handleCommandMessage(CommandMessage* reply);
-	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
-			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
-
-	void checkTimeout();
-};
-
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+
+#include "../objectmanager/SystemObject.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/CommandMessage.h"
+#include "../container/FixedMap.h"
+#include "../container/FIFO.h"
+#include "../serialize/SerializeIF.h"
+
+class TcPacketStored;
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This class is the basis for all PUS Services, which have to
+ * 			relay Telecommands to software bus.
+ *
+ * It manages Telecommand reception and the generation of Verification Reports
+ * similar to PusServiceBase. This class is used if a telecommand can't be
+ * handled immediately and must be relayed to the internal software bus.
+ *   - isValidSubservice
+ *   - getMessageQueueAndObject
+ *   - prepareCommand
+ *   - handleReply
+ * @author gaisser
+ * @ingroup pus_services
+ */
+class CommandingServiceBase: public SystemObject,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
+	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
+	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(4);
+	static const ReturnValue_t INVALID_TC = MAKE_RETURN_CODE(5);
+	static const ReturnValue_t INVALID_OBJECT = MAKE_RETURN_CODE(6);
+	static const ReturnValue_t INVALID_REPLY = MAKE_RETURN_CODE(7);
+
+	/**
+	 * Class constructor. Initializes two important MessageQueues:
+	 * commandQueue for command reception and requestQueue for device reception
+	 * @param setObjectId
+	 * @param apid
+	 * @param service
+	 * @param numberOfParallelCommands
+	 * @param commandTimeout_seconds
+	 * @param setPacketSource
+	 * @param setPacketDestination
+	 * @param queueDepth
+	 */
+	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
+			uint8_t service, uint8_t numberOfParallelCommands,
+			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
+	virtual ~CommandingServiceBase();
+
+	/**
+	 * This setter can be used to set the packet source individually instead
+	 * of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetSource
+	 */
+	void setPacketSource(object_id_t packetSource);
+	/**
+	 * This setter can be used to set the packet destination individually
+	 * instead of using the default static framework ID set in the factory.
+	 * This should be called at object initialization and not during run-time!
+	 * @param packetDestination
+	 */
+	void setPacketDestination(object_id_t packetDestination);
+
+	/***
+	 * This is the periodically called function.
+	 * Handle request queue for external commands.
+	 * Handle command Queue for internal commands.
+	 * @param opCode is unused here at the moment
+	 * @return RETURN_OK
+	 */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+	virtual uint16_t getIdentifier();
+
+	/**
+	 * Returns the requestQueue MessageQueueId_t
+	 *
+	 * The requestQueue is the queue for external commands (TC)
+	 *
+	 * @return requestQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getRequestQueue();
+
+	/**
+	 * Returns the commandQueue MessageQueueId_t
+	 *
+	 * Remember the CommandQueue is the queue for internal communication
+	 * @return commandQueue messageQueueId_t
+	 */
+	virtual MessageQueueId_t getCommandQueue();
+
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * 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) override;
+
+protected:
+	/**
+	 * Check the target subservice
+	 * @param subservice[in]
+	 * @return
+	 * -@c RETURN_OK Subservice valid, continue message handling
+     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
+	 */
+	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;
+
+	/**
+	 * Once a TC Request is valid, the existence of the destination and its
+	 * target interface is checked and retrieved. The target message queue ID
+	 * can then be acquired by using the target interface.
+	 * @param subservice
+	 * @param tcData Application Data of TC Packet
+	 * @param tcDataLen
+	 * @param id MessageQueue ID is stored here
+	 * @param objectId Object ID is extracted and stored here
+	 * @return
+	 * - @c RETURN_OK Cotinue message handling
+	 * - @c RETURN_FAILED Reject the packet and generates a start failure
+	 *      verification
+	 */
+	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) = 0;
+
+	/**
+	 * After the Message Queue and Object ID are determined, the command is
+	 * prepared by using an implementation specific CommandMessage type
+	 * which is sent to the target object. It contains all necessary information
+	 * for the device to execute telecommands.
+	 * @param message [out] message which can be set and is sent to the object
+	 * @param subservice Subservice of the current communication
+	 * @param tcData Application data of command
+	 * @param tcDataLen Application data length
+	 * @param state [out/in] Setable state of the communication.
+	 * communication
+	 * @param objectId Target object ID
+	 * @return
+	 * - @c RETURN_OK to generate a verification start message
+	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
+	 *      verification message.
+	 * - @c Anything else rejects the packets and generates a start failure
+	 *      verification.
+	 */
+	virtual ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) = 0;
+
+	/**
+	 * This function is implemented by child services to specify how replies
+	 * to a command from another software component are handled.
+	 * @param reply
+	 * This is the reply in form of a generic read-only command message.
+	 * @param previousCommand
+	 * Command_t of related command
+	 * @param state [out/in]
+	 * Additional parameter which can be used to pass state information.
+	 * State of the communication
+	 * @param optionalNextCommand [out]
+	 * An optional next command which can be set in this function
+	 * @param objectId Source object ID
+	 * @param isStep Flag value to mark steps of command execution
+	 * @return
+	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
+	 *   generate TC verification success
+	 * - @c INVALID_REPLY Calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
+	 * 	 INVALID_REPLY is returned and the command ID is
+	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
+	 * 	 the reason as the error parameter and the initial command as
+	 * 	 failure parameter 1 is generated.
+	 */
+	virtual ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) = 0;
+
+	/**
+	 * This function can be overidden to handle unrequested reply,
+	 * when the reply sender ID is unknown or is not found is the command map.
+	 * The default implementation will clear the command message and all
+	 * its contents.
+	 * @param reply
+	 * Reply which is non-const so the default implementation can clear the
+	 * message.
+	 */
+	virtual void handleUnrequestedReply(CommandMessage* reply);
+
+	virtual void doPeriodicOperation();
+
+
+	struct CommandInfo {
+		struct tcInfo {
+			uint8_t ackFlags;
+			uint16_t tcPacketId;
+			uint16_t tcSequenceControl;
+		} tcInfo;
+		uint32_t uptimeOfStart;
+		uint8_t step;
+		uint8_t subservice;
+		uint32_t state;
+		Command_t command;
+		object_id_t objectId;
+		FIFO<store_address_t, 3> fifo;
+	};
+
+	using CommandMapIter = FixedMap<MessageQueueId_t,
+	        CommandingServiceBase::CommandInfo>::Iterator;
+
+	const uint16_t apid;
+
+	const uint8_t service;
+
+	const uint16_t timeoutSeconds;
+
+	uint8_t tmPacketCounter = 0;
+
+	StorageManagerIF *IPCStore = nullptr;
+
+	StorageManagerIF *TCStore = nullptr;
+
+	MessageQueueIF* commandQueue = nullptr;
+
+	MessageQueueIF* requestQueue = nullptr;
+
+	VerificationReporter verificationReporter;
+
+	FixedMap<MessageQueueId_t, CommandInfo> commandMap;
+
+	/* May be set be children to return a more precise failure condition. */
+	uint32_t failureParameter1 = 0;
+	uint32_t failureParameter2 = 0;
+
+	static object_id_t defaultPacketSource;
+	object_id_t packetSource = objects::NO_OBJECT;
+	static object_id_t defaultPacketDestination;
+	object_id_t packetDestination = objects::NO_OBJECT;
+
+	/**
+	 * Pointer to the task which executes this component,
+	 * is invalid before setTaskIF was called.
+	 */
+	PeriodicTaskIF* executingTask = nullptr;
+
+	/**
+	 * @brief   Send TM data from pointer to data.
+	 *          If a header is supplied it is added before data
+	 * @param subservice Number of subservice
+	 * @param data Pointer to the data in the Packet
+	 * @param dataLen Lenght of data in the Packet
+	 * @param headerData HeaderData will be placed before data
+	 * @param headerSize Size of HeaderData
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data,
+	        size_t dataLen, const uint8_t* headerData = nullptr,
+	        size_t headerSize = 0);
+
+	/**
+	 * @brief   To send TM packets of objects that still need to be serialized
+	 *          and consist of an object ID with appended data.
+	 * @param subservice Number of subservice
+	 * @param objectId ObjectId is placed before data
+	 * @param data Data to append to the packet
+	 * @param dataLen Length of Data
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId,
+			const uint8_t *data, size_t dataLen);
+
+	/**
+	 * @brief   To send packets which are contained inside a class implementing
+	 *          SerializeIF.
+	 * @param subservice Number of subservice
+	 * @param content This is a pointer to the serialized packet
+	 * @param header Serialize IF header which will be placed before content
+	 */
+	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
+			SerializeIF* header = nullptr);
+
+	void checkAndExecuteFifo(CommandMapIter iter);
+
+private:
+	/**
+	 * This method handles internal execution of a command,
+	 * once it has been started by @sa{startExecution()} in the request
+	 * queue handler.
+	 * It handles replies generated by the devices and relayed by the specific
+	 * service implementation. This means that it determines further course of
+	 * action depending on the return values specified in the service
+	 * implementation.
+	 * This includes the generation of TC verification messages. Note that
+	 * the static framework object ID @c VerificationReporter::messageReceiver
+	 * needs to be set.
+	 *   - TM[1,5] Step Successs
+	 *   - TM[1,6] Step Failure
+	 *   - TM[1,7] Completion Success
+	 *   - TM[1,8] Completion Failure
+	 */
+	void handleCommandQueue();
+
+	/**
+	 * @brief       Handler function for request queue
+	 * @details
+	 * Sequence of request queue handling:
+	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
+	 * Generates a Start Success Reports TM[1,3] in subfunction
+	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
+	 * TC Verification Service.
+	 */
+	void handleRequestQueue();
+
+	void rejectPacket(uint8_t reportId, TcPacketStored* packet,
+			ReturnValue_t errorCode);
+
+	void acceptPacket(uint8_t reportId, TcPacketStored* packet);
+
+	void startExecution(TcPacketStored *storedPacket, CommandMapIter iter);
+
+	void handleCommandMessage(CommandMessage* reply);
+	void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter,
+			CommandMessage* nextCommand, CommandMessage* reply, bool& isStep);
+
+	void checkTimeout();
+};
+
+#endif /* COMMANDINGSERVICEBASE_H_ */
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index a8b74e39..9d4aabd9 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,123 +1,123 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tmtcservices/PusServiceBase.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcservices/TmTcMessage.h"
-#include "../ipc/QueueFactory.h"
-
-object_id_t PusServiceBase::packetSource = 0;
-object_id_t PusServiceBase::packetDestination = 0;
-
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
-		uint8_t setServiceId) :
-		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
-	requestQueue = QueueFactory::instance()->
-			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
-}
-
-PusServiceBase::~PusServiceBase() {
-	QueueFactory::instance()->deleteMessageQueue(requestQueue);
-}
-
-ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
-	handleRequestQueue();
-	ReturnValue_t result = this->performService();
-	if (result != RETURN_OK) {
-		sif::error << "PusService " << (uint16_t) this->serviceId
-				<< ": performService returned with " << (int16_t) result
-				<< std::endl;
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
-    this->taskHandle = taskHandle;
-}
-
-void PusServiceBase::handleRequestQueue() {
-	TmTcMessage message;
-	ReturnValue_t result = RETURN_FAILED;
-	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
-		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
-//		if(status != MessageQueueIF::EMPTY) {
-//			sif::debug << "PusServiceBase::performOperation: Receiving from "
-//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
-//					<< std::setfill('0') << this->requestQueue->getId()
-//					<< std::dec << " returned: " << status << std::setfill(' ')
-//					<<  std::endl;
-//		}
-
-		if (status == RETURN_OK) {
-			this->currentPacket.setStoreAddress(message.getStorageId());
-			//info << "Service " << (uint16_t) this->serviceId <<
-			//     ": new packet!" << std::endl;
-
-			result = this->handleRequest(currentPacket.getSubService());
-
-			// debug << "Service " << (uint16_t)this->serviceId <<
-			//    ": handleRequest returned: " << (int)return_code << std::endl;
-			if (result == RETURN_OK) {
-				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
-			}
-			else {
-				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
-						result, 0, errorParameter1, errorParameter2);
-			}
-			this->currentPacket.deletePacket();
-			errorParameter1 = 0;
-			errorParameter2 = 0;
-		}
-		else if (status == MessageQueueIF::EMPTY) {
-			status = RETURN_OK;
-			// debug << "PusService " << (uint16_t)this->serviceId <<
-			//      ": no new packet." << std::endl;
-			break;
-		}
-		else {
-			sif::error << "PusServiceBase::performOperation: Service "
-					<< this->serviceId << ": Error receiving packet. Code: "
-					<< std::hex << status << std::dec << std::endl;
-		}
-	}
-}
-
-uint16_t PusServiceBase::getIdentifier() {
-	return this->serviceId;
-}
-
-MessageQueueId_t PusServiceBase::getRequestQueue() {
-	return this->requestQueue->getId();
-}
-
-ReturnValue_t PusServiceBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
-			packetDestination);
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
-			packetSource);
-	if (destService == nullptr or distributor == nullptr) {
-		sif::error << "PusServiceBase::PusServiceBase: Service "
-				<< this->serviceId << ": Configuration error. Make sure "
-				<<	"packetSource and packetDestination are defined correctly"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	this->requestQueue->setDefaultDestination(
-			destService->getReportReceptionQueue());
-	distributor->registerService(this);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
-    // If task parameters, for example task frequency are required, this
-    // function should be overriden and the system object task IF can
-    // be used to get those parameters.
-    return HasReturnvaluesIF::RETURN_OK;
-}
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tmtcservices/PusServiceBase.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+object_id_t PusServiceBase::packetSource = 0;
+object_id_t PusServiceBase::packetDestination = 0;
+
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid,
+		uint8_t setServiceId) :
+		SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+	requestQueue = QueueFactory::instance()->
+			createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
+}
+
+PusServiceBase::~PusServiceBase() {
+	QueueFactory::instance()->deleteMessageQueue(requestQueue);
+}
+
+ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
+	handleRequestQueue();
+	ReturnValue_t result = this->performService();
+	if (result != RETURN_OK) {
+		sif::error << "PusService " << (uint16_t) this->serviceId
+				<< ": performService returned with " << (int16_t) result
+				<< std::endl;
+		return RETURN_FAILED;
+	}
+	return RETURN_OK;
+}
+
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) {
+    this->taskHandle = taskHandle;
+}
+
+void PusServiceBase::handleRequestQueue() {
+	TmTcMessage message;
+	ReturnValue_t result = RETURN_FAILED;
+	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
+		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
+//		if(status != MessageQueueIF::EMPTY) {
+//			sif::debug << "PusServiceBase::performOperation: Receiving from "
+//					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
+//					<< std::setfill('0') << this->requestQueue->getId()
+//					<< std::dec << " returned: " << status << std::setfill(' ')
+//					<<  std::endl;
+//		}
+
+		if (status == RETURN_OK) {
+			this->currentPacket.setStoreAddress(message.getStorageId());
+			//info << "Service " << (uint16_t) this->serviceId <<
+			//     ": new packet!" << std::endl;
+
+			result = this->handleRequest(currentPacket.getSubService());
+
+			// debug << "Service " << (uint16_t)this->serviceId <<
+			//    ": handleRequest returned: " << (int)return_code << std::endl;
+			if (result == RETURN_OK) {
+				this->verifyReporter.sendSuccessReport(
+						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+			}
+			else {
+				this->verifyReporter.sendFailureReport(
+						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						result, 0, errorParameter1, errorParameter2);
+			}
+			this->currentPacket.deletePacket();
+			errorParameter1 = 0;
+			errorParameter2 = 0;
+		}
+		else if (status == MessageQueueIF::EMPTY) {
+			status = RETURN_OK;
+			// debug << "PusService " << (uint16_t)this->serviceId <<
+			//      ": no new packet." << std::endl;
+			break;
+		}
+		else {
+			sif::error << "PusServiceBase::performOperation: Service "
+					<< this->serviceId << ": Error receiving packet. Code: "
+					<< std::hex << status << std::dec << std::endl;
+		}
+	}
+}
+
+uint16_t PusServiceBase::getIdentifier() {
+	return this->serviceId;
+}
+
+MessageQueueId_t PusServiceBase::getRequestQueue() {
+	return this->requestQueue->getId();
+}
+
+ReturnValue_t PusServiceBase::initialize() {
+	ReturnValue_t result = SystemObject::initialize();
+	if (result != RETURN_OK) {
+		return result;
+	}
+	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
+			packetDestination);
+	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+			packetSource);
+	if (destService == nullptr or distributor == nullptr) {
+		sif::error << "PusServiceBase::PusServiceBase: Service "
+				<< this->serviceId << ": Configuration error. Make sure "
+				<<	"packetSource and packetDestination are defined correctly"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	this->requestQueue->setDefaultDestination(
+			destService->getReportReceptionQueue());
+	distributor->registerService(this);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
+    // If task parameters, for example task frequency are required, this
+    // function should be overriden and the system object task IF can
+    // be used to get those parameters.
+    return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index f9431275..7c8f504c 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,159 +1,159 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationCodes.h"
-#include "../tmtcservices/VerificationReporter.h"
-#include "../ipc/MessageQueueIF.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @defgroup pus_services PUS Service Framework
- * These group contains all implementations of PUS Services in the OBSW.
- * Most of the Services are directly taken from the ECSS PUS Standard.
- */
-
-/**
- * @brief 	This class is the basis for all PUS Services,
- * 			which can immediately process Telecommand Packets.
- * @details
- * It manages Telecommand reception and the generation of Verification Reports.
- * Every class that inherits from this abstract class has to implement
- * handleRequest and performService. Services that are created with this
- * Base class have to handle any kind of request immediately on reception.
- * All PUS Services are System Objects, so an Object ID needs to be specified
- * on construction.
- * @ingroup pus_services
- */
-class PusServiceBase : public ExecutableObjectIF,
-        public AcceptsTelecommandsIF,
-        public SystemObject,
-        public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	/**
-	 * @brief	The passed values are set, but inter-object initialization is
-	 * 			done in the initialize method.
-	 * @param setObjectId
-	 * The system object identifier of this Service instance.
-	 * @param setApid
-	 * The APID the Service is instantiated for.
-	 * @param setServiceId
-	 * The Service Identifier as specified in ECSS PUS.
-	 */
-	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
-			uint8_t setServiceId);
-	/**
-	 * The destructor is empty.
-	 */
-	virtual ~PusServiceBase();
-	/**
-	 * @brief 	The handleRequest method shall handle any kind of Telecommand
-	 * 			Request immediately.
-	 * @details
-	 * Implemetations can take the Telecommand in currentPacket and perform
-	 * any kind of operation.
-	 * They may send additional "Start Success (1,3)" messages with the
-	 * verifyReporter, but Completion Success or Failure Reports are generated
-	 * automatically after execution of this method.
-	 *
-	 * If a Telecommand can not be executed within one call cycle,
-	 * this Base class is not the right parent.
-	 *
-	 * The child class may add additional error information by setting
-	 * #errorParameters which aren attached to the generated verification
-	 * message.
-	 *
-	 * Subservice checking should be implemented in this method.
-	 *
-	 * @return	The returned status_code is directly taken as main error code
-	 * 			in the Verification Report.
-	 * 			On success, RETURN_OK shall be returned.
-	 */
-	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
-	/**
-	 * In performService, implementations can handle periodic,
-	 * non-TC-triggered activities.
-	 * The performService method is always called.
-	 * @return	Currently, everything other that RETURN_OK only triggers
-	 * 			diagnostic output.
-	 */
-	virtual ReturnValue_t performService() = 0;
-	/**
-	 * This method implements the typical activity of a simple PUS Service.
-	 * It checks for new requests, and, if found, calls handleRequest, sends
-	 * completion verification messages and deletes
-	 * the TC requests afterwards.
-	 * performService is always executed afterwards.
-	 * @return	@c RETURN_OK if the periodic performService was successful.
-	 * 			@c RETURN_FAILED else.
-	 */
-	ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual uint16_t getIdentifier() override;
-	MessageQueueId_t getRequestQueue() override;
-	virtual ReturnValue_t initialize() override;
-
-	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-protected:
-	/**
-	 * @brief   Handle to the underlying task
-	 * @details
-	 * Will be set by setTaskIF(), which is called on task creation.
-	 */
-	PeriodicTaskIF* taskHandle = nullptr;
-	/**
-	 * The APID of this instance of the Service.
-	 */
-	uint16_t apid;
-	/**
-	 * The Service Identifier.
-	 */
-	uint8_t serviceId;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter1 = 0;
-	/**
-	 * One of two error parameters for additional error information.
-	 */
-	uint32_t errorParameter2 = 0;
-	/**
-	 * This is a complete instance of the telecommand reception queue
-	 * of the class. It is initialized on construction of the class.
-	 */
-	MessageQueueIF* requestQueue = nullptr;
-	/**
-	 * An instance of the VerificationReporter class, that simplifies
-	 * sending any kind of verification message to the TC Verification Service.
-	 */
-	VerificationReporter verifyReporter;
-	/**
-	 * The current Telecommand to be processed.
-	 * It is deleted after handleRequest was executed.
-	 */
-	TcPacketStored currentPacket;
-
-	static object_id_t packetSource;
-
-	static object_id_t packetDestination;
-private:
-	/**
-	 * This constant sets the maximum number of packets accepted per call.
-	 * Remember that one packet must be completely handled in one
-	 * #handleRequest call.
-	 */
-	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
-
-	void handleRequestQueue();
-};
-
-#endif /* PUSSERVICEBASE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../tmtcservices/VerificationCodes.h"
+#include "../tmtcservices/VerificationReporter.h"
+#include "../ipc/MessageQueueIF.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @defgroup pus_services PUS Service Framework
+ * These group contains all implementations of PUS Services in the OBSW.
+ * Most of the Services are directly taken from the ECSS PUS Standard.
+ */
+
+/**
+ * @brief 	This class is the basis for all PUS Services,
+ * 			which can immediately process Telecommand Packets.
+ * @details
+ * It manages Telecommand reception and the generation of Verification Reports.
+ * Every class that inherits from this abstract class has to implement
+ * handleRequest and performService. Services that are created with this
+ * Base class have to handle any kind of request immediately on reception.
+ * All PUS Services are System Objects, so an Object ID needs to be specified
+ * on construction.
+ * @ingroup pus_services
+ */
+class PusServiceBase : public ExecutableObjectIF,
+        public AcceptsTelecommandsIF,
+        public SystemObject,
+        public HasReturnvaluesIF {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	/**
+	 * @brief	The passed values are set, but inter-object initialization is
+	 * 			done in the initialize method.
+	 * @param setObjectId
+	 * The system object identifier of this Service instance.
+	 * @param setApid
+	 * The APID the Service is instantiated for.
+	 * @param setServiceId
+	 * The Service Identifier as specified in ECSS PUS.
+	 */
+	PusServiceBase(	object_id_t setObjectId, uint16_t setApid,
+			uint8_t setServiceId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PusServiceBase();
+	/**
+	 * @brief 	The handleRequest method shall handle any kind of Telecommand
+	 * 			Request immediately.
+	 * @details
+	 * Implemetations can take the Telecommand in currentPacket and perform
+	 * any kind of operation.
+	 * They may send additional "Start Success (1,3)" messages with the
+	 * verifyReporter, but Completion Success or Failure Reports are generated
+	 * automatically after execution of this method.
+	 *
+	 * If a Telecommand can not be executed within one call cycle,
+	 * this Base class is not the right parent.
+	 *
+	 * The child class may add additional error information by setting
+	 * #errorParameters which aren attached to the generated verification
+	 * message.
+	 *
+	 * Subservice checking should be implemented in this method.
+	 *
+	 * @return	The returned status_code is directly taken as main error code
+	 * 			in the Verification Report.
+	 * 			On success, RETURN_OK shall be returned.
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) = 0;
+	/**
+	 * In performService, implementations can handle periodic,
+	 * non-TC-triggered activities.
+	 * The performService method is always called.
+	 * @return	Currently, everything other that RETURN_OK only triggers
+	 * 			diagnostic output.
+	 */
+	virtual ReturnValue_t performService() = 0;
+	/**
+	 * This method implements the typical activity of a simple PUS Service.
+	 * It checks for new requests, and, if found, calls handleRequest, sends
+	 * completion verification messages and deletes
+	 * the TC requests afterwards.
+	 * performService is always executed afterwards.
+	 * @return	@c RETURN_OK if the periodic performService was successful.
+	 * 			@c RETURN_FAILED else.
+	 */
+	ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual uint16_t getIdentifier() override;
+	MessageQueueId_t getRequestQueue() override;
+	virtual ReturnValue_t initialize() override;
+
+	virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+protected:
+	/**
+	 * @brief   Handle to the underlying task
+	 * @details
+	 * Will be set by setTaskIF(), which is called on task creation.
+	 */
+	PeriodicTaskIF* taskHandle = nullptr;
+	/**
+	 * The APID of this instance of the Service.
+	 */
+	uint16_t apid;
+	/**
+	 * The Service Identifier.
+	 */
+	uint8_t serviceId;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter1 = 0;
+	/**
+	 * One of two error parameters for additional error information.
+	 */
+	uint32_t errorParameter2 = 0;
+	/**
+	 * This is a complete instance of the telecommand reception queue
+	 * of the class. It is initialized on construction of the class.
+	 */
+	MessageQueueIF* requestQueue = nullptr;
+	/**
+	 * An instance of the VerificationReporter class, that simplifies
+	 * sending any kind of verification message to the TC Verification Service.
+	 */
+	VerificationReporter verifyReporter;
+	/**
+	 * The current Telecommand to be processed.
+	 * It is deleted after handleRequest was executed.
+	 */
+	TcPacketStored currentPacket;
+
+	static object_id_t packetSource;
+
+	static object_id_t packetDestination;
+private:
+	/**
+	 * This constant sets the maximum number of packets accepted per call.
+	 * Remember that one packet must be completely handled in one
+	 * #handleRequest call.
+	 */
+	static const uint8_t PUS_SERVICE_MAX_RECEPTION = 10;
+
+	void handleRequestQueue();
+};
+
+#endif /* PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index d83380a2..369519d8 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -1,163 +1,163 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-PusVerificationMessage::PusVerificationMessage() {
-}
-
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
-PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
-		uint32_t parameter2) {
-	uint8_t *data = this->getBuffer();
-	data[messageSize] = set_report_id;
-	messageSize += sizeof(set_report_id);
-	data[messageSize] = ackFlags;
-	messageSize += sizeof(ackFlags);
-	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-	messageSize += sizeof(tcPacketId);
-	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-	messageSize += sizeof(tcSequenceControl);
-	data[messageSize] = set_step;
-	messageSize += sizeof(set_step);
-	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-	messageSize += sizeof(set_error_code);
-	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-	messageSize += sizeof(parameter1);
-	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-	messageSize += sizeof(parameter2);
-}
-
-uint8_t PusVerificationMessage::getReportId() {
-
-	return getContent()->reportId;
-}
-
-uint8_t PusVerificationMessage::getAckFlags() {
-
-	return getContent()->ackFlags;
-}
-
-uint16_t PusVerificationMessage::getTcPacketId() {
-
-	uint16_t tcPacketId;
-	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
-	return tcPacketId;
-}
-
-uint16_t PusVerificationMessage::getTcSequenceControl() {
-
-	uint16_t tcSequenceControl;
-	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
-			sizeof(tcSequenceControl));
-	return tcSequenceControl;
-}
-
-uint8_t PusVerificationMessage::getStep() {
-
-	return getContent()->step;
-}
-
-ReturnValue_t PusVerificationMessage::getErrorCode() {
-	ReturnValue_t errorCode;
-	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
-	return errorCode;
-}
-
-PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
-	return (verifciationMessageContent*) this->getData();
-}
-
-uint32_t PusVerificationMessage::getParameter1() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
-	return parameter;
-}
-
-uint32_t PusVerificationMessage::getParameter2() {
-	uint32_t parameter;
-	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
-	return parameter;
-}
-
-PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, uint8_t setStep) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-}
-
-PusSuccessReport::~PusSuccessReport() {
-
-}
-
-uint32_t PusSuccessReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusSuccessReport::getReport() {
-	return reportBuffer;
-}
-
-PusFailureReport::PusFailureReport(uint16_t setPacketId,
-		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
-		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
-		reportSize(0), pBuffer(reportBuffer) {
-	//Serialization won't fail, because we know the necessary max-size of the buffer.
-	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	if (setStep != 0) {
-		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
-				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	}
-	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
-			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
-}
-
-PusFailureReport::~PusFailureReport() {
-}
-
-size_t PusFailureReport::getSize() {
-	return reportSize;
-}
-
-uint8_t* PusFailureReport::getReport() {
-	return reportBuffer;
-}
+#include "../serialize/SerializeAdapter.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PusVerificationMessage::PusVerificationMessage() {
+}
+
+//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
+//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
+//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
+//	uint16_t tcPacketId = current_packet->getPacketId();
+//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
+//	uint8_t* data = this->getBuffer();
+//	data[messageSize] = set_report_id;
+//	messageSize += sizeof(set_report_id);
+//	data[messageSize] = ackFlags;
+//	messageSize += sizeof(ackFlags);
+//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+//	messageSize += sizeof(tcPacketId);
+//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+//	messageSize += sizeof(tcSequenceControl);
+//	data[messageSize] = set_step;
+//	messageSize += sizeof(set_step);
+//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+//	messageSize += sizeof(set_error_code);
+//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+//	messageSize += sizeof(parameter1);
+//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+//	messageSize += sizeof(parameter2);
+//}
+
+PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
+		uint32_t parameter2) {
+	uint8_t *data = this->getBuffer();
+	data[messageSize] = set_report_id;
+	messageSize += sizeof(set_report_id);
+	data[messageSize] = ackFlags;
+	messageSize += sizeof(ackFlags);
+	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
+	messageSize += sizeof(tcPacketId);
+	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
+	messageSize += sizeof(tcSequenceControl);
+	data[messageSize] = set_step;
+	messageSize += sizeof(set_step);
+	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
+	messageSize += sizeof(set_error_code);
+	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
+	messageSize += sizeof(parameter1);
+	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
+	messageSize += sizeof(parameter2);
+}
+
+uint8_t PusVerificationMessage::getReportId() {
+
+	return getContent()->reportId;
+}
+
+uint8_t PusVerificationMessage::getAckFlags() {
+
+	return getContent()->ackFlags;
+}
+
+uint16_t PusVerificationMessage::getTcPacketId() {
+
+	uint16_t tcPacketId;
+	memcpy(&tcPacketId, &getContent()->packetId_0, sizeof(tcPacketId));
+	return tcPacketId;
+}
+
+uint16_t PusVerificationMessage::getTcSequenceControl() {
+
+	uint16_t tcSequenceControl;
+	memcpy(&tcSequenceControl, &getContent()->tcSequenceControl_0,
+			sizeof(tcSequenceControl));
+	return tcSequenceControl;
+}
+
+uint8_t PusVerificationMessage::getStep() {
+
+	return getContent()->step;
+}
+
+ReturnValue_t PusVerificationMessage::getErrorCode() {
+	ReturnValue_t errorCode;
+	memcpy(&errorCode, &getContent()->error_code_0, sizeof(errorCode));
+	return errorCode;
+}
+
+PusVerificationMessage::verifciationMessageContent* PusVerificationMessage::getContent() {
+	return (verifciationMessageContent*) this->getData();
+}
+
+uint32_t PusVerificationMessage::getParameter1() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter1_0, sizeof(parameter));
+	return parameter;
+}
+
+uint32_t PusVerificationMessage::getParameter2() {
+	uint32_t parameter;
+	memcpy(&parameter, &getContent()->parameter2_0, sizeof(parameter));
+	return parameter;
+}
+
+PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, uint8_t setStep) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+}
+
+PusSuccessReport::~PusSuccessReport() {
+
+}
+
+uint32_t PusSuccessReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusSuccessReport::getReport() {
+	return reportBuffer;
+}
+
+PusFailureReport::PusFailureReport(uint16_t setPacketId,
+		uint16_t setSequenceControl, ReturnValue_t setErrorCode,
+		uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
+		reportSize(0), pBuffer(reportBuffer) {
+	//Serialization won't fail, because we know the necessary max-size of the buffer.
+	SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	if (setStep != 0) {
+		SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
+				sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	}
+	SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+	SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
+			sizeof(reportBuffer), SerializeIF::Endianness::BIG);
+}
+
+PusFailureReport::~PusFailureReport() {
+}
+
+size_t PusFailureReport::getSize() {
+	return reportSize;
+}
+
+uint8_t* PusFailureReport::getReport() {
+	return reportBuffer;
+}
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index 26a1eaed..c0a46758 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,77 +1,77 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../tmtcpacket/pus/TcPacketBase.h"
-#include "../tmtcservices/VerificationCodes.h"
-
-class PusVerificationMessage: public MessageQueueMessage {
-private:
-	struct verifciationMessageContent {
-		uint8_t reportId;
-		uint8_t ackFlags;
-		uint8_t packetId_0;
-		uint8_t packetId_1;
-		uint8_t tcSequenceControl_0;
-		uint8_t tcSequenceControl_1;
-		uint8_t step;
-		uint8_t error_code_0;
-		uint8_t error_code_1;
-		uint8_t parameter1_0;
-		uint8_t parameter1_1;
-		uint8_t parameter1_2;
-		uint8_t parameter1_3;
-		uint8_t parameter2_0;
-		uint8_t parameter2_1;
-		uint8_t parameter2_2;
-		uint8_t parameter2_3;
-	};
-	verifciationMessageContent* getContent();
-public:
-	static const uint8_t VERIFICATION_MIN_SIZE = 6;
-	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
-	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	uint8_t getReportId();
-	uint8_t getAckFlags();
-	uint16_t getTcPacketId();
-	uint16_t getTcSequenceControl();
-	ReturnValue_t getErrorCode();
-	uint8_t getStep();
-	uint32_t getParameter1();
-	uint32_t getParameter2();
-};
-
-class PusSuccessReport {
-private:
-	static const uint16_t MAX_SIZE = 7;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			uint8_t set_step = 0);
-	~PusSuccessReport();
-	uint32_t getSize();
-	uint8_t* getReport();
-};
-
-class PusFailureReport {
-private:
-	static const uint16_t MAX_SIZE = 16;
-	uint8_t reportBuffer[MAX_SIZE];
-	size_t reportSize;
-	uint8_t * pBuffer;
-public:
-	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
-			ReturnValue_t setErrorCode, uint8_t setStep = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-	~PusFailureReport();
-	size_t getSize();
-	uint8_t* getReport();
-};
-
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#ifndef PUSVERIFICATIONREPORT_H_
+#define PUSVERIFICATIONREPORT_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../tmtcpacket/pus/TcPacketBase.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+class PusVerificationMessage: public MessageQueueMessage {
+private:
+	struct verifciationMessageContent {
+		uint8_t reportId;
+		uint8_t ackFlags;
+		uint8_t packetId_0;
+		uint8_t packetId_1;
+		uint8_t tcSequenceControl_0;
+		uint8_t tcSequenceControl_1;
+		uint8_t step;
+		uint8_t error_code_0;
+		uint8_t error_code_1;
+		uint8_t parameter1_0;
+		uint8_t parameter1_1;
+		uint8_t parameter1_2;
+		uint8_t parameter1_3;
+		uint8_t parameter2_0;
+		uint8_t parameter2_1;
+		uint8_t parameter2_2;
+		uint8_t parameter2_3;
+	};
+	verifciationMessageContent* getContent();
+public:
+	static const uint8_t VERIFICATION_MIN_SIZE = 6;
+	PusVerificationMessage();
+//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	uint8_t getReportId();
+	uint8_t getAckFlags();
+	uint16_t getTcPacketId();
+	uint16_t getTcSequenceControl();
+	ReturnValue_t getErrorCode();
+	uint8_t getStep();
+	uint32_t getParameter1();
+	uint32_t getParameter2();
+};
+
+class PusSuccessReport {
+private:
+	static const uint16_t MAX_SIZE = 7;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			uint8_t set_step = 0);
+	~PusSuccessReport();
+	uint32_t getSize();
+	uint8_t* getReport();
+};
+
+class PusFailureReport {
+private:
+	static const uint16_t MAX_SIZE = 16;
+	uint8_t reportBuffer[MAX_SIZE];
+	size_t reportSize;
+	uint8_t * pBuffer;
+public:
+	PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
+			ReturnValue_t setErrorCode, uint8_t setStep = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	~PusFailureReport();
+	size_t getSize();
+	uint8_t* getReport();
+};
+
+#endif /* PUSVERIFICATIONREPORT_H_ */
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index 0db53380..1cc58758 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,30 +1,30 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
-
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
-#include "../tmtcpacket/SpacePacketBase.h"
-
-class SourceSequenceCounter {
-private:
-	uint16_t sequenceCount;
-public:
-	SourceSequenceCounter() : sequenceCount(0) {}
-	void increment() {
-		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	void decrement() {
-		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-	uint16_t get() { return this->sequenceCount; }
-	void reset(uint16_t toValue = 0) {
-		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
-	}
-};
-
-
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+/**
+ * @file	SourceSequenceCounter.h
+ * @brief	This file defines the SourceSequenceCounter class.
+ * @date	04.02.2013
+ * @author	baetz
+ */
+
+#ifndef SOURCESEQUENCECOUNTER_H_
+#define SOURCESEQUENCECOUNTER_H_
+#include "../tmtcpacket/SpacePacketBase.h"
+
+class SourceSequenceCounter {
+private:
+	uint16_t sequenceCount;
+public:
+	SourceSequenceCounter() : sequenceCount(0) {}
+	void increment() {
+		sequenceCount = (sequenceCount+1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	void decrement() {
+		sequenceCount = (sequenceCount-1) % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+	uint16_t get() { return this->sequenceCount; }
+	void reset(uint16_t toValue = 0) {
+		sequenceCount = toValue % (SpacePacketBase::LIMIT_SEQUENCE_COUNT);
+	}
+};
+
+
+#endif /* SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 706bbbf2..8c2f15e5 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,237 +1,237 @@
-#include "../tmtcservices/TmTcBridge.h"
-
-#include "../ipc/QueueFactory.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../globalfunctions/arrayprinter.h"
-
-TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
-		object_id_t tmStoreId, object_id_t tcStoreId):
-		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
-		tcDestination(tcDestination)
-
-{
-    tmTcReceptionQueue = QueueFactory::instance()->
-            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
-}
-
-TmTcBridge::~TmTcBridge() {}
-
-ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
-		uint8_t sentPacketsPerCycle) {
-	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
-		this->sentPacketsPerCycle = sentPacketsPerCycle;
-		return RETURN_OK;
-	}
-	else {
-	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
-	             << "packets sent per cycle exceeds limits. "
-	             << "Keeping default value." << std::endl;
-		return RETURN_FAILED;
-	}
-}
-
-ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
-        uint8_t maxNumberOfPacketsStored) {
-    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
-        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
-        return RETURN_OK;
-    }
-    else {
-        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
-                << "packets stored exceeds limits. "
-                << "Keeping default value." << std::endl;
-        return RETURN_FAILED;
-    }
-}
-
-ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
-	if (tcStore == nullptr) {
-		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
-				"it is created and set up properly." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
-	if (tmStore == nullptr) {
-		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
-				"it is created and set up properly." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
-	if (tcDistributor == nullptr) {
-		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
-				<< std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-
-	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
-
-	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
-	return RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
-	ReturnValue_t result;
-	result = handleTc();
-	if(result != RETURN_OK) {
-		sif::debug << "TmTcBridge::performOperation: "
-		        << "Error handling TCs" << std::endl;
-	}
-	result = handleTm();
-	if (result != RETURN_OK) {
-	    sif::debug << "TmTcBridge::performOperation: "
-	                    << "Error handling TMs" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t TmTcBridge::handleTc() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::handleTm() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	ReturnValue_t result = handleTmQueue();
-	if(result != RETURN_OK) {
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
-		        << std::endl;
-		status = result;
-	}
-
-	if(tmStored and communicationLinkUp and
-	        (packetSentCounter < sentPacketsPerCycle)) {
-	    result = handleStoredTm();
-	    if(result != RETURN_OK) {
-	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
-	                << std::endl;
-	        status = result;
-	    }
-	}
-	packetSentCounter = 0;
-	return status;
-}
-
-ReturnValue_t TmTcBridge::handleTmQueue() {
-	TmTcMessage message;
-	const uint8_t* data = nullptr;
-	size_t size = 0;
-	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
-		 result == HasReturnvaluesIF::RETURN_OK;
-		 result = tmTcReceptionQueue->receiveMessage(&message))
-	{
-	    //sif::info << (int) packetSentCounter << std::endl;
-		if(communicationLinkUp == false or
-		        packetSentCounter >= sentPacketsPerCycle) {
-			storeDownlinkData(&message);
-			continue;
-		}
-
-		result = tmStore->getData(message.getStorageId(), &data, &size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-			continue;
-		}
-
-		result = sendTm(data, size);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-		}
-		else {
-		    tmStore->deleteData(message.getStorageId());
-		    packetSentCounter++;
-		}
-	}
-	return status;
-}
-
-ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	store_address_t storeId = 0;
-
-	if(tmFifo->full()) {
-	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-	                    << "of stored packet IDs reached! " << std::endl;
-	    if(overwriteOld) {
-	        tmFifo->retrieve(&storeId);
-	        tmStore->deleteData(storeId);
-	    }
-	    else {
-	        return HasReturnvaluesIF::RETURN_FAILED;
-	    }
-	}
-
-	storeId = message->getStorageId();
-	tmFifo->insert(storeId);
-	tmStored = true;
-	return RETURN_OK;
-}
-
-ReturnValue_t TmTcBridge::handleStoredTm() {
-    ReturnValue_t status = RETURN_OK;
-	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
-		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
-
-		store_address_t storeId;
-		const uint8_t* data = nullptr;
-		size_t size = 0;
-		tmFifo->retrieve(&storeId);
-		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    status = result;
-		}
-
-		result = sendTm(data,size);
-		if(result != RETURN_OK) {
-			sif::error << "TMTC Bridge: Could not send stored downlink data"
-			      << std::endl;
-			status = result;
-		}
-		packetSentCounter ++;
-
-		if(tmFifo->empty()) {
-			tmStored = false;
-		}
-		tmStore->deleteData(storeId);
-	}
-	return status;
-}
-
-void TmTcBridge::registerCommConnect() {
-	if(not communicationLinkUp) {
-		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
-		communicationLinkUp = true;
-	}
-}
-
-void TmTcBridge::registerCommDisconnect() {
-	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
-	if(communicationLinkUp) {
-		communicationLinkUp = false;
-	}
-}
-
-MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
-	return tmTcReceptionQueue->getId();
-}
-
-
-void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
-	arrayprinter::print(data, dataLen);
-}
-
-uint16_t TmTcBridge::getIdentifier() {
-	// This is no PUS service, so we just return 0
-	return 0;
-}
-
-MessageQueueId_t TmTcBridge::getRequestQueue() {
-	// Default implementation: Relay TC messages to TC distributor directly.
-	return tmTcReceptionQueue->getDefaultDestination();
-}
-
-void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
-    this->overwriteOld = overwriteOld;
-}
+#include "../tmtcservices/TmTcBridge.h"
+
+#include "../ipc/QueueFactory.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../globalfunctions/arrayprinter.h"
+
+TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+		object_id_t tmStoreId, object_id_t tcStoreId):
+		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
+		tcDestination(tcDestination)
+
+{
+    tmTcReceptionQueue = QueueFactory::instance()->
+            createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
+}
+
+TmTcBridge::~TmTcBridge() {}
+
+ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
+		uint8_t sentPacketsPerCycle) {
+	if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) {
+		this->sentPacketsPerCycle = sentPacketsPerCycle;
+		return RETURN_OK;
+	}
+	else {
+	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
+	             << "packets sent per cycle exceeds limits. "
+	             << "Keeping default value." << std::endl;
+		return RETURN_FAILED;
+	}
+}
+
+ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
+        uint8_t maxNumberOfPacketsStored) {
+    if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) {
+        this->maxNumberOfPacketsStored = maxNumberOfPacketsStored;
+        return RETURN_OK;
+    }
+    else {
+        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
+                << "packets stored exceeds limits. "
+                << "Keeping default value." << std::endl;
+        return RETURN_FAILED;
+    }
+}
+
+ReturnValue_t TmTcBridge::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	if (tcStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	if (tmStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	AcceptsTelecommandsIF* tcDistributor =
+			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	if (tcDistributor == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmFifo = new DynamicFIFO<store_address_t>(maxNumberOfPacketsStored);
+
+	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
+	ReturnValue_t result;
+	result = handleTc();
+	if(result != RETURN_OK) {
+		sif::debug << "TmTcBridge::performOperation: "
+		        << "Error handling TCs" << std::endl;
+	}
+	result = handleTm();
+	if (result != RETURN_OK) {
+	    sif::debug << "TmTcBridge::performOperation: "
+	                    << "Error handling TMs" << std::endl;
+	}
+	return result;
+}
+
+ReturnValue_t TmTcBridge::handleTc() {
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::handleTm() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = handleTmQueue();
+	if(result != RETURN_OK) {
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
+		        << std::endl;
+		status = result;
+	}
+
+	if(tmStored and communicationLinkUp and
+	        (packetSentCounter < sentPacketsPerCycle)) {
+	    result = handleStoredTm();
+	    if(result != RETURN_OK) {
+	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
+	                << std::endl;
+	        status = result;
+	    }
+	}
+	packetSentCounter = 0;
+	return status;
+}
+
+ReturnValue_t TmTcBridge::handleTmQueue() {
+	TmTcMessage message;
+	const uint8_t* data = nullptr;
+	size_t size = 0;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
+		 result == HasReturnvaluesIF::RETURN_OK;
+		 result = tmTcReceptionQueue->receiveMessage(&message))
+	{
+	    //sif::info << (int) packetSentCounter << std::endl;
+		if(communicationLinkUp == false or
+		        packetSentCounter >= sentPacketsPerCycle) {
+			storeDownlinkData(&message);
+			continue;
+		}
+
+		result = tmStore->getData(message.getStorageId(), &data, &size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+			continue;
+		}
+
+		result = sendTm(data, size);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		else {
+		    tmStore->deleteData(message.getStorageId());
+		    packetSentCounter++;
+		}
+	}
+	return status;
+}
+
+ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
+	store_address_t storeId = 0;
+
+	if(tmFifo->full()) {
+	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+	                    << "of stored packet IDs reached! " << std::endl;
+	    if(overwriteOld) {
+	        tmFifo->retrieve(&storeId);
+	        tmStore->deleteData(storeId);
+	    }
+	    else {
+	        return HasReturnvaluesIF::RETURN_FAILED;
+	    }
+	}
+
+	storeId = message->getStorageId();
+	tmFifo->insert(storeId);
+	tmStored = true;
+	return RETURN_OK;
+}
+
+ReturnValue_t TmTcBridge::handleStoredTm() {
+    ReturnValue_t status = RETURN_OK;
+	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
+		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
+		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+
+		store_address_t storeId;
+		const uint8_t* data = nullptr;
+		size_t size = 0;
+		tmFifo->retrieve(&storeId);
+		ReturnValue_t result = tmStore->getData(storeId, &data, &size);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    status = result;
+		}
+
+		result = sendTm(data,size);
+		if(result != RETURN_OK) {
+			sif::error << "TMTC Bridge: Could not send stored downlink data"
+			      << std::endl;
+			status = result;
+		}
+		packetSentCounter ++;
+
+		if(tmFifo->empty()) {
+			tmStored = false;
+		}
+		tmStore->deleteData(storeId);
+	}
+	return status;
+}
+
+void TmTcBridge::registerCommConnect() {
+	if(not communicationLinkUp) {
+		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+		communicationLinkUp = true;
+	}
+}
+
+void TmTcBridge::registerCommDisconnect() {
+	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+	if(communicationLinkUp) {
+		communicationLinkUp = false;
+	}
+}
+
+MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
+	return tmTcReceptionQueue->getId();
+}
+
+
+void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
+	arrayprinter::print(data, dataLen);
+}
+
+uint16_t TmTcBridge::getIdentifier() {
+	// This is no PUS service, so we just return 0
+	return 0;
+}
+
+MessageQueueId_t TmTcBridge::getRequestQueue() {
+	// Default implementation: Relay TC messages to TC distributor directly.
+	return tmTcReceptionQueue->getDefaultDestination();
+}
+
+void TmTcBridge::setFifoToOverwriteOldData(bool overwriteOld) {
+    this->overwriteOld = overwriteOld;
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 763980dc..62cfdaac 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,162 +1,162 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-
-
-#include "../objectmanager/SystemObject.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../container/DynamicFIFO.h"
-#include "../tmtcservices/TmTcMessage.h"
-
-class TmTcBridge : public AcceptsTelemetryIF,
-		public AcceptsTelecommandsIF,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF,
-		public SystemObject {
-public:
-	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
-	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
-	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
-
-	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
-	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
-
-	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
-			object_id_t tmStoreId, object_id_t tcStoreId);
-	virtual ~TmTcBridge();
-
-	/**
-	 * Set number of packets sent per performOperation().Please note that this
-	 * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE
-	 * @param sentPacketsPerCycle
-	 * @return -@c RETURN_OK if value was set successfully
-	 * 		   -@c RETURN_FAILED otherwise, stored value stays the same
-	 */
-	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
-
-	/**
-	 * Set number of packets sent per performOperation().Please note that this
-	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
-	 * @param sentPacketsPerCycle
-	 * @return -@c RETURN_OK if value was set successfully
-	 *         -@c RETURN_FAILED otherwise, stored value stays the same
-	 */
-	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
-
-	/**
-	 * This will set up the bridge to overwrite old data in the FIFO.
-	 * @param overwriteOld
-	 */
-	void setFifoToOverwriteOldData(bool overwriteOld);
-
-	virtual void registerCommConnect();
-	virtual void registerCommDisconnect();
-
-	/**
-	 * Initializes necessary FSFW components for the TMTC Bridge
-	 * @return
-	 */
-	virtual ReturnValue_t initialize() override;
-
-	/**
-	 * @brief	Handles TMTC reception
-	 */
-	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-
-	/** AcceptsTelemetryIF override */
-	virtual MessageQueueId_t getReportReceptionQueue(
-			uint8_t virtualChannel = 0) override;
-
-	/** AcceptsTelecommandsIF override */
-	virtual uint16_t getIdentifier() override;
-	virtual MessageQueueId_t getRequestQueue() override;
-
-protected:
-	//! Cached for initialize function.
-	object_id_t tmStoreId = objects::NO_OBJECT;
-	object_id_t tcStoreId = objects::NO_OBJECT;
-	object_id_t tcDestination = objects::NO_OBJECT;
-
-	//! Used to send and receive TMTC messages.
-	//! The TmTcMessage class is used to transport messages between tasks.
-	MessageQueueIF* tmTcReceptionQueue = nullptr;
-
-	StorageManagerIF* tmStore = nullptr;
-	StorageManagerIF* tcStore = nullptr;
-
-	//! Used to specify whether communication link is up. Will be true
-	//! by default, so telemetry will be handled immediately.
-	bool communicationLinkUp = true;
-	bool tmStored = false;
-	bool overwriteOld = true;
-	uint8_t packetSentCounter = 0;
-
-	/**
-	 * @brief 	Handle TC reception
-	 * @details
-	 * Default implementation provided, but is empty.
-	 * In most cases, TC reception will be handled in a separate task anyway.
-	 * @return
-	 */
-	virtual ReturnValue_t handleTc();
-
-	/**
-	 * Handle Telemetry. Default implementation provided.
-	 * Calls sendTm()
-	 * @return
-	 */
-	virtual ReturnValue_t handleTm();
-
-	/**
-	 * Read the TM Queue and send TM if necessary.
-	 * Default implementation provided
-	 * @return
-	 */
-	virtual ReturnValue_t handleTmQueue();
-
-	/**
-	 * Send stored data if communication link is active
-	 * @return
-	 */
-	virtual ReturnValue_t handleStoredTm();
-
-	/**
-	 * Implemented by child class. Perform sending of Telemetry by implementing
-	 * communication drivers or wrappers, e.g. serial communication or a socket
-	 * call.
-	 * @param data
-	 * @param dataLen
-	 * @return
-	 */
-	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0;
-
-	/**
-	 * Store data to be sent later if communication link is not up.
-	 * @param message
-	 * @return
-	 */
-	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
-
-
-	/**
-	 * Print data as hexidecimal array
-	 * @param data
-	 * @param dataLen
-	 */
-	void printData(uint8_t * data, size_t dataLen);
-
-	/**
-	 * This fifo can be used to store downlink data
-	 * which can not be sent at the moment.
-	 */
-	DynamicFIFO<store_address_t>* tmFifo = nullptr;
-    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
-    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
-};
-
-
-#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+
+
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../ipc/MessageQueueIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../container/DynamicFIFO.h"
+#include "../tmtcservices/TmTcMessage.h"
+
+class TmTcBridge : public AcceptsTelemetryIF,
+		public AcceptsTelecommandsIF,
+		public ExecutableObjectIF,
+		public HasReturnvaluesIF,
+		public SystemObject {
+public:
+	static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
+	static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
+	static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20;
+
+	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
+	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
+
+	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId);
+	virtual ~TmTcBridge();
+
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 * 		   -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle);
+
+	/**
+	 * Set number of packets sent per performOperation().Please note that this
+	 * value must be smaller than MAX_DOWNLINK_PACKETS_STORED
+	 * @param sentPacketsPerCycle
+	 * @return -@c RETURN_OK if value was set successfully
+	 *         -@c RETURN_FAILED otherwise, stored value stays the same
+	 */
+	ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored);
+
+	/**
+	 * This will set up the bridge to overwrite old data in the FIFO.
+	 * @param overwriteOld
+	 */
+	void setFifoToOverwriteOldData(bool overwriteOld);
+
+	virtual void registerCommConnect();
+	virtual void registerCommDisconnect();
+
+	/**
+	 * Initializes necessary FSFW components for the TMTC Bridge
+	 * @return
+	 */
+	virtual ReturnValue_t initialize() override;
+
+	/**
+	 * @brief	Handles TMTC reception
+	 */
+	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+
+	/** AcceptsTelemetryIF override */
+	virtual MessageQueueId_t getReportReceptionQueue(
+			uint8_t virtualChannel = 0) override;
+
+	/** AcceptsTelecommandsIF override */
+	virtual uint16_t getIdentifier() override;
+	virtual MessageQueueId_t getRequestQueue() override;
+
+protected:
+	//! Cached for initialize function.
+	object_id_t tmStoreId = objects::NO_OBJECT;
+	object_id_t tcStoreId = objects::NO_OBJECT;
+	object_id_t tcDestination = objects::NO_OBJECT;
+
+	//! Used to send and receive TMTC messages.
+	//! The TmTcMessage class is used to transport messages between tasks.
+	MessageQueueIF* tmTcReceptionQueue = nullptr;
+
+	StorageManagerIF* tmStore = nullptr;
+	StorageManagerIF* tcStore = nullptr;
+
+	//! Used to specify whether communication link is up. Will be true
+	//! by default, so telemetry will be handled immediately.
+	bool communicationLinkUp = true;
+	bool tmStored = false;
+	bool overwriteOld = true;
+	uint8_t packetSentCounter = 0;
+
+	/**
+	 * @brief 	Handle TC reception
+	 * @details
+	 * Default implementation provided, but is empty.
+	 * In most cases, TC reception will be handled in a separate task anyway.
+	 * @return
+	 */
+	virtual ReturnValue_t handleTc();
+
+	/**
+	 * Handle Telemetry. Default implementation provided.
+	 * Calls sendTm()
+	 * @return
+	 */
+	virtual ReturnValue_t handleTm();
+
+	/**
+	 * Read the TM Queue and send TM if necessary.
+	 * Default implementation provided
+	 * @return
+	 */
+	virtual ReturnValue_t handleTmQueue();
+
+	/**
+	 * Send stored data if communication link is active
+	 * @return
+	 */
+	virtual ReturnValue_t handleStoredTm();
+
+	/**
+	 * Implemented by child class. Perform sending of Telemetry by implementing
+	 * communication drivers or wrappers, e.g. serial communication or a socket
+	 * call.
+	 * @param data
+	 * @param dataLen
+	 * @return
+	 */
+	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0;
+
+	/**
+	 * Store data to be sent later if communication link is not up.
+	 * @param message
+	 * @return
+	 */
+	virtual ReturnValue_t storeDownlinkData(TmTcMessage * message);
+
+
+	/**
+	 * Print data as hexidecimal array
+	 * @param data
+	 * @param dataLen
+	 */
+	void printData(uint8_t * data, size_t dataLen);
+
+	/**
+	 * This fifo can be used to store downlink data
+	 * which can not be sent at the moment.
+	 */
+	DynamicFIFO<store_address_t>* tmFifo = nullptr;
+    uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE;
+    uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED;
+};
+
+
+#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index 0fe3229c..a715225b 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,29 +1,29 @@
-#include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
-
-
-TmTcMessage::TmTcMessage() {
-	this->messageSize += sizeof(store_address_t);
-}
-
-TmTcMessage::~TmTcMessage() {
-}
-
-store_address_t TmTcMessage::getStorageId() {
-	store_address_t temp_id;
-	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
-	return temp_id;
-}
-
-TmTcMessage::TmTcMessage(store_address_t store_id) {
-	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
-}
-
-size_t TmTcMessage::getMinimumMessageSize() {
-	return this->HEADER_SIZE + sizeof(store_address_t);
-}
-
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
-}
+#include "../tmtcservices/TmTcMessage.h"
+#include <string.h>
+
+
+TmTcMessage::TmTcMessage() {
+	this->messageSize += sizeof(store_address_t);
+}
+
+TmTcMessage::~TmTcMessage() {
+}
+
+store_address_t TmTcMessage::getStorageId() {
+	store_address_t temp_id;
+	memcpy(&temp_id, this->getData(), sizeof(store_address_t) );
+	return temp_id;
+}
+
+TmTcMessage::TmTcMessage(store_address_t store_id) {
+	this->messageSize += sizeof(store_address_t);
+	this->setStorageId(store_id);
+}
+
+size_t TmTcMessage::getMinimumMessageSize() {
+	return this->HEADER_SIZE + sizeof(store_address_t);
+}
+
+void TmTcMessage::setStorageId(store_address_t store_id) {
+	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+}
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index ad97c056..b5e1ff8d 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,50 +1,50 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-/**
- * @brief	This message class is used to pass Telecommand and Telemetry
- * 			packets between tasks.
- * @details	Within such a packet, nothing is transported but the identifier of
- * 			a packet stored in one of the IPC stores (typically a special TM and
- * 			a special TC store). This makes passing commands very simple and
- * 			efficient.
- *	\ingroup message_queue
- */
-class TmTcMessage : public MessageQueueMessage {
-protected:
-	/**
-	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
-	 */
-	size_t getMinimumMessageSize();
-public:
-	/**
-	 * @brief	In the default constructor, only the message_size is set.
-	 */
-	TmTcMessage();
-	/**
-	 * @brief	With this constructor, the passed packet id is directly put
-	 * 			into the message.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	TmTcMessage( store_address_t packet_id );
-	/**
-	 * @brief	The class's destructor is empty.
-	 */
-	~TmTcMessage();
-	/**
-	 * @brief	This getter returns the packet id in the correct format.
-	 * @return	Returns the packet id.
-	 */
-	store_address_t getStorageId();
-	/**
-	 * @brief	In some cases it might be useful to have a setter for packet id
-	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
-	 */
-	void setStorageId( store_address_t packet_id );
-};
-
-#endif /* TMTCMESSAGE_H_ */
+#ifndef TMTCMESSAGE_H_
+#define TMTCMESSAGE_H_
+
+#include "../ipc/MessageQueueMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+/**
+ * @brief	This message class is used to pass Telecommand and Telemetry
+ * 			packets between tasks.
+ * @details	Within such a packet, nothing is transported but the identifier of
+ * 			a packet stored in one of the IPC stores (typically a special TM and
+ * 			a special TC store). This makes passing commands very simple and
+ * 			efficient.
+ *	\ingroup message_queue
+ */
+class TmTcMessage : public MessageQueueMessage {
+protected:
+	/**
+	 * @brief	This call always returns the same fixed size of the message.
+	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 */
+	size_t getMinimumMessageSize();
+public:
+	/**
+	 * @brief	In the default constructor, only the message_size is set.
+	 */
+	TmTcMessage();
+	/**
+	 * @brief	With this constructor, the passed packet id is directly put
+	 * 			into the message.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	TmTcMessage( store_address_t packet_id );
+	/**
+	 * @brief	The class's destructor is empty.
+	 */
+	~TmTcMessage();
+	/**
+	 * @brief	This getter returns the packet id in the correct format.
+	 * @return	Returns the packet id.
+	 */
+	store_address_t getStorageId();
+	/**
+	 * @brief	In some cases it might be useful to have a setter for packet id
+	 * 			as well.
+	 * @param packet_id	The packet id to put into the message.
+	 */
+	void setStorageId( store_address_t packet_id );
+};
+
+#endif /* TMTCMESSAGE_H_ */
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index e9a43855..4f9f4e54 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,105 +1,105 @@
-#include "../tmtcservices/VerificationReporter.h"
-
-#include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../objectmanager/frameworkObjects.h"
-
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
-
-VerificationReporter::VerificationReporter() :
-		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
-}
-
-VerificationReporter::~VerificationReporter() {}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		TcPacketBase* current_packet, uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		uint8_t set_step) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
-		this->initialize();
-	}
-	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
-			tcSequenceControl, 0, set_step);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-			&message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
-		uint32_t parameter1, uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id,
-			current_packet->getAcknowledgeFlags(),
-			current_packet->getPacketId(),
-			current_packet->getPacketSequenceControl(), error_code, step,
-			parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::sendFailureReport(uint8_t report_id,
-		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
-		uint32_t parameter2) {
-	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
-		this->initialize();
-	}
-	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
-			tcSequenceControl, error_code, step, parameter1, parameter2);
-	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
-	        &message);
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
-				<< std::endl;
-	}
-}
-
-void VerificationReporter::initialize() {
-	if(messageReceiver == objects::NO_OBJECT) {
-		sif::warning << "VerificationReporter::initialize: Verification message"
-				" receiver object ID not set yet in Factory!" << std::endl;
-		return;
-	}
-	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
-			messageReceiver);
-	if (temp == nullptr) {
-		sif::error << "VerificationReporter::initialize: Message "
-				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
-	}
-	this->acknowledgeQueue = temp->getVerificationQueue();
-}
+#include "../tmtcservices/VerificationReporter.h"
+
+#include "../ipc/MessageQueueIF.h"
+#include "../tmtcservices/AcceptsVerifyMessageIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/frameworkObjects.h"
+
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+
+VerificationReporter::VerificationReporter() :
+		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
+}
+
+VerificationReporter::~VerificationReporter() {}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		TcPacketBase* current_packet, uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		uint8_t set_step) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE)  {
+		this->initialize();
+	}
+	PusVerificationMessage message(set_report_id, ackFlags, tcPacketId,
+			tcSequenceControl, 0, set_step);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+			&message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		TcPacketBase* current_packet, ReturnValue_t error_code, uint8_t step,
+		uint32_t parameter1, uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id,
+			current_packet->getAcknowledgeFlags(),
+			current_packet->getPacketId(),
+			current_packet->getPacketSequenceControl(), error_code, step,
+			parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::sendFailureReport(uint8_t report_id,
+		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+		ReturnValue_t error_code, uint8_t step, uint32_t parameter1,
+		uint32_t parameter2) {
+	if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+		this->initialize();
+	}
+	PusVerificationMessage message(report_id, ackFlags, tcPacketId,
+			tcSequenceControl, error_code, step, parameter1, parameter2);
+	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
+	        &message);
+	if (status != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "VerificationReporter::sendFailureReport Error writing "
+				<< "to queue. Code: " << std::hex << status << std::dec
+				<< std::endl;
+	}
+}
+
+void VerificationReporter::initialize() {
+	if(messageReceiver == objects::NO_OBJECT) {
+		sif::warning << "VerificationReporter::initialize: Verification message"
+				" receiver object ID not set yet in Factory!" << std::endl;
+		return;
+	}
+	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
+			messageReceiver);
+	if (temp == nullptr) {
+		sif::error << "VerificationReporter::initialize: Message "
+				<< "receiver invalid. Make sure it is set up properly and "
+				<<"implementsAcceptsVerifyMessageIF" << std::endl;
+
+	}
+	this->acknowledgeQueue = temp->getVerificationQueue();
+}
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 86aea826..4d92f6b3 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,50 +1,50 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief 	This helper object is used to forward verification messages
- * 			which are generated by the Flight Software Framework.
- * @details
- * The messages can be relayed to an arbitrary object, for example a dedicated
- * Verification Reporter. The destination is set by setting the static framework
- * Id VerificationReporter::messageReceiver. The default verification reporter
- * will be the PUS service 1, which sends verification messages according
- * to the PUS standard.
- *
- */
-class VerificationReporter {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-	VerificationReporter();
-	virtual ~VerificationReporter();
-
-	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
-			uint8_t set_step = 0 );
-	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
-			uint16_t tcPacketId, uint16_t tcSequenceControl,
-			uint8_t set_step = 0);
-
-	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
-			ReturnValue_t error_code = 0,
-			uint8_t step = 0, uint32_t parameter1 = 0,
-			uint32_t parameter2 = 0 );
-	void sendFailureReport(uint8_t report_id,
-			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
-			ReturnValue_t error_code = 0, uint8_t step = 0,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
-
-	void initialize();
-
-private:
-	static object_id_t messageReceiver;
-	MessageQueueId_t acknowledgeQueue;
-};
-
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+namespace Factory{
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief 	This helper object is used to forward verification messages
+ * 			which are generated by the Flight Software Framework.
+ * @details
+ * The messages can be relayed to an arbitrary object, for example a dedicated
+ * Verification Reporter. The destination is set by setting the static framework
+ * Id VerificationReporter::messageReceiver. The default verification reporter
+ * will be the PUS service 1, which sends verification messages according
+ * to the PUS standard.
+ *
+ */
+class VerificationReporter {
+	friend void (Factory::setStaticFrameworkObjectIds)();
+public:
+	VerificationReporter();
+	virtual ~VerificationReporter();
+
+	void sendSuccessReport( uint8_t set_report_id, TcPacketBase* current_packet,
+			uint8_t set_step = 0 );
+	void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags,
+			uint16_t tcPacketId, uint16_t tcSequenceControl,
+			uint8_t set_step = 0);
+
+	void sendFailureReport( uint8_t report_id, TcPacketBase* current_packet,
+			ReturnValue_t error_code = 0,
+			uint8_t step = 0, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0 );
+	void sendFailureReport(uint8_t report_id,
+			uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
+			ReturnValue_t error_code = 0, uint8_t step = 0,
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+
+	void initialize();
+
+private:
+	static object_id_t messageReceiver;
+	MessageQueueId_t acknowledgeQueue;
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From b6a19f911d177e4129dfc0a5a10e0e499aa1ba88 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:45:19 +0200
Subject: [PATCH 0683/1292] include guards improved

---
 parameters/HasParametersIF.h             |  6 +++---
 parameters/ParameterHelper.cpp           |  4 ++--
 parameters/ParameterHelper.h             | 10 +++++-----
 parameters/ParameterMessage.h            |  8 ++++----
 parameters/ParameterWrapper.cpp          |  2 +-
 parameters/ParameterWrapper.h            |  8 ++++----
 parameters/ReceivesParameterMessagesIF.h |  8 ++++----
 7 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 0c6afc12..005403fa 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,5 +1,5 @@
-#ifndef HASPARAMETERSIF_H_
-#define HASPARAMETERSIF_H_
+#ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
+#define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
 #include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -64,4 +64,4 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
-#endif /* HASPARAMETERSIF_H_ */
+#endif /* FSFW_PARAMETERS_HASPARAMETERSIF_H_ */
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index ec7ded3c..659b00de 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -1,6 +1,6 @@
+#include "ParameterHelper.h"
+#include "ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../parameters/ParameterHelper.h"
-#include "../parameters/ParameterMessage.h"
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
 		owner(owner) {}
diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 5dd78b64..6b06ffdc 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
+#ifndef FSFW_PARAMETERS_PARAMETERHELPER_H_
+#define FSFW_PARAMETERS_PARAMETERHELPER_H_
 
+#include "ParameterMessage.h"
+#include "ReceivesParameterMessagesIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../parameters/ParameterMessage.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
 
 /**
  * @brief	Helper class to handle parameter messages
@@ -33,4 +33,4 @@ private:
 			Command_t initialCommand);
 };
 
-#endif /* PARAMETERHELPER_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERHELPER_H_ */
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index de68dcfc..31d7fe0b 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -1,8 +1,8 @@
-#ifndef PARAMETERMESSAGE_H_
-#define PARAMETERMESSAGE_H_
+#ifndef FSFW_PARAMETERS_PARAMETERMESSAGE_H_
+#define FSFW_PARAMETERS_PARAMETERMESSAGE_H_
 
+#include "HasParametersIF.h"
 #include "../ipc/CommandMessage.h"
-#include "../parameters/HasParametersIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 class ParameterMessage {
@@ -26,4 +26,4 @@ public:
 
 };
 
-#endif /* PARAMETERMESSAGE_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERMESSAGE_H_ */
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index fd36a0a9..d020da33 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -1,4 +1,4 @@
-#include "../parameters/ParameterWrapper.h"
+#include "ParameterWrapper.h"
 
 ParameterWrapper::ParameterWrapper() :
 		pointsToStream(false), type(Type::UNKNOWN_TYPE) {
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 35045959..f07205d4 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -1,11 +1,11 @@
-#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
-#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
+#ifndef FSFW_PARAMETERS_PARAMETERWRAPPER_H_
+#define FSFW_PARAMETERS_PARAMETERWRAPPER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serialize/SerializeIF.h"
-#include <stddef.h>
 #include "../globalfunctions/Type.h"
+#include <cstddef>
 
 /**
  * @brief
@@ -159,4 +159,4 @@ inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
 	}
 }
 
-#endif /* PARAMETERWRAPPER_H_ */
+#endif /* FSFW_PARAMETERS_PARAMETERWRAPPER_H_ */
diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h
index f8c3746e..e8c7fa69 100644
--- a/parameters/ReceivesParameterMessagesIF.h
+++ b/parameters/ReceivesParameterMessagesIF.h
@@ -1,8 +1,8 @@
-#ifndef RECEIVESPARAMETERMESSAGESIF_H_
-#define RECEIVESPARAMETERMESSAGESIF_H_
+#ifndef FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
+#define FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_
 
 
-#include "../parameters/HasParametersIF.h"
+#include "HasParametersIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
 class ReceivesParameterMessagesIF : public HasParametersIF {
@@ -16,4 +16,4 @@ public:
 };
 
 
-#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
+#endif /* FSFW_PARAMETERS_RECEIVESPARAMETERMESSAGESIF_H_ */

From b0673c7fa6e7f66d9c76a5f66c3d209579a759f1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 28 Aug 2020 18:47:11 +0200
Subject: [PATCH 0684/1292] typo fixes

---
 parameters/ParameterHelper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h
index 6b06ffdc..595b4bc5 100644
--- a/parameters/ParameterHelper.h
+++ b/parameters/ParameterHelper.h
@@ -6,9 +6,9 @@
 #include "../ipc/MessageQueueIF.h"
 
 /**
- * @brief	Helper class to handle parameter messages
+ * @brief	Helper class to handle parameter messages.
  * @details
- * This class simplfiies handling of parameter messages, which are sent
+ * This class simplfies handling of parameter messages, which are sent
  * to a class which implements ReceivesParameterMessagesIF.
  */
 class ParameterHelper {

From 6c02776975fbebb9a49302825943c0244c3ebc55 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 29 Aug 2020 00:16:40 +0200
Subject: [PATCH 0685/1292] added srv9

---
 pus/Service9TimeManagement.cpp       | 58 ++++++++++++++++++++++++++++
 pus/Service9TimeManagement.h         | 42 ++++++++++++++++++++
 pus/servicepackets/Service9Packets.h | 32 +++++++++++++++
 returnvalues/FwClassIds.h            |  1 +
 4 files changed, 133 insertions(+)
 create mode 100644 pus/Service9TimeManagement.cpp
 create mode 100644 pus/Service9TimeManagement.h
 create mode 100644 pus/servicepackets/Service9Packets.h

diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
new file mode 100644
index 00000000..5625bdd8
--- /dev/null
+++ b/pus/Service9TimeManagement.cpp
@@ -0,0 +1,58 @@
+#include "Service9TimeManagement.h"
+#include "servicepackets/Service9Packets.h"
+
+#include "../timemanager/CCSDSTime.h"
+#include "../events/EventManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service9TimeManagement::Service9TimeManagement(object_id_t objectId,
+		uint16_t apid, uint8_t serviceId) :
+	PusServiceBase(objectId, apid , serviceId) {
+}
+
+Service9TimeManagement::~Service9TimeManagement() {}
+
+ReturnValue_t Service9TimeManagement::performService() {
+	return RETURN_OK;
+}
+
+ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
+	switch(subservice){
+		case SUBSERVICE::SET_TIME:{
+			return setTime();
+		}
+		default:
+			return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+		}
+}
+
+ReturnValue_t Service9TimeManagement::setTime() {
+	Clock::TimeOfDay_t timeToSet;
+	TimePacket timePacket(currentPacket.getApplicationData(),
+			currentPacket.getApplicationDataSize());
+	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
+			timePacket.getTime(), timePacket.getTimeSize());
+	if(result != RETURN_OK) {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return result;
+	}
+
+	uint32_t formerUptime;
+	Clock::getUptime(&formerUptime);
+	result = Clock::setClock(&timeToSet);
+
+	if(result == RETURN_OK) {
+		uint32_t newUptime;
+		Clock::getUptime(&newUptime);
+		triggerEvent(CLOCK_SET,newUptime,formerUptime);
+		return RETURN_OK;
+	}
+	else {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return RETURN_FAILED;
+	}
+}
+
+
+
diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
new file mode 100644
index 00000000..4ad6be6e
--- /dev/null
+++ b/pus/Service9TimeManagement.h
@@ -0,0 +1,42 @@
+#ifndef FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+#define FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+class Service9TimeManagement: public PusServiceBase {
+public:
+
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+
+	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
+
+	/**
+	 * 	@brief This service provides the capability to set the on-board time.
+	 */
+	Service9TimeManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId);
+
+	virtual ~Service9TimeManagement();
+
+	virtual ReturnValue_t performService() override;
+
+	/**
+	 * 	@brief Sets the onboard-time by retrieving the time to set from TC[9,128].
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	virtual ReturnValue_t setTime();
+private:
+
+	enum SUBSERVICE {
+		SET_TIME = 128 //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+	};
+
+	void setIsisClock(Clock::TimeOfDay_t& timeOfDay);
+};
+
+
+
+#endif /* FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service9Packets.h b/pus/servicepackets/Service9Packets.h
new file mode 100644
index 00000000..11bd2600
--- /dev/null
+++ b/pus/servicepackets/Service9Packets.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+
+/**
+ * @brief Subservice 128
+ * @details
+ * It only contains the time encoded as ASCII, CRC, CUC or CDS
+ * @ingroup spacepackets
+ */
+class TimePacket : SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	TimePacket(const uint8_t * timeBuffer_, uint32_t timeSize_) {
+		timeBuffer = timeBuffer_;
+		timeSize = timeSize_;
+	}
+	const uint8_t*  getTime() {
+		return timeBuffer;
+	}
+
+	uint32_t getTimeSize() const {
+		return timeSize;
+	}
+
+private:
+	TimePacket(const TimePacket &command);
+	const uint8_t * timeBuffer;
+	uint32_t timeSize; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_ */
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index ebd1847d..12877b40 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -67,6 +67,7 @@ enum {
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
 	SERIAL_ANALYZER, //SERA 63
+	PUS_SERVICE_9,
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 15bb0aee985cc5b558cea21e635b1600db5905f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 29 Aug 2020 19:08:10 +0200
Subject: [PATCH 0686/1292] handler ID cached, debug output improved

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 13 +++++++++----
 tasks/FixedSequenceSlot.cpp         |  2 +-
 tasks/FixedSequenceSlot.h           |  2 ++
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 404c3c05..309574eb 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -147,13 +147,18 @@ void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
 }
 
 void FixedTimeslotTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
+
+#ifdef DEBUG
+    object_id_t handlerId = pst.current->handlerId;
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) << " with"
+            << " object ID 0x" << std::setfill('0') << std::setw(8) << std::hex
+            << handlerId <<  " missed deadline!" << std::setfill(' ')
+            << std::dec << std::endl;
+#endif
+
 }
 
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index a38734a2..d7aeff0a 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -4,7 +4,7 @@
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
 		int8_t setSequenceId, ExecutableObjectIF* executableObject,
-		PeriodicTaskIF* executingTask) :
+		PeriodicTaskIF* executingTask) : handlerId(handlerId),
 		pollingTimeMs(setTime), opcode(setSequenceId) {
     if(executableObject == nullptr) {
         return;
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 6ec9ae13..151173e9 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -20,6 +20,8 @@ public:
 			PeriodicTaskIF* executingTask);
 	virtual ~FixedSequenceSlot();
 
+	object_id_t handlerId;
+
 	/**
 	 * @brief	Handler identifies which object is executed in this slot.
 	 */

From edde2ee58b54270aa832193312ecd289940fe0d2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:43:50 +0200
Subject: [PATCH 0687/1292] offsetr update

---
 parameters/ParameterWrapper.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index d020da33..6adc6857 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -270,7 +270,8 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		//need a type to do arithmetic
 		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
+			size_t offset = (((startingRow + fromRow) * columns) +
+					startingColumn) * typeSize;
 			std::memcpy(typedData +  offset, from->readonlyData,
 					typeSize * from->columns);
 		}

From f7f134ac20ca6bb76fedd14804290fc06455c44a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:48:11 +0200
Subject: [PATCH 0688/1292] corrections

---
 container/FIFOBase.tpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index c73e9d59..e1287dcf 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -1,7 +1,7 @@
-#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
 

From 7cf79c17a9e54de41fd9a10e630ad07fd967829f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:48:51 +0200
Subject: [PATCH 0689/1292] fifo update

---
 container/FIFO.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/container/FIFO.h b/container/FIFO.h
index 4688a7b0..e60a4979 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,8 +1,7 @@
 #ifndef FRAMEWORK_CONTAINER_FIFO_H_
 #define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../container/FIFOBase.h"
+#include "FIFOBase.h"
 #include <array>
 
 /**

From a634875b4b08cde12d2c2ea14d50303ab13d573d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:50:17 +0200
Subject: [PATCH 0690/1292] dynamic fifo update

---
 container/DynamicFIFO.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 9af98f96..7fa0c32c 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
-#define FRAMEWORK_CONTAINER_DYNAMICFIFO_H_
+#ifndef FSFW_CONTAINER_DYNAMICFIFO_H_
+#define FSFW_CONTAINER_DYNAMICFIFO_H_
 
-#include "../container/FIFOBase.h"
+#include "FIFOBase.h"
 #include <vector>
 
 /**
@@ -39,4 +39,4 @@ private:
 	std::vector<T> fifoVector;
 };
 
-#endif /* FRAMEWORK_CONTAINER_DYNAMICFIFO_H_ */
+#endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */

From bec562ece0ae8cc5f7c81d7e998f47ebfaaa083b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:54:33 +0200
Subject: [PATCH 0691/1292] FIFO updates

---
 container/DynamicFIFO.h |  4 ++--
 container/FIFO.h        | 12 +++++++-----
 container/FIFOBase.h    | 10 +++++-----
 container/FIFOBase.tpp  |  2 +-
 4 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 7fa0c32c..abb53330 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -22,7 +22,7 @@ public:
 		// 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());
+		this->setContainer(fifoVector.data());
 	};
 
 	/**
@@ -31,7 +31,7 @@ public:
 	 */
 	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
 			fifoVector(other.maxCapacity) {
-		this->setData(fifoVector.data());
+		this->setContainer(fifoVector.data());
 	}
 
 
diff --git a/container/FIFO.h b/container/FIFO.h
index e60a4979..19f763fc 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FRAMEWORK_CONTAINER_FIFO_H_
+#ifndef FSFW_CONTAINER_FIFO_H_
+#define FSFW_CONTAINER_FIFO_H_
 
 #include "FIFOBase.h"
 #include <array>
@@ -16,18 +16,20 @@
 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());
+		this->setContainer(fifoArray.data());
 	}
 
 private:
 	std::array<T, capacity> fifoArray;
 };
 
-#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */
+#endif /* FSFW_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index 410e52a5..b744706d 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
-#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+#ifndef FSFW_CONTAINER_FIFOBASE_H_
+#define FSFW_CONTAINER_FIFOBASE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
@@ -48,7 +48,7 @@ public:
 	size_t getMaxCapacity() const;
 
 protected:
-	void setData(T* data);
+	void setContainer(T* data);
 	size_t maxCapacity = 0;
 
 	T* values;
@@ -60,6 +60,6 @@ protected:
 	size_t next(size_t current);
 };
 
-#include "../container/FIFOBase.tpp"
+#include "FIFOBase.tpp"
 
-#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */
+#endif /* FSFW_CONTAINER_FIFOBASE_H_ */
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index e1287dcf..d54b3f8f 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -80,7 +80,7 @@ inline size_t FIFOBase<T>::getMaxCapacity() const {
 
 
 template<typename T>
-inline void FIFOBase<T>::setData(T *data) {
+inline void FIFOBase<T>::setContainer(T *data) {
 	this->values = data;
 }
 

From 33039f8c6055b45cb75b39a4e86a8a38430222a9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Sep 2020 12:57:56 +0200
Subject: [PATCH 0692/1292] include  guard correction

---
 tmtcservices/CommandingServiceBase.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 4a180445..29ab967a 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#ifndef FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
+#define FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -345,4 +345,4 @@ private:
 	void checkTimeout();
 };
 
-#endif /* COMMANDINGSERVICEBASE_H_ */
+#endif /* FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ */

From ae9bc39bdaadb7323dfe009b5e93276e620e6d76 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 17:59:26 +0200
Subject: [PATCH 0693/1292] some bugfixes and improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 13 ++++++++-----
 devicehandlers/DeviceHandlerBase.h   |  2 ++
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0253d6a7..820a2cce 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -678,7 +678,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xFFFFFFFF;
+	DeviceCommandId_t foundId = 0xffffffff;
 	size_t foundLen = 0;
 	// The loop may not execute more often than the number of received bytes
 	// (worst case). This approach avoids infinite loops due to buggy
@@ -709,7 +709,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			break;
 		}
 		case IGNORE_REPLY_DATA:
-			break;
+			continue;
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
@@ -741,16 +741,19 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
 	DeviceReplyInfo *info = &(iter->second);
 
 	if (info->delayCycles != 0) {
+	    result = interpretDeviceReply(foundId, receivedData);
 
-		if (info->periodic != false) {
+	    if(result == IGNORE_REPLY_DATA) {
+	        return;
+	    }
+
+		if (info->periodic) {
 			info->delayCycles = info->maxDelayCycles;
 		}
 		else {
 			info->delayCycles = 0;
 		}
 
-		result = interpretDeviceReply(foundId, receivedData);
-
 		if (result != RETURN_OK) {
 			// Report failed interpretation to FDIR.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5357148e..abab7875 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -323,6 +323,8 @@ protected:
 	 * @param packet
 	 * @return
 	 *     - @c RETURN_OK when the reply was interpreted.
+	 *     - @c IGNORE_REPLY_DATA Ignore the reply and don't reset reply cycle
+	 *          counter.
 	 *     - @c RETURN_FAILED when the reply could not be interpreted,
 	 *     e.g. logical errors or range violations occurred
 	 */

From 6069c64048b2850f7cb080cac2d0f836c4543be0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 23:36:54 +0200
Subject: [PATCH 0694/1292] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 63 ++++++++++++------------------
 1 file changed, 25 insertions(+), 38 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index abab7875..5f76f7e4 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -39,9 +39,10 @@ class StorageManagerIF;
  * Documentation: Dissertation Baetz p.138,139, p.141-149
  *
  * It features handling of @link DeviceHandlerIF::Mode_t Modes @endlink,
- * communication with physical devices, using the @link DeviceCommunicationIF @endlink,
- * and communication with commanding objects.
- * It inherits SystemObject and thus can be created by the ObjectManagerIF.
+ * communication with physical devices, using the
+ * @link DeviceCommunicationIF @endlink, and communication with commanding
+ * objects. It inherits SystemObject and thus can be created by the
+ * ObjectManagerIF.
  *
  * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
  * For each step an RMAP action is selected and executed.
@@ -49,7 +50,7 @@ class StorageManagerIF;
  * The action for each step can be defined by the child class but as most
  * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
  * a default implementation is provided.
- * NOTE: RMAP is a standard which is used for FLP.
+ * NOTE: RMAP is a standard which is used for Flying Laptop.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are
  * two write and two send calls involved.
@@ -70,9 +71,6 @@ class StorageManagerIF;
  *
  * Other important virtual methods with a default implementation
  * are the getTransitionDelayMs() function and the getSwitches() function.
- * Please ensure that getSwitches() returns DeviceHandlerIF::NO_SWITCHES if
- * power switches are not implemented yet. Otherwise, the device handler will
- * not transition to MODE_ON, even if setMode(MODE_ON) is called.
  * If a transition to MODE_ON is desired without commanding, override the
  * intialize() function and call setMode(_MODE_START_UP) before calling
  * DeviceHandlerBase::initialize().
@@ -94,13 +92,10 @@ public:
 	 * The constructor passes the objectId to the SystemObject().
 	 *
 	 * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-	 * @param maxDeviceReplyLen the length the RMAP getRead call will be sent with
-	 * @param setDeviceSwitch the switch the device is connected to,
-	 * for devices using two switches, overwrite getSwitches()
 	 * @param deviceCommuncation Communcation Interface object which is used
 	 * to implement communication functions
-	 * @param thermalStatePoolId
-	 * @param thermalRequestPoolId
+	 * @param comCookie This object will be passed to the communication inter-
+	 * face and can contain user-defined information about the communication.
 	 * @param fdirInstance
 	 * @param cmdQueueSize
 	 */
@@ -352,22 +347,10 @@ protected:
 	 *    set to the maximum expected number of PST cycles between two replies
 	 *    (also a tolerance should be added, as an FDIR message will be
 	 *    generated if it is missed).
-	 *
-	 *    (Robin) This part confuses me. "must do as soon as" implies that
-	 *    the developer must do something somewhere else in the code. Is
-	 *    that really the case? If I understood correctly, DHB performs
-	 *    almost everything (e.g. in erirm function) as long as the commands
-	 *    are inserted correctly.
-	 *
-	 *    As soon as the replies are enabled, DeviceCommandInfo.periodic must
-	 *    be set to true, DeviceCommandInfo.delayCycles to
-	 *    DeviceCommandInfo.maxDelayCycles.
 	 *    From then on, the base class handles the reception.
 	 *    Then, scanForReply returns the id of the reply or the placeholder id
 	 *    and the base class will take care of checking that all replies are
 	 *    received and the interval is correct.
-	 *    When the replies are disabled, DeviceCommandInfo.periodic must be set
-	 *    to 0, DeviceCommandInfo.delayCycles to 0;
 	 *
 	 *  - Aperiodic, unrequested replies. These are replies that are sent
 	 *    by the device without any preceding command and not in a defined
@@ -705,14 +688,18 @@ protected:
 	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
 
 	/**
-	 * Optional Error code
-	 * Can be set in doStartUp(), doShutDown() and doTransition() to signal cause for Transition failure.
+	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
+	 * doTransition() to signal cause for Transition failure.
 	 */
 	ReturnValue_t childTransitionFailure;
 
-	uint32_t ignoreMissedRepliesCount = 0; //!< Counts if communication channel lost a reply, so some missed replys can be ignored.
+	/** Counts if communication channel lost a reply, so some missed
+	 * replys can be ignored. */
+	uint32_t ignoreMissedRepliesCount = 0;
 
-	FailureIsolationBase* fdirInstance; //!< Pointer to the used FDIR instance. If not provided by child, default class is instantiated.
+	/** Pointer to the used FDIR instance. If not provided by child,
+	 * default class is instantiated. */
+	FailureIsolationBase* fdirInstance;
 
 	HkSwitchHelper hkSwitcher;
 
@@ -1099,11 +1086,6 @@ private:
 	void buildRawDeviceCommand(CommandMessage* message);
 	void buildInternalCommand(void);
 
-//	/**
-//	 * Send a reply with the current mode and submode.
-//	 */
-//	void announceMode(void);
-
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
@@ -1130,10 +1112,14 @@ private:
 	/**
 	 * Build and send a command to the device.
 	 *
-	 * This routine checks whether a raw or direct command has been received, checks the content of the received command and
-	 * calls buildCommandFromCommand() for direct commands or sets #rawpacket to the received raw packet.
-	 * If no external command is received or the received command is invalid and the current mode is @c MODE_NORMAL or a transitional mode,
-	 * it asks the child class to build a command (via getNormalDeviceCommand() or getTransitionalDeviceCommand() and buildCommand()) and
+	 * This routine checks whether a raw or direct command has been received,
+	 * checks the content of the received command and calls
+	 * buildCommandFromCommand() for direct commands or sets #rawpacket
+	 * to the received raw packet.
+	 * If no external command is received or the received command is invalid and
+	 * the current mode is @c MODE_NORMAL or a transitional mode, it asks the
+	 * child class to build a command (via getNormalDeviceCommand() or
+	 * getTransitionalDeviceCommand() and buildCommand()) and
 	 * sends the command via RMAP.
 	 */
 	void doSendWrite(void);
@@ -1196,7 +1182,8 @@ private:
 	 * @param newChannel the object Id of the channel to switch to
 	 * @return
 	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed, eg because the newChannel is not enabled
+	 *     - @c RETURN_FAILED when cookies could not be changed,
+	 *          e.g. because the newChannel is not enabled
 	 *     - @c returnvalues of RMAPChannelIF::isActive()
 	 */
 	ReturnValue_t switchCookieChannel(object_id_t newChannelId);

From e8fa9816ceea383d1e15e55b6bbf84d1e6327702 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 2 Sep 2020 23:45:14 +0200
Subject: [PATCH 0695/1292] doc improved

---
 devicehandlers/DeviceHandlerBase.h | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 5f76f7e4..f809953e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -44,12 +44,10 @@ class StorageManagerIF;
  * objects. It inherits SystemObject and thus can be created by the
  * ObjectManagerIF.
  *
- * This class uses the opcode of ExecutableObjectIF to perform a step-wise execution.
- * For each step an RMAP action is selected and executed.
- * If data has been received (GET_READ), the data will be interpreted.
- * The action for each step can be defined by the child class but as most
- * device handlers share a 4-call (sendRead-getRead-sendWrite-getWrite) structure,
- * a default implementation is provided.
+ * This class uses the opcode of ExecutableObjectIF to perform a
+ * step-wise execution. For each step a different action is selected and
+ * executed. Currently, the device handler base performs a 4-step
+ * execution related to 4 communication steps (based on RMAP).
  * NOTE: RMAP is a standard which is used for Flying Laptop.
  * RMAP communication is not mandatory for projects implementing the FSFW.
  * However, the communication principles are similar to RMAP as there are

From 822a908353608f053590fecd9e0a3115c37cb6f9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 00:17:01 +0200
Subject: [PATCH 0696/1292] separated steps, everything seems to work

---
 devicehandlers/DeviceHandlerBase.cpp | 47 ++++++++++++----------------
 devicehandlers/DeviceHandlerBase.h   |  2 +-
 devicehandlers/DeviceHandlerIF.h     |  3 +-
 3 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 820a2cce..7cba6dba 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -72,8 +72,11 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
+	if (getComAction() == CommunicationAction::NOTHING) {
+	    return HasReturnvaluesIF::RETURN_OK;
+	}
 
-	if (getComAction() == SEND_WRITE) {
+	if (getComAction() == CommunicationAction::PERFORM_OPERATION) {
 		cookieInfo.state = COOKIE_UNUSED;
 		readCommandQueue();
 		doStateMachine();
@@ -88,21 +91,21 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		return RETURN_OK;
 	}
 	switch (getComAction()) {
-	case SEND_WRITE:
-		if ((cookieInfo.state == COOKIE_UNUSED)) {
+	case CommunicationAction::SEND_WRITE:
+		if (cookieInfo.state == COOKIE_UNUSED) {
+		    // if no external command was specified, build internal command.
 			buildInternalCommand();
 		}
 		doSendWrite();
 		break;
-	case GET_WRITE:
+	case CommunicationAction::GET_WRITE:
 		doGetWrite();
 		break;
-	case SEND_READ:
+	case CommunicationAction::SEND_READ:
 		doSendRead();
 		break;
-	case GET_READ:
+	case CommunicationAction::GET_READ:
 		doGetRead();
-		cookieInfo.state = COOKIE_UNUSED;
 		break;
 	default:
 		break;
@@ -821,24 +824,27 @@ void DeviceHandlerBase::replyRawData(const uint8_t *data, size_t len,
 }
 
 //Default child implementations
-DeviceHandlerIF::CommunicationAction_t DeviceHandlerBase::getComAction() {
+DeviceHandlerIF::CommunicationAction DeviceHandlerBase::getComAction() {
 	switch (pstStep) {
 	case 0:
-		return SEND_WRITE;
+		return CommunicationAction::PERFORM_OPERATION;
 		break;
 	case 1:
-		return GET_WRITE;
-		break;
+	    return CommunicationAction::SEND_WRITE;
+	    break;
 	case 2:
-		return SEND_READ;
+		return CommunicationAction::GET_WRITE;
 		break;
 	case 3:
-		return GET_READ;
+		return CommunicationAction::SEND_READ;
+		break;
+	case 4:
+		return CommunicationAction::GET_READ;
 		break;
 	default:
 		break;
 	}
-	return NOTHING;
+	return CommunicationAction::NOTHING;
 }
 
 MessageQueueId_t DeviceHandlerBase::getCommandQueue() const {
@@ -1129,19 +1135,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f809953e..e0e2b2d5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -819,7 +819,7 @@ protected:
 	 * @return The Rmap action to execute in this step
 	 */
 
-	virtual CommunicationAction_t getComAction();
+	virtual CommunicationAction getComAction();
 
 	/**
 	 * Build the device command to send for raw mode.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index e3fa3b88..fcf50128 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,8 @@ public:
 	 *
 	 * This is used by the child class to tell the base class what to do.
 	 */
-	enum CommunicationAction_t: uint8_t {
+	enum CommunicationAction: uint8_t {
+	    PERFORM_OPERATION,
 		SEND_WRITE,//!< Send write
 		GET_WRITE, //!< Get write
 		SEND_READ, //!< Send read

From dbb394f761a147aae4a2fb722cb7ffc264452079 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 00:22:16 +0200
Subject: [PATCH 0697/1292] new member to store last step

---
 devicehandlers/DeviceHandlerBase.cpp | 5 +++++
 devicehandlers/DeviceHandlerBase.h   | 1 +
 2 files changed, 6 insertions(+)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 7cba6dba..ffb94359 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -72,6 +72,8 @@ DeviceHandlerBase::~DeviceHandlerBase() {
 
 ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 	this->pstStep = counter;
+	this->lastStep = this->pstStep;
+
 	if (getComAction() == CommunicationAction::NOTHING) {
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -86,10 +88,13 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		hkSwitcher.performOperation();
 		hkManager.performHkOperation();
 		performOperationHook();
+		return RETURN_OK;
 	}
+
 	if (mode == MODE_OFF) {
 		return RETURN_OK;
 	}
+
 	switch (getComAction()) {
 	case CommunicationAction::SEND_WRITE:
 		if (cookieInfo.state == COOKIE_UNUSED) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index e0e2b2d5..8c4fb04e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -555,6 +555,7 @@ protected:
 
 	/** This is the counter value from performOperation(). */
 	uint8_t pstStep = 0;
+	uint8_t lastStep = 0;
 	uint32_t pstIntervalMs = 0;
 
 	/**

From 403d83f32cedcd6c655e95e25e4f421df9e94971 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 3 Sep 2020 13:01:14 +0200
Subject: [PATCH 0698/1292] removed commented out code

---
 devicehandlers/DeviceHandlerBase.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 820a2cce..45cf3781 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1129,19 +1129,6 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 		}
 		replyReturnvalueToCommand(RETURN_OK);
 		return RETURN_OK;
-//	case DeviceHandlerMessage::CMD_SWITCH_IOBOARD:
-//		if (mode != MODE_OFF) {
-//			replyReturnvalueToCommand(WRONG_MODE_FOR_COMMAND);
-//		} else {
-//			result = switchCookieChannel(
-//					DeviceHandlerMessage::getIoBoardObjectId(message));
-//			if (result == RETURN_OK) {
-//				replyReturnvalueToCommand(RETURN_OK);
-//			} else {
-//				replyReturnvalueToCommand(CANT_SWITCH_IO_ADDRESS);
-//			}
-//		}
-//		return RETURN_OK;
 	case DeviceHandlerMessage::CMD_RAW:
 		if ((mode != MODE_RAW)) {
 			DeviceHandlerMessage::clear(message);

From 31c16382fc5d40cccc9ca3a58a8a60cef5d7a04f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:28:43 +0200
Subject: [PATCH 0699/1292] took over changed for fixed slot sequence

---
 osal/FreeRTOS/FixedTimeslotTask.h |  8 +--
 tasks/FixedSequenceSlot.cpp       |  4 +-
 tasks/FixedSequenceSlot.h         |  9 ++--
 tasks/FixedSlotSequence.cpp       | 29 ++++++++---
 tasks/FixedSlotSequence.h         | 81 ++++++++++++++++++-------------
 5 files changed, 80 insertions(+), 51 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index c46de5b7..7d2cdb70 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
-#include "../../osal/FreeRTOS/FreeRTOSTaskIF.h"
+#include "FreeRTOSTaskIF.h"
 #include "../../tasks/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "../../tasks/Typedef.h"
@@ -98,4 +98,4 @@ protected:
 	void handleMissedDeadline();
 };
 
-#endif /* POLLINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ */
diff --git a/tasks/FixedSequenceSlot.cpp b/tasks/FixedSequenceSlot.cpp
index d7aeff0a..f5d82178 100644
--- a/tasks/FixedSequenceSlot.cpp
+++ b/tasks/FixedSequenceSlot.cpp
@@ -1,5 +1,5 @@
-#include "../objectmanager/SystemObjectIF.h"
-#include "../tasks/FixedSequenceSlot.h"
+#include "FixedSequenceSlot.h"
+#include "PeriodicTaskIF.h"
 #include <cstddef>
 
 FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime,
diff --git a/tasks/FixedSequenceSlot.h b/tasks/FixedSequenceSlot.h
index 151173e9..1744ec19 100644
--- a/tasks/FixedSequenceSlot.h
+++ b/tasks/FixedSequenceSlot.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
-#define FRAMEWORK_TASKS_FIXEDSEQUENCESLOT_H_
+#ifndef FSFW_TASKS_FIXEDSEQUENCESLOT_H_
+#define FSFW_TASKS_FIXEDSEQUENCESLOT_H_
 
+#include "ExecutableObjectIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/ExecutableObjectIF.h"
+
 class PeriodicTaskIF;
 
 /**
@@ -56,4 +57,4 @@ public:
 };
 
 
-#endif /* FIXEDSEQUENCESLOT_H_ */
+#endif /* FSFW_TASKS_FIXEDSEQUENCESLOT_H_ */
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 59859ce5..e5db4301 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -1,5 +1,5 @@
+#include "FixedSlotSequence.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tasks/FixedSlotSequence.h"
 #include <cstdlib>
 
 FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) :
@@ -91,21 +91,31 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-		sif::error << "Fixed Slot Sequence: Slot list is empty!" << std::endl;
+		sif::error << "FixedSlotSequence::checkSequence:"
+				<< " Slot list is empty!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
-	uint32_t count = 0;
+	if(customCheckFunction != nullptr) {
+		ReturnValue_t result = customCheckFunction(slotList);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			// Continue for now but print error output.
+			sif::error << "FixedSlotSequence::checkSequence:"
+					<< " Custom check failed!" << std::endl;
+		}
+	}
+
+	uint32_t errorCount = 0;
 	uint32_t time = 0;
 	for(const auto& slot: slotList) {
 		if (slot.executableObject == nullptr) {
-			count++;
+			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
-			sif::error << "FixedSlotSequence::initialize: Time: "
+			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
-			count++;
+			errorCount++;
 		}
 		else {
 			// All ok, print slot.
@@ -117,7 +127,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 	}
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
-	if (count > 0) {
+	if (errorCount > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -145,3 +155,8 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+void FixedSlotSequence::addCustomCheck(ReturnValue_t
+		(*customCheckFunction)(const SlotList&)) {
+	this->customCheckFunction = customCheckFunction;
+}
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 1140dd25..19a05f21 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -1,26 +1,30 @@
-#ifndef FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
-#define FRAMEWORK_TASKS_FIXEDSLOTSEQUENCE_H_
+#ifndef FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
+#define FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
 
+#include "FixedSequenceSlot.h"
 #include "../objectmanager/SystemObject.h"
-#include "../tasks/FixedSequenceSlot.h"
 
 #include <set>
 
 /**
- * @brief	This class is the representation of a Polling Sequence Table in software.
+ * @brief	This class is the representation of a
+ * 			Polling Sequence Table in software.
  * @details
  * The FixedSlotSequence object maintains the dynamic execution of
- * device handler objects.
+ * objects with stricter timing requirements for the FixedTimeslotTask.
  *
- * The main idea is to create a list of device handlers, to announce all
- * handlers to thepolling sequence and to maintain a list of
- * polling slot objects. This slot list represents the Polling Sequence Table
- * in software.
+ * The main idea is to create a list of executable objects (for example
+ * device handlers), to announce all handlers to the polling sequence and to
+ * maintain a list of polling slot objects.
+ * This slot list represents the Polling Sequence Table in software.
  *
  * Each polling slot contains information to indicate when and
- * which device handler shall be executed within a given polling period.
- * The sequence is then executed by iterating through this slot list.
- * Handlers are invoking by calling a certain function stored in the handler list.
+ * which executable object shall be executed within a given polling period.
+ * When adding a slot, a pointer to the executing task, a pointer to the
+ * executable object and a step number can be passed. The step number will be
+ * passed to the periodic handler.
+ * The sequence is executed by iterating through the slot sequence and
+ * executing the executable object in the correct timeslot.
  */
 class FixedSlotSequence {
 public:
@@ -29,41 +33,44 @@ public:
 
 	/**
 	 * @brief	The constructor of the FixedSlotSequence object.
-	 *
-	 * @details	The constructor takes two arguments, the period length and the init function.
-	 *
 	 * @param	setLength	The period length, expressed in ms.
 	 */
 	FixedSlotSequence(uint32_t setLengthMs);
 
 	/**
 	 * @brief	The destructor of the FixedSlotSequence object.
-	 *
-	 * @details	The destructor frees all allocated memory by iterating through the slotList
-	 *  		and deleting all allocated resources.
+	 * @details
+	 * The destructor frees all allocated memory by iterating through the
+	 * slotList and deleting all allocated resources.
 	 */
 	virtual ~FixedSlotSequence();
 
 	/**
 	 * @brief	This is a method to add an PollingSlot object to slotList.
 	 *
-	 * @details	Here, a polling slot object is added to the slot list. It is appended
-	 * 			to the end of the list. The list is currently NOT reordered.
-	 * 			Afterwards, the iterator current is set to the beginning of the list.
-	 * 	@param Object ID of the object to add
-	 * 	@param setTime Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
-	 * 				   will be called inside the slot period.
-	 * 	@param setSequenceId ID which can be used to distinguish
-	 * 	                     different task operations
+	 * @details
+	 * Here, a polling slot object is added to the slot list. It is appended
+	 * to the end of the list. The list is currently NOT reordered.
+	 * Afterwards, the iterator current is set to the beginning of the list.
+	 * 	@param handlerId ID of the object to add
+	 * 	@param setTime
+	 * 	Value between (0 to 1) * slotLengthMs, when a FixedTimeslotTask
+	 * 	will be called inside the slot period.
+	 * 	@param setSequenceId
+	 * 	ID which can be used to distinguish different task operations. This
+	 * 	value will be passed to the executable function.
 	 * 	@param
 	 * 	@param
 	 */
 	void addSlot(object_id_t handlerId, uint32_t setTime, int8_t setSequenceId,
-			ExecutableObjectIF* executableObject, PeriodicTaskIF* executingTask);
+			ExecutableObjectIF* executableObject,
+			PeriodicTaskIF* executingTask);
 
 	/**
-	 * Checks if the current slot shall be executed immediately after the one before.
-	 * This allows to distinguish between grouped and not grouped handlers.
+	 * @brief	Checks if the current slot shall be executed immediately
+	 * 			after the one before.
+	 * @details
+	 * This allows to distinguish between grouped and separated handlers.
 	 * @return 	- @c true if the slot has the same polling time as the previous
 	 * 			- @c false else
 	 */
@@ -128,12 +135,18 @@ public:
 	 * @brief   Check and initialize slot list.
 	 * @details
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
-	 * Also calls any initialization steps which are required after task
-	 * creation.
 	 * @return
 	 */
 	ReturnValue_t checkSequence() const;
 
+	void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
+
+	/**
+	 * @brief 	Perform any initialization steps required after the executing
+	 * 			task has been created. This function should be called from the
+	 * 			executing task!
+	 * @return
+	 */
 	ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
 protected:
@@ -151,9 +164,9 @@ protected:
 	 */
 	SlotList slotList;
 
-	uint32_t lengthMs;
+	ReturnValue_t (*customCheckFunction)(const SlotList&) = nullptr;
 
-	bool isEmpty = false;
+	uint32_t lengthMs;
 };
 
-#endif /* FIXEDSLOTSEQUENCE_H_ */
+#endif /* FSFW_TASKS_FIXEDSLOTSEQUENCE_H_ */

From 6980245c984c69f052c8d1ba2ad1c5c240f50c56 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:30:04 +0200
Subject: [PATCH 0700/1292] added line break

---
 osal/linux/FixedTimeslotTask.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index b634b4cf..cffdd1c5 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -63,6 +63,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	}
 
 	pst.intializeSequenceAfterTaskCreation();
+
 	//The start time for the first entry is read.
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	uint64_t interval = pst.getIntervalToNextSlotMs();

From 9d1f292af0f2973f595b0db09957a45a94782662 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:32:32 +0200
Subject: [PATCH 0701/1292] changed taken over

---
 osal/linux/FixedTimeslotTask.cpp | 2 +-
 osal/linux/FixedTimeslotTask.h   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index cffdd1c5..247a34ed 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -1,5 +1,5 @@
+#include "FixedTimeslotTask.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/FixedTimeslotTask.h"
 
 #include <limits.h>
 
diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h
index 0148922d..5c5c1814 100644
--- a/osal/linux/FixedTimeslotTask.h
+++ b/osal/linux/FixedTimeslotTask.h
@@ -1,9 +1,9 @@
-#ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
-#define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#ifndef FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
+#define FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_
 
+#include "PosixThread.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "../../tasks/FixedSlotSequence.h"
-#include "../../osal/linux/PosixThread.h"
 #include <pthread.h>
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread {
@@ -74,4 +74,4 @@ private:
 	bool started;
 };
 
-#endif /* FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */
+#endif /* FSFW_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ */

From 94b45d7407bd6413926184e8ec8f746fda648cfe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:49:27 +0200
Subject: [PATCH 0702/1292] changed taken over

---
 osal/linux/PeriodicPosixTask.cpp | 35 +++++++++++++++++---------------
 osal/linux/PeriodicPosixTask.h   |  4 ++--
 2 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index bbf33b01..3c1df6bb 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -1,8 +1,7 @@
 #include "../../tasks/ExecutableObjectIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
-
 #include <errno.h>
+#include "PeriodicPosixTask.h"
 
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
 		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
@@ -26,14 +25,14 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
-	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
-	            "it implements ExecutableObjectIF" << std::endl;
+		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
+				<< " it implements ExecutableObjectIF!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
 	newObject->setTaskIF(this);
 
-	return newObject->initializeAfterTaskCreation();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
@@ -49,27 +48,31 @@ ReturnValue_t PeriodicPosixTask::startTask(void) {
 }
 
 void PeriodicPosixTask::taskFunctionality(void) {
-	if(!started){
+	if(not started) {
 		suspend();
 	}
 
+	for (auto const &object: objectList) {
+		object->initializeAfterTaskCreation();
+	}
+
 	uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
 	//The task's "infinite" inner loop is entered.
 	while (1) {
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (auto const &object: objectList) {
+			object->performOperation();
 		}
-		if(!PosixThread::delayUntil(&lastWakeTime,periodMs)){
+
+		if(not PosixThread::delayUntil(&lastWakeTime, periodMs)){
 			char name[20] = {0};
-			int status = pthread_getname_np(pthread_self(),name,sizeof(name));
-			if(status == 0){
-				//sif::error << "PeriodicPosixTask " << name << ": Deadline "
-				//		"missed." << std::endl;
+			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
+			if(status == 0) {
+				sif::error << "PeriodicPosixTask " << name << ": Deadline "
+						"missed." << std::endl;
 			}
 			else {
-				//sif::error << "PeriodicPosixTask X: Deadline missed. " <<
-				//		status << std::endl;
+				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
+						status << std::endl;
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h
index 38825bbf..ffee236b 100644
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@@ -3,7 +3,7 @@
 
 #include "../../tasks/PeriodicTaskIF.h"
 #include "../../objectmanager/ObjectManagerIF.h"
-#include "../../osal/linux/PosixThread.h"
+#include "PosixThread.h"
 #include "../../tasks/ExecutableObjectIF.h"
 #include <vector>
 
@@ -32,7 +32,7 @@ public:
 	 * 			The address of the task object is passed as an argument
 	 * 			to the system call.
 	 */
-	ReturnValue_t startTask(void) override;
+	ReturnValue_t startTask() override;
 	/**
 	 * Adds an object to the list of objects to be executed.
 	 * The objects are executed in the order added.

From f4a50677751b01417a476dc1f309b5074e337601 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 14:53:27 +0200
Subject: [PATCH 0703/1292] update fw class Ids

---
 returnvalues/FwClassIds.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 12877b40..781320e3 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -67,7 +67,7 @@ enum {
 	DLE_ENCODER, //DLEE 61
 	PUS_PARSER, //PUSP 62
 	SERIAL_ANALYZER, //SERA 63
-	PUS_SERVICE_9,
+	PUS_SERVICE_9, // PUS9 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 147ab94149e2dff309ea628b5d77e74ed9a58208 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:13:32 +0200
Subject: [PATCH 0704/1292] include guard improvements

---
 container/SharedRingBuffer.cpp | 2 +-
 container/SharedRingBuffer.h   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 490988e5..800e75d3 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -1,4 +1,4 @@
-#include "../container/SharedRingBuffer.h"
+#include "SharedRingBuffer.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 394dcaaa..80c068b3 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
-#include "../container/SimpleRingBuffer.h"
+#include "SimpleRingBuffer.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../timemanager/Clock.h"
@@ -65,4 +65,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_CONTAINER_SHAREDRINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

From fff0131c9b27b25d8705ce42837f432035b51741 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:20:07 +0200
Subject: [PATCH 0705/1292] taken over changes

---
 health/HealthHelper.cpp |  2 +-
 health/HealthHelper.h   | 13 +++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index 61718f99..cced11d9 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -1,4 +1,4 @@
-#include "../health/HealthHelper.h"
+#include "HealthHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index d8b81ca9..d1f1945c 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -1,11 +1,12 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHHELPER_H_
-#define FRAMEWORK_HEALTH_HEALTHHELPER_H_
+#ifndef FSFW_HEALTH_HEALTHHELPER_H_
+#define FSFW_HEALTH_HEALTHHELPER_H_
+
+#include "HasHealthIF.h"
+#include "HealthMessage.h"
+#include "HealthTableIF.h"
 
 #include "../events/EventManagerIF.h"
 #include "../events/EventReportingProxyIF.h"
-#include "../health/HasHealthIF.h"
-#include "../health/HealthMessage.h"
-#include "../health/HealthTableIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -118,4 +119,4 @@ private:
 	void handleSetHealthCommand(CommandMessage *message);
 };
 
-#endif /* HEALTHHELPER_H_ */
+#endif /* FSFW_HEALTH_HEALTHHELPER_H_ */

From cfa952d9829b4b686ab615b5383c5fa59de285d1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:33:36 +0200
Subject: [PATCH 0706/1292] hybrid iterator same to FSFW

---
 container/HybridIterator.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 630bae28..8d020cb9 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,8 +1,8 @@
 #ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 #define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
-#include "../container/ArrayList.h"
-#include "../container/SinglyLinkedList.h"
+#include "ArrayList.h"
+#include "SinglyLinkedList.h"
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,

From be89e7ebb73f273077c4211eb01078e01d8f537a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:36:53 +0200
Subject: [PATCH 0707/1292] taken over from upstream with little tweak

---
 serialize/SerializeIF.h | 81 ++++++++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 26 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 6d5a0dda..3c0540f9 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -1,34 +1,19 @@
-#ifndef SERIALIZEIF_H_
-#define SERIALIZEIF_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEIF_H_
+#define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
 /**
  * @defgroup serialize Serialization
- * Contains serialisation services.
+ * Contains serialization services.
  */
 
 /**
- * @brief An interface for alle classes which require
- *        translation of objects data into data streams and vice-versa.
+ * @brief 	Translation of objects into data streams and from data streams.
  * @details
- * If the target architecture is little endian (e.g. ARM), any data types
- * created might  have the wrong endianess if they are to be used for the FSFW.
- * Depending on the system architecture, endian correctness must be assured,
- * This is important for incoming and outgoing data. The internal handling
- * of data should be performed in the native system endianness.
- * There are three ways to copy data (with different options to ensure
- * endian correctness):
- *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
- *      the endian flag)
- *   2. Perform a bitshift operation (with correct order)
- *   3. @c memcpy (with @c EndianSwapper if necessary)
- *
- * When serializing for downlink, the packets are generally serialized
- * assuming big endian data format like seen in TmPacketStored.cpp for example.
- *
+ * Also provides options to convert from/to data with different endianness.
+ * variables.
  * @ingroup serialize
  */
 class SerializeIF {
@@ -38,21 +23,65 @@ public:
 	};
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
-	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);
+	static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1); // !< The given buffer in serialize is too short
+	static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2); // !< The input stream in deserialize is too short
+	static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);// !< There are too many elements to be deserialized
 
 	virtual ~SerializeIF() {
 	}
-
+	/**
+	 * @brief
+	 * Function to serialize the object into a buffer with maxSize. Size represents the written amount.
+	 * If a part of the buffer has been used already, size must be set to the used amount of bytes.
+	 *
+	 * @details
+	 * Implementations of this function must increase the size variable and move the buffer pointer.
+	 * MaxSize must be checked by implementations of this function
+	 * and BUFFER_TOO_SHORT has to be returned if size would be larger than maxSize.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to serialize into, will be set to the current write location
+	 * @param[in/out] size Size that has been used in the buffer already, will be increased by the function
+	 * @param[in] maxSize The size of the buffer that is allowed to be used for serialize.
+	 * @param[in] streamEndianness Endianness of the serialized data according to SerializeIF::Endianness
+	 * @return
+	 * 		- @¢ BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
 	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
 			size_t maxSize, Endianness streamEndianness) const = 0;
 
+	/**
+	 * Gets the size of a object if it would be serialized in a buffer
+	 * @return Size of serialized object
+	 */
 	virtual size_t getSerializedSize() const = 0;
 
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 *
+	 * @details
+	 * Buffer must be moved to the current read location by the implementation
+	 * of this function. Size must be decreased by the implementation.
+	 * Implementations are not allowed to alter the buffer as indicated by const pointer.
+	 *
+	 * Custom implementations might use additional return values.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
 	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
 			Endianness streamEndianness) = 0;
 
 };
 
-#endif /* SERIALIZEIF_H_ */
+#endif /* FSFW_SERIALIZE_SERIALIZEIF_H_ */

From 37764f7ca710f3ae0ab3b41b7e6b72ea6ba3a14b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:39:17 +0200
Subject: [PATCH 0708/1292] include guard fixed

---
 serialize/EndianConverter.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index f981751d..c888a905 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -1,5 +1,5 @@
-#ifndef ENDIANSWAPPER_H_
-#define ENDIANSWAPPER_H_
+#ifndef FSFW_SERIALIZE_ENDIANCONVERTER_H_
+#define FSFW_SERIALIZE_ENDIANCONVERTER_H_
 
 #include "../osal/Endiness.h"
 #include <cstring>
@@ -121,4 +121,4 @@ public:
 	}
 };
 
-#endif /* ENDIANSWAPPER_H_ */
+#endif /* FSFW_SERIALIZE_ENDIANCONVERTER_H_ */

From 0d69e9beca4b0f35b2c0aea86d5c6df983e9ccaa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:42:15 +0200
Subject: [PATCH 0709/1292] taken over serial uffer adapter from upstream

---
 serialize/SerialBufferAdapter.cpp | 258 +++++++++++++++---------------
 serialize/SerialBufferAdapter.h   | 156 +++++++++---------
 2 files changed, 207 insertions(+), 207 deletions(-)

diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1c11afd4..812cd34b 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength),
-		constBuffer(buffer), buffer(nullptr),
-		bufferLength(bufferLength) {}
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
-		bufferLength(bufferLength) {}
-
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	if (serializeLength) {
-		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
-				buffer, size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	if (*size + bufferLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-
-	if (this->constBuffer != nullptr) {
-		std::memcpy(*buffer, this->constBuffer, bufferLength);
-	}
-	else if (this->buffer != nullptr) {
-		// This will propably be never reached, constBuffer should always be
-		// set if non-const buffer is set.
-		std::memcpy(*buffer, this->buffer, bufferLength);
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*size += bufferLength;
-	(*buffer) += bufferLength;
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-template<typename count_t>
-size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	if (this->buffer == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(serializeLength){
-		count_t lengthField = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
-				buffer, size, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if(lengthField > bufferLength) {
-			return TOO_MANY_ELEMENTS;
-		}
-		bufferLength = lengthField;
-	}
-
-	if (bufferLength <= *size) {
-		*size -= bufferLength;
-		std::memcpy(this->buffer, *buffer, bufferLength);
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-template<typename count_t>
-uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(buffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getConstBuffer()." << std::endl;
-		return nullptr;
-	}
-	return buffer;
-}
-
-template<typename count_t>
-const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter::getConstBuffer:"
-				" Buffers are unitialized!" << std::endl;
-		return nullptr;
-	}
-	return constBuffer;
-}
-
-template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t bufferLength) {
-	this->buffer = buffer;
-	this->constBuffer = buffer;
-	this->bufferLength = bufferLength;
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-template class SerialBufferAdapter<uint64_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index 9a89e18b..c3dfcd8f 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../serialize/SerializeAdapter.h"
-
-/**
- * This adapter provides an interface for SerializeIF to serialize or deserialize
- * buffers with no length header but a known size.
- *
- * Additionally, the buffer length can be serialized too and will be put in
- * front of the serialized buffer.
- *
- * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
- * Right now, the SerialBufferAdapter must always
- * be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename count_t>
-class SerialBufferAdapter: public SerializeIF {
-public:
-
-    /**
-     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength
-     */
-    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    /**
-     * Constructor for non-constant uint8_t buffer.
-     * Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength Length field will be serialized with size count_t
-     */
-    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    virtual ~SerialBufferAdapter();
-
-    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const override;
-
-    virtual size_t getSerializedSize() const override;
-
-    /**
-     * @brief This function deserializes a buffer into the member buffer.
-     * @details
-     * If a length field is present, it is ignored, as the size should have
-     * been set in the constructor. If the size is not known beforehand,
-     * consider using SerialFixedArrayListAdapter instead.
-     * @param buffer [out] Resulting buffer
-     * @param size remaining size to deserialize, should be larger than buffer
-     *        + size field size
-     * @param bigEndian
-     * @return
-     */
-    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) override;
-
-    uint8_t * getBuffer();
-    const uint8_t * getConstBuffer();
-    void setBuffer(uint8_t* buffer, count_t bufferLength);
-private:
-	bool serializeLength = false;
-	const uint8_t *constBuffer = nullptr;
-	uint8_t *buffer = nullptr;
-	count_t bufferLength = 0;
-};
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */

From f2f7a5de87b728868e13d96765846e50349a789f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:47:33 +0200
Subject: [PATCH 0710/1292] taken over convergence changes

---
 serialize/SerialFixedArrayListAdapter.h | 30 ++++++++++---------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h
index c866df86..70ca987a 100644
--- a/serialize/SerialFixedArrayListAdapter.h
+++ b/serialize/SerialFixedArrayListAdapter.h
@@ -1,8 +1,8 @@
-#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
-#define SERIALFIXEDARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_
 
+#include "SerialArrayListAdapter.h"
 #include "../container/FixedArrayList.h"
-#include "../serialize/SerialArrayListAdapter.h"
 
 /**
  * @brief 	This adapter provides an interface for SerializeIF to serialize and
@@ -13,18 +13,11 @@
  * The sequence of objects is defined in the constructor by
  * using the setStart and setNext functions.
  *
- *  - Buffers with a size header inside that class can be declared with
- *    @code
- *    SerialFixedArrayListAdapter<BUFFER_TYPE,
- *          MAX_SIZE, count_t> mySerialFixedArrayList(...).
- *    @endcode
- *
- *  - MAX_SIZE: specifies the maximum allowed number of elements
- *    in FixedArrayList.
- *  - BUFFER_TYPE: specifies the data type of the buffer
- *  - count_t: specifies the type/size of the length field
- *    which defaults to one byte.
- *
+ * @tparam BUFFER_TYPE: Specifies the data type of the buffer
+ * @tparam MAX_SIZE: Specifies the maximum allowed number of elements
+ * 					 (not bytes!)
+ * @tparam count_t: specifies the type/size of the length field which defaults
+ * 					to one byte.
  * @ingroup serialize
  */
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
@@ -33,7 +26,7 @@ class SerialFixedArrayListAdapter :
 		public SerializeIF {
 public:
 	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Constructor arguments are forwarded to FixedArrayList constructor.
 	 * Refer to the fixed array list constructors for different options.
 	 * @param args
 	 */
@@ -49,7 +42,8 @@ public:
     }
 
     size_t getSerializedSize() const {
-        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+        return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+        		getSerializedSize(this);
     }
 
     ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
@@ -60,4 +54,4 @@ public:
 
 };
 
-#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALFIXEDARRAYLISTADAPTER_H_ */

From 305d8ef84079a9e0e0861b4708147e3b562d2e10 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 15:56:52 +0200
Subject: [PATCH 0711/1292] taken over changes

---
 serialize/SerializeAdapter.h | 71 +++++++-----------------------------
 1 file changed, 14 insertions(+), 57 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 3e84bdf9..24f6111e 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,11 +1,12 @@
-#ifndef SERIALIZEADAPTER_H_
-#define SERIALIZEADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+
+#include "EndianConverter.h"
+#include "SerializeIF.h"
 
 #include "../container/IsDerivedFrom.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/EndianConverter.h"
-#include "../serialize/SerializeIF.h"
-#include <type_traits>
+#include <cstring>
 
  /**
  * @brief These adapters provides an interface to use the SerializeIF functions
@@ -13,56 +14,11 @@
  * 		  serialization of classes with different multiple different data types
  * 		  into buffers and vice-versa.
  * @details
- *
- * A report class is converted into a TM buffer. The report class implements a
- * serialize functions and calls the AutoSerializeAdapter::serialize function
- * repeatedly on all object data fields. The getSerializedSize function is
- * implemented by calling the AutoSerializeAdapter::getSerializedSize function
- * repeatedly on all data fields.
- *
- * The AutoSerializeAdapter functions can also be used as an alternative to
- * memcpy to retrieve data out of a buffer directly into a class variable
- * with data type T while being able to specify endianness. The boolean
- * bigEndian specifies whether an endian swap is performed on the data before
- * serialization or deserialization.
- *
- * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data. Examples:
- *
- *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize
- *		 of the object, so this function can be called on &buffer repeatedly
- *		without adjusting pointer position. Set bigEndian parameter to true
- *		to perform endian swapping, if necessary
- *		@code
- *   	uint16_t data;
- *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result =
- *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *   	@endcode
- *
- *   2. Perform a bitshift operation. Watch for for endianness:
- *		@code
- *   	uint16_t data;
- *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data); //optional, or swap order above
- *   	@endcode
- *
- *   3. memcpy or std::copy can also be used, but watch out if system
- *   	endianness is different from required data endianness.
- *   	Perform endian-swapping if necessary.
- *		@code
- *   	uint16_t data;
- *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data); //optional
- *   	@endcode
- *
- * When serializing for downlink, the packets are generally serialized assuming
- * big endian data format like seen in TmPacketStored.cpp for example.
+ * The correct serialization or deserialization function is chosen at
+ * compile time with template type deduction.
  *
  * @ingroup serialize
  */
-
 class SerializeAdapter {
 public:
 	template<typename T>
@@ -88,9 +44,10 @@ private:
 	class InternalSerializeAdapter {
 	public:
 		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
+				size_t *size, size_t max_size,
+				SerializeIF::Endianness streamEndianness) {
 			size_t ignoredSize = 0;
-			if (size == NULL) {
+			if (size == nullptr) {
 				size = &ignoredSize;
 			}
 			//TODO check integer overflow of *size
@@ -108,7 +65,7 @@ private:
 					tmp = *object;
 					break;
 				}
-				memcpy(*buffer, &tmp, sizeof(T));
+				std::memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
 				(*buffer) += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -122,7 +79,7 @@ private:
 			T tmp;
 			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
+				std::memcpy(&tmp, *buffer, sizeof(T));
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
 					*object = EndianConverter::convertBigEndian<T>(tmp);
@@ -156,7 +113,7 @@ private:
 				size_t *size, size_t max_size,
 				SerializeIF::Endianness streamEndianness) const {
 			size_t ignoredSize = 0;
-			if (size == NULL) {
+			if (size == nullptr) {
 				size = &ignoredSize;
 			}
 			return object->serialize(buffer, size, max_size, streamEndianness);

From 721b981df2df5ea852d0ad8a0381b488099f2d32 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:01:18 +0200
Subject: [PATCH 0712/1292] changes taken over

---
 serialize/SerialLinkedListAdapter.h | 51 +++++++++++++----------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h
index 987fa70e..430a21ac 100644
--- a/serialize/SerialLinkedListAdapter.h
+++ b/serialize/SerialLinkedListAdapter.h
@@ -1,17 +1,10 @@
-/**
- * @file	SerialLinkedListAdapter.h
- * @brief	This file defines the SerialLinkedListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALLINKEDLISTADAPTER_H_
-#define SERIALLINKEDLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_
 
 #include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeElement.h"
-#include "../serialize/SerializeIF.h"
-//This is where we need the SerializeAdapter!
+#include "SerializeAdapter.h"
+#include "SerializeElement.h"
+#include "SerializeIF.h"
 
  /**
  * @brief  	Implement the conversion of object data to data streams
@@ -22,7 +15,7 @@
  *     SerializeElement<element_type> members inside the class
  *     implementing this adapter.
  *   - The element type can also be a SerialBufferAdapter to
- *     de-/serialize buffers with a known size
+ *     de-/serialize buffers.
  *   - The element type can also be a SerialFixedArrayListAdapter to
  *     de-/serialize buffers with a size header, which is scanned automatically.
  *
@@ -37,21 +30,12 @@
  *    supplying a buffer with the data which is converted into an object.
  *    The size of data to serialize can be supplied and is
  *    decremented in the function. Range checking is done internally.
- *
+ * @author baetz
  * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialLinkedListAdapter: public SinglyLinkedList<T>, public SerializeIF {
 public:
-	/**
-	 * Copying is forbidden by deleting the copy constructor and the copy
-	 * assignment operator because of the pointers to the linked list members.
-	 * Unless the child class implements an own copy constructor or
-	 * copy assignment operator, these operation will throw a compiler error.
-	 * @param
-	 */
-	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
-	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
 
 	SerialLinkedListAdapter(typename LinkedElement<T>::Iterator start,
 			bool printCount = false) :
@@ -85,7 +69,7 @@ public:
 			uint8_t** buffer, size_t* size, size_t maxSize,
 			Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
 			result = element->value->serialize(buffer, size, maxSize,
 					streamEndianness);
 			element = element->getNext();
@@ -104,7 +88,7 @@ public:
 
 	static size_t getSerializedSize(const LinkedElement<T> *element) {
 		size_t size = 0;
-		while (element != NULL) {
+		while (element != nullptr) {
 			size += element->value->getSerializedSize();
 			element = element->getNext();
 		}
@@ -114,20 +98,31 @@ public:
 
 	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) override {
-		return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
+		return deSerialize(SinglyLinkedList<T>::start, buffer, size,
+				streamEndianness);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
 			const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
+		while ((result == HasReturnvaluesIF::RETURN_OK) and (element != nullptr)) {
 			result = element->value->deSerialize(buffer, size, streamEndianness);
 			element = element->getNext();
 		}
 		return result;
 	}
 
+	/**
+	 * Copying is forbidden by deleting the copy constructor and the copy
+	 * assignment operator because of the pointers to the linked list members.
+	 * Unless the child class implements an own copy constructor or
+	 * copy assignment operator, these operation will throw a compiler error.
+	 * @param
+	 */
+	SerialLinkedListAdapter(const SerialLinkedListAdapter &) = delete;
+	SerialLinkedListAdapter& operator=(const SerialLinkedListAdapter&) = delete;
+
 	bool printCount;
 };
 
-#endif /* SERIALLINKEDLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALLINKEDLISTADAPTER_H_ */

From 1803030640f2201a006a3e3e30e8029cf001464b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:04:11 +0200
Subject: [PATCH 0713/1292] taken over serialize element changes

---
 serialize/SerializeElement.h | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h
index 8c3472b2..47080292 100644
--- a/serialize/SerializeElement.h
+++ b/serialize/SerializeElement.h
@@ -1,8 +1,8 @@
-#ifndef SERIALIZEELEMENT_H_
-#define SERIALIZEELEMENT_H_
+#ifndef FSFW_SERIALIZE_SERIALIZEELEMENT_H_
+#define FSFW_SERIALIZE_SERIALIZEELEMENT_H_
 
+#include "SerializeAdapter.h"
 #include "../container/SinglyLinkedList.h"
-#include "../serialize/SerializeAdapter.h"
 #include <utility>
 
 /**
@@ -12,7 +12,7 @@
  * Used by declaring any arbitrary datatype with SerializeElement<T> myVariable,
  * inside a SerialLinkedListAdapter implementation and setting the sequence
  * of objects with setNext() and setStart().
- * Serilization and Deserialization is then performed automatically in
+ * Serialization and Deserialization is then performed automatically in
  * specified sequence order.
  * @ingroup serialize
  */
@@ -27,7 +27,7 @@ public:
 	SerializeElement() :
 			LinkedElement<SerializeIF>(this) {
 	}
-	T entry;
+
 	ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
 			Endianness streamEndianness) const override {
 		return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
@@ -52,9 +52,12 @@ public:
 		entry = newValue;
 		return *this;
 	}
+
 	T* operator->() {
 		return &entry;
 	}
+
+	T entry;
 };
 
-#endif /* SERIALIZEELEMENT_H_ */
+#endif /* FSFW_SERIALIZE_SERIALIZEELEMENT_H_ */

From faeeca8707857dc75451f06fb78e1c5bffd22b63 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 4 Sep 2020 16:07:54 +0200
Subject: [PATCH 0714/1292] seiralize folder converged

---
 serialize/SerialArrayListAdapter.h | 33 +++++++++++++-----------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h
index 69afdd4a..daa3fe7f 100644
--- a/serialize/SerialArrayListAdapter.h
+++ b/serialize/SerialArrayListAdapter.h
@@ -1,18 +1,13 @@
-/**
- * @file	SerialArrayListAdapter.h
- * @brief	This file defines the SerialArrayListAdapter class.
- * @date	22.07.2014
- * @author	baetz
- */
-#ifndef SERIALARRAYLISTADAPTER_H_
-#define SERIALARRAYLISTADAPTER_H_
+#ifndef FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
+#define FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_
 
+#include "SerializeIF.h"
 #include "../container/ArrayList.h"
-#include "../serialize/SerializeIF.h"
 #include <utility>
 
 /**
  * Also serializes length field !
+ * @author 	baetz
  * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
@@ -26,8 +21,9 @@ public:
 		return serialize(adaptee, buffer, size, maxSize, streamEndianness);
 	}
 
-	static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) {
+	static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
+			uint8_t** buffer, size_t* size, size_t maxSize,
+			Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::serialize(&list->size,
 				buffer, size, maxSize, streamEndianness);
 		count_t i = 0;
@@ -59,14 +55,19 @@ public:
 		return deSerialize(adaptee, buffer, size, streamEndianness);
 	}
 
-	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
+	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
+			const uint8_t** buffer, size_t* size,
 			Endianness streamEndianness) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
 				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}
+
 		list->size = tempSize;
 		count_t i = 0;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
@@ -78,14 +79,8 @@ public:
 		return result;
 	}
 
-
-	static void swapArrayListEndianness(ArrayList<T, count_t>* list) {
-		list->swapArrayListEndianness();
-	}
 private:
 	ArrayList<T, count_t> *adaptee;
 };
 
-
-
-#endif /* SERIALARRAYLISTADAPTER_H_ */
+#endif /* FSFW_SERIALIZE_SERIALARRAYLISTADAPTER_H_ */

From 05814dc805e3901aecdfd353c6e63712e9ed2c27 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 15:58:53 +0200
Subject: [PATCH 0715/1292] added way to start DH immediately, bugfix in event
 manager

---
 devicehandlers/DeviceHandlerBase.cpp          |  8 +++
 devicehandlers/DeviceHandlerBase.h            | 52 +++++++++++--------
 .../DeviceHandlerFailureIsolation.cpp         |  8 +++
 events/EventManagerIF.h                       | 22 +++++---
 modes/HasModesIF.h                            | 12 ++---
 5 files changed, 66 insertions(+), 36 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 45cf3781..86fd01b1 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1385,6 +1385,10 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
         pstIntervalMs = executingTask->getPeriodMs();
     }
     this->hkManager.initializeAfterTaskCreation();
+
+    if(setStartupImmediately) {
+        startTransition(MODE_ON, SUBMODE_NONE);
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -1402,6 +1406,10 @@ object_id_t DeviceHandlerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
+void DeviceHandlerBase::setStartUpImmediately() {
+    this->setStartupImmediately = true;
+}
+
 dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f809953e..c3748172 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -104,6 +104,16 @@ public:
 	void setHkDestination(object_id_t hkDestination);
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
+	/**
+	 * @brief   Helper function to easy device handler development.
+	 * This will instruct the transition to MODE_ON immediately
+	 * (leading to doStartUp() being called for the transition to the ON mode),
+	 * so external mode commanding is not necessary anymore.
+	 *
+	 * This has to be called before the task is started!
+	 * (e.g. in the task factory)
+	 */
+	void setStartUpImmediately();
 
 	/**
 	 * @brief 	This function is the device handler base core component and is
@@ -149,6 +159,14 @@ public:
 	 * @return
 	 */
 	virtual ReturnValue_t initialize();
+
+	/**
+	 * @brief   Intialization steps performed after all tasks have been created.
+	 *          This function will be called by the executing task.
+	 * @return
+	 */
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
 	/** Destructor. */
 	virtual ~DeviceHandlerBase();
 
@@ -945,14 +963,17 @@ protected:
 
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
+
+	/* HasModesIF overrides */
+	virtual void startTransition(Mode_t mode, Submode_t submode) override;
+	virtual void setToExternalControl() override;
+	virtual void announceMode(bool recursive) override;
 
 	virtual ReturnValue_t letChildHandleMessage(CommandMessage *message);
 
 	/**
-	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper" faster about executed events.
+	 * Overwrites SystemObject::triggerEvent in order to inform FDIR"Helper"
+	 * faster about executed events.
 	 * This is a bit sneaky, but improves responsiveness of the device FDIR.
 	 * @param event	The event to be thrown
 	 * @param parameter1	Optional parameter 1
@@ -1044,6 +1065,8 @@ private:
 	 */
 	uint32_t timeoutStart = 0;
 
+	bool setStartupImmediately = false;
+
 	/**
 	 * Delay for the current mode transition, used for time out
 	 */
@@ -1162,7 +1185,6 @@ private:
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,
 			uint32_t *len);
 
-
 	/**
 	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
 	 */
@@ -1173,28 +1195,14 @@ private:
 	 */
 	void callChildStatemachine();
 
-	/**
-	 * Switches the channel of the cookie used for the communication
-	 *
-	 *
-	 * @param newChannel the object Id of the channel to switch to
-	 * @return
-	 *     - @c RETURN_OK when cookie was changed
-	 *     - @c RETURN_FAILED when cookies could not be changed,
-	 *          e.g. because the newChannel is not enabled
-	 *     - @c returnvalues of RMAPChannelIF::isActive()
-	 */
-	ReturnValue_t switchCookieChannel(object_id_t newChannelId);
-
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
 	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
 
-	void parseReply(const uint8_t* receivedData,
-	            size_t receivedDataLen);
-
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
+
+    void parseReply(const uint8_t* receivedData,
+                size_t receivedDataLen);
 };
 
 #endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9fbe71d8..24fe15a0 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -247,6 +247,14 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 		}
 		return true;
 	}
+
+	if (owner == nullptr) {
+	    // Configuration error.
+	    sif::error << "DeviceHandlerFailureIsolation::"
+	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+	    return false;
+	}
+
 	if (owner->getHealth() == HasHealthIF::FAULTY
 			|| owner->getHealth() == HasHealthIF::PERMANENT_FAULTY) {
 		//Ignore all events in case device is already faulty.
diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h
index f9ac420b..253e6910 100644
--- a/events/EventManagerIF.h
+++ b/events/EventManagerIF.h
@@ -1,10 +1,11 @@
 #ifndef EVENTMANAGERIF_H_
 #define EVENTMANAGERIF_H_
 
-#include "eventmatching/eventmatching.h"
 #include "EventMessage.h"
+#include "eventmatching/eventmatching.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+#include "../ipc/MessageQueueIF.h"
 
 class EventManagerIF {
 public:
@@ -16,7 +17,8 @@ public:
 
 	virtual MessageQueueId_t getEventReportQueue() = 0;
 
-	virtual ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false) = 0;
+	virtual ReturnValue_t registerListener(MessageQueueId_t listener,
+	        bool forwardAllButSelected = false) = 0;
 	virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener,
 			EventId_t event) = 0;
 	virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener,
@@ -31,18 +33,22 @@ public:
 			bool reporterInverted = false) = 0;
 
 	static void triggerEvent(object_id_t reportingObject, Event event,
-			uint32_t parameter1 = 0, uint32_t parameter2 = 0, MessageQueueId_t sentFrom = 0) {
+			uint32_t parameter1 = 0, uint32_t parameter2 = 0,
+			MessageQueueId_t sentFrom = 0) {
 		EventMessage message(event, reportingObject, parameter1, parameter2);
 		triggerEvent(&message, sentFrom);
 	}
-	static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
-		static MessageQueueId_t eventmanagerQueue = 0;
-		if (eventmanagerQueue == 0) {
+
+	static void triggerEvent(EventMessage* message,
+	        MessageQueueId_t sentFrom = 0) {
+		static MessageQueueId_t eventmanagerQueue = MessageQueueIF::NO_QUEUE;
+		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
 			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
 					objects::EVENT_MANAGER);
-			if (eventmanager != NULL) {
-				eventmanagerQueue = eventmanager->getEventReportQueue();
+			if (eventmanager == nullptr) {
+			    return;
 			}
+			eventmanagerQueue = eventmanager->getEventReportQueue();
 		}
 		MessageQueueSenderIF::sendMessage(eventmanagerQueue, message, sentFrom);
 	}
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index c3abaaaf..39a50c2a 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -46,12 +46,12 @@ protected:
 			uint32_t *msToReachTheMode) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	virtual void startTransition(Mode_t mode, Submode_t submode) {
-	}
-	virtual void setToExternalControl() {
-	}
-	virtual void announceMode(bool recursive) {
-	}
+
+	virtual void startTransition(Mode_t mode, Submode_t submode) {}
+
+	virtual void setToExternalControl() {}
+
+	virtual void announceMode(bool recursive) {}
 };
 
 #endif /* HASMODESIF_H_ */

From 39b675cf9984a1b22c215979821073a81202b273 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 20:39:10 +0200
Subject: [PATCH 0716/1292] repairing host osal

---
 osal/host/FixedTimeslotTask.cpp |  7 +++++--
 osal/host/MessageQueue.cpp      | 10 ++++++----
 osal/host/MessageQueue.h        |  3 ++-
 osal/host/Mutex.cpp             |  7 +++----
 osal/host/Mutex.h               |  5 +++--
 osal/host/QueueMapManager.cpp   |  2 +-
 osal/host/SemaphoreFactory.cpp  |  3 ---
 7 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1139badb..1257eb16 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -122,8 +122,11 @@ void FixedTimeslotTask::taskFunctionality() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
-    if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep, this);
+    ExecutableObjectIF* executableObject = objectManager->
+            get<ExecutableObjectIF>(componentId);
+    if (executableObject!= nullptr) {
+        pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
+                executableObject, this);
         return HasReturnvaluesIF::RETURN_OK;
     }
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 8a34282c..59825084 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -61,7 +61,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 	// not sure this will work..
 	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, 20);
+	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -126,7 +126,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	}
 
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock, 20);
+		MutexHelper mutexLock(targetQueue->queueLock,
+		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =
 				dynamic_cast<MessageQueueMessage*>(message);
@@ -146,8 +147,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::lockQueue(dur_millis_t lockTimeout) {
-	return queueLock->lockMutex(lockTimeout);
+ReturnValue_t MessageQueue::lockQueue(MutexIF::TimeoutType timeoutType,
+        dur_millis_t lockTimeout) {
+	return queueLock->lockMutex(timeoutType, lockTimeout);
 }
 
 ReturnValue_t MessageQueue::unlockQueue() {
diff --git a/osal/host/MessageQueue.h b/osal/host/MessageQueue.h
index 21a01663..97a9e491 100644
--- a/osal/host/MessageQueue.h
+++ b/osal/host/MessageQueue.h
@@ -182,7 +182,8 @@ public:
 
 	bool isDefaultDestinationSet() const override;
 
-	ReturnValue_t lockQueue(dur_millis_t lockTimeout);
+	ReturnValue_t lockQueue(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t lockTimeout);
 	ReturnValue_t unlockQueue();
 protected:
 	/**
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 2718f2b9..8471cab8 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -1,10 +1,9 @@
-#include "../../osal/host/Mutex.h"
+#include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::POLLING = 0;
-const uint32_t MutexIF::BLOCKING = 0xffffffff;
+Mutex::Mutex() {}
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	if(timeoutMs == MutexIF::BLOCKING) {
 		mutex.lock();
 		locked = true;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 4461e5f2..b755bc30 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -15,8 +15,9 @@
  */
 class Mutex : public MutexIF {
 public:
-	Mutex() = default;
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
+	Mutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) override;
 	ReturnValue_t unlockMutex() override;
 
 	std::timed_mutex* getMutexHandle();
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 47687bc1..a466c3f8 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -37,7 +37,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, 50);
+	MutexHelper(MutexIF::TimeoutType::WAITING, mapLock, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index c354c47c..b19b2c75 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -3,9 +3,6 @@
 #include "../../osal/linux/CountingSemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::BLOCKING = 0xFFFFFFFF;
-
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 
 SemaphoreFactory::SemaphoreFactory() {

From 80e60566d82c5a6ed35c91af6f3d6cc21866dd7f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:11:27 +0200
Subject: [PATCH 0717/1292] compiling and working again

---
 osal/host/FixedTimeslotTask.cpp | 9 ++++++---
 osal/host/FixedTimeslotTask.h   | 2 +-
 osal/host/QueueMapManager.cpp   | 2 +-
 timemanager/CCSDSTime.cpp       | 4 ++++
 4 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1257eb16..e78c974a 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -90,9 +90,12 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 }
 
 void FixedTimeslotTask::taskFunctionality() {
+    pollingSeqTable.intializeSequenceAfterTaskCreation();
+
     // A local iterator for the Polling Sequence Table is created to
     // find the start time for the first entry.
-    FixedSlotSequence::SlotListIter slotListIter = pollingSeqTable.current;
+    auto slotListIter = pollingSeqTable.current;
+
     // Get start time for first entry.
     chron_ms interval(slotListIter->pollingTimeMs);
     auto currentStartTime {
@@ -124,7 +127,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
     ExecutableObjectIF* executableObject = objectManager->
             get<ExecutableObjectIF>(componentId);
-    if (executableObject!= nullptr) {
+    if (executableObject != nullptr) {
         pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,
                 executableObject, this);
         return HasReturnvaluesIF::RETURN_OK;
@@ -135,7 +138,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkAndInitializeSequence() const {
+ReturnValue_t FixedTimeslotTask::checkSequence() const {
     return pollingSeqTable.checkSequence();
 }
 
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 3ea97b97..9985e2ee 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -61,7 +61,7 @@ public:
     ReturnValue_t addSlot(object_id_t componentId,
                    uint32_t slotTimeMs, int8_t executionStep);
 
-    ReturnValue_t checkAndInitializeSequence() const;
+    ReturnValue_t checkSequence() const override;
 
     uint32_t getPeriodMs() const;
 
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index a466c3f8..6007e9f3 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -37,7 +37,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(MutexIF::TimeoutType::WAITING, mapLock, 50);
+	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 130b3175..12ecf34a 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -3,6 +3,10 @@
 #include <inttypes.h>
 #include <math.h>
 
+#ifndef SCNu8
+  #define SCNu8 "hhu"
+#endif
+
 CCSDSTime::CCSDSTime() {
 }
 

From 883103af2b4de3e099180e1fb999af974675e7ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:13:07 +0200
Subject: [PATCH 0718/1292] queue map manager update

---
 osal/host/QueueMapManager.cpp | 3 ++-
 osal/host/QueueMapManager.h   | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 6007e9f3..1b2094e9 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -1,6 +1,7 @@
+#include "QueueMapManager.h"
+
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexHelper.h"
-#include "../../osal/host/QueueMapManager.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h
index 823fd4c2..d7d5c915 100644
--- a/osal/host/QueueMapManager.h
+++ b/osal/host/QueueMapManager.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
-#define FRAMEWORK_OSAL_HOST_QUEUEMAP_H_
+#ifndef FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
+#define FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_
 
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../osal/host/MessageQueue.h"
@@ -44,4 +44,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_OSAL_HOST_QUEUEMAP_H_ */
+#endif /* FSFW_OSAL_HOST_QUEUEMAPMANAGER_H_ */

From c43ae66205f6fc4c594075660d34b0f6317569fa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:18:30 +0200
Subject: [PATCH 0719/1292] some tweaks

---
 osal/host/MessageQueue.cpp | 8 +++++---
 osal/host/Mutex.h          | 6 +++---
 osal/host/PeriodicTask.cpp | 6 +++---
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 59825084..bced3713 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -1,6 +1,7 @@
-#include "../../osal/host/MessageQueue.h"
+#include "MessageQueue.h"
+#include "QueueMapManager.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/host/QueueMapManager.h"
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexHelper.h"
 
@@ -9,7 +10,8 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "MessageQueue: Could not be created" << std::endl;
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Could not be created" << std::endl;
 	}
 }
 
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index b755bc30..24dafbbd 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
-#define FRAMEWORK_OSAL_FREERTOS_MUTEX_H_
+#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
+#define FSFW_OSAL_HOSTED_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -26,4 +26,4 @@ private:
 	std::timed_mutex mutex;
 };
 
-#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 0b5f8bbe..f4ee079b 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -1,7 +1,7 @@
-#include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/PeriodicTask.h"
+#include "Mutex.h"
+#include "PeriodicTask.h"
 
+#include "../../ipc/MutexFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tasks/ExecutableObjectIF.h"
 

From 7a24f899158ad8b6a3a74ff2da8a0ba530dc8539 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:19:15 +0200
Subject: [PATCH 0720/1292] removed comment

---
 osal/host/TaskFactory.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osal/host/TaskFactory.cpp b/osal/host/TaskFactory.cpp
index 37df981a..bc65504c 100644
--- a/osal/host/TaskFactory.cpp
+++ b/osal/host/TaskFactory.cpp
@@ -25,8 +25,6 @@ PeriodicTaskIF* TaskFactory::createPeriodicTask(TaskName name_,
 		TaskPriority taskPriority_,TaskStackSize stackSize_,
 		TaskPeriod periodInSeconds_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
 	return new PeriodicTask(name_, taskPriority_, stackSize_, periodInSeconds_,
 			deadLineMissedFunction_);
 }
@@ -35,8 +33,6 @@ FixedTimeslotTaskIF* TaskFactory::createFixedTimeslotTask(TaskName name_,
 		TaskPriority taskPriority_,TaskStackSize stackSize_,
 		TaskPeriod periodInSeconds_,
 		TaskDeadlineMissedFunction deadLineMissedFunction_) {
-	// This is going to be interesting. Time now learn the C++ threading library
-	// :-)
 	return new FixedTimeslotTask(name_, taskPriority_, stackSize_,
 	        periodInSeconds_, deadLineMissedFunction_);
 }

From cb970b1883b35412b64145ddff4f1c5eb1604529 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:24:59 +0200
Subject: [PATCH 0721/1292] task IF is set now

---
 osal/host/PeriodicTask.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index f4ee079b..3157ffb7 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -101,13 +101,14 @@ void PeriodicTask::taskFunctionality() {
 		if(terminateThread.load()) {
 			break;
 		}
-		for (ObjectList::iterator it = objectList.begin();
-				it != objectList.end(); ++it) {
-			(*it)->performOperation();
+		for (const auto& object: objectList) {
+			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
+#ifdef DEBUG
 			sif::warning << "PeriodicTask: " << taskName <<
 					" missed deadline!\n" << std::flush;
+#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
@@ -121,6 +122,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From c7606b7b1e870b510488da7d72c0dbe9b47e6ddb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:51:17 +0200
Subject: [PATCH 0722/1292] updating and cleaning pool files

---
 datapool/PoolDataSetBase.h         | 11 ++++++-----
 datapool/PoolDataSetIF.h           |  7 ++++---
 datapool/PoolEntry.cpp             |  3 ++-
 datapool/PoolEntry.h               |  8 ++++----
 datapool/PoolEntryIF.h             |  6 +++---
 datapool/PoolRawAccessHelper.cpp   |  9 +--------
 datapool/PoolRawAccessHelper.h     | 10 ++--------
 datapoolglob/DataPoolAdmin.cpp     |  9 +++++----
 datapoolglob/DataPoolAdmin.h       | 13 +++++++------
 datapoolglob/GlobalPoolVector.h    |  6 +++---
 datapoolglob/GlobalPoolVector.tpp  |  4 ++--
 datapoollocal/HasLocalDataPoolIF.h |  7 ++++---
 datapoollocal/LocalDataSet.h       |  9 +++++----
 13 files changed, 48 insertions(+), 54 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 66662413..a8931d62 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#define FRAMEWORK_DATAPOOL_DATASETBASE_H_
-#include "../datapool/PoolDataSetIF.h"
-#include "../datapool/PoolVariableIF.h"
+#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
+#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+
+#include "PoolDataSetIF.h"
+#include "PoolVariableIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
@@ -148,4 +149,4 @@ private:
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
 };
 
-#endif /* FRAMEWORK_DATAPOOL_POOLPOOLDATASETBASE_H_ */
+#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 44ca468b..78c05d43 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
-#define FRAMEWORK_DATAPOOL_POOLDATASETIF_H_
+#ifndef FSFW_DATAPOOL_POOLDATASETIF_H_
+#define FSFW_DATAPOOL_POOLDATASETIF_H_
+
 #include "DataSetIF.h"
 
 class PoolDataSetIF: public DataSetIF {
@@ -25,4 +26,4 @@ public:
     virtual bool isValid() const = 0;
 };
 
-#endif /* FRAMEWORK_DATAPOOL_POOLDATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index b0506b82..fb73328c 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,4 +1,5 @@
-#include "../datapool/PoolEntry.h"
+#include "PoolEntry.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 6a3daacf..033db40d 100644
--- a/datapool/PoolEntry.h
+++ b/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 "../datapool/PoolEntryIF.h"
+#include "PoolEntryIF.h"
 
 #include <initializer_list>
 #include <type_traits>
@@ -127,4 +127,4 @@ public:
 	Type getType();
 };
 
-#endif /* POOLENTRY_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h
index 462de18b..d9db5237 100644
--- a/datapool/PoolEntryIF.h
+++ b/datapool/PoolEntryIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
-#define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_
+#ifndef FSFW_DATAPOOL_POOLENTRYIF_H_
+#define FSFW_DATAPOOL_POOLENTRYIF_H_
 
 #include "../globalfunctions/Type.h"
 #include <cstdint>
@@ -60,4 +60,4 @@ public:
 	virtual Type getType() = 0;
 };
 
-#endif /* POOLENTRYIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLENTRYIF_H_ */
diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
index 3696a21d..5a6827b6 100644
--- a/datapool/PoolRawAccessHelper.cpp
+++ b/datapool/PoolRawAccessHelper.cpp
@@ -1,11 +1,4 @@
-/**
- * @file PoolRawAccessHelper.cpp
- *
- * @date 22.12.2019
- * @author R. Mueller
- */
-
-#include "../datapool/PoolRawAccessHelper.h"
+#include "PoolRawAccessHelper.h"
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
index db25acdf..6ff3e955 100644
--- a/datapool/PoolRawAccessHelper.h
+++ b/datapool/PoolRawAccessHelper.h
@@ -1,11 +1,5 @@
-/**
- * @file PoolRawAccessHelper.h
- *
- * @date 22.12.2019
- */
-
-#ifndef FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FRAMEWORK_DATAPOOL_POOLRAWACCESSHELPER_H_
+#ifndef FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
+#define FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../datapoolglob/GlobalDataSet.h"
diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 029a336d..6ede0841 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -1,7 +1,8 @@
-#include "../datapoolglob/DataPoolAdmin.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
+#include "DataPoolAdmin.h"
+#include "GlobalDataSet.h"
+#include "GlobalDataPool.h"
+#include "PoolRawAccess.h"
+
 #include "../ipc/CommandMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../parameters/ParameterMessage.h"
diff --git a/datapoolglob/DataPoolAdmin.h b/datapoolglob/DataPoolAdmin.h
index a08f322d..d8871b65 100644
--- a/datapoolglob/DataPoolAdmin.h
+++ b/datapoolglob/DataPoolAdmin.h
@@ -1,5 +1,7 @@
-#ifndef DATAPOOLADMIN_H_
-#define DATAPOOLADMIN_H_
+#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
+
+#include "DataPoolParameterWrapper.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -7,10 +9,9 @@
 #include "../action/HasActionsIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../parameters/ReceivesParameterMessagesIF.h"
-
-#include "../memory/MemoryHelper.h"
 #include "../action/SimpleActionHelper.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
+#include "../memory/MemoryHelper.h"
+
 
 class DataPoolAdmin: public HasActionsIF,
 		public ExecutableObjectIF,
@@ -56,4 +57,4 @@ private:
 			Command_t initialCommand);
 };
 
-#endif /* DATAPOOLADMIN_H_ */
+#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/datapoolglob/GlobalPoolVector.h b/datapoolglob/GlobalPoolVector.h
index 6b592fc6..0f5daacd 100644
--- a/datapoolglob/GlobalPoolVector.h
+++ b/datapoolglob/GlobalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef GLOBALPOOLVECTOR_H_
-#define GLOBALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
@@ -182,4 +182,4 @@ private:
 template<typename T, uint16_t vectorSize>
 using gp_vec_t = GlobPoolVector<T, vectorSize>;
 
-#endif /* POOLVECTOR_H_ */
+#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/datapoolglob/GlobalPoolVector.tpp b/datapoolglob/GlobalPoolVector.tpp
index ccf33138..013a682a 100644
--- a/datapoolglob/GlobalPoolVector.tpp
+++ b/datapoolglob/GlobalPoolVector.tpp
@@ -1,5 +1,5 @@
-#ifndef GLOBALPOOLVECTOR_TPP_
-#define GLOBALPOOLVECTOR_TPP_
+#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
 
 
 template<typename T, uint16_t vectorSize>
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 9eb1c9f1..3e6b843f 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
-#define FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
+
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
@@ -89,4 +90,4 @@ public:
 	};
 };
 
-#endif /* FRAMEWORK_DATAPOOL_HASHKPOOLPARAMETERSIF_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 5641ebfb..0368f26d 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_
-#include "../datapoollocal/LocalPoolDataSetBase.h"
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
 #include <vector>
 
 class LocalDataSet: public LocalPoolDataSetBase {
@@ -17,4 +18,4 @@ private:
     std::vector<PoolVariableIF*> poolVarList;
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATASET_H_ */

From f698275a0bafc6494780f9b65858ca7d920e8e5a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 5 Sep 2020 21:59:17 +0200
Subject: [PATCH 0723/1292] removed seconds typedef, confusing

---
 datapoollocal/HasLocalDataPoolIF.h   |  4 +++-
 datapoollocal/LocalPoolDataSetBase.h |  9 +++++----
 datapoollocal/SharedLocalDataSet.h   |  9 +++++----
 datapoollocal/StaticLocalDataSet.h   | 12 +++++++-----
 timemanager/Clock.h                  |  1 -
 timemanager/Stopwatch.cpp            |  2 +-
 timemanager/Stopwatch.h              |  2 +-
 7 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3e6b843f..4b49ee11 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,6 +4,8 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
+#include "../timemanager/Clock.h"
+
 #include <map>
 
 class LocalDataPoolManager;
@@ -85,7 +87,7 @@ public:
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        dur_seconds_t newInterval) {
+	        float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 };
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index bd127db4..77c1df1b 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+
+#include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../serialize/SerializeIF.h"
 
 #include <vector>
@@ -130,4 +131,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index f6748e4d..b1f9aa3d 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#ifndef FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
+
+#include "LocalPoolDataSetBase.h"
 #include "../datapool/SharedDataSetIF.h"
-#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
@@ -28,4 +29,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index b3e8422c..7c2f0039 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#ifndef FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+
 #include "LocalPoolDataSetBase.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include <array>
@@ -16,12 +17,13 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-    StaticLocalDataSet(sid_t sid):
-        LocalPoolDataSetBase(sid, poolVarList.data(), NUM_VARIABLES) {
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
     }
 
 private:
     std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
 };
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 9463b5a6..acb68e2e 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -10,7 +10,6 @@
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
 using dur_millis_t = uint32_t;
-using dur_seconds_t = double;
 
 class Clock {
 public:
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 637c5078..28ae4543 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -18,7 +18,7 @@ dur_millis_t Stopwatch::stop() {
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-dur_seconds_t Stopwatch::stopSeconds() {
+double Stopwatch::stopSeconds() {
     stopInternal();
     return timevalOperations::toDouble(elapsedTime);
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 191929dc..49b686f9 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -45,7 +45,7 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)
      */
-    dur_seconds_t stopSeconds();
+    double stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display

From 08ffbfefae6ea75186a6b405afacc1b9e73e0f55 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 09:33:02 +0200
Subject: [PATCH 0724/1292] added windows udp bridge

---
 osal/host/FixedTimeslotTask.cpp  | 17 +++++-----
 osal/host/Mutex.h                |  6 ++--
 osal/host/TmTcWinUdpBridge.cpp   | 57 ++++++++++++++++++++++++++++++++
 osal/host/TmTcWinUdpBridge.h     | 47 ++++++++++++++++++++++++++
 osal/linux/TmTcUnixUdpBridge.cpp |  2 +-
 5 files changed, 116 insertions(+), 13 deletions(-)
 create mode 100644 osal/host/TmTcWinUdpBridge.cpp
 create mode 100644 osal/host/TmTcWinUdpBridge.h

diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index e78c974a..3c31eb76 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,9 +1,7 @@
-#include "../../osal/host/FixedTimeslotTask.h"
+#include "FixedTimeslotTask.h"
+#include "Mutex.h"
 
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/host/Mutex.h"
-#include "../../osal/host/FixedTimeslotTask.h"
-
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
@@ -35,15 +33,15 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with "
+                << "code " << GetLastError() << std::endl;
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with "
+                "code " << GetLastError() << std::endl;
     }
 #elif defined(LINUX)
     // we can just copy and paste the code from linux here.
@@ -60,7 +58,8 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
+    FixedTimeslotTask *originalTask(
+            reinterpret_cast<FixedTimeslotTask*>(argument));
 
     if (not originalTask->started) {
         // we have to suspend/block here until the task is started.
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index 24dafbbd..af56b8f7 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
-#define FSFW_OSAL_HOSTED_MUTEX_H_
+#ifndef FSFW_OSAL_HOST_MUTEX_H_
+#define FSFW_OSAL_HOST_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -26,4 +26,4 @@ private:
 	std::timed_mutex mutex;
 };
 
-#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOST_MUTEX_H_ */
diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/host/TmTcWinUdpBridge.cpp
new file mode 100644
index 00000000..b7b43b13
--- /dev/null
+++ b/osal/host/TmTcWinUdpBridge.cpp
@@ -0,0 +1,57 @@
+#include "TmTcWinUdpBridge.h"
+
+TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
+        object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
+        uint16_t serverPort, uint16_t clientPort):
+        TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+    mutex = MutexFactory::instance()->createMutex();
+
+    uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
+    if(serverPort != 0xFFFF) {
+        setServerPort = serverPort;
+    }
+
+    uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
+    if(clientPort != 0xFFFF) {
+        setClientPort = clientPort;
+    }
+
+    // Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
+    //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
+    serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if(socket < 0) {
+        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+                " UDP socket!" << std::endl;
+        handleSocketError();
+        return;
+    }
+
+    serverAddress.sin_family = AF_INET;
+
+    // Accept packets from any interface.
+    //serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    serverAddress.sin_port = htons(setServerPort);
+    //serverAddressLen = sizeof(serverAddress);
+    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
+            reinterpret_cast<const char*>(&serverSocketOptions),
+            sizeof(serverSocketOptions));
+
+    clientAddress.sin_family = AF_INET;
+    clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+    clientAddress.sin_port = htons(setClientPort);
+    //clientAddressLen = sizeof(clientAddress);
+
+    int result = bind(serverSocket,
+            reinterpret_cast<struct sockaddr*>(&serverAddress),
+            serverAddressLen);
+    if(result == -1) {
+        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+                "local port " << setServerPort << " to server socket!"
+                << std::endl;
+        handleBindError();
+        return;
+    }
+}
+
+
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/host/TmTcWinUdpBridge.h
new file mode 100644
index 00000000..66463065
--- /dev/null
+++ b/osal/host/TmTcWinUdpBridge.h
@@ -0,0 +1,47 @@
+#ifndef FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+#define FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+
+#include "../../tmtcservices/TmTcBridge.h"
+#include <Winsock.h>
+
+class TmTcWinUdpBridge: public TmTcBridge {
+    friend class TcWinUdpPollingTask;
+public:
+    // The ports chosen here should not be used by any other process.
+    // List of used ports on Linux: /etc/services
+    static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
+    static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
+
+    TmTcWinUdpBridge(object_id_t objectId, object_id_t tcDestination,
+            object_id_t tmStoreId, object_id_t tcStoreId,
+            uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
+    virtual~ TmTcWinUdpBridge();
+
+    void checkAndSetClientAddress(sockaddr_in clientAddress);
+
+protected:
+    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+
+private:
+    SOCKET serverSocket = 0;
+
+    const int serverSocketOptions = 0;
+
+    struct sockaddr_in clientAddress;
+    //socklen_t clientAddressLen = 0;
+
+    struct sockaddr_in serverAddress;
+    //socklen_t serverAddressLen = 0;
+
+    //! Access to the client address is mutex protected as it is set
+    //! by another task.
+    MutexIF* mutex;
+
+    void handleSocketError();
+    void handleBindError();
+    void handleSendError();
+};
+
+
+
+#endif /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 3e9674f3..d0c9517f 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -24,7 +24,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
 	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-	if(socket < 0) {
+	if(serverSocket < 0) {
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 		handleSocketError();

From 0c85b05aca4d7a1adc8f5bf1a85133c845ecc63f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 09:54:22 +0200
Subject: [PATCH 0725/1292] continued win bridge

---
 osal/host/TmTcWinUdpBridge.cpp | 24 ++++++++++++++++++++----
 osal/host/TmTcWinUdpBridge.h   |  4 ++--
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/host/TmTcWinUdpBridge.cpp
index b7b43b13..4bb9a3b1 100644
--- a/osal/host/TmTcWinUdpBridge.cpp
+++ b/osal/host/TmTcWinUdpBridge.cpp
@@ -19,8 +19,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     // Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    if(socket < 0) {
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
+    if(serverSocket != 0) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
         handleSocketError();
         return;
@@ -32,7 +32,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
     serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     serverAddress.sin_port = htons(setServerPort);
-    //serverAddressLen = sizeof(serverAddress);
+    serverAddressLen = sizeof(serverAddress);
     setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR,
             reinterpret_cast<const char*>(&serverSocketOptions),
             sizeof(serverSocketOptions));
@@ -40,7 +40,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     clientAddress.sin_family = AF_INET;
     clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     clientAddress.sin_port = htons(setClientPort);
-    //clientAddressLen = sizeof(clientAddress);
+    clientAddressLen = sizeof(clientAddress);
 
     int result = bind(serverSocket,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
@@ -54,4 +54,20 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     }
 }
 
+TmTcWinUdpBridge::~TmTcWinUdpBridge() {}
 
+void TmTcWinUdpBridge::handleSocketError() {
+}
+
+void TmTcWinUdpBridge::handleBindError() {
+}
+
+ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
+}
+
+void TmTcWinUdpBridge::handleSendError() {
+}
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/host/TmTcWinUdpBridge.h
index 66463065..8e6bb0fd 100644
--- a/osal/host/TmTcWinUdpBridge.h
+++ b/osal/host/TmTcWinUdpBridge.h
@@ -28,10 +28,10 @@ private:
     const int serverSocketOptions = 0;
 
     struct sockaddr_in clientAddress;
-    //socklen_t clientAddressLen = 0;
+    int clientAddressLen = 0;
 
     struct sockaddr_in serverAddress;
-    //socklen_t serverAddressLen = 0;
+    int serverAddressLen = 0;
 
     //! Access to the client address is mutex protected as it is set
     //! by another task.

From b7c4f5ce05ec1c235cbea3b825d21ce4497dd095 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 10:36:39 +0200
Subject: [PATCH 0726/1292] continued win sockets

---
 osal/linux/TcUnixUdpPollingTask.cpp         |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp            |  3 +-
 osal/{host => windows}/TmTcWinUdpBridge.cpp | 73 ++++++++++++++++++---
 osal/{host => windows}/TmTcWinUdpBridge.h   | 10 +--
 4 files changed, 73 insertions(+), 15 deletions(-)
 rename osal/{host => windows}/TmTcWinUdpBridge.cpp (54%)
 rename osal/{host => windows}/TmTcWinUdpBridge.h (88%)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index d8a39869..95910b02 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/TcUnixUdpPollingTask.h"
+#include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index d0c9517f..2549a4b7 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,10 +1,11 @@
-#include "../../osal/linux/TmTcUnixUdpBridge.h"
+#include "TmTcUnixUdpBridge.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
 #include <arpa/inet.h>
 
+
 TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 		object_id_t tcDestination, object_id_t tmStoreId, object_id_t tcStoreId,
 		uint16_t serverPort, uint16_t clientPort):
diff --git a/osal/host/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
similarity index 54%
rename from osal/host/TmTcWinUdpBridge.cpp
rename to osal/windows/TmTcWinUdpBridge.cpp
index 4bb9a3b1..c5902e88 100644
--- a/osal/host/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,6 +6,18 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     mutex = MutexFactory::instance()->createMutex();
 
+    // Initiates Winsock DLL.
+    WSAData wsaData;
+    WORD wVersionRequested = MAKEWORD(2, 2);
+    int err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0) {
+        /* Tell the user that we could not find a usable */
+        /* Winsock DLL.                                  */
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
+                "WSAStartup failed with error: " << err << std::endl;
+        return;
+    }
+
     uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
     if(serverPort != 0xFFFF) {
         setServerPort = serverPort;
@@ -45,8 +57,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     int result = bind(serverSocket,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
-    if(result == -1) {
-        sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
+    if(result != 0) {
+        sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
         handleBindError();
@@ -54,12 +66,8 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     }
 }
 
-TmTcWinUdpBridge::~TmTcWinUdpBridge() {}
-
-void TmTcWinUdpBridge::handleSocketError() {
-}
-
-void TmTcWinUdpBridge::handleBindError() {
+TmTcWinUdpBridge::~TmTcWinUdpBridge() {
+    WSACleanup();
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
@@ -69,5 +77,52 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
 }
 
-void TmTcWinUdpBridge::handleSendError() {
+void TmTcWinUdpBridge::handleSocketError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
 }
+
+void TmTcWinUdpBridge::handleBindError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+void TmTcWinUdpBridge::handleSendError() {
+    int errCode = WSAGetLastError();
+    switch(errCode) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
+                << errCode << std::endl;
+        break;
+    }
+    }
+}
+
+#endif
diff --git a/osal/host/TmTcWinUdpBridge.h b/osal/windows/TmTcWinUdpBridge.h
similarity index 88%
rename from osal/host/TmTcWinUdpBridge.h
rename to osal/windows/TmTcWinUdpBridge.h
index 8e6bb0fd..8188039c 100644
--- a/osal/host/TmTcWinUdpBridge.h
+++ b/osal/windows/TmTcWinUdpBridge.h
@@ -1,14 +1,15 @@
-#ifndef FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
-#define FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_
+#ifndef FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
+#define FSFW_OSAL_WINDOWS_TMTCWINUDPBRIDGE_H_
 
 #include "../../tmtcservices/TmTcBridge.h"
-#include <Winsock.h>
+
+#include <winsock2.h>
+#include <windows.h>
 
 class TmTcWinUdpBridge: public TmTcBridge {
     friend class TcWinUdpPollingTask;
 public:
     // The ports chosen here should not be used by any other process.
-    // List of used ports on Linux: /etc/services
     static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
     static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
 
@@ -45,3 +46,4 @@ private:
 
 
 #endif /* FSFW_OSAL_HOST_TMTCWINUDPBRIDGE_H_ */
+

From 3e0819f954d3eb6b6fb090f7b0d157d867f4ed6c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 11:48:32 +0200
Subject: [PATCH 0727/1292] some bugfixes

---
 fsfw.mk                              |   4 +
 osal/host/PeriodicTask.cpp           |   4 +
 osal/host/QueueMapManager.cpp        |  14 ++-
 osal/windows/TcWinUdpPollingTask.cpp | 147 +++++++++++++++++++++++++++
 osal/windows/TcWinUdpPollingTask.h   |  67 ++++++++++++
 osal/windows/TmTcWinUdpBridge.cpp    |   4 +-
 6 files changed, 234 insertions(+), 6 deletions(-)
 create mode 100644 osal/windows/TcWinUdpPollingTask.cpp
 create mode 100644 osal/windows/TcWinUdpPollingTask.h

diff --git a/fsfw.mk b/fsfw.mk
index a548b6a8..b8e9ff98 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -37,6 +37,10 @@ else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
+ifeq ($(OS),Windows_NT)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+endif
+
 else
 $(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
 endif
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 3157ffb7..f7807a17 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -96,6 +96,10 @@ void PeriodicTask::taskFunctionality() {
 	};
 	auto nextStartTime{ currentStartTime };
 
+	for (const auto& object: objectList) {
+	    object->initializeAfterTaskCreation();
+	}
+
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		if(terminateThread.load()) {
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 1b2094e9..c3d94584 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -44,9 +44,17 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-		sif::warning << "QueueMapManager::getQueueHandle: The ID" <<
-				messageQueueId << " does not exists in the map" << std::endl;
-		return nullptr;
+	    if(messageQueueId == MessageQueueIF::NO_QUEUE) {
+	        sif::error << "QueueMapManager::getQueueHandle: Configuration"
+	                << " error, NO_QUEUE was passed to this function!"
+	                << std::endl;
+	    }
+	    else {
+	        sif::warning << "QueueMapManager::getQueueHandle: The ID "
+	                << messageQueueId << " does not exists in the map."
+	                << std::endl;
+	    }
+	    return nullptr;
 	}
 }
 
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
new file mode 100644
index 00000000..661d596a
--- /dev/null
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -0,0 +1,147 @@
+#include "TcWinUdpPollingTask.h"
+#include "../../globalfunctions/arrayprinter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <winsock2.h>
+#include <windows.h>
+
+TcWinUdpPollingTask::TcWinUdpPollingTask(object_id_t objectId,
+		object_id_t tmtcUnixUdpBridge, size_t frameSize,
+		double timeoutSeconds): SystemObject(objectId),
+		tmtcBridgeId(tmtcUnixUdpBridge) {
+	if(frameSize > 0) {
+		this->frameSize = frameSize;
+	}
+	else {
+		this->frameSize = DEFAULT_MAX_FRAME_SIZE;
+	}
+
+	// Set up reception buffer with specified frame size.
+	// For now, it is assumed that only one frame is held in the buffer!
+	receptionBuffer.reserve(this->frameSize);
+	receptionBuffer.resize(this->frameSize);
+
+	if(timeoutSeconds == -1) {
+		receptionTimeout = DEFAULT_TIMEOUT;
+	}
+	else {
+		receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
+	}
+}
+
+TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
+
+ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
+	// Poll for new UDP datagrams in permanent loop.
+	while(1) {
+		//! Sender Address is cached here.
+		struct sockaddr_in senderAddress;
+		int senderAddressSize = sizeof(senderAddress);
+		ssize_t bytesReceived = recvfrom(serverUdpSocket,
+				reinterpret_cast<char*>(receptionBuffer.data()), frameSize,
+				receptionFlags, reinterpret_cast<sockaddr*>(&senderAddress),
+				&senderAddressSize);
+		if(bytesReceived == SOCKET_ERROR) {
+			// handle error
+			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
+					" error." << std::endl;
+			handleReadError();
+			continue;
+		}
+		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
+				<< " bytes received" << std::endl;
+
+		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
+		if(result != HasReturnvaluesIF::RETURN_FAILED) {
+
+		}
+		tmtcBridge->registerCommConnect();
+		tmtcBridge->checkAndSetClientAddress(senderAddress);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
+	store_address_t storeId;
+	ReturnValue_t result = tcStore->addData(&storeId,
+			receptionBuffer.data(), bytesRead);
+	// arrayprinter::print(receptionBuffer.data(), bytesRead);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
+				"storage failed" << std::endl;
+		sif::error << "Packet size: " << bytesRead << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	TmTcMessage message(storeId);
+
+	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "Serial Polling: Sending message to queue failed"
+				<< std::endl;
+		tcStore->deleteData(storeId);
+	}
+	return result;
+}
+
+ReturnValue_t TcWinUdpPollingTask::initialize() {
+	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	if (tcStore == nullptr) {
+		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
+	if(tmtcBridge == nullptr) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
+				" TMTC bridge object!" << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+
+	serverUdpSocket = tmtcBridge->serverSocket;
+	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
+	//        << serverUdpSocket << std::endl;
+
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TcWinUdpPollingTask::initializeAfterTaskCreation() {
+	// Initialize the destination after task creation. This ensures
+	// that the destination has already been set in the TMTC bridge.
+	targetTcDestination = tmtcBridge->getRequestQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
+	DWORD timeoutMs = timeoutSeconds * 1000.0;
+	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
+			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
+	if(result == -1) {
+		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+				"receive timeout failed with " << strerror(errno) << std::endl;
+	}
+}
+
+void TcWinUdpPollingTask::handleReadError() {
+    int error = WSAGetLastError();
+    switch(error) {
+    case(WSANOTINITIALISED): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+                << "WSAStartup(...) call " << "necessary" << std::endl;
+        break;
+    }
+    case(WSAEFAULT): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+                << "Bad address " << std::endl;
+        Sleep(2000);
+        break;
+    }
+    default: {
+        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+                << error << std::endl;
+        break;
+    }
+    }
+}
diff --git a/osal/windows/TcWinUdpPollingTask.h b/osal/windows/TcWinUdpPollingTask.h
new file mode 100644
index 00000000..50d39d25
--- /dev/null
+++ b/osal/windows/TcWinUdpPollingTask.h
@@ -0,0 +1,67 @@
+#ifndef FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+#define FSFW_OSAL_WINDOWS_TCSOCKETPOLLINGTASK_H_
+
+#include "TmTcWinUdpBridge.h"
+#include "../../objectmanager/SystemObject.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+
+#include <vector>
+
+/**
+ * @brief 	This class can be used to implement the polling of a Unix socket,
+ * 			using UDP for now.
+ * @details
+ * The task will be blocked while the specified number of bytes has not been
+ * received, so TC reception is handled inside a separate task.
+ * This class caches the IP address of the sender. It is assumed there
+ * is only one sender for now.
+ */
+class TcWinUdpPollingTask: public SystemObject,
+		public ExecutableObjectIF {
+	friend class TmTcWinUdpBridge;
+public:
+	static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
+	//! 0.5  default milliseconds timeout for now.
+	static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
+
+	TcWinUdpPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
+			size_t frameSize = 0, double timeoutSeconds = -1);
+	virtual~ TcWinUdpPollingTask();
+
+	/**
+	 * Turn on optional timeout for UDP polling. In the default mode,
+	 * the receive function will block until a packet is received.
+	 * @param timeoutSeconds
+	 */
+	void setTimeout(double timeoutSeconds);
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+	StorageManagerIF* tcStore = nullptr;
+
+private:
+	//! TMTC bridge is cached.
+	object_id_t tmtcBridgeId = objects::NO_OBJECT;
+	TmTcWinUdpBridge* tmtcBridge = nullptr;
+	MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
+	//! Reception flags: https://linux.die.net/man/2/recvfrom.
+	int receptionFlags = 0;
+
+	//! Server socket, which is member of TMTC bridge and is assigned in
+	//! constructor
+	SOCKET serverUdpSocket = 0;
+
+	std::vector<uint8_t> receptionBuffer;
+
+	size_t frameSize = 0;
+	timeval receptionTimeout;
+
+	ReturnValue_t handleSuccessfullTcRead(size_t bytesRead);
+	void handleReadError();
+};
+
+#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index c5902e88..2ea6ae97 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -31,7 +31,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     // Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    if(serverSocket != 0) {
+    if(serverSocket == INVALID_SOCKET) {
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
         handleSocketError();
@@ -62,7 +62,6 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
         handleBindError();
-        return;
     }
 }
 
@@ -125,4 +124,3 @@ void TmTcWinUdpBridge::handleSendError() {
     }
 }
 
-#endif

From 7774434d7a211f212ec376bb8296d6aa9f63aab7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 11:58:12 +0200
Subject: [PATCH 0728/1292] windows sockets working

---
 osal/windows/TmTcWinUdpBridge.cpp | 53 ++++++++++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 2ea6ae97..3e273507 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/ipc/MutexHelper.h>
 #include "TmTcWinUdpBridge.h"
 
 TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
@@ -70,10 +71,43 @@ TmTcWinUdpBridge::~TmTcWinUdpBridge() {
 }
 
 ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+    int flags = 0;
+
+    //clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+    //clientAddressLen = sizeof(serverAddress);
+
+//  char ipAddress [15];
+//  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+    ssize_t bytesSent = sendto(serverSocket,
+            reinterpret_cast<const char*>(data), dataLen, flags,
+            reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
+    if(bytesSent == SOCKET_ERROR) {
+        sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
+                << std::endl;
+        handleSendError();
+    }
+//  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
+//          " sent." << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in clientAddress) {
+void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+    MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+//  char ipAddress [15];
+//  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
+//          &newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+//  sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
+//          &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+
+    // Set new IP address if it has changed.
+    if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
+        clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
+        clientAddressLen = sizeof(clientAddress);
+    }
 }
 
 void TmTcWinUdpBridge::handleSocketError() {
@@ -85,6 +119,10 @@ void TmTcWinUdpBridge::handleSocketError() {
         break;
     }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+         */
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
         break;
@@ -101,6 +139,10 @@ void TmTcWinUdpBridge::handleBindError() {
         break;
     }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
         break;
@@ -116,7 +158,16 @@ void TmTcWinUdpBridge::handleSendError() {
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
+    case(WSAEADDRNOTAVAIL): {
+        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+                << "Check target address. " << std::endl;
+        break;
+    }
     default: {
+        /*
+        https://docs.microsoft.com/en-us/windows/win32/winsock/
+        windows-sockets-error-codes-2
+        */
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
         break;

From 8db9a4a1911862a359d6c9a27569fb4e640670a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:00:57 +0200
Subject: [PATCH 0729/1292] some minor tweaks

---
 osal/windows/TcWinUdpPollingTask.cpp | 9 +++++----
 osal/windows/TmTcWinUdpBridge.cpp    | 3 +--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 661d596a..7b54bb2c 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -33,7 +33,7 @@ TcWinUdpPollingTask::~TcWinUdpPollingTask() {}
 
 ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 	// Poll for new UDP datagrams in permanent loop.
-	while(1) {
+	while(true) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
 		int senderAddressSize = sizeof(senderAddress);
@@ -48,8 +48,8 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 			handleReadError();
 			continue;
 		}
-		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
-				<< " bytes received" << std::endl;
+		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
+		//		<< " bytes received" << std::endl;
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -135,7 +135,6 @@ void TcWinUdpPollingTask::handleReadError() {
     case(WSAEFAULT): {
         sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
-        Sleep(2000);
         break;
     }
     default: {
@@ -144,4 +143,6 @@ void TcWinUdpPollingTask::handleReadError() {
         break;
     }
     }
+    // to prevent spam.
+    Sleep(1000);
 }
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 3e273507..7e283c2a 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -41,8 +41,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
 
     serverAddress.sin_family = AF_INET;
 
-    // Accept packets from any interface.
-    //serverAddress.sin_addr.s_addr = inet_addr("127.73.73.0");
+    // Accept packets from any interface. (potentially insecure).
     serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
     serverAddress.sin_port = htons(setServerPort);
     serverAddressLen = sizeof(serverAddress);

From efa41b29aa2fb45180d7bd6c2805a8ced32378fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:16:43 +0200
Subject: [PATCH 0730/1292] added informative comment

---
 fsfw.mk | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/fsfw.mk b/fsfw.mk
index b8e9ff98..c5847554 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -31,14 +31,23 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
 # select the OS
 ifeq ($(OS_FSFW),rtems)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
+
 else ifeq ($(OS_FSFW),linux)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
+
 else ifeq ($(OS_FSFW),freeRTOS)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
+
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 ifeq ($(OS),Windows_NT)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
+else
+# For now, the linux UDP bridge sources needs to be included manually by upper makefile
+# for host OS because we can't be sure the OS is linux.
+# Following lines can be used to do this:
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TcUnixUdpPollingTask.cpp
+# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TmTcUnixUdpBridge.cpp
 endif
 
 else

From ac2f6c5ed4dff00bf3ce3228896e393813998bf7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 12:59:59 +0200
Subject: [PATCH 0731/1292] minor improvements

---
 osal/linux/TcUnixUdpPollingTask.cpp | 1 +
 osal/linux/TmTcUnixUdpBridge.cpp    | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 95910b02..670ba804 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -120,6 +120,7 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	}
 }
 
+// TODO: sleep after error detection to prevent spam
 void TcUnixUdpPollingTask::handleReadError() {
 	switch(errno) {
 	case(EAGAIN): {
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 2549a4b7..b55291b3 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -101,8 +101,8 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 	}
 }
 
-void TmTcUnixUdpBridge::handleSocketError() {
 
+void TmTcUnixUdpBridge::handleSocketError() {
 	// See: https://man7.org/linux/man-pages/man2/socket.2.html
 	switch(errno) {
 	case(EACCES):
@@ -163,7 +163,8 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
-		sif::error << "Error: " << strerror(errno) << std::endl;
+		sif::error << "TmTcUnixBridge::handleSendError: "
+		        << strerror(errno) << std::endl;
 	}
 }
 

From 50ae50d28679e620d0a60392f5b557ae4875995d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 14:01:41 +0200
Subject: [PATCH 0732/1292] removed pool raw access helper

---
 datapool/PoolRawAccessHelper.cpp | 181 -------------------------------
 datapool/PoolRawAccessHelper.h   | 105 ------------------
 2 files changed, 286 deletions(-)
 delete mode 100644 datapool/PoolRawAccessHelper.cpp
 delete mode 100644 datapool/PoolRawAccessHelper.h

diff --git a/datapool/PoolRawAccessHelper.cpp b/datapool/PoolRawAccessHelper.cpp
deleted file mode 100644
index 5a6827b6..00000000
--- a/datapool/PoolRawAccessHelper.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-#include "PoolRawAccessHelper.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../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;
-}
diff --git a/datapool/PoolRawAccessHelper.h b/datapool/PoolRawAccessHelper.h
deleted file mode 100644
index 6ff3e955..00000000
--- a/datapool/PoolRawAccessHelper.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
-#define FSFW_DATAPOOL_POOLRAWACCESSHELPER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../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_ */

From 673af264724261873f78079e72e5fc109fbf2f63 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 14:57:05 +0200
Subject: [PATCH 0733/1292] rework/restructuring

---
 datapool/DataSetIF.h                         | 7 +++----
 datapool/PoolDataSetIF.h                     | 4 ++++
 datapool/PoolVarList.h                       | 9 +++++----
 datapool/PoolVariableIF.h                    | 6 +++---
 {datapool => datapoolglob}/ControllerSet.cpp | 2 +-
 {datapool => datapoolglob}/ControllerSet.h   | 6 +++---
 datapoollocal/LocalDataPoolManager.cpp       | 6 +++---
 datapoollocal/LocalDataPoolManager.h         | 8 ++++----
 housekeeping/HousekeepingPacketDownlink.h    | 5 +++--
 9 files changed, 29 insertions(+), 24 deletions(-)
 rename {datapool => datapoolglob}/ControllerSet.cpp (79%)
 rename {datapool => datapoolglob}/ControllerSet.h (59%)

diff --git a/datapool/DataSetIF.h b/datapool/DataSetIF.h
index b51da3a4..a6634a5c 100644
--- a/datapool/DataSetIF.h
+++ b/datapool/DataSetIF.h
@@ -1,5 +1,5 @@
-#ifndef DATASETIF_H_
-#define DATASETIF_H_
+#ifndef FSFW_DATAPOOL_DATASETIF_H_
+#define FSFW_DATAPOOL_DATASETIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Clock.h"
@@ -34,7 +34,6 @@ public:
 	 */
 	virtual ~DataSetIF() {}
 
-
 	/**
 	 * @brief	This operation provides a method to register local data pool
 	 * 			variables to register in a data set by passing itself
@@ -45,4 +44,4 @@ public:
 	virtual uint16_t getFillCount() const = 0;
 };
 
-#endif /* FRAMEWORK_DATAPOOL_DATASETIF_H_ */
+#endif /* FSFW_DATAPOOL_DATASETIF_H_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 78c05d43..aa45fa54 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -3,6 +3,10 @@
 
 #include "DataSetIF.h"
 
+/**
+ * @brief   Extendes the DataSetIF by adding abstract functions to lock
+ *          and unlock a data pool and read/commit semantics.
+ */
 class PoolDataSetIF: public DataSetIF {
 public:
     virtual~ PoolDataSetIF() {};
diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h
index 1c8a7be4..0b2b0f06 100644
--- a/datapool/PoolVarList.h
+++ b/datapool/PoolVarList.h
@@ -1,5 +1,5 @@
-#ifndef POOLVARLIST_H_
-#define POOLVARLIST_H_
+#ifndef FSFW_DATAPOOL_POOLVARLIST_H_
+#define FSFW_DATAPOOL_POOLVARLIST_H_
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
@@ -8,7 +8,8 @@ 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_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 2aa269dd..cd15f744 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
-#define FRAMEWORK_DATAPOOL_POOLVARIABLEIF_H_
+#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
+#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
@@ -96,4 +96,4 @@ protected:
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
 
-#endif /* POOLVARIABLEIF_H_ */
+#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */
diff --git a/datapool/ControllerSet.cpp b/datapoolglob/ControllerSet.cpp
similarity index 79%
rename from datapool/ControllerSet.cpp
rename to datapoolglob/ControllerSet.cpp
index 4055158b..54fc6e8c 100644
--- a/datapool/ControllerSet.cpp
+++ b/datapoolglob/ControllerSet.cpp
@@ -1,4 +1,4 @@
-#include "../datapool/ControllerSet.h"
+#include <fsfw/datapoolglob/ControllerSet.h>
 
 ControllerSet::ControllerSet() {
 
diff --git a/datapool/ControllerSet.h b/datapoolglob/ControllerSet.h
similarity index 59%
rename from datapool/ControllerSet.h
rename to datapoolglob/ControllerSet.h
index 43e1cbf2..5da11397 100644
--- a/datapool/ControllerSet.h
+++ b/datapoolglob/ControllerSet.h
@@ -1,5 +1,5 @@
-#ifndef CONTROLLERSET_H_
-#define CONTROLLERSET_H_
+#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
+#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
 
 #include "../datapoolglob/GlobalDataSet.h"
 
@@ -12,4 +12,4 @@ public:
 	void setInvalid();
 };
 
-#endif /* CONTROLLERSET_H_ */
+#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 87a0a3cb..c84b2c69 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,5 @@
-#include "../datapoollocal/LocalDataPoolManager.h"
-#include "../datapoollocal/LocalDataSet.h"
+#include "LocalDataPoolManager.h"
+#include "LocalPoolDataSetBase.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -185,7 +185,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	sif::info << "hk gen called" << std::endl;
+
 	store_address_t storeId;
 	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
 	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c851978c..c6567c80 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,14 +1,14 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
+#include "HasLocalDataPoolIF.h"
+
 #include "../housekeeping/HousekeepingPacketDownlink.h"
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../datapool/DataSetIF.h"
+#include "../datapool/PoolEntry.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../ipc/MutexIF.h"
-
-#include "../housekeeping/HousekeepingMessage.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexHelper.h"
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index bee0bac1..ee531bae 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -1,7 +1,8 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
-#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 
 #include "../datapoollocal/LocalPoolDataSetBase.h"
+
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../storagemanager/StorageManagerIF.h"

From 26cbcdbff058a542a30055ba4104b18cb16353a7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 15:21:02 +0200
Subject: [PATCH 0734/1292] removed comment

---
 datapoollocal/SharedLocalDataSet.h | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index b1f9aa3d..2e5a76fa 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,13 +6,6 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
-/**
- * Baseline question: If this dataset is shared, is there once instance
- * shared among many objects or multiple instances? Maybe be flexible
- * and provide both ways? Sharing one instance requires a mutex lock.
- * If there are multiple instances, it is not shared anymore, to be fair..
- * Then a regular local data set is sufficient.
- */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
@@ -28,5 +21,4 @@ private:
 };
 
 
-
 #endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */

From d99b100ace281a6a371e42ba15c8d260a27159ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 6 Sep 2020 18:46:56 +0200
Subject: [PATCH 0735/1292] debug output removed

---
 storagemanager/ConstStorageAccessor.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 4ada7f80..6235ac40 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -14,7 +14,6 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		sif::debug << "deleting store data" << std::endl;
 		store->deleteData(storeId);
 	}
 }

From e085deb2355e68e4456143988964a152ff96134b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 7 Sep 2020 15:23:27 +0200
Subject: [PATCH 0736/1292] fifo fix

---
 container/FIFO.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/container/FIFO.h b/container/FIFO.h
index 19f763fc..5a66a334 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -25,6 +25,7 @@ public:
 	 * @param other
 	 */
 	FIFO(const FIFO& other): FIFOBase<T>(other) {
+		this->fifoArray = other.fifoArray;
 		this->setContainer(fifoArray.data());
 	}
 

From d43ef479b6191923a60b308fa9a3efa7fd1bd249 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:02:58 +0200
Subject: [PATCH 0737/1292] assignment operator added

---
 container/DynamicFIFO.h | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index abb53330..86d43f7d 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -27,14 +27,27 @@ public:
 
 	/**
 	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong.
+	 * 	        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;
 };

From cefac2db0b9f2672039e83bce27d38a92cdb7933 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:03:28 +0200
Subject: [PATCH 0738/1292] assignment operator added

---
 container/FIFO.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/container/FIFO.h b/container/FIFO.h
index 5a66a334..70113852 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -29,6 +29,17 @@ public:
 		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;
 };

From 18e6de7d6ba75326262918d4bd0dde93e5c6fa0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:04:43 +0200
Subject: [PATCH 0739/1292] added compile time check

---
 container/FixedMap.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 3da65784..3b09fa3b 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -14,6 +14,10 @@
  */
 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);

From db3e32655d70fc4b56c69325faee75449190bf01 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:05:26 +0200
Subject: [PATCH 0740/1292] changes taken over from master

---
 tmtcservices/CommandingServiceBase.h | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 29ab967a..23b08acf 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -5,9 +5,9 @@
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "AcceptsTelecommandsIF.h"
 
-#include "../tmtcservices/VerificationReporter.h"
+#include "VerificationReporter.h"
 #include "../ipc/CommandMessage.h"
 #include "../container/FixedMap.h"
 #include "../container/FIFO.h"
@@ -211,8 +211,7 @@ protected:
 
 	virtual void doPeriodicOperation();
 
-
-	struct CommandInfo {
+	struct CommandInfo: public SerializeIF{
 		struct tcInfo {
 			uint8_t ackFlags;
 			uint16_t tcPacketId;
@@ -225,6 +224,20 @@ protected:
 		Command_t command;
 		object_id_t objectId;
 		FIFO<store_address_t, 3> fifo;
+
+		virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
+					size_t maxSize, Endianness streamEndianness) const override{
+			return HasReturnvaluesIF::RETURN_FAILED;
+		};
+
+		virtual size_t getSerializedSize() const override {
+			return 0;
+		};
+
+		virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+				Endianness streamEndianness) override{
+			return HasReturnvaluesIF::RETURN_FAILED;
+		};
 	};
 
 	using CommandMapIter = FixedMap<MessageQueueId_t,

From 224ea3914a08710227f057703b64c8a0aaf4d240 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:15:13 +0200
Subject: [PATCH 0741/1292] deleted file not needed anymore

---
 container/IsDerivedFrom.h | 50 ---------------------------------------
 1 file changed, 50 deletions(-)
 delete mode 100644 container/IsDerivedFrom.h

diff --git a/container/IsDerivedFrom.h b/container/IsDerivedFrom.h
deleted file mode 100644
index 8142a378..00000000
--- a/container/IsDerivedFrom.h
+++ /dev/null
@@ -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_ */

From f663de2418ae1be1064ab4acbf132651c0e5b509 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:17:38 +0200
Subject: [PATCH 0742/1292] taken over changes from master

---
 serialize/SerializeAdapter.h | 116 +++++++++++++++++++++++++----------
 1 file changed, 83 insertions(+), 33 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index 24f6111e..a05b1791 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -1,47 +1,92 @@
-#ifndef FSFW_SERIALIZE_SERIALIZEADAPTER_H_
-#define FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#ifndef _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
+#define _FSFW_SERIALIZE_SERIALIZEADAPTER_H_
 
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "EndianConverter.h"
 #include "SerializeIF.h"
+#include <cstddef>
+#include <type_traits>
 
-#include "../container/IsDerivedFrom.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-
- /**
- * @brief These adapters provides an interface to use the SerializeIF functions
- * 		  with arbitrary template objects to facilitate and simplify the
- * 		  serialization of classes with different multiple different data types
- * 		  into buffers and vice-versa.
- * @details
- * The correct serialization or deserialization function is chosen at
- * compile time with template type deduction.
- *
- * @ingroup serialize
+/**
+ * \ingroup serialize
  */
+
 class SerializeAdapter {
 public:
+	/***
+	 * This function can be used to serialize a trivial copy-able type or a child of SerializeIF.
+	 * The right template to be called is determined in the function itself.
+	 * For objects of non trivial copy-able type this function is almost never called by the user directly.
+	 * Instead helpers for specific types like SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
+	 *
+	 * @param[in] object Object to serialize, the used type is deduced from this pointer
+	 * @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
+	 * @param[in/out] size Size of current written buffer. Will be incremented by the function.
+	 * @param[in] maxSize Max size of Buffer
+	 * @param[in] streamEndianness Endianness of serialized element as in according to SerializeIF::Endianness
+	 * @return
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c RETURN_FAILED Generic Error
+	 * 		- @c RETURN_OK Successful serialization
+	 */
 	template<typename T>
 	static ReturnValue_t serialize(const T *object, uint8_t **buffer,
-			size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+			size_t *size, size_t maxSize,
+			SerializeIF::Endianness streamEndianness) {
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.serialize(object, buffer, size, maxSize,
 				streamEndianness);
 	}
+	/**
+	 * Function to return the serialized size of the object in the pointer.
+	 * May be a trivially copy-able object or a Child of SerializeIF
+	 *
+	 * @param object Pointer to Object
+	 * @return Serialized size of object
+	 */
 	template<typename T>
-	static uint32_t getSerializedSize(const T *object) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+	static size_t getSerializedSize(const T *object){
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.getSerializedSize(object);
 	}
+	/**
+	 * @brief
+	 * Deserializes a object from a given buffer of given size.
+	 * Object Must be trivially copy-able or a child of SerializeIF.
+	 *
+	 * @details
+	 * Buffer will be moved to the current read location. Size will be decreased by the function.
+	 *
+	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+	 * @return
+	 * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+	 * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+	 * 	- @c RETURN_FAILED Generic Error
+	 * 	- @c RETURN_OK Successful deserialization
+	 */
 	template<typename T>
 	static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
 			size_t *size, SerializeIF::Endianness streamEndianness) {
-		InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
 		return adapter.deSerialize(object, buffer, size, streamEndianness);
 	}
 private:
-	template<typename T, int>
-	class InternalSerializeAdapter {
+	/**
+	 * Internal template to deduce the right function calls at compile time
+	 */
+	template<typename T, bool> class InternalSerializeAdapter;
+
+	/**
+	 * Template to be used if T is not a child of SerializeIF
+	 *
+	 * @tparam T T must be trivially_copyable
+	 */
+	template<typename T>
+	class InternalSerializeAdapter<T, false> {
+		static_assert (std::is_trivially_copyable<T>::value,
+				"If a type needs to be serialized it must be a child of SerializeIF or trivially copy-able");
 	public:
 		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
 				size_t *size, size_t max_size,
@@ -50,8 +95,9 @@ private:
 			if (size == nullptr) {
 				size = &ignoredSize;
 			}
-			//TODO check integer overflow of *size
-			if (sizeof(T) + *size <= max_size) {
+			//Check remaining size is large enough and check integer overflow of *size
+			size_t newSize = sizeof(T) + *size;
+			if ((newSize <= max_size) and (newSize > *size)) {
 				T tmp;
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
@@ -65,7 +111,7 @@ private:
 					tmp = *object;
 					break;
 				}
-				std::memcpy(*buffer, &tmp, sizeof(T));
+				memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
 				(*buffer) += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -79,7 +125,7 @@ private:
 			T tmp;
 			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-				std::memcpy(&tmp, *buffer, sizeof(T));
+				memcpy(&tmp, *buffer, sizeof(T));
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
 					*object = EndianConverter::convertBigEndian<T>(tmp);
@@ -103,14 +149,18 @@ private:
 		uint32_t getSerializedSize(const T *object) {
 			return sizeof(T);
 		}
-
 	};
 
+	/**
+	 * Template for objects that inherit from SerializeIF
+	 *
+	 * @tparam T A child of SerializeIF
+	 */
 	template<typename T>
-	class InternalSerializeAdapter<T, 1> {
+	class InternalSerializeAdapter<T, true> {
 	public:
-		ReturnValue_t serialize(const T *object, uint8_t **buffer,
-				size_t *size, size_t max_size,
+		ReturnValue_t serialize(const T *object, uint8_t **buffer, size_t *size,
+				size_t max_size,
 				SerializeIF::Endianness streamEndianness) const {
 			size_t ignoredSize = 0;
 			if (size == nullptr) {
@@ -118,7 +168,7 @@ private:
 			}
 			return object->serialize(buffer, size, max_size, streamEndianness);
 		}
-		uint32_t getSerializedSize(const T *object) const {
+		size_t getSerializedSize(const T *object) const {
 			return object->getSerializedSize();
 		}
 
@@ -129,4 +179,4 @@ private:
 	};
 };
 
-#endif /* SERIALIZEADAPTER_H_ */
+#endif /* _FSFW_SERIALIZE_SERIALIZEADAPTER_H_ */

From fd09774fc3577eb3993759d2473112796c87a0cb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:18:45 +0200
Subject: [PATCH 0743/1292] serialize if update

---
 serialize/SerializeIF.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index 3c0540f9..a701fe53 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,7 +2,7 @@
 #define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
+#include <stddef.h>
 
 /**
  * @defgroup serialize Serialization
@@ -10,10 +10,7 @@
  */
 
 /**
- * @brief 	Translation of objects into data streams and from data streams.
- * @details
- * Also provides options to convert from/to data with different endianness.
- * variables.
+ * Translation of objects into data streams and from data streams.
  * @ingroup serialize
  */
 class SerializeIF {
@@ -46,7 +43,7 @@ public:
 	 * @param[in] maxSize The size of the buffer that is allowed to be used for serialize.
 	 * @param[in] streamEndianness Endianness of the serialized data according to SerializeIF::Endianness
 	 * @return
-	 * 		- @¢ BUFFER_TOO_SHORT The given buffer in is too short
+	 * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
 	 * 		- @c RETURN_FAILED Generic error
 	 * 		- @c RETURN_OK Successful serialization
 	 */

From bbc73a6aaf5d607aca25c04b2bc59a1f7d4b031c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:25:29 +0200
Subject: [PATCH 0744/1292] taken over serialize adapter changes

---
 serialize/SerializeAdapter.h | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h
index a05b1791..e6cd247e 100644
--- a/serialize/SerializeAdapter.h
+++ b/serialize/SerializeAdapter.h
@@ -7,17 +7,26 @@
 #include <cstddef>
 #include <type_traits>
 
-/**
- * \ingroup serialize
+ /**
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
+ * @details
+ * The correct serialization or deserialization function is chosen at
+ * compile time with template type deduction.
+ *
+ * @ingroup serialize
  */
-
 class SerializeAdapter {
 public:
 	/***
-	 * This function can be used to serialize a trivial copy-able type or a child of SerializeIF.
+	 * This function can be used to serialize a trivial copy-able type or a
+	 * child of SerializeIF.
 	 * The right template to be called is determined in the function itself.
-	 * For objects of non trivial copy-able type this function is almost never called by the user directly.
-	 * Instead helpers for specific types like SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
+	 * For objects of non trivial copy-able type this function is almost never
+	 * called by the user directly. Instead helpers for specific types like
+	 * SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
 	 *
 	 * @param[in] object Object to serialize, the used type is deduced from this pointer
 	 * @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
@@ -86,7 +95,8 @@ private:
 	template<typename T>
 	class InternalSerializeAdapter<T, false> {
 		static_assert (std::is_trivially_copyable<T>::value,
-				"If a type needs to be serialized it must be a child of SerializeIF or trivially copy-able");
+				"If a type needs to be serialized it must be a child of "
+				"SerializeIF or trivially copy-able");
 	public:
 		static ReturnValue_t serialize(const T *object, uint8_t **buffer,
 				size_t *size, size_t max_size,
@@ -95,7 +105,8 @@ private:
 			if (size == nullptr) {
 				size = &ignoredSize;
 			}
-			//Check remaining size is large enough and check integer overflow of *size
+			// Check remaining size is large enough and check integer
+			// overflow of *size
 			size_t newSize = sizeof(T) + *size;
 			if ((newSize <= max_size) and (newSize > *size)) {
 				T tmp;
@@ -111,7 +122,7 @@ private:
 					tmp = *object;
 					break;
 				}
-				memcpy(*buffer, &tmp, sizeof(T));
+				std::memcpy(*buffer, &tmp, sizeof(T));
 				*size += sizeof(T);
 				(*buffer) += sizeof(T);
 				return HasReturnvaluesIF::RETURN_OK;
@@ -125,7 +136,7 @@ private:
 			T tmp;
 			if (*size >= sizeof(T)) {
 				*size -= sizeof(T);
-				memcpy(&tmp, *buffer, sizeof(T));
+				std::memcpy(&tmp, *buffer, sizeof(T));
 				switch (streamEndianness) {
 				case SerializeIF::Endianness::BIG:
 					*object = EndianConverter::convertBigEndian<T>(tmp);

From 96e471add600b1829d08958e87b505d37e45a8e3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:51:11 +0200
Subject: [PATCH 0745/1292] merged fixed map changes

---
 container/FixedMap.h | 76 +++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 47 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 3b09fa3b..475d4091 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -1,23 +1,27 @@
-#ifndef FIXEDMAP_H_
-#define FIXEDMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDMAP_H_
+#define FSFW_CONTAINER_FIXEDMAP_H_
 
-#include "../container/ArrayList.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");
+	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);
@@ -55,29 +59,8 @@ public:
 		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;
-		}
-
-		// -> operator overloaded, can be used to access value
-		T *operator->() {
-			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
-
-		// 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;
-		}
-
-		// Alternative to access value, similar to std::map implementation
-		T second() {
-			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-		}
 	};
 
-
-
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}
@@ -90,16 +73,16 @@ public:
 		return _size;
 	}
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return FixedMap::KEY_ALREADY_EXISTS;
+			return KEY_ALREADY_EXISTS;
 		}
 		if (_size == theMap.maxSize()) {
-			return FixedMap::MAP_FULL;
+			return MAP_FULL;
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
-		if (storedValue != NULL) {
+		if (storedValue != nullptr) {
 			*storedValue = Iterator(&theMap[_size]);
 		}
 		++_size;
@@ -160,6 +143,15 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
 	void clear() {
 		_size = 0;
 	}
@@ -168,16 +160,6 @@ public:
 		return theMap.maxSize();
 	}
 
-
-	bool full() {
-		if(_size == theMap.maxSize()) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			size_t maxSize, Endianness streamEndianness) const {
 		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
@@ -226,4 +208,4 @@ public:
 
 };
 
-#endif /* FIXEDMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

From f35efa3cbe3926b1e47e8a62faeb81a6dae9a1ef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:52:00 +0200
Subject: [PATCH 0746/1292] taken over CSB changes

---
 tmtcservices/CommandingServiceBase.cpp | 76 +++++++++++++-------------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index e5a87f18..4cead0e9 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,9 +1,9 @@
 #include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
+#include "AcceptsTelemetryIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-#include "../tmtcservices/CommandingServiceBase.h"
-#include "../tmtcservices/TmTcMessage.h"
+#include "CommandingServiceBase.h"
+#include "TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -122,8 +122,8 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 
 
 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
-			&nextCommand, iter->objectId, &isStep);
+	ReturnValue_t result = handleReply(reply, iter->second.command, &iter->second.state,
+			&nextCommand, iter->second.objectId, &isStep);
 
 	/* If the child implementation does not implement special handling for
 	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
@@ -132,7 +132,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
 			(result == RETURN_FAILED or result == INVALID_REPLY)) {
 	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->command;
+	    failureParameter1 = iter->second.command;
 	}
 
 	switch (result) {
@@ -149,14 +149,14 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
-					result, ++iter->step, failureParameter1,
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
+					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -170,7 +170,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		CommandMapIter iter, CommandMessage* nextCommand,
 		CommandMessage* reply, bool& isStep) {
-	iter->command = nextCommand->getCommand();
+	iter->second.command = nextCommand->getCommand();
 
 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
@@ -185,14 +185,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, ++iter->step);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, 0);
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
 		}
 	}
@@ -200,16 +200,16 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult,
-					++iter->step, failureParameter1, failureParameter2);
+					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult,
+					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
-					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
-					iter->tcInfo.tcSequenceControl, sendResult, 0,
+					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
+					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@@ -248,7 +248,7 @@ void CommandingServiceBase::handleRequestQueue() {
 		iter = commandMap.find(queue);
 
 		if (iter != commandMap.end()) {
-			result = iter->fifo.insert(address);
+			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
 				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
 			}
@@ -316,11 +316,11 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
         CommandMapIter iter) {
     ReturnValue_t result = RETURN_OK;
     CommandMessage command;
-    iter->subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->subservice,
+    iter->second.subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->second.subservice,
             storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->state,
-            iter->objectId);
+            storedPacket->getApplicationDataSize(), &iter->second.state,
+            iter->second.objectId);
 
     ReturnValue_t sendResult = RETURN_OK;
 	switch (result) {
@@ -330,13 +330,13 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->uptimeOfStart);
-			iter->step = 0;
-			iter->subservice = storedPacket->getSubService();
-			iter->command = command.getCommand();
-			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->tcInfo.tcSequenceControl =
+			Clock::getUptime(&iter->second.uptimeOfStart);
+			iter->second.step = 0;
+			iter->second.subservice = storedPacket->getSubService();
+			iter->second.command = command.getCommand();
+			iter->second.tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
@@ -386,7 +386,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 
 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
-	if (iter->fifo.retrieve(&address) != RETURN_OK) {
+	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
 		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
@@ -412,10 +412,10 @@ void CommandingServiceBase::checkTimeout() {
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
-					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
 		}

From d9dcee3692aa548a94fc614529c954ffcd36b9fe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 15:55:56 +0200
Subject: [PATCH 0747/1292] array list changes taken over

---
 container/ArrayList.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 9f5e76de..bda60433 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -116,7 +116,11 @@ public:
             return tmp;
         }
 
-        T operator*() {
+        T& operator*() {
+            return *value;
+        }
+
+        const T& operator*() const {
             return *value;
         }
 
@@ -124,12 +128,13 @@ 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{
+        bool operator==(const typename ArrayList<T, count_t>::Iterator& other) const {
             return (value == other.value);
         }
 

From e57d4a11ae1db3b965a24e3de5efcae1ffc29781 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 16:01:05 +0200
Subject: [PATCH 0748/1292] fixed ordered multi map changes integrated

---
 container/FixedOrderedMultimap.h   | 13 +++++--------
 container/FixedOrderedMultimap.tpp | 15 +++------------
 2 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 41465c33..99825dc4 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
+#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
 #include "../container/ArrayList.h"
 #include <cstring>
@@ -39,10 +39,6 @@ public:
         Iterator();
         /** Initializes iterator to given entry */
         Iterator(std::pair<key_t, T> *pair);
-        /** Dereference operator can be used to get value */
-        T operator*();
-        /** Arrow operator can be used to get pointer to value */
-        T *operator->();
     };
 
     /** Iterator to start of map */
@@ -160,7 +156,8 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(&theMap[position], &theMap[position + 1],
+		std::memmove(static_cast<void*>(&theMap[position]),
+		        static_cast<void*>(&theMap[position + 1]),
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
@@ -168,4 +165,4 @@ private:
 
 #include "FixedOrderedMultimap.tpp"
 
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
+#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 74edbf9a..5b7b9ead 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -10,11 +10,6 @@ inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
         std::pair<key_t, T> *pair):
         ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline T FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator*() {
-    return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-}
-
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
 FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
@@ -33,11 +28,6 @@ inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
     return _size;
 }
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline T* FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::operator->() {
-    return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
-}
-
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
         size_t maxSize): theMap(maxSize), _size(0) {}
@@ -52,8 +42,9 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(
     uint32_t position = findNicePlace(key);
     // Compiler might emitt warning because std::pair is not a POD type (yet..)
     // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
-    // Should still work without issues.
-    std::memmove(&theMap[position + 1], &theMap[position],
+    // Circumvent warning by casting to void*
+    std::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;

From e4d95a4e0991e766725ddcb4158f26341c7d213e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 16:07:09 +0200
Subject: [PATCH 0749/1292] subsystem changes taken over

---
 subsystem/Subsystem.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 400ecc83..ba1f463c 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -545,7 +545,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); ++iter) {
 		if (iter.value->first == sequence) {
-			return iter->fallbackSequence;
+			return iter->second.fallbackSequence;
 		}
 	}
 	return -1;
@@ -554,7 +554,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); iter++) {
-		if (iter->fallbackSequence == SequenceId) {
+		if (iter->second.fallbackSequence == SequenceId) {
 			return true;
 		}
 	}

From d7bbd4b652ff2e2e4fe63485fe57e5622ec3d82a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 19:51:17 +0200
Subject: [PATCH 0750/1292] severla bugfixes, new periodic op divider added

---
 datapoollocal/LocalDataPoolManager.cpp       | 32 ++++++----
 datapoollocal/LocalDataPoolManager.h         |  5 +-
 globalfunctions/PeriodicOperationDivider.cpp | 34 +++++++++++
 globalfunctions/PeriodicOperationDivider.h   | 55 +++++++++++++++++
 housekeeping/HousekeepingPacketDownlink.h    | 64 +++++---------------
 5 files changed, 127 insertions(+), 63 deletions(-)
 create mode 100644 globalfunctions/PeriodicOperationDivider.cpp
 create mode 100644 globalfunctions/PeriodicOperationDivider.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c84b2c69..39434b5a 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -177,7 +177,8 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        float collectionInterval, MessageQueueId_t destination) {
+        /*float collectionInterval, bool reportingEnabled, */
+		bool forDownlink, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -187,10 +188,13 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, collectionInterval,
-	        dataSetToSerialize->getFillCount(), dataSetToSerialize);
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
+	HousekeepingPacketDownlink hkPacket(sid,/* reportingEnabled,
+			collectionInterval, dataSetToSerialize->getFillCount(), */
+			dataSetToSerialize);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
 	    return result;
 	}
 
@@ -213,17 +217,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
-        store_address_t *storeId) {
+        store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
     uint8_t* dataPtr = nullptr;
-    size_t serializedSize = 0;
     const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t  result = ipcStore->getFreeElement(storeId,
-            serializedSize, &dataPtr);
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            maxSize, &dataPtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
 
-    return hkPacket.serialize(&dataPtr, &serializedSize, maxSize,
+    if(forDownlink) {
+    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+    	            SerializeIF::Endianness::BIG);
+    }
+    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
             SerializeIF::Endianness::MACHINE);
 }
 
@@ -265,7 +273,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid);
+                receiver->dataId.dataSetSid, true
+				/*intervalToIntervalSeconds(receiver->isDiagnostics,
+				receiver->hkParameter.collectionIntervalTicks), true */);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c6567c80..552aaff7 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -110,7 +110,8 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-	        float collectionInterval = 0,
+			bool forDownlink,
+	        /*float collectionInterval, bool reportingEnabled, */
 	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
@@ -248,7 +249,7 @@ private:
 	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
-	        store_address_t *storeId);
+	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
 	uint32_t intervalSecondsToInterval(bool isDiagnostics,
 	        float collectionIntervalSeconds);
diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp
new file mode 100644
index 00000000..ad3b8bbd
--- /dev/null
+++ b/globalfunctions/PeriodicOperationDivider.cpp
@@ -0,0 +1,34 @@
+#include "PeriodicOperationDivider.h"
+
+
+PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
+		bool resetAutomatically): resetAutomatically(resetAutomatically),
+		counter(divider), divider(divider) {
+}
+
+bool PeriodicOperationDivider::checkAndIncrement() {
+	if(counter >= divider) {
+		if(resetAutomatically) {
+			counter = 0;
+		}
+		return true;
+	}
+	counter ++;
+	return false;
+}
+
+void PeriodicOperationDivider::resetCounter() {
+	counter = 0;
+}
+
+void PeriodicOperationDivider::setDivider(uint32_t newDivider) {
+	divider = newDivider;
+}
+
+uint32_t PeriodicOperationDivider::getCounter() const {
+	return counter;
+}
+
+uint32_t PeriodicOperationDivider::getDivider() const {
+	return divider;
+}
diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h
new file mode 100644
index 00000000..dd970fb8
--- /dev/null
+++ b/globalfunctions/PeriodicOperationDivider.h
@@ -0,0 +1,55 @@
+#ifndef FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
+#define FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_
+
+#include <cstdint>
+
+/**
+ * @brief	Lightweight helper class to facilitate periodic operation with
+ * 			decreased frequencies.
+ * @details
+ * This class is useful to perform operations which have to be performed
+ * with a reduced frequency, like debugging printouts in high periodic tasks
+ * or low priority operations.
+ */
+class PeriodicOperationDivider {
+public:
+	/**
+	 * Initialize with the desired divider and specify whether the internal
+	 * counter will be reset automatically.
+	 * @param divider
+	 * @param resetAutomatically
+	 */
+	PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
+
+	/**
+	 * Check whether operation is necessary.
+	 * If an operation is necessary and the class has been
+	 * configured to be reset automatically, the counter will be reset.
+	 * If not, the counter will be incremented.
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool checkAndIncrement();
+
+	/**
+	 * Can be used to reset the counter to 0 manually.
+	 */
+	void resetCounter();
+	uint32_t getCounter() const;
+
+	/**
+	 * Can be used to set a new divider value.
+	 * @param newDivider
+	 */
+	void setDivider(uint32_t newDivider);
+	uint32_t getDivider() const;
+private:
+	bool resetAutomatically = true;
+	uint32_t counter = 0;
+	uint32_t divider = 0;
+};
+
+
+
+#endif /* FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ */
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index ee531bae..0be1551d 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -2,8 +2,6 @@
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
 
 #include "../datapoollocal/LocalPoolDataSetBase.h"
-
-#include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../storagemanager/StorageManagerIF.h"
 
@@ -16,67 +14,33 @@
  */
 class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
 public:
-    HousekeepingPacketDownlink(sid_t sid, float collectionInterval, uint8_t
-            numberOfParameters, LocalPoolDataSetBase* dataSetPtr):
+    HousekeepingPacketDownlink(sid_t sid, /*bool reportingStatus,
+    		float collectionInterval, uint8_t numberOfParameters, */
+			LocalPoolDataSetBase* dataSetPtr):
             sourceId(sid.objectId), setId(sid.ownerSetId),
-            collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), hkData(dataSetPtr) {
+			/*reportingStatus(reportingStatus),
+			collectionInterval(collectionInterval),
+            numberOfParameters(numberOfParameters), */hkData(dataSetPtr) {
         setLinks();
     }
 
-    /**
-     * Helper functions which can be used to move HK data from the IPC store
-     * to the telemetry store. TODO: maybe not needed.
-     * @param formerStore
-     * @param storeId
-     * @param newStore
-     * @param newStoreId [out]
-     * @return
-     */
-    virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore,
-            store_address_t storeId, StorageManagerIF* newStore,
-            store_address_t* newStoreId) {
-        const uint8_t* dataPtr = nullptr;
-        size_t hkDataSize = 0;
-        ReturnValue_t result = formerStore->getData(storeId, &dataPtr,
-                &hkDataSize);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-
-        return newStore->addData(newStoreId, dataPtr, hkDataSize);
-    }
-
 private:
     void setLinks() {
         setStart(&sourceId);
         sourceId.setNext(&setId);
-        setId.setNext(&collectionInterval);
-        collectionInterval.setNext(&numberOfParameters);
-        numberOfParameters.setNext(&hkData);
+        setId.setNext(&hkData);
+        //setId.setNext(&reportingStatus);
+		//reportingStatus.setNext(&collectionInterval);
+        //collectionInterval.setNext(&numberOfParameters);
+        //numberOfParameters.setNext(&hkData);
     }
 
     SerializeElement<object_id_t> sourceId;
     SerializeElement<uint32_t> setId;
-    SerializeElement<float> collectionInterval;
-    SerializeElement<uint8_t> numberOfParameters;
+    //SerializeElement<uint8_t> reportingStatus;
+    //SerializeElement<float> collectionInterval;
+    //SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
 };
 
 #endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
-
-
-
-//    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-//                size_t maxSize, Endianness streamEndianness) const override {
-//        ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
-//                maxSize, streamEndianness);
-//        if(result != HasReturnvaluesIF::RETURN_OK) {
-//            return result;
-//        }
-//        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
-//   }
-//
-//   virtual size_t getSerializedSize() const override {
-//
-//   }

From 2d2d0de35cefdc627e556d33e9537cee4dca36a5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 20:24:49 +0200
Subject: [PATCH 0751/1292] local data pool manager bugfixes

---
 datapoollocal/LocalDataPoolManager.cpp | 19 ++++++++++---------
 datapoollocal/LocalDataPoolManager.h   |  3 +--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 39434b5a..f33cd8ab 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -177,8 +177,7 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        /*float collectionInterval, bool reportingEnabled, */
-		bool forDownlink, MessageQueueId_t destination) {
+        bool isDiagnostics, bool forDownlink, MessageQueueId_t destination) {
 	LocalPoolDataSetBase* dataSetToSerialize =
 			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
 	if(dataSetToSerialize == nullptr) {
@@ -188,9 +187,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid,/* reportingEnabled,
-			collectionInterval, dataSetToSerialize->getFillCount(), */
-			dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, dataSetToSerialize);
 	size_t serializedSize = 0;
 	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
 			forDownlink, &serializedSize);
@@ -200,7 +197,13 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	if(isDiagnostics) {
+		HousekeepingMessage::setHkDiagnosticsMessage(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+	}
+
 	if(hkQueue == nullptr) {
 	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
@@ -273,9 +276,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, true
-				/*intervalToIntervalSeconds(receiver->isDiagnostics,
-				receiver->hkParameter.collectionIntervalTicks), true */);
+                receiver->dataId.dataSetSid, receiver->isDiagnostics, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 552aaff7..1ab08903 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -110,8 +110,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			bool forDownlink,
-	        /*float collectionInterval, bool reportingEnabled, */
+			bool isDiagnostics, bool forDownlink,
 	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 

From 71125c075a267e5f0b8cc6229095827b1e9285da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 10 Sep 2020 21:05:50 +0200
Subject: [PATCH 0752/1292] added new setter function

---
 datapoollocal/LocalPoolDataSetBase.cpp | 9 ++++++++-
 datapoollocal/LocalPoolDataSetBase.h   | 8 ++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8abdc0e3..859f1f2c 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -190,4 +190,11 @@ bool LocalPoolDataSetBase::isValid() const {
     return this->valid;
 }
 
-
+void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
+	if(setEntriesRecursively) {
+		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+			registeredVariables[idx] -> setValid(valid);
+		}
+	}
+	this->valid = valid;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 77c1df1b..17c20d4f 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -91,6 +91,13 @@ public:
 	        size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const;
 
+	/**
+	 * Set the dataset valid or invalid
+	 * @param setEntriesRecursively
+	 * If this is true, all contained datasets will also be set recursively.
+	 */
+	void setValidity(bool valid, bool setEntriesRecursively);
+
 	bool isValid() const override;
 
 protected:
@@ -131,4 +138,5 @@ private:
 
 };
 
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */

From f9612afe06248d38db5b8b4bb875bd7c66a12598 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 11 Sep 2020 14:06:08 +0200
Subject: [PATCH 0753/1292] added report status toggler

---
 datapoollocal/LocalDataPoolManager.cpp |  5 -----
 housekeeping/HousekeepingMessage.cpp   | 24 +++++++++++++++++++++++-
 housekeeping/HousekeepingMessage.h     | 16 +++++++---------
 3 files changed, 30 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f33cd8ab..c97bbfd2 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -140,11 +140,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
     switch(command) {
-    // I think those are the only commands which can be handled here..
-    case(HousekeepingMessage::ADD_HK_REPORT_STRUCT):
-    case(HousekeepingMessage::ADD_DIAGNOSTICS_REPORT_STRUCT):
-        // We should use OwnsLocalPoolDataIF to specify those functions..
-        return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
         //return generateSetStructurePacket(message->getSid());
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index e354f8ff..f96f4d34 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -27,6 +27,29 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
+void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
+		sid_t sid, bool enableReporting, bool isDiagnostics) {
+	if(isDiagnostics) {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_DIAGNOSTICS_GENERATION);
+		}
+	}
+	else {
+		if(enableReporting) {
+			message->setCommand(ENABLE_PERIODIC_HK_GENERATION);
+		}
+		else {
+			message->setCommand(DISABLE_PERIODIC_HK_REPORT_GENERATION);
+		}
+	}
+
+	setSid(message, sid);
+}
+
+
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
 	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
@@ -36,4 +59,3 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
-
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 75b31505..ab8fd7ac 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -58,15 +58,6 @@ public:
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 
-	static constexpr Command_t ADD_HK_REPORT_STRUCT =
-			MAKE_COMMAND_ID(1);
-	static constexpr Command_t ADD_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(2);
-
-	static constexpr Command_t DELETE_HK_REPORT_STRUCT = MAKE_COMMAND_ID(3);
-	static constexpr Command_t DELETE_DIAGNOSTICS_REPORT_STRUCT =
-			MAKE_COMMAND_ID(4);
-
 	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
 			MAKE_COMMAND_ID(5);
 	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
@@ -77,6 +68,11 @@ public:
 	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
 			MAKE_COMMAND_ID(8);
 
+	static constexpr Command_t REPORTING_TOGGLE_SUCCESS =
+			MAKE_COMMAND_ID(128);
+	static constexpr Command_t REPORTING_TOGGLE_FAILURE =
+			MAKE_COMMAND_ID(129);
+
 	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
 	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
 			MAKE_COMMAND_ID(11);
@@ -104,6 +100,8 @@ public:
 
 	static sid_t getSid(const CommandMessage* message);
 
+	static void setToggleReportingMessage(CommandMessage* message, sid_t sid,
+			bool enableReporting, bool isDiagnostics);
 	static void setHkReportMessage(CommandMessage* message, sid_t sid,
 			store_address_t storeId);
 	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,

From 2d2316a0c7824defdd1f079f7fd5d23c29f5d27c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Sep 2020 18:01:48 +0200
Subject: [PATCH 0754/1292] hk message continued

---
 datapoollocal/LocalDataPoolManager.cpp |  4 +-
 housekeeping/HousekeepingMessage.cpp   | 54 ++++++++++++++++++++++++--
 housekeeping/HousekeepingMessage.h     | 53 ++++++++++++++-----------
 3 files changed, 83 insertions(+), 28 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c97bbfd2..619d8365 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -193,10 +193,10 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
 	if(isDiagnostics) {
-		HousekeepingMessage::setHkDiagnosticsMessage(&hkMessage, sid, storeId);
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
-		HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
 	}
 
 	if(hkQueue == nullptr) {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index f96f4d34..65ba8c94 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -3,7 +3,7 @@
 
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
+void HousekeepingMessage::setHkReportReply(CommandMessage* message, sid_t sid,
 		store_address_t storeId) {
 	message->setCommand(HK_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
@@ -11,7 +11,7 @@ void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
 	message->setParameter3(storeId.raw);
 }
 
-void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
+void HousekeepingMessage::setHkDiagnosticsReply(CommandMessage* message,
 		sid_t sid, store_address_t storeId) {
 	message->setCommand(DIAGNOSTICS_REPORT);
 	message->setMessageSize(HK_MESSAGE_SIZE);
@@ -19,7 +19,7 @@ void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
 	message->setParameter3(storeId.raw);
 }
 
-sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
+sid_t HousekeepingMessage::getHkDataReply(const CommandMessage *message,
 		store_address_t *storeIdToSet) {
 	if(storeIdToSet != nullptr) {
 	    *storeIdToSet = message->getParameter3();
@@ -27,7 +27,7 @@ sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
 	return getSid(message);
 }
 
-void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
+void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message,
 		sid_t sid, bool enableReporting, bool isDiagnostics) {
 	if(isDiagnostics) {
 		if(enableReporting) {
@@ -49,6 +49,52 @@ void HousekeepingMessage::setToggleReportingMessage(CommandMessage *message,
 	setSid(message, sid);
 }
 
+void HousekeepingMessage::setStructureReportingCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(REPORT_DIAGNOSTICS_REPORT_STRUCTURES);
+	}
+	else {
+		command->setCommand(REPORT_HK_REPORT_STRUCTURES);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setOneShotReportCommand(CommandMessage *command,
+		sid_t sid, bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(GENERATE_ONE_DIAGNOSTICS_REPORT);
+	}
+	else {
+		command->setCommand(GENERATE_ONE_PARAMETER_REPORT);
+	}
+
+	setSid(command, sid);
+}
+
+void HousekeepingMessage::setCollectionIntervalModificationCommand(
+		CommandMessage *command, sid_t sid, float collectionInterval,
+		bool isDiagnostics) {
+	if(isDiagnostics) {
+		command->setCommand(MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL);
+	}
+	else {
+		command->setCommand(MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL);
+	}
+	command->setParameter3(collectionInterval);
+
+	setSid(command, sid);
+}
+
+sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
+		const CommandMessage* command, float* newCollectionInterval) {
+	if(newCollectionInterval != nullptr) {
+		*newCollectionInterval = command->getParameter3();
+	}
+
+	return getSid(command);
+}
 
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index ab8fd7ac..81fa2f02 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
-#define FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
@@ -49,9 +49,8 @@ public:
 	        sizeof(sid_t) + sizeof(uint32_t);
 
 	/**
-	 * The HK message is initialized with a pointer to a message which holds
-	 * the message data, see CommandMessageIF and getInternalMessage().
-	 * @param message
+	 * Concrete instance is not used, instead this class operates on
+	 * command message instances.
 	 */
 	HousekeepingMessage() = delete;
 	virtual ~HousekeepingMessage();
@@ -68,11 +67,6 @@ public:
 	static constexpr Command_t DISABLE_PERIODIC_DIAGNOSTICS_GENERATION =
 			MAKE_COMMAND_ID(8);
 
-	static constexpr Command_t REPORTING_TOGGLE_SUCCESS =
-			MAKE_COMMAND_ID(128);
-	static constexpr Command_t REPORTING_TOGGLE_FAILURE =
-			MAKE_COMMAND_ID(129);
-
 	static constexpr Command_t REPORT_HK_REPORT_STRUCTURES = MAKE_COMMAND_ID(9);
 	static constexpr Command_t REPORT_DIAGNOSTICS_REPORT_STRUCTURES =
 			MAKE_COMMAND_ID(11);
@@ -88,33 +82,48 @@ public:
 	static constexpr Command_t GENERATE_ONE_DIAGNOSTICS_REPORT =
 			MAKE_COMMAND_ID(28);
 
-	static constexpr Command_t APPEND_PARAMETERS_TO_PARAMETER_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(29);
-	static constexpr Command_t APPEND_PARAMETERS_TO_DIAGNOSTICS_REPORT_STRUCTURE =
-			MAKE_COMMAND_ID(30);
-
 	static constexpr Command_t MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(31);
 	static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
 			MAKE_COMMAND_ID(32);
 
+	static constexpr Command_t HK_REQUEST_SUCCESS =
+			MAKE_COMMAND_ID(128);
+	static constexpr Command_t HK_REQUEST_FAILURE =
+			MAKE_COMMAND_ID(129);
+
 	static sid_t getSid(const CommandMessage* message);
 
-	static void setToggleReportingMessage(CommandMessage* message, sid_t sid,
+	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
-	static void setHkReportMessage(CommandMessage* message, sid_t sid,
+	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setOneShotReportCommand(CommandMessage* command, sid_t sid,
+			bool isDiagnostics);
+	static void setCollectionIntervalModificationCommand(
+			CommandMessage* command, sid_t sid, float collectionInterval,
+			bool isDiagnostics);
+
+	static void setHkReportReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
-	static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
+	static void setHkDiagnosticsReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
 
-	//! Get the respective SID and store ID. Command ID can be used beforehand
-	//! to distinguish between diagnostics and regular HK packets
-	static sid_t getHkReportMessage(const CommandMessage* message,
+	/**
+	 * @brief	Generic getter function for housekeeping data replies
+	 * @details
+	 * Command ID can be used beforehand to distinguish between diagnostics and
+	 * regular HK packets. This getter function should be used for the
+	 * command IDs 10, 12, 25 and 26.
+	 */
+	static sid_t getHkDataReply(const CommandMessage* message,
 			store_address_t * storeIdToSet);
+	static sid_t getCollectionIntervalModificationCommand(
+			const CommandMessage* command, float* newCollectionInterval);
 
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
 };
 
 
-#endif /* FRAMEWORK_HK_HOUSEKEEPINGMESSAGE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_ */

From e8de2fc47a1f1c6451ec5a7a6ec3767377289de7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Sep 2020 18:29:19 +0200
Subject: [PATCH 0755/1292] added srv3

---
 events/fwSubsystemIdRanges.h         |   1 +
 pus/Service17Test.h                  |   6 +-
 pus/Service3Housekeeping.cpp         | 262 +++++++++++++++++++++++++++
 pus/Service3Housekeeping.h           | 101 +++++++++++
 pus/servicepackets/Service3Packets.h |  21 +++
 5 files changed, 388 insertions(+), 3 deletions(-)
 create mode 100644 pus/Service3Housekeeping.cpp
 create mode 100644 pus/Service3Housekeeping.h
 create mode 100644 pus/servicepackets/Service3Packets.h

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index a05652c2..3c57c160 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -19,6 +19,7 @@ enum {
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
 	PUS_SERVICE_1 = 80,
+	PUS_SERVICE_17 = 83,
 	FW_SUBSYSTEM_ID_RANGE
 };
 }
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
index 8d6a4377..e2681865 100644
--- a/pus/Service17Test.h
+++ b/pus/Service17Test.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICE17TEST_H_
-#define MISSION_PUS_SERVICE17TEST_H_
+#ifndef FSFW_PUS_SERVICE17TEST_H_
+#define FSFW_PUS_SERVICE17TEST_H_
 
 #include "../tmtcservices/PusServiceBase.h"
 #include "../objectmanager/SystemObject.h"
@@ -41,4 +41,4 @@ protected:
 	uint16_t packetSubCounter = 0;
 };
 
-#endif /* MISSION_PUS_SERVICE17TEST_H_ */
+#endif /* FSFW_PUS_SERVICE17TEST_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
new file mode 100644
index 00000000..db77328a
--- /dev/null
+++ b/pus/Service3Housekeeping.cpp
@@ -0,0 +1,262 @@
+#include "Service3Housekeeping.h"
+#include "servicepackets/Service3Packets.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
+
+
+Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId):
+		CommandingServiceBase(objectId, apid, serviceId,
+		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+
+Service3Housekeeping::~Service3Housekeeping() {}
+
+ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES :
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return HasReturnvaluesIF::RETURN_OK;
+	// Telemetry or invalid subservice.
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
+		const uint8_t *tcData, size_t tcDataLen,
+		MessageQueueId_t *id, object_id_t *objectId) {
+	return HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return checkInterfaceAndAcquireMessageQueue(id,objectId);
+}
+
+ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
+		object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) {
+	if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
+	        SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) {
+		return CommandingServiceBase::INVALID_TC;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
+		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
+	// check OwnsLocalDataPoolIF property of target
+	HasLocalDataPoolIF* possibleTarget =
+			objectManager->get<HasLocalDataPoolIF>(*objectId);
+	if(possibleTarget == nullptr){
+		return CommandingServiceBase::INVALID_OBJECT;
+	}
+	*messageQueueToSet = possibleTarget->getCommandQueue();
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
+		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+		uint32_t *state, object_id_t objectId) {
+	switch(static_cast<Subservice>(subservice)) {
+	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, true, false,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, false, false,
+				tcData, tcDataLen);
+	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, true, true,
+				tcData, tcDataLen);
+	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
+		return prepareReportingTogglingCommand(message, false, true,
+				tcData, tcDataLen);
+	case Subservice::REPORT_HK_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, false, tcData,
+				tcDataLen);
+	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
+		return prepareStructureReportingCommand(message, true, tcData,
+				tcDataLen);
+	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
+		return prepareOneShotReportCommand(message, false, tcData, tcDataLen);
+	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
+		return prepareOneShotReportCommand(message, true, tcData, tcDataLen);
+	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, false,
+				tcData, tcDataLen);
+	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
+		return prepareCollectionIntervalModificationCommand(message, true,
+				tcData, tcDataLen);
+	case Subservice::HK_DEFINITIONS_REPORT:
+	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
+	case Subservice::HK_REPORT:
+	case Subservice::DIAGNOSTICS_REPORT:
+		// Those are telemetry packets.
+		return CommandingServiceBase::INVALID_TC;
+	default:
+		// should never happen, subservice was already checked.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t *state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool *isStep) {
+	switch(reply->getCommand()) {
+	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+		failureParameter1 = objectId;
+		// also provide failure reason (returnvalue)
+		// will be most commonly invalid SID or the set already has the desired
+		// reporting status.
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply!"
+				<< std::endl;
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
+		CommandMessage *command, bool enableReporting, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+				SerializeIF::Endianness::BIG);
+
+	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
+			enableReporting, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t* tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+
+	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t)) {
+		// It is assumed the full SID is sent for now (even if that means
+		// 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
+			isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
+		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
+		size_t tcDataLen) {
+	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
+		// It is assumed the full SID and the new collection interval as a float
+		// is sent for now (even if that means 4 bytes are redundant)
+		return CommandingServiceBase::INVALID_TC;
+	}
+
+	sid_t targetSid;
+	float newCollectionInterval = 0;
+	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
+			targetSid, newCollectionInterval, isDiagnostics);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+void Service3Housekeeping::handleUnrequestedReply(
+        CommandMessage* reply) {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(reply->getCommand()) {
+    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+    	result = generateHkReport(reply,
+    			static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+    	break;
+    }
+    case(HousekeepingMessage::HK_REPORT): {
+        result = generateHkReport(reply,
+        		static_cast<uint8_t>(Subservice::HK_REPORT));
+        break;
+    }
+    default: {
+        sif::error << "Service3Housekeeping::handleUnrequestedReply: "
+                << "Invalid reply!" << std::endl;
+    }
+    }
+
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// Configuration error
+		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
+				<< "Could not generate reply!" << std::endl;
+	}
+}
+
+MessageQueueId_t Service3Housekeeping::getHkQueue() const {
+	return commandQueue->getId();
+}
+
+ReturnValue_t Service3Housekeeping::generateHkReport(
+		const CommandMessage* hkMessage, uint8_t subserviceId) {
+	store_address_t storeId;
+
+	sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
+	auto resultPair = IPCStore->getData(storeId);
+	if(resultPair.first != HasReturnvaluesIF::RETURN_OK) {
+		return resultPair.first;
+	}
+
+	HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
+	return sendTmPacket(static_cast<uint8_t>(subserviceId),
+			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
+}
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
new file mode 100644
index 00000000..6c5d2469
--- /dev/null
+++ b/pus/Service3Housekeeping.h
@@ -0,0 +1,101 @@
+#ifndef FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+#define FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_
+
+#include "../housekeeping/AcceptsHkPacketsIF.h"
+#include "../housekeeping/HousekeepingMessage.h"
+#include "../tmtcservices/CommandingServiceBase.h"
+
+/**
+ * @brief   Manges spacecraft housekeeping reports and
+ *          sends pool variables (temperature, GPS data ...) to ground.
+ *
+ * @details Full Documentation: ECSS-E70-41A or ECSS-E-ST-70-41C.
+ * Implementation based on PUS-C
+ *
+ * The housekeeping service type provides means to control and adapt the
+ * spacecraft reporting plan according to the mission phases.
+ * The housekeeping service type provides the visibility of any
+ * on-board parameters assembled in housekeeping parameter report structures
+ * or diagnostic parameter report structures as required for the mission.
+ * The parameter report structures used by the housekeeping service can
+ * be predefined on-board or created when needed.
+ *
+ * @author 	R. Mueller
+ * @ingroup pus_services
+ */
+class Service3Housekeeping: public CommandingServiceBase,
+		public AcceptsHkPacketsIF {
+public:
+	static constexpr uint8_t NUM_OF_PARALLEL_COMMANDS = 4;
+	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
+
+	Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual~ Service3Housekeeping();
+protected:
+	/* CSB abstract functions implementation . See CSB documentation. */
+	ReturnValue_t isValidSubservice(uint8_t subservice) override;
+	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
+			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
+			object_id_t *objectId) override;
+	ReturnValue_t prepareCommand(CommandMessage* message,
+			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
+			uint32_t *state, object_id_t objectId) override;
+	ReturnValue_t handleReply(const CommandMessage* reply,
+			Command_t previousCommand, uint32_t *state,
+			CommandMessage* optionalNextCommand, object_id_t objectId,
+			bool *isStep) override;
+
+	virtual MessageQueueId_t getHkQueue() const;
+private:
+	enum class Subservice {
+		ENABLE_PERIODIC_HK_REPORT_GENERATION = 5, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_HK_REPORT_GENERATION = 6, //!< [EXPORT] : [TC]
+
+		ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 7, //!< [EXPORT] : [TC]
+		DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION = 8, //!< [EXPORT] : [TC]
+
+		//! [EXPORT] : [TC] Report HK structure by supplying SID
+		REPORT_HK_REPORT_STRUCTURES = 9,
+		//! [EXPORT] : [TC] Report Diagnostics structure by supplying SID
+		REPORT_DIAGNOSTICS_REPORT_STRUCTURES = 11,
+
+		//! [EXPORT] : [TM] Report corresponding to Subservice 9 TC
+		HK_DEFINITIONS_REPORT = 10,
+		//! [EXPORT] : [TM] Report corresponding to Subservice 11 TC
+		DIAGNOSTICS_DEFINITION_REPORT = 12,
+
+		//! [EXPORT] : [TM] Core packet. Contains Housekeeping data
+		HK_REPORT = 25,
+		//! [EXPORT] : [TM] Core packet. Contains diagnostics data
+		DIAGNOSTICS_REPORT = 26,
+
+		/* PUS-C */
+		GENERATE_ONE_PARAMETER_REPORT = 27, //!< [EXPORT] : [TC]
+		GENERATE_ONE_DIAGNOSTICS_REPORT = 28, //!< [EXPORT] : [TC]
+
+		MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL = 31, //!< [EXPORT] : [TC]
+		MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL = 32, //!< [EXPORT] : [TC]
+	};
+
+	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
+			const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
+			MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
+
+	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
+			uint8_t subserviceId);
+	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
+			bool enableReporting, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareStructureReportingCommand(CommandMessage* command,
+			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
+			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
+	ReturnValue_t prepareCollectionIntervalModificationCommand(
+			CommandMessage* command, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+
+	void handleUnrequestedReply(CommandMessage* reply) override;
+};
+
+#endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */
diff --git a/pus/servicepackets/Service3Packets.h b/pus/servicepackets/Service3Packets.h
new file mode 100644
index 00000000..05732e11
--- /dev/null
+++ b/pus/servicepackets/Service3Packets.h
@@ -0,0 +1,21 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_
+
+#include <fsfw/housekeeping/HousekeepingMessage.h>
+#include <cstdint>
+
+/**
+ * @brief Subservices 25 and 26: TM packets
+ * @ingroup spacepackets
+ */
+class HkPacket { //!< [EXPORT] : [SUBSERVICE] 25, 26
+public:
+    sid_t sid; //!< [EXPORT] : [COMMENT] Structure ID (SID) of housekeeping data.
+    const uint8_t* hkData; //!< [EXPORT] : [MAXSIZE] Deduced size
+    size_t hkSize; //!< [EXPORT] : [IGNORE]
+
+    HkPacket(sid_t sid, const uint8_t* data, size_t size):
+            sid(sid), hkData(data), hkSize(size) {}
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_ */

From e707c5e05117b9734f50f4a144987ec51b4dfb65 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 15:58:12 +0200
Subject: [PATCH 0756/1292] fixes taken over

---
 ipc/CommandMessage.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index ca7b817f..8f5daa04 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -8,7 +8,7 @@
 /**
  * @brief 	Default command message used to pass command messages between tasks.
  * 			Primary message type for IPC. Contains sender, 2-byte command ID
- * 			field, and 2 4-byte parameters.
+ * 			field, and 3 4-byte parameter
  * @details
  * It operates on an external memory which is contained inside a
  * class implementing MessageQueueMessageIF by taking its address.
@@ -23,10 +23,11 @@
 class CommandMessage: public MessageQueueMessage, public CommandMessageIF {
 public:
     /**
-     * Default size can accomodate 2 4-byte parameters.
+     * Default size can accomodate 3 4-byte parameters.
      */
     static constexpr size_t DEFAULT_COMMAND_MESSAGE_SIZE =
-            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE + sizeof(uint32_t);
+            CommandMessageIF::MINIMUM_COMMAND_MESSAGE_SIZE +
+			3 * sizeof(uint32_t);
 
 	/**
 	 * @brief   Default Constructor, does not initialize anything.

From ad98a63e87602790de874b7fa336a2d04d012a1a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:02:58 +0200
Subject: [PATCH 0757/1292] changes taken over from upstream master

---
 serialize/SerializeIF.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h
index a701fe53..d72218f0 100644
--- a/serialize/SerializeIF.h
+++ b/serialize/SerializeIF.h
@@ -2,7 +2,7 @@
 #define FSFW_SERIALIZE_SERIALIZEIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stddef.h>
+#include <cstddef>
 
 /**
  * @defgroup serialize Serialization
@@ -10,7 +10,10 @@
  */
 
 /**
- * Translation of objects into data streams and from data streams.
+ * @brief 	Translation of objects into data streams and from data streams.
+ * @details
+ * Also provides options to convert from/to data with different endianness.
+ * variables.
  * @ingroup serialize
  */
 class SerializeIF {

From 15891b3cf08b585a9e177447d0d15a5ba7490705 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:42:17 +0200
Subject: [PATCH 0758/1292] fixed some message queue includes

---
 action/ActionHelper.cpp                 |  1 +
 action/SimpleActionHelper.cpp           |  1 +
 devicehandlers/CommunicationMessage.cpp |  4 ++--
 health/HealthHelper.cpp                 |  4 ++--
 ipc/MessageQueueIF.h                    | 14 ++++++++------
 ipc/MessageQueueMessage.h               |  1 -
 ipc/MessageQueueMessageIF.h             | 17 +++--------------
 ipc/MessageQueueSenderIF.h              |  3 ++-
 ipc/QueueFactory.h                      |  2 ++
 ipc/messageQueueDefintions.h            | 18 ++++++++++++++++++
 modes/ModeHelper.cpp                    |  9 +++++----
 osal/FreeRTOS/MessageQueue.cpp          |  8 ++++----
 osal/FreeRTOS/MessageQueue.h            |  5 +++--
 osal/FreeRTOS/QueueFactory.cpp          |  1 +
 14 files changed, 52 insertions(+), 36 deletions(-)
 create mode 100644 ipc/messageQueueDefintions.h

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index b43c676d..70c3f0fc 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/ipc/MessageQueueSenderIF.h>
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index d79a3c97..51e3fa1c 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,5 +1,6 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
 		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
index abdfd3a8..57774270 100644
--- a/devicehandlers/CommunicationMessage.cpp
+++ b/devicehandlers/CommunicationMessage.cpp
@@ -122,7 +122,7 @@ uint32_t CommunicationMessage::getUint32Data() const{
 }
 
 void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(0 <= position && position <= 3) {
+	if(position <= 3) {
 		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
 	}
 	else {
@@ -131,7 +131,7 @@ void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
 }
 
 uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(0 <= position && position <= 3) {
+	if(position <= 3) {
 		uint8_t byte;
 		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
 		return byte;
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index cced11d9..d574634d 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -71,7 +71,7 @@ void HealthHelper::setHealth(HasHealthIF::HealthState health) {
 
 void HealthHelper::informParent(HasHealthIF::HealthState health,
 		HasHealthIF::HealthState oldHealth) {
-	if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
+	if (parentQueue == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	CommandMessage information;
@@ -86,7 +86,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 
 void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
-	if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
+	if (command->getSender() == MessageQueueIF::NO_QUEUE) {
 		return;
 	}
 	CommandMessage reply;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 96bd379f..e9a4a00b 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,21 +1,23 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
+#include "MessageQueueMessageIF.h"
+#include "messageQueueDefintions.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+
+#include <cstdint>
+
+
 // COULDDO: We could support blocking calls
 // semaphores are being implemented, which makes this idea even more iteresting.
 
-
 /**
  * @defgroup message_queue Message Queue
  * @brief Message Queue related software components
  */
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../ipc/MessageQueueSenderIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
 class MessageQueueIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = MessageQueueMessageIF::NO_QUEUE; //!< Ugly hack.
+	static const MessageQueueId_t NO_QUEUE = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MESSAGE_QUEUE_IF;
 	//! No new messages on the queue
diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h
index f68e9b9f..5234f64f 100644
--- a/ipc/MessageQueueMessage.h
+++ b/ipc/MessageQueueMessage.h
@@ -2,7 +2,6 @@
 #define FSFW_IPC_MESSAGEQUEUEMESSAGE_H_
 
 #include "../ipc/MessageQueueMessageIF.h"
-#include "../ipc/MessageQueueSenderIF.h"
 #include <cstddef>
 
 /**
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index 91753ced..daf7e8bb 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,24 +1,13 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
+
+#include "messageQueueDefintions.h"
 #include <cstddef>
 #include <cstdint>
 
-/*
- * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
- * breaks layering. However, it is difficult to keep layering, as the ID is
- * stored in many places and sent around in MessageQueueMessage.
- * Ideally, one would use the (current) object_id_t only, however, doing a
- * lookup of queueIDs for every call does not sound ideal.
- * In a first step, I'll circumvent the issue by not touching it,
- * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues..
- */
-
-typedef uint32_t MessageQueueId_t;
-
 class MessageQueueMessageIF {
 public:
-	static const MessageQueueId_t NO_QUEUE = -1;
+
     /**
      * @brief   This constants defines the size of the header,
      *          which is added to every message.
diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index b967bbdf..beb27f50 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
 
+#include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
@@ -15,7 +16,7 @@ public:
 	 */
 	static ReturnValue_t sendMessage(MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom = MessageQueueMessageIF::NO_QUEUE,
+			MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
 			bool ignoreFault = false);
 private:
 	MessageQueueSenderIF() {}
diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index be554406..5fbfdf2d 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -2,7 +2,9 @@
 #define FRAMEWORK_IPC_QUEUEFACTORY_H_
 
 #include "MessageQueueIF.h"
+#include "MessageQueueMessage.h"
 #include <cstdint>
+
 /**
  * Creates message queues.
  * This class is a "singleton" interface, i.e. it provides an
diff --git a/ipc/messageQueueDefintions.h b/ipc/messageQueueDefintions.h
new file mode 100644
index 00000000..3d625de1
--- /dev/null
+++ b/ipc/messageQueueDefintions.h
@@ -0,0 +1,18 @@
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues..
+ */
+using MessageQueueId_t = uint32_t;
+
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index e7fc0bcb..68f009e7 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,3 +1,4 @@
+#include "../ipc/MessageQueueSenderIF.h"
 #include "../modes/HasModesIF.h"
 #include "../modes/ModeHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -35,7 +36,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		commandedMode = mode;
 		commandedSubmode = submode;
 
-		if ((parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+		if ((parentQueueId != MessageQueueIF::NO_QUEUE)
 				&& (theOneWhoCommandedAMode != parentQueueId)) {
 			owner->setToExternalControl();
 		}
@@ -73,13 +74,13 @@ void ModeHelper::modeChanged(Mode_t ownerMode, Submode_t ownerSubmode) {
 	forced = false;
 	sendModeReplyMessage(ownerMode, ownerSubmode);
 	sendModeInfoMessage(ownerMode, ownerSubmode);
-	theOneWhoCommandedAMode = MessageQueueMessageIF::NO_QUEUE;
+	theOneWhoCommandedAMode = MessageQueueIF::NO_QUEUE;
 }
 
 void ModeHelper::sendModeReplyMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
 	CommandMessage reply;
-	if (theOneWhoCommandedAMode != MessageQueueMessageIF::NO_QUEUE)
+	if (theOneWhoCommandedAMode != MessageQueueIF::NO_QUEUE)
 	{
 		if (ownerMode != commandedMode or ownerSubmode != commandedSubmode)
 		{
@@ -101,7 +102,7 @@ void ModeHelper::sendModeInfoMessage(Mode_t ownerMode,
 		Submode_t ownerSubmode) {
 	CommandMessage reply;
 	if (theOneWhoCommandedAMode != parentQueueId
-			and parentQueueId != MessageQueueMessageIF::NO_QUEUE)
+			and parentQueueId != MessageQueueIF::NO_QUEUE)
 	{
 		ModeMessage::setModeMessage(&reply, ModeMessage::REPLY_MODE_INFO,
 				ownerMode, ownerSubmode);
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e3e0ef1c..2dfe5ab6 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 // TODO I guess we should have a way of checking if we are in an ISR and then
@@ -40,7 +40,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != MessageQueueMessageIF::NO_QUEUE) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return NO_REPLY_PARTNER;
@@ -58,8 +58,8 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
 		if (not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
-					objectManager->get<InternalErrorReporterIF>(
+			InternalErrorReporterIF* internalErrorReporter = objectManager->
+					get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index e953ec34..b99bf7c8 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -8,6 +8,7 @@
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
 
 // TODO: this class assumes that MessageQueueId_t is the same size as void*
 // (the FreeRTOS handle type), compiler will catch this but it might be nice
@@ -139,8 +140,8 @@ protected:
 private:
 	bool defaultDestinationSet = false;
 	QueueHandle_t handle;
-	MessageQueueId_t defaultDestination = 0;
-	MessageQueueId_t lastPartner = 0;
+	MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
+	MessageQueueId_t lastPartner = MessageQueueIF::NO_QUEUE;
 	const size_t maxMessageSize;
 	//! Stores the current system context
 	CallContext callContext =  CallContext::TASK;
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index cd99afd9..5b3c73dc 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,3 +1,4 @@
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
 #include "../../osal/FreeRTOS/MessageQueue.h"

From 850a4a3e3deddf8a13a9ee52e53262a8e0c7fe41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 16:44:48 +0200
Subject: [PATCH 0759/1292] header file renamed

---
 ipc/MessageQueueIF.h                                        | 2 +-
 ipc/MessageQueueMessageIF.h                                 | 2 +-
 ipc/{messageQueueDefintions.h => messageQueueDefinitions.h} | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)
 rename ipc/{messageQueueDefintions.h => messageQueueDefinitions.h} (79%)

diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index e9a4a00b..44b6f4c0 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
+#include <fsfw/ipc/messageQueueDefinitions.h>
 #include "MessageQueueMessageIF.h"
-#include "messageQueueDefintions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 #include <cstdint>
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index daf7e8bb..b5a30c08 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 
-#include "messageQueueDefintions.h"
+#include <fsfw/ipc/messageQueueDefinitions.h>
 #include <cstddef>
 #include <cstdint>
 
diff --git a/ipc/messageQueueDefintions.h b/ipc/messageQueueDefinitions.h
similarity index 79%
rename from ipc/messageQueueDefintions.h
rename to ipc/messageQueueDefinitions.h
index 3d625de1..d30e6984 100644
--- a/ipc/messageQueueDefintions.h
+++ b/ipc/messageQueueDefinitions.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
-#define FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
 
 #include <cstdint>
 
@@ -15,4 +15,4 @@
  */
 using MessageQueueId_t = uint32_t;
 
-#endif /* FSFW_IPC_MESSAGEQUEUEDEFINTIONS_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */

From b8ad17639ceb8b773175749608477d8ff970521c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:02:31 +0200
Subject: [PATCH 0760/1292] include guard fix

---
 ipc/MessageQueueSenderIF.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index beb27f50..d8ede535 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
-#define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_
+#ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
+#define FSFWw_IPC_MESSAGEQUEUESENDERIF_H_
 
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"
@@ -23,4 +23,4 @@ private:
 };
 
 
-#endif /* FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ */
+#endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */

From 7643af8607ad9b1ccb27f9bd120a324869807134 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:15:22 +0200
Subject: [PATCH 0761/1292] include guard fix

---
 ipc/MessageQueueSenderIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index d8ede535..42d4078f 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,5 +1,5 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
-#define FSFWw_IPC_MESSAGEQUEUESENDERIF_H_
+#define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueMessageIF.h"

From 347d591deff649540ff9dbeee1115c2803c060c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:33:21 +0200
Subject: [PATCH 0762/1292] uses new define and config file now

---
 events/Event.h          | 2 +-
 events/EventManager.cpp | 4 ++--
 events/EventManager.h   | 6 ++++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/events/Event.h b/events/Event.h
index e22c9db1..f8410f32 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <config/tmtc/subsystemIdRanges.h>
+#include <subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index e71951e3..0971dadc 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -109,13 +109,13 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
 	case SEVERITY::INFO:
-#ifdef DEBUG_INFO_EVENT
+#if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";
 		if (string != 0) {
diff --git a/events/EventManager.h b/events/EventManager.h
index 2602aeb2..f03c0241 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -8,9 +8,11 @@
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
+#include <FSFWConfig.h>
+
 #include <map>
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -55,7 +57,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#ifdef DEBUG
+#if FSFW_DEBUG_OUTPUT == 1
 	void printEvent(EventMessage *message);
 #endif
 

From 0d5724e3d416f837348b764cde3f7f732c2c5af6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:34:07 +0200
Subject: [PATCH 0763/1292] include improvements taken over

---
 timemanager/CCSDSTime.cpp | 9 +++------
 timemanager/CCSDSTime.h   | 4 ++--
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 12ecf34a..f99f8fbb 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,11 +1,8 @@
 #include "../timemanager/CCSDSTime.h"
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
+#include <cstdio>
+#include <cinttypes>
+#include <cmath>
 
-#ifndef SCNu8
-  #define SCNu8 "hhu"
-#endif
 
 CCSDSTime::CCSDSTime() {
 }
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index b9efa49c..89fcff92 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -3,9 +3,9 @@
 
 // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
 
-#include "../timemanager/Clock.h"
+#include "Clock.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 
 bool operator<(const timeval& lhs, const timeval& rhs);
 bool operator<=(const timeval& lhs, const timeval& rhs);

From e5dac30e98f694ad92ea82cc8c15ff7bfc7bd8b2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 15 Sep 2020 17:37:43 +0200
Subject: [PATCH 0764/1292] new include used now

---
 timemanager/CCSDSTime.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index f99f8fbb..80a4e27c 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,4 +1,5 @@
 #include "../timemanager/CCSDSTime.h"
+#include <FSFWConfig.h>
 #include <cstdio>
 #include <cinttypes>
 #include <cmath>
@@ -158,7 +159,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
 // Suggestion: use uint16 all the time. This should work on all systems.
-#ifdef NEWLIB_NANO_NO_C99_IO
+#if FSFW_NEWLIB_NANO_NO_C99_IO == 1
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;

From 6ef5e3e5501e5d925160306f25e39c3e1cfbb312 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 16 Sep 2020 21:22:53 +0200
Subject: [PATCH 0765/1292] queue factory host OS fix

---
 osal/host/QueueFactory.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index da3fea55..7feb1ad6 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,5 +1,6 @@
+#include "MessageQueue.h"
 #include "../../ipc/QueueFactory.h"
-#include "../../osal/host/MessageQueue.h"
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <cstring>
 

From 0c6514a682a03e4dc74e5b7878960b0af8bf34f3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 17 Sep 2020 22:31:28 +0200
Subject: [PATCH 0766/1292] clock uses getUptime again

---
 osal/linux/Clock.cpp      | 27 +++++++++------------------
 timemanager/Stopwatch.cpp | 11 +++++++----
 timemanager/Stopwatch.h   |  2 +-
 3 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 5f764a6f..b3b09923 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -75,24 +75,15 @@ timeval Clock::getUptime() {
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	uptime->tv_sec = sysInfo.uptime;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
-//	}
-
-	return HasReturnvaluesIF::RETURN_OK;
+    //TODO This is not posix compatible and delivers only seconds precision
+    // is the OS not called Linux?
+    //Linux specific file read but more precise
+    double uptimeSeconds;
+    if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+        uptime->tv_sec = uptimeSeconds;
+        uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 28ae4543..2cd31969 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -6,15 +6,18 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(
         displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
 void Stopwatch::start() {
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
-dur_millis_t Stopwatch::stop() {
+dur_millis_t Stopwatch::stop(bool display) {
     stopInternal();
+    if(display) {
+        this->display();
+    }
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
@@ -52,6 +55,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
 
 void Stopwatch::stopInternal() {
 	timeval endTime;
-	Clock::getClock_timeval(&endTime);
+	Clock::getUptime(&endTime);
     elapsedTime = endTime - startTime;
 }
diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 49b686f9..093f5c9e 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -40,7 +40,7 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    dur_millis_t stop();
+    dur_millis_t stop(bool display = false);
     /**
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)

From 37f4cc46447906295f11e9e368e32e010eedecad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:28:29 +0200
Subject: [PATCH 0767/1292] taken over stopwatch changes

---
 timemanager/Stopwatch.h | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h
index 093f5c9e..ea72c66e 100644
--- a/timemanager/Stopwatch.h
+++ b/timemanager/Stopwatch.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
-#include "../timemanager/Clock.h"
+#ifndef FSFW_TIMEMANAGER_STOPWATCH_H_
+#define FSFW_TIMEMANAGER_STOPWATCH_H_
+
+#include "Clock.h"
 
 enum class StopwatchDisplayMode {
     MILLIS,
@@ -66,6 +67,4 @@ private:
 };
 
 
-
-
-#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */
+#endif /* FSFW_TIMEMANAGER_STOPWATCH_H_ */

From e0b2e0b00a578f59ac692c57d1d3b2bc1ea4528c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:31:11 +0200
Subject: [PATCH 0768/1292] fxed linux message queues

---
 osal/linux/MessageQueue.cpp | 4 +++-
 osal/linux/MessageQueue.h   | 6 +++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 87251724..cfadb793 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,6 @@
+#include "MessageQueue.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/MessageQueue.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
 
@@ -9,6 +10,7 @@
 #include <errno.h>
 
 
+
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
 		defaultDestination(MessageQueueIF::NO_QUEUE),
diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h
index c0b77019..239bbbdb 100644
--- a/osal/linux/MessageQueue.h
+++ b/osal/linux/MessageQueue.h
@@ -1,5 +1,5 @@
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
+#define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -184,4 +184,4 @@ private:
 	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_LINUX_MESSAGEQUEUE_H_ */

From 19632b8fb1cf4cdedf13795ee5ecaa6158f91f10 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:36:36 +0200
Subject: [PATCH 0769/1292] linux fixes

---
 ipc/QueueFactory.h          |  6 +++---
 osal/linux/Clock.cpp        |  2 +-
 osal/linux/QueueFactory.cpp | 10 ++++++++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 5fbfdf2d..9853d256 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_
-#define FRAMEWORK_IPC_QUEUEFACTORY_H_
+#ifndef FSFW_IPC_QUEUEFACTORY_H_
+#define FSFW_IPC_QUEUEFACTORY_H_
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
@@ -32,4 +32,4 @@ private:
 	static QueueFactory* factoryInstance;
 };
 
-#endif /* FRAMEWORK_IPC_QUEUEFACTORY_H_ */
+#endif /* FSFW_IPC_QUEUEFACTORY_H_ */
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index b3b09923..6f2faedb 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -6,8 +6,8 @@
 #include <linux/sysinfo.h>
 #include <time.h>
 #include <unistd.h>
+#include <fstream>
 
-//#include <fstream>
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = NULL;
 
diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp
index fb8f6df7..44def48a 100644
--- a/osal/linux/QueueFactory.cpp
+++ b/osal/linux/QueueFactory.cpp
@@ -1,8 +1,14 @@
 #include "../../ipc/QueueFactory.h"
+#include "MessageQueue.h"
+
+#include "../../ipc/messageQueueDefinitions.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <mqueue.h>
 #include <errno.h>
-#include "../../osal/linux/MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+
 #include <cstring>
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;

From e70e9e3f1f67e007245ab457c1e2f685d5450697 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 12:57:30 +0200
Subject: [PATCH 0770/1292] added uptime seconds functions

---
 osal/FreeRTOS/Clock.cpp |  7 +++++++
 osal/host/Clock.cpp     |  5 +++++
 osal/linux/Clock.cpp    | 14 ++++++++++++--
 timemanager/Clock.h     |  2 ++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d556444c..42f060b4 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -67,6 +67,13 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+uint32_t Clock::getUptimeSeconds() {
+	timeval uptime = getUptime();
+	return uptime.tv_sec;
+}
+
+
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	timeval time_timeval;
 	ReturnValue_t result = getClock_timeval(&time_timeval);
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 41321eeb..17d98ba8 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -106,6 +106,11 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+uint32_t Clock::getUptimeSeconds() {
+	timeval uptime = getUptime();
+	return uptime.tv_sec;
+}
+
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	// do some magic with chrono (C++20!)
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 6f2faedb..468fcb80 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/Stopwatch.h>
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
@@ -76,8 +77,7 @@ timeval Clock::getUptime() {
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
     //TODO This is not posix compatible and delivers only seconds precision
-    // is the OS not called Linux?
-    //Linux specific file read but more precise
+    // Linux specific file read but more precise.
     double uptimeSeconds;
     if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
         uptime->tv_sec = uptimeSeconds;
@@ -86,6 +86,16 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+uint32_t Clock::getUptimeSeconds() {
+	//TODO This is not posix compatible and delivers only seconds precision
+	struct sysinfo sysInfo;
+	int result = sysinfo(&sysInfo);
+	if(result != 0){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	return sysInfo.uptime;
+}
+
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	timeval uptime;
 	ReturnValue_t result = getUptime(&uptime);
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index acb68e2e..1ad88305 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -67,6 +67,8 @@ public:
 
 	static timeval getUptime();
 
+	static uint32_t getUptimeSeconds();
+
 	/**
 	 * Get the time since boot in milliseconds
 	 *

From 7b0ddb3941729647276cdfe0218d0727d2f6e343 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:09:23 +0200
Subject: [PATCH 0771/1292] quick fix DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 86fd01b1..1f76fc4f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1275,10 +1275,14 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+			//so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::endl; //so we can track misconfigurations
-			return; //this is an internal command, no need to report a failure here, missed reply will track if a reply is too late, otherwise, it's ok
+					<< deviceCommandId << " isExecuting" << std::dec
+					<< std::endl;
+			// this is an internal command, no need to report a failure here,
+			// missed reply will track if a reply is too late, otherwise, it's ok
+			return;
 		} else {
 			iter->second.sendReplyTo = NO_COMMANDER;
 			iter->second.isExecuting = true;

From 57c88059e5be68191b25dac2f179df237b125df2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:12:07 +0200
Subject: [PATCH 0772/1292] DHB small improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 16 ++++++++--------
 devicehandlers/DeviceHandlerBase.h   | 15 ++++++++-------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1f76fc4f..0a3aec6d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1,18 +1,18 @@
-#include "../devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
+#include "AcceptsDeviceResponsesIF.h"
+#include "DeviceTmReportingWrapper.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
-#include "../devicehandlers/AcceptsDeviceResponsesIF.h"
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
 #include "../globalfunctions/CRC.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../ipc/MessageQueueMessage.h"
-#include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../subsystem/SubsystemBase.h"
 
 #include <iomanip>
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c3748172..752f7352 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1,25 +1,26 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+
+#include "DeviceHandlerIF.h"
+#include "DeviceCommunicationIF.h"
+#include "DeviceHandlerFailureIsolation.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../action/HasActionsIF.h"
 #include "../datapool/PoolVariableIF.h"
-#include "../devicehandlers/DeviceCommunicationIF.h"
 #include "../modes/HasModesIF.h"
 #include "../power/PowerSwitchIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../tasks/PeriodicTaskIF.h"
-
 #include "../action/ActionHelper.h"
 #include "../health/HealthHelper.h"
 #include "../parameters/ParameterHelper.h"
 #include "../datapool/HkSwitchHelper.h"
 #include "../datapoollocal/HasLocalDataPoolIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+
 #include <map>
 
 namespace Factory{
@@ -1205,4 +1206,4 @@ private:
                 size_t receivedDataLen);
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */

From b429359864f3a25eb33af17f52958fa102ffb8b9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:14:01 +0200
Subject: [PATCH 0773/1292] renormalize files

---
 ipc/messageQueueDefinitions.h     |  36 ++---
 serialize/SerialBufferAdapter.cpp | 258 +++++++++++++++---------------
 serialize/SerialBufferAdapter.h   | 156 +++++++++---------
 3 files changed, 225 insertions(+), 225 deletions(-)

diff --git a/ipc/messageQueueDefinitions.h b/ipc/messageQueueDefinitions.h
index d30e6984..d250da8a 100644
--- a/ipc/messageQueueDefinitions.h
+++ b/ipc/messageQueueDefinitions.h
@@ -1,18 +1,18 @@
-#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
-
-#include <cstdint>
-
-/*
- * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
- * breaks layering. However, it is difficult to keep layering, as the ID is
- * stored in many places and sent around in MessageQueueMessage.
- * Ideally, one would use the (current) object_id_t only, however, doing a
- * lookup of queueIDs for every call does not sound ideal.
- * In a first step, I'll circumvent the issue by not touching it,
- * maybe in a second step. This also influences Interface design
- * (getCommandQueue) and some other issues..
- */
-using MessageQueueId_t = uint32_t;
-
-#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
+#ifndef FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+#define FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_
+
+#include <cstdint>
+
+/*
+ * TODO: Actually, the definition of this ID to be a uint32_t is not  ideal and
+ * breaks layering. However, it is difficult to keep layering, as the ID is
+ * stored in many places and sent around in MessageQueueMessage.
+ * Ideally, one would use the (current) object_id_t only, however, doing a
+ * lookup of queueIDs for every call does not sound ideal.
+ * In a first step, I'll circumvent the issue by not touching it,
+ * maybe in a second step. This also influences Interface design
+ * (getCommandQueue) and some other issues..
+ */
+using MessageQueueId_t = uint32_t;
+
+#endif /* FSFW_IPC_MESSAGEQUEUEDEFINITIONS_H_ */
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 812cd34b..1c11afd4 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -1,129 +1,129 @@
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength),
-		constBuffer(buffer), buffer(nullptr),
-		bufferLength(bufferLength) {}
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
-		count_t bufferLength, bool serializeLength) :
-		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
-		bufferLength(bufferLength) {}
-
-
-template<typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	if (serializeLength) {
-		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
-				buffer, size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-
-	if (*size + bufferLength > maxSize) {
-		return BUFFER_TOO_SHORT;
-	}
-
-	if (this->constBuffer != nullptr) {
-		std::memcpy(*buffer, this->constBuffer, bufferLength);
-	}
-	else if (this->buffer != nullptr) {
-		// This will propably be never reached, constBuffer should always be
-		// set if non-const buffer is set.
-		std::memcpy(*buffer, this->buffer, bufferLength);
-	}
-	else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	*size += bufferLength;
-	(*buffer) += bufferLength;
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-template<typename count_t>
-size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
-	if (serializeLength) {
-		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
-	} else {
-		return bufferLength;
-	}
-}
-
-template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	if (this->buffer == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	if(serializeLength){
-		count_t lengthField = 0;
-		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
-				buffer, size, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if(lengthField > bufferLength) {
-			return TOO_MANY_ELEMENTS;
-		}
-		bufferLength = lengthField;
-	}
-
-	if (bufferLength <= *size) {
-		*size -= bufferLength;
-		std::memcpy(this->buffer, *buffer, bufferLength);
-		(*buffer) += bufferLength;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-template<typename count_t>
-uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
-	if(buffer == nullptr) {
-		sif::error << "Wrong access function for stored type !"
-				 " Use getConstBuffer()." << std::endl;
-		return nullptr;
-	}
-	return buffer;
-}
-
-template<typename count_t>
-const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
-	if(constBuffer == nullptr) {
-		sif::error << "SerialBufferAdapter::getConstBuffer:"
-				" Buffers are unitialized!" << std::endl;
-		return nullptr;
-	}
-	return constBuffer;
-}
-
-template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
-		count_t bufferLength) {
-	this->buffer = buffer;
-	this->constBuffer = buffer;
-	this->bufferLength = bufferLength;
-}
-
-
-//forward Template declaration for linker
-template class SerialBufferAdapter<uint8_t>;
-template class SerialBufferAdapter<uint16_t>;
-template class SerialBufferAdapter<uint32_t>;
-template class SerialBufferAdapter<uint64_t>;
-
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include <cstring>
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(const uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength),
+		constBuffer(buffer), buffer(nullptr),
+		bufferLength(bufferLength) {}
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer,
+		count_t bufferLength, bool serializeLength) :
+		serializeLength(serializeLength), constBuffer(buffer), buffer(buffer),
+		bufferLength(bufferLength) {}
+
+
+template<typename count_t>
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, size_t maxSize, Endianness streamEndianness) const {
+	if (serializeLength) {
+		ReturnValue_t result = SerializeAdapter::serialize(&bufferLength,
+				buffer, size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
+
+	if (*size + bufferLength > maxSize) {
+		return BUFFER_TOO_SHORT;
+	}
+
+	if (this->constBuffer != nullptr) {
+		std::memcpy(*buffer, this->constBuffer, bufferLength);
+	}
+	else if (this->buffer != nullptr) {
+		// This will propably be never reached, constBuffer should always be
+		// set if non-const buffer is set.
+		std::memcpy(*buffer, this->buffer, bufferLength);
+	}
+	else {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	*size += bufferLength;
+	(*buffer) += bufferLength;
+	return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+template<typename count_t>
+size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
+	if (serializeLength) {
+		return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
+	} else {
+		return bufferLength;
+	}
+}
+
+template<typename count_t>
+ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
+		size_t* size, Endianness streamEndianness) {
+	if (this->buffer == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	if(serializeLength){
+		count_t lengthField = 0;
+		ReturnValue_t result = SerializeAdapter::deSerialize(&lengthField,
+				buffer, size, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		if(lengthField > bufferLength) {
+			return TOO_MANY_ELEMENTS;
+		}
+		bufferLength = lengthField;
+	}
+
+	if (bufferLength <= *size) {
+		*size -= bufferLength;
+		std::memcpy(this->buffer, *buffer, bufferLength);
+		(*buffer) += bufferLength;
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		return STREAM_TOO_SHORT;
+	}
+}
+
+template<typename count_t>
+uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
+	if(buffer == nullptr) {
+		sif::error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()." << std::endl;
+		return nullptr;
+	}
+	return buffer;
+}
+
+template<typename count_t>
+const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
+	if(constBuffer == nullptr) {
+		sif::error << "SerialBufferAdapter::getConstBuffer:"
+				" Buffers are unitialized!" << std::endl;
+		return nullptr;
+	}
+	return constBuffer;
+}
+
+template<typename count_t>
+void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer,
+		count_t bufferLength) {
+	this->buffer = buffer;
+	this->constBuffer = buffer;
+	this->bufferLength = bufferLength;
+}
+
+
+//forward Template declaration for linker
+template class SerialBufferAdapter<uint8_t>;
+template class SerialBufferAdapter<uint16_t>;
+template class SerialBufferAdapter<uint32_t>;
+template class SerialBufferAdapter<uint64_t>;
+
diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h
index c3dfcd8f..9a89e18b 100644
--- a/serialize/SerialBufferAdapter.h
+++ b/serialize/SerialBufferAdapter.h
@@ -1,78 +1,78 @@
-#ifndef SERIALBUFFERADAPTER_H_
-#define SERIALBUFFERADAPTER_H_
-
-#include "../serialize/SerializeIF.h"
-#include "../serialize/SerializeAdapter.h"
-
-/**
- * This adapter provides an interface for SerializeIF to serialize or deserialize
- * buffers with no length header but a known size.
- *
- * Additionally, the buffer length can be serialized too and will be put in
- * front of the serialized buffer.
- *
- * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
- * Right now, the SerialBufferAdapter must always
- * be initialized with the buffer and size !
- *
- * \ingroup serialize
- */
-template<typename count_t>
-class SerialBufferAdapter: public SerializeIF {
-public:
-
-    /**
-     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength
-     */
-    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    /**
-     * Constructor for non-constant uint8_t buffer.
-     * Length field can be serialized optionally.
-     * Type of length can be supplied as template type.
-     * @param buffer
-     * @param bufferLength
-     * @param serializeLength Length field will be serialized with size count_t
-     */
-    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
-            bool serializeLength = false);
-
-    virtual ~SerialBufferAdapter();
-
-    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-            size_t maxSize, Endianness streamEndianness) const override;
-
-    virtual size_t getSerializedSize() const override;
-
-    /**
-     * @brief This function deserializes a buffer into the member buffer.
-     * @details
-     * If a length field is present, it is ignored, as the size should have
-     * been set in the constructor. If the size is not known beforehand,
-     * consider using SerialFixedArrayListAdapter instead.
-     * @param buffer [out] Resulting buffer
-     * @param size remaining size to deserialize, should be larger than buffer
-     *        + size field size
-     * @param bigEndian
-     * @return
-     */
-    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-            Endianness streamEndianness) override;
-
-    uint8_t * getBuffer();
-    const uint8_t * getConstBuffer();
-    void setBuffer(uint8_t* buffer, count_t bufferLength);
-private:
-	bool serializeLength = false;
-	const uint8_t *constBuffer = nullptr;
-	uint8_t *buffer = nullptr;
-	count_t bufferLength = 0;
-};
-
-#endif /* SERIALBUFFERADAPTER_H_ */
+#ifndef SERIALBUFFERADAPTER_H_
+#define SERIALBUFFERADAPTER_H_
+
+#include "../serialize/SerializeIF.h"
+#include "../serialize/SerializeAdapter.h"
+
+/**
+ * This adapter provides an interface for SerializeIF to serialize or deserialize
+ * buffers with no length header but a known size.
+ *
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
+ *
+ * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
+ *
+ * \ingroup serialize
+ */
+template<typename count_t>
+class SerialBufferAdapter: public SerializeIF {
+public:
+
+    /**
+     * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength
+     */
+    SerialBufferAdapter(const uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    /**
+     * Constructor for non-constant uint8_t buffer.
+     * Length field can be serialized optionally.
+     * Type of length can be supplied as template type.
+     * @param buffer
+     * @param bufferLength
+     * @param serializeLength Length field will be serialized with size count_t
+     */
+    SerialBufferAdapter(uint8_t* buffer, count_t bufferLength,
+            bool serializeLength = false);
+
+    virtual ~SerialBufferAdapter();
+
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const override;
+
+    virtual size_t getSerializedSize() const override;
+
+    /**
+     * @brief This function deserializes a buffer into the member buffer.
+     * @details
+     * If a length field is present, it is ignored, as the size should have
+     * been set in the constructor. If the size is not known beforehand,
+     * consider using SerialFixedArrayListAdapter instead.
+     * @param buffer [out] Resulting buffer
+     * @param size remaining size to deserialize, should be larger than buffer
+     *        + size field size
+     * @param bigEndian
+     * @return
+     */
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) override;
+
+    uint8_t * getBuffer();
+    const uint8_t * getConstBuffer();
+    void setBuffer(uint8_t* buffer, count_t bufferLength);
+private:
+	bool serializeLength = false;
+	const uint8_t *constBuffer = nullptr;
+	uint8_t *buffer = nullptr;
+	count_t bufferLength = 0;
+};
+
+#endif /* SERIALBUFFERADAPTER_H_ */

From 1b5c3786b61ceecdb4e7cf1b7b664e81399dbcf6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:24:06 +0200
Subject: [PATCH 0774/1292] taken over serviceinterface folder

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 2 +-
 serviceinterface/ServiceInterfaceStream.cpp | 2 +-
 serviceinterface/ServiceInterfaceStream.h   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 880f51e1..68fc4dec 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,5 +1,5 @@
 #include "../timemanager/Clock.h"
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"
 #include <cstring>
 #include <inttypes.h>
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 8a358999..5b7b9f00 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,4 +1,4 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "ServiceInterfaceStream.h"
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 051500f5..76fa1bf2 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
-#include "../serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"
 #include <iostream>
 #include <cstdio>
 

From 4d4166071ca864ce4e60d0aa92ddcc6b74fa1644 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:28:20 +0200
Subject: [PATCH 0775/1292] added pus services to framework objects

---
 objectmanager/frameworkObjects.h | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 46d5feea..4a30e70a 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -1,10 +1,14 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
-#define FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#ifndef FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#define FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
 
 namespace objects {
 enum framework_objects {
 	// Default verification reporter.
-	PUS_SERVICE_1 = 0x53000000,
+	PUS_SERVICE_1 = 0x53000001,
+	PUS_SERVICE_2 = 0x53000002,
+	PUS_SERVICE_5 = 0x53000005,
+	PUS_SERVICE_8 = 0x53000008,
+	PUS_SERVICE_200 = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
@@ -22,4 +26,4 @@ enum framework_objects {
 
 
 
-#endif /* FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */
+#endif /* FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */

From f50a80fc3c61066d69117d033b59a85722212c09 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:29:42 +0200
Subject: [PATCH 0776/1292] minor tweaks

---
 objectmanager/ObjectManager.cpp |  2 +-
 objectmanager/ObjectManager.h   | 27 +++++++++++----------------
 2 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a8c84415..5871bfcd 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,4 +1,4 @@
-#include "../objectmanager/ObjectManager.h"
+#include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 #include <cstdlib>
diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h
index e582584c..69a74f73 100644
--- a/objectmanager/ObjectManager.h
+++ b/objectmanager/ObjectManager.h
@@ -1,15 +1,8 @@
-/**
- * @file	ObjectManager.h
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
+#define FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
 
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../objectmanager/SystemObjectIF.h"
+#include "ObjectManagerIF.h"
+#include "SystemObjectIF.h"
 #include <map>
 
 /**
@@ -22,14 +15,15 @@
  * 			most of the system initialization.
  * 			As the system is static after initialization, no new objects are
  * 			created or inserted into the list after startup.
- * \ingroup system_objects
+ * @ingroup system_objects
+ * @author	Bastian Baetz
  */
 class ObjectManager : public ObjectManagerIF {
 private:
 	//comparison?
 	/**
-	 * \brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 * @brief	This is the map of all initialized objects in the manager.
+	 * @details	Objects in the List must inherit the SystemObjectIF.
 	 */
 	std::map<object_id_t, SystemObjectIF*> objectList;
 protected:
@@ -54,7 +48,8 @@ public:
 	/**
 	 *	@brief	In the class's destructor, all objects in the list are deleted.
 	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	// SHOULDDO: If, for some reason, deleting an ObjectManager instance is
+	// required, check if this works.
 	virtual ~ObjectManager( void );
 	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
 	ReturnValue_t remove( object_id_t id );
@@ -64,4 +59,4 @@ public:
 
 
 
-#endif /* OBJECTMANAGER_H_ */
+#endif /* FSFW_OBJECTMANAGER_OBJECTMANAGER_H_ */

From 3a043b5773de78516ac6efd0c3b483e79ebd729e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:31:51 +0200
Subject: [PATCH 0777/1292] object manager tweaks complete

---
 objectmanager/ObjectManagerIF.h |  9 +++++----
 objectmanager/SystemObject.cpp  |  4 ++--
 objectmanager/SystemObject.h    | 19 +++++++++++--------
 objectmanager/SystemObjectIF.h  |  6 +++---
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 16619e23..1f462509 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
-#include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
+#include "frameworkObjects.h"
+#include "SystemObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
@@ -79,6 +79,7 @@ public:
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
+// maybe but this in the glob namespace to explicitely mark it global?
 extern ObjectManagerIF *objectManager;
 
 /*Documentation can be found in the class method declaration above.*/
diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp
index 61eaf90a..64330fbc 100644
--- a/objectmanager/SystemObject.cpp
+++ b/objectmanager/SystemObject.cpp
@@ -1,6 +1,6 @@
+#include "ObjectManager.h"
+#include "SystemObject.h"
 #include "../events/EventManagerIF.h"
-#include "../objectmanager/ObjectManager.h"
-#include "../objectmanager/SystemObject.h"
 
 SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
 		objectId(setObjectId), registered(doRegister) {
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index ae4b1389..9188693e 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -1,9 +1,9 @@
-#ifndef SYSTEMOBJECT_H_
-#define SYSTEMOBJECT_H_
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
 
+#include "SystemObjectIF.h"
 #include "../events/Event.h"
 #include "../events/EventReportingProxyIF.h"
-#include "../objectmanager/SystemObjectIF.h"
 #include "../timemanager/Clock.h"
 
 /**
@@ -13,7 +13,7 @@
  * 			class that is announced to ObjectManager. It automatically includes
  * 			itself (and therefore the inheriting class) in the object manager's
  * 			list.
- * \ingroup system_objects
+ * @ingroup system_objects
  */
 class SystemObject: public SystemObjectIF {
 private:
@@ -30,14 +30,16 @@ public:
 	 * @param parameter1
 	 * @param parameter2
 	 */
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
 
 	/**
 	 * @brief	The class's constructor.
 	 * @details	In the constructor, the object id is set and the class is
 	 * 			inserted in the object manager.
 	 * @param setObjectId	The id the object shall have.
-	 * @param doRegister	Determines if the object is registered in the global object manager.
+	 * @param doRegister	Determines if the object is registered in
+	 * 						the global object manager.
 	 */
 	SystemObject(object_id_t setObjectId, bool doRegister = true);
 	/**
@@ -48,7 +50,8 @@ public:
 	virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t checkObjectConnections();
 
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0) const;
 };
 
-#endif /* SYSTEMOBJECT_H_ */
+#endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */
diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h
index 108717af..315fde9b 100644
--- a/objectmanager/SystemObjectIF.h
+++ b/objectmanager/SystemObjectIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
-#define FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -59,4 +59,4 @@ public:
 	virtual ReturnValue_t checkObjectConnections() = 0;
 };
 
-#endif /* FRAMEWORK_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */
+#endif /* #ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */

From 5e3f40a2c1c163eaa36705de597db37b36ec8635 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 13:40:48 +0200
Subject: [PATCH 0778/1292] changes taken over from pull request

---
 objectmanager/ObjectManagerIF.h | 4 ++--
 objectmanager/SystemObject.h    | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 1f462509..4bd1d915 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -21,7 +21,7 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
 	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
 	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 ); //!< Can be used if the initialization of a SystemObject failed.
 	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
 
 protected:
@@ -79,7 +79,7 @@ public:
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
-// maybe but this in the glob namespace to explicitely mark it global?
+// SHOULDDO: maybe put this in the glob namespace to explicitely mark it global?
 extern ObjectManagerIF *objectManager;
 
 /*Documentation can be found in the class method declaration above.*/
diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h
index 9188693e..d9c4236d 100644
--- a/objectmanager/SystemObject.h
+++ b/objectmanager/SystemObject.h
@@ -13,6 +13,7 @@
  * 			class that is announced to ObjectManager. It automatically includes
  * 			itself (and therefore the inheriting class) in the object manager's
  * 			list.
+ * @author	Ulrich Mohr
  * @ingroup system_objects
  */
 class SystemObject: public SystemObjectIF {

From 33e7cca23c3175b7349654e790fadb9a2938546c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 15:01:35 +0200
Subject: [PATCH 0779/1292] several bugfixes amd improvements

---
 datapoollocal/LocalDataPoolManager.cpp |   5 +-
 pus/Service3Housekeeping.cpp           | 205 ++++++++++++++-----------
 pus/Service3Housekeeping.h             |  18 ++-
 3 files changed, 128 insertions(+), 100 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 619d8365..77851904 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -144,8 +144,11 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
         //return generateSetStructurePacket(message->getSid());
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				false, true);
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        //return generateHousekeepingPacket(message->getSid());
+        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+        		true, true);
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index db77328a..55e687cc 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -36,7 +36,6 @@ ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
 ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
 		const uint8_t *tcData, size_t tcDataLen,
 		MessageQueueId_t *id, object_id_t *objectId) {
-	return HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen);
 	if(result != RETURN_OK) {
 		return result;
@@ -55,7 +54,7 @@ ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(
 
 ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check OwnsLocalDataPoolIF property of target
+	// check HasLocalDataPoolIF property of target
 	HasLocalDataPoolIF* possibleTarget =
 			objectManager->get<HasLocalDataPoolIF>(*objectId);
 	if(possibleTarget == nullptr){
@@ -71,33 +70,35 @@ ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
 		uint32_t *state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)) {
 	case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, true, false,
+		return prepareReportingTogglingCommand(message, objectId, true, false,
 				tcData, tcDataLen);
 	case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, false, false,
+		return prepareReportingTogglingCommand(message, objectId, false, false,
 				tcData, tcDataLen);
 	case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, true, true,
+		return prepareReportingTogglingCommand(message, objectId, true, true,
 				tcData, tcDataLen);
 	case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
-		return prepareReportingTogglingCommand(message, false, true,
+		return prepareReportingTogglingCommand(message, objectId, false, true,
 				tcData, tcDataLen);
 	case Subservice::REPORT_HK_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, false, tcData,
+		return prepareStructureReportingCommand(message, objectId, false, tcData,
 				tcDataLen);
 	case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
-		return prepareStructureReportingCommand(message, true, tcData,
+		return prepareStructureReportingCommand(message, objectId, true, tcData,
 				tcDataLen);
 	case Subservice::GENERATE_ONE_PARAMETER_REPORT:
-		return prepareOneShotReportCommand(message, false, tcData, tcDataLen);
+		return prepareOneShotReportCommand(message, objectId, false,
+				tcData, tcDataLen);
 	case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
-		return prepareOneShotReportCommand(message, true, tcData, tcDataLen);
+		return prepareOneShotReportCommand(message, objectId, true,
+				tcData, tcDataLen);
 	case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, false,
-				tcData, tcDataLen);
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				false, tcData, tcDataLen);
 	case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
-		return prepareCollectionIntervalModificationCommand(message, true,
-				tcData, tcDataLen);
+		return prepareCollectionIntervalModificationCommand(message, objectId,
+				true, tcData, tcDataLen);
 	case Subservice::HK_DEFINITIONS_REPORT:
 	case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
 	case Subservice::HK_REPORT:
@@ -111,103 +112,59 @@ ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t *state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool *isStep) {
-	switch(reply->getCommand()) {
-	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
-	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
-		failureParameter1 = objectId;
-		// also provide failure reason (returnvalue)
-		// will be most commonly invalid SID or the set already has the desired
-		// reporting status.
-		return CommandingServiceBase::EXECUTION_COMPLETE;
-	}
-	default:
-		sif::error << "Service3Housekeeping::handleReply: Invalid reply!"
-				<< std::endl;
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
 ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
-		CommandMessage *command, bool enableReporting, bool isDiagnostics,
+		CommandMessage *command, object_id_t objectId,
+		bool enableReporting, bool isDiagnostics,
 		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+	if(tcDataLen < sizeof(object_id_t)) {
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-				SerializeIF::Endianness::BIG);
-
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
 			enableReporting, isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t* tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t* tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t)) {
-		// It is assumed the full SID is sent for now (even if that means
-		// 4 bytes are redundant)
+		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
-		CommandMessage *command, bool isDiagnostics, const uint8_t *tcData,
-		size_t tcDataLen) {
+		CommandMessage *command, object_id_t objectId, bool isDiagnostics,
+		const uint8_t *tcData, size_t tcDataLen) {
 	if(tcDataLen < sizeof(sid_t) + sizeof(float)) {
-		// It is assumed the full SID and the new collection interval as a float
-		// is sent for now (even if that means 4 bytes are redundant)
+		// SID plus the size of the new collection intervL.
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid;
+	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
 	float newCollectionInterval = 0;
-	SerializeAdapter::deSerialize(&targetSid.objectId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
-			SerializeIF::Endianness::BIG);
 	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
 			SerializeIF::Endianness::BIG);
 	HousekeepingMessage::setCollectionIntervalModificationCommand(command,
@@ -215,25 +172,76 @@ ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
+		Command_t previousCommand, uint32_t *state,
+		CommandMessage* optionalNextCommand, object_id_t objectId,
+		bool *isStep) {
+	Command_t command = reply->getCommand();
+	switch(command) {
+
+	case(HousekeepingMessage::HK_REPORT): {
+		ReturnValue_t result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		ReturnValue_t result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
+		failureParameter1 = objectId;
+		// also provide failure reason (returnvalue)
+		// will be most commonly invalid SID or the set already has the desired
+		// reporting status.
+		return CommandingServiceBase::EXECUTION_COMPLETE;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+				<< "reply command " << command << "!" << std::endl;
+		return CommandingServiceBase::INVALID_REPLY;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
 void Service3Housekeeping::handleUnrequestedReply(
-        CommandMessage* reply) {
+		CommandMessage* reply) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(reply->getCommand()) {
-    case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-    	result = generateHkReport(reply,
-    			static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
-    	break;
-    }
-    case(HousekeepingMessage::HK_REPORT): {
-        result = generateHkReport(reply,
-        		static_cast<uint8_t>(Subservice::HK_REPORT));
-        break;
-    }
-    default: {
-        sif::error << "Service3Housekeeping::handleUnrequestedReply: "
-                << "Invalid reply!" << std::endl;
-    }
-    }
+	Command_t command = reply->getCommand();
+
+	switch(command) {
+
+	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
+		result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
+		break;
+	}
+
+	case(HousekeepingMessage::HK_REPORT): {
+		result = generateHkReport(reply,
+				static_cast<uint8_t>(Subservice::HK_REPORT));
+		break;
+	}
+
+	default:
+		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
+				<< "reply command " << command << "!" << std::endl;
+		return;
+	}
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
@@ -260,3 +268,16 @@ ReturnValue_t Service3Housekeeping::generateHkReport(
 	return sendTmPacket(static_cast<uint8_t>(subserviceId),
 			hkPacket.hkData, hkPacket.hkSize, nullptr, 0);
 }
+
+sid_t Service3Housekeeping::buildSid(object_id_t objectId,
+		const uint8_t* tcData, size_t tcDataLen) {
+	sid_t targetSid;
+	targetSid.objectId = objectId;
+	// skip deserialization of object ID, was already done.
+	tcData += sizeof(object_id_t);
+	tcDataLen -= sizeof(object_id_t);
+	// size check is expected to be performed beforehand!
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+			SerializeIF::Endianness::BIG);
+	return targetSid;
+}
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 6c5d2469..1dab3153 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -85,17 +85,21 @@ private:
 	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
 			uint8_t subserviceId);
 	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
-			bool enableReporting, bool isDiagnostics, const uint8_t* tcData,
-			size_t tcDataLen);
+			object_id_t objectId, bool enableReporting, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
 	ReturnValue_t prepareStructureReportingCommand(CommandMessage* command,
-			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
-			bool isDiagnostics, const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareCollectionIntervalModificationCommand(
-			CommandMessage* command, bool isDiagnostics, const uint8_t* tcData,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
 			size_t tcDataLen);
+	ReturnValue_t prepareOneShotReportCommand(CommandMessage* command,
+			object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
+			size_t tcDataLen);
+	ReturnValue_t prepareCollectionIntervalModificationCommand(
+			CommandMessage* command, object_id_t objectId, bool isDiagnostics,
+			const uint8_t* tcData, size_t tcDataLen);
 
 	void handleUnrequestedReply(CommandMessage* reply) override;
+	sid_t buildSid(object_id_t objectId, const uint8_t* tcData,
+			size_t tcDataLen);
 };
 
 #endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */

From 757d2275ea9f1f19e134e896459fa8a02c9bedcb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 18 Sep 2020 15:06:14 +0200
Subject: [PATCH 0780/1292] internal bugfix

---
 pus/Service3Housekeeping.cpp | 16 ++++++++--------
 pus/Service3Housekeeping.h   |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 55e687cc..d8e4466b 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -121,7 +121,7 @@ ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setToggleReportingCommand(command, targetSid,
 			enableReporting, isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -135,7 +135,7 @@ ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setStructureReportingCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -149,7 +149,7 @@ ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	HousekeepingMessage::setOneShotReportCommand(command, targetSid,
 			isDiagnostics);
 	return HasReturnvaluesIF::RETURN_OK;
@@ -163,7 +163,7 @@ ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand
 		return CommandingServiceBase::INVALID_TC;
 	}
 
-	sid_t targetSid = buildSid(objectId, tcData, tcDataLen);
+	sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
 	float newCollectionInterval = 0;
 	SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
 			SerializeIF::Endianness::BIG);
@@ -270,14 +270,14 @@ ReturnValue_t Service3Housekeeping::generateHkReport(
 }
 
 sid_t Service3Housekeeping::buildSid(object_id_t objectId,
-		const uint8_t* tcData, size_t tcDataLen) {
+		const uint8_t** tcData, size_t* tcDataLen) {
 	sid_t targetSid;
 	targetSid.objectId = objectId;
 	// skip deserialization of object ID, was already done.
-	tcData += sizeof(object_id_t);
-	tcDataLen -= sizeof(object_id_t);
+	*tcData += sizeof(object_id_t);
+	*tcDataLen -= sizeof(object_id_t);
 	// size check is expected to be performed beforehand!
-	SerializeAdapter::deSerialize(&targetSid.ownerSetId, &tcData, &tcDataLen,
+	SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
 			SerializeIF::Endianness::BIG);
 	return targetSid;
 }
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 1dab3153..01964bab 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -98,8 +98,8 @@ private:
 			const uint8_t* tcData, size_t tcDataLen);
 
 	void handleUnrequestedReply(CommandMessage* reply) override;
-	sid_t buildSid(object_id_t objectId, const uint8_t* tcData,
-			size_t tcDataLen);
+	sid_t buildSid(object_id_t objectId, const uint8_t** tcData,
+			size_t* tcDataLen);
 };
 
 #endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */

From ba56f48e8e87f0087b9c5e29846723505abe71cf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 01:17:43 +0200
Subject: [PATCH 0781/1292] huge progress on hk + testing

---
 datapoollocal/LocalDataPoolManager.cpp       | 127 ++++++++++++++++---
 datapoollocal/LocalDataPoolManager.h         |  29 +++--
 datapoollocal/LocalPoolDataSetBase.cpp       |  16 +++
 datapoollocal/LocalPoolDataSetBase.h         |  15 ++-
 datapoollocal/LocalPoolVariable.h            |  14 +-
 datapoollocal/LocalPoolVariable.tpp          |   6 +-
 datapoollocal/LocalPoolVector.h              |  10 +-
 datapoollocal/LocalPoolVector.tpp            |  27 ++--
 globalfunctions/PeriodicOperationDivider.cpp |  14 +-
 globalfunctions/PeriodicOperationDivider.h   |  12 +-
 housekeeping/HousekeepingMessage.cpp         |   2 +-
 housekeeping/HousekeepingMessage.h           |  10 +-
 housekeeping/HousekeepingPacketDownlink.h    |  16 +--
 housekeeping/HousekeepingPacketUpdate.h      |   6 +-
 housekeeping/HousekeepingSetPacket.h         |  13 ++
 pus/Service3Housekeeping.cpp                 |   2 +-
 16 files changed, 237 insertions(+), 82 deletions(-)
 create mode 100644 housekeeping/HousekeepingSetPacket.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 77851904..17c7ad1d 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -35,7 +35,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
 	    AcceptsHkPacketsIF* hkPacketReceiver =
 	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
 	    if(hkPacketReceiver != nullptr) {
-	        defaultHkDestinationId = hkPacketReceiver->getHkQueue();
+	        hkDestinationId = hkPacketReceiver->getHkQueue();
 	    }
 	}
 }
@@ -78,9 +78,6 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
     for(auto& hkReceiversIter: hkReceiversMap) {
         HkReceiver* receiver = &hkReceiversIter.second;
-        if(not receiver->reportingEnabled) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
 
         switch(receiver->reportingType) {
         case(ReportingType::PERIODIC): {
@@ -118,7 +115,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.dataId.dataSetSid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
-	hkReceiver.reportingEnabled = enableReporting;
+
 	if(not isDiagnostics) {
 	    hkReceiver.hkParameter.collectionIntervalTicks =
 	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
@@ -129,7 +126,13 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
 	}
 
-	hkReceiver.isDiagnostics = isDiagnostics;
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+	            owner->getDataSetHandle(sid));
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(enableReporting);
+		dataSet->setIsDiagnostic(isDiagnostics);
+	}
+
 	hkReceiver.intervalCounter = 1;
 
 	hkReceiversMap.emplace(packetDestination, hkReceiver);
@@ -139,16 +142,51 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
+    sid_t sid = HousekeepingMessage::getSid(message);
     switch(command) {
+    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION):
+    	return togglePeriodicGeneration(sid, true, true);
+    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION):
+		return togglePeriodicGeneration(sid, false, true);
+    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION):
+		return togglePeriodicGeneration(sid, true, false);
+    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
+		return togglePeriodicGeneration(sid, false, false);
+
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        //return generateSetStructurePacket(message->getSid());
+		return generateSetStructurePacket(sid);
+
+    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+    	float newCollIntvl = 0;
+    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+    			&newCollIntvl);
+    	if(command == HousekeepingMessage::
+    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+    		return changeCollectionInterval(sid, newCollIntvl, true);
+    	}
+    	else {
+    		return changeCollectionInterval(sid, newCollIntvl, false);
+    	}
+    }
+
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-				false, true);
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT):
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-        		true, true);
+    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+    			owner->getDataSetHandle(sid));
+    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+    			and dataSet->getIsDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+    			and not dataSet->getIsDiagnostics()) {
+    		return WRONG_HK_PACKET_TYPE;
+    	}
+    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+    			dataSet, true);
+    }
+
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
@@ -175,17 +213,17 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        bool isDiagnostics, bool forDownlink, MessageQueueId_t destination) {
-	LocalPoolDataSetBase* dataSetToSerialize =
-			dynamic_cast<LocalPoolDataSetBase*>(owner->getDataSetHandle(sid));
-	if(dataSetToSerialize == nullptr) {
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				" Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSetToSerialize);
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
 	size_t serializedSize = 0;
 	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
 			forDownlink, &serializedSize);
@@ -195,7 +233,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(isDiagnostics) {
+	if(dataSet->getIsDiagnostics()) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -206,11 +244,11 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	    return QUEUE_OR_DESTINATION_NOT_SET;
 	}
 	if(destination == MessageQueueIF::NO_QUEUE) {
-	    if(defaultHkDestinationId == MessageQueueIF::NO_QUEUE) {
+	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
 	        // error, all destinations invalid
 	        return HasReturnvaluesIF::RETURN_FAILED;
 	    }
-	    destination = defaultHkDestinationId;
+	    destination = hkDestinationId;
 	}
 
 	return hkQueue->sendMessage(destination, &hkMessage);
@@ -273,8 +311,15 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
+    	sid_t sid = receiver->dataId.dataSetSid;
+    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+    			owner->getDataSetHandle(sid));
+    	if(not dataSet->getReportingEnabled()) {
+    		return;
+    	}
+
         ReturnValue_t result = generateHousekeepingPacket(
-                receiver->dataId.dataSetSid, receiver->isDiagnostics, true);
+                sid, dataSet, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             // configuration error
             sif::debug << "LocalDataPoolManager::performHkOperation:"
@@ -312,3 +357,43 @@ float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
                 regularMinimumInterval);
     }
 }
+
+ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
+		bool enable, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+			owner->getDataSetHandle(sid));
+	if((dataSet->getIsDiagnostics() and not isDiagnostics) or
+			(not dataSet->getIsDiagnostics() and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	if((dataSet->getReportingEnabled() and enable) or
+			(not dataSet->getReportingEnabled() and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
+
+	dataSet->setReportingEnabled(enable);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
+		float newCollectionInterval, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+				owner->getDataSetHandle(sid));
+	bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
+
+	for(auto& receiver: hkReceiversMap) {
+		if(receiver.second.reportingType != ReportingType::PERIODIC) {
+			continue;
+		}
+
+		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
+				newCollectionInterval);
+		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 1ab08903..559b8cc2 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -23,7 +23,7 @@ class LocalDataSetBase;
 
 
 /**
- * @brief 	This class is the managing instance for local data pool.
+ * @brief 		This class is the managing instance for the local data pool.
  * @details
  * The actual data pool structure is a member of this class. Any class which
  * has a local data pool shall have this class as a member and implement
@@ -37,7 +37,7 @@ class LocalDataSetBase;
  * value is stored. The helper classes offer a read() and commit() interface
  * through the PoolVariableIF which is used to read and update values.
  * Each pool entry has a valid state too.
- * @author R. Mueller
+ * @author 		R. Mueller
  */
 class LocalDataPoolManager {
 	template<typename T>
@@ -49,11 +49,13 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
 
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -110,8 +112,8 @@ public:
 	 * @return
 	 */
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			bool isDiagnostics, bool forDownlink,
-	        MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+			LocalPoolDataSetBase* dataSet, bool forDownlink,
+			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@@ -169,7 +171,7 @@ private:
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
-	MessageQueueId_t defaultHkDestinationId = MessageQueueIF::NO_QUEUE;
+	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
@@ -185,8 +187,11 @@ private:
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
+        // SHOULDDO: it would be nice to also have the object ID instead of
+        // a queue (or in addition).. but the FSFW is not ready  for that yet.
+        // Also, an object can have multiple queues.
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-        bool reportingEnabled = true;
+
         /** Different members of this union will be used depending on reporting
         type */
         union HkParameter {
@@ -196,7 +201,6 @@ private:
             bool hkDataChanged;
         };
         HkParameter hkParameter;
-        bool isDiagnostics;
         /** General purpose counter which is used for periodic generation. */
         uint32_t intervalCounter;
     };
@@ -245,7 +249,6 @@ private:
 	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
 			PoolEntry<T> **poolEntry);
 
-	void setMinimalSamplingFrequency(float frequencySeconds);
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
@@ -256,6 +259,10 @@ private:
 	        uint32_t collectionInterval);
 
 	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
+	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
+			bool isDiagnostics);
+	ReturnValue_t changeCollectionInterval(sid_t sid,
+			float newCollectionInterval, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 859f1f2c..362e8981 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -175,6 +175,22 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
+void LocalPoolDataSetBase::setIsDiagnostic(bool isDiagnostics) {
+	this->isDiagnostics = isDiagnostics;
+}
+
+bool LocalPoolDataSetBase::getIsDiagnostics() const {
+	return isDiagnostics;
+}
+
+void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
+	this->reportingEnabled = reportingEnabled;
+}
+
+bool LocalPoolDataSetBase::getReportingEnabled() const {
+	return reportingEnabled;
+}
+
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 		uint8_t position) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 17c20d4f..69c71d5a 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -32,6 +32,7 @@ class LocalDataPoolManager;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase {
+	friend class LocalDataPoolManager;
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
@@ -97,11 +98,23 @@ public:
 	 * If this is true, all contained datasets will also be set recursively.
 	 */
 	void setValidity(bool valid, bool setEntriesRecursively);
-
 	bool isValid() const override;
 
+	void setIsDiagnostic(bool diagnostics);
+	bool getIsDiagnostics() const;
+
 protected:
 	sid_t sid;
+
+	bool isDiagnostics = false;
+
+	void setReportingEnabled(bool enabled);
+	bool getReportingEnabled() const;
+	/**
+	 * Used for periodic generation.
+	 */
+    bool reportingEnabled = false;
+
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 7107bffe..6047342e 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -38,13 +38,14 @@ public:
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner Pointer of the owner. This will generally be the calling
 	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+
 	 */
 	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -58,13 +59,14 @@ public:
 	 * the pool variable in that dataset directly.
 	 * @param poolId ID of the local pool entry.
 	 * @param hkOwner object ID of the pool owner.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
+	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
+	 *
 	 */
 	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	virtual~ LocalPoolVar() {};
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 6e6f27aa..09d10acc 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,8 +7,8 @@
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
-		DataSetIF* dataSet):
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
 		localPoolId(poolId),readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
@@ -27,7 +27,7 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-		pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
 		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 86705bb0..69df192c 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -47,8 +47,9 @@ public:
 	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -65,8 +66,9 @@ public:
 	 * If nullptr, the variable is not registered.
 	 */
 	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE,
-			DataSetIF* dataSet = nullptr);
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
+			);
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 7c3d2c1e..2aa6fbb5 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,14 +7,14 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, pool_rwm_t setReadWriteMode,
-		DataSetIF* dataSet) :
+		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+		pool_rwm_t setReadWriteMode):
 		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
 	}
-	memset(this->value, 0, vectorSize * sizeof(T));
+	std::memset(this->value, 0, vectorSize * sizeof(T));
 	hkManager = hkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
@@ -23,17 +23,18 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		object_id_t poolOwner, pool_rwm_t setReadWriteMode, DataSetIF *dataSet):
-		readWriteMode(readWriteMode) {
+		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
+				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
 	}
 	HasLocalDataPoolIF* hkOwner =
 			objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
-				"the correct interface HasHkPoolParametersIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface HasHkPoolParametersIF!"
+				<< std::endl;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
@@ -67,7 +68,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 				std::dec << " failed." << std::endl;
 		return result;
 	}
-	memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
+	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
 	this->valid = poolEntry->valid;
 	return RETURN_OK;
 }
@@ -96,7 +97,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				std::dec << " failed.\n" << std::flush;
 		return result;
 	}
-	memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
+	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
 	poolEntry->valid = this->valid;
 	return RETURN_OK;
 }
diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp
index ad3b8bbd..28e98feb 100644
--- a/globalfunctions/PeriodicOperationDivider.cpp
+++ b/globalfunctions/PeriodicOperationDivider.cpp
@@ -7,16 +7,26 @@ PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
 }
 
 bool PeriodicOperationDivider::checkAndIncrement() {
-	if(counter >= divider) {
+	bool opNecessary = check();
+	if(opNecessary) {
 		if(resetAutomatically) {
 			counter = 0;
 		}
-		return true;
+		return opNecessary;
 	}
 	counter ++;
+	return opNecessary;
+}
+
+bool PeriodicOperationDivider::check() {
+	if(counter >= divider) {
+		return true;
+	}
 	return false;
 }
 
+
+
 void PeriodicOperationDivider::resetCounter() {
 	counter = 0;
 }
diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h
index dd970fb8..7f7fb469 100644
--- a/globalfunctions/PeriodicOperationDivider.h
+++ b/globalfunctions/PeriodicOperationDivider.h
@@ -21,17 +21,27 @@ public:
 	 */
 	PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
 
+
 	/**
 	 * Check whether operation is necessary.
 	 * If an operation is necessary and the class has been
 	 * configured to be reset automatically, the counter will be reset.
-	 * If not, the counter will be incremented.
+	 *
 	 * @return
 	 * -@c true if the counter is larger or equal to the divider
 	 * -@c false otherwise
 	 */
 	bool checkAndIncrement();
 
+	/**
+	 * Checks whether an operation is necessary.
+	 * This function will not increment the counter!
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool check();
+
 	/**
 	 * Can be used to reset the counter to 0 manually.
 	 */
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 65ba8c94..a3aab03a 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -39,7 +39,7 @@ void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message,
 	}
 	else {
 		if(enableReporting) {
-			message->setCommand(ENABLE_PERIODIC_HK_GENERATION);
+			message->setCommand(ENABLE_PERIODIC_HK_REPORT_GENERATION);
 		}
 		else {
 			message->setCommand(DISABLE_PERIODIC_HK_REPORT_GENERATION);
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 81fa2f02..6a3ca616 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -33,6 +33,14 @@ union sid_t {
 	bool notSet() const {
 	    return raw == INVALID_ADDRESS;
 	}
+
+	bool operator==(const sid_t& other) const {
+		return raw == other.raw;
+	}
+
+	bool operator!=(const sid_t& other) const {
+		return not (raw == other.raw);
+	}
 };
 
 
@@ -57,7 +65,7 @@ public:
 
 	static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
 
-	static constexpr Command_t ENABLE_PERIODIC_HK_GENERATION =
+	static constexpr Command_t ENABLE_PERIODIC_HK_REPORT_GENERATION =
 			MAKE_COMMAND_ID(5);
 	static constexpr Command_t DISABLE_PERIODIC_HK_REPORT_GENERATION =
 			MAKE_COMMAND_ID(6);
diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h
index 0be1551d..ae0cc988 100644
--- a/housekeeping/HousekeepingPacketDownlink.h
+++ b/housekeeping/HousekeepingPacketDownlink.h
@@ -14,13 +14,8 @@
  */
 class HousekeepingPacketDownlink: public SerialLinkedListAdapter<SerializeIF> {
 public:
-    HousekeepingPacketDownlink(sid_t sid, /*bool reportingStatus,
-    		float collectionInterval, uint8_t numberOfParameters, */
-			LocalPoolDataSetBase* dataSetPtr):
-            sourceId(sid.objectId), setId(sid.ownerSetId),
-			/*reportingStatus(reportingStatus),
-			collectionInterval(collectionInterval),
-            numberOfParameters(numberOfParameters), */hkData(dataSetPtr) {
+    HousekeepingPacketDownlink(sid_t sid, LocalPoolDataSetBase* dataSetPtr):
+            sourceId(sid.objectId), setId(sid.ownerSetId), hkData(dataSetPtr) {
         setLinks();
     }
 
@@ -29,17 +24,10 @@ private:
         setStart(&sourceId);
         sourceId.setNext(&setId);
         setId.setNext(&hkData);
-        //setId.setNext(&reportingStatus);
-		//reportingStatus.setNext(&collectionInterval);
-        //collectionInterval.setNext(&numberOfParameters);
-        //numberOfParameters.setNext(&hkData);
     }
 
     SerializeElement<object_id_t> sourceId;
     SerializeElement<uint32_t> setId;
-    //SerializeElement<uint8_t> reportingStatus;
-    //SerializeElement<float> collectionInterval;
-    //SerializeElement<uint8_t> numberOfParameters;
     LinkedElement<SerializeIF> hkData;
 };
 
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index e7b644f5..eebdc11c 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 #define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/datapoollocal/LocalPoolDataSetBase.h>
+#include "../serialize/SerialBufferAdapter.h"
+#include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 
 /**
  * @brief   This helper class will be used to serialize and deserialize
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
new file mode 100644
index 00000000..9a717420
--- /dev/null
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -0,0 +1,13 @@
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+
+#include "../serialize/SerialLinkedListAdapter.h"
+
+class HousekeepingSetPacket: public SerialLinkedListAdapter<SerializeIF> {
+
+
+};
+
+
+
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index d8e4466b..0d63a4e2 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -116,7 +116,7 @@ ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
 		CommandMessage *command, object_id_t objectId,
 		bool enableReporting, bool isDiagnostics,
 		const uint8_t* tcData, size_t tcDataLen) {
-	if(tcDataLen < sizeof(object_id_t)) {
+	if(tcDataLen < sizeof(sid_t)) {
 		// TC data should consist of object ID and set ID.
 		return CommandingServiceBase::INVALID_TC;
 	}

From 9ecbc8199e458e6c56a91c4de91b6217d30d9ea3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 02:46:29 +0200
Subject: [PATCH 0782/1292] added periodic helper

---
 datapoollocal/LocalDataPoolManager.cpp      | 92 ++++++++++++---------
 datapoollocal/LocalDataPoolManager.h        |  3 +-
 datapoollocal/LocalPoolDataSetBase.cpp      |  3 +
 datapoollocal/LocalPoolDataSetBase.h        | 15 ++--
 housekeeping/HousekeepingSetPacket.h        | 49 ++++++++++-
 housekeeping/PeriodicHousekeepingHelper.cpp | 47 +++++++++++
 housekeeping/PeriodicHousekeepingHelper.h   | 35 ++++++++
 7 files changed, 195 insertions(+), 49 deletions(-)
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.cpp
 create mode 100644 housekeeping/PeriodicHousekeepingHelper.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 17c7ad1d..48d57a91 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/housekeeping/HousekeepingSetPacket.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolDataSetBase.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
@@ -155,8 +156,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-		return generateSetStructurePacket(sid);
-
+		//return generateSetStructurePacket(sid, );
+		return HasReturnvaluesIF::RETURN_OK;
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
     	float newCollIntvl = 0;
@@ -274,40 +275,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
             SerializeIF::Endianness::MACHINE);
 }
 
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
-}
-
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
         uint8_t nonDiagInvlFactor) {
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
     if(receiver->intervalCounter >=
             receiver->hkParameter.collectionIntervalTicks) {
@@ -386,14 +358,56 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	for(auto& receiver: hkReceiversMap) {
-		if(receiver.second.reportingType != ReportingType::PERIODIC) {
-			continue;
-		}
-
-		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
-				newCollectionInterval);
-		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+	if(dataSet->periodicHelper == nullptr) {
+		// config error
+		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+
+	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+//	for(auto& receiver: hkReceiversMap) {
+//		if(receiver.second.reportingType != ReportingType::PERIODIC) {
+//			continue;
+//		}
+//
+//		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
+//				newCollectionInterval);
+//		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
+
+ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
+		float collectionInterval, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+            owner->getDataSetHandle(sid));
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    bool valid = dataSet->isValid();
+    bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+    bool reportingEnabled = dataSet->getReportingEnabled();
+
+    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid, reportingEnabled,
+    		valid, collectionInterval, dataSet);
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
+    size_t size = 0;
+    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
+            expectedSize, SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                "Expected size is not equal to serialized size" << std::endl;
+    }
+    return result;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 559b8cc2..2a5c68b5 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -114,7 +114,6 @@ public:
 	ReturnValue_t generateHousekeepingPacket(sid_t sid,
 			LocalPoolDataSetBase* dataSet, bool forDownlink,
 			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-	ReturnValue_t generateSetStructurePacket(sid_t sid);
 
 	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
@@ -263,6 +262,8 @@ private:
 			bool isDiagnostics);
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
+	ReturnValue_t generateSetStructurePacket(sid_t sid,
+			float collectionInterval, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 362e8981..e0fc6b68 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -17,6 +17,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
+
+    // Data creators get a periodic helper for periodic HK data generation.
+    periodicHelper = new PeriodicHousekeepingHelper(this);
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 69c71d5a..2f7db9fb 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
+#include <fsfw/housekeeping/PeriodicHousekeepingHelper.h>
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -33,6 +34,7 @@ class LocalDataPoolManager;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase {
 	friend class LocalDataPoolManager;
+	friend class PeriodicHousekeepingHelper;
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
@@ -100,20 +102,19 @@ public:
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
-	void setIsDiagnostic(bool diagnostics);
-	bool getIsDiagnostics() const;
-
 protected:
 	sid_t sid;
 
 	bool isDiagnostics = false;
+	void setIsDiagnostic(bool diagnostics);
+	bool getIsDiagnostics() const;
 
-	void setReportingEnabled(bool enabled);
-	bool getReportingEnabled() const;
 	/**
 	 * Used for periodic generation.
 	 */
-    bool reportingEnabled = false;
+	bool reportingEnabled = false;
+	void setReportingEnabled(bool enabled);
+	bool getReportingEnabled() const;
 
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
@@ -147,7 +148,7 @@ protected:
 	void bitSetter(uint8_t* byte, uint8_t position) const;
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 private:
-
+	PeriodicHousekeepingHelper* periodicHelper = nullptr;
 
 };
 
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 9a717420..007b95be 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -1,13 +1,58 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
 
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../serialize/SerialLinkedListAdapter.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 
 class HousekeepingSetPacket: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	HousekeepingSetPacket(sid_t sid, bool reportingEnabled, bool valid,
+			float collectionInterval, LocalPoolDataSetBase* dataSetPtr):
+			objectId(sid.objectId), setId(sid.ownerSetId),
+			reportingEnabled(reportingEnabled), valid(valid),
+			collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) {
+	}
 
+	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+				size_t maxSize, Endianness streamEndianness) const override {
+		ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size,
+				maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+		return dataSet->serializeLocalPoolIds(buffer, size ,maxSize,
+				streamEndianness);
+	}
 
+	size_t getSerializedSize() const override {
+		size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
+		linkedSize += dataSet->getFillCount() * sizeof(lp_id_t);
+		return linkedSize;
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+				Endianness streamEndianness) override {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+private:
+
+	void setLinks() {
+		setStart(&objectId);
+		objectId.setNext(&setId);
+		setId.setNext(&reportingEnabled);
+		reportingEnabled.setNext(&valid);
+		valid.setNext(&collectionIntervalSeconds);
+		collectionIntervalSeconds.setEnd();
+	}
+
+	SerializeElement<object_id_t> objectId;
+	SerializeElement<uint32_t> setId;
+	SerializeElement<bool> reportingEnabled;
+	SerializeElement<bool> valid;
+	SerializeElement<float> collectionIntervalSeconds;
+	LocalPoolDataSetBase* dataSet;
 };
 
-
-
 #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
new file mode 100644
index 00000000..c2ae8126
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -0,0 +1,47 @@
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "PeriodicHousekeepingHelper.h"
+#include <cmath>
+
+PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(
+		LocalPoolDataSetBase* owner): owner(owner) {}
+
+
+void PeriodicHousekeepingHelper::initialize(float collectionInterval,
+		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+		uint8_t nonDiagIntervalFactor) {
+	this->minimumPeriodicInterval = minimumPeriodicInterval;
+	if(not owner->getIsDiagnostics()) {
+		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
+				nonDiagIntervalFactor;
+	}
+}
+
+float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
+	return intervalToIntervalSeconds(collectionIntervalTicks);
+}
+
+bool PeriodicHousekeepingHelper::checkOpNecessary() {
+	if(internalTickCounter >= collectionIntervalTicks) {
+		internalTickCounter = 1;
+		return true;
+	}
+	internalTickCounter++;
+	return false;
+}
+
+uint32_t PeriodicHousekeepingHelper::intervalSecondsToInterval(
+		float collectionIntervalSeconds) {
+        return std::ceil(collectionIntervalSeconds * 1000
+                / minimumPeriodicInterval);
+}
+
+float PeriodicHousekeepingHelper::intervalToIntervalSeconds(
+		uint32_t collectionInterval) {
+	return static_cast<float>(collectionInterval *
+			minimumPeriodicInterval);
+}
+
+void PeriodicHousekeepingHelper::changeCollectionInterval(
+		float newIntervalSeconds) {
+	collectionIntervalTicks = intervalSecondsToInterval(newIntervalSeconds);
+}
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
new file mode 100644
index 00000000..982e8cf6
--- /dev/null
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -0,0 +1,35 @@
+#ifndef FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+#define FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
+
+#include "../timemanager/Clock.h"
+#include <cstdint>
+
+class LocalPoolDataSetBase;
+
+class PeriodicHousekeepingHelper {
+public:
+	PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
+
+	void initialize(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
+			uint8_t nonDiagIntervalFactor);
+
+	void changeCollectionInterval(float newInterval);
+	float getCollectionIntervalInSeconds();
+	bool checkOpNecessary();
+private:
+	LocalPoolDataSetBase* owner = nullptr;
+
+
+	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
+	float intervalToIntervalSeconds(uint32_t collectionInterval);
+
+	dur_millis_t minimumPeriodicInterval = 0;
+	uint32_t internalTickCounter = 1;
+	uint32_t collectionIntervalTicks = 0;
+
+};
+
+
+
+#endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */

From 32c0140cc24c2aee082abf777f9bcda65b6ba43c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 15:58:34 +0200
Subject: [PATCH 0783/1292] hk stuff continued

---
 container/ArrayList.h                       |   6 +-
 container/FixedMap.h                        |   9 +
 datapoollocal/HasLocalDataPoolIF.h          |   5 +-
 datapoollocal/LocalDataPoolManager.cpp      | 199 ++++++++------------
 datapoollocal/LocalDataPoolManager.h        |  72 +++----
 datapoollocal/LocalPoolDataSetBase.cpp      |  48 +++--
 datapoollocal/LocalPoolDataSetBase.h        |  32 +++-
 datapoollocal/StaticLocalDataSet.h          |  18 ++
 devicehandlers/DeviceHandlerBase.cpp        |   8 +-
 devicehandlers/DeviceHandlerBase.h          |  11 +-
 housekeeping/HousekeepingMessage.h          |  11 +-
 housekeeping/PeriodicHousekeepingHelper.cpp |   3 +-
 housekeeping/PeriodicHousekeepingHelper.h   |   3 -
 pus/Service3Housekeeping.cpp                |   2 +-
 tmtcservices/CommandingServiceBase.cpp      |   8 +-
 tmtcservices/VerificationReporter.cpp       |   8 +-
 16 files changed, 235 insertions(+), 208 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index bda60433..ae983171 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -140,7 +140,11 @@ public:
 
         //SHOULDDO this should be implemented as non-member
         bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-            return !(*this == other);
+        	// POSSIBLY BUGGY ! Also this is really confusing. Why does
+        	// the operator above use the value while this one
+        	// dereferences itself?
+        	//return not (value == other.value);
+        	return !(*this == other);
         }
     };
 
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 475d4091..e5fbb3be 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -143,6 +143,15 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+	bool empty() {
+		if(_size == 0) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
     bool full() {
         if(_size >= theMap.maxSize()) {
             return true;
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 4b49ee11..e078f01e 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -9,7 +9,8 @@
 #include <map>
 
 class LocalDataPoolManager;
-class DataSetIF;
+class LocalPoolDataSetBase;
+
 /**
  * @brief	Type definition for local pool entries.
  */
@@ -76,7 +77,7 @@ public:
 	 * @param sid Corresponding structure ID
 	 * @return
 	 */
-	virtual DataSetIF* getDataSetHandle(sid_t sid) = 0;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
 	/* These function can be implemented by pool owner, as they are required
 	 * by the housekeeping message interface */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 48d57a91..f9a64777 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -56,9 +56,6 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
         uint8_t nonDiagInvlFactor) {
     setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    diagnosticMinimumInterval = owner->getPeriodicOperationFrequency();
-    regularMinimumInterval = diagnosticMinimumInterval *
-            nonDiagnosticIntervalFactor;
     return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -77,12 +74,12 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    for(auto& hkReceiversIter: hkReceiversMap) {
-        HkReceiver* receiver = &hkReceiversIter.second;
+    for(auto& receiver: hkReceiversMap) {
+        //HkReceiver* receiver = &hkReceiversIter.second;
 
-        switch(receiver->reportingType) {
+        switch(receiver.reportingType) {
         case(ReportingType::PERIODIC): {
-            if(receiver->dataId.dataSetSid.notSet()) {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 // Periodic packets shall only be generated from datasets.
                 continue;
             }
@@ -113,30 +110,19 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	}
 
 	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.dataSetSid = sid;
+	hkReceiver.dataId.sid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	if(not isDiagnostics) {
-	    hkReceiver.hkParameter.collectionIntervalTicks =
-	            intervalSecondsToInterval(isDiagnostics, collectionInterval *
-	            nonDiagnosticIntervalFactor);
-	}
-	else {
-	    hkReceiver.hkParameter.collectionIntervalTicks =
-	            intervalSecondsToInterval(isDiagnostics, collectionInterval);
-	}
-
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-	            owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
 		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setIsDiagnostic(isDiagnostics);
+		dataSet->setDiagnostic(isDiagnostics);
+		dataSet->initializePeriodicHelper(collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
 	}
 
-	hkReceiver.intervalCounter = 1;
-
-	hkReceiversMap.emplace(packetDestination, hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -153,7 +139,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		return togglePeriodicGeneration(sid, true, false);
     case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
 		return togglePeriodicGeneration(sid, false, false);
-
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
 		//return generateSetStructurePacket(sid, );
@@ -174,14 +159,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-    			owner->getDataSetHandle(sid));
+    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-    			and dataSet->getIsDiagnostics()) {
+    			and dataSet->isDiagnostics()) {
     		return WRONG_HK_PACKET_TYPE;
     	}
     	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-    			and not dataSet->getIsDiagnostics()) {
+    			and not dataSet->isDiagnostics()) {
     		return WRONG_HK_PACKET_TYPE;
     	}
     	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
@@ -234,7 +218,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(dataSet->getIsDiagnostics()) {
+	if(dataSet->isDiagnostics()) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -280,62 +264,40 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
     this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
-void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) {
-    if(receiver->intervalCounter >=
-            receiver->hkParameter.collectionIntervalTicks) {
-    	sid_t sid = receiver->dataId.dataSetSid;
-    	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-    			owner->getDataSetHandle(sid));
-    	if(not dataSet->getReportingEnabled()) {
-    		return;
-    	}
+void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
+	sid_t sid = receiver.dataId.sid;
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(not dataSet->getReportingEnabled()) {
+		return;
+	}
 
-        ReturnValue_t result = generateHousekeepingPacket(
-                sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            // configuration error
-            sif::debug << "LocalDataPoolManager::performHkOperation:"
-                    << "0x" << std::setfill('0') << std::setw(8)
-                    << owner->getObjectId() << " Error generating "
-                    << "HK packet" << std::setfill(' ') << std::endl;
-        }
-        receiver->intervalCounter = 1;
-    }
-    else {
-        receiver->intervalCounter++;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
+
+	if(not dataSet->periodicHelper->checkOpNecessary()) {
+		return;
+	}
+
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
+		sif::debug << "LocalDataPoolManager::performHkOperation:"
+				<< "0x" << std::setfill('0') << std::setw(8)
+		<< owner->getObjectId() << " Error generating "
+		<< "HK packet" << std::setfill(' ') << std::endl;
+	}
 }
 
-uint32_t LocalDataPoolManager::intervalSecondsToInterval(bool isDiagnostics,
-        float collectionIntervalSeconds) {
-    if(isDiagnostics) {
-        return std::ceil(collectionIntervalSeconds * 1000
-                /diagnosticMinimumInterval);
-    }
-    else {
-        return std::ceil(collectionIntervalSeconds * 1000
-                /regularMinimumInterval);
-    }
-}
-
-float LocalDataPoolManager::intervalToIntervalSeconds(bool isDiagnostics,
-        uint32_t collectionInterval) {
-    if(isDiagnostics) {
-        return static_cast<float>(collectionInterval *
-        		diagnosticMinimumInterval);
-    }
-    else {
-        return static_cast<float>(collectionInterval *
-                regularMinimumInterval);
-    }
-}
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
-	if((dataSet->getIsDiagnostics() and not isDiagnostics) or
-			(not dataSet->getIsDiagnostics() and isDiagnostics)) {
+	if((dataSet->isDiagnostics() and not isDiagnostics) or
+			(not dataSet->isDiagnostics() and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
@@ -352,7 +314,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 				owner->getDataSetHandle(sid));
-	bool targetIsDiagnostics = dataSet->getIsDiagnostics();
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
@@ -364,50 +326,49 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 	}
 
 	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-//	for(auto& receiver: hkReceiversMap) {
-//		if(receiver.second.reportingType != ReportingType::PERIODIC) {
-//			continue;
-//		}
-//
-//		uint32_t newInterval = intervalSecondsToInterval(isDiagnostics,
-//				newCollectionInterval);
-//		receiver.second.hkParameter.collectionIntervalTicks = newInterval;
-//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		float collectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-            owner->getDataSetHandle(sid));
-    if(dataSet == nullptr) {
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                " Set ID not found" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
+			owner->getDataSetHandle(sid));
+	if(dataSet == nullptr) {
+		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+				" Set ID not found" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
-    bool valid = dataSet->isValid();
-    bool targetIsDiagnostics = dataSet->getIsDiagnostics();
-    bool reportingEnabled = dataSet->getReportingEnabled();
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t);
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid, reportingEnabled,
-    		valid, collectionInterval, dataSet);
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                "Could not get free element from IPC store." << std::endl;
-        return result;
-    }
-    size_t size = 0;
-    result = dataSet->serializeLocalPoolIds(&storePtr, &size,
-            expectedSize, SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                "Expected size is not equal to serialized size" << std::endl;
-    }
-    return result;
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = dataSet->getReportingEnabled();
+	float collectionInterval =
+			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+
+	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+				"Could not get free element from IPC store." << std::endl;
+		return result;
+	}
+
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		sif::error << "HousekeepingManager::generateSetStructurePacket: "
+				"Expected size is not equal to serialized size" << std::endl;
+	}
+	return result;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 2a5c68b5..505b9b1a 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -5,6 +5,7 @@
 
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -131,16 +132,15 @@ public:
 
     /**
      * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC: HK packets are generated in fixed intervals and sent to
+     *  1. PERIODIC:
+     *     HK packets are generated in fixed intervals and sent to
      *     destination. Fromat will be raw.
-     *  2. UPDATED: Notification will be sent out if HK data has changed.
-     *     Question: Send Raw data directly or just the message?
-     *  3. REQUESTED: HK packets are only generated if explicitely requested.
+     *  2. UPDATE_NOTIFICATION:
+     *     Notification will be sent out if HK data has changed.
+     *  3. UPDATE_SNAPSHOT:
+     *     HK packets are only generated if explicitely requested.
      *     Propably not necessary, just use multiple local data sets or
      *     shared datasets.
-     *
-     *  Notifications should also be possible for single variables instead of
-     *  full dataset updates.
      */
     enum class ReportingType: uint8_t {
         //! Periodic generation of HK packets.
@@ -152,6 +152,17 @@ public:
         UPDATE_SNAPSHOT,
     };
 
+    /**
+     * Different data types are possible in the HK receiver map.
+     * For example, updates can be requested for full datasets or
+     * for single pool variables. Periodic reporting is only possible for
+     * data sets.
+     */
+    enum class DataType: uint8_t {
+    	LOCAL_POOL_VARIABLE,
+		DATA_SET
+    };
+
     /* Copying forbidden */
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
@@ -165,8 +176,6 @@ private:
     HasLocalDataPoolIF* owner = nullptr;
 
     uint8_t nonDiagnosticIntervalFactor = 0;
-    dur_millis_t regularMinimumInterval = 0;
-    dur_millis_t diagnosticMinimumInterval = 0;
 
 	/** Default receiver for periodic HK packets */
 	static object_id_t defaultHkDestination;
@@ -174,40 +183,25 @@ private:
 
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
-        /** Different member of this union will be used depending on the
-        type of data the receiver is interested in (full datasets or
-        single data variables. */
+		/** Object ID of receiver */
+		object_id_t objectId = objects::NO_OBJECT;
+
+		DataType dataType = DataType::DATA_SET;
         union DataId {
-        	DataId(): dataSetSid() {}
-            /** Will be initialized to INVALID_ADDRESS */
-            sid_t dataSetSid;
-            lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
+			DataId(): sid() {};
+            sid_t sid;
+            lp_id_t localPoolId;
         };
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
-        // SHOULDDO: it would be nice to also have the object ID instead of
-        // a queue (or in addition).. but the FSFW is not ready  for that yet.
-        // Also, an object can have multiple queues.
         MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-
-        /** Different members of this union will be used depending on reporting
-        type */
-        union HkParameter {
-            /** This parameter will be used for the PERIODIC type */
-            uint32_t collectionIntervalTicks = 0;
-            /** This parameter will be used for the ON_UPDATE type */
-            bool hkDataChanged;
-        };
-        HkParameter hkParameter;
-        /** General purpose counter which is used for periodic generation. */
-        uint32_t intervalCounter;
     };
 
-    /** Using a multimap as the same object might request multiple datasets */
-    using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
+    /** This vector will contain the list of HK receivers. */
+    using HkReceivers = std::vector<struct HkReceiver>;
 
-    HkReceiversMap hkReceiversMap;
+    HkReceivers hkReceiversMap;
 
     /** This is the map holding the actual data. Should only be initialized
      * once ! */
@@ -252,18 +246,12 @@ private:
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
 
-	uint32_t intervalSecondsToInterval(bool isDiagnostics,
-	        float collectionIntervalSeconds);
-	float intervalToIntervalSeconds(bool isDiagnostics,
-	        uint32_t collectionInterval);
-
-	void performPeriodicHkGeneration(HkReceiver* hkReceiver);
+	void performPeriodicHkGeneration(HkReceiver& hkReceiver);
 	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
 			bool isDiagnostics);
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
-	ReturnValue_t generateSetStructurePacket(sid_t sid,
-			float collectionInterval, bool isDiagnostics);
+	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index e0fc6b68..6832005b 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,5 +1,6 @@
 #include "LocalPoolDataSetBase.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
+#include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
 
 #include <cmath>
@@ -7,13 +8,14 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-    if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
-        return;
-    }
+		const size_t maxNumberOfVariables):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(hkOwner == nullptr) {
+		// Configuration error.
+		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				<< "invalid!" << std::endl;
+		return;
+	}
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
@@ -29,8 +31,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
-        sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
-                << std::endl;
+    	// Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        		<< "invalid!" << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -178,12 +181,12 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     *byte |= 1 << shiftNumber;
 }
 
-void LocalPoolDataSetBase::setIsDiagnostic(bool isDiagnostics) {
-	this->isDiagnostics = isDiagnostics;
+void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
+	this->diagnostic = isDiagnostics;
 }
 
-bool LocalPoolDataSetBase::getIsDiagnostics() const {
-	return isDiagnostics;
+bool LocalPoolDataSetBase::isDiagnostics() const {
+	return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
@@ -194,6 +197,25 @@ bool LocalPoolDataSetBase::getReportingEnabled() const {
 	return reportingEnabled;
 }
 
+void LocalPoolDataSetBase::initializePeriodicHelper(
+		float collectionInterval, dur_millis_t minimumPeriodicInterval,
+		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+			isDiagnostics, nonDiagIntervalFactor);
+}
+
+void LocalPoolDataSetBase::setChanged(bool changed) {
+	this->changed = changed;
+}
+
+bool LocalPoolDataSetBase::isChanged() const {
+	return changed;
+}
+
+sid_t LocalPoolDataSetBase::getSid() const {
+	return sid;
+}
+
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 		uint8_t position) const {
     if(position > 7) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2f7db9fb..1b58a211 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include <fsfw/housekeeping/PeriodicHousekeepingHelper.h>
+
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -10,6 +10,7 @@
 #include <vector>
 
 class LocalDataPoolManager;
+class PeriodicHousekeepingHelper;
 
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out
@@ -38,14 +39,16 @@ class LocalPoolDataSetBase: public PoolDataSetBase {
 public:
 	/**
 	 * @brief	Constructor for the creator of local pool data.
+	 * @details
+	 * This constructor also initializes the components required for
+	 * periodic handling.
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * @brief	Constructor for users of local pool data. The passed pool
-	 * 			owner should implement the HasHkPoolParametersIF.
+	 * @brief	Constructor for users of local pool data.
 	 * @details
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
@@ -67,6 +70,8 @@ public:
 
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
+	sid_t getSid() const;
+
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	            SerializeIF::Endianness streamEndianness) const override;
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
@@ -102,12 +107,15 @@ public:
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
+	void setChanged(bool changed);
+	bool isChanged() const;
+
 protected:
 	sid_t sid;
 
-	bool isDiagnostics = false;
-	void setIsDiagnostic(bool diagnostics);
-	bool getIsDiagnostics() const;
+	bool diagnostic = false;
+	void setDiagnostic(bool diagnostics);
+	bool isDiagnostics() const;
 
 	/**
 	 * Used for periodic generation.
@@ -116,12 +124,22 @@ protected:
 	void setReportingEnabled(bool enabled);
 	bool getReportingEnabled() const;
 
+	void initializePeriodicHelper(float collectionInterval,
+			dur_millis_t minimumPeriodicInterval,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+
 	/**
 	 * If the valid state of a dataset is always relevant to the whole
 	 * data set we can use this flag.
 	 */
 	bool valid = false;
 
+	/**
+	 * Can be used to mark the dataset as changed, which is used
+	 * by the LocalDataPoolManager to send out update messages.
+	 */
+	bool changed = false;
+
 	bool withValidityBuffer = true;
 
 	/**
@@ -147,7 +165,7 @@ protected:
 	 */
 	void bitSetter(uint8_t* byte, uint8_t position) const;
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
-private:
+
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
 
 };
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 7c2f0039..2f306898 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -17,6 +17,24 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
+	/**
+	 * Constructor used by data owner and creator like device handlers.
+	 * This constructor also initialized the components required for
+	 * periodic handling.
+	 * @param hkOwner
+	 * @param setId
+	 */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner,
+    		uint32_t setId): LocalPoolDataSetBase(hkOwner, setId, nullptr,
+            NUM_VARIABLES) {
+        this->setContainer(poolVarList.data());
+    }
+
+	/**
+	 * Constructor used by data users like controllers.
+	 * @param hkOwner
+	 * @param setId
+	 */
     StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
             NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0a3aec6d..227d5b6d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -391,7 +391,7 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode,
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 		DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-		PoolDataSetIF* replyDataSet, size_t replyLen, bool periodic,
+		LocalPoolDataSetBase* replyDataSet, size_t replyLen, bool periodic,
 		bool hasDifferentReplyId, DeviceCommandId_t replyId) {
 	//No need to check, as we may try to insert multiple times.
 	insertInCommandMap(deviceCommand);
@@ -405,7 +405,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 }
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
-		uint16_t maxDelayCycles, PoolDataSetIF* dataSet,
+		uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet,
 		size_t replyLen, bool periodic) {
 	DeviceReplyInfo info;
 	info.maxDelayCycles = maxDelayCycles;
@@ -455,7 +455,7 @@ ReturnValue_t DeviceHandlerBase::updateReplyMapEntry(DeviceCommandId_t deviceRep
 
 
 ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
-        PoolDataSetIF *dataSet) {
+        LocalPoolDataSetBase *dataSet) {
     auto replyIter = deviceReplyMap.find(replyId);
     if(replyIter == deviceReplyMap.end()) {
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -1396,7 +1396,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-DataSetIF* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
+LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
 	auto iter = deviceReplyMap.find(sid.ownerSetId);
 	if(iter != deviceReplyMap.end()) {
 		return iter->second.dataSet;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 752f7352..8f1b135b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -389,7 +389,8 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, PoolDataSetIF* replyDataSet = nullptr,
+			uint16_t maxDelayCycles,
+			LocalPoolDataSetBase* replyDataSet = nullptr,
 			size_t replyLen = 0, bool periodic = false,
 			bool hasDifferentReplyId = false, DeviceCommandId_t replyId = 0);
 
@@ -404,7 +405,7 @@ protected:
 	 *          - @c RETURN_FAILED else.
 	 */
 	ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand,
-			uint16_t maxDelayCycles, PoolDataSetIF* dataSet = nullptr,
+			uint16_t maxDelayCycles, LocalPoolDataSetBase* dataSet = nullptr,
 			size_t replyLen = 0, bool periodic = false);
 
 	/**
@@ -434,7 +435,7 @@ protected:
 			bool periodic = false);
 
 	ReturnValue_t setReplyDataset(DeviceCommandId_t replyId,
-	        PoolDataSetIF* dataset);
+	        LocalPoolDataSetBase* dataset);
 
 	/**
 	 * @brief   Can be implemented by child handler to
@@ -663,7 +664,7 @@ protected:
 		//! The dataset used to access housekeeping data related to the
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
-		PoolDataSetIF* dataSet = nullptr;
+		LocalPoolDataSetBase* dataSet;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -1198,7 +1199,7 @@ private:
 
 	ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-	virtual DataSetIF* getDataSetHandle(sid_t sid) override;
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
 
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 6a3ca616..e2e894b4 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -3,14 +3,15 @@
 
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
+#include "../objectmanager/frameworkObjects.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include <limits>
 
 union sid_t {
-	static constexpr uint64_t INVALID_ADDRESS =
-			std::numeric_limits<uint64_t>::max();
-	sid_t(): raw(INVALID_ADDRESS) {}
+	static constexpr uint64_t INVALID_SID = -1;
+	static constexpr uint32_t INVALID_SET_ID = -1;
+	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	sid_t(): raw(INVALID_SID) {}
 
 	sid_t(object_id_t objectId, uint32_t setId):
 			objectId(objectId),
@@ -31,7 +32,7 @@ union sid_t {
 	uint64_t raw;
 
 	bool notSet() const {
-	    return raw == INVALID_ADDRESS;
+	    return raw == INVALID_SID;
 	}
 
 	bool operator==(const sid_t& other) const {
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index c2ae8126..d184489b 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -10,10 +10,11 @@ void PeriodicHousekeepingHelper::initialize(float collectionInterval,
 		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
 		uint8_t nonDiagIntervalFactor) {
 	this->minimumPeriodicInterval = minimumPeriodicInterval;
-	if(not owner->getIsDiagnostics()) {
+	if(isDiagnostics) {
 		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
 				nonDiagIntervalFactor;
 	}
+	collectionIntervalTicks = intervalSecondsToInterval(collectionInterval);
 }
 
 float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() {
diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h
index 982e8cf6..d96eae1d 100644
--- a/housekeeping/PeriodicHousekeepingHelper.h
+++ b/housekeeping/PeriodicHousekeepingHelper.h
@@ -20,7 +20,6 @@ public:
 private:
 	LocalPoolDataSetBase* owner = nullptr;
 
-
 	uint32_t intervalSecondsToInterval(float collectionIntervalSeconds);
 	float intervalToIntervalSeconds(uint32_t collectionInterval);
 
@@ -30,6 +29,4 @@ private:
 
 };
 
-
-
 #endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 0d63a4e2..ebfa4be9 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -6,7 +6,7 @@
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
 			uint8_t serviceId):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
+		NUM_OF_PARALLEL_COMMANDS, 5) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 4cead0e9..3a204703 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -387,7 +387,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
 	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(&iter);
+		commandMap.erase(iter->first);
 	} else {
 		TcPacketStored newPacket(address);
 		startExecution(&newPacket, iter);
@@ -411,8 +411,14 @@ void CommandingServiceBase::checkTimeout() {
 	uint32_t uptime;
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
+	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
+		if(commandMap.empty()) {
+			// intermediate solution.
+			break;
+		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+			sif::info << "test" << std::endl;
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4f9f4e54..0c53e1a4 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -63,8 +63,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
+		sif::error << "VerificationReporter::sendFailureReport: Error writing "
+				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
 	}
 }
@@ -81,8 +81,8 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "VerificationReporter::sendFailureReport Error writing "
-				<< "to queue. Code: " << std::hex << status << std::dec
+		sif::error << "VerificationReporter::sendFailureReport: Error writing "
+				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
 	}
 }

From 4ab7a0838702698e23590c636b93f375103688f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:08:08 +0200
Subject: [PATCH 0784/1292] srv3 continued

---
 datapoollocal/LocalDataPoolManager.cpp | 45 +++++++++++++++++++-------
 housekeeping/HousekeepingMessage.cpp   | 21 ++++++++++++
 housekeeping/HousekeepingMessage.h     |  6 ++++
 pus/Service3Housekeeping.cpp           |  8 ++---
 tmtcservices/CommandingServiceBase.cpp |  3 +-
 5 files changed, 65 insertions(+), 18 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f9a64777..20d6451d 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -130,15 +130,28 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
     sid_t sid = HousekeepingMessage::getSid(message);
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION):
-    	return togglePeriodicGeneration(sid, true, true);
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION):
-		return togglePeriodicGeneration(sid, false, true);
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION):
-		return togglePeriodicGeneration(sid, true, false);
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION):
-		return togglePeriodicGeneration(sid, false, false);
+    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, true);
+    	break;
+    }
+
+    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, true, false);
+    	break;
+    }
+
+    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+    	result = togglePeriodicGeneration(sid, false, false);
+    	break;
+    }
+
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
 		//return generateSetStructurePacket(sid, );
@@ -175,6 +188,16 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
+
+    CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
@@ -294,8 +317,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if((dataSet->isDiagnostics() and not isDiagnostics) or
 			(not dataSet->isDiagnostics() and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
@@ -312,8 +334,7 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-				owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index a3aab03a..25475072 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -96,6 +96,27 @@ sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(
 	return getSid(command);
 }
 
+void HousekeepingMessage::setHkRequestSuccessReply(CommandMessage *reply,
+		sid_t sid) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_SUCCESS);
+}
+
+void HousekeepingMessage::setHkRequestFailureReply(CommandMessage *reply,
+		sid_t sid, ReturnValue_t error) {
+	setSid(reply, sid);
+	reply->setCommand(HK_REQUEST_FAILURE);
+	reply->setParameter3(error);
+}
+
+sid_t HousekeepingMessage::getHkRequestFailureReply(const CommandMessage *reply,
+		ReturnValue_t *error) {
+	if(error != nullptr) {
+		*error = reply->getParameter3();
+	}
+	return getSid(reply);
+}
+
 sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 	sid_t sid;
 	std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index e2e894b4..5c1b4e55 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -118,6 +118,12 @@ public:
 	static void setHkDiagnosticsReply(CommandMessage* reply, sid_t sid,
 			store_address_t storeId);
 
+	static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
+	static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid,
+			ReturnValue_t error);
+	static sid_t getHkRequestFailureReply(const CommandMessage* reply,
+			ReturnValue_t* error);
+
 	/**
 	 * @brief	Generic getter function for housekeeping data replies
 	 * @details
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index ebfa4be9..ad08c328 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -6,7 +6,7 @@
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
 			uint8_t serviceId):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUM_OF_PARALLEL_COMMANDS, 5) {}
+		NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {}
 
 Service3Housekeeping::~Service3Housekeeping() {}
 
@@ -204,9 +204,9 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 
 	case(HousekeepingMessage::HK_REQUEST_FAILURE): {
 		failureParameter1 = objectId;
-		// also provide failure reason (returnvalue)
-		// will be most commonly invalid SID or the set already has the desired
-		// reporting status.
+		ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED;
+		HousekeepingMessage::getHkRequestFailureReply(reply,&error);
+		failureParameter2 = error;
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
 
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3a204703..3a124f5d 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -414,11 +414,10 @@ void CommandingServiceBase::checkTimeout() {
 	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
 		if(commandMap.empty()) {
-			// intermediate solution.
+			// intermediate solution!
 			break;
 		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
-			sif::info << "test" << std::endl;
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,

From 02f778ea1d4bbe07df38a7e58ca50ebf6ea81232 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:14:09 +0200
Subject: [PATCH 0785/1292] new error code added

---
 datapoollocal/LocalDataPoolManager.cpp | 7 ++++---
 datapoollocal/LocalDataPoolManager.h   | 1 +
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 20d6451d..635fafce 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -163,11 +163,12 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			&newCollIntvl);
     	if(command == HousekeepingMessage::
     			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-    		return changeCollectionInterval(sid, newCollIntvl, true);
+    		result = changeCollectionInterval(sid, newCollIntvl, true);
     	}
     	else {
-    		return changeCollectionInterval(sid, newCollIntvl, false);
+    		result = changeCollectionInterval(sid, newCollIntvl, false);
     	}
+    	break;
     }
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
@@ -343,7 +344,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 
 	if(dataSet->periodicHelper == nullptr) {
 		// config error
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return PERIODIC_HELPER_INVALID;
 	}
 
 	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 505b9b1a..44b15f59 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -57,6 +57,7 @@ public:
 
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it

From 718502c04b35f2677c39d68da4c00f5052e01d33 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 17:15:33 +0200
Subject: [PATCH 0786/1292] added additional flag which casn be used to disable

periodic handling
---
 datapoollocal/LocalPoolDataSetBase.cpp | 6 ++++--
 datapoollocal/LocalPoolDataSetBase.h   | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 6832005b..c280e7c7 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables):
+		const size_t maxNumberOfVariables, bool noPeriodicHandling):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
 	if(hkOwner == nullptr) {
 		// Configuration error.
@@ -21,7 +21,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
-    periodicHelper = new PeriodicHousekeepingHelper(this);
+    if(not noPeriodicHandling) {
+    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+    }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 1b58a211..83e0425c 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -45,7 +45,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables);
+	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
 
 	/**
 	 * @brief	Constructor for users of local pool data.

From 44989ada64c2fa5919e2ae6245d964eed009976f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 19:41:41 +0200
Subject: [PATCH 0787/1292] file system message taken over

---
 memory/FileSystemMessage.cpp | 54 ++++++++++++++++++++++++++++++------
 memory/FileSystemMessage.h   | 26 +++++++++++------
 2 files changed, 63 insertions(+), 17 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 30437a62..fe1ff2b8 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -5,24 +5,60 @@
  *      Author: Jakob Meier
  */
 
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include <framework/memory/FileSystemMessage.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
 
-ReturnValue_t FileSystemMessage::setWriteToFileCommand(CommandMessage* message,
-		MessageQueueId_t replyQueueId, store_address_t storageID) {
-	message->setCommand(WRITE_TO_FILE);
-	message->setParameter(replyQueueId);
+
+ReturnValue_t FileSystemMessage::setDeleteFileCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(DELETE_FILE);
 	message->setParameter2(storageID.raw);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-store_address_t FileSystemMessage::getStoreID(const CommandMessage* message) {
+ReturnValue_t FileSystemMessage::setCreateDirectoryCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(CREATE_DIRECTORY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setDeleteDirectoryCommand(
+		CommandMessage* message, store_address_t storageID) {
+	message->setCommand(DELETE_DIRECTORY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setWriteCommand(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(WRITE);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setReadCommand(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(READ);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FileSystemMessage::setReadReply(CommandMessage* message,
+		store_address_t storageID) {
+	message->setCommand(READ_REPLY);
+	message->setParameter2(storageID.raw);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();
 	return temp;
 }
 
-MessageQueueId_t FileSystemMessage::getReplyQueueId(const CommandMessage* message){
-	return message->getParameter();
+void FileSystemMessage::setCompletionReply(CommandMessage* message,
+		Command_t completionStatus) {
+	message->setCommand(completionStatus);
 }
 
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index da5b3181..cbc4f8bf 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -8,9 +8,9 @@
 #ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
 #define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
 
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
+#include <framework/ipc/CommandMessage.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
 
 class FileSystemMessage {
 private:
@@ -19,12 +19,22 @@ public:
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t WRITE_TO_FILE = MAKE_COMMAND_ID( 0x80 );
-
-	static ReturnValue_t setWriteToFileCommand(CommandMessage* message, MessageQueueId_t replyToQueue, store_address_t storageID );
-	static store_address_t getStoreID( const CommandMessage* message );
-	static MessageQueueId_t getReplyQueueId(const CommandMessage* message);
+	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID( 0x09 );
+	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID( 0x0A );
+	static const Command_t WRITE = MAKE_COMMAND_ID( 0x80 );
+	static const Command_t READ = MAKE_COMMAND_ID( 0x81 );
+	static const Command_t READ_REPLY = MAKE_COMMAND_ID( 0x82 );
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
 
+	static ReturnValue_t setDeleteFileCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setCreateDirectoryCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setDeleteDirectoryCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setWriteCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
+	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
+	static store_address_t getStoreId( const CommandMessage* message );
+	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
 };
 
 #endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */

From 9e9bde03951b143fec0e16078bcb0a02f0cd442e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 19:50:02 +0200
Subject: [PATCH 0788/1292] srv23 taken over

---
 memory/FileSystemMessage.cpp | 11 ++---------
 memory/FileSystemMessage.h   | 24 ++++++++++--------------
 pus/Service2DeviceAccess.cpp |  3 +--
 3 files changed, 13 insertions(+), 25 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index fe1ff2b8..0d1421fa 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,12 +1,5 @@
-/*
- * FileSystemMessage.cpp
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#include <framework/memory/FileSystemMessage.h>
-#include <framework/objectmanager/ObjectManagerIF.h>
+#include "FileSystemMessage.h"
+#include "../objectmanager/ObjectManagerIF.h"
 
 
 ReturnValue_t FileSystemMessage::setDeleteFileCommand(
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index cbc4f8bf..348c9409 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -1,17 +1,13 @@
-/*
- * FileSystemMessage.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
+#ifndef FSFW_MEMORY_FILESYSTEMMESSAGE_H_
+#define FSFW_MEMORY_FILESYSTEMMESSAGE_H_
+
+#include "../ipc/CommandMessage.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @author  Jakob Meier
  */
-
-#ifndef FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-#define FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include <framework/ipc/CommandMessage.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
-
 class FileSystemMessage {
 private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
@@ -37,4 +33,4 @@ public:
 	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
 };
 
-#endif /* FRAMEWORK_MEMORY_FILESYSTEMMESSAGE_H_ */
+#endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 9529c675..8780b22c 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -39,8 +39,7 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
     SerializeAdapter::deSerialize(objectId, &tcData,
                 &tcDataLen, SerializeIF::Endianness::BIG);
 
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
+    return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }
 
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(

From e140d39944ba02407aa281cc6397bc75e69017ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 20:08:25 +0200
Subject: [PATCH 0789/1292] some  fixes for sd card handler

---
 memory/HasFileSystemIF.h | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index b6d43981..6065ebfd 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -1,15 +1,11 @@
-/*
- * HasFileSystemIF.h
- *
- *  Created on: 19.01.2020
- *      Author: Jakob Meier
- */
-
-#ifndef FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
-#define FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_
+#ifndef FSFW_MEMORY_HASFILESYSTEMIF_H_
+#define FSFW_MEMORY_HASFILESYSTEMIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+/**
+ * @author  Jakob Meier
+ */
 class HasFileSystemIF {
 public:
 
@@ -19,18 +15,24 @@ public:
 	 * @return MessageQueueId_t of the object
 	 */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
+
 	/**
 	 * Function to write to a file
 	 * @param dirname Directory of the file
 	 * @param filename The filename of the file
 	 * @param data The data to write to the file
 	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets. For large files the write procedure must be split in multiple calls to writeToFile
+	 * @param packetNumber Counts the number of packets.
+	 * For large files the write procedure must be split in multiple calls
+	 * to writeToFile
 	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, char* filename, const uint8_t* data, uint32_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename, const uint8_t* data, uint32_t size) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname, const char* filename) = 0;
+	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
+	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
+	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
+	        const uint8_t* data, size_t size) = 0;
+	virtual ReturnValue_t deleteFile(const char* dirname,
+	        const char* filename) = 0;
 };
 
 
-#endif /* FRAMEWORK_MEMORY_HASFILESYSTEMIF_H_ */
+#endif /* FSFW_MEMORY_HASFILESYSTEMIF_H_ */

From cad08e1ea9d722801b1e6675b88a8513bdc6078a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 20:54:27 +0200
Subject: [PATCH 0790/1292] error output for failed deletion

---
 storagemanager/ConstStorageAccessor.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 6235ac40..5c143adb 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -14,7 +14,12 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		store->deleteData(storeId);
+		ReturnValue_t result = store->deleteData(storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    // Configuration error.
+		    sif::error << "ConstStorageAccessor::~ConstStorageAccessor: "
+		            << "Could not delete entry!" << std::endl;
+		}
 	}
 }
 

From 40db85e73f54d77cd813afe7f57667ca7e3f56cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 21:36:12 +0200
Subject: [PATCH 0791/1292] separate messages for success/failure

---
 memory/FileSystemMessage.cpp | 10 +++++++---
 memory/FileSystemMessage.h   |  3 ++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 0d1421fa..951836e9 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -50,8 +50,12 @@ store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	return temp;
 }
 
-void FileSystemMessage::setCompletionReply(CommandMessage* message,
-		Command_t completionStatus) {
-	message->setCommand(completionStatus);
+void FileSystemMessage::setSuccessReply(CommandMessage *message) {
+    message->setCommand(COMPLETION_SUCCESS);
 }
 
+void FileSystemMessage::setFailureReply(CommandMessage *message,
+        ReturnValue_t errorCode) {
+    message->setCommand(COMPLETION_SUCCESS);
+    message->setParameter(errorCode);
+}
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 348c9409..6508f6be 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -30,7 +30,8 @@ public:
 	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
 	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
 	static store_address_t getStoreId( const CommandMessage* message );
-	static void setCompletionReply(CommandMessage* message, Command_t completionStatus);
+	static void setSuccessReply(CommandMessage* message);
+	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
 };
 
 #endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From 763c52cfca0c173cf54924cb736ebb4262171489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 19 Sep 2020 21:57:23 +0200
Subject: [PATCH 0792/1292] CSB FIFO first steps to make configurable

---
 tmtcservices/CommandingServiceBase.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 23b08acf..8237415a 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -39,7 +39,11 @@ class CommandingServiceBase: public SystemObject,
 		public HasReturnvaluesIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
+	// We could make this configurable via preprocessor and the FSFWConfig file.
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
@@ -223,7 +227,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		FIFO<store_address_t, COMMAND_INFO_FIFO_DEPTH> fifo;
 
 		virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
 					size_t maxSize, Endianness streamEndianness) const override{
@@ -235,7 +239,7 @@ protected:
 		};
 
 		virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-				Endianness streamEndianness) override{
+				Endianness streamEndianness) override {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		};
 	};

From f5d793a1cf63b9ebe87bef2e0d49e55947c11cf1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 20 Sep 2020 13:38:53 +0200
Subject: [PATCH 0793/1292] file system message getter func

---
 memory/FileSystemMessage.cpp | 5 +++++
 memory/FileSystemMessage.h   | 2 ++
 2 files changed, 7 insertions(+)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 951836e9..416f646c 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -59,3 +59,8 @@ void FileSystemMessage::setFailureReply(CommandMessage *message,
     message->setCommand(COMPLETION_SUCCESS);
     message->setParameter(errorCode);
 }
+
+ReturnValue_t FileSystemMessage::getFailureReply(
+		const CommandMessage *message) {
+	return message->getParameter();
+}
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index 6508f6be..d3dbd83c 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -32,6 +32,8 @@ public:
 	static store_address_t getStoreId( const CommandMessage* message );
 	static void setSuccessReply(CommandMessage* message);
 	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
+
+	static ReturnValue_t getFailureReply(const CommandMessage* message);
 };
 
 #endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From e3cbc4dfd5a854204130df4e0dd3434438b8d795 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 02:12:02 +0200
Subject: [PATCH 0794/1292] shared ring buffer extended

---
 container/SharedRingBuffer.cpp | 25 +++++++++++++++++++++++++
 container/SharedRingBuffer.h   | 16 ++++++++++++++++
 timemanager/Countdown.cpp      | 13 +++----------
 timemanager/Countdown.h        | 26 +++++++++++++-------------
 4 files changed, 57 insertions(+), 23 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 800e75d3..48bdb9df 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -9,6 +9,7 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 		const size_t size, bool overwriteOld, size_t maxExcessBytes):
 		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
@@ -16,6 +17,11 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 	mutex = MutexFactory::instance()->createMutex();
 }
 
+
+void SharedRingBuffer::setToUseReceiveSizeFIFO(uint32_t fifoDepth) {
+	this->fifoDepth = fifoDepth;
+}
+
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
         MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
     return mutex->lockMutex(timeoutType, timeout);
@@ -25,6 +31,25 @@ ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
     return mutex->unlockMutex();
 }
 
+
+
 MutexIF* SharedRingBuffer::getMutexHandle() const {
     return mutex;
 }
+
+ReturnValue_t SharedRingBuffer::initialize() {
+	if(fifoDepth > 0) {
+		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+	}
+	return SystemObject::initialize();
+}
+
+DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
+	if(receiveSizesFIFO == nullptr) {
+		// Configuration error.
+		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+				<< " was not configured to have sizes FIFO, returning nullptr!"
+				<< std::endl;
+	}
+	return receiveSizesFIFO;
+}
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 80c068b3..c9e0ae3f 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 #define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
+#include <fsfw/container/DynamicFIFO.h>
 #include "SimpleRingBuffer.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
@@ -26,6 +27,8 @@ public:
 	SharedRingBuffer(object_id_t objectId, const size_t size,
 			bool overwriteOld, size_t maxExcessBytes);
 
+	void setToUseReceiveSizeFIFO(uint32_t fifoDepth);
+
 	/**
 	 * This constructor takes an external buffer with the specified size.
 	 * @param buffer
@@ -59,8 +62,21 @@ public:
 	 * @return
 	 */
 	MutexIF* getMutexHandle() const;
+
+	ReturnValue_t initialize() override;
+
+	/**
+	 * 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:
 	MutexIF* mutex = nullptr;
+
+	size_t fifoDepth = 0;
+	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index 95cce029..dfe0e1ec 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,14 +1,7 @@
-/**
- * @file	Countdown.cpp
- * @brief	This file defines the Countdown class.
- * @date	21.03.2013
- * @author	baetz
- */
+#include "Countdown.h"
 
-
-#include "../timemanager/Countdown.h"
-
-Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout): startTime(0),
+		timeout(initialTimeout) {
 }
 
 Countdown::~Countdown() {
diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h
index 20380e71..f6a41e73 100644
--- a/timemanager/Countdown.h
+++ b/timemanager/Countdown.h
@@ -1,18 +1,13 @@
+#ifndef FSFW_TIMEMANAGER_COUNTDOWN_H_
+#define FSFW_TIMEMANAGER_COUNTDOWN_H_
+
+#include "Clock.h"
+
 /**
- * @file	Countdown.h
  * @brief	This file defines the Countdown class.
- * @date	21.03.2013
  * @author	baetz
  */
-
-#ifndef COUNTDOWN_H_
-#define COUNTDOWN_H_
-
-#include "../timemanager/Clock.h"
-
 class Countdown {
-private:
-	uint32_t startTime;
 public:
 	uint32_t timeout;
 	Countdown(uint32_t initialTimeout = 0);
@@ -23,9 +18,14 @@ public:
 
 	bool isBusy() const;
 
-	ReturnValue_t resetTimer(); //!< Use last set timeout value and restart timer.
+	//!< Use last set timeout value and restart timer.
+	ReturnValue_t resetTimer();
 
-	void timeOut(); //!< Make hasTimedOut() return true
+	//!< Make hasTimedOut() return true
+	void timeOut();
+
+private:
+	uint32_t startTime = 0;
 };
 
-#endif /* COUNTDOWN_H_ */
+#endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

From 5072c09bc030e381df054b5b28ff979804030cff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 13:59:25 +0200
Subject: [PATCH 0795/1292] csb hotfix

---
 tmtcservices/CommandingServiceBase.cpp | 9 ++-------
 tmtcservices/CommandingServiceBase.h   | 2 +-
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 3a124f5d..0ebc3944 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -384,10 +384,10 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 }
 
 
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter& iter) {
 	store_address_t address;
 	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
-		commandMap.erase(iter->first);
+		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
 		startExecution(&newPacket, iter);
@@ -411,12 +411,7 @@ void CommandingServiceBase::checkTimeout() {
 	uint32_t uptime;
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
-	// TODO: BUG HERE! Problems with comparison operator of iterator.
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if(commandMap.empty()) {
-			// intermediate solution!
-			break;
-		}
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 8237415a..252b6943 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -316,7 +316,7 @@ protected:
 	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
-	void checkAndExecuteFifo(CommandMapIter iter);
+	void checkAndExecuteFifo(CommandMapIter& iter);
 
 private:
 	/**

From 4074ca1b8970e3c3c115f77df15dc87e60f64f59 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 14:22:14 +0200
Subject: [PATCH 0796/1292] error code improved

---
 tmtcservices/TmTcBridge.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c2f15e5..8abe37a2 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -95,8 +95,9 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TmTcBridge::handleTm: Error handling TM queue!"
-		        << std::endl;
+		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
+		       << "error code 0x" << std::hex << result  << std::dec
+			   << "!" << std::endl;
 		status = result;
 	}
 

From c7a6711eecddf89a5bad9ab193f166dfd8e93452 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 22 Sep 2020 16:25:10 +0200
Subject: [PATCH 0797/1292] include fix

---
 container/SharedRingBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index c9e0ae3f..fdc9d626 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 #define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
 
-#include <fsfw/container/DynamicFIFO.h>
 #include "SimpleRingBuffer.h"
+#include "DynamicFIFO.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../timemanager/Clock.h"

From 320a5ac355728fd8b357d8bb3e0bca889e2e280e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 17:44:22 +0200
Subject: [PATCH 0798/1292] has health IF improvements

---
 health/HasHealthIF.h     | 16 +++++++----
 health/HealthHelper.h    |  3 +-
 health/HealthMessage.cpp |  2 +-
 health/HealthMessage.h   | 17 +++++++-----
 health/HealthTable.cpp   | 59 ++++++++++++++++------------------------
 health/HealthTable.h     | 32 +++++++++++++---------
 health/HealthTableIF.h   | 20 ++++++--------
 health/ManagesHealthIF.h |  9 +++---
 8 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index ac404300..d5321a6d 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -1,5 +1,5 @@
-#ifndef HASHEALTHIF_H_
-#define HASHEALTHIF_H_
+#ifndef FSFW_HEALTH_HASHEALTHIF_H_
+#define FSFW_HEALTH_HASHEALTHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -8,9 +8,13 @@
 class HasHealthIF {
 public:
 
-	typedef enum {
-		HEALTHY = 1, FAULTY = 0, EXTERNAL_CONTROL = 2, NEEDS_RECOVERY = 3, PERMANENT_FAULTY = 4
-	} HealthState;
+	enum HealthState: uint8_t {
+		HEALTHY = 1,
+		FAULTY = 0,
+		EXTERNAL_CONTROL = 2,
+		NEEDS_RECOVERY = 3,
+		PERMANENT_FAULTY = 4
+	};
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
 	static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
@@ -47,4 +51,4 @@ public:
 	virtual HasHealthIF::HealthState getHealth() = 0;
 };
 
-#endif /* HASHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_HASHEALTHIF_H_ */
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index d1f1945c..813123b2 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -114,7 +114,8 @@ private:
 	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
 	 * @param oldHealth information of the previous health state.
 	 */
-	void informParent(HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth);
+	void informParent(HasHealthIF::HealthState health,
+	        HasHealthIF::HealthState oldHealth);
 
 	void handleSetHealthCommand(CommandMessage *message);
 };
diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 39c53fb1..1bb29526 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -1,4 +1,4 @@
-#include "../health/HealthMessage.h"
+#include "HealthMessage.h"
 
 void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
 		HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) {
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index fa773d42..de4923ab 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -1,19 +1,22 @@
-#ifndef HEALTHMESSAGE_H_
-#define HEALTHMESSAGE_H_
+#ifndef FSFW_HEALTH_HEALTHMESSAGE_H_
+#define FSFW_HEALTH_HEALTHMESSAGE_H_
 
-#include "../health/HasHealthIF.h"
+#include "HasHealthIF.h"
 #include "../ipc/CommandMessage.h"
 
 class HealthMessage {
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);//REPLY_COMMAND_OK/REPLY_REJECTED
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);	//NO REPLY!
+	// REPLY_COMMAND_OK/REPLY_REJECTED
+	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);
+	// NO REPLY!
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
 	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command,
-			HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
+			HasHealthIF::HealthState health,
+			HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command);
 
@@ -27,4 +30,4 @@ private:
 	HealthMessage();
 };
 
-#endif /* HEALTHMESSAGE_H_ */
+#endif /* FSFW_HEALTH_HEALTHMESSAGE_H_ */
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 1aa5a3ae..6d6fe017 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -1,6 +1,7 @@
-#include "../health/HealthTable.h"
-#include "../serialize/SerializeAdapter.h"
+#include "HealthTable.h"
+#include "../ipc/MutexHelper.h"
 #include "../ipc/MutexFactory.h"
+#include "../serialize/SerializeAdapter.h"
 
 HealthTable::HealthTable(object_id_t objectid) :
 		SystemObject(objectid) {
@@ -18,74 +19,64 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 	if (healthMap.count(object) != 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	healthMap.insert(
-			std::pair<object_id_t, HasHealthIF::HealthState>(object,
-					initilialState));
+	healthMap.emplace(object, initilialState);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
 	}
-	mutex->unlockMutex();
 }
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
 	}
-	mutex->unlockMutex();
 	return state;
 }
 
-uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::BLOCKING);
-	uint32_t size = healthMap.size() * 5 + 2;
-	mutex->unlockMutex();
-	return size;
-}
 
 bool HealthTable::hasHealth(object_id_t object) {
-	bool exits = false;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
-		exits = true;
+		return true;
 	}
-	mutex->unlockMutex();
-	return exits;
+	return false;
+}
+
+size_t HealthTable::getPrintSize() {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    uint32_t size = healthMap.size() * sizeof(object_id_t) +
+            sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
+    return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::BLOCKING);
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
-	ReturnValue_t result = SerializeAdapter::serialize(&count,
+	SerializeAdapter::serialize(&count,
 			&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-	HealthMap::iterator iter;
-	for (iter = healthMap.begin();
-			iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
-			++iter) {
-		result = SerializeAdapter::serialize(&iter->first,
+	for (const auto& health: healthMap) {
+		SerializeAdapter::serialize(&health.first,
 				&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
-		uint8_t health = iter->second;
-		result = SerializeAdapter::serialize(&health, &pointer, &size,
+		uint8_t healthValue = health.second;
+		SerializeAdapter::serialize(&healthValue, &pointer, &size,
 				maxSize, SerializeIF::Endianness::BIG);
 	}
-	mutex->unlockMutex();
 }
 
-ReturnValue_t HealthTable::iterate(
-		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
+ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
@@ -94,7 +85,5 @@ ReturnValue_t HealthTable::iterate(
 	}
 	*value = *mapIterator;
 	mapIterator++;
-	mutex->unlockMutex();
-
 	return result;
 }
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 0f54a264..c5ebb5d4 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -1,27 +1,31 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLE_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLE_H_
+#ifndef FSFW_HEALTH_HEALTHTABLE_H_
+#define FSFW_HEALTH_HEALTHTABLE_H_
 
-#include "../health/HealthTableIF.h"
+#include "HealthTableIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 #include <map>
 
 typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
+using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 class HealthTable: public HealthTableIF, public SystemObject {
 public:
 	HealthTable(object_id_t objectid);
 	virtual ~HealthTable();
 
-	virtual ReturnValue_t registerObject(object_id_t object,
-			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY);
+    /** HealthTableIF overrides */
+    virtual ReturnValue_t registerObject(object_id_t object,
+            HasHealthIF::HealthState initilialState =
+            HasHealthIF::HEALTHY) override;
+    virtual size_t getPrintSize() override;
+    virtual void printAll(uint8_t *pointer, size_t maxSize) override;
 
-	virtual bool hasHealth(object_id_t object);
-	virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState);
-	virtual HasHealthIF::HealthState getHealth(object_id_t);
-
-	virtual uint32_t getPrintSize();
-	virtual void printAll(uint8_t *pointer, size_t maxSize);
+	/** ManagesHealthIF overrides */
+	virtual bool hasHealth(object_id_t object) override;
+	virtual void setHealth(object_id_t object,
+	        HasHealthIF::HealthState newState) override;
+	virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
 protected:
 	MutexIF* mutex;
@@ -29,7 +33,9 @@ protected:
 
 	HealthMap::iterator mapIterator;
 
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false);
+	virtual ReturnValue_t iterate(
+	        HealthEntry* value,
+	        bool reset = false) override;
 };
 
-#endif /* HEALTHTABLE_H_ */
+#endif /* FSFW_HEALTH_HEALTHTABLE_H_ */
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index f18f0315..d61e6761 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -1,28 +1,24 @@
-#ifndef FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
-#define FRAMEWORK_HEALTH_HEALTHTABLEIF_H_
+#ifndef FSFW_HEALTH_HEALTHTABLEIF_H_
+#define FSFW_HEALTH_HEALTHTABLEIF_H_
 
-#include "../health/ManagesHealthIF.h"
+#include "ManagesHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <map>
-
 
 class HealthTableIF: public ManagesHealthIF {
-	// TODO: This is in the mission folder and not in the framework folder.
-	// delete it?
-	friend class HealthCommandingService;
 public:
-	virtual ~HealthTableIF() {
-	}
+	virtual ~HealthTableIF() {}
 
 	virtual ReturnValue_t registerObject(object_id_t object,
 			HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
-	virtual uint32_t getPrintSize() = 0;
+	virtual size_t getPrintSize() = 0;
 	virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
 
 protected:
-	virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
+	virtual ReturnValue_t iterate(
+	        std::pair<object_id_t,HasHealthIF::HealthState> *value,
+	        bool reset = false) = 0;
 };
 
 #endif /* FRAMEWORK_HEALTH_HEALTHTABLEIF_H_ */
diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h
index 8ca17012..2edfceca 100644
--- a/health/ManagesHealthIF.h
+++ b/health/ManagesHealthIF.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
-#define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_
+#ifndef FSFW_HEALTH_MANAGESHEALTHIF_H_
+#define FSFW_HEALTH_MANAGESHEALTHIF_H_
 
-#include "../health/HasHealthIF.h"
+#include "HasHealthIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+
 class ManagesHealthIF {
 public:
 	virtual ~ManagesHealthIF() {
@@ -49,4 +50,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ */
+#endif /* FSFW_HEALTH_MANAGESHEALTHIF_H_ */

From 2f0b36de46938bf6dd58539f75f91f183e567d25 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:54:22 +0200
Subject: [PATCH 0799/1292] updated framework object list

---
 objectmanager/frameworkObjects.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 4a30e70a..87439c88 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -8,6 +8,8 @@ enum framework_objects {
 	PUS_SERVICE_2 = 0x53000002,
 	PUS_SERVICE_5 = 0x53000005,
 	PUS_SERVICE_8 = 0x53000008,
+	PUS_SERVICE_9 = 0x53000009,
+	PUS_SERVICE_17 = 0x53000017,
 	PUS_SERVICE_200 = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events

From 43ab0ba2702f482f1f5e7d39493a90e66bb91336 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:55:48 +0200
Subject: [PATCH 0800/1292] updated subsystemId ranged

---
 events/fwSubsystemIdRanges.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 3c57c160..8dc4def7 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -19,7 +19,8 @@ enum {
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
 	PUS_SERVICE_1 = 80,
-	PUS_SERVICE_17 = 83,
+	PUS_SERVICE_9 = 89,
+	PUS_SERVICE_17 = 97,
 	FW_SUBSYSTEM_ID_RANGE
 };
 }

From 5ca1c7bca2d7a5c431488afde034dbe6625807cb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 23 Sep 2020 19:58:51 +0200
Subject: [PATCH 0801/1292] coutndown update

---
 timemanager/Countdown.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp
index dfe0e1ec..20b56189 100644
--- a/timemanager/Countdown.cpp
+++ b/timemanager/Countdown.cpp
@@ -1,7 +1,6 @@
 #include "Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout): startTime(0),
-		timeout(initialTimeout) {
+Countdown::Countdown(uint32_t initialTimeout): timeout(initialTimeout) {
 }
 
 Countdown::~Countdown() {

From a65745d037a2ef26e51302d5c585620681a0f56a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Sep 2020 18:40:04 +0200
Subject: [PATCH 0802/1292] added explicit function to refresh task handle

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp |  8 ++++++--
 osal/FreeRTOS/BinSemaphUsingTask.h   | 28 +++++++++++++++++++++-------
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index dd1e48ca..9c29948e 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinSemaphUsingTask.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
@@ -16,6 +16,10 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite, nullptr);
 }
 
+void BinarySemaphoreUsingTask::refreshTaskHandle() {
+	handle = TaskManagement::getCurrentTaskHandle();
+}
+
 ReturnValue_t BinarySemaphoreUsingTask::acquire(TimeoutType timeoutType,
         uint32_t timeoutMs) {
     TickType_t timeout = 0;
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 4317e0b2..65a091a3 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -7,16 +7,20 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+// todo: does not work for older FreeRTOS version, so we should
+// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
+
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
  * 			The notification value should therefore not be used
- * 			for other purposes.
+ * 			for other purposes!
  * @details
  * Additional information: https://www.freertos.org/RTOS-task-notifications.html
  * and general semaphore documentation.
  * This semaphore is bound to the task it is created in!
- * Take care of calling this function with the correct executing task,
- * (for example in the initializeAfterTaskCreation() function).
+ * Take care of building this class with the correct executing task,
+ * (for example in the initializeAfterTaskCreation() function) or
+ * by calling refreshTaskHandle() with the correct executing task.
  */
 class BinarySemaphoreUsingTask: public SemaphoreIF,
 		public HasReturnvaluesIF {
@@ -28,6 +32,16 @@ public:
 	//! @brief Default dtor
 	virtual~ BinarySemaphoreUsingTask();
 
+	/**
+	 * This function can be used to get the correct task handle from the
+	 * currently executing task.
+	 *
+	 * This is required because the task notification value will be used
+	 * as a binary semaphore, and the semaphore might be created by another
+	 * task.
+	 */
+	void refreshTaskHandle();
+
 	ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
 	        uint32_t timeoutMs = portMAX_DELAY) override;
 	ReturnValue_t release() override;
@@ -70,10 +84,10 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t releaseFromISR(TaskHandle_t taskToNotify,
-				BaseType_t * higherPriorityTaskWoken);
+				BaseType_t* higherPriorityTaskWoken);
 
 protected:
 	TaskHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */

From cf28c9ff9d861b7ecd30a45b172635ed1766b882 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Sep 2020 19:01:59 +0200
Subject: [PATCH 0803/1292] make event func changed

---
 events/Event.cpp | 6 ++++--
 events/Event.h   | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/events/Event.cpp b/events/Event.cpp
index ea3d46fe..0f76b438 100644
--- a/events/Event.cpp
+++ b/events/Event.cpp
@@ -1,4 +1,5 @@
 #include "Event.h"
+
 namespace EVENT {
 EventId_t getEventId(Event event) {
 	return (event & 0xFFFF);
@@ -8,7 +9,8 @@ EventSeverity_t getSeverity(Event event) {
 	return ((event >> 16) & 0xFF);
 }
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (eventId & 0xFFFF);
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
 }
 }
diff --git a/events/Event.h b/events/Event.h
index f8410f32..f5434826 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -18,9 +18,10 @@ EventId_t getEventId(Event event);
 
 EventSeverity_t getSeverity(Event event);
 
-Event makeEvent(EventId_t eventId, EventSeverity_t eventSeverity);
-
+Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity);
 }
+
 namespace SEVERITY {
 	static const EventSeverity_t INFO = 1;
 	static const EventSeverity_t LOW = 2;

From 9aca5cb6f246d3db825bb447fa18d28468a59ec4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 14:59:40 +0200
Subject: [PATCH 0804/1292] taken over convergence changes

---
 memory/AcceptsMemoryMessagesIF.h | 17 ++++---------
 memory/MemoryHelper.cpp          | 15 +++++------
 memory/MemoryHelper.h            | 36 +++++++++++++++++---------
 memory/MemoryMessage.cpp         | 27 ++++++++------------
 memory/MemoryMessage.h           | 43 +++++++++++++++++++-------------
 modes/HasModesIF.h               | 24 +++++++-----------
 modes/ModeHelper.cpp             |  7 +++---
 modes/ModeHelper.h               | 14 +++++------
 modes/ModeMessage.cpp            | 10 ++++----
 modes/ModeMessage.h              | 20 ++++++---------
 10 files changed, 106 insertions(+), 107 deletions(-)

diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index 4c222dec..cf8aa5ec 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -1,15 +1,8 @@
-/**
- * @file	AcceptsMemoryMessagesIF.h
- * @brief	This file defines the AcceptsMemoryMessagesIF class.
- * @date	11.07.2013
- * @author	baetz
- */
+#ifndef FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
+#define FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_
 
-#ifndef ACCEPTSMEMORYMESSAGESIF_H_
-#define ACCEPTSMEMORYMESSAGESIF_H_
-
-#include "../memory/HasMemoryIF.h"
-#include "../memory/MemoryMessage.h"
+#include "HasMemoryIF.h"
+#include "MemoryMessage.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
 class AcceptsMemoryMessagesIF : public HasMemoryIF {
@@ -18,4 +11,4 @@ public:
 };
 
 
-#endif /* ACCEPTSMEMORYMESSAGESIF_H_ */
+#endif /* AFSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 2daddf63..6b11882f 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -1,14 +1,15 @@
+#include "MemoryHelper.h"
+#include "MemoryMessage.h"
+
 #include "../globalfunctions/CRC.h"
-#include "../memory/MemoryHelper.h"
-#include "../memory/MemoryMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/EndianConverter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
 		MessageQueueIF* useThisQueue):
-		workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(nullptr),
-		ipcAddress(), lastCommand(CommandMessage::CMD_NONE), busy(false) {
+		workOnThis(workOnThis), queueToUse(useThisQueue), ipcAddress(),
+		lastCommand(CommandMessage::CMD_NONE), busy(false) {
 }
 
 ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
@@ -34,7 +35,7 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 }
 
 void MemoryHelper::completeLoad(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size, uint8_t* copyHere) {
+		const uint8_t* dataToCopy, const size_t size, uint8_t* copyHere) {
 	busy = false;
 	switch (errorCode) {
 	case HasMemoryIF::DO_IT_MYSELF:
@@ -64,7 +65,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
 }
 
 void MemoryHelper::completeDump(ReturnValue_t errorCode,
-		const uint8_t* dataToCopy, const uint32_t size) {
+		const uint8_t* dataToCopy, const size_t size) {
 	busy = false;
 	CommandMessage reply;
 	MemoryMessage::setMemoryReplyFailed(&reply, errorCode, lastCommand);
@@ -121,7 +122,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
 }
 
 void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
-		uint32_t totalSize, uint8_t datatypeSize) {
+		size_t totalSize, uint8_t datatypeSize) {
 	if (totalSize % datatypeSize != 0){
 		return;
 	}
diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h
index 418cf50d..a651861c 100644
--- a/memory/MemoryHelper.h
+++ b/memory/MemoryHelper.h
@@ -1,11 +1,16 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYHELPER_H_
-#define FRAMEWORK_MEMORY_MEMORYHELPER_H_
+#ifndef FSFW_MEMORY_MEMORYHELPER_H_
+#define FSFW_MEMORY_MEMORYHELPER_H_
+
+#include "AcceptsMemoryMessagesIF.h"
+
 #include "../ipc/CommandMessage.h"
-#include "../memory/AcceptsMemoryMessagesIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../ipc/MessageQueueIF.h"
 
+/**
+ * @brief   TODO: documentation.
+ */
 class MemoryHelper : public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::MEMORY_HELPER;
@@ -13,6 +18,20 @@ public:
 	static const ReturnValue_t INVALID_ADDRESS = MAKE_RETURN_CODE(0xE1);
 	static const ReturnValue_t INVALID_SIZE = MAKE_RETURN_CODE(0xE2);
 	static const ReturnValue_t STATE_MISMATCH = MAKE_RETURN_CODE(0xE3);
+
+    MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue);
+    ~MemoryHelper();
+
+    ReturnValue_t handleMemoryCommand(CommandMessage* message);
+    void completeLoad(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0,
+            uint8_t* copyHere = nullptr);
+    void completeDump(ReturnValue_t errorCode,
+            const uint8_t* dataToCopy = nullptr, const size_t size = 0);
+    void swapMatrixCopy(uint8_t *out, const uint8_t *in, size_t totalSize,
+            uint8_t datatypeSize);
+    ReturnValue_t initialize(MessageQueueIF* queueToUse_);
+
 private:
 	HasMemoryIF* workOnThis;
 	MessageQueueIF* queueToUse;
@@ -25,13 +44,6 @@ private:
 	void handleMemoryLoad(CommandMessage* message);
 	void handleMemoryCheckOrDump(CommandMessage* message);
 	ReturnValue_t initialize();
-public:
-	ReturnValue_t handleMemoryCommand(CommandMessage* message);
-	void completeLoad( ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0, uint8_t* copyHere = NULL );
-	void completeDump(  ReturnValue_t errorCode, const uint8_t* dataToCopy = NULL, const uint32_t size = 0);
-	void swapMatrixCopy( uint8_t *out, const uint8_t *in, uint32_t totalSize, uint8_t datatypeSize);
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_);
-	MemoryHelper( HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue );
-	~MemoryHelper();
+
 };
-#endif /* MEMORYHELPER_H_ */
+#endif /* FSFW_MEMORY_MEMORYHELPER_H_ */
diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp
index 4e077dee..94fa4691 100644
--- a/memory/MemoryMessage.cpp
+++ b/memory/MemoryMessage.cpp
@@ -1,7 +1,6 @@
-#include "../memory/MemoryMessage.h"
+#include "MemoryMessage.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
-MemoryMessage::MemoryMessage() {
-}
 
 uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
 	return message->getParameter();
@@ -17,18 +16,17 @@ uint32_t MemoryMessage::getLength(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
+void MemoryMessage::setMemoryDumpCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_DUMP);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryDumpReply(CommandMessage* message, store_address_t storageID) {
+void MemoryMessage::setMemoryDumpReply(CommandMessage* message,
+        store_address_t storageID) {
 	message->setCommand(REPLY_MEMORY_DUMP);
 	message->setParameter2( storageID.raw );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void MemoryMessage::setMemoryLoadCommand(CommandMessage* message,
@@ -64,22 +62,21 @@ void MemoryMessage::clear(CommandMessage* message) {
 		}
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
+void MemoryMessage::setMemoryCheckCommand(CommandMessage* message,
 		uint32_t address, uint32_t length) {
 	message->setCommand(CMD_MEMORY_CHECK);
 	message->setParameter( address );
 	message->setParameter2( length );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCheckReply(CommandMessage* message,
+void MemoryMessage::setMemoryCheckReply(CommandMessage* message,
 		uint16_t crc) {
 	message->setCommand(REPLY_MEMORY_CHECK);
 	message->setParameter( crc );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void MemoryMessage::setCrcReturnValue(CommandMessage* message, ReturnValue_t returnValue){
+void MemoryMessage::setCrcReturnValue(CommandMessage* message,
+        ReturnValue_t returnValue){
 	message->setParameter(returnValue<<16);
 };
 
@@ -95,18 +92,16 @@ Command_t MemoryMessage::getInitialCommand(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
+void MemoryMessage::setMemoryReplyFailed(CommandMessage* message,
 		ReturnValue_t errorCode, Command_t initialCommand) {
 	message->setCommand(REPLY_MEMORY_FAILED);
 	message->setParameter(errorCode);
 	message->setParameter2(initialCommand);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
+void MemoryMessage::setMemoryCopyEnd(CommandMessage* message) {
 	message->setCommand(END_OF_MEMORY_COPY);
 	message->setParameter(0);
 	message->setParameter2(0);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h
index a366eb9a..05b9926d 100644
--- a/memory/MemoryMessage.h
+++ b/memory/MemoryMessage.h
@@ -1,14 +1,15 @@
-#ifndef MEMORYMESSAGE_H_
-#define MEMORYMESSAGE_H_
+#ifndef FSFW_MEMORY_MEMORYMESSAGE_H_
+#define FSFW_MEMORY_MEMORYMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 
 class MemoryMessage {
-private:
-	MemoryMessage(); //A private ctor inhibits instantiation
 public:
+    // Instantiation forbidden.
+	MemoryMessage() = delete;
+
 	static const uint8_t MESSAGE_ID = messagetypes::MEMORY;
 	static const Command_t CMD_MEMORY_LOAD = MAKE_COMMAND_ID( 0x01 );
 	static const Command_t CMD_MEMORY_DUMP = MAKE_COMMAND_ID( 0x02 );
@@ -19,21 +20,29 @@ public:
 	static const Command_t END_OF_MEMORY_COPY = MAKE_COMMAND_ID(0xF0);
 
 	static uint32_t getAddress( const CommandMessage* message );
-	static store_address_t getStoreID( const CommandMessage* message );
+	static store_address_t getStoreID(const CommandMessage* message);
 	static uint32_t getLength( const CommandMessage* message );
-	static ReturnValue_t getErrorCode( const CommandMessage* message );
-	static ReturnValue_t setMemoryDumpCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryDumpReply( CommandMessage* message, store_address_t storageID );
-	static void setMemoryLoadCommand( CommandMessage* message, uint32_t address, store_address_t storageID );
-	static ReturnValue_t setMemoryCheckCommand( CommandMessage* message, uint32_t address, uint32_t length );
-	static ReturnValue_t setMemoryCheckReply(  CommandMessage* message, uint16_t crc );
-	static ReturnValue_t setMemoryReplyFailed(  CommandMessage* message, ReturnValue_t errorCode, Command_t initialCommand );
-	static ReturnValue_t setMemoryCopyEnd( CommandMessage* message);
+	static ReturnValue_t getErrorCode(const CommandMessage* message);
+    static uint16_t getCrc(const CommandMessage* message );
+    static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
+    static Command_t getInitialCommand(const CommandMessage* message);
+
+	static void setMemoryDumpCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length );
+	static void setMemoryDumpReply(CommandMessage* message,
+	        store_address_t storageID);
+	static void setMemoryLoadCommand(CommandMessage* message,
+	        uint32_t address, store_address_t storageID );
+	static void setMemoryCheckCommand(CommandMessage* message,
+	        uint32_t address, uint32_t length);
+	static void setMemoryCheckReply(CommandMessage* message,
+	        uint16_t crc);
+	static void setMemoryReplyFailed(CommandMessage* message,
+	        ReturnValue_t errorCode, Command_t initialCommand);
+	static void setMemoryCopyEnd(CommandMessage* message);
 	static void setCrcReturnValue(CommandMessage*, ReturnValue_t returnValue);
-	static uint16_t getCrc( const CommandMessage* message );
-	static ReturnValue_t getCrcReturnValue(const CommandMessage* message);
-	static Command_t getInitialCommand( const CommandMessage* message );
+
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MEMORYMESSAGE_H_ */
+#endif /* FSFW_MEMORY_MEMORYMESSAGE_H_ */
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 39a50c2a..34a15937 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -1,18 +1,11 @@
-/**
- * @file	HasModesIF.h
- * @brief	This file defines the HasModesIF class.
- * @date	20.06.2013
- * @author	baetz
- */
-
-#ifndef HASMODESIF_H_
-#define HASMODESIF_H_
+#ifndef FSFW_MODES_HASMODESIF_H_
+#define FSFW_MODES_HASMODESIF_H_
 
+#include "ModeHelper.h"
+#include "ModeMessage.h"
 #include "../events/Event.h"
-#include "../modes/ModeHelper.h"
-#include "../modes/ModeMessage.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 
 
 class HasModesIF {
@@ -37,10 +30,11 @@ public:
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
 	static const Submode_t SUBMODE_NONE = 0; //!< To avoid checks against magic number "0".
-	virtual ~HasModesIF() {
-	}
+
+	virtual ~HasModesIF() {}
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
+
 protected:
 	virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
 			uint32_t *msToReachTheMode) {
@@ -54,4 +48,4 @@ protected:
 	virtual void announceMode(bool recursive) {}
 };
 
-#endif /* HASMODESIF_H_ */
+#endif /*FSFW_MODES_HASMODESIF_H_ */
diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp
index 68f009e7..6be4f776 100644
--- a/modes/ModeHelper.cpp
+++ b/modes/ModeHelper.cpp
@@ -1,6 +1,7 @@
+#include "HasModesIF.h"
+#include "ModeHelper.h"
+
 #include "../ipc/MessageQueueSenderIF.h"
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 ModeHelper::ModeHelper(HasModesIF *owner) :
@@ -26,7 +27,7 @@ ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
 		uint32_t timeout;
 		ReturnValue_t result = owner->checkModeCommand(mode, submode, &timeout);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			ModeMessage::cantReachMode(&reply, result);
+			ModeMessage::setCantReachMode(&reply, result);
 			MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 			        owner->getCommandQueue());
 			break;
diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h
index 02cf5799..c2f089ec 100644
--- a/modes/ModeHelper.h
+++ b/modes/ModeHelper.h
@@ -1,8 +1,8 @@
-#ifndef MODEHELPER_H_
-#define MODEHELPER_H_
+#ifndef FSFW_MODES_MODEHELPER_H_
+#define FSFW_MODES_MODEHELPER_H_
 
+#include "ModeMessage.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../modes/ModeMessage.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
@@ -20,14 +20,14 @@ public:
 	ReturnValue_t handleModeCommand(CommandMessage *message);
 
 	/**
-	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue the Queue id of the parent object.
+	 * Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueueId);
 
 	ReturnValue_t initialize(MessageQueueId_t parentQueueId);
 
-	ReturnValue_t initialize(void); //void is there to stop eclipse CODAN from falsely reporting an error
+	ReturnValue_t initialize(void);
 
 	void modeChanged(Mode_t mode, Submode_t submode);
 
@@ -50,4 +50,4 @@ private:
 	void sendModeInfoMessage(Mode_t ownerMode, Submode_t ownerSubmode);
 };
 
-#endif /* MODEHELPER_H_ */
+#endif /* FSFW_MODES_MODEHELPER_H_ */
diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp
index 7ad7d06f..b33bba60 100644
--- a/modes/ModeMessage.cpp
+++ b/modes/ModeMessage.cpp
@@ -1,4 +1,4 @@
-#include "../modes/ModeMessage.h"
+#include "ModeMessage.h"
 
 Mode_t ModeMessage::getMode(const CommandMessage* message) {
 	return message->getParameter();
@@ -8,12 +8,11 @@ Submode_t ModeMessage::getSubmode(const CommandMessage* message) {
 	return message->getParameter2();
 }
 
-ReturnValue_t ModeMessage::setModeMessage(CommandMessage* message, Command_t command,
-		Mode_t mode, Submode_t submode) {
+void ModeMessage::setModeMessage(CommandMessage* message,
+        Command_t command, Mode_t mode, Submode_t submode) {
 	message->setCommand( command );
 	message->setParameter( mode );
 	message->setParameter2( submode );
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ModeMessage::getCantReachModeReason(const CommandMessage* message) {
@@ -24,7 +23,8 @@ void ModeMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 }
 
-void ModeMessage::cantReachMode(CommandMessage* message, ReturnValue_t reason) {
+void ModeMessage::setCantReachMode(CommandMessage* message,
+        ReturnValue_t reason) {
 	message->setCommand(REPLY_CANT_REACH_MODE);
 	message->setParameter(reason);
 	message->setParameter2(0);
diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h
index 925f3fc1..856996cf 100644
--- a/modes/ModeMessage.h
+++ b/modes/ModeMessage.h
@@ -1,12 +1,5 @@
-/**
- * @file	ModeMessage.h
- * @brief	This file defines the ModeMessage class.
- * @date	17.07.2013
- * @author	baetz
- */
-
-#ifndef MODEMESSAGE_H_
-#define MODEMESSAGE_H_
+#ifndef FSFW_MODES_MODEMESSAGE_H_
+#define FSFW_MODES_MODEMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 
@@ -30,11 +23,12 @@ public:
 
 	static Mode_t getMode(const CommandMessage* message);
 	static Submode_t getSubmode(const CommandMessage* message);
-	static ReturnValue_t setModeMessage(CommandMessage* message,
+    static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+
+	static void setModeMessage(CommandMessage* message,
 			Command_t command, Mode_t mode, Submode_t submode);
-	static void cantReachMode(CommandMessage* message, ReturnValue_t reason);
-	static ReturnValue_t getCantReachModeReason(const CommandMessage* message);
+	static void setCantReachMode(CommandMessage* message, ReturnValue_t reason);
 	static void clear(CommandMessage* message);
 };
 
-#endif /* MODEMESSAGE_H_ */
+#endif /* FSFW_MODES_MODEMESSAGE_H_ */

From fab7eb8a5d40386237ee243cc98af78e22f5fffe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:03:04 +0200
Subject: [PATCH 0805/1292] controller base update

---
 controller/ControllerBase.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index da84ed27..4f50fe1f 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -1,5 +1,5 @@
-#include "../subsystem/SubsystemBase.h"
-#include "../controller/ControllerBase.h"
+#include "ControllerBase.h"
+
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
@@ -25,7 +25,7 @@ ReturnValue_t ControllerBase::initialize() {
 	MessageQueueId_t parentQueue = 0;
 	if (parentId != objects::NO_OBJECT) {
 		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == NULL) {
+		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}
 		parentQueue = parent->getCommandQueue();

From 08d0e0949342c3620fb119c9d2e6dabde243e2aa Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:16:13 +0200
Subject: [PATCH 0806/1292] power equalization

---
 power/Fuse.cpp           | 20 ++++++++++++--------
 power/Fuse.h             | 13 +++++++------
 power/PowerComponent.cpp | 24 +++++++++---------------
 power/PowerComponent.h   | 24 ++++++++++++++----------
 power/PowerComponentIF.h | 14 +++++++-------
 power/PowerSensor.cpp    | 14 ++++++++------
 power/PowerSensor.h      |  8 ++++----
 power/PowerSwitchIF.h    | 23 ++++++++---------------
 power/PowerSwitcher.cpp  | 25 ++++++++++++++++---------
 power/PowerSwitcher.h    | 19 ++++++++++++-------
 10 files changed, 97 insertions(+), 87 deletions(-)

diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 3ea0b18c..ace625bf 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -1,7 +1,8 @@
+#include "Fuse.h"
+
 #include "../monitoring/LimitViolationReporter.h"
 #include "../monitoring/MonitoringMessageContent.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../power/Fuse.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../ipc/QueueFactory.h"
 
@@ -10,13 +11,16 @@ object_id_t Fuse::powerSwitchId = 0;
 Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
 		float maxCurrent, uint16_t confirmationCount) :
 		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
-				maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
-				GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
-				confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
-				ids.pidCurrent, &set), state(ids.pidState, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
-				NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
+		NULL),
+		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
+				maxCurrent, FUSE_CURRENT_HIGH),
+		powerMonitor(fuseObjectId, 2,
+		        GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+				confirmationCount),
+		set(), voltage(ids.pidVoltage, &set), current(ids.pidCurrent, &set),
+		state(ids.pidState, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
+		parameterHelper(this), healthHelper(this, fuseObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue();
 }
 
diff --git a/power/Fuse.h b/power/Fuse.h
index dd8759f4..13a0eb7c 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -1,13 +1,14 @@
-#ifndef FUSE_H_
-#define FUSE_H_
+#ifndef FSFW_POWER_FUSE_H_
+#define FSFW_POWER_FUSE_H_
+
+#include "PowerComponentIF.h"
+#include "PowerSwitchIF.h"
 
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
-#include "../power/PowerComponentIF.h"
-#include "../power/PowerSwitchIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../parameters/ParameterHelper.h"
 #include <list>
@@ -90,7 +91,7 @@ private:
 	PIDReader<float> current;
 	PIDReader<uint8_t> state;
 	gp_float_t power;
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	static object_id_t powerSwitchId;
@@ -103,4 +104,4 @@ private:
 	bool areSwitchesOfComponentOn(DeviceList::iterator iter);
 };
 
-#endif /* FUSE_H_ */
+#endif /* FSFW_POWER_FUSE_H_ */
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index a3797055..4af7c96b 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,20 +1,14 @@
-/**
- * @file	PowerComponent.cpp
- * @brief	This file defines the PowerComponent class.
- * @date	28.08.2014
- * @author	baetz
- */
+#include "PowerComponent.h"
 
-#include "../power/PowerComponent.h"
-
-PowerComponent::PowerComponent() :
-		deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
-		false), min(0.0), max(0.0), moduleId(0) {
+PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
+        doIHaveTwoSwitches(false) {
 }
-PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
-		uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
-		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2), doIHaveTwoSwitches(
-				twoSwitches), min(min), max(max), moduleId(moduleId) {
+
+PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min,
+        float max, uint8_t switchId1, bool twoSwitches, uint8_t switchId2) :
+		deviceObjectId(setId), switchId1(switchId1), switchId2(switchId2),
+		doIHaveTwoSwitches(twoSwitches), min(min), max(max),
+		moduleId(moduleId) {
 }
 
 ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
diff --git a/power/PowerComponent.h b/power/PowerComponent.h
index dc5217be..c1add3b9 100644
--- a/power/PowerComponent.h
+++ b/power/PowerComponent.h
@@ -1,13 +1,17 @@
-#ifndef POWERCOMPONENT_H_
-#define POWERCOMPONENT_H_
+#ifndef FSFW_POWER_POWERCOMPONENT_H_
+#define FSFW_POWER_POWERCOMPONENT_H_
 
+#include "PowerComponentIF.h"
+
+#include "../objectmanager/frameworkObjects.h"
 #include "../objectmanager/SystemObjectIF.h"
-#include "../power/PowerComponentIF.h"
+
 
 class PowerComponent: public PowerComponentIF {
 public:
-	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
-			bool twoSwitches = false, uint8_t switchId2 = 0xFF);
+	PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
+	        uint8_t switchId1, bool twoSwitches = false,
+	        uint8_t switchId2 = 0xFF);
 
 	virtual object_id_t getDeviceObjectId();
 
@@ -31,18 +35,18 @@ public:
 				ParameterWrapper *parameterWrapper,
 				const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	const object_id_t deviceObjectId;
+	const object_id_t deviceObjectId = objects::NO_OBJECT;
 	const uint8_t switchId1;
 	const uint8_t switchId2;
 
 	const bool doIHaveTwoSwitches;
 
-	float min;
-	float max;
+	float min = 0.0;
+	float max = 0.0;
 
-	uint8_t moduleId;
+	uint8_t moduleId = 0;
 
 	PowerComponent();
 };
 
-#endif /* POWERCOMPONENT_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENT_H_ */
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index c2e3a6a5..58f27b6c 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -1,5 +1,5 @@
-#ifndef POWERCOMPONENTIF_H_
-#define POWERCOMPONENTIF_H_
+#ifndef FSFW_POWER_POWERCOMPONENTIF_H_
+#define FSFW_POWER_POWERCOMPONENTIF_H_
 
 #include "../serialize/SerializeIF.h"
 #include "../parameters/HasParametersIF.h"
@@ -10,15 +10,15 @@ public:
 
 	}
 
-	virtual object_id_t getDeviceObjectId()=0;
+	virtual object_id_t getDeviceObjectId() = 0;
 
-	virtual uint8_t getSwitchId1()=0;
-	virtual uint8_t getSwitchId2()=0;
-	virtual bool hasTwoSwitches()=0;
+	virtual uint8_t getSwitchId1() = 0;
+	virtual uint8_t getSwitchId2() = 0;
+	virtual bool hasTwoSwitches() = 0;
 
 	virtual float getMin() = 0;
 	virtual float getMax() = 0;
 
 };
 
-#endif /* POWERCOMPONENTIF_H_ */
+#endif /* FSFW_POWER_POWERCOMPONENTIF_H_ */
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index df26fb8e..739d02f2 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -1,14 +1,16 @@
-#include "../power/PowerSensor.h"
+#include "PowerSensor.h"
+
 #include "../ipc/QueueFactory.h"
 
 PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
 		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
-				ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
-				ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
-				setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+		SystemObject(setId), parameterHelper(this), healthHelper(this, setId),
+		set(), current(ids.pidCurrent, &set), voltage(ids.pidVoltage, &set),
+		power(ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE),
+		currentLimit(setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
 				limits.currentMin, limits.currentMax, events.currentLow,
-				events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
+				events.currentHigh),
+		voltageLimit(setId, MODULE_ID_VOLTAGE,
 				ids.pidVoltage, confirmationCount, limits.voltageMin,
 				limits.voltageMax, events.voltageLow, events.voltageHigh) {
 		commandQueue = QueueFactory::instance()->createMessageQueue();
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index da0bd8c7..20ebff39 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,5 +1,5 @@
-#ifndef POWERSENSOR_H_
-#define POWERSENSOR_H_
+#ifndef FSFW_POWER_POWERSENSOR_H_
+#define FSFW_POWER_POWERSENSOR_H_
 
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
@@ -50,7 +50,7 @@ public:
 			ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex);
 private:
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
 	GlobDataSet set;
@@ -68,4 +68,4 @@ protected:
 	LimitMonitor<float> voltageLimit;
 };
 
-#endif /* POWERSENSOR_H_ */
+#endif /* FSFW_POWER_POWERSENSOR_H_ */
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 876a82c5..1422baeb 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -1,22 +1,15 @@
-/**
- * @file	PowerSwitchIF.h
- * @brief	This file defines the PowerSwitchIF class.
- * @date	20.03.2013
- * @author	baetz
- */
-
-#ifndef POWERSWITCHIF_H_
-#define POWERSWITCHIF_H_
+#ifndef FSFW_POWER_POWERSWITCHIF_H_
+#define FSFW_POWER_POWERSWITCHIF_H_
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 /**
  *
- * @brief   This interface defines a connection to a device that is capable of turning on and off
- *          switches of devices identified by a switch ID.
- * @details The virtual functions of this interface do not allow to make any assignments
- *          because they can be called asynchronosuly (const ending).
- *
+ * @brief   This interface defines a connection to a device that is capable of
+ *          turning on and off switches of devices identified by a switch ID.
+ * @details
+ * The virtual functions of this interface do not allow to make any assignments
+ * because they can be called asynchronosuly (const ending).
  * @ingroup interfaces
  */
 class PowerSwitchIF : public HasReturnvaluesIF {
@@ -77,4 +70,4 @@ public:
 };
 
 
-#endif /* POWERSWITCHIF_H_ */
+#endif /* FSFW_POWER_POWERSWITCHIF_H_ */
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index 1844a11a..a9ada457 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -1,15 +1,17 @@
+#include "PowerSwitcher.h"
+
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../power/PowerSwitcher.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
-		PowerSwitcher::State_t setStartState) :
-		state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
+		PowerSwitcher::State_t setStartState):
+		state(setStartState), firstSwitch(setSwitch1),
+		secondSwitch(setSwitch2) {
 }
 
 ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
-	if (power == NULL) {
+	if (power == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -17,17 +19,22 @@ ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
 
 ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 	SwitchReturn_t result = howManySwitches();
+
 	switch (result) {
 	case ONE_SWITCH:
 		return power->getSwitchState(firstSwitch);
 	case TWO_SWITCHES:
-		if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
+	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
+	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
+		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
+				&& (secondSwitchState == PowerSwitchIF::SWITCH_ON)) {
 			return PowerSwitchIF::SWITCH_ON;
-		} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
-				&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
+		}
+		else if ((firstSwitchState == PowerSwitchIF::SWITCH_OFF)
+				&& (secondSwitchState  == PowerSwitchIF::SWITCH_OFF)) {
 			return PowerSwitchIF::SWITCH_OFF;
-		} else {
+		}
+		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	default:
diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h
index 515ce042..f4e2138d 100644
--- a/power/PowerSwitcher.h
+++ b/power/PowerSwitcher.h
@@ -1,10 +1,13 @@
-#ifndef POWERSWITCHER_H_
-#define POWERSWITCHER_H_
-#include "../power/PowerSwitchIF.h"
+#ifndef FSFW_POWER_POWERSWITCHER_H_
+#define FSFW_POWER_POWERSWITCHER_H_
+
+#include "PowerSwitchIF.h"
+
+#include "../objectmanager/SystemObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../timemanager/Countdown.h"
 
-class PowerSwitcher : public HasReturnvaluesIF {
+class PowerSwitcher: public HasReturnvaluesIF {
 public:
 	enum State_t {
 		WAIT_OFF,
@@ -16,7 +19,8 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
 	static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
+	PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH,
+	        State_t setStartState = SWITCH_IS_OFF );
 	ReturnValue_t initialize(object_id_t powerSwitchId);
 	void turnOn();
 	void turnOff();
@@ -29,7 +33,8 @@ public:
 private:
 	uint8_t firstSwitch;
 	uint8_t secondSwitch;
-	PowerSwitchIF* power;
+	PowerSwitchIF* power = nullptr;
+
 	static const uint8_t NO_SWITCH = 0xFF;
 	enum SwitchReturn_t {
 		ONE_SWITCH = 1,
@@ -42,4 +47,4 @@ private:
 
 
 
-#endif /* POWERSWITCHER_H_ */
+#endif /* FSFW_POWER_POWERSWITCHER_H_ */

From 6fd39dfac38da3c825f14b8171e05ef961dcb96c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:27:06 +0200
Subject: [PATCH 0807/1292] set struct reporting continued

---
 datapoollocal/LocalDataPoolManager.cpp | 12 ++++++++++++
 housekeeping/HousekeepingMessage.cpp   | 14 ++++++++++++++
 housekeeping/HousekeepingMessage.h     |  6 ++++++
 power/PowerComponentIF.h               |  5 ++---
 power/PowerSwitcher.cpp                |  3 ++-
 5 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 635fafce..553d2ec1 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -392,5 +392,17 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		sif::error << "HousekeepingManager::generateSetStructurePacket: "
 				"Expected size is not equal to serialized size" << std::endl;
 	}
+
+	CommandMessage reply;
+	if(isDiagnostics) {
+	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+	            sid, storeId);
+	}
+	else {
+	    HousekeepingMessage::setHkStuctureReportReply(&reply,
+	                    sid, storeId);
+	}
+
+	hkQueue->reply(&reply);
 	return result;
 }
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 25475072..706bd273 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -126,3 +126,17 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
 void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
 	std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
+
+void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply,
+        sid_t sid, store_address_t storeId) {
+    reply->setCommand(HK_DEFINITIONS_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setDiagnosticsStuctureReportReply(
+        CommandMessage *reply, sid_t sid, store_address_t storeId) {
+    reply->setCommand(DIAGNOSTICS_DEFINITION_REPORT);
+    setSid(reply, sid);
+    reply->setParameter3(storeId.raw);
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 5c1b4e55..af89dade 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -121,6 +121,12 @@ public:
 	static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
 	static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid,
 			ReturnValue_t error);
+
+	static void setHkStuctureReportReply(CommandMessage* reply,
+	        sid_t sid, store_address_t storeId);
+	static void setDiagnosticsStuctureReportReply(CommandMessage* reply,
+	            sid_t sid, store_address_t storeId);
+
 	static sid_t getHkRequestFailureReply(const CommandMessage* reply,
 			ReturnValue_t* error);
 
diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h
index 58f27b6c..f35b4d1d 100644
--- a/power/PowerComponentIF.h
+++ b/power/PowerComponentIF.h
@@ -3,12 +3,11 @@
 
 #include "../serialize/SerializeIF.h"
 #include "../parameters/HasParametersIF.h"
+#include "../objectmanager/SystemObjectIF.h"
 
 class PowerComponentIF : public SerializeIF, public HasParametersIF {
 public:
-	virtual ~PowerComponentIF() {
-
-	}
+	virtual ~PowerComponentIF() {}
 
 	virtual object_id_t getDeviceObjectId() = 0;
 
diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp
index a9ada457..ed37998e 100644
--- a/power/PowerSwitcher.cpp
+++ b/power/PowerSwitcher.cpp
@@ -23,7 +23,7 @@ ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 	switch (result) {
 	case ONE_SWITCH:
 		return power->getSwitchState(firstSwitch);
-	case TWO_SWITCHES:
+	case TWO_SWITCHES: {
 	    ReturnValue_t firstSwitchState = power->getSwitchState(firstSwitch);
 	    ReturnValue_t secondSwitchState = power->getSwitchState(firstSwitch);
 		if ((firstSwitchState == PowerSwitchIF::SWITCH_ON)
@@ -37,6 +37,7 @@ ReturnValue_t PowerSwitcher::getStateOfSwitches() {
 		else {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}

From 55bdd2c2f5e8d656375912dc24a4d40515bca925 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:28:28 +0200
Subject: [PATCH 0808/1292] include fix

---
 datapoollocal/LocalDataPoolManager.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 553d2ec1..7986a3ed 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,7 @@
-#include <fsfw/housekeeping/HousekeepingSetPacket.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolDataSetBase.h"
+
+#include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"

From 50621704073764a4673288442e54346af7bf4af2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:32:16 +0200
Subject: [PATCH 0809/1292] correct function used now

---
 datapoollocal/LocalDataPoolManager.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7986a3ed..4299861e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -154,9 +154,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     }
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
+        return generateSetStructurePacket(sid, true);
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-		//return generateSetStructurePacket(sid, );
-		return HasReturnvaluesIF::RETURN_OK;
+        return generateSetStructurePacket(sid, false);
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
     	float newCollIntvl = 0;
@@ -354,6 +354,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
+    // Get and check dataset first.
 	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
 			owner->getDataSetHandle(sid));
 	if(dataSet == nullptr) {
@@ -373,6 +374,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 	float collectionInterval =
 			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
+	// Generate set packet which can be serialized.
 	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
 			reportingEnabled, valid, collectionInterval, dataSet);
 	size_t expectedSize = setPacket.getSerializedSize();
@@ -386,6 +388,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		return result;
 	}
 
+	// Serialize set packet into store.
 	size_t size = 0;
 	result = setPacket.serialize(&storePtr, &size, expectedSize,
 			SerializeIF::Endianness::BIG);
@@ -394,6 +397,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 				"Expected size is not equal to serialized size" << std::endl;
 	}
 
+	// Send structure reporting reply.
 	CommandMessage reply;
 	if(isDiagnostics) {
 	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,

From de08bd6c8a9b8ec3f0627a028c319446d0a09bc7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:33:24 +0200
Subject: [PATCH 0810/1292] small include fix

---
 datapoollocal/LocalPoolVector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 69df192c..57c4b90b 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -194,7 +194,7 @@ private:
 
 };
 
-#include "../datapoollocal/LocalPoolVector.tpp"
+#include "LocalPoolVector.tpp"
 
 template<typename T, uint16_t vectorSize>
 using lp_vec_t = LocalPoolVector<T, vectorSize>;

From 52d8c4f3a84c870e67f251be025ec27f657d2e17 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 15:35:10 +0200
Subject: [PATCH 0811/1292] include guard fix

---
 datapoollocal/LocalDataPoolManager.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 44b15f59..55d971ce 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
 #include "HasLocalDataPoolIF.h"
 
@@ -276,4 +276,4 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 }
 
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */

From e67b1fce9a1f23d30a73d41142472adb7fb42b57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 16:38:07 +0200
Subject: [PATCH 0812/1292] added additional include

---
 controller/ControllerBase.h          | 1 +
 datapoollocal/LocalDataPoolManager.h | 1 +
 2 files changed, 2 insertions(+)

diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 400c3bb6..6c2ec1d6 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -7,6 +7,7 @@
 #include "../modes/ModeHelper.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
+#include "../tasks/PeriodicTaskIF.h"
 #include "../datapool/HkSwitchHelper.h"
 
 /**
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 55d971ce..3b9b6cd9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -173,6 +173,7 @@ private:
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
+
     /** The class which actually owns the manager (and its datapool). */
     HasLocalDataPoolIF* owner = nullptr;
 

From 4a97596030f2dbebcdebdd00c2c524e74df00d36 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:21:32 +0200
Subject: [PATCH 0813/1292] internal error reporter uses new local datapool now

---
 internalError/InternalErrorDataset.h    |  31 +++++++
 internalError/InternalErrorReporter.cpp | 107 +++++++++++++++++-------
 internalError/InternalErrorReporter.h   |  63 ++++++++++----
 3 files changed, 158 insertions(+), 43 deletions(-)
 create mode 100644 internalError/InternalErrorDataset.h

diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
new file mode 100644
index 00000000..c5dc3d73
--- /dev/null
+++ b/internalError/InternalErrorDataset.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+#define FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+
+enum errorPoolIds {
+    TM_HITS,
+    QUEUE_HITS,
+    STORE_HITS
+};
+
+
+class InternalErrorDataset: public StaticLocalDataSet<3 * sizeof(uint32_t)> {
+public:
+    static constexpr uint8_t ERROR_SET_ID = 0;
+
+    InternalErrorDataset(HasLocalDataPoolIF* owner):
+            StaticLocalDataSet(owner, ERROR_SET_ID) {}
+
+    InternalErrorDataset(sid_t sid):
+           StaticLocalDataSet(sid) {}
+
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS, sid.objectId, this);
+};
+
+
+
+#endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3424266b..f22fd03a 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,16 +1,18 @@
-#include "../datapoolglob/GlobalDataSet.h"
 #include "InternalErrorReporter.h"
 
+#include "../ipc/QueueFactory.h"
+#include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../ipc/MutexFactory.h"
-
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-		uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) :
-		SystemObject(setObjectId), mutex(NULL), queuePoolId(queuePoolId),
-		tmPoolId(tmPoolId),storePoolId(storePoolId), queueHits(0), tmHits(0),
-		storeHits(0) {
+        uint32_t messageQueueDepth) :
+		SystemObject(setObjectId),
+		commandQueue(QueueFactory::instance()->
+		        createMessageQueue(messageQueueDepth)),
+		poolManager(this, commandQueue),
+		internalErrorDataset(this) {
 	mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -18,28 +20,40 @@ InternalErrorReporter::~InternalErrorReporter() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
 
+void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
+    this->diagnosticPrintout = enable;
+}
+
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-
-	GlobDataSet mySet;
-	gp_uint32_t queueHitsInPool(queuePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	gp_uint32_t tmHitsInPool(tmPoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-
-	gp_uint32_t storeHitsInPool(storePoolId, &mySet,
-			PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
+    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-	queueHitsInPool.value += newQueueHits;
-	tmHitsInPool.value += newTmHits;
-	storeHitsInPool.value += newStoreHits;
+#ifdef DEBUG
+	if(diagnosticPrintout) {
+	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+	        sif::debug << "InternalErrorReporter::performOperation: Errors "
+	                << "occured!" << std::endl;
+	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
+	        sif::debug << "TM errors: " << newQueueHits << std::endl;
+	        sif::debug << "Store errors: " << newQueueHits << std::endl;
+	    }
+	}
+#endif
 
-	mySet.commit(PoolVariableIF::VALID);
+	internalErrorDataset.queueHits.value += newQueueHits;
+	internalErrorDataset.storeHits.value += newTmHits;
+	internalErrorDataset.tmHits.value += newStoreHits;
 
+	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+
+	CommandMessage message;
+	ReturnValue_t result = commandQueue->receiveMessage(&message);
+	if(result != MessageQueueIF::EMPTY) {
+	    poolManager.handleHousekeepingMessage(&message);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -53,7 +67,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -62,21 +76,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -85,14 +99,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -103,7 +117,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -112,14 +126,49 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
 	storeHits++;
 	mutex->unlockMutex();
 }
+
+object_id_t InternalErrorReporter::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
+    return this->commandQueue->getId();
+}
+
+ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(errorPoolIds::TM_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
+            new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
+            new PoolEntry<uint32_t>());
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
+}
+
+dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
+    return &internalErrorDataset;
+}
+
+void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
+    this->executingTask = task;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 9aa24a0f..1deb1422 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -1,37 +1,72 @@
-#ifndef INTERNALERRORREPORTER_H_
-#define INTERNALERRORREPORTER_H_
+#ifndef FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
+#define FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
 
 #include "InternalErrorReporterIF.h"
 
+#include "../tasks/PeriodicTaskIF.h"
+#include "../internalError/InternalErrorDataset.h"
+#include "../datapoollocal/LocalDataPoolManager.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../ipc/MutexIF.h"
 
+/**
+ * @brief   This class is used to track internal errors like lost telemetry,
+ *          failed message sending or a full store.
+ * @details
+ * All functions were kept virtual so this class can be extended easily
+ * to store custom internal errors (e.g. communication interface errors).
+ */
 class InternalErrorReporter: public SystemObject,
 		public ExecutableObjectIF,
-		public InternalErrorReporterIF {
+		public InternalErrorReporterIF,
+		public HasLocalDataPoolIF {
 public:
-	InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId,
-			uint32_t tmPoolId, uint32_t storePoolId);
+    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
+
+	InternalErrorReporter(object_id_t setObjectId,
+	        uint32_t messageQueueDepth = 5);
+
+	/**
+	 * Enable diagnostic printout. Please note that this feature will
+	 * only work if DEBUG has been supplied to the build defines.
+	 * @param enable
+	 */
+	void setDiagnosticPrintout(bool enable);
+
 	virtual ~InternalErrorReporter();
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+    virtual object_id_t getObjectId() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();
 
 	virtual void lostTm();
 
 	virtual void storeFull();
+
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 protected:
-	MutexIF* mutex;
+	MessageQueueIF* commandQueue;
+	LocalDataPoolManager poolManager;
 
-	uint32_t queuePoolId;
-	uint32_t tmPoolId;
-	uint32_t storePoolId;
+	PeriodicTaskIF* executingTask = nullptr;
+	MutexIF* mutex = nullptr;
+	InternalErrorDataset internalErrorDataset;
 
-	uint32_t queueHits;
-	uint32_t tmHits;
-	uint32_t storeHits;
+	bool diagnosticPrintout = true;
+
+	uint32_t queueHits = 0;
+	uint32_t tmHits = 0;
+	uint32_t storeHits = 0;
 
 	uint32_t getAndResetQueueHits();
 	uint32_t getQueueHits();
@@ -47,4 +82,4 @@ protected:
 
 };
 
-#endif /* INTERNALERRORREPORTER_H_ */
+#endif /* FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_ */

From c3830da3d0a1f871bfca904b240f7cedfbb2a366 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:24:06 +0200
Subject: [PATCH 0814/1292] bugfixes

---
 internalError/InternalErrorReporter.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index f22fd03a..3f7a0619 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -37,15 +37,15 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
-	        sif::debug << "TM errors: " << newQueueHits << std::endl;
-	        sif::debug << "Store errors: " << newQueueHits << std::endl;
+	        sif::debug << "TM errors: " << newTmHits << std::endl;
+	        sif::debug << "Store errors: " << newStoreHits << std::endl;
 	    }
 	}
 #endif
 
 	internalErrorDataset.queueHits.value += newQueueHits;
-	internalErrorDataset.storeHits.value += newTmHits;
-	internalErrorDataset.tmHits.value += newStoreHits;
+	internalErrorDataset.storeHits.value += newStoreHits;
+	internalErrorDataset.tmHits.value += newTmHits;
 
 	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
 

From 6eaade239579ca814bb3aaded0f858b8f7bf47d7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 17:28:03 +0200
Subject: [PATCH 0815/1292] added new mode for local datapool manager

---
 datapoollocal/LocalDataPoolManager.h    | 2 ++
 internalError/InternalErrorReporter.cpp | 5 +++++
 internalError/InternalErrorReporter.h   | 1 +
 3 files changed, 8 insertions(+)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3b9b6cd9..6fb51b3e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -146,6 +146,8 @@ public:
     enum class ReportingType: uint8_t {
         //! Periodic generation of HK packets.
         PERIODIC,
+        //! Housekeeping packet will be generated if values have changed.
+        UPDATE_HK,
 		//! Update notification will be sent out as message.
 		UPDATE_NOTIFICATION,
         //! Notification will be sent out as message and a snapshot of the
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3f7a0619..767ece51 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -12,6 +12,7 @@ InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
 		commandQueue(QueueFactory::instance()->
 		        createMessageQueue(messageQueueDepth)),
 		poolManager(this, commandQueue),
+		internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
 		internalErrorDataset(this) {
 	mutex = MutexFactory::instance()->createMutex();
 }
@@ -154,6 +155,10 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
             new PoolEntry<uint32_t>());
+    // todo: Only send HK if values have changed, will be supported by
+    // pool manager soon.
+    poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
+            getPeriodicOperationFrequency(), false);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1deb1422..85ac0836 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -60,6 +60,7 @@ protected:
 
 	PeriodicTaskIF* executingTask = nullptr;
 	MutexIF* mutex = nullptr;
+	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
 	bool diagnosticPrintout = true;

From c12110cbf16c71394aa939e67629fc3c11370472 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 26 Sep 2020 22:23:17 +0200
Subject: [PATCH 0816/1292] has file system IF retvals

---
 memory/HasFileSystemIF.h  | 15 ++++++++++++++-
 returnvalues/FwClassIds.h |  6 +++---
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 6065ebfd..916169ee 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -2,12 +2,24 @@
 #define FSFW_MEMORY_HASFILESYSTEMIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include "../returnvalues/FwClassIds.h"
+#include "../ipc/messageQueueDefinitions.h"
+
+#include <cstddef>
 
 /**
  * @author  Jakob Meier
  */
 class HasFileSystemIF {
 public:
+    static constexpr uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM;
+
+    static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
 
 	virtual ~HasFileSystemIF() {}
 	/**
@@ -29,7 +41,8 @@ public:
 	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
 	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
 	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
-	        const uint8_t* data, size_t size) = 0;
+	        const uint8_t* data = nullptr, size_t size = 0,
+	        size_t* bytesWritten = nullptr) = 0;
 	virtual ReturnValue_t deleteFile(const char* dirname,
 	        const char* filename) = 0;
 };
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 781320e3..c8c0a3ad 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -65,9 +65,9 @@ enum {
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
-	PUS_PARSER, //PUSP 62
-	SERIAL_ANALYZER, //SERA 63
-	PUS_SERVICE_9, // PUS9 64
+	SERIAL_ANALYZER, //SERA 62
+	PUS_SERVICE_9, // PUS9 63
+	FILE_SYSTEM, // FLSY 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From 88c4b2a5390a927d1eda33e9ac410ddc757cfc45 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 16:56:42 +0200
Subject: [PATCH 0817/1292] bugfixes for srv3

---
 datapoollocal/LocalDataPoolManager.cpp  | 63 +++++++++++++++----------
 housekeeping/HousekeepingSetPacket.h    |  1 +
 internalError/InternalErrorReporter.cpp |  8 ++++
 internalError/InternalErrorReporter.h   |  1 +
 pus/Service3Housekeeping.cpp            | 21 +++++++--
 pus/Service3Housekeeping.h              |  2 +-
 6 files changed, 64 insertions(+), 32 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4299861e..f07f458e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -15,42 +15,53 @@ object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
         appendValidityBuffer(appendValidityBuffer) {
-	if(owner == nullptr) {
-		sif::error << "HkManager: Invalid supplied owner!" << std::endl;
-		return;
-	}
-	this->owner = owner;
-	mutex = MutexFactory::instance()->createMutex();
-	if(mutex == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not create mutex." << std::endl;
-	}
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if(ipcStore == nullptr) {
-	    sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-	            "Could not set IPC store." << std::endl;
-	}
+    if(owner == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Invalid supplied owner!" << std::endl;
+        return;
+    }
+    this->owner = owner;
+    mutex = MutexFactory::instance()->createMutex();
+    if(mutex == nullptr) {
+        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                << "Could not create mutex." << std::endl;
+    }
 
-	hkQueue = queueToUse;
-
-	if(defaultHkDestination != objects::NO_OBJECT) {
-	    AcceptsHkPacketsIF* hkPacketReceiver =
-	            objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-	    if(hkPacketReceiver != nullptr) {
-	        hkDestinationId = hkPacketReceiver->getHkQueue();
-	    }
-	}
+    hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-        sif::error << "LocalDataPoolManager::initialize: Supplied queue "
-                "invalid!" << std::endl;
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
+                << "queue invalid!" << std::dec << std::endl;
     }
     hkQueue = queueToUse;
 
+    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if(ipcStore == nullptr) {
+        sif::error << "LocalDataPoolManager::initialize: "
+                << std::hex << "0x" << owner->getObjectId() << ": Could not "
+                << "set IPC store." <<std::dec << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+
+    if(defaultHkDestination != objects::NO_OBJECT) {
+        AcceptsHkPacketsIF* hkPacketReceiver =
+                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+        if(hkPacketReceiver != nullptr) {
+            hkDestinationId = hkPacketReceiver->getHkQueue();
+        }
+        else {
+            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
+                   << "Default HK destination object is invalid!" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 007b95be..051e4c61 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -12,6 +12,7 @@ public:
 			objectId(sid.objectId), setId(sid.ownerSetId),
 			reportingEnabled(reportingEnabled), valid(valid),
 			collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) {
+	    setLinks();
 	}
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 767ece51..4cdab9e7 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -177,3 +177,11 @@ LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
 void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
     this->executingTask = task;
 }
+
+ReturnValue_t InternalErrorReporter::initialize() {
+    ReturnValue_t result = poolManager.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return SystemObject::initialize();
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 85ac0836..c715f7a0 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -45,6 +45,7 @@ public:
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
+    virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index ad08c328..c668ec8e 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -181,7 +181,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	switch(command) {
 
 	case(HousekeepingMessage::HK_REPORT): {
-		ReturnValue_t result = generateHkReport(reply,
+		ReturnValue_t result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::HK_REPORT));
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -190,7 +190,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		ReturnValue_t result = generateHkReport(reply,
+		ReturnValue_t result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
@@ -198,6 +198,17 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
 
+    case(HousekeepingMessage::HK_DEFINITIONS_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::HK_DEFINITIONS_REPORT));
+        break;
+    }
+    case(HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
+        return generateHkReply(reply, static_cast<uint8_t>(
+                Subservice::DIAGNOSTICS_REPORT));
+        break;
+    }
+
 	case(HousekeepingMessage::HK_REQUEST_SUCCESS): {
 		return CommandingServiceBase::EXECUTION_COMPLETE;
 	}
@@ -226,13 +237,13 @@ void Service3Housekeeping::handleUnrequestedReply(
 	switch(command) {
 
 	case(HousekeepingMessage::DIAGNOSTICS_REPORT): {
-		result = generateHkReport(reply,
+		result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
 		break;
 	}
 
 	case(HousekeepingMessage::HK_REPORT): {
-		result = generateHkReport(reply,
+		result = generateHkReply(reply,
 				static_cast<uint8_t>(Subservice::HK_REPORT));
 		break;
 	}
@@ -254,7 +265,7 @@ MessageQueueId_t Service3Housekeeping::getHkQueue() const {
 	return commandQueue->getId();
 }
 
-ReturnValue_t Service3Housekeeping::generateHkReport(
+ReturnValue_t Service3Housekeeping::generateHkReply(
 		const CommandMessage* hkMessage, uint8_t subserviceId) {
 	store_address_t storeId;
 
diff --git a/pus/Service3Housekeeping.h b/pus/Service3Housekeeping.h
index 01964bab..269710ef 100644
--- a/pus/Service3Housekeeping.h
+++ b/pus/Service3Housekeeping.h
@@ -82,7 +82,7 @@ private:
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 			MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
 
-	ReturnValue_t generateHkReport(const CommandMessage* hkMessage,
+	ReturnValue_t generateHkReply(const CommandMessage* hkMessage,
 			uint8_t subserviceId);
 	ReturnValue_t prepareReportingTogglingCommand(CommandMessage* command,
 			object_id_t objectId, bool enableReporting, bool isDiagnostics,

From bf574c12e4ea8397062d17a3e047e7de7d223437 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 21:09:56 +0200
Subject: [PATCH 0818/1292] bugfixes, owner ptr not const anymore

---
 datapoollocal/LocalDataPoolManager.cpp |  3 ++-
 datapoollocal/LocalDataPoolManager.h   |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 20 ++++++++++++--
 datapoollocal/LocalPoolDataSetBase.h   |  4 ++-
 datapoollocal/LocalPoolVariable.tpp    | 37 +++++++++++++-------------
 housekeeping/HousekeepingSetPacket.h   |  2 +-
 6 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f07f458e..1a8239ae 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -229,7 +229,7 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
 	return mutex;
 }
 
-const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
+HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
     return owner;
 }
 
@@ -374,6 +374,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
+
 	bool targetIsDiagnostics = dataSet->isDiagnostics();
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6fb51b3e..e55efa9c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -127,7 +127,7 @@ public:
 	 */
 	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
 
-	const HasLocalDataPoolIF* getOwner() const;
+	HasLocalDataPoolIF* getOwner();
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index c280e7c7..da0a86b2 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -119,8 +119,14 @@ ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
+        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+        bool serializeFillCount) const {
+    // Serialize as uint8_t
+    uint8_t fillCount = this->fillCount;
+    if(serializeFillCount) {
+        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+                streamEndianness);
+    }
     for (uint16_t count = 0; count < fillCount; count++) {
         lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
@@ -135,6 +141,16 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
 }
 
 
+uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
+        bool serializeFillCount) const {
+    if(serializeFillCount) {
+        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+    }
+    else {
+        return fillCount * sizeof(lp_id_t);
+    }
+}
+
 size_t LocalPoolDataSetBase::getSerializedSize() const {
     if(withValidityBuffer) {
         uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 83e0425c..4f277123 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -97,7 +97,9 @@ public:
 	        size_t *size, SerializeIF::Endianness streamEndianness);
 	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
 	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
+	        SerializeIF::Endianness streamEndianness,
+	        bool serializeFillCount = true) const;
+	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
 	/**
 	 * Set the dataset valid or invalid
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 09d10acc..b47e602c 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -9,36 +9,37 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId),readWriteMode(setReadWriteMode) {
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
 	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+		        << "which is the NO_PARAMETER value!" << std::endl;
 	}
 	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner is a nullptr!"
-				<< std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+		        << "owner is a invalid!" << std::endl;
 		return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
+	    dataSet->registerVariable(this);
 	}
 }
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: 0 passed as pool ID, which is the "
-				"NO_PARAMETER value!" << std::endl;
-	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not implement"
-				"the correct interface HasHkPoolParametersIF!" << std::endl;
-		return;
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement  the correct interface "
+                << "HasLocalDataPoolIF!" << std::endl;
+        return;
 	}
 	hkManager = hkOwner->getHkManagerHandle();
 	if(dataSet != nullptr) {
diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h
index 051e4c61..f94720d4 100644
--- a/housekeeping/HousekeepingSetPacket.h
+++ b/housekeeping/HousekeepingSetPacket.h
@@ -28,7 +28,7 @@ public:
 
 	size_t getSerializedSize() const override {
 		size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
-		linkedSize += dataSet->getFillCount() * sizeof(lp_id_t);
+		linkedSize += dataSet->getLocalPoolIdsSerializedSize();
 		return linkedSize;
 	}
 

From ad2ca814b2e100c7da2b3371244f28c70baa1e32 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 21:28:03 +0200
Subject: [PATCH 0819/1292] improved doc

---
 datapoollocal/LocalPoolDataSetBase.h | 24 +++++++++++++++++++-----
 datapoollocal/LocalPoolVariable.h    | 13 ++++++-------
 datapoollocal/LocalPoolVariable.tpp  |  6 +++---
 datapoollocal/StaticLocalDataSet.h   | 13 ++++++++-----
 4 files changed, 36 insertions(+), 20 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 4f277123..d00af992 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,7 +1,6 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-
 #include "HasLocalDataPoolIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -16,15 +15,22 @@ class PeriodicHousekeepingHelper;
  * @brief	The LocalDataSet class manages a set of locally checked out
  *          variables for local data pools
  * @details
+ * Extends the PoolDataSetBase class for local data pools by introducing
+ * a validity state, a flag to mark the set as changed, and various other
+ * functions to make it usable by the LocalDataPoolManager class.
+ *
  * 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 local data pools,
- * to ensure thread-safety.
+ * the commit call. The data set manages locking and freeing the local data
+ * pools, to ensure thread-safety.
+ *
+ * Pool variables can be added to the dataset by using the constructor
+ * argument of the pool variable or using the #registerVariable member function.
  *
  * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
+ * registered before any read call is made, and the commit call can only happen
  * after the read call.
  *
  * If pool variables are writable and not committed until destruction
@@ -72,6 +78,7 @@ public:
 
 	sid_t getSid() const;
 
+	/** SerializeIF overrides */
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	            SerializeIF::Endianness streamEndianness) const override;
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
@@ -82,7 +89,7 @@ public:
 	 * Special version of the serilization function which appends a
 	 * validity buffer at the end. Each bit of this validity buffer
 	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first.
+	 * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
 	 * @param buffer
 	 * @param size
 	 * @param maxSize
@@ -142,6 +149,13 @@ protected:
 	 */
 	bool changed = false;
 
+	/**
+	 * Specify whether the validity buffer is serialized too when serializing
+	 * or deserializing the packet. Each bit of the validity buffer will
+	 * contain the validity state of the pool variables from left to right.
+	 * The size of validity buffer thus will be ceil(N / 8) with N = number of
+	 * pool variables.
+	 */
 	bool withValidityBuffer = true;
 
 	/**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 6047342e..ec5c8cd1 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,12 +1,12 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+
+#include "HasLocalDataPoolIF.h"
+#include "LocalDataPoolManager.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
 #include "../objectmanager/ObjectManagerIF.h"
-
 #include "../serialize/SerializeAdapter.h"
 
 /**
@@ -41,7 +41,6 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-
 	 */
 	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			DataSetIF* dataSet = nullptr,
@@ -175,4 +174,4 @@ using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
 
-#endif
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b47e602c..b0bdd7b9 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
 
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
 #endif
 
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index 2f306898..a637e360 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -8,11 +8,14 @@
 /**
  * @brief   This local dataset type is created on the stack.
  * @details
- * Size of data set specified as a constructor argument. It is recommended
- * to use the default LocalDataSet of the dataset is constructed on the heap
- * and the SharedLocalDataSet if it created on the heap and used by multiple
- * other software objects.
- * @tparam capacity
+ * This will is the primary data structure to organize pool variables into
+ * sets which can be accessed via the housekeeping service interface or
+ * which can be sent to other software objects.
+ *
+ * It is recommended to read the documentation of the LocalPoolDataSetBase
+ * class for more information on how this class works and how to use it.
+ * @tparam capacity Capacity of the static dataset, which is usually known
+ * beforehand.
  */
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {

From 786dcdf88d915c701a0266768b06e6158cdd59e9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:13:17 +0200
Subject: [PATCH 0820/1292] removed clock include

---
 datapoollocal/HasLocalDataPoolIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index e078f01e..f8f4ef4c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,7 +4,6 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
-#include "../timemanager/Clock.h"
 
 #include <map>
 
@@ -65,11 +64,11 @@ public:
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 	/**
-	 * Returns the minimum sampling frequency, which will usually be the
-	 * period the pool owner performs its periodic operation-
+	 * Returns the minimum sampling frequency in milliseconds, which will
+	 * usually be the period the pool owner performs its periodic operation.
 	 * @return
 	 */
-	virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
+	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
 	/**
 	 * This function is used by the pool manager to get a valid dataset

From e48dbb87973ccbce0fb5679b7bd0ad726c34161b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:17:18 +0200
Subject: [PATCH 0821/1292] small improvements

---
 datapoollocal/LocalDataPoolManager.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 1a8239ae..d8b57377 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -81,7 +81,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 		return result;
 	}
 	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        "once!" << std::endl;
+	        << "once!" << std::endl;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -117,7 +117,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
 	if(hkReceiverObject == nullptr) {
 		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-				" Invalid receiver!"<< std::endl;
+				<< " Invalid receiver!"<< std::endl;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -218,7 +218,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				" Pool entry not found." << std::endl;
+				<< " Pool entry not found." << std::endl;
 		return POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
@@ -239,7 +239,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 	if(dataSet == nullptr) {
 		// Configuration error.
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found or dataset not assigned!" << std::endl;
+				<< " Set ID not found or dataset not assigned!" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -321,9 +321,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// configuration error
 		sif::debug << "LocalDataPoolManager::performHkOperation:"
-				<< "0x" << std::setfill('0') << std::setw(8)
-		<< owner->getObjectId() << " Error generating "
-		<< "HK packet" << std::setfill(' ') << std::endl;
+				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
+				<< owner->getObjectId() << " Error generating "
+				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
 	}
 }
 
@@ -370,7 +370,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			owner->getDataSetHandle(sid));
 	if(dataSet == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				" Set ID not found" << std::endl;
+				<< " Set ID not found" << std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -396,7 +396,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			expectedSize,&storePtr);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-				"Could not get free element from IPC store." << std::endl;
+				<< "Could not get free element from IPC store." << std::endl;
 		return result;
 	}
 
@@ -406,7 +406,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			SerializeIF::Endianness::BIG);
 	if(expectedSize != size) {
 		sif::error << "HousekeepingManager::generateSetStructurePacket: "
-				"Expected size is not equal to serialized size" << std::endl;
+				<< "Expected size is not equal to serialized size" << std::endl;
 	}
 
 	// Send structure reporting reply.

From 7e9d095ed16264786480e648465efa7d44abe8d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:38:36 +0200
Subject: [PATCH 0822/1292] important bugfixes

---
 datapool/PoolDataSetBase.cpp            |  5 +++++
 datapoollocal/LocalDataPoolManager.h    | 11 +++++++++--
 internalError/InternalErrorReporter.cpp |  7 ++++++-
 internalError/InternalErrorReporter.h   |  1 +
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 1acd3fd3..cb2348f7 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -59,6 +59,11 @@ uint16_t PoolDataSetBase::getFillCount() const {
 
 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() !=
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index e55efa9c..c3b385e8 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -58,6 +58,7 @@ public:
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
     static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -73,14 +74,20 @@ public:
 	virtual~ LocalDataPoolManager();
 
 	/**
-	 * Initializes the map by calling the map initialization function of the
-	 * owner and assigns the queue to use.
+	 * Assigns the queue to use.
 	 * @param queueToUse
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
 	 */
 	ReturnValue_t initialize(MessageQueueIF* queueToUse);
 
+	/**
+	 * Initializes the map by calling the map initialization function and
+	 * setting the periodic factor for non-diagnostic packets.
+	 * Don't forget to call this, otherwise the map will be invalid!
+	 * @param nonDiagInvlFactor
+	 * @return
+	 */
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
 	/**
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 4cdab9e7..943ae8b3 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -158,7 +158,7 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     // todo: Only send HK if values have changed, will be supported by
     // pool manager soon.
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
-            getPeriodicOperationFrequency(), false);
+            getPeriodicOperationFrequency(), true);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -185,3 +185,8 @@ ReturnValue_t InternalErrorReporter::initialize() {
     }
     return SystemObject::initialize();
 }
+
+ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index c715f7a0..8d33c06e 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,6 +46,7 @@ public:
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
     virtual ReturnValue_t initialize() override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
 	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
 	virtual void queueMessageNotSent();

From 1d972fcbef9e935121ad5a168ec1f5f6f2c8619d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:46:18 +0200
Subject: [PATCH 0823/1292] hk messages are cleared properly now

---
 housekeeping/HousekeepingMessage.cpp | 19 +++++++++++++++++++
 housekeeping/HousekeepingMessage.h   |  1 +
 ipc/CommandMessageCleaner.cpp        |  6 +++++-
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 706bd273..7c3e04f7 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/objectmanager/ObjectManagerIF.h>
 #include "HousekeepingMessage.h"
 #include <cstring>
 
@@ -140,3 +141,21 @@ void HousekeepingMessage::setDiagnosticsStuctureReportReply(
     setSid(reply, sid);
     reply->setParameter3(storeId.raw);
 }
+
+void HousekeepingMessage::clear(CommandMessage* message) {
+    switch(message->getCommand()) {
+    case(HK_REPORT):
+    case(DIAGNOSTICS_REPORT):
+    case(HK_DEFINITIONS_REPORT):
+    case(DIAGNOSTICS_DEFINITION_REPORT): {
+        store_address_t storeId;
+        getHkDataReply(message, &storeId);
+        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != nullptr) {
+            ipcStore->deleteData(storeId);
+        }
+    }
+    }
+    message->setCommand(CommandMessage::CMD_NONE);
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index af89dade..f276e263 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -142,6 +142,7 @@ public:
 	static sid_t getCollectionIntervalModificationCommand(
 			const CommandMessage* command, float* newCollectionInterval);
 
+	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
 };
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index 6a99b4d2..fa03a9a3 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -1,4 +1,4 @@
-#include "../ipc/CommandMessageCleaner.h"
+#include "CommandMessageCleaner.h"
 
 #include "../devicehandlers/DeviceHandlerMessage.h"
 #include "../health/HealthMessage.h"
@@ -7,6 +7,7 @@
 #include "../monitoring/MonitoringMessage.h"
 #include "../subsystem/modes/ModeSequenceMessage.h"
 #include "../tmstorage/TmStoreMessage.h"
+#include "../housekeeping/HousekeepingMessage.h"
 #include "../parameters/ParameterMessage.h"
 
 void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
@@ -38,6 +39,9 @@ void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	case messagetypes::PARAMETER:
 		ParameterMessage::clear(message);
 		break;
+	case messagetypes::HOUSEKEEPING:
+	    HousekeepingMessage::clear(message);
+	    break;
 	default:
 		messagetypes::clearMissionMessage(message);
 		break;

From 62ee1391bf195337af99bddb151cd65fcc95504e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:48:10 +0200
Subject: [PATCH 0824/1292] added two new commands

---
 housekeeping/HousekeepingMessage.cpp | 3 ++-
 housekeeping/HousekeepingMessage.h   | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index 7c3e04f7..b07368e6 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -147,7 +147,8 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(HK_REPORT):
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
-    case(DIAGNOSTICS_DEFINITION_REPORT): {
+    case(DIAGNOSTICS_DEFINITION_REPORT):
+    case(UPDATE_SNAPSHOT):{
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index f276e263..041a5eaa 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -101,6 +101,9 @@ public:
 	static constexpr Command_t HK_REQUEST_FAILURE =
 			MAKE_COMMAND_ID(129);
 
+	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+
 	static sid_t getSid(const CommandMessage* message);
 
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,

From 7ff9c29b62cbd3738377bcb6883ac42362db4731 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 22:51:02 +0200
Subject: [PATCH 0825/1292] added another command

---
 housekeeping/HousekeepingMessage.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 041a5eaa..6dc95f54 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -104,8 +104,11 @@ public:
 	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
 	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
 
+	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+
 	static sid_t getSid(const CommandMessage* message);
 
+	/** Setter functions */
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
 	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,

From 1f70b1159d39527d58cbcd2a0e85ca46c2d66695 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 23:21:21 +0200
Subject: [PATCH 0826/1292] another small bugfix

---
 datapoollocal/LocalDataPoolManager.h        | 14 ++++++++------
 housekeeping/HousekeepingMessage.cpp        |  2 +-
 housekeeping/PeriodicHousekeepingHelper.cpp |  2 +-
 internalError/InternalErrorDataset.h        |  9 ++++++---
 internalError/InternalErrorReporter.cpp     |  4 ++--
 5 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c3b385e8..779e3050 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -90,6 +90,14 @@ public:
 	 */
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
+    /**
+     * This should be called in the periodic handler of the owner.
+     * It performs all the periodic functionalities of the data pool manager,
+     * for example generating periodic HK packets.
+     * @return
+     */
+    ReturnValue_t performHkOperation();
+
 	/**
 	 * @return
 	 */
@@ -108,12 +116,6 @@ public:
 	 */
 	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
-	/**
-	 * This should be called in the periodic handler of the owner.
-	 * It performs all the periodic functionalities of the data pool manager.
-	 * @return
-	 */
-	ReturnValue_t performHkOperation();
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index b07368e6..d2ab546b 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -148,7 +148,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT):{
+    case(UPDATE_SNAPSHOT): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index d184489b..37349f81 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -10,7 +10,7 @@ void PeriodicHousekeepingHelper::initialize(float collectionInterval,
 		dur_millis_t minimumPeriodicInterval, bool isDiagnostics,
 		uint8_t nonDiagIntervalFactor) {
 	this->minimumPeriodicInterval = minimumPeriodicInterval;
-	if(isDiagnostics) {
+	if(not isDiagnostics) {
 		this->minimumPeriodicInterval = this->minimumPeriodicInterval *
 				nonDiagIntervalFactor;
 	}
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index c5dc3d73..6bba1171 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,9 +21,12 @@ public:
     InternalErrorDataset(sid_t sid):
            StaticLocalDataSet(sid) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS, sid.objectId, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS, sid.objectId, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS, sid.objectId, this);
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
+            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS,
+            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS,
+            hkManager->getOwner(), this);
 };
 
 
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 943ae8b3..a41d4568 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -50,6 +50,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 
 	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
 
+	poolManager.performHkOperation();
+
 	CommandMessage message;
 	ReturnValue_t result = commandQueue->receiveMessage(&message);
 	if(result != MessageQueueIF::EMPTY) {
@@ -155,8 +157,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::STORE_HITS,
             new PoolEntry<uint32_t>());
-    // todo: Only send HK if values have changed, will be supported by
-    // pool manager soon.
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
             getPeriodicOperationFrequency(), true);
     return HasReturnvaluesIF::RETURN_OK;

From 260fac43f73d638823c4dd1d887e2e8409c9a480 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Sep 2020 23:38:37 +0200
Subject: [PATCH 0827/1292] bugfix

---
 internalError/InternalErrorReporter.cpp | 1 +
 pus/Service3Housekeeping.cpp            | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a41d4568..22e2c38c 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -159,6 +159,7 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
             new PoolEntry<uint32_t>());
     poolManager.subscribeForPeriodicPacket(internalErrorSid, false,
             getPeriodicOperationFrequency(), true);
+    internalErrorDataset.setValidity(true, true);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index c668ec8e..3f41f541 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -205,7 +205,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
     }
     case(HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
         return generateHkReply(reply, static_cast<uint8_t>(
-                Subservice::DIAGNOSTICS_REPORT));
+                Subservice::DIAGNOSTICS_DEFINITION_REPORT));
         break;
     }
 

From 53a62257906df8ca44d3a447dd4434e3d7b889ea Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 12:50:36 +0200
Subject: [PATCH 0828/1292] doc & tweaks

---
 devicehandlers/DeviceHandlerBase.h   | 6 ++++--
 internalError/InternalErrorDataset.h | 4 ++--
 osal/FreeRTOS/PeriodicTask.cpp       | 8 ++++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 8f1b135b..eda318cb 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -106,13 +106,15 @@ public:
 	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
 			uint32_t thermalRequestPoolId);
 	/**
-	 * @brief   Helper function to easy device handler development.
+	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
 	 * (leading to doStartUp() being called for the transition to the ON mode),
 	 * so external mode commanding is not necessary anymore.
 	 *
 	 * This has to be called before the task is started!
-	 * (e.g. in the task factory)
+	 * (e.g. in the task factory). This is only a helper function for
+	 * development. Regular mode commanding should be performed by commanding
+	 * the AssemblyBase or Subsystem objects resposible for the device handler.
 	 */
 	void setStartUpImmediately();
 
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index 6bba1171..52a4b632 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -18,8 +18,8 @@ public:
     InternalErrorDataset(HasLocalDataPoolIF* owner):
             StaticLocalDataSet(owner, ERROR_SET_ID) {}
 
-    InternalErrorDataset(sid_t sid):
-           StaticLocalDataSet(sid) {}
+    InternalErrorDataset(object_id_t objectId):
+           StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
     lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
             hkManager->getOwner(), this);
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 990d38d6..c90587bd 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -133,11 +133,11 @@ TaskHandle_t PeriodicTask::getTaskHandle() {
 }
 
 void PeriodicTask::handleMissedDeadline() {
-#ifdef DEBUG
-    sif::warning << "PeriodicTask: " << pcTaskGetName(NULL) <<
-            " missed deadline!\n" << std::flush;
-#endif
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
+#ifdef DEBUG
+    sif::warning << "PeriodicTask::handleMissedDeadline " << pcTaskGetName(NULL)
+    		<< " missed deadline!\n" << std::flush;
+#endif
 }

From 7b1f72254f866666d251f097b6587fc1c92f67e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:30:30 +0200
Subject: [PATCH 0829/1292] object id names improved

---
 objectmanager/frameworkObjects.h      | 14 +++++++-------
 tmtcservices/VerificationReporter.cpp |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 87439c88..4d08f084 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -4,13 +4,13 @@
 namespace objects {
 enum framework_objects {
 	// Default verification reporter.
-	PUS_SERVICE_1 = 0x53000001,
-	PUS_SERVICE_2 = 0x53000002,
-	PUS_SERVICE_5 = 0x53000005,
-	PUS_SERVICE_8 = 0x53000008,
-	PUS_SERVICE_9 = 0x53000009,
-	PUS_SERVICE_17 = 0x53000017,
-	PUS_SERVICE_200 = 0x53000200,
+	PUS_SERVICE_1_VERIFICATION = 0x53000001,
+	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
+	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
+	PUS_SERVICE_9_TIME_MGMT = 0x53000009,
+	PUS_SERVICE_17_TEST = 0x53000017,
+	PUS_SERVICE_200_MODE_MGMT = 0x53000200,
 
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 0c53e1a4..4255c5ae 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -6,7 +6,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../objectmanager/frameworkObjects.h"
 
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1;
+object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
 
 VerificationReporter::VerificationReporter() :
 		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {

From 3663d7269ca37b8ac2a5af62e1f86557d9766462 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:37:21 +0200
Subject: [PATCH 0830/1292] changes taken over

---
 tmtcservices/VerificationReporter.cpp | 13 +++++++------
 tmtcservices/VerificationReporter.h   |  8 ++++----
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 4255c5ae..7e40bd27 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -1,12 +1,13 @@
-#include "../tmtcservices/VerificationReporter.h"
+#include "VerificationReporter.h"
+#include "AcceptsVerifyMessageIF.h"
+#include "PusVerificationReport.h"
 
 #include "../ipc/MessageQueueIF.h"
-#include "../tmtcservices/AcceptsVerifyMessageIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../objectmanager/frameworkObjects.h"
 
-object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+object_id_t VerificationReporter::messageReceiver =
+		objects::PUS_SERVICE_1_VERIFICATION;
 
 VerificationReporter::VerificationReporter() :
 		acknowledgeQueue(MessageQueueIF::NO_QUEUE) {
@@ -98,8 +99,8 @@ void VerificationReporter::initialize() {
 	if (temp == nullptr) {
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
-				<<"implementsAcceptsVerifyMessageIF" << std::endl;
-
+				<< "implementsAcceptsVerifyMessageIF" << std::endl;
+		return;
 	}
 	this->acknowledgeQueue = temp->getVerificationQueue();
 }
diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h
index 4d92f6b3..f26fa54f 100644
--- a/tmtcservices/VerificationReporter.h
+++ b/tmtcservices/VerificationReporter.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
-#define FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#ifndef FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_
+#define FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_
 
+#include "PusVerificationReport.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmtcservices/PusVerificationReport.h"
 
 namespace Factory{
 void setStaticFrameworkObjectIds();
@@ -47,4 +47,4 @@ private:
 	MessageQueueId_t acknowledgeQueue;
 };
 
-#endif /* FRAMEWORK_TMTCSERVICES_VERIFICATIONREPORTER_H_ */
+#endif /* FSFW_TMTCSERVICES_VERIFICATIONREPORTER_H_ */

From 1691d63169c7bec77954873c476f1fa530f981ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 13:54:08 +0200
Subject: [PATCH 0831/1292] include fix

---
 datapoollocal/LocalDataPoolManager.cpp |  4 +++-
 objectmanager/frameworkObjects.h       |  1 +
 tmtcservices/PusVerificationReport.h   | 12 +++++++-----
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d8b57377..c23f183b 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -6,11 +6,13 @@
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
+#include "../objectmanager/frameworkObjects.h"
 
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+object_id_t LocalDataPoolManager::defaultHkDestination =
+		objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 4d08f084..57783286 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -6,6 +6,7 @@ enum framework_objects {
 	// Default verification reporter.
 	PUS_SERVICE_1_VERIFICATION = 0x53000001,
 	PUS_SERVICE_2_DEVICE_ACCESS = 0x53000002,
+	PUS_SERVICE_3_HOUSEKEEPING = 0x53000003,
 	PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
 	PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
 	PUS_SERVICE_9_TIME_MGMT = 0x53000009,
diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h
index c0a46758..9dce95ac 100644
--- a/tmtcservices/PusVerificationReport.h
+++ b/tmtcservices/PusVerificationReport.h
@@ -1,9 +1,11 @@
-#ifndef PUSVERIFICATIONREPORT_H_
-#define PUSVERIFICATIONREPORT_H_
+#ifndef FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+#define FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_
+
+#include "VerificationCodes.h"
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../tmtcpacket/pus/TcPacketBase.h"
-#include "../tmtcservices/VerificationCodes.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 class PusVerificationMessage: public MessageQueueMessage {
 private:
@@ -30,7 +32,7 @@ private:
 public:
 	static const uint8_t VERIFICATION_MIN_SIZE = 6;
 	PusVerificationMessage();
-//	PusVerificationMessage( uint8_t set_report_id, TcPacketBase* current_packet, ReturnValue_t set_error_code = 0, uint8_t set_step = 0, uint32_t parameter1 = 0, uint32_t parameter2 = 0 );
+
 	PusVerificationMessage(uint8_t set_report_id, uint8_t ackFlags,
 			uint16_t tcPacketId, uint16_t tcSequenceControl,
 			ReturnValue_t set_error_code = 0, uint8_t set_step = 0,
@@ -74,4 +76,4 @@ public:
 	uint8_t* getReport();
 };
 
-#endif /* PUSVERIFICATIONREPORT_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSVERIFICATIONREPORT_H_ */

From 224248dfa1e3ca25eaa4cd94910b8e1293679406 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:27:31 +0200
Subject: [PATCH 0832/1292] removed debug outpuzt for missed deadline

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 9 ---------
 osal/FreeRTOS/PeriodicTask.cpp      | 4 ----
 2 files changed, 13 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 309574eb..062686e2 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -150,15 +150,6 @@ void FixedTimeslotTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
-
-#ifdef DEBUG
-    object_id_t handlerId = pst.current->handlerId;
-    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) << " with"
-            << " object ID 0x" << std::setfill('0') << std::setw(8) << std::hex
-            << handlerId <<  " missed deadline!" << std::setfill(' ')
-            << std::dec << std::endl;
-#endif
-
 }
 
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index c90587bd..5c0a840d 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -136,8 +136,4 @@ void PeriodicTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
     }
-#ifdef DEBUG
-    sif::warning << "PeriodicTask::handleMissedDeadline " << pcTaskGetName(NULL)
-    		<< " missed deadline!\n" << std::flush;
-#endif
 }

From 485e96f12f74dc6dd891aed548b8915872dd540c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:49:57 +0200
Subject: [PATCH 0833/1292] merged changes

---
 storagemanager/ConstStorageAccessor.cpp | 15 ++++++---------
 storagemanager/ConstStorageAccessor.h   |  8 ++++----
 storagemanager/LocalPool.h              | 13 +++++++------
 storagemanager/LocalPool.tpp            | 17 +++++++++--------
 storagemanager/PoolManager.h            | 25 ++++++++++++++++---------
 storagemanager/PoolManager.tpp          | 19 +++++++++++--------
 storagemanager/StorageAccessor.cpp      |  4 ++--
 storagemanager/StorageAccessor.h        |  8 ++++----
 storagemanager/StorageManagerIF.h       | 12 +++++++-----
 9 files changed, 66 insertions(+), 55 deletions(-)

diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 5c143adb..842f1ce8 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -1,6 +1,7 @@
+#include "ConstStorageAccessor.h"
+#include "StorageManagerIF.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/ConstStorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
 #include "../globalfunctions/arrayprinter.h"
 
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
@@ -14,12 +15,7 @@ ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId,
 
 ConstStorageAccessor::~ConstStorageAccessor() {
 	if(deleteData and store != nullptr) {
-		ReturnValue_t result = store->deleteData(storeId);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    // Configuration error.
-		    sif::error << "ConstStorageAccessor::~ConstStorageAccessor: "
-		            << "Could not delete entry!" << std::endl;
-		}
+		store->deleteData(storeId);
 	}
 }
 
@@ -62,7 +58,8 @@ ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-		sif::error << "StorageAccessor: Supplied buffer not large enough" << std::endl;
+		sif::error << "StorageAccessor: Supplied buffer not large enough"
+				<< std::endl;
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(constDataPointer, constDataPointer + size_, pointer);
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 573892da..96d2dca2 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#ifndef FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
+#define FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_
 
-#include "../storagemanager/storeAddress.h"
+#include "storeAddress.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
@@ -113,4 +113,4 @@ protected:
 };
 
 
-#endif /* FRAMEWORK_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
+#endif /* FSFW_STORAGEMANAGER_CONSTSTORAGEACCESSOR_H_ */
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 2a526b6a..3a94c03d 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -1,14 +1,15 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
+#define FSFW_STORAGEMANAGER_LOCALPOOL_H_
 
+#include "StorageManagerIF.h"
 #include "../objectmanager/SystemObject.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../storagemanager/StorageManagerIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../internalError/InternalErrorReporterIF.h"
 #include "../storagemanager/StorageAccessor.h"
 #include <cstring>
 
+
 /**
  * @brief	The LocalPool class provides an intermediate data storage with
  * 			a fixed pool size policy.
@@ -184,6 +185,6 @@ private:
 	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
 };
 
-#include "../storagemanager/LocalPool.tpp"
+#include "LocalPool.tpp"
 
-#endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */
+#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/LocalPool.tpp
index 764bd7be..5e61efe4 100644
--- a/storagemanager/LocalPool.tpp
+++ b/storagemanager/LocalPool.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
-#define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_TPP_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
+#define FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
 
-#ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_
+#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
 #error Include LocalPool.h before LocalPool.tpp!
 #endif
 
@@ -125,9 +125,10 @@ inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
 	}
 }
 
-template<uint8_t NUMBER_OF_POOLS> inline
-ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(store_address_t* storageId,
-		const uint8_t* data, size_t size, bool ignoreFault) {
+template<uint8_t NUMBER_OF_POOLS>
+inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
+		store_address_t* storageId, const uint8_t* data, size_t size,
+		bool ignoreFault) {
 	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
 	if (status == RETURN_OK) {
 		write(*storageId, data, size);
@@ -171,7 +172,7 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
 		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
-	uint8_t* tempData = NULL;
+	uint8_t* tempData = nullptr;
 	ReturnValue_t status = modifyData(packet_id, &tempData, size);
 	*packet_ptr = tempData;
 	return status;
@@ -301,4 +302,4 @@ inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
 	return RETURN_OK;
 }
 
-#endif
+#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_TPP_ */
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 76bddb8f..8cc6c065 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -1,9 +1,10 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
+#define FSFW_STORAGEMANAGER_POOLMANAGER_H_
 
-#include "../storagemanager/LocalPool.h"
+#include "LocalPool.h"
+#include "StorageAccessor.h"
 #include "../ipc/MutexHelper.h"
-#include "../storagemanager/StorageAccessor.h"
+
 
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
@@ -19,18 +20,24 @@ public:
 			const uint16_t element_sizes[NUMBER_OF_POOLS],
 			const uint16_t n_elements[NUMBER_OF_POOLS]);
 
-	//! @brief	In the PoolManager's destructor all allocated memory is freed.
+	/**
+	 * @brief	In the PoolManager's destructor all allocated memory
+	 * 			is freed.
+	 */
 	virtual ~PoolManager();
 
-	//! @brief LocalPool overrides for thread-safety. Decorator function which
-	//! 	   wraps LocalPool calls with a mutex protection.
+	/**
+	 * @brief 	LocalPool overrides for thread-safety. Decorator function
+	 * 			which wraps LocalPool calls with a mutex protection.
+	 */
 	ReturnValue_t deleteData(store_address_t) override;
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
 
+	void setMutexTimeout(uint32_t mutexTimeoutMs);
 protected:
 	//! Default mutex timeout value to prevent permanent blocking.
-	static constexpr uint32_t mutexTimeout = 50;
+	uint32_t mutexTimeoutMs = 20;
 
 	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
 			bool ignoreFault) override;
@@ -46,4 +53,4 @@ protected:
 
 #include "PoolManager.tpp"
 
-#endif /* POOLMANAGER_H_ */
+#endif /* FSFW_STORAGEMANAGER_POOLMANAGER_H_ */
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 0656e967..2be44ece 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 #define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
 
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_H_
+#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
 #error Include PoolManager.h before PoolManager.tpp!
 #endif
 
@@ -21,8 +21,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-			mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -34,8 +33,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-				mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -43,11 +41,16 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
-				mutexTimeout);
+	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;
 }
 
-#endif
+template<uint8_t NUMBER_OF_POOLS>
+inline void PoolManager<NUMBER_OF_POOLS>::setMutexTimeout(
+		uint32_t mutexTimeoutMs) {
+	this->mutexTimeout = mutexTimeoutMs;
+}
+
+#endif /* FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_ */
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 60bd4130..9c2f936a 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -1,5 +1,5 @@
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/StorageManagerIF.h"
+#include "StorageAccessor.h"
+#include "StorageManagerIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 StorageAccessor::StorageAccessor(store_address_t storeId):
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index a65427b8..5cf15d50 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
-#define FRAMEWORK_STORAGEMANAGER_STORAGEACCESSOR_H_
+#ifndef FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_
+#define FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_
 
-#include "../storagemanager/ConstStorageAccessor.h"
+#include "ConstStorageAccessor.h"
 
 class StorageManagerIF;
 
@@ -42,4 +42,4 @@ private:
 	void assignConstPointer();
 };
 
-#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */
+#endif /* FSFW_STORAGEMANAGER_STORAGEACCESSOR_H_ */
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 2229cdf8..834e7563 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -1,10 +1,12 @@
-#ifndef STORAGEMANAGERIF_H_H
-#define STORAGEMANAGERIF_H_H
+#ifndef FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
+#define FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_
+
+#include "StorageAccessor.h"
+#include "storeAddress.h"
 
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../storagemanager/StorageAccessor.h"
-#include "../storagemanager/storeAddress.h"
+
 #include <utility>
 #include <cstddef>
 
@@ -164,4 +166,4 @@ public:
 	virtual void clearStore() = 0;
 };
 
-#endif /* STORAGEMANAGERIF_H_ */
+#endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From fd87a16661290a771e18287bd88ef9df42d60cb2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 14:51:25 +0200
Subject: [PATCH 0834/1292] changes taken over

---
 storagemanager/storeAddress.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 5dd785a3..044c0790 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
-#define FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_
+#ifndef FSFW_STORAGEMANAGER_STOREADDRESS_H_
+#define FSFW_STORAGEMANAGER_STOREADDRESS_H_
+
 #include <cstdint>
 
 /**
@@ -51,4 +52,4 @@ union store_address_t {
 	}
 };
 
-#endif /* FRAMEWORK_STORAGEMANAGER_STOREADDRESS_H_ */
+#endif /* FSFW_STORAGEMANAGER_STOREADDRESS_H_ */

From bc23fd65a678fef98a3a7e701d6e40fdac8cf387 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:13:51 +0200
Subject: [PATCH 0835/1292] master taken over

---
 pus/Service8FunctionManagement.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 3c94071d..2c2e590b 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service8FunctionManagement.h"
-#include "../pus/servicepackets/Service8Packets.h"
+#include "Service8FunctionManagement.h"
+#include "servicepackets/Service8Packets.h"
 
 #include "../objectmanager/SystemObjectIF.h"
 #include "../action/HasActionsIF.h"

From 207d2cab9c6345c02b93f754344e0e34fc446a5f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:15:29 +0200
Subject: [PATCH 0836/1292] service 1 changes taken over

---
 pus/servicepackets/Service1Packets.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index 8c5cb005..dbd31028 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,9 +1,3 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcservices/VerificationCodes.h"
-
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -11,12 +5,18 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
+#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
+#include "../../serialize/SerializeAdapter.h"
+#include "../../tmtcservices/VerificationCodes.h"
+
 /**
  * @brief 	FailureReport class to serialize a failure report
  * @brief 	Subservice 1, 3, 5, 7
  * @ingroup spacepackets
  */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
+class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
 public:
 	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_, uint8_t stepNumber_,
@@ -111,7 +111,7 @@ private:
  * @brief       Subservices 2, 4, 6, 8
  * @ingroup     spacepackets
  */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
+class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
 public:
 	SuccessReport(uint8_t subtype_, uint16_t packetId_,
 			uint16_t packetSequenceControl_,uint8_t stepNumber_) :

From 1ea1c8c02fca9cc46536831280e3160b0c73b3f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:16:20 +0200
Subject: [PATCH 0837/1292] srv9 fix

---
 pus/Service9TimeManagement.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
index 4ad6be6e..4802cdec 100644
--- a/pus/Service9TimeManagement.h
+++ b/pus/Service9TimeManagement.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
 #define FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
 
-#include <fsfw/tmtcservices/PusServiceBase.h>
+#include "../tmtcservices/PusServiceBase.h"
 
 class Service9TimeManagement: public PusServiceBase {
 public:
@@ -34,7 +34,6 @@ private:
 		SET_TIME = 128 //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
 	};
 
-	void setIsisClock(Clock::TimeOfDay_t& timeOfDay);
 };
 
 

From e1eb1a3be17fa8b417859ff5d3231dc32cf1535f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 15:48:42 +0200
Subject: [PATCH 0838/1292] small tweaks

---
 pus/CService201HealthCommanding.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index cc5dd640..7e68533d 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -7,8 +7,8 @@
 
 CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
         uint16_t apid, uint8_t serviceId):
-	CommandingServiceBase(objectId, apid, serviceId,
-			NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+		CommandingServiceBase(objectId, apid, serviceId,
+		NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
 }
 
 CService201HealthCommanding::~CService201HealthCommanding() {
@@ -56,8 +56,8 @@ ReturnValue_t CService201HealthCommanding::prepareCommand
 	if (result != RETURN_OK) {
 		return result;
 	} else {
-		HealthMessage::setHealthMessage(dynamic_cast<CommandMessage*>(message),
-				HealthMessage::HEALTH_SET, healthCommand.getHealth());
+		HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+				healthCommand.getHealth());
 		return result;
 	}
 }
@@ -79,6 +79,6 @@ void CService201HealthCommanding::prepareHealthSetReply(
 	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
 	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
 	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET,&healthSetReply);
+	sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }
 

From d85096d98b951890bf93d373c4a928bea822676f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:03:01 +0200
Subject: [PATCH 0839/1292] service 200 take over

---
 pus/CService200ModeCommanding.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index dda58e03..c63b47a6 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -1,5 +1,5 @@
-#include "../pus/CService200ModeCommanding.h"
-#include "../pus/servicepackets/Service200Packets.h"
+#include "CService200ModeCommanding.h"
+#include "servicepackets/Service200Packets.h"
 
 #include "../modes/HasModesIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -107,13 +107,23 @@ ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
 			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not correct
+		return RETURN_FAILED;
+	}
+	return result;
 }
 
 ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
 		const CommandMessage *reply, object_id_t objectId) {
 	CantReachModePacket cantReachModePacket(objectId,
 	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
+	ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
 	        &cantReachModePacket);
+	if(result == RETURN_OK){
+		// We want to produce an error here in any case because the mode was not reached
+		return RETURN_FAILED;
+	}
+	return result;
 }

From 9013ac240ff9a9ef2f488c1e6bee22ec314b6a37 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:12:01 +0200
Subject: [PATCH 0840/1292] array list taken over

---
 container/ArrayList.h | 200 +++++++++++++++++++++---------------------
 1 file changed, 99 insertions(+), 101 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index ae983171..426e02b3 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_ARRAYLIST_H_
-#define FRAMEWORK_CONTAINER_ARRAYLIST_H_
+#ifndef FSFW_CONTAINER_ARRAYLIST_H_
+#define FSFW_CONTAINER_ARRAYLIST_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeAdapter.h"
@@ -20,11 +20,35 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
 	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-    /**
-     * 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?)
-     */
+	/**
+	 * 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;
 
@@ -33,30 +57,6 @@ public:
 	 */
 	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.
@@ -67,86 +67,84 @@ public:
 		}
 	}
 
-    /**
-     * An Iterator to go trough an ArrayList
-     *
-     * It stores a pointer to an element and increments the
-     * pointer when incremented itself.
-     */
-    class Iterator {
-    public:
-        /**
-         * Empty ctor, points to NULL
-         */
-        Iterator(): value(0) {}
+	/**
+	 * An Iterator to go trough an ArrayList
+	 *
+	 * It stores a pointer to an element and increments the
+	 * pointer when incremented itself.
+	 */
+	class Iterator {
+	public:
+		/**
+		 * Empty ctor, points to NULL
+		 */
+		Iterator(): value(0) {}
 
-        /**
-         * Initializes the Iterator to point to an element
-         *
-         * @param initialize
-         */
-        Iterator(T *initialize) {
-            value = initialize;
-        }
+		/**
+		 * Initializes the Iterator to point to an element
+		 *
+		 * @param initialize
+		 */
+		Iterator(T *initialize) {
+			value = initialize;
+		}
 
-        /**
-         * The current element the iterator points to
-         */
-        T *value;
+		/**
+		 * The current element the iterator points to
+		 */
+		T *value;
 
-        Iterator& operator++() {
-            value++;
-            return *this;
-        }
+		Iterator& operator++() {
+			value++;
+			return *this;
+		}
 
-        Iterator operator++(int) {
-            Iterator tmp(*this);
-            operator++();
-            return tmp;
-        }
+		Iterator operator++(int) {
+			Iterator tmp(*this);
+			operator++();
+			return tmp;
+		}
 
-        Iterator& operator--() {
-            value--;
-            return *this;
-        }
+		Iterator& operator--() {
+			value--;
+			return *this;
+		}
 
-        Iterator operator--(int) {
-            Iterator tmp(*this);
-            operator--();
-            return tmp;
-        }
+		Iterator operator--(int) {
+			Iterator tmp(*this);
+			operator--();
+			return tmp;
+		}
 
-        T& operator*() {
-            return *value;
-        }
+		T& operator*() {
+			return *value;
+		}
 
-        const T& operator*() const {
-            return *value;
-        }
+		const T& operator*() const {
+			return *value;
+		}
 
-        T *operator->() {
-            return value;
-        }
+		T *operator->() {
+			return value;
+		}
 
-        const T *operator->() const {
-            return value;
-        }
+		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 (value == other.value);
+		}
 
-        //SHOULDDO this should be implemented as non-member
-        bool operator!=(const typename ArrayList<T, count_t>::Iterator& other) const {
-        	// POSSIBLY BUGGY ! Also this is really confusing. Why does
-        	// the operator above use the value while this one
-        	// dereferences itself?
-        	//return not (value == other.value);
-        	return !(*this == other);
-        }
-    };
+		//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
@@ -201,7 +199,7 @@ public:
 	 *
 	 * @return maximum number of elements
 	 */
-	uint32_t maxSize() const {
+	size_t maxSize() const {
 		return this->maxSize_;
 	}
 
@@ -245,7 +243,7 @@ protected:
 	/**
 	 * remembering the maximum size
 	 */
-	uint32_t maxSize_;
+	size_t maxSize_;
 
 	/**
 	 * true if the array was allocated and needs to be deleted in the destructor.
@@ -253,4 +251,4 @@ protected:
 	bool allocated;
 };
 
-#endif /* ARRAYLIST_H_ */
+#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

From 4f3cfdcaaf57a790ae7b8cf874c76252f20ceb6d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 16:41:14 +0200
Subject: [PATCH 0841/1292] fixed map and array list implemented as non -
 members

---
 container/ArrayList.h | 34 +++++++++++++++++++++++-----------
 container/FixedMap.h  | 10 ++++++++++
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 426e02b3..16318569 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -133,19 +133,29 @@ public:
 		}
 
 
-		//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);
-		}
+//		//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);
+//		}
 	};
 
+	friend bool operator==(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const ArrayList::Iterator& lhs,
+			const ArrayList::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	/**
 	 * Iterator pointing to the first stored elmement
 	 *
@@ -251,4 +261,6 @@ protected:
 	bool allocated;
 };
 
+
+
 #endif /* FSFW_CONTAINER_ARRAYLIST_H_ */
diff --git a/container/FixedMap.h b/container/FixedMap.h
index e5fbb3be..1e36b1bc 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -61,6 +61,16 @@ public:
 		}
 	};
 
+	friend bool operator==(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return (lhs.value == rhs.value);
+	}
+
+	friend bool operator!=(const typename FixedMap::Iterator& lhs,
+			const typename FixedMap::Iterator& rhs) {
+		return not (lhs.value == rhs.value);
+	}
+
 	Iterator begin() const {
 		return Iterator(&theMap[0]);
 	}

From 3c814a5e6105390bbbee8ae7df825af45fa53df1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 18:01:55 +0200
Subject: [PATCH 0842/1292] include fixes

---
 monitoring/AbsLimitMonitor.h          |  2 +-
 monitoring/LimitMonitor.h             | 13 ++++++-------
 monitoring/LimitViolationReporter.cpp |  6 +++---
 monitoring/MonitorBase.h              | 12 ++++++------
 monitoring/MonitorReporter.h          |  6 +++---
 monitoring/MonitoringIF.h             |  2 +-
 monitoring/MonitoringMessage.cpp      |  2 +-
 monitoring/MonitoringMessageContent.h |  4 ++--
 monitoring/TwoValueLimitMonitor.h     |  2 +-
 9 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index c32c63ef..2e60f6f8 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
 
-#include "../monitoring/MonitorBase.h"
+#include "MonitorBase.h"
 #include <cmath>
 
 template<typename T>
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 4aec8669..66e6725e 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_LIMITMONITOR_H_
 
-#include "../monitoring/MonitorBase.h"
+#include "MonitorBase.h"
 
 /**
  * Variant of a limit checking class.
@@ -16,13 +16,12 @@ public:
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit),
-			lowerLimit(lowerLimit), upperLimit(upperLimit), belowLowEvent(belowLowEvent),
-			aboveHighEvent(aboveHighEvent) {
+			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
+					lowerLimit), upperLimit(upperLimit), belowLowEvent(
+					belowLowEvent), aboveHighEvent(aboveHighEvent) {
+	}
+	virtual ~LimitMonitor() {
 	}
-
-	virtual ~LimitMonitor() {}
-
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) {
 		*crossedLimit = 0.0;
 		if (sample > upperLimit) {
diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp
index 87278f4e..c531a6e6 100644
--- a/monitoring/LimitViolationReporter.cpp
+++ b/monitoring/LimitViolationReporter.cpp
@@ -4,9 +4,9 @@
  * @date	17.07.2014
  * @author	baetz
  */
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/ReceivesMonitoringReportsIF.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "ReceivesMonitoringReportsIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 5173c479..51677fc1 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,12 +1,12 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
-#include "../monitoring/MonitorReporter.h"
+#include "../datapool/DataSet.h"
+#include "../datapool/PIDReader.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "MonitoringMessageContent.h"
+#include "MonitorReporter.h"
 
 /**
  * Base class for monitoring of parameters.
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9823cde0..ca2b534b 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -2,9 +2,9 @@
 #define FRAMEWORK_MONITORING_MONITORREPORTER_H_
 
 #include "../events/EventManagerIF.h"
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringIF.h"
-#include "../monitoring/MonitoringMessageContent.h"
+#include "LimitViolationReporter.h"
+#include "MonitoringIF.h"
+#include "MonitoringMessageContent.h"
 #include "../parameters/HasParametersIF.h"
 
 template<typename T>
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index d9ea339f..44218c36 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -2,7 +2,7 @@
 #define MONITORINGIF_H_
 
 #include "../memory/HasMemoryIF.h"
-#include "../monitoring/MonitoringMessage.h"
+#include "MonitoringMessage.h"
 #include "../serialize/SerializeIF.h"
 
 class MonitoringIF : public SerializeIF {
diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp
index 2cfe1ece..8caa27ae 100644
--- a/monitoring/MonitoringMessage.cpp
+++ b/monitoring/MonitoringMessage.cpp
@@ -1,4 +1,4 @@
-#include "../monitoring/MonitoringMessage.h"
+#include "MonitoringMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 MonitoringMessage::~MonitoringMessage() {
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index ea52962b..c82506f3 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,8 +1,8 @@
 #ifndef MONITORINGMESSAGECONTENT_H_
 #define MONITORINGMESSAGECONTENT_H_
 
-#include "../monitoring/HasMonitorsIF.h"
-#include "../monitoring/MonitoringIF.h"
+#include "HasMonitorsIF.h"
+#include "MonitoringIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h
index 74934828..e690cdae 100644
--- a/monitoring/TwoValueLimitMonitor.h
+++ b/monitoring/TwoValueLimitMonitor.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
 #define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_
 
-#include "../monitoring/LimitMonitor.h"
+#include "LimitMonitor.h"
 
 template<typename T>
 class TwoValueLimitMonitor: public LimitMonitor<T> {

From b59a4c5de62863afd9fa3a45912a4f4e7f862b4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 29 Sep 2020 18:02:41 +0200
Subject: [PATCH 0843/1292] equalization complete

---
 monitoring/MonitorBase.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 51677fc1..964fd55e 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,8 +1,8 @@
 #ifndef MONITORBASE_H_
 #define MONITORBASE_H_
 
-#include "../datapool/DataSet.h"
-#include "../datapool/PIDReader.h"
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"

From d8392de058b1ecde643dabb5903f3534b68acefb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 20:28:33 +0200
Subject: [PATCH 0844/1292] made define more generic

---
 timemanager/CCSDSTime.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 80a4e27c..8878a38a 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -159,7 +159,7 @@ ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
 // Suggestion: use uint16 all the time. This should work on all systems.
-#if FSFW_NEWLIB_NANO_NO_C99_IO == 1
+#if FSFW_NO_C99_IO == 1
 	uint16_t year;
 	uint16_t month;
 	uint16_t day;

From d44428f49c8d99de93632b20307d9ddbe4b77584 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 23:38:54 +0200
Subject: [PATCH 0845/1292] DH IF and DH message improved

---
 devicehandlers/DeviceHandlerIF.h      | 14 +++--
 devicehandlers/DeviceHandlerMessage.h | 75 ++++++++++-----------------
 2 files changed, 37 insertions(+), 52 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index e3fa3b88..b4cf736d 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,8 +1,9 @@
-#ifndef DEVICEHANDLERIF_H_
-#define DEVICEHANDLERIF_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
+
+#include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -14,6 +15,11 @@
  */
 class DeviceHandlerIF {
 public:
+    /**
+     * This is used to uniquely identify commands that are sent to a device
+     * The values are defined in the device-specific implementations
+     */
+    typedef uint32_t DeviceCommandId_t;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
@@ -152,4 +158,4 @@ public:
 
 };
 
-#endif /* DEVICEHANDLERIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 5f4583d2..842dfee8 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -1,69 +1,53 @@
-#ifndef DEVICEHANDLERMESSAGE_H_
-#define DEVICEHANDLERMESSAGE_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_
 
 #include "../action/ActionMessage.h"
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-//SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID.
+// SHOULDDO: rework the static constructors to name the type of command
+// they are building, maybe even hide setting the commandID.
+
 
 /**
- * This is used to uniquely identify commands that are sent to a device
- *
- * The values are defined in the device-specific implementations
- */
-typedef uint32_t DeviceCommandId_t;
-
-/**
- * The DeviceHandlerMessage is used to send Commands to a DeviceHandlerIF
+ * @brief   The DeviceHandlerMessage is used to send commands to classes
+ *          implementing DeviceHandlerIF
  */
 class DeviceHandlerMessage {
-private:
-	DeviceHandlerMessage();
 public:
+    // Instantiation forbidden.
+	DeviceHandlerMessage() = delete;
+	virtual ~DeviceHandlerMessage() {}
 
 	/**
 	 * These are the commands that can be sent to a DeviceHandlerBase
 	 */
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 ); //!< Sends a raw command, setParameter is a ::store_id_t containing the raw packet to send
-//	static const Command_t CMD_DIRECT = MAKE_COMMAND_ID( 2 ); //!< Sends a direct command, setParameter is a ::DeviceCommandId_t, setParameter2 is a ::store_id_t containing the data needed for the command
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 ); //!< Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 ); //!< (De)Activates the monitoring of all raw traffic in DeviceHandlers, setParameter is 0 to deactivate, 1 to activate
+	//! Sends a raw command, setParameter is a storeId containing the
+	//! raw packet to send
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 );
+	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 );
+	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
+	//! setParameter is 0 to deactivate, 1 to activate
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 );
 
-	/*static const Command_t REPLY_SWITCHED_IOBOARD = MAKE_COMMAND_ID(1 );//!< Reply to a @c CMD_SWITCH_IOBOARD, indicates switch was successful, getParameter() contains the board switched to (0: nominal, 1: redundant)
-	 static const Command_t REPLY_CANT_SWITCH_IOBOARD = MAKE_COMMAND_ID( 2);	//!< Reply to a @c CMD_SWITCH_IOBOARD, indicating the switch could not be performed, getParameter() contains the error message
-	 static const Command_t REPLY_WIRETAPPING = MAKE_COMMAND_ID( 3);	//!< Reply to a @c CMD_WIRETAPPING, getParameter() is the current state, 1 enabled, 0 disabled
-
-	 static const Command_t REPLY_COMMAND_WAS_SENT = MAKE_COMMAND_ID(4 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was successfully sent to the device, getParameter() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_NOT_SUPPORTED = MAKE_COMMAND_ID(5 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t is not supported, getParameter() contains the requested ::DeviceCommand_t, getParameter2() contains the ::DeviceCommandId_t
-	 static const Command_t REPLY_COMMAND_WAS_NOT_SENT = MAKE_COMMAND_ID(6 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates the command was not sent, getParameter contains the RMAP Return code (@see rmap.h), getParameter2() contains the ::DeviceCommandId_t
-
-	 static const Command_t REPLY_COMMAND_ALREADY_SENT = MAKE_COMMAND_ID(7 );//!< Reply to a @c CMD_DIRECT, the requested ::DeviceCommand_t has already been sent to the device and not ye been answered
-	 static const Command_t REPLY_WRONG_MODE_FOR_CMD = MAKE_COMMAND_ID(8 );//!< Reply to a @c CMD_RAW or @c CMD_DIRECT, indicates that the requested command can not be sent in the curent mode, getParameter() contains the DeviceHandlerCommand_t
-	 static const Command_t REPLY_NO_DATA = MAKE_COMMAND_ID(9 );	//!< Reply to a CMD_RAW or @c CMD_DIRECT, indicates that the ::store_id_t was invalid, getParameter() contains the ::DeviceCommandId_t, getPrameter2() contains the error code
-	 */
-	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS; //!< Signals that a direct command was sent
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 ); //!< Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12); //!< Contains a raw reply from the Device, getParameter() is the ObjcetId of the sender, getParameter2() is a ::store_id_t containing the raw packet received
+	//! Signals that a direct command was sent
+	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
+	//! Contains a raw command sent to the Device
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 );
+	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
+	//! of the sender, getParameter2() is a ::store_id_t containing the
+	//! raw packet received
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
-	/**
-	 * Default Destructor
-	 */
-	virtual ~DeviceHandlerMessage() {
-	}
-
 	static store_address_t getStoreAddress(const CommandMessage* message);
 	static uint32_t getDeviceCommandId(const CommandMessage* message);
 	static object_id_t getDeviceObjectId(const CommandMessage *message);
 	static object_id_t getIoBoardObjectId(const CommandMessage* message);
 	static uint8_t getWiretappingMode(const CommandMessage* message);
 
-//	static void setDeviceHandlerDirectCommandMessage(CommandMessage* message,
-//			DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-
 	static void setDeviceHandlerDirectCommandReply(CommandMessage* message,
 			object_id_t deviceObjectid,
 			store_address_t commandParametersStoreId);
@@ -75,11 +59,6 @@ public:
 			object_id_t deviceObjectid, store_address_t rawPacketStoreId,
 			bool isCommand);
 
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, DeviceCommandId_t deviceCommand,
-//			store_address_t commandParametersStoreId);
-//	static void setDeviceHandlerMessage(CommandMessage* message,
-//			Command_t command, store_address_t rawPacketStoreId);
 	static void setDeviceHandlerWiretappingMessage(CommandMessage* message,
 			uint8_t wiretappingMode);
 	static void setDeviceHandlerSwitchIoBoardMessage(CommandMessage* message,
@@ -88,4 +67,4 @@ public:
 	static void clear(CommandMessage* message);
 };
 
-#endif /* DEVICEHANDLERMESSAGE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERMESSAGE_H_ */

From aed2d7fc9369e006cc7aa672a1cfeb7fb46e9f25 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Sep 2020 23:42:18 +0200
Subject: [PATCH 0846/1292] slight formatting

---
 devicehandlers/DeviceHandlerIF.h        | 12 +++++++-----
 devicehandlers/DeviceHandlerMessage.cpp | 17 ++---------------
 devicehandlers/DeviceHandlerMessage.h   | 15 +++++++++------
 3 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index b4cf736d..9c8eb098 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -8,6 +8,12 @@
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
+/**
+ * This is used to uniquely identify commands that are sent to a device
+ * The values are defined in the device-specific implementations
+ */
+using DeviceCommandId_t = uint32_t;
+
 /**
  * @brief 	This is the Interface used to communicate with a device handler.
  * @details Includes all expected return values, events and modes.
@@ -15,11 +21,7 @@
  */
 class DeviceHandlerIF {
 public:
-    /**
-     * This is used to uniquely identify commands that are sent to a device
-     * The values are defined in the device-specific implementations
-     */
-    typedef uint32_t DeviceCommandId_t;
+
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp
index b4963dbf..cb9043db 100644
--- a/devicehandlers/DeviceHandlerMessage.cpp
+++ b/devicehandlers/DeviceHandlerMessage.cpp
@@ -1,9 +1,5 @@
+#include "DeviceHandlerMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../devicehandlers/DeviceHandlerMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-DeviceHandlerMessage::DeviceHandlerMessage() {
-}
 
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
@@ -25,14 +21,6 @@ uint8_t DeviceHandlerMessage::getWiretappingMode(
 	return message->getParameter();
 }
 
-//void DeviceHandlerMessage::setDeviceHandlerDirectCommandMessage(
-//		CommandMessage* message, DeviceCommandId_t deviceCommand,
-//		store_address_t commandParametersStoreId) {
-//	message->setCommand(CMD_DIRECT);
-//	message->setParameter(deviceCommand);
-//	message->setParameter2(commandParametersStoreId.raw);
-//}
-
 void DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(
 		CommandMessage* message, store_address_t rawPacketStoreId) {
 	message->setCommand(CMD_RAW);
@@ -79,13 +67,12 @@ void DeviceHandlerMessage::setDeviceHandlerDirectCommandReply(
 void DeviceHandlerMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_RAW:
-//	case CMD_DIRECT:
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
 		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
 				objects::IPC_STORE);
-		if (ipcStore != NULL) {
+		if (ipcStore != nullptr) {
 			ipcStore->deleteData(getStoreAddress(message));
 		}
 	}
diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h
index 842dfee8..e5da01c8 100644
--- a/devicehandlers/DeviceHandlerMessage.h
+++ b/devicehandlers/DeviceHandlerMessage.h
@@ -15,7 +15,10 @@
  */
 class DeviceHandlerMessage {
 public:
-    // Instantiation forbidden.
+    /**
+     * Instantiation forbidden. Instead, use static functions to operate
+     * on messages.
+     */
 	DeviceHandlerMessage() = delete;
 	virtual ~DeviceHandlerMessage() {}
 
@@ -25,21 +28,21 @@ public:
 	static const uint8_t MESSAGE_ID = messagetypes::DEVICE_HANDLER_COMMAND;
 	//! Sends a raw command, setParameter is a storeId containing the
 	//! raw packet to send
-	static const Command_t CMD_RAW = MAKE_COMMAND_ID( 1 );
+	static const Command_t CMD_RAW = MAKE_COMMAND_ID(1);
 	//! Requests a IO-Board switch, setParameter() is the IO-Board identifier
-	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID( 3 );
+	static const Command_t CMD_SWITCH_ADDRESS = MAKE_COMMAND_ID(3);
 	//! (De)Activates the monitoring of all raw traffic in DeviceHandlers,
 	//! setParameter is 0 to deactivate, 1 to activate
-	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID( 4 );
+	static const Command_t CMD_WIRETAPPING = MAKE_COMMAND_ID(4);
 
 	//! Signals that a direct command was sent
 	static const Command_t REPLY_DIRECT_COMMAND_SENT = ActionMessage::STEP_SUCCESS;
 	//! Contains a raw command sent to the Device
-	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11 );
+	static const Command_t REPLY_RAW_COMMAND = MAKE_COMMAND_ID(0x11);
 	//! Contains a raw reply from the Device, getParameter() is the ObjcetId
 	//! of the sender, getParameter2() is a ::store_id_t containing the
 	//! raw packet received
-	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID( 0x12);
+	static const Command_t REPLY_RAW_REPLY = MAKE_COMMAND_ID(0x12);
 	static const Command_t REPLY_DIRECT_COMMAND_DATA = ActionMessage::DATA_REPLY;
 
 	static store_address_t getStoreAddress(const CommandMessage* message);

From 43b44c57b6754c82e3813444568b8fc275469f92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:07:20 +0200
Subject: [PATCH 0847/1292] placement fact update

---
 container/PlacementFactory.h | 42 +++++++++++++++++++++++++++++++++---
 1 file changed, 39 insertions(+), 3 deletions(-)

diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index 05538478..a0aebb7d 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -3,26 +3,62 @@
 
 #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) {
 	}
+
+	/***
+	 * 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 = NULL;
+		uint8_t* pData = nullptr;
 		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
 				&pData);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return NULL;
+			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);

From 32ebca48b864039cd5ee334b6f69ff6010d1d700 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 11:07:46 +0200
Subject: [PATCH 0848/1292] FIFO updates

---
 container/FIFOBase.h   | 30 ++++++++++++++++++++++--------
 container/FIFOBase.tpp |  6 ++++++
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index b744706d..edd66d37 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -19,32 +19,46 @@ public:
 	/**
 	 * Insert value into FIFO
 	 * @param value
-	 * @return
+	 * @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
-	 * @return
+	 * @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
-	 * @return
+	 * @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 RETURN_OK on success, EMPTY if empty
 	 */
 	ReturnValue_t pop();
 
+	/***
+	 * 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:
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index d54b3f8f..763004b6 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -26,6 +26,9 @@ inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
 	if (empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		readIndex = next(readIndex);
 		--currentSize;
@@ -38,6 +41,9 @@ inline ReturnValue_t FIFOBase<T>::peek(T* value) {
 	if(empty()) {
 		return EMPTY;
 	} else {
+		if (value == nullptr){
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
 		*value = values[readIndex];
 		return HasReturnvaluesIF::RETURN_OK;
 	}

From 315777d265a57b50aff944bc795a15a24e64ac72 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 13:21:23 +0200
Subject: [PATCH 0849/1292] tc distribution equalization

---
 tcdistribution/CCSDSDistributor.cpp | 22 ++++---
 tcdistribution/CCSDSDistributor.h   | 14 +++--
 tcdistribution/CCSDSDistributorIF.h | 36 ++++++-----
 tcdistribution/PUSDistributor.cpp   | 94 +++++++++++++++++------------
 tcdistribution/PUSDistributor.h     | 18 +++---
 tcdistribution/PUSDistributorIF.h   | 13 ++--
 tcdistribution/TcDistributor.cpp    | 25 ++++----
 tcdistribution/TcDistributor.h      | 34 ++++++-----
 tcdistribution/TcPacketCheck.cpp    | 24 ++++----
 tcdistribution/TcPacketCheck.h      | 25 ++++----
 10 files changed, 170 insertions(+), 135 deletions(-)

diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index dda26d7f..ddd63308 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -1,5 +1,6 @@
+#include "CCSDSDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributor.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 
 CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
@@ -19,7 +20,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
-				"store failed!" << std::endl;
+				" store failed!" << std::endl;
 	}
 	SpacePacketBase currentPacket(packet);
 
@@ -42,9 +43,9 @@ MessageQueueId_t CCSDSDistributor::getRequestQueue() {
 ReturnValue_t CCSDSDistributor::registerApplication(
 		AcceptsTelecommandsIF* application) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
-	if(  errorCode == false ) {
+	auto insertPair = this->queueMap.emplace(application->getIdentifier(),
+	        application->getRequestQueue());
+	if(not insertPair.second) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -53,9 +54,8 @@ ReturnValue_t CCSDSDistributor::registerApplication(
 ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
 		MessageQueueId_t id) {
 	ReturnValue_t returnValue = RETURN_OK;
-	bool errorCode = true;
-	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
-	if(  errorCode == false ) {
+	auto insertPair = this->queueMap.emplace(apid, id);
+	if(not insertPair.second) {
 		returnValue = RETURN_FAILED;
 	}
 	return returnValue;
@@ -69,7 +69,11 @@ uint16_t CCSDSDistributor::getIdentifier() {
 ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
-	if (this->tcStore == NULL) status = RETURN_FAILED;
+	if (this->tcStore == nullptr) {
+	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
+	            " TC store!" << std::endl;
+	    status = RETURN_FAILED;
+	}
 	return status;
 }
 
diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h
index 6abd952b..e8d54c9c 100644
--- a/tcdistribution/CCSDSDistributor.h
+++ b/tcdistribution/CCSDSDistributor.h
@@ -38,7 +38,7 @@ public:
 			MessageQueueId_t id) override;
 	ReturnValue_t registerApplication(
 			AcceptsTelecommandsIF* application) override;
-	uint16_t getIdentifier();
+	uint16_t getIdentifier() override;
 	ReturnValue_t initialize() override;
 
 protected:
@@ -50,6 +50,12 @@ protected:
 	 * @return Iterator to map entry of found APID or iterator to default APID.
 	 */
 	TcMqMapIter selectDestination() override;
+    /**
+     * The callback here handles the generation of acceptance
+     * success/failure messages.
+     */
+    ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus ) override;
+
 	/**
 	 * The default APID, where packets with unknown APID are sent to.
 	 */
@@ -59,11 +65,7 @@ protected:
 	 * pure Space Packets and there exists no SpacePacketStored class.
 	 */
 	StorageManagerIF* tcStore = nullptr;
-	/**
-	 * The callback here handles the generation of acceptance
-	 * success/failure messages.
-	 */
-	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+
 };
 
 #endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h
index be3c2811..6334a35a 100644
--- a/tcdistribution/CCSDSDistributorIF.h
+++ b/tcdistribution/CCSDSDistributorIF.h
@@ -1,34 +1,38 @@
-#ifndef CCSDSDISTRIBUTORIF_H_
-#define CCSDSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 /**
  * This is the Interface to a CCSDS Distributor.
- * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
- * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
- * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
- * \ingroup tc_distribution
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register
+ * themselves, either by passing a pointer to themselves (and implementing the
+ * CCSDSApplicationIF),  or by explicitly passing an APID and a MessageQueueId
+ * to route the TC's to.
+ * @ingroup tc_distribution
  */
 class CCSDSDistributorIF {
 public:
 	/**
-	 * With this call, a class implementing the CCSDSApplicationIF can register at the
-	 * distributor.
+	 * With this call, a class implementing the CCSDSApplicationIF can register
+	 * at the distributor.
 	 * @param application A pointer to the Application to register.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	virtual ReturnValue_t registerApplication(
+	        AcceptsTelecommandsIF* application) = 0;
 	/**
 	 * With this call, other Applications can register to the CCSDS distributor.
 	 * This is done by passing an APID and a MessageQueueId to the method.
 	 * @param apid	The APID to register.
-	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
-	 * @return	- \c RETURN_OK on success,
-	 * 			- \c RETURN_FAILED on failure.
+	 * @param id	The MessageQueueId of the message queue to send the
+	 *              TC Packets to.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c RETURN_FAILED on failure.
 	 */
-	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	virtual ReturnValue_t registerApplication( uint16_t apid,
+	        MessageQueueId_t id) = 0;
 	/**
 	 * The empty virtual destructor.
 	 */
@@ -37,4 +41,4 @@ public:
 };
 
 
-#endif /* CCSDSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 0c710ef2..3baef7d1 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -1,57 +1,66 @@
+#include "CCSDSDistributorIF.h"
+#include "PUSDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/PUSDistributor.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
 
 PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 		object_id_t setPacketSource) :
 		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
-		currentPacket(), tcStatus(RETURN_FAILED),
-		packetSource(setPacketSource) {}
+		tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
 
 PUSDistributor::~PUSDistributor() {}
 
-TcDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-	TcMqMapIter queueMapIt = this->queueMap.end();
-	this->currentPacket.setStoreAddress(this->currentMessage.getStorageId());
-	if (currentPacket.getWholeData() != NULL) {
-		tcStatus = checker.checkPacket(&currentPacket);
-//		sif::debug << "PUSDistributor::handlePacket: packetCheck returned with "
-//				<< (int)tcStatus << std::endl;
-		uint32_t queue_id = currentPacket.getService();
-		queueMapIt = this->queueMap.find(queue_id);
-	} else {
-		tcStatus = PACKET_LOST;
-	}
-	if (queueMapIt == this->queueMap.end()) {
-		tcStatus = DESTINATION_NOT_FOUND;
-	}
+PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+    // sif:: debug << "PUSDistributor::handlePacket received: "
+    //          << this->current_packet_id.store_index << ", "
+    //          << this->current_packet_id.packet_index << std::endl;
+    TcMqMapIter queueMapIt = this->queueMap.end();
+    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+    if (currentPacket->getWholeData() != NULL) {
+        tcStatus = checker.checkPacket(currentPacket);
+#ifdef DEBUG
+        if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+            sif::debug << "PUSDistributor::handlePacket: Packet format "
+                    << "invalid, code "<< static_cast<int>(tcStatus)
+                    << std::endl;
+        }
+#endif
+        uint32_t queue_id = currentPacket->getService();
+        queueMapIt = this->queueMap.find(queue_id);
+    }
+    else {
+        tcStatus = PACKET_LOST;
+    }
 
-	if (tcStatus != RETURN_OK) {
-		sif::debug << "PUSDistributor::handlePacket: Error with " << tcStatus
-				<< ", 0x"<< std::hex << tcStatus << std::dec << std::endl;
-		return this->queueMap.end();
-	} else {
-		return queueMapIt;
-	}
+    if (queueMapIt == this->queueMap.end()) {
+        tcStatus = DESTINATION_NOT_FOUND;
+#ifdef DEBUG
+        sif::debug << "PUSDistributor::handlePacket: Destination not found, "
+                << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
+    }
+
+    if (tcStatus != RETURN_OK) {
+        return this->queueMap.end();
+    }
+    else {
+        return queueMapIt;
+    }
 
 }
 
-//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
-//	return ( service_id << 8 ) + subservice_id;
-//}
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
-	//info << "Service ID: " << (int)serviceId << std::endl;
+	// sif::info << "Service ID: " << (int)serviceId << std::endl;
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
-		//TODO Return Code
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return SERVICE_ID_ALREADY_EXISTS;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -66,13 +75,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 	}
 	if (tcStatus != RETURN_OK) {
 		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
-				&currentPacket, tcStatus);
-		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
-		currentPacket.deletePacket();
+				currentPacket, tcStatus);
+		// A failed packet is deleted immediately after reporting,
+		// otherwise it will block memory.
+		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
 		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
-				&currentPacket);
+				currentPacket);
 		return RETURN_OK;
 	}
 }
@@ -84,9 +94,15 @@ uint16_t PUSDistributor::getIdentifier() {
 ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
-	if (ccsdsDistributor == NULL) {
-		return RETURN_FAILED;
-	} else {
+	if (ccsdsDistributor == nullptr) {
+		sif::error << "PUSDistributor::initialize: Packet source invalid."
+		        << " Make sure it exists and implements CCSDSDistributorIF!"
+		        << std::endl;
+	    return RETURN_FAILED;
+	}
+	else {
 		return ccsdsDistributor->registerApplication(this);
 	}
+
+	currentPacket = new TcPacketStored();
 }
diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h
index b8cff1f4..be3804ef 100644
--- a/tcdistribution/PUSDistributor.h
+++ b/tcdistribution/PUSDistributor.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
-#define FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "PUSDistributorIF.h"
+#include "TcDistributor.h"
+#include "TcPacketCheck.h"
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tcdistribution/PUSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tcdistribution/TcPacketCheck.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/VerificationReporter.h"
 
@@ -50,7 +51,7 @@ protected:
 	/**
 	 * The currently handled packet is stored here.
 	 */
-	TcPacketStored currentPacket;
+	TcPacketStored* currentPacket = nullptr;
 	/**
 	 * With this variable, the current check status is stored to generate
 	 * acceptance messages later.
@@ -58,6 +59,7 @@ protected:
 	ReturnValue_t tcStatus;
 
 	const object_id_t packetSource;
+
 	/**
 	 * This method reads the packet service, checks if such a service is
 	 * registered and forwards the packet to the destination.
@@ -71,7 +73,7 @@ protected:
 	 * The callback here handles the generation of acceptance
 	 * success/failure messages.
 	 */
-	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus);
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
 };
 
-#endif /* FRAMEWORK_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h
index 5e27b35c..0125c08f 100644
--- a/tcdistribution/PUSDistributorIF.h
+++ b/tcdistribution/PUSDistributorIF.h
@@ -1,11 +1,12 @@
-#ifndef PUSDISTRIBUTORIF_H_
-#define PUSDISTRIBUTORIF_H_
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
 
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 /**
  * This interface allows PUS Services to register themselves at a PUS Distributor.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class PUSDistributorIF {
 public:
@@ -17,10 +18,10 @@ public:
 /**
  * With this method, Services can register themselves at the PUS Distributor.
  * @param service A pointer to the registering Service.
- * @return	- \c RETURN_OK on success,
- * 			- \c RETURN_FAILED on failure.
+ * @return	- @c RETURN_OK on success,
+ * 			- @c RETURN_FAILED on failure.
  */
 	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
 };
 
-#endif /* PUSDISTRIBUTORIF_H_ */
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_ */
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index b0354558..06e1817f 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -1,12 +1,13 @@
+#include "TcDistributor.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tcdistribution/TcDistributor.h"
 #include "../tmtcservices/TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 
-TcDistributor::TcDistributor(object_id_t set_object_id) :
-		SystemObject(set_object_id), tcQueue(NULL) {
-	tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+TcDistributor::TcDistributor(object_id_t objectId) :
+		SystemObject(objectId) {
+	tcQueue = QueueFactory::instance()->
+	        createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }
 
 TcDistributor::~TcDistributor() {
@@ -38,14 +39,14 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
-	sif::debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
-			<< std::endl;
-	for (TcMqMapIter it = this->queueMap.begin(); it != this->queueMap.end();
-			it++) {
-		sif::debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
-				<< std::endl;
+	sif::debug << "Distributor content is: " << std::endl
+	        << "ID\t| Message Queue ID" << std::endl;
+	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
+	for (const auto& queueMapIter: queueMap) {
+		sif::debug << queueMapIter.first << "\t| 0x"   << queueMapIter.second
+		         << std::endl;
 	}
-	sif::debug << std::dec;
+	sif::debug << std::setfill(' ') << std::dec;
 
 }
 
diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h
index 95b7d25b..5d0ca45d 100644
--- a/tcdistribution/TcDistributor.h
+++ b/tcdistribution/TcDistributor.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
-#define FRAMEWORK_TMTCSERVICES_TCDISTRIBUTOR_H_
+#ifndef FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
@@ -34,9 +34,10 @@ public:
 	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
 	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
 
-	static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
-	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
-	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static constexpr ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t SERVICE_ID_ALREADY_EXISTS = MAKE_RETURN_CODE(3);
 	/**
 	 * Within the default constructor, the SystemObject id is set and the
 	 * message queue is initialized.
@@ -44,7 +45,7 @@ public:
 	 * @param set_object_id	This id is assigned to the distributor
 	 * 		implementation.
 	 */
-	TcDistributor( object_id_t set_object_id );
+	TcDistributor(object_id_t objectId);
 	/**
 	 * The destructor is empty, the message queues are not in the vicinity of
 	 * this class.
@@ -69,7 +70,7 @@ protected:
 	 * This is the receiving queue for incoming Telecommands.
 	 * The child classes must make its queue id public.
 	 */
-	MessageQueueIF* tcQueue;
+	MessageQueueIF* tcQueue = nullptr;
 	/**
 	 * The last received incoming packet information is stored in this
 	 * member.
@@ -94,18 +95,19 @@ protected:
 	/**
 	 * The handlePacket method calls the child class's selectDestination method
 	 * and forwards the packet to its destination, if found.
-	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * @return The message queue return value or @c RETURN_FAILED, in case no
 	 * 		destination was found.
 	 */
 	ReturnValue_t handlePacket();
 	/**
-	 * This method gives the child class a chance to perform some kind of operation
-	 * after the parent tried to forward the message.
+	 * This method gives the child class a chance to perform some kind of
+	 * operation after the parent tried to forward the message.
 	 * A typically application would be sending success/failure messages.
-	 * The default implementation just returns \c RETURN_OK.
-	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
-	 * @return	- \c RETURN_OK on success
-	 * 			- \c RETURN_FAILED on failure
+	 * The default implementation just returns @c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt
+	 *                      to send the TC.
+	 * @return	- @c RETURN_OK on success
+	 * 			- @c RETURN_FAILED on failure
 	 */
 	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
 
@@ -113,8 +115,8 @@ private:
 	/**
 	 * This constant sets the maximum number of packets distributed per call.
 	 */
-	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+	static constexpr uint8_t DISTRIBUTER_MAX_PACKETS = 128;
 };
 
 
-#endif /* TCDISTRIBUTOR_H_ */
+#endif /* FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_ */
diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp
index 4701ce23..38ed04aa 100644
--- a/tcdistribution/TcPacketCheck.cpp
+++ b/tcdistribution/TcPacketCheck.cpp
@@ -1,31 +1,33 @@
+#include "TcPacketCheck.h"
+
 #include "../globalfunctions/CRC.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/TcPacketCheck.h"
 #include "../tmtcservices/VerificationCodes.h"
 
-TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+TcPacketCheck::TcPacketCheck( uint16_t setApid ) : apid(setApid) {
 }
 
-ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
-	uint16_t calculated_crc = CRC::crc16ccitt( current_packet->getWholeData(), current_packet->getFullSize() );
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* currentPacket ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( currentPacket->getWholeData(),
+	        currentPacket->getFullSize() );
 	if ( calculated_crc != 0 ) {
 		return INCORRECT_CHECKSUM;
 	}
-	bool condition = !(current_packet->hasSecondaryHeader()) ||
-			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
-			!(current_packet->isTelecommand());
+	bool condition = (not currentPacket->hasSecondaryHeader()) or
+			(currentPacket->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
+			(not currentPacket->isTelecommand());
 	if ( condition ) {
 		return INCORRECT_PRIMARY_HEADER;
 	}
-	if ( current_packet->getAPID() != this->apid )
+	if ( currentPacket->getAPID() != this->apid )
 		return ILLEGAL_APID;
 
-	if ( !current_packet->isSizeCorrect() ) {
+	if ( not currentPacket->isSizeCorrect() ) {
 		return INCOMPLETE_PACKET;
 	}
-	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	condition = (currentPacket->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(currentPacket->getPusVersionNumber() != PUS_VERSION_NUMBER);
 	if ( condition ) {
 		return INCORRECT_SECONDARY_HEADER;
 	}
diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h
index 4ba269f5..703bb1bb 100644
--- a/tcdistribution/TcPacketCheck.h
+++ b/tcdistribution/TcPacketCheck.h
@@ -1,28 +1,29 @@
-#ifndef TCPACKETCHECK_H_
-#define TCPACKETCHECK_H_
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
+
 /**
  * This class performs a formal packet check for incoming PUS Telecommand Packets.
  * Currently, it only checks if the APID and CRC are correct.
- * \ingroup tc_distribution
+ * @ingroup tc_distribution
  */
 class TcPacketCheck : public HasReturnvaluesIF {
 protected:
 	/**
 	 * Describes the version number a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
 	/**
 	 * Describes the secondary header a packet must have to pass.
 	 */
-	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
 	/**
 	 * Describes the TC Packet PUS Version Number a packet must have to pass.
 	 */
-	static const uint8_t PUS_VERSION_NUMBER = 1;
+	static constexpr uint8_t PUS_VERSION_NUMBER = 1;
 	/**
 	 * The packet id each correct packet should have.
 	 * It is composed of the APID and some static fields.
@@ -41,19 +42,19 @@ public:
 	 * The constructor only sets the APID attribute.
 	 * @param set_apid The APID to set.
 	 */
-	TcPacketCheck( uint16_t set_apid );
+	TcPacketCheck( uint16_t setApid );
 	/**
 	 * This is the actual method to formally check a certain Telecommand Packet.
 	 * The packet's Application Data can not be checked here.
 	 * @param current_packet The packt to check
-	 * @return	- \c RETURN_OK on success.
-	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
-	 * 			- \c ILLEGAL_APID if APID does not match.
+	 * @return	- @c RETURN_OK on success.
+	 * 			- @c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- @c ILLEGAL_APID if APID does not match.
 	 */
-	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+	ReturnValue_t checkPacket( TcPacketStored* currentPacket );
 
 	uint16_t getApid() const;
 };
 
 
-#endif /* TCPACKETCHECK_H_ */
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_ */

From 26454356f8958bf077e8756471869dc0bb8e0af8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 13:57:34 +0200
Subject: [PATCH 0850/1292] tpp extraction

---
 container/FixedOrderedMultimap.h   | 56 +++---------------------
 container/FixedOrderedMultimap.tpp | 69 ++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 49 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 99825dc4..cb8ab10f 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -1,9 +1,8 @@
 #ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 #define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
 
-#include "../container/ArrayList.h"
+#include "ArrayList.h"
 #include <cstring>
-#include <set>
 
 /**
  * @brief   Map implementation which allows entries with identical keys
@@ -72,56 +71,15 @@ public:
      */
     ReturnValue_t exists(key_t key) const;
 
-    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(Iterator *iter);
+    ReturnValue_t erase(key_t key);
 
-    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;
-    }
+    Iterator find(key_t key) const;
+    ReturnValue_t find(key_t key, T **value) const;
 
-    Iterator find(key_t key) const {
-        ReturnValue_t result = exists(key);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return end();
-        }
-        return Iterator(&theMap[findFirstIndex(key)]);
-    }
+    void clear();
 
-    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;
-    }
-
-    size_t maxSize() const {
-        return theMap.maxSize();
-    }
+    size_t maxSize() const;
 
 private:
 	typedef KEY_COMPARE compare;
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 5b7b9ead..bc76c594 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -71,4 +71,73 @@ inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(
     return result;
 }
 
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::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;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::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;
+}
+
+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 typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
+FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
+        key_t key) const
+{
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return end();
+    }
+    return Iterator(&theMap[findFirstIndex(key)]);
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
+{
+    _size = 0;
+}
+
+template<typename key_t, typename T, typename KEY_COMPARE>
+inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
+{
+    return theMap.maxSize();
+}
+
+
 #endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

From 0714dc6e06d7bbd30b12775d1f7f39bac189b216 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:31:30 +0200
Subject: [PATCH 0851/1292] taken over container

---
 container/FixedOrderedMultimap.h   | 250 +++++++++++++++++++----------
 container/FixedOrderedMultimap.tpp | 190 +++++++++-------------
 2 files changed, 243 insertions(+), 197 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index cb8ab10f..96bc0073 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -5,120 +5,200 @@
 #include <cstring>
 
 /**
- * @brief   Map implementation which allows entries with identical keys
+ * @brief  An associative container which allows multiple entries of the same key.
  * @details
- * Performs no dynamic memory allocation except on initialization.
- * Uses an ArrayList as the underlying container and thus has a linear
+ * 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 exensive memory move operations (the underlying container
+ * as those incur extensive memory move operations (the underlying container
  * is not node based).
- * @ingroup container
+ *
+ * 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 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]);
+	}
 
 	/**
-	 * Initializes the ordered multimap with a fixed maximum size.
-	 * @param maxSize
+	 * Returns an iterator pointing to one element past the end
+	 * @return Iterator pointing to one element past the end
 	 */
-    FixedOrderedMultimap(size_t maxSize);
+	Iterator end() const {
+		return Iterator(&theMap[_size]);
+	}
 
-    virtual ~FixedOrderedMultimap() {}
+	/***
+	 * Returns the current size of the map (not maximum size!)
+	 * @return Current size
+	 */
+	size_t size() const{
+		return _size;
+	}
 
-    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-    public:
-        /** Returns an iterator to nullptr */
-        Iterator();
-        /** Initializes iterator to given entry */
-        Iterator(std::pair<key_t, T> *pair);
-    };
+	/**
+	 * Clears the map, does not deallocate any memory
+	 */
+	void clear(){
+		_size = 0;
+	}
 
-    /** Iterator to start of map */
-    Iterator begin() const;
-    /** Iterator to end of map */
-    Iterator end() const;
-    /** Current (variable) size of the map */
-    size_t size() const;
+	/**
+	 * Returns the maximum size of the map
+	 * @return Maximum size of the map
+	 */
+	size_t maxSize() const{
+		return theMap.maxSize();
+	}
 
-    /**
-     * Insert a key/value pair inside the map. An iterator to the stored
-     * value might be returned optionally.
-     * @param key
-     * @param value
-     * @param storedValue
-     * @return
-     */
-    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
-    /**
-     * Insert a given std::pair<key, value>
-     * @param pair
-     * @return
-     */
-    ReturnValue_t insert(std::pair<key_t, T> pair);
-    /**
-     * Checks existence of key in map.
-     * @param key
-     * @return
-     * - @c KEY_DOES_NOT_EXIST if key does not exists.
-     * - @c RETURN_OK otherwise.
-     */
-    ReturnValue_t exists(key_t key) const;
+	/***
+	 * 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);
 
-    ReturnValue_t erase(Iterator *iter);
-    ReturnValue_t erase(key_t key);
+	/***
+	 * 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);
 
-    Iterator find(key_t key) const;
-    ReturnValue_t find(key_t key, T **value) const;
+	/***
+	 * 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;
 
-    void clear();
+	/***
+	 * 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);
 
-    size_t maxSize() const;
+	/***
+	 * 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;
+	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;
-	}
+	size_t findNicePlace(key_t key) const;
 
-	void removeFromPosition(uint32_t position) {
-		if (_size <= position) {
-			return;
-		}
-		std::memmove(static_cast<void*>(&theMap[position]),
-		        static_cast<void*>(&theMap[position + 1]),
-				(_size - position - 1) * sizeof(std::pair<key_t,T>));
-		--_size;
-	}
+	void removeFromPosition(size_t position);
 };
 
 #include "FixedOrderedMultimap.tpp"
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index bc76c594..4aa85e97 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -1,142 +1,108 @@
 #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
 
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator():
-        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(){}
 
 template<typename key_t, typename T, typename KEY_COMPARE>
-inline FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator::Iterator(
-        std::pair<key_t, T> *pair):
-        ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair){}
-
+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 typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::begin() const {
-    return Iterator(&theMap[0]);
+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 typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::end() const {
-    return Iterator(&theMap[_size]);
-}
-
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::size() const {
-    return _size;
+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 FixedOrderedMultimap<key_t, T, KEY_COMPARE>::FixedOrderedMultimap(
-        size_t maxSize): theMap(maxSize), _size(0) {}
-
-
-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;
-    }
-    uint32_t position = findNicePlace(key);
-    // Compiler might emitt warning because std::pair is not a POD type (yet..)
-    // See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm#std::pair-example
-    // Circumvent warning by casting to void*
-    std::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;
+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>::insert(
-        std::pair<key_t, T> pair) {
-    return insert(pair.fist, pair.second);
+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>::exists(
-        key_t key) const {
-    ReturnValue_t result = KEY_DOES_NOT_EXIST;
-    if (findFirstIndex(key) < _size) {
-        result = HasReturnvaluesIF::RETURN_OK;
-    }
-    return result;
+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 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::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;
+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 ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::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;
+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 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 typename FixedOrderedMultimap<key_t, T, KEY_COMPARE>::Iterator
-FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(
-        key_t key) const
-{
-    ReturnValue_t result = exists(key);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return end();
-    }
-    return Iterator(&theMap[findFirstIndex(key)]);
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::clear()
-{
-    _size = 0;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::maxSize() const
-{
-    return theMap.maxSize();
+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;
 }
 
 

From 1ecca4b3d882fcbc704f21a0ed9f32c0e2d2524e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:33:50 +0200
Subject: [PATCH 0852/1292] taken over array list

---
 container/ArrayList.h | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 16318569..6bd5c1d5 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -131,19 +131,6 @@ public:
 		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);
-//		}
 	};
 
 	friend bool operator==(const ArrayList::Iterator& lhs,

From 5fbb8f8ef02747e8c95c74f4301b369982a7b2f7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:35:13 +0200
Subject: [PATCH 0853/1292] taken over fixed array list from master

---
 container/FixedArrayList.h | 33 +++++++--------------------------
 1 file changed, 7 insertions(+), 26 deletions(-)

diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index da85c623..e9e127cf 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -1,51 +1,32 @@
 #ifndef FIXEDARRAYLIST_H_
 #define FIXEDARRAYLIST_H_
 
-#include "../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> {
+	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
 	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) {
 	}
 
-	// (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& operator=(FixedArrayList other) {
 		memcpy(this->data, other.data, sizeof(this->data));
 		this->entries = data;
+		this->size = other.size;
 		return *this;
 	}
 

From f2c07ee9c6268f255eca9f8cbb374f393cf1ef72 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:35:56 +0200
Subject: [PATCH 0854/1292] removed tests

---
 container/RingBufferTest.cpp.ignore |  79 ------
 container/listTest.cpp.ignore       | 365 ----------------------------
 2 files changed, 444 deletions(-)
 delete mode 100644 container/RingBufferTest.cpp.ignore
 delete mode 100644 container/listTest.cpp.ignore

diff --git a/container/RingBufferTest.cpp.ignore b/container/RingBufferTest.cpp.ignore
deleted file mode 100644
index d660e29c..00000000
--- a/container/RingBufferTest.cpp.ignore
+++ /dev/null
@@ -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;
-	}
-}
-
-
diff --git a/container/listTest.cpp.ignore b/container/listTest.cpp.ignore
deleted file mode 100644
index 257b733f..00000000
--- a/container/listTest.cpp.ignore
+++ /dev/null
@@ -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;
-}

From 148bbb4be4ef309ac023631782064140fa8d5966 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:36:43 +0200
Subject: [PATCH 0855/1292] master taken over

---
 container/FixedMap.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/container/FixedMap.h b/container/FixedMap.h
index 1e36b1bc..7a5220fa 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -154,22 +154,22 @@ public:
 	}
 
 	bool empty() {
-		if(_size == 0) {
-			return true;
-		}
-		else {
-			return false;
-		}
+	    if(_size == 0) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
 	}
 
-    bool full() {
-        if(_size >= theMap.maxSize()) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
+	bool full() {
+	    if(_size >= theMap.maxSize()) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
 
 	void clear() {
 		_size = 0;

From bf3276cbb2545c1773b1478569703dda9bb402d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:40:02 +0200
Subject: [PATCH 0856/1292] taken over master

---
 container/RingBufferBase.h     | 8 ++++----
 container/SimpleRingBuffer.cpp | 6 +-----
 container/SimpleRingBuffer.h   | 9 +++++----
 container/SinglyLinkedList.h   | 2 +-
 4 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 243a2915..886b9fab 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
-#define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_
+#ifndef FSFW_CONTAINER_RINGBUFFERBASE_H_
+#define FSFW_CONTAINER_RINGBUFFERBASE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
@@ -65,6 +65,7 @@ protected:
 	size_t read[N_READ_PTRS];
 	const size_t size;
 	const bool overwriteOld;
+
 	void incrementWrite(uint32_t amount) {
 		write = ((write + amount - start) % size) + start;
 	}
@@ -90,7 +91,6 @@ protected:
 		}
 	}
 
-
 	size_t getRead(uint8_t n = 0) const {
 		return read[n];
 	}
@@ -110,4 +110,4 @@ protected:
 	}
 };
 
-#endif /* FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ */
+#endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index d6b6f5af..88c9290e 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -1,4 +1,4 @@
-#include "../container/SimpleRingBuffer.h"
+#include "SimpleRingBuffer.h"
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
@@ -25,12 +25,10 @@ SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
 	}
 }
 
-
 SimpleRingBuffer::~SimpleRingBuffer() {
 	delete[] buffer;
 }
 
-
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
         size_t amount) {
     if (availableWriteSpace() >= amount or overwriteOld) {
@@ -131,5 +129,3 @@ ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
 	incrementRead(amount, READ_PTR);
 	return HasReturnvaluesIF::RETURN_OK;
 }
-
-
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index dcf2684b..37ad5679 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
-#define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_
+#ifndef FSFW_CONTAINER_SIMPLERINGBUFFER_H_
+#define FSFW_CONTAINER_SIMPLERINGBUFFER_H_
 
-#include "../container/RingBufferBase.h"
+#include "RingBufferBase.h"
 #include <cstddef>
 
 /**
@@ -117,6 +117,7 @@ public:
 	 */
 	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;
@@ -124,5 +125,5 @@ private:
 	size_t excessBytes = 0;
 };
 
-#endif /* FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ */
+#endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
 
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index 7d5fc4a9..eb6ae276 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -100,7 +100,7 @@ public:
 	 */
 	ElementIterator back() const {
 	    LinkedElement<T> *element = start;
-	    while (element != nullptr) {
+	    while (element->getNext() != nullptr) {
 	        element = element->getNext();
 	    }
 	    return ElementIterator::Iterator(element);

From 0b1b159582b7b3234fdb926f4a1cb4fb875ad69d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:40:45 +0200
Subject: [PATCH 0857/1292] taken over master

---
 action/ActionHelper.cpp       | 2 +-
 action/SimpleActionHelper.cpp | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 70c3f0fc..361f7dc3 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,6 +1,6 @@
-#include <fsfw/ipc/MessageQueueSenderIF.h>
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
+#include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index 51e3fa1c..d79a3c97 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,6 +1,5 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
-
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
 		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(

From f9e6b9facac4e9f8c4c7a261f4bccf04337c1f07 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:42:28 +0200
Subject: [PATCH 0858/1292] taken over master

---
 fdir/ConfirmsFailuresIF.h     | 1 -
 fdir/EventCorrelation.cpp     | 2 +-
 fdir/FailureIsolationBase.cpp | 2 +-
 fdir/FailureIsolationBase.h   | 4 ++--
 fdir/FaultCounter.cpp         | 2 +-
 5 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h
index 6cb2c47d..14411461 100644
--- a/fdir/ConfirmsFailuresIF.h
+++ b/fdir/ConfirmsFailuresIF.h
@@ -4,7 +4,6 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 
-// TODO: Documentation.
 class ConfirmsFailuresIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HANDLES_FAILURES_IF;
diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp
index f98d2223..d60fc6ca 100644
--- a/fdir/EventCorrelation.cpp
+++ b/fdir/EventCorrelation.cpp
@@ -1,4 +1,4 @@
-#include "../fdir/EventCorrelation.h"
+#include "EventCorrelation.h"
 
 EventCorrelation::EventCorrelation(uint32_t timeout) :
 		eventPending(false) {
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index ab462a97..f3b34f0f 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -1,5 +1,5 @@
 #include "../events/EventManagerIF.h"
-#include "../fdir/FailureIsolationBase.h"
+#include "FailureIsolationBase.h"
 #include "../health/HasHealthIF.h"
 #include "../health/HealthMessage.h"
 #include "../ipc/QueueFactory.h"
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index f8a307b3..5b2c099a 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -2,8 +2,8 @@
 #define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_
 
 #include "../events/EventMessage.h"
-#include "../fdir/ConfirmsFailuresIF.h"
-#include "../fdir/FaultCounter.h"
+#include "ConfirmsFailuresIF.h"
+#include "FaultCounter.h"
 #include "../health/HealthMessage.h"
 #include "../parameters/HasParametersIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index b75bd48f..443adb52 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -1,4 +1,4 @@
-#include "../fdir/FaultCounter.h"
+#include "FaultCounter.h"
 
 FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs,
 		uint8_t setParameterDomain) :

From af038d0a2f04c30cd4bfbe6ff3811afdc2740ddc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:44:27 +0200
Subject: [PATCH 0859/1292] master taken over

---
 globalfunctions/AsciiConverter.cpp                | 2 +-
 globalfunctions/CRC.cpp                           | 2 +-
 globalfunctions/DleEncoder.cpp                    | 2 +-
 globalfunctions/DleEncoder.h                      | 8 ++++----
 globalfunctions/arrayprinter.cpp                  | 4 ++--
 globalfunctions/matching/BinaryMatcher.h          | 2 +-
 globalfunctions/matching/DecimalMatcher.h         | 2 +-
 globalfunctions/matching/MatchTree.h              | 2 +-
 globalfunctions/matching/RangeMatcher.h           | 2 +-
 globalfunctions/matching/SerializeableMatcherIF.h | 2 +-
 globalfunctions/math/QuaternionOperations.cpp     | 2 +-
 11 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp
index c57125e2..9eb3698f 100644
--- a/globalfunctions/AsciiConverter.cpp
+++ b/globalfunctions/AsciiConverter.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/AsciiConverter.h"
+#include "AsciiConverter.h"
 #include <limits>
 #include <cmath>
 
diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp
index 1258b698..7bb56806 100644
--- a/globalfunctions/CRC.cpp
+++ b/globalfunctions/CRC.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/CRC.h"
+#include "CRC.h"
 #include <math.h>
 
 const uint16_t CRC::crc16ccitt_table[256] = {
diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp
index 6bd402d7..8520389d 100644
--- a/globalfunctions/DleEncoder.cpp
+++ b/globalfunctions/DleEncoder.cpp
@@ -92,7 +92,7 @@ ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
 			else {
 			    /* The next byte is a STX, DTX or 0x0D character which
 			     * was escaped by a DLE character. The actual byte was
-				 * also encoded by adding + 0x40 to preven having control chars,
+				 * also encoded by adding + 0x40 to prevent having control chars,
 				 * in the stream at all, so we convert it back. */
 				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
 					destStream[decodedIndex] = nextByte - 0x40;
diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h
index 3c535d1f..6d073f9a 100644
--- a/globalfunctions/DleEncoder.h
+++ b/globalfunctions/DleEncoder.h
@@ -15,12 +15,12 @@
  * char based transmission systems.
  * The passed source strean is converted into a encoded stream by adding
  * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurences in the source stream are
+ * the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
  * escaped by a DLE character. The encoder also replaces escaped control chars
  * by another char, so STX, ETX and CR should not appear anywhere in the actual
  * encoded data stream.
  *
- * When using a strictly char based reception of packets enoded with DLE,
+ * When using a strictly char based reception of packets encoded with DLE,
  * STX can be used to notify a reader that actual data will start to arrive
  * while ETX can be used to notify the reader that the data has ended.
  */
@@ -38,7 +38,7 @@ public:
 	static constexpr uint8_t STX_CHAR = 0x02;
 	//! End Of Text character. Last character in encoded stream
 	static constexpr uint8_t ETX_CHAR = 0x03;
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurences
+	//! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
 	//! in the source stream.
 	static constexpr uint8_t DLE_CHAR = 0x10;
 	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
@@ -47,7 +47,7 @@ public:
      * Encodes the give data stream by preceding it with the STX marker
      * and ending it with an ETX marker. STX, ETX and DLE characters inside
      * the stream are escaped by DLE characters and also replaced by adding
-     * 0x40 (which is reverted in the decoing process).
+     * 0x40 (which is reverted in the decoding process).
      * @param sourceStream
      * @param sourceLen
      * @param destStream
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index fa89c0dc..b1e888c5 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/arrayprinter.h"
+#include "arrayprinter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <bitset>
 
@@ -27,7 +27,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 		if(i < size - 1){
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << "\r\n" << std::flush;
+				sif::info << std::endl;
 			}
 		}
 
diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h
index 550439ab..4f6db85d 100644
--- a/globalfunctions/matching/BinaryMatcher.h
+++ b/globalfunctions/matching/BinaryMatcher.h
@@ -1,7 +1,7 @@
 #ifndef BINARYMATCHER_H_
 #define BINARYMATCHER_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 
 template<typename T>
 class BinaryMatcher: public MatcherIF<T> {
diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h
index 3c765cd7..53505020 100644
--- a/globalfunctions/matching/DecimalMatcher.h
+++ b/globalfunctions/matching/DecimalMatcher.h
@@ -1,7 +1,7 @@
 #ifndef DECIMALMATCHER_H_
 #define DECIMALMATCHER_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 
 template<typename T>
 class DecimalMatcher: public MatcherIF<T> {
diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h
index 46245c25..755687b2 100644
--- a/globalfunctions/matching/MatchTree.h
+++ b/globalfunctions/matching/MatchTree.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_
 
 #include "../../container/BinaryTree.h"
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
 
 template<typename T>
diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h
index 04c9c3fa..b64b9e30 100644
--- a/globalfunctions/matching/RangeMatcher.h
+++ b/globalfunctions/matching/RangeMatcher.h
@@ -1,7 +1,7 @@
 #ifndef RANGEMATCHER_H_
 #define RANGEMATCHER_H_
 
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
+#include "SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
 
 template<typename T>
diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h
index f99c6964..067b0251 100644
--- a/globalfunctions/matching/SerializeableMatcherIF.h
+++ b/globalfunctions/matching/SerializeableMatcherIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
 #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_
 
-#include "../../globalfunctions/matching/MatcherIF.h"
+#include "MatcherIF.h"
 #include "../../serialize/SerializeIF.h"
 
 template<typename T>
diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp
index c6778de4..c09426da 100644
--- a/globalfunctions/math/QuaternionOperations.cpp
+++ b/globalfunctions/math/QuaternionOperations.cpp
@@ -1,5 +1,5 @@
 #include "QuaternionOperations.h"
-#include "../../globalfunctions/math/VectorOperations.h"
+#include "VectorOperations.h"
 
 #include <cmath>
 #include <cstring>

From 55a4c0423db264b8a1d16bd7bc8abb527d9a9597 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 1 Oct 2020 20:45:28 +0200
Subject: [PATCH 0860/1292] typo

---
 memory/AcceptsMemoryMessagesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h
index cf8aa5ec..7491f47d 100644
--- a/memory/AcceptsMemoryMessagesIF.h
+++ b/memory/AcceptsMemoryMessagesIF.h
@@ -11,4 +11,4 @@ public:
 };
 
 
-#endif /* AFSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */
+#endif /* FSFW_MEMORY_ACCEPTSMEMORYMESSAGESIF_H_ */

From 0c1c61558ba2d2c831260d4a6be51cc9b90a1ee4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 3 Oct 2020 03:45:29 +0200
Subject: [PATCH 0861/1292] very important bugfix

---
 tcdistribution/PUSDistributor.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 3baef7d1..63d1dcde 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -17,8 +17,11 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
     TcMqMapIter queueMapIt = this->queueMap.end();
+    if(this->currentPacket == nullptr) {
+        return queueMapIt;
+    }
     this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
-    if (currentPacket->getWholeData() != NULL) {
+    if (currentPacket->getWholeData() != nullptr) {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
@@ -94,6 +97,7 @@ uint16_t PUSDistributor::getIdentifier() {
 ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
+	currentPacket = new TcPacketStored();
 	if (ccsdsDistributor == nullptr) {
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
@@ -103,6 +107,4 @@ ReturnValue_t PUSDistributor::initialize() {
 	else {
 		return ccsdsDistributor->registerApplication(this);
 	}
-
-	currentPacket = new TcPacketStored();
 }

From 20c261514b672d3919c036c85702d71fe107723e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 14:31:06 +0200
Subject: [PATCH 0862/1292] made message interface more readable (dec instead
 hex)

---
 memory/FileSystemMessage.cpp | 18 ++++++-----------
 memory/FileSystemMessage.h   | 38 +++++++++++++++++++++---------------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 416f646c..b01e1fc6 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -2,46 +2,40 @@
 #include "../objectmanager/ObjectManagerIF.h"
 
 
-ReturnValue_t FileSystemMessage::setDeleteFileCommand(
+void FileSystemMessage::setDeleteFileCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(DELETE_FILE);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setCreateDirectoryCommand(
+void FileSystemMessage::setCreateDirectoryCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(CREATE_DIRECTORY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setDeleteDirectoryCommand(
+void FileSystemMessage::setDeleteDirectoryCommand(
 		CommandMessage* message, store_address_t storageID) {
 	message->setCommand(DELETE_DIRECTORY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setWriteCommand(CommandMessage* message,
+void FileSystemMessage::setWriteCommand(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(WRITE);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setReadCommand(CommandMessage* message,
+void FileSystemMessage::setReadCommand(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(READ);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemMessage::setReadReply(CommandMessage* message,
+void FileSystemMessage::setReadReply(CommandMessage* message,
 		store_address_t storageID) {
 	message->setCommand(READ_REPLY);
 	message->setParameter2(storageID.raw);
-	return HasReturnvaluesIF::RETURN_OK;
 }
 
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index d3dbd83c..a56abb9c 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -13,26 +13,32 @@ private:
 	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID( 0x01 );
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID( 0x02 );
-	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID( 0x09 );
-	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID( 0x0A );
-	static const Command_t WRITE = MAKE_COMMAND_ID( 0x80 );
-	static const Command_t READ = MAKE_COMMAND_ID( 0x81 );
-	static const Command_t READ_REPLY = MAKE_COMMAND_ID( 0x82 );
+	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
+	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
+	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
+	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
+	static const Command_t WRITE = MAKE_COMMAND_ID(128);
+	static const Command_t READ = MAKE_COMMAND_ID(129);
+	static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
 	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
 	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
 
-	static ReturnValue_t setDeleteFileCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setCreateDirectoryCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setDeleteDirectoryCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setWriteCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setReadCommand(CommandMessage* message, store_address_t storageID);
-	static ReturnValue_t setReadReply(CommandMessage* message, store_address_t storageID);
-	static store_address_t getStoreId( const CommandMessage* message );
-	static void setSuccessReply(CommandMessage* message);
-	static void setFailureReply(CommandMessage* message, ReturnValue_t errorCode);
+	static void setDeleteFileCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setCreateDirectoryCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setDeleteDirectoryCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setWriteCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setReadCommand(CommandMessage* message,
+	        store_address_t storeId);
+	static void setReadReply(CommandMessage* message, store_address_t storeId);
+    static void setSuccessReply(CommandMessage* message);
+    static void setFailureReply(CommandMessage* message,
+            ReturnValue_t errorCode);
 
+	static store_address_t getStoreId(const CommandMessage* message);
 	static ReturnValue_t getFailureReply(const CommandMessage* message);
 };
 

From 2b1029916bab936cd7553d8c93f5300abeefe495 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 15:55:39 +0200
Subject: [PATCH 0863/1292] using deletei nstead

---
 memory/FileSystemMessage.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index a56abb9c..c098d407 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -9,9 +9,10 @@
  * @author  Jakob Meier
  */
 class FileSystemMessage {
-private:
-	FileSystemMessage(); //A private ctor inhibits instantiation
 public:
+    // Instantiation forbidden
+	FileSystemMessage() = delete;
+
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);

From a8a6d448ecc601fc74cefbc7b80736985b8ca06b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 23:24:36 +0200
Subject: [PATCH 0864/1292] added subservices

---
 memory/FileSystemMessage.cpp | 11 ++++++++--
 memory/FileSystemMessage.h   | 41 ++++++++++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index b01e1fc6..b9c426a8 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -22,13 +22,13 @@ void FileSystemMessage::setDeleteDirectoryCommand(
 
 void FileSystemMessage::setWriteCommand(CommandMessage* message,
 		store_address_t storageID) {
-	message->setCommand(WRITE);
+	message->setCommand(APPEND_TO_FILE);
 	message->setParameter2(storageID.raw);
 }
 
 void FileSystemMessage::setReadCommand(CommandMessage* message,
 		store_address_t storageID) {
-	message->setCommand(READ);
+	message->setCommand(READ_FROM_FILE);
 	message->setParameter2(storageID.raw);
 }
 
@@ -38,6 +38,12 @@ void FileSystemMessage::setReadReply(CommandMessage* message,
 	message->setParameter2(storageID.raw);
 }
 
+void FileSystemMessage::setCreateFileCommand(CommandMessage *message,
+        store_address_t storeId) {
+    message->setCommand(CREATE_FILE);
+    message->setParameter2(storeId.raw);
+}
+
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();
@@ -58,3 +64,4 @@ ReturnValue_t FileSystemMessage::getFailureReply(
 		const CommandMessage *message) {
 	return message->getParameter();
 }
+
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
index c098d407..4d77fd16 100644
--- a/memory/FileSystemMessage.h
+++ b/memory/FileSystemMessage.h
@@ -14,16 +14,45 @@ public:
 	FileSystemMessage() = delete;
 
 	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
+	/* PUS standard  (ECSS-E-ST-70-41C15 2016 p.654) */
 	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
 	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
+	/** Report file attributes */
+	static const Command_t REPORT_FILE_ATTRIBUTES = MAKE_COMMAND_ID(3);
+	static const Command_t FILE_ATTRIBUTES_REPLY = MAKE_COMMAND_ID(4);
+	/** Command to lock a file, setting it read-only */
+	static const Command_t LOCK_FILE = MAKE_COMMAND_ID(5);
+	/** Command to unlock a file, enabling further operations on it */
+	static const Command_t UNLOCK_FILE = MAKE_COMMAND_ID(6);
+	/**
+	 * Find file in repository, using a search pattern.
+	 * Please note that * is the wildcard character.
+	 * For example, when looking for all files which start with have the
+	 * structure tm<something>.bin, tm*.bin can be used.
+	 */
+	static const Command_t FIND_FILE = MAKE_COMMAND_ID(7);
 	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
-	static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
-	static const Command_t WRITE = MAKE_COMMAND_ID(128);
-	static const Command_t READ = MAKE_COMMAND_ID(129);
-	static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
+    static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
+	static const Command_t RENAME_DIRECTORY = MAKE_COMMAND_ID(11);
 
+	/** Dump contents of a repository */
+	static const Command_t DUMP_REPOSITORY = MAKE_COMMAND_ID(12);
+	/** Repository dump reply */
+	static const Command_t DUMY_REPOSITORY_REPLY = MAKE_COMMAND_ID(13);
+
+    static const Command_t APPEND_TO_FILE = MAKE_COMMAND_ID(128);
+    static const Command_t READ_FROM_FILE = MAKE_COMMAND_ID(129);
+    static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
+
+    /** Dump the structure of the whole SD card as an ASCII file */
+    static const Command_t DUMP_FILE_STRUCTURE = MAKE_COMMAND_ID(131);
+
+
+	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(150);
+	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(151);
+
+	static void setCreateFileCommand(CommandMessage* message,
+	        store_address_t storeId);
 	static void setDeleteFileCommand(CommandMessage* message,
 	        store_address_t storeId);
 	static void setCreateDirectoryCommand(CommandMessage* message,

From f955cd9eee41ad52eb854f8fb8cca4b040dba181 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 4 Oct 2020 23:37:22 +0200
Subject: [PATCH 0865/1292] made interface more generic

---
 memory/HasFileSystemIF.h | 40 +++++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 916169ee..e270f256 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -29,22 +29,44 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
 	/**
-	 * Function to write to a file
+	 * Generic function to append to file.
 	 * @param dirname Directory of the file
 	 * @param filename The filename of the file
 	 * @param data The data to write to the file
 	 * @param size The size of the data to write
-	 * @param packetNumber Counts the number of packets.
+	 * @param packetNumber Current packet number. Can be used to verify that
+	 * there are no missing packets.
+	 * @param args Any other arguments which an implementation might require.
+	 * @param bytesWritten Actual bytes written to file
 	 * For large files the write procedure must be split in multiple calls
 	 * to writeToFile
 	 */
-	virtual ReturnValue_t writeToFile(const char* dirname, const char* filename,
-	        const uint8_t* data, size_t size, uint16_t packetNumber) = 0;
-	virtual ReturnValue_t createFile(const char* dirname, const char* filename,
-	        const uint8_t* data = nullptr, size_t size = 0,
-	        size_t* bytesWritten = nullptr) = 0;
-	virtual ReturnValue_t deleteFile(const char* dirname,
-	        const char* filename) = 0;
+	virtual ReturnValue_t appendToFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data, size_t size,
+	        uint16_t packetNumber, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to create a new file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param data
+	 * @param size
+	 * @param args Any other arguments which an implementation might require.
+	 * @return
+	 */
+	virtual ReturnValue_t createFile(const char* repositoryPath,
+	        const char* filename, const uint8_t* data = nullptr,
+	        size_t size = 0, void* args = nullptr) = 0;
+
+	/**
+	 * Generic function to delete a file.
+	 * @param repositoryPath
+	 * @param filename
+	 * @param args
+	 * @return
+	 */
+	virtual ReturnValue_t deleteFile(const char* repositoryPath,
+	        const char* filename, void* args = nullptr) = 0;
 };
 
 

From a7fe23c3004d8c933b36d3c5a23f0b8322eaa022 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 00:12:52 +0200
Subject: [PATCH 0866/1292] small stuff

---
 memory/FileSystemMessage.cpp | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index b9c426a8..839268a0 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -1,35 +1,40 @@
 #include "FileSystemMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
+void FileSystemMessage::setCreateFileCommand(CommandMessage* message,
+        store_address_t storeId) {
+    message->setCommand(CREATE_FILE);
+    message->setParameter2(storeId.raw);
+}
 
 void FileSystemMessage::setDeleteFileCommand(
-		CommandMessage* message, store_address_t storageID) {
-	message->setCommand(DELETE_FILE);
-	message->setParameter2(storageID.raw);
+        CommandMessage* message, store_address_t storeId) {
+    message->setCommand(DELETE_FILE);
+    message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setCreateDirectoryCommand(
-		CommandMessage* message, store_address_t storageID) {
+		CommandMessage* message, store_address_t storeId) {
 	message->setCommand(CREATE_DIRECTORY);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setDeleteDirectoryCommand(
-		CommandMessage* message, store_address_t storageID) {
+		CommandMessage* message, store_address_t storeId) {
 	message->setCommand(DELETE_DIRECTORY);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setWriteCommand(CommandMessage* message,
-		store_address_t storageID) {
+		store_address_t storeId) {
 	message->setCommand(APPEND_TO_FILE);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setReadCommand(CommandMessage* message,
-		store_address_t storageID) {
+		store_address_t storeId) {
 	message->setCommand(READ_FROM_FILE);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
 }
 
 void FileSystemMessage::setReadReply(CommandMessage* message,
@@ -38,12 +43,6 @@ void FileSystemMessage::setReadReply(CommandMessage* message,
 	message->setParameter2(storageID.raw);
 }
 
-void FileSystemMessage::setCreateFileCommand(CommandMessage *message,
-        store_address_t storeId) {
-    message->setCommand(CREATE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
 store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
 	store_address_t temp;
 	temp.raw = message->getParameter2();

From 1431116417672389bfef1ea1a77bf832cbbe309e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 12:11:11 +0200
Subject: [PATCH 0867/1292] NULL exception somewhere

---
 memory/FileSystemMessage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
index 839268a0..21f22f5d 100644
--- a/memory/FileSystemMessage.cpp
+++ b/memory/FileSystemMessage.cpp
@@ -55,7 +55,7 @@ void FileSystemMessage::setSuccessReply(CommandMessage *message) {
 
 void FileSystemMessage::setFailureReply(CommandMessage *message,
         ReturnValue_t errorCode) {
-    message->setCommand(COMPLETION_SUCCESS);
+    message->setCommand(COMPLETION_FAILED);
     message->setParameter(errorCode);
 }
 

From c17d50bd1e16031be3861723d68b9269c4623cbf Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 19:46:25 +0200
Subject: [PATCH 0868/1292] file syste mmessage moved to mission code for now

---
 memory/FileSystemMessage.cpp | 66 -------------------------------
 memory/FileSystemMessage.h   | 75 ------------------------------------
 2 files changed, 141 deletions(-)
 delete mode 100644 memory/FileSystemMessage.cpp
 delete mode 100644 memory/FileSystemMessage.h

diff --git a/memory/FileSystemMessage.cpp b/memory/FileSystemMessage.cpp
deleted file mode 100644
index 21f22f5d..00000000
--- a/memory/FileSystemMessage.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "FileSystemMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-void FileSystemMessage::setCreateFileCommand(CommandMessage* message,
-        store_address_t storeId) {
-    message->setCommand(CREATE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setDeleteFileCommand(
-        CommandMessage* message, store_address_t storeId) {
-    message->setCommand(DELETE_FILE);
-    message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setCreateDirectoryCommand(
-		CommandMessage* message, store_address_t storeId) {
-	message->setCommand(CREATE_DIRECTORY);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setDeleteDirectoryCommand(
-		CommandMessage* message, store_address_t storeId) {
-	message->setCommand(DELETE_DIRECTORY);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setWriteCommand(CommandMessage* message,
-		store_address_t storeId) {
-	message->setCommand(APPEND_TO_FILE);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setReadCommand(CommandMessage* message,
-		store_address_t storeId) {
-	message->setCommand(READ_FROM_FILE);
-	message->setParameter2(storeId.raw);
-}
-
-void FileSystemMessage::setReadReply(CommandMessage* message,
-		store_address_t storageID) {
-	message->setCommand(READ_REPLY);
-	message->setParameter2(storageID.raw);
-}
-
-store_address_t FileSystemMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void FileSystemMessage::setSuccessReply(CommandMessage *message) {
-    message->setCommand(COMPLETION_SUCCESS);
-}
-
-void FileSystemMessage::setFailureReply(CommandMessage *message,
-        ReturnValue_t errorCode) {
-    message->setCommand(COMPLETION_FAILED);
-    message->setParameter(errorCode);
-}
-
-ReturnValue_t FileSystemMessage::getFailureReply(
-		const CommandMessage *message) {
-	return message->getParameter();
-}
-
diff --git a/memory/FileSystemMessage.h b/memory/FileSystemMessage.h
deleted file mode 100644
index 4d77fd16..00000000
--- a/memory/FileSystemMessage.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef FSFW_MEMORY_FILESYSTEMMESSAGE_H_
-#define FSFW_MEMORY_FILESYSTEMMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../objectmanager/SystemObject.h"
-
-/**
- * @author  Jakob Meier
- */
-class FileSystemMessage {
-public:
-    // Instantiation forbidden
-	FileSystemMessage() = delete;
-
-	static const uint8_t MESSAGE_ID = messagetypes::FILE_SYSTEM_MESSAGE;
-	/* PUS standard  (ECSS-E-ST-70-41C15 2016 p.654) */
-	static const Command_t CREATE_FILE = MAKE_COMMAND_ID(1);
-	static const Command_t DELETE_FILE = MAKE_COMMAND_ID(2);
-	/** Report file attributes */
-	static const Command_t REPORT_FILE_ATTRIBUTES = MAKE_COMMAND_ID(3);
-	static const Command_t FILE_ATTRIBUTES_REPLY = MAKE_COMMAND_ID(4);
-	/** Command to lock a file, setting it read-only */
-	static const Command_t LOCK_FILE = MAKE_COMMAND_ID(5);
-	/** Command to unlock a file, enabling further operations on it */
-	static const Command_t UNLOCK_FILE = MAKE_COMMAND_ID(6);
-	/**
-	 * Find file in repository, using a search pattern.
-	 * Please note that * is the wildcard character.
-	 * For example, when looking for all files which start with have the
-	 * structure tm<something>.bin, tm*.bin can be used.
-	 */
-	static const Command_t FIND_FILE = MAKE_COMMAND_ID(7);
-	static const Command_t CREATE_DIRECTORY = MAKE_COMMAND_ID(9);
-    static const Command_t DELETE_DIRECTORY = MAKE_COMMAND_ID(10);
-	static const Command_t RENAME_DIRECTORY = MAKE_COMMAND_ID(11);
-
-	/** Dump contents of a repository */
-	static const Command_t DUMP_REPOSITORY = MAKE_COMMAND_ID(12);
-	/** Repository dump reply */
-	static const Command_t DUMY_REPOSITORY_REPLY = MAKE_COMMAND_ID(13);
-
-    static const Command_t APPEND_TO_FILE = MAKE_COMMAND_ID(128);
-    static const Command_t READ_FROM_FILE = MAKE_COMMAND_ID(129);
-    static const Command_t READ_REPLY = MAKE_COMMAND_ID(130);
-
-    /** Dump the structure of the whole SD card as an ASCII file */
-    static const Command_t DUMP_FILE_STRUCTURE = MAKE_COMMAND_ID(131);
-
-
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(150);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(151);
-
-	static void setCreateFileCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setDeleteFileCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setCreateDirectoryCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setDeleteDirectoryCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setWriteCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setReadCommand(CommandMessage* message,
-	        store_address_t storeId);
-	static void setReadReply(CommandMessage* message, store_address_t storeId);
-    static void setSuccessReply(CommandMessage* message);
-    static void setFailureReply(CommandMessage* message,
-            ReturnValue_t errorCode);
-
-	static store_address_t getStoreId(const CommandMessage* message);
-	static ReturnValue_t getFailureReply(const CommandMessage* message);
-};
-
-#endif /* FSFW_MEMORY_FILESYSTEMMESSAGE_H_ */

From 8c43c6993eca053fdf8dc633ea049ceed6564a43 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 5 Oct 2020 22:47:32 +0200
Subject: [PATCH 0869/1292] CSB fifo depth configurable

---
 pus/Service1TelecommandVerification.cpp | 5 ++---
 pus/Service1TelecommandVerification.h   | 3 ++-
 returnvalues/FwClassIds.h               | 4 ++--
 tmtcservices/CommandingServiceBase.h    | 4 +++-
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 9b17eba5..6d081fe2 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -8,13 +8,12 @@
 #include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-
 Service1TelecommandVerification::Service1TelecommandVerification(
         object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
+        object_id_t targetDestination, uint16_t messageQueueDepth):
         SystemObject(objectId), apid(apid), serviceId(serviceId),
         targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
+	tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service1TelecommandVerification::~Service1TelecommandVerification() {}
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 37562d1c..6fff0332 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -44,7 +44,8 @@ public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
 
 	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
+	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination,
+			uint16_t messageQueueDepth);
 	virtual ~Service1TelecommandVerification();
 
 	/**
diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index c8c0a3ad..120d1e2e 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -66,8 +66,8 @@ enum {
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
 	SERIAL_ANALYZER, //SERA 62
-	PUS_SERVICE_9, // PUS9 63
-	FILE_SYSTEM, // FLSY 64
+	PUS_SERVICE_9, //PUS9 63
+	FILE_SYSTEM, //FLSY 64
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 252b6943..9f1d4c4f 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -13,6 +13,8 @@
 #include "../container/FIFO.h"
 #include "../serialize/SerializeIF.h"
 
+#include <FSFWConfig.h>
+
 class TcPacketStored;
 
 namespace Factory{
@@ -40,7 +42,7 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 

From 6a077c583dd2063ad9b71d9298967c78e59d967b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 14:00:18 +0200
Subject: [PATCH 0870/1292] action helper some formatting stuff

---
 action/ActionHelper.h | 74 +++++++++++++++++++++++++++----------------
 1 file changed, 47 insertions(+), 27 deletions(-)

diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index bbc6d114..0334543c 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -1,15 +1,18 @@
-#ifndef ACTIONHELPER_H_
-#define ACTIONHELPER_H_
+#ifndef FSFW_ACTION_ACTIONHELPER_H_
+#define FSFW_ACTION_ACTIONHELPER_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;
 
@@ -18,7 +21,8 @@ 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.
+	 * @param useThisQueue  messageQueue to be used, can be set during
+	 *                      initialize function as well.
 	 */
 	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
 
@@ -26,28 +30,35 @@ public:
 	/**
 	 * 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.
+	 * 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
+	 * @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
+	 * 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.
+	 * 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);
+	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
 	 *
@@ -55,39 +66,48 @@ public:
 	 * @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);
+	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 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);
+	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.
+	 * 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
+	//!< Increase of value of this per step
+	static const uint8_t STEP_OFFSET = 1;
 	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)
+	//! 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;
+
 	/**
-	 *Internal function called by handleActionMessage(CommandMessage* command)
-	 *
+	 * 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);
+	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_ */

From df1a730cdff36835424057e64f89f3817fda24bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 16:01:35 +0200
Subject: [PATCH 0871/1292] some form stuff

---
 action/ActionHelper.cpp            | 15 +++++++++------
 action/ActionHelper.h              |  2 +-
 pus/Service8FunctionManagement.cpp |  4 ++--
 tmtcservices/TmTcMessage.cpp       |  8 ++++----
 tmtcservices/TmTcMessage.h         | 16 ++++++++--------
 5 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 361f7dc3..ab986c6c 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -3,8 +3,9 @@
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) {
+ActionHelper::ActionHelper(HasActionsIF* setOwner,
+        MessageQueueIF* useThisQueue) :
+		owner(setOwner), queueToUse(useThisQueue) {
 }
 
 ActionHelper::~ActionHelper() {
@@ -33,13 +34,15 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo, ActionId_t commandId, ReturnValue_t result) {
+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) {
+void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
+        ReturnValue_t result) {
 	CommandMessage reply;
 	ActionMessage::setCompletionReply(&reply, commandId, result);
 	queueToUse->sendMessage(reportTo, &reply);
@@ -49,8 +52,8 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
 	queueToUse = queue;
 }
 
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-		store_address_t dataAddress) {
+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);
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 0334543c..a20f286a 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -94,7 +94,7 @@ protected:
 	//! setQueueToUse
 	MessageQueueIF* queueToUse;
 	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore;
+	StorageManagerIF* ipcStore = nullptr;
 
 	/**
 	 * Internal function called by handleActionMessage
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index 2c2e590b..c1c88a50 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -7,10 +7,10 @@
 #include "../serialize/SerializeAdapter.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
+Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
 		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
+		CommandingServiceBase(objectId, apid, serviceId, numParallelCommands,
 		commandTimeoutSeconds) {}
 
 Service8FunctionManagement::~Service8FunctionManagement() {}
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index a715225b..f81eba62 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -15,15 +15,15 @@ store_address_t TmTcMessage::getStorageId() {
 	return temp_id;
 }
 
-TmTcMessage::TmTcMessage(store_address_t store_id) {
+TmTcMessage::TmTcMessage(store_address_t storeId) {
 	this->messageSize += sizeof(store_address_t);
-	this->setStorageId(store_id);
+	this->setStorageId(storeId);
 }
 
 size_t TmTcMessage::getMinimumMessageSize() {
 	return this->HEADER_SIZE + sizeof(store_address_t);
 }
 
-void TmTcMessage::setStorageId(store_address_t store_id) {
-	memcpy(this->getData(), &store_id, sizeof(store_address_t) );
+void TmTcMessage::setStorageId(store_address_t storeId) {
+	memcpy(this->getData(), &storeId, sizeof(store_address_t) );
 }
diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h
index b5e1ff8d..41fe198a 100644
--- a/tmtcservices/TmTcMessage.h
+++ b/tmtcservices/TmTcMessage.h
@@ -1,5 +1,5 @@
-#ifndef TMTCMESSAGE_H_
-#define TMTCMESSAGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCMESSAGE_H_
+#define FSFW_TMTCSERVICES_TMTCMESSAGE_H_
 
 #include "../ipc/MessageQueueMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
@@ -10,13 +10,13 @@
  * 			a packet stored in one of the IPC stores (typically a special TM and
  * 			a special TC store). This makes passing commands very simple and
  * 			efficient.
- *	\ingroup message_queue
+ * @ingroup message_queue
  */
 class TmTcMessage : public MessageQueueMessage {
 protected:
 	/**
 	 * @brief	This call always returns the same fixed size of the message.
-	 * @return	Returns HEADER_SIZE + \c sizeof(store_address_t).
+	 * @return	Returns HEADER_SIZE + @c sizeof(store_address_t).
 	 */
 	size_t getMinimumMessageSize();
 public:
@@ -29,7 +29,7 @@ public:
 	 * 			into the message.
 	 * @param packet_id	The packet id to put into the message.
 	 */
-	TmTcMessage( store_address_t packet_id );
+	TmTcMessage( store_address_t packetId );
 	/**
 	 * @brief	The class's destructor is empty.
 	 */
@@ -42,9 +42,9 @@ public:
 	/**
 	 * @brief	In some cases it might be useful to have a setter for packet id
 	 * 			as well.
-	 * @param packet_id	The packet id to put into the message.
+	 * @param packetId	The packet id to put into the message.
 	 */
-	void setStorageId( store_address_t packet_id );
+	void setStorageId( store_address_t packetId );
 };
 
-#endif /* TMTCMESSAGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCMESSAGE_H_ */

From 9fb38e9b7c168e514706b3b757e70b2d1b163c3f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 6 Oct 2020 19:58:29 +0200
Subject: [PATCH 0872/1292] better error output

---
 osal/FreeRTOS/MessageQueue.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 2dfe5ab6..fdadf8b7 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -11,7 +11,12 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
 	if (handle == nullptr) {
-		sif::error << "MessageQueue::MessageQueue Creation failed" << std::endl;
+		sif::error << "MessageQueue::MessageQueue:"
+		        << " Creation failed." << std::endl;
+		sif::error << "Specified Message Depth: " << messageDepth
+		        << std::endl;
+		sif::error << "Specified Maximum Message Size: "
+		        << maxMessageSize << std::endl;
 	}
 }
 

From 6e9db0d67533b8b3fa25def2b185691749c2b6f6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 7 Oct 2020 18:43:56 +0200
Subject: [PATCH 0873/1292] retval added

---
 memory/HasFileSystemIF.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index e270f256..7ab4cc4e 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -21,6 +21,8 @@ public:
     static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
     static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
 
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING = MAKE_RETURN_CODE(0x05);
+
 	virtual ~HasFileSystemIF() {}
 	/**
 	 * Function to get the MessageQueueId_t of the implementing object

From 2364c4f9a4d1aa551557e0d2a4b616652da8d2db Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 7 Oct 2020 20:47:46 +0200
Subject: [PATCH 0874/1292] form improvements

---
 tmtcpacket/pus/TmPacketStored.cpp |  7 +++--
 tmtcpacket/pus/TmPacketStored.h   | 47 +++++++++++++++++++------------
 2 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 17b49f43..4cf76589 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -1,8 +1,9 @@
+#include "TmPacketStored.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketStored.h"
 #include "../../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include <cstring>
 
 TmPacketStored::TmPacketStored(store_address_t setAddress) :
 		TmPacketBase(NULL), storeAddress(setAddress) {
@@ -11,7 +12,7 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+		size_t size, const uint8_t *headerData, size_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	if (!checkAndSetStore()) {
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 98e37ed5..81a6f6e5 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,9 +1,9 @@
-#ifndef TMPACKETSTORED_H_
-#define TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_TMPACKETSTORED_H_
 
+#include "TmPacketBase.h"
 #include "../../serialize/SerializeIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueSenderIF.h"
 
@@ -21,7 +21,7 @@ class TmPacketStored : public TmPacketBase {
 private:
 	/**
 	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
+	 * If the store is not yet set (i.e. @c store is NULL), every constructor
 	 * call tries to set it and throws an error message in case of failures.
 	 * The default store is objects::TM_STORE.
 	 */
@@ -37,8 +37,8 @@ private:
 	 * A helper method to check if a store is assigned to the class.
 	 * If not, the method tries to retrieve the store from the global
 	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
+	 * @return	@li	@c true if the store is linked or could be created.
+	 * 			@li @c false otherwise.
 	 */
 	bool checkAndSetStore();
 
@@ -52,8 +52,9 @@ public:
 	/**
 	 * With this constructor, new space is allocated in the packet store and
 	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet. The Application data is
-	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet Application Data passed in data is copied into the packet.
+	 * The Application data is passed in two parts, first a header, then a
+	 * data field. This allows building a Telemetry
 	 * Packet from two separate data sources.
 	 * @param apid			Sets the packet's APID field.
 	 * @param service		Sets the packet's Service ID field.
@@ -61,20 +62,29 @@ public:
 	 * @param subservice	Sets the packet's Service Subtype field.
 	 * 		This specifies the source sub-service.
 	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param data			The payload data to be copied to the Application
+	 * 						Data Field
 	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerData 	The header Data of the Application field; will be
+	 * 						copied in front of data
 	 * @param headerSize	The size of the headerDataF
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+			size_t size = 0, const uint8_t* headerData = nullptr,
+			size_t headerSize = 0);
 	/**
-	 * Another ctor to directly pass structured content and header data to the packet to avoid additional buffers.
+	 * Another ctor to directly pass structured content and header data to the
+	 * packet to avoid additional buffers.
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter, SerializeIF* content,
+			SerializeIF* header = nullptr);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
+	 * @return
+	 * The current store address. The (raw) value is
+	 * @c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
 	/**
@@ -87,10 +97,11 @@ public:
 	 * if the packet is a class member and used for more than one packet.
 	 * @param setAddress	The new packet id to link to.
 	 */
-	void setStoreAddress( store_address_t setAddress );
+	void setStoreAddress(store_address_t setAddress);
 
-	ReturnValue_t sendPacket( MessageQueueId_t destination, MessageQueueId_t sentFrom, bool doErrorReporting = true );
+	ReturnValue_t sendPacket(MessageQueueId_t destination,
+			MessageQueueId_t sentFrom, bool doErrorReporting = true);
 };
 
 
-#endif /* TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_TMPACKETSTORED_H_ */

From e338b4662d8682f391cdf950ed4a47e80eaf37da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 9 Oct 2020 02:49:18 +0200
Subject: [PATCH 0875/1292] fix for c++11 comformity

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c23f183b..4f124e7f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -389,7 +389,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
 	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid,
+	HousekeepingSetPacket setPacket(sid,
 			reportingEnabled, valid, collectionInterval, dataSet);
 	size_t expectedSize = setPacket.getSerializedSize();
 	uint8_t* storePtr = nullptr;

From 94884c2402e3c5077bfe5b88c3255cd554a4ad5b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:11:11 +0200
Subject: [PATCH 0876/1292] service 1 small improvements

---
 pus/Service1TelecommandVerification.cpp | 5 ++---
 pus/Service1TelecommandVerification.h   | 8 ++++----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 6d081fe2..86b0dcde 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -1,12 +1,11 @@
-#include "../pus/Service1TelecommandVerification.h"
-#include "../pus/servicepackets/Service1Packets.h"
+#include "Service1TelecommandVerification.h"
+#include "servicepackets/Service1Packets.h"
 
 #include "../ipc/QueueFactory.h"
 #include "../tmtcservices/PusVerificationReport.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
 
 Service1TelecommandVerification::Service1TelecommandVerification(
         object_id_t objectId, uint16_t apid, uint8_t serviceId,
diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h
index 6fff0332..3d68a4e0 100644
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#ifndef FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
+#define FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
 
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -52,7 +52,7 @@ public:
 	 *
 	 * @return ID of Verification Queue
 	 */
-	virtual MessageQueueId_t getVerificationQueue();
+	virtual MessageQueueId_t getVerificationQueue() override;
 
 	/**
 	 * Performs the service periodically as specified in init_mission().
@@ -92,4 +92,4 @@ private:
 	};
 };
 
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
+#endif /* FSFW_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */

From 3aa666633e4d561847e2cf12972c2fb916d41ee8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:14:52 +0200
Subject: [PATCH 0877/1292] include guard replacements

---
 pus/CService200ModeCommanding.h        | 6 +++---
 pus/Service2DeviceAccess.cpp           | 4 ++--
 pus/Service2DeviceAccess.h             | 6 +++---
 pus/Service5EventReporting.cpp         | 4 ++--
 pus/Service5EventReporting.h           | 6 +++---
 pus/Service8FunctionManagement.h       | 6 +++---
 pus/servicepackets/Service1Packets.h   | 6 +++---
 pus/servicepackets/Service200Packets.h | 6 +++---
 pus/servicepackets/Service2Packets.h   | 6 +++---
 pus/servicepackets/Service5Packets.h   | 6 +++---
 pus/servicepackets/Service8Packets.h   | 6 +++---
 11 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index 89347dbd..c86d7b84 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
+#ifndef FSFW_PUS_CSERVICE200MODECOMMANDING_H_
+#define FSFW_PUS_CSERVICE200MODECOMMANDING_H_
 
 #include "../tmtcservices/CommandingServiceBase.h"
 
@@ -82,4 +82,4 @@ private:
 	};
 };
 
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
+#endif /* FSFW_PUS_CSERVICE200MODECOMMANDING_H_ */
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 8780b22c..878a13b0 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service2DeviceAccess.h"
-#include "../pus/servicepackets/Service2Packets.h"
+#include "Service2DeviceAccess.h"
+#include "servicepackets/Service2Packets.h"
 
 #include "../devicehandlers/DeviceHandlerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index f6aa8b52..fa2ea75c 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
+#ifndef FSFW_PUS_SERVICE2DEVICEACCESS_H_
+#define FSFW_PUS_SERVICE2DEVICEACCESS_H_
 
 #include "../objectmanager/SystemObjectIF.h"
 #include "../devicehandlers/AcceptsDeviceResponsesIF.h"
@@ -89,4 +89,4 @@ private:
 };
 
 
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
+#endif /* FSFW_PUS_DEVICE2DEVICECOMMANDING_H_ */
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 02031df4..829d04bd 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -1,5 +1,5 @@
-#include "../pus/Service5EventReporting.h"
-#include "../pus/servicepackets/Service5Packets.h"
+#include "Service5EventReporting.h"
+#include "servicepackets/Service5Packets.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../events/EventManagerIF.h"
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 0b6ee9a8..78c18bf3 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
+#ifndef FSFW_PUS_SERVICE5EVENTREPORTING_H_
+#define FSFW_PUS_SERVICE5EVENTREPORTING_H_
 
 #include "../tmtcservices/PusServiceBase.h"
 #include "../events/EventMessage.h"
@@ -83,4 +83,4 @@ private:
 	ReturnValue_t generateEventReport(EventMessage message);
 };
 
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
+#endif /* FSFW_PUS_SERVICE5EVENTREPORTING_H_ */
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index b5ebcda8..292a5e36 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#ifndef FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
+#define FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
 #include "../action/ActionMessage.h"
 #include "../tmtcservices/CommandingServiceBase.h"
@@ -64,4 +64,4 @@ private:
 	        object_id_t objectId, ActionId_t actionId);
 };
 
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
+#endif /* FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index dbd31028..ecb62693 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -1,3 +1,6 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
+
 /**
  * @defgroup spacepackets PUS Packet Definitions
  *  This group contains all implemented TM or TM packages that are sent to
@@ -5,9 +8,6 @@
  *  packet structures in Mission Information Base (MIB).
  */
 
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
 
diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h
index efcf65fc..cb9ad4a7 100644
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
 
 #include "../../serialize/SerialLinkedListAdapter.h"
 #include "../../modes/ModeMessage.h"
@@ -60,4 +60,4 @@ public:
 	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h
index d4f3fb17..285a8f9f 100644
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -73,4 +73,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h
index 9655608a..f903d6a2 100644
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
 
 #include "../../serialize/SerializeAdapter.h"
 #include "../../tmtcservices/VerificationCodes.h"
@@ -73,4 +73,4 @@ private:
 };
 
 
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h
index 14f8b6e6..b026edf5 100644
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
@@ -118,4 +118,4 @@ private:
 
 };
 
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */

From 837a18135e2d643f52213ff1c1995af3d1cd9f2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:41:51 +0200
Subject: [PATCH 0878/1292] subsystem folder update

---
 subsystem/Subsystem.cpp                 | 28 +++++++++++++------------
 subsystem/Subsystem.h                   | 24 +++++++++++----------
 subsystem/SubsystemBase.cpp             | 18 +++++++---------
 subsystem/SubsystemBase.h               | 23 ++++++++++----------
 subsystem/modes/HasModeSequenceIF.h     |  6 +++---
 subsystem/modes/ModeDefinitions.h       | 21 ++++++++-----------
 subsystem/modes/ModeSequenceMessage.cpp | 25 ++++++----------------
 subsystem/modes/ModeSequenceMessage.h   |  9 ++++----
 subsystem/modes/ModeStore.cpp           |  2 ++
 9 files changed, 73 insertions(+), 83 deletions(-)

diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index ba1f463c..9712d7d4 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -12,13 +12,10 @@ Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent,
 		uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables) :
 		SubsystemBase(setObjectId, parent, 0), isInTransition(false),
 		childrenChangedHealth(false), currentTargetTable(),
-		targetMode(0), targetSubmode(SUBMODE_NONE), initialMode(0),
-		currentSequenceIterator(), modeTables(maxNumberOfTables),
-		modeSequences(maxNumberOfSequences) {}
+		targetSubmode(SUBMODE_NONE), currentSequenceIterator(),
+		modeTables(maxNumberOfTables), modeSequences(maxNumberOfSequences) {}
 
-Subsystem::~Subsystem() {
-	//Auto-generated destructor stub
-}
+Subsystem::~Subsystem() {}
 
 ReturnValue_t Subsystem::checkSequence(HybridIterator<ModeListEntry> iter,
 		Mode_t fallbackSequence) {
@@ -344,7 +341,8 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
+	//Before initialize() is called, tables must not be checked as the
+	//children are not added yet.
 	//Sequences added before are checked by initialize()
 	if (!preInit) {
 		result = checkSequence(
@@ -390,8 +388,8 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 
 	ReturnValue_t result;
 
-	//Before initialize() is called, tables must not be checked as the children are not added yet.
-	//Tables added before are checked by initialize()
+	//Before initialize() is called, tables must not be checked as the children
+	//are not added yet. Tables added before are checked by initialize()
 	if (!preInit) {
 		result = checkTable(
 				HybridIterator<ModeListEntry>(table->front(), table->back()));
@@ -582,12 +580,14 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
 	triggerEvent(MODE_TRANSITION_FAILED, failureCode, parameter);
 	if (mode == targetMode) {
 		//already tried going back to the current mode
-		//go into fallback mode, also set current mode to fallback mode, so we come here at the next fail
+		//go into fallback mode, also set current mode to fallback mode,
+	    //so we come here at the next fail
 		modeHelper.setForced(true);
 		ReturnValue_t result;
 		if ((result = checkSequence(getFallbackSequence(mode))) != RETURN_OK) {
 			triggerEvent(FALLBACK_FAILED, result, getFallbackSequence(mode));
-			isInTransition = false; //keep still and allow arbitrary mode commands to recover
+			//keep still and allow arbitrary mode commands to recover
+			isInTransition = false;
 			return;
 		}
 		mode = getFallbackSequence(mode);
@@ -651,8 +651,10 @@ void Subsystem::cantKeepMode() {
 
 	modeHelper.setForced(true);
 
-	//already set the mode, so that we do not try to go back in our old mode when the transition fails
+	//already set the mode, so that we do not try to go back in our old mode
+	//when the transition fails
 	mode = getFallbackSequence(mode);
-	//SHOULDDO: We should store submodes for fallback sequence as well, otherwise we should get rid of submodes completely.
+	//SHOULDDO: We should store submodes for fallback sequence as well,
+	//otherwise we should get rid of submodes completely.
 	startTransition(mode, SUBMODE_NONE);
 }
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 2b501574..9a3fcdfe 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -1,13 +1,14 @@
-#ifndef SUBSYSTEM_H_
-#define SUBSYSTEM_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEM_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEM_H_
+
+#include "SubsystemBase.h"
+#include "modes/ModeDefinitions.h"
 
 #include "../container/FixedArrayList.h"
 #include "../container/FixedMap.h"
 #include "../container/HybridIterator.h"
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
-#include "../subsystem/modes/ModeDefinitions.h"
-#include "../subsystem/SubsystemBase.h"
 
 class Subsystem: public SubsystemBase, public HasModeSequenceIF {
 public:
@@ -44,11 +45,11 @@ public:
 
 	void setInitialMode(Mode_t mode);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t checkObjectConnections();
+	virtual ReturnValue_t checkObjectConnections() override;
 
-	virtual MessageQueueId_t getSequenceCommandQueue() const;
+	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
 	/**
 	 *
@@ -96,11 +97,11 @@ protected:
 
 	HybridIterator<ModeListEntry> currentTargetTable;
 
-	Mode_t targetMode;
+	Mode_t targetMode = 0;
 
 	Submode_t targetSubmode;
 
-	Mode_t initialMode;
+	Mode_t initialMode = 0;
 
 	HybridIterator<ModeListEntry> currentSequenceIterator;
 
@@ -153,7 +154,8 @@ protected:
 
 	virtual void startTransition(Mode_t mode, Submode_t submode);
 
-	void sendSerializablesAsCommandMessage(Command_t command, SerializeIF **elements, uint8_t count);
+	void sendSerializablesAsCommandMessage(Command_t command,
+	        SerializeIF **elements, uint8_t count);
 
 	void transitionFailed(ReturnValue_t failureCode, uint32_t parameter);
 
@@ -161,4 +163,4 @@ protected:
 
 };
 
-#endif /* SUBSYSTEM_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 17599808..f60c8847 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -6,10 +6,10 @@
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
 		Mode_t initialMode, uint16_t commandQueueDepth) :
 		SystemObject(setObjectId), mode(initialMode), submode(SUBMODE_NONE),
-		childrenChangedMode(false), commandsOutstanding(0), commandQueue(NULL),
+		childrenChangedMode(false),
+		commandQueue(QueueFactory::instance()->createMessageQueue(
+		        commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE)),
 		healthHelper(this, setObjectId), modeHelper(this), parentId(parent) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth,
-			MessageQueueMessage::MAX_MESSAGE_SIZE);
 }
 
 SubsystemBase::~SubsystemBase() {
@@ -21,7 +21,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	ChildInfo info;
 
 	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
-	//This is a rather ugly hack to have the changedHealth info for all children available. (needed for FOGs).
+	// This is a rather ugly hack to have the changedHealth info for all
+	// children available.
 	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
 	if (child == nullptr) {
 		if (healthChild == nullptr) {
@@ -38,14 +39,11 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	info.submode = SUBMODE_NONE;
 	info.healthChanged = false;
 
-	std::pair<std::map<object_id_t, ChildInfo>::iterator, bool> returnValue =
-			childrenMap.insert(
-					std::pair<object_id_t, ChildInfo>(objectId, info));
-	if (!(returnValue.second)) {
+	auto resultPair = childrenMap.emplace(objectId, info);
+	if (not resultPair.second) {
 		return COULD_NOT_INSERT_CHILD;
-	} else {
-		return RETURN_OK;
 	}
+	return RETURN_OK;
 }
 
 ReturnValue_t SubsystemBase::checkStateAgainstTable(
diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h
index 2d949b56..b8e4f902 100644
--- a/subsystem/SubsystemBase.h
+++ b/subsystem/SubsystemBase.h
@@ -1,5 +1,7 @@
-#ifndef SUBSYSTEMBASE_H_
-#define SUBSYSTEMBASE_H_
+#ifndef FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+#define FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_
+
+#include "modes/HasModeSequenceIF.h"
 
 #include "../container/HybridIterator.h"
 #include "../health/HasHealthIF.h"
@@ -7,7 +9,6 @@
 #include "../modes/HasModesIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../subsystem/modes/HasModeSequenceIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include <map>
@@ -34,17 +35,17 @@ public:
 			Mode_t initialMode = 0, uint16_t commandQueueDepth = 8);
 	virtual ~SubsystemBase();
 
-	virtual MessageQueueId_t getCommandQueue() const;
+	virtual MessageQueueId_t getCommandQueue() const override;
 
 	ReturnValue_t registerChild(object_id_t objectId);
 
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode);
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
 
-	virtual ReturnValue_t setHealth(HealthState health);
+	virtual ReturnValue_t setHealth(HealthState health) override;
 
-	virtual HasHealthIF::HealthState getHealth();
+	virtual HasHealthIF::HealthState getHealth() override;
 
 protected:
 	struct ChildInfo {
@@ -62,9 +63,9 @@ protected:
 	/**
 	 * Always check this against <=0, so you are robust against too many replies
 	 */
-	int32_t commandsOutstanding;
+	int32_t commandsOutstanding = 0;
 
-	MessageQueueIF* commandQueue;
+	MessageQueueIF* commandQueue = nullptr;
 
 	HealthHelper healthHelper;
 
@@ -126,4 +127,4 @@ protected:
 	virtual void modeChanged();
 };
 
-#endif /* SUBSYSTEMBASE_H_ */
+#endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */
diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h
index 06bde2aa..70b1667e 100644
--- a/subsystem/modes/HasModeSequenceIF.h
+++ b/subsystem/modes/HasModeSequenceIF.h
@@ -1,9 +1,9 @@
 #ifndef HASMODESEQUENCEIF_H_
 #define HASMODESEQUENCEIF_H_
 
-#include "../../subsystem/modes/ModeDefinitions.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
+#include "ModeDefinitions.h"
+#include "ModeSequenceMessage.h"
+#include "ModeStoreIF.h"
 
 
 class HasModeSequenceIF {
diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h
index a865ab0c..13a780ee 100644
--- a/subsystem/modes/ModeDefinitions.h
+++ b/subsystem/modes/ModeDefinitions.h
@@ -1,22 +1,19 @@
-#ifndef MODEDEFINITIONS_H_
-#define MODEDEFINITIONS_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
+#define FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_
 
 #include "../../modes/HasModesIF.h"
 #include "../../objectmanager/SystemObjectIF.h"
 #include "../../serialize/SerializeIF.h"
 #include "../../serialize/SerialLinkedListAdapter.h"
+
 class ModeListEntry: public SerializeIF, public LinkedElement<ModeListEntry> {
 public:
-	ModeListEntry() :
-			LinkedElement<ModeListEntry>(this), value1(0), value2(0), value3(0), value4(
-					0) {
+	ModeListEntry(): LinkedElement<ModeListEntry>(this) {}
 
-	}
-
-	uint32_t value1;
-	uint32_t value2;
-	uint8_t value3;
-	uint8_t value4;
+	uint32_t value1 = 0;
+	uint32_t value2 = 0;
+	uint8_t value3 = 0;
+	uint8_t value4 = 0;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			size_t maxSize, Endianness streamEndianness) const {
@@ -149,4 +146,4 @@ public:
 	}
 };
 
-#endif //MODEDEFINITIONS_H_
+#endif /* FSFW_SUBSYSTEM_MODES_MODEDEFINITIONS_H_ */
diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp
index e092380e..7733098e 100644
--- a/subsystem/modes/ModeSequenceMessage.cpp
+++ b/subsystem/modes/ModeSequenceMessage.cpp
@@ -1,8 +1,7 @@
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "ModeSequenceMessage.h"
+
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeSequenceMessage.h"
 
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence, store_address_t storeAddress) {
@@ -11,25 +10,12 @@ void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table, store_address_t storeAddress) {
-//	message->setCommand(command);
-//	message->setParameter(storeAddress.raw);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, Mode_t sequence) {
 	message->setCommand(command);
 	message->setParameter2(sequence);
 }
 
-//void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
-//		Command_t command, ModeTableId_t table) {
-//	message->setCommand(command);
-//	message->setParameter2(table);
-//}
-
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
 		Command_t command, store_address_t storeAddress) {
 	message->setCommand(command);
@@ -63,9 +49,10 @@ void ModeSequenceMessage::clear(CommandMessage *message) {
 	case SEQUENCE_LIST:
 	case TABLE_LIST:
 	case TABLE:
-	case SEQUENCE:{
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL){
+	case SEQUENCE: {
+		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		        objects::IPC_STORE);
+		if (ipcStore != nullptr){
 			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));
 		}
 	}
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 61ba30f3..9be4586e 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -1,9 +1,10 @@
-#ifndef MODESEQUENCEMESSAGE_H_
-#define MODESEQUENCEMESSAGE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
 
+#include "ModeDefinitions.h"
 #include "../../ipc/CommandMessage.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
+
 
 class ModeSequenceMessage {
 public:
@@ -45,4 +46,4 @@ private:
 	ModeSequenceMessage();
 };
 
-#endif /* MODESEQUENCEMESSAGE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_ */
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index dce2931c..260e5ab2 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,5 +1,7 @@
 #include "../../subsystem/modes/ModeStore.h"
 
+// todo: I think some parts are deprecated. If this is used,  the define
+// USE_MODESTORE could be part of the new FSFWConfig.h file.
 #ifdef USE_MODESTORE
 
 ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :

From bc0402faf7c819d5b63630bc209444b3c2df89bb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:49:50 +0200
Subject: [PATCH 0879/1292] health update

---
 health/HasHealthIF.h  |  9 +++------
 health/HealthHelper.h | 42 +++++++++++++++++++++++++-----------------
 health/HealthTable.h  |  5 +++--
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index d5321a6d..86863ea8 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -35,18 +35,15 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
 	/**
-	 * set the Health State
-	 *
+	 * @brief   Set the Health State
 	 * The parent will be informed, if the Health changes
-	 *
 	 * @param health
 	 */
 	virtual ReturnValue_t setHealth(HealthState health) = 0;
 
 	/**
-	 * get Health State
-	 *
-	 * @return Health State of the object
+	 * @brief   Get Health State
+	 * @return  Health State of the object
 	 */
 	virtual HasHealthIF::HealthState getHealth() = 0;
 };
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index 813123b2..08889fba 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -12,13 +12,15 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 
 /**
- * Helper class for Objects that implement HasHealthIF
+ * @brief   Helper class for Objects that implement HasHealthIF
+ * @details
+ * It takes care of registering with the Health Table as well as handling
+ * health commands (including replying to the sender) and updating
+ * the Health Table.
  *
- * It takes care of registering with the Health Table as well as handling health commands
- * (including replying to the sender) and updating the Health Table.
- *
- * If a parent is set in the ctor, the parent will be informed with a @c HEALTH_INFO message
- * about changes in the health state. Note that a @c HEALTH_INFO is only generated if the Health
+ * If a parent is set in the ctor, the parent will be informed with a
+ * @c HEALTH_INFO message about changes in the health state.
+ * Note that a @c HEALTH_INFO is only generated if the Health
  * changes, not for all @c HEALTH_SET commands received.
  *
  * It does NOT handle @c HEALTH_INFO messages
@@ -27,10 +29,9 @@ class HealthHelper {
 public:
 
 	/**
-	 * ctor
-	 *
 	 * @param owner
-	 * @param objectId the object Id to use when communication with the HealthTable
+	 * @param objectId      The object Id to use when communication with
+	 *                      the HealthTable
 	 */
 	HealthHelper(HasHealthIF* owner, object_id_t objectId);
 
@@ -56,8 +57,9 @@ public:
 	 *
 	 * @param message
 	 * @return
-	 * 			-@c RETURN_OK if the message was handled
-	 * 			-@c RETURN_FAILED if the message could not be handled (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
+	 * -@c RETURN_OK if the message was handled
+	 * -@c RETURN_FAILED if the message could not be handled
+	 *     (ie it was not a @c HEALTH_SET or @c HEALTH_READ message)
 	 */
 	ReturnValue_t handleHealthCommand(CommandMessage *message);
 
@@ -78,16 +80,19 @@ public:
 	HasHealthIF::HealthState getHealth();
 
 	/**
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 */
 	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *
-	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
+	 * @param parentQueue   The queue ID of the parent object.
+	 *                      Set to 0 if no parent present
 	 * @return
-	 * 			-@c RETURN_OK if the Health Table was found and the object could be registered
-	 * 			-@c RETURN_FAILED else
+	 * -@c RETURN_OK if the Health Table was found and the object
+	 * could be registered
+	 * -@c RETURN_FAILED else
 	 */
 	ReturnValue_t initialize(MessageQueueId_t parentQueue );
 
@@ -110,8 +115,11 @@ private:
 	HasHealthIF* owner;
 
 	/**
-	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message will be sent to this queue
-	 * @param health the health is passed as parameter so that the number of calls to the health table can be minimized
+	 * if the #parentQueue is not NULL, a @c HEALTH_INFO message
+	 * will be sent to this queue
+	 * @param health
+	 * The health is passed as parameter so that the number of
+	 * calls to the health table can be minimized
 	 * @param oldHealth information of the previous health state.
 	 */
 	void informParent(HasHealthIF::HealthState health,
diff --git a/health/HealthTable.h b/health/HealthTable.h
index c5ebb5d4..945fb2e6 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -6,8 +6,6 @@
 #include "../ipc/MutexIF.h"
 #include <map>
 
-typedef std::map<object_id_t, HasHealthIF::HealthState> HealthMap;
-using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 class HealthTable: public HealthTableIF, public SystemObject {
 public:
@@ -28,6 +26,9 @@ public:
 	virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
 protected:
+	using HealthMap = std::map<object_id_t, HasHealthIF::HealthState>;
+	using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
+
 	MutexIF* mutex;
 	HealthMap healthMap;
 

From 01e7a98425f8fd09b08d8f0e8edbbe9bed695de6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 17:55:38 +0200
Subject: [PATCH 0880/1292] added announce all subservice

---
 health/HealthMessage.cpp |  6 ++++--
 health/HealthMessage.h   | 11 +++++++----
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp
index 1bb29526..52479c26 100644
--- a/health/HealthMessage.cpp
+++ b/health/HealthMessage.cpp
@@ -7,11 +7,13 @@ void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command,
 	message->setParameter2(oldHealth);
 }
 
-void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command) {
+void HealthMessage::setHealthMessage(CommandMessage* message,
+        Command_t command) {
 	message->setCommand(command);
 }
 
-HasHealthIF::HealthState HealthMessage::getHealth(const CommandMessage* message) {
+HasHealthIF::HealthState HealthMessage::getHealth(
+        const CommandMessage* message) {
 	return (HasHealthIF::HealthState) message->getParameter();
 }
 
diff --git a/health/HealthMessage.h b/health/HealthMessage.h
index de4923ab..fb979c66 100644
--- a/health/HealthMessage.h
+++ b/health/HealthMessage.h
@@ -7,17 +7,20 @@
 class HealthMessage {
 public:
 	static const uint8_t MESSAGE_ID = messagetypes::HEALTH_COMMAND;
-	// REPLY_COMMAND_OK/REPLY_REJECTED
+
 	static const Command_t HEALTH_SET = MAKE_COMMAND_ID(1);
-	// NO REPLY!
-	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(3);
+	// No reply expected, health will be announced as event!
+	static const Command_t HEALTH_ANNOUNCE = MAKE_COMMAND_ID(2);
+	// Same as before, but all objects in health table will
+	// announce their health as events.
+	static const Command_t HEALTH_ANNOUNCE_ALL = MAKE_COMMAND_ID(3);
+
 	static const Command_t HEALTH_INFO = MAKE_COMMAND_ID(5);
 	static const Command_t REPLY_HEALTH_SET = MAKE_COMMAND_ID(6);
 
 	static void setHealthMessage(CommandMessage *message, Command_t command,
 			HasHealthIF::HealthState health,
 			HasHealthIF::HealthState oldHealth = HasHealthIF::FAULTY);
-
 	static void setHealthMessage(CommandMessage *message, Command_t command);
 
 	static HasHealthIF::HealthState getHealth(const CommandMessage *message);

From b9c7d1bd3f77f8d2da1e7376ef55df99ea26ec92 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 18:09:04 +0200
Subject: [PATCH 0881/1292] added health subservices

---
 pus/CService200ModeCommanding.cpp      |  5 ++-
 pus/CService200ModeCommanding.h        |  5 +--
 pus/CService201HealthCommanding.cpp    | 54 +++++++++++++++++---------
 pus/CService201HealthCommanding.h      | 17 +++++---
 pus/servicepackets/Service201Packets.h |  4 +-
 5 files changed, 54 insertions(+), 31 deletions(-)

diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp
index c63b47a6..c4e99359 100644
--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@@ -7,9 +7,10 @@
 #include "../modes/ModeMessage.h"
 
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
         CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
+                numParallelCommands, commandTimeoutSeconds) {}
 
 CService200ModeCommanding::~CService200ModeCommanding() {}
 
diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h
index c86d7b84..84040212 100644
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@@ -15,11 +15,10 @@
  */
 class CService200ModeCommanding: public CommandingServiceBase {
 public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
 	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
+	        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands = 4,
+            uint16_t commandTimeoutSeconds = 60);
 	virtual~ CService200ModeCommanding();
 
 protected:
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index 7e68533d..db43db89 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -6,9 +6,10 @@
 #include "servicepackets/Service201Packets.h"
 
 CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
+        uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
+        uint16_t commandTimeoutSeconds):
 		CommandingServiceBase(objectId, apid, serviceId,
-		NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {
+		        numParallelCommands, commandTimeoutSeconds) {
 }
 
 CService201HealthCommanding::~CService201HealthCommanding() {
@@ -17,6 +18,8 @@ CService201HealthCommanding::~CService201HealthCommanding() {
 ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
 	switch(subservice) {
 	case(Subservice::COMMAND_SET_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH):
+	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
 		sif::error << "Invalid Subservice" << std::endl;
@@ -47,19 +50,34 @@ ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CService201HealthCommanding::prepareCommand
-		(CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
+ReturnValue_t CService201HealthCommanding::prepareCommand(
+        CommandMessage* message, uint8_t subservice, const uint8_t *tcData,
 		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	HealthCommand healthCommand;
-	ReturnValue_t result = healthCommand.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	} else {
-		HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
-				healthCommand.getHealth());
-		return result;
-	}
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(subservice) {
+    case(Subservice::COMMAND_SET_HEALTH): {
+        HealthSetCommand healthCommand;
+        result = healthCommand.deSerialize(&tcData, &tcDataLen,
+                SerializeIF::Endianness::BIG);
+        if (result != RETURN_OK) {
+            break;
+        }
+        HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_SET,
+                healthCommand.getHealth());
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE);
+        break;
+    }
+    case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
+        HealthMessage::setHealthMessage(message,
+                HealthMessage::HEALTH_ANNOUNCE_ALL);
+        break;
+    }
+    }
+    return result;
 }
 
 ReturnValue_t CService201HealthCommanding::handleReply
@@ -68,17 +86,17 @@ ReturnValue_t CService201HealthCommanding::handleReply
 		object_id_t objectId, bool *isStep) {
 	Command_t replyId = reply->getCommand();
 	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		prepareHealthSetReply(reply);
+		return prepareHealthSetReply(reply);
 	}
-	return RETURN_OK;
+	return CommandingServiceBase::INVALID_REPLY;
 }
 
-void CService201HealthCommanding::prepareHealthSetReply(
+ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
         const CommandMessage* reply) {
 	prepareHealthSetReply(reply);
 	uint8_t health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
 	uint8_t oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
 	HealthSetReply healthSetReply(health, oldHealth);
-	sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
+	return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
 }
 
diff --git a/pus/CService201HealthCommanding.h b/pus/CService201HealthCommanding.h
index 100f675e..124e2ac7 100644
--- a/pus/CService201HealthCommanding.h
+++ b/pus/CService201HealthCommanding.h
@@ -19,11 +19,10 @@
  */
 class CService201HealthCommanding: public CommandingServiceBase {
 public:
-    static const uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-    static const uint16_t COMMAND_TIMEOUT_SECONDS = 60;
 
 	CService201HealthCommanding(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId);
+	        uint8_t serviceId, uint8_t numParallelCommands = 4,
+	        uint16_t commandTimeoutSeconds = 60);
 	virtual~ CService201HealthCommanding();
 protected:
 	/* CSB abstract function implementations */
@@ -47,11 +46,17 @@ private:
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
 			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
 
-	void prepareHealthSetReply(const CommandMessage *reply);
+	ReturnValue_t prepareHealthSetReply(const CommandMessage *reply);
 
 	enum Subservice {
-		COMMAND_SET_HEALTH = 1, //!< [EXPORT] : [TC] Set health of target object
-		REPLY_HEALTH_SET = 2 //!< [EXPORT] : [TM] Reply to health set command which also provides old health
+	    //! [EXPORT] : [TC] Set health of target object
+		COMMAND_SET_HEALTH = 1,
+		//! [EXPORT] : [TM] Reply to health set command which also provides old health
+		REPLY_HEALTH_SET = 2,
+		//! [EXPORT] : [TC] Commands object to announce their health as an event
+		COMMAND_ANNOUNCE_HEALTH = 3,
+		//! [EXPORT] : [TC] Commands all objects in the health map to announce their health
+		COMMAND_ANNOUNCE_HEALTH_ALL = 4
 	};
 };
 
diff --git a/pus/servicepackets/Service201Packets.h b/pus/servicepackets/Service201Packets.h
index 8dce88e5..aed821f9 100644
--- a/pus/servicepackets/Service201Packets.h
+++ b/pus/servicepackets/Service201Packets.h
@@ -5,10 +5,10 @@
 #include "../../serialize/SerializeIF.h"
 #include "../../health/HasHealthIF.h"
 
-class HealthCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
+class HealthSetCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1
 public:
 
-	HealthCommand() {
+	HealthSetCommand() {
 		setLinks();
 	}
 

From 670e9bfa0f4fa55fddfd3cbcd7669987e65aa3f5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 18:12:22 +0200
Subject: [PATCH 0882/1292] CMD/REPLY prefixes added

---
 pus/Service2DeviceAccess.cpp       | 12 ++++++------
 pus/Service2DeviceAccess.h         | 12 ++++++++----
 pus/Service8FunctionManagement.cpp |  4 ++--
 pus/Service8FunctionManagement.h   |  6 ++++--
 4 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 878a13b0..3648b7eb 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -21,8 +21,8 @@ Service2DeviceAccess::~Service2DeviceAccess() {}
 
 ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
+	case Subservice::COMMAND_RAW_COMMANDING:
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		sif::error << "Invalid Subservice" << std::endl;
@@ -58,11 +58,11 @@ ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
 		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
 		uint32_t* state, object_id_t objectId) {
 	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
+	case Subservice::COMMAND_RAW_COMMANDING: {
 		return prepareRawCommand(message, tcData, tcDataLen);
 	}
 	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
+	case Subservice::COMMAND_TOGGLE_WIRETAPPING: {
 		return prepareWiretappingCommand(message, tcData, tcDataLen);
 	}
 	break;
@@ -118,11 +118,11 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 	switch(reply->getCommand()) {
 	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
+				static_cast<uint8_t>(Subservice::REPLY_WIRETAPPING_RAW_TC));
 		break;
 	case DeviceHandlerMessage::REPLY_RAW_REPLY:
 		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
+				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
 		sif::error << "Unknown message in Service2DeviceAccess::"
diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h
index fa2ea75c..b62e6854 100644
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@@ -81,10 +81,14 @@ private:
 	        const uint8_t* tcData, size_t tcDataLen);
 
 	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+	    //!< [EXPORT] : [COMMAND] Command in device native protocol
+		COMMAND_RAW_COMMANDING = 128,
+		//!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
+		COMMAND_TOGGLE_WIRETAPPING = 129,
+		//!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
+		REPLY_RAW = 130,
+		//!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
+		REPLY_WIRETAPPING_RAW_TC = 131
 	};
 };
 
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index c1c88a50..d710c56e 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -19,7 +19,7 @@ Service8FunctionManagement::~Service8FunctionManagement() {}
 ReturnValue_t Service8FunctionManagement::isValidSubservice(
 		uint8_t subservice) {
 	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
+	case Subservice::COMMAND_DIRECT_COMMANDING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -131,7 +131,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     }
     DataReply dataReply(objectId, actionId, buffer, size);
     result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
+            Subservice::REPLY_DIRECT_COMMANDING_DATA), &dataReply);
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h
index 292a5e36..00153cfb 100644
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@@ -52,8 +52,10 @@ protected:
 
 private:
 	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
+	    //!< [EXPORT] : [COMMAND] Functional commanding
+		COMMAND_DIRECT_COMMANDING = 128,
+		//!< [EXPORT] : [REPLY] Data reply
+		REPLY_DIRECT_COMMANDING_DATA = 130,
 	};
 
 	ReturnValue_t checkInterfaceAndAcquireMessageQueue(

From 3e79d2e73ad239b5f1c4838178f35348ac5ca6b8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 20:04:01 +0200
Subject: [PATCH 0883/1292] added extended controller base

---
 controller/ControllerBase.cpp         |   8 +-
 controller/ControllerBase.h           |  30 +++----
 controller/ExtendedControllerBase.cpp | 110 ++++++++++++++++++++++++++
 controller/ExtendedControllerBase.h   |  70 ++++++++++++++++
 4 files changed, 201 insertions(+), 17 deletions(-)
 create mode 100644 controller/ExtendedControllerBase.cpp
 create mode 100644 controller/ExtendedControllerBase.h

diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 4f50fe1f..45e678eb 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -9,7 +9,8 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
 		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
 		submode(SUBMODE_NONE), modeHelper(this),
 		healthHelper(this, setObjectId), hkSwitcher(this) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
+	commandQueue = QueueFactory::instance()->createMessageQueue(
+	        commandQueueDepth);
 }
 
 ControllerBase::~ControllerBase() {
@@ -56,8 +57,9 @@ MessageQueueId_t ControllerBase::getCommandQueue() const {
 
 void ControllerBase::handleQueue() {
 	CommandMessage command;
-	ReturnValue_t result;
-	for (result = commandQueue->receiveMessage(&command); result == RETURN_OK;
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	for (result = commandQueue->receiveMessage(&command);
+	        result == RETURN_OK;
 			result = commandQueue->receiveMessage(&command)) {
 
 		result = modeHelper.handleModeCommand(&command);
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 6c2ec1d6..25d3ab1f 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -11,9 +11,10 @@
 #include "../datapool/HkSwitchHelper.h"
 
 /**
- * @brief  Generic base class for controller classes
+ * @brief   Generic base class for controller classes
  * @details
- * Implements common interfaces for controllers.
+ * Implements common interfaces for controllers, which generally have
+ * a mode and a health state. This avoids boilerplate code.
  */
 class ControllerBase: public HasModesIF,
 		public HasHealthIF,
@@ -27,24 +28,18 @@ public:
 			size_t commandQueueDepth = 3);
 	virtual ~ControllerBase();
 
+	/** SystemObject override */
 	virtual ReturnValue_t initialize() override;
 
 	virtual MessageQueueId_t getCommandQueue() const override;
 
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-
+	/** HasHealthIF overrides */
 	virtual ReturnValue_t setHealth(HealthState health) override;
-
 	virtual HasHealthIF::HealthState getHealth() override;
 
-	/**
-	 * 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_) override;
-
+	/** ExecutableObjectIF overrides */
+	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual void setTaskIF(PeriodicTaskIF* task) override;
 	virtual ReturnValue_t initializeAfterTaskCreation() override;
 
 protected:
@@ -57,6 +52,9 @@ protected:
 	 */
     virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
 
+    /**
+     * Periodic helper, implemented by child class.
+     */
     virtual void performControlOperation() = 0;
 
     virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
@@ -74,6 +72,7 @@ protected:
 
 	HealthHelper healthHelper;
 
+	// Is this still needed?
 	HkSwitchHelper hkSwitcher;
 
 	/**
@@ -82,13 +81,16 @@ protected:
 	 */
 	PeriodicTaskIF* executingTask = nullptr;
 
-	void handleQueue();
+	/** 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);
 };
 
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
new file mode 100644
index 00000000..f3336e43
--- /dev/null
+++ b/controller/ExtendedControllerBase.cpp
@@ -0,0 +1,110 @@
+#include "ExtendedControllerBase.h"
+
+
+ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
+        object_id_t parentId, size_t commandQueueDepth):
+        ControllerBase(objectId, parentId, commandQueueDepth),
+        localPoolManager(this, commandQueue),
+        actionHelper(this, commandQueue) {
+}
+
+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;
+}
+
+
+
+ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
+        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    // needs to be overriden and implemented by child class.
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t ExtendedControllerBase::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &localPoolManager;
+}
+
+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 localPoolManager.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 = localPoolManager.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 localPoolManager.initialize(commandQueue);
+}
+
+ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
+    return localPoolManager.initializeAfterTaskCreation();
+}
+
+ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
+    handleQueue();
+    hkSwitcher.performOperation();
+    localPoolManager.performHkOperation();
+    performControlOperation();
+    return RETURN_OK;
+}
+
+LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
+    sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
+            << " implementation provided, returning nullptr!" << std::endl;
+    return nullptr;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
new file mode 100644
index 00000000..fa47950a
--- /dev/null
+++ b/controller/ExtendedControllerBase.h
@@ -0,0 +1,70 @@
+#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);
+
+    /** SystemObjectIF overrides */
+    virtual ReturnValue_t initialize() override;
+
+    /** ExecutableObjectIF overrides */
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+protected:
+    LocalDataPoolManager localPoolManager;
+    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 object_id_t getObjectId() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            LocalDataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
+    virtual uint32_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+};
+
+
+
+#endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

From ed71a3700435aa8532abd2764ddfa9d5be882235 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 10 Oct 2020 20:11:20 +0200
Subject: [PATCH 0884/1292] get command queue override

---
 controller/ExtendedControllerBase.cpp | 4 ++++
 controller/ExtendedControllerBase.h   | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f3336e43..f69d2ea1 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -103,6 +103,10 @@ ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     return RETURN_OK;
 }
 
+MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
+    return commandQueue->getId();
+}
+
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index fa47950a..02c5728e 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -26,6 +26,8 @@ public:
     /** 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;

From 18671a0db7357a0e209cc547d64271f84f8893af Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 13:40:24 +0200
Subject: [PATCH 0885/1292] doc wrong

---
 action/HasActionsIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 886d0837..a26ed588 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -47,10 +47,9 @@ public:
 	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!
+	 * When used in conjunction with the ActionHelper class, returning
+	 * a return code which is not equal to RETURN_OK will trigger a step reply
+	 * with step 0.
 	 */
 	virtual ReturnValue_t executeAction(ActionId_t actionId,
 			MessageQueueId_t commandedBy, const uint8_t* data, size_t size) = 0;

From b9ebd153a2d6e897b76c41d09f2f2f8d40c1d517 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 16:55:40 +0200
Subject: [PATCH 0886/1292] added action helper function

---
 action/ActionHelper.cpp | 56 ++++++++++++++++++++++++++++++++++++-----
 action/ActionHelper.h   | 15 +++++++++--
 2 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index ab986c6c..9fd117f3 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -89,22 +89,28 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
-	result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
+	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.
+	// 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);
 
 	//TODO Service Implementation sucks at the moment
-	if (hideSender){
+	// why does it suck and why would someone need to hide the sender?
+	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	} else {
+	}
+	else {
 		result = queueToUse->sendMessage(reportTo, &reply);
 	}
-	if ( result != HasReturnvaluesIF::RETURN_OK){
+
+	if (result != HasReturnvaluesIF::RETURN_OK){
 		ipcStore->deleteData(storeAddress);
 	}
 	return result;
@@ -112,3 +118,41 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 
 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;
+    uint8_t *dataPtr = nullptr;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    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);
+
+    //TODO Service Implementation sucks at the moment
+    // why does it suck and why would someone need to hide the sender?
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index a20f286a..17ca3ebd 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -69,8 +69,8 @@ public:
 	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
-	 *
+	 * 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
@@ -79,6 +79,17 @@ public:
 	 */
 	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

From e4c74ec060df2beb86eb34f1b2a9a8b1193adbd8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 16:57:37 +0200
Subject: [PATCH 0887/1292] added todos

---
 action/ActionHelper.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 9fd117f3..8122885b 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -101,8 +101,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-	//TODO Service Implementation sucks at the moment
-	// why does it suck and why would someone need to hide the sender?
+	// TODO: Service Implementation sucks at the moment
+	// TODO: why does it suck and why would someone need to hide the sender?
 	if (hideSender) {
 		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
 	}
@@ -124,8 +124,6 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
         bool hideSender) {
     CommandMessage reply;
     store_address_t storeAddress;
-    uint8_t *dataPtr = nullptr;
-    size_t size = 0;
     ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
     if (result != HasReturnvaluesIF::RETURN_OK) {
         return result;
@@ -142,8 +140,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     // another dedicated message.
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    //TODO Service Implementation sucks at the moment
-    // why does it suck and why would someone need to hide the sender?
+    // TODO: Service Implementation sucks at the moment
+    // TODO: why does it suck and why would someone need to hide the sender?
     if (hideSender) {
         result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
     }

From 06c7919daa1f30e93452d2fe284d7ff0ccae4a41 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 17:39:13 +0200
Subject: [PATCH 0888/1292] monitoring form improvements

---
 monitoring/AbsLimitMonitor.h | 23 +++++++++++++++--------
 monitoring/HasMonitorsIF.h   | 12 +++---------
 monitoring/MonitoringIF.h    |  8 ++++----
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 2e60f6f8..c9c33c74 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
-#define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_
+#ifndef FSFW_MONITORING_ABSLIMITMONITOR_H_
+#define FSFW_MONITORING_ABSLIMITMONITOR_H_
 
 #include "MonitorBase.h"
 #include <cmath>
@@ -7,9 +7,14 @@
 template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
-	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
-			uint16_t confirmationLimit, T limit, Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE, bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), limit(limit), violationEvent(violationEvent), aboveIsViolation(aboveIsViolation) {
+	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        uint32_t parameterId, uint16_t confirmationLimit, T limit,
+	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
+	        bool aboveIsViolation = true) :
+			MonitorBase<T>(reporterId, monitorId, parameterId,
+			        confirmationLimit),
+			limit(limit), violationEvent(violationEvent),
+			aboveIsViolation(aboveIsViolation) {
 	}
 	virtual ~AbsLimitMonitor() {
 	}
@@ -32,7 +37,8 @@ public:
 			const ParameterWrapper *newValues, uint16_t startAtIndex) {
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
-		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
+		// We'll reuse the DOMAIN_ID of MonitorReporter,
+		// as we know the parameterIds used there.
 		if (result != this->INVALID_MATRIX_ID) {
 			return result;
 		}
@@ -59,7 +65,8 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
-			EventManagerIF::triggerEvent(this->reportingId, violationEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId,
+			        violationEvent, this->parameterId);
 			break;
 		default:
 			break;
@@ -70,4 +77,4 @@ protected:
 	const bool aboveIsViolation;
 };
 
-#endif /* FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ */
+#endif /* FSFW_MONITORING_ABSLIMITMONITOR_H_ */
diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h
index 85d92b6b..04f63437 100644
--- a/monitoring/HasMonitorsIF.h
+++ b/monitoring/HasMonitorsIF.h
@@ -1,11 +1,5 @@
-/**
- * @file	HasMonitorsIF.h
- * @brief	This file defines the HasMonitorsIF class.
- * @date	28.07.2014
- * @author	baetz
- */
-#ifndef HASMONITORSIF_H_
-#define HASMONITORSIF_H_
+#ifndef FSFW_MONITORING_HASMONITORSIF_H_
+#define FSFW_MONITORING_HASMONITORSIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -27,4 +21,4 @@ public:
 	}
 };
 
-#endif /* HASMONITORSIF_H_ */
+#endif /* FSFW_MONITORING_HASMONITORSIF_H_ */
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index 44218c36..aa266f33 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -1,8 +1,8 @@
-#ifndef MONITORINGIF_H_
-#define MONITORINGIF_H_
+#ifndef FSFW_MONITORING_MONITORINGIF_H_
+#define FSFW_MONITORING_MONITORINGIF_H_
 
-#include "../memory/HasMemoryIF.h"
 #include "MonitoringMessage.h"
+#include "../memory/HasMemoryIF.h"
 #include "../serialize/SerializeIF.h"
 
 class MonitoringIF : public SerializeIF {
@@ -64,4 +64,4 @@ public:
 
 
 
-#endif /* MONITORINGIF_H_ */
+#endif /* FSFW_MONITORING_MONITORINGIF_H_ */

From 736ce2d5fd199ed5c18eb2d59718ce4faa3b5cff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 17:42:30 +0200
Subject: [PATCH 0889/1292] some more form improvements

---
 monitoring/MonitorBase.h     | 36 ++++++++++++++++++++++--------------
 monitoring/MonitorReporter.h | 26 +++++++++++++++-----------
 2 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 964fd55e..5f9a2caf 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -1,35 +1,42 @@
-#ifndef MONITORBASE_H_
-#define MONITORBASE_H_
+#ifndef FSFW_MONITORING_MONITORBASE_H_
+#define FSFW_MONITORING_MONITORBASE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 #include "MonitorReporter.h"
 
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/PIDReader.h"
+
 /**
- * Base class for monitoring of parameters.
- * Can be used anywhere, specializations need to implement checkSample and should override sendTransitionEvent.
- * Manages state handling, enabling and disabling of events/reports and forwarding of transition
- * reports via MonitorReporter. In addition, it provides default implementations for fetching the parameter sample from
- * the data pool and a simple confirmation counter.
+ * @brief   Base class for monitoring of parameters.
+ * @details
+ * Can be used anywhere, specializations need to implement checkSample and
+ * should override sendTransitionEvent.
+ * Manages state handling, enabling and disabling of events/reports and
+ * forwarding of transition reports via MonitorReporter.
+ *
+ * In addition, it provides default implementations for fetching the
+ * parameter sample from the data pool and a simple confirmation counter.
  */
 template<typename T>
 class MonitorBase: public MonitorReporter<T> {
 public:
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
 			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId, confirmationLimit) {
+			MonitorReporter<T>(reporterId, monitorId, parameterId,
+			        confirmationLimit) {
 	}
 	virtual ~MonitorBase() {
 	}
 	virtual ReturnValue_t check() {
-		//1. Fetch sample of type T, return validity.
+		// 1. Fetch sample of type T, return validity.
 		T sample = 0;
 		ReturnValue_t validity = fetchSample(&sample);
 
-		//2. If returning from fetch != OK, parameter is invalid. Report (if oldState is != invalidity).
+		// 2. If returning from fetch != OK, parameter is invalid.
+		// Report (if oldState is != invalidity).
 		if (validity != HasReturnvaluesIF::RETURN_OK) {
 			this->monitorStateIs(validity, sample, 0);
 			//3. Otherwise, check sample.
@@ -43,7 +50,8 @@ public:
 		ReturnValue_t currentState = checkSample(sample, &crossedLimit);
 		return this->monitorStateIs(currentState,sample, crossedLimit);
 	}
-	//Abstract or default.
+
+	// Abstract or default.
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
 
 protected:
@@ -59,4 +67,4 @@ protected:
 	}
 };
 
-#endif /* MONITORBASE_H_ */
+#endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index ca2b534b..88fa6ede 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_
-#define FRAMEWORK_MONITORING_MONITORREPORTER_H_
+#ifndef FSFW_MONITORING_MONITORREPORTER_H_
+#define FSFW_MONITORING_MONITORREPORTER_H_
 
-#include "../events/EventManagerIF.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
+
+#include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
 template<typename T>
@@ -14,11 +15,12 @@ public:
 	static const uint8_t ENABLED = 1;
 	static const uint8_t DISABLED = 0;
 
-	MonitorReporter(object_id_t reportingId, uint8_t monitorId, uint32_t parameterId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId), reportingId(
-					reportingId), oldState(MonitoringIF::UNCHECKED), reportingEnabled(
-			ENABLED), eventEnabled(ENABLED), currentCounter(0), confirmationLimit(
-					confirmationLimit) {
+	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
+	        uint32_t parameterId, uint16_t confirmationLimit) :
+			monitorId(monitorId), parameterId(parameterId),
+			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
+			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
+			confirmationLimit(confirmationLimit) {
 	}
 
 	virtual ~MonitorReporter() {
@@ -148,7 +150,8 @@ protected:
 		case HasReturnvaluesIF::RETURN_OK:
 			break;
 		default:
-			EventManagerIF::triggerEvent(reportingId, MonitoringIF::MONITOR_CHANGED_STATE, state);
+			EventManagerIF::triggerEvent(reportingId,
+			        MonitoringIF::MONITOR_CHANGED_STATE, state);
 			break;
 		}
 	}
@@ -159,7 +162,8 @@ protected:
 	 * @param crossedLimit The limit crossed (if applicable).
 	 * @param state Current state the monitor is in.
 	 */
-	virtual void sendTransitionReport(T parameterValue, T crossedLimit, ReturnValue_t state) {
+	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
+	        ReturnValue_t state) {
 		MonitoringReportContent<T> report(parameterId,
 				parameterValue, crossedLimit, oldState, state);
 		LimitViolationReporter::sendLimitViolationReport(&report);
@@ -175,4 +179,4 @@ protected:
 	}
 };
 
-#endif /* FRAMEWORK_MONITORING_MONITORREPORTER_H_ */
+#endif /* FSFW_MONITORING_MONITORREPORTER_H_ */

From afe5a627895f40bb05d314aaa98eb9ee898424ca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:12:26 +0200
Subject: [PATCH 0890/1292] imrpoved form, removed comm msg for now

---
 devicehandlers/AcceptsDeviceResponsesIF.h   |   6 +-
 devicehandlers/AssemblyBase.cpp             |   2 +-
 devicehandlers/AssemblyBase.h               |  11 +-
 devicehandlers/ChildHandlerBase.cpp         |   2 +-
 devicehandlers/ChildHandlerBase.h           |  14 +-
 devicehandlers/ChildHandlerFDIR.cpp         |   5 +-
 devicehandlers/ChildHandlerFDIR.h           |   6 +-
 devicehandlers/CommunicationMessage.cpp     | 201 --------------------
 devicehandlers/CommunicationMessage.h       | 173 -----------------
 devicehandlers/CookieIF.h                   |   9 +-
 devicehandlers/DeviceCommunicationIF.h      |  11 +-
 devicehandlers/DeviceTmReportingWrapper.cpp |   3 +-
 devicehandlers/DeviceTmReportingWrapper.h   |   6 +-
 devicehandlers/HealthDevice.cpp             |   5 +-
 devicehandlers/HealthDevice.h               |   6 +-
 15 files changed, 46 insertions(+), 414 deletions(-)
 delete mode 100644 devicehandlers/CommunicationMessage.cpp
 delete mode 100644 devicehandlers/CommunicationMessage.h

diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h
index eb7780db..8e13ba0c 100644
--- a/devicehandlers/AcceptsDeviceResponsesIF.h
+++ b/devicehandlers/AcceptsDeviceResponsesIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
-#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#ifndef FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
+#define FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -16,4 +16,4 @@ public:
 	virtual MessageQueueId_t getDeviceQueue() = 0;
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */
diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp
index 3bcb8a11..46b2211a 100644
--- a/devicehandlers/AssemblyBase.cpp
+++ b/devicehandlers/AssemblyBase.cpp
@@ -1,4 +1,4 @@
-#include "../devicehandlers/AssemblyBase.h"
+#include "AssemblyBase.h"
 
 AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId,
 		uint16_t commandQueueDepth) :
diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h
index b67c551e..353d5f89 100644
--- a/devicehandlers/AssemblyBase.h
+++ b/devicehandlers/AssemblyBase.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
-#define FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#ifndef FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
+#define FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_
 
+#include "DeviceHandlerBase.h"
 #include "../container/FixedArrayList.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 /**
@@ -156,8 +156,9 @@ protected:
 	 * Also sets state to STATE_OVERWRITE_HEATH.
 	 * @param objectId Must be a registered child.
 	 */
-	void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
+	void overwriteDeviceHealth(object_id_t objectId,
+	        HasHealthIF::HealthState oldHealth);
 
 };
 
-#endif /* FRAMEWORK_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 976c252a..d4ef67ad 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -1,5 +1,5 @@
+#include "ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
-#include "../devicehandlers/ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h
index 19e0fc80..eed4c95e 100644
--- a/devicehandlers/ChildHandlerBase.h
+++ b/devicehandlers/ChildHandlerBase.h
@@ -1,8 +1,8 @@
-#ifndef PAYLOADHANDLERBASE_H_
-#define PAYLOADHANDLERBASE_H_
+#ifndef FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
+#define FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_
 
-#include "../devicehandlers/ChildHandlerFDIR.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
+#include "DeviceHandlerBase.h"
+#include "ChildHandlerFDIR.h"
 
 class ChildHandlerBase: public DeviceHandlerBase {
 public:
@@ -10,7 +10,9 @@ public:
 			CookieIF * cookie, object_id_t hkDestination,
 			uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
 			object_id_t parent = objects::NO_OBJECT,
-			FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
+			FailureIsolationBase* customFdir = nullptr,
+			size_t cmdQueueSize = 20);
+
 	virtual ~ChildHandlerBase();
 
 	virtual ReturnValue_t initialize();
@@ -21,4 +23,4 @@ protected:
 
 };
 
-#endif /* PAYLOADHANDLERBASE_H_ */
+#endif /* FSFW_DEVICEHANDLER_CHILDHANDLERBASE_H_ */
diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp
index 9589b44f..cb4c75ea 100644
--- a/devicehandlers/ChildHandlerFDIR.cpp
+++ b/devicehandlers/ChildHandlerFDIR.cpp
@@ -1,6 +1,7 @@
-#include "../devicehandlers/ChildHandlerFDIR.h"
+#include "ChildHandlerFDIR.h"
 
-ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) :
+ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner,
+        object_id_t faultTreeParent, uint32_t recoveryCount) :
 		DeviceHandlerFailureIsolation(owner, faultTreeParent) {
 	recoveryCounter.setFailureThreshold(recoveryCount);
 }
diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h
index 203fc944..13d1345c 100644
--- a/devicehandlers/ChildHandlerFDIR.h
+++ b/devicehandlers/ChildHandlerFDIR.h
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
-#define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#ifndef FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
+#define FSFW_DEVICEHANDLERS_CHILDHANDLERFDIR_H_
 
-#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
+#include "DeviceHandlerFailureIsolation.h"
 
 /**
  * Very simple extension to normal FDIR.
diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp
deleted file mode 100644
index 57774270..00000000
--- a/devicehandlers/CommunicationMessage.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/**
- * @file CommunicationMessage.cpp
- *
- * @date 28.02.2020
- */
-
-#include "../devicehandlers/CommunicationMessage.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include <cstring>
-
-CommunicationMessage::CommunicationMessage(): uninitialized(true) {
-}
-
-CommunicationMessage::~CommunicationMessage() {}
-
-void CommunicationMessage::setSendRequestFromPointer(uint32_t address,
-		uint32_t dataLen, const uint8_t * data) {
-	setMessageType(SEND_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(SEND_DATA_FROM_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-
-void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length,
-		uint16_t sendBufferPosition) {
-	setMessageType(SEND_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(sendBufferPosition != 0) {
-		setBufferPosition(sendBufferPosition);
-	}
-}
-
-void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) {
-	setMessageType(REPLY_DATA_IPC_STORE);
-	setAddress(address);
-	setStoreId(storeId.raw);
-}
-void CommunicationMessage::setDataReplyFromPointer(uint32_t address,
-		uint32_t dataLen, uint8_t *data) {
-	setMessageType(REPLY_DATA_FROM_POINTER);
-	setAddress(address);
-	setDataLen(dataLen);
-	setDataPointer(data);
-}
-
-void CommunicationMessage::setDataReplyRaw(uint32_t address,
-		uint32_t length, uint16_t receiveBufferPosition) {
-	setMessageType(REPLY_DATA_RAW);
-	setAddress(address);
-	setDataLen(length);
-	if(receiveBufferPosition != 0) {
-		setBufferPosition(receiveBufferPosition);
-	}
-}
-
-void CommunicationMessage::setMessageType(messageType status) {
-	uint8_t status_uint8 = status;
-	memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8));
-}
-
-void CommunicationMessage::setAddress(address_t address) {
-	memcpy(getData(),&address,sizeof(address));
-}
-
-address_t CommunicationMessage::getAddress() const {
-	address_t address;
-	memcpy(&address,getData(),sizeof(address));
-	return address;
-}
-
-void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t),
-			&bufferPosition, sizeof(bufferPosition));
-}
-
-uint16_t CommunicationMessage::getBufferPosition() const {
-	uint16_t bufferPosition;
-	memcpy(&bufferPosition,
-			getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition));
-	return bufferPosition;
-}
-
-void CommunicationMessage::setDataPointer(const void * data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t));
-}
-
-void CommunicationMessage::setStoreId(store_address_t storeId) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t));
-}
-
-store_address_t CommunicationMessage::getStoreId() const{
-	store_address_t temp;
-	memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t));
-	return temp;
-}
-
-void CommunicationMessage::setDataLen(uint32_t length) {
-	memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length));
-}
-
-uint32_t CommunicationMessage::getDataLen() const {
-	uint32_t len;
-	memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len));
-	return len;
-}
-
-void CommunicationMessage::setUint32Data(uint32_t data) {
-	memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data));
-}
-
-uint32_t CommunicationMessage::getUint32Data() const{
-	uint32_t data;
-	memcpy(&data,getData() + 3 * sizeof(uint32_t),  sizeof(data));
-	return data;
-}
-
-void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) {
-	if(position <= 3) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-uint8_t CommunicationMessage::getDataByte(uint8_t position) const {
-	if(position <= 3) {
-		uint8_t byte;
-		memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte));
-		return byte;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) {
-	if(position == 0 || position == 1) {
-		memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data));
-	}
-	else {
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-
-}
-
-uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{
-	if(position == 0 || position == 1) {
-		uint16_t data;
-		memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data));
-		return data;
-	}
-	else {
-		return 0;
-		sif::error << "Comm Message: Invalid byte position" << std::endl;
-	}
-}
-
-CommunicationMessage::messageType CommunicationMessage::getMessageType() const{
-	messageType messageType;
-	memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t));
-	return messageType;
-}
-
-void CommunicationMessage::setMessageId(uint8_t messageId) {
-	memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId));
-}
-
-uint8_t CommunicationMessage::getMessageId() const {
-	uint8_t messageId;
-	memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId));
-	return messageId;
-}
-
-void CommunicationMessage::clearCommunicationMessage() {
-	messageType messageType = getMessageType();
-	switch(messageType) {
-	case(messageType::REPLY_DATA_IPC_STORE):
-	case(messageType::SEND_DATA_FROM_IPC_STORE): {
-		store_address_t storeId = getStoreId();
-		StorageManagerIF *ipcStore = objectManager->
-				get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(storeId);
-		}
-	}
-	/* NO BREAK falls through*/
-	default:
-		memset(getData(),0,4*sizeof(uint32_t));
-		break;
-	}
-}
-
diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h
deleted file mode 100644
index 5b429d9a..00000000
--- a/devicehandlers/CommunicationMessage.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
- * @file CommunicationMessage.h
- *
- * @date 28.02.2020
- */
-
-#ifndef FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#define FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_
-#include "../devicehandlers/CommunicationMessage.h"
-
-#include "../ipc/MessageQueueMessage.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../devicehandlers/DeviceHandlerBase.h"
-
-/**
- * @brief Message type to send larger messages
- *
- * @details
- * Can be used to pass information like data pointers and
- * data sizes between communication tasks.
- *
- */
-class CommunicationMessage: public MessageQueueMessage {
-public:
-	enum messageType {
-		NONE,
-		SEND_DATA_FROM_POINTER,
-		SEND_DATA_FROM_IPC_STORE,
-		SEND_DATA_RAW,
-		REPLY_DATA_FROM_POINTER,
-		REPLY_DATA_IPC_STORE,
-		REPLY_DATA_RAW,
-		FAULTY,
-	};
-
-	//Add other messageIDs here if necessary.
-	static const uint8_t COMMUNICATION_MESSAGE_SIZE = HEADER_SIZE + 4 * sizeof(uint32_t);
-
-	CommunicationMessage();
-	virtual ~CommunicationMessage();
-
-	/**
-	 * Message Type is stored as the fifth byte of the message data
-	 * @param status
-	 */
-	void setMessageType(messageType status);
-	messageType getMessageType() const;
-
-	/**
-	 * This is a unique ID which can be used to handle different kinds of messages.
-	 * For example, the same interface (e.g. SPI) could be used to exchange raw data
-	 * (e.g. sensor values) and data stored in the IPC store.
-	 * The ID can be used to distinguish the messages in child implementations.
-	 * The message ID is stored as the sixth byte of the message data.
-	 * @param messageId
-	 */
-	void setMessageId(uint8_t messageId);
-	uint8_t getMessageId() const;
-
-	/**
-	 * Send requests with pointer to the data to be sent and send data length
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestFromPointer(uint32_t address, uint32_t dataLen, const uint8_t * data);
-
-	/**
-	 * Send requests with a store ID, using the IPC store
-	 * @param address Target Address, first four bytes
-	 * @param storeId Store ID in the IPC store
-	 *
-	 */
-	void setSendRequestFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Send requests with data length and data in message (max. 4 bytes)
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to data to send
-	 *
-	 */
-	void setSendRequestRaw(uint32_t address, uint32_t length,
-			uint16_t sendBufferPosition = 0);
-
-	/**
-	 * Data message with data stored in IPC store
-	 * @param address Target Address, first four bytes
-	 * @param length
-	 * @param storeId
-	 */
-	void setDataReplyFromIpcStore(uint32_t address, store_address_t storeId);
-
-	/**
-	 * Data reply with data stored in buffer, passing the pointer to
-	 * the buffer and the data size
-	 * @param address Target Address, first four bytes
-	 * @param dataLen Length of data to send, next four bytes
-	 * @param data Pointer to the data
-	 */
-	void setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t * data);
-
-	/**
-	 * Data message with data stored in actual message.
-	 * 4 byte datafield is intialized with 0.
-	 * Set data with specific setter functions below.
-	 * Can also be used to supply information at which position the raw data should be stored
-	 * in a receive buffer.
-	 */
-	void setDataReplyRaw(uint32_t address, uint32_t length, uint16_t receiveBufferPosition = 0);
-
-	/**
-	 * First four bytes of message data
-	 * @param address
-	 */
-	void setAddress(address_t address);
-
-	address_t getAddress() const;
-	/**
-	 * Set byte as position of 4 byte data field
-	 * @param byte
-	 * @param position Position, 0 to 3 possible
-	 */
-	void setDataByte(uint8_t byte, uint8_t position);
-	uint8_t getDataByte(uint8_t position) const;
-
-	/**
-	 * Set 2 byte value at position 1 or 2 of data field
-	 * @param data
-	 * @param position 0 or 1 possible
-	 */
-	void setDataUint16(uint16_t data, uint8_t position);
-	uint16_t getDataUint16(uint8_t position) const;
-
-	void setUint32Data(uint32_t data);
-	uint32_t getUint32Data() const;
-
-	/**
-	 * Stored in Bytes 13-16 of message data
-	 * @param length
-	 */
-	void setDataLen(uint32_t length);
-
-	uint32_t getDataLen() const;
-
-	/**
-	 * Stored in last four bytes (Bytes 17-20) of message data
-	 * @param sendData
-	 */
-	void setDataPointer(const void * data);
-
-	/**
-	 * In case the send request data or reply data is to be stored in a buffer,
-	 * a buffer Position can be stored here as the seventh and eigth byte of
-	 * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now.
-	 * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here
-	 */
-	void setBufferPosition(uint16_t bufferPosition);
-	uint16_t getBufferPosition() const;
-	void setStoreId(store_address_t storeId);
-	store_address_t getStoreId() const;
-
-	/**
-	 * Clear the message. Deletes IPC Store data
-	 * and sets all data to 0. Also sets message type to NONE
-	 */
-	void clearCommunicationMessage();
-private:
-	bool uninitialized; //!< Could be used to warn if data has not been set.
-};
-
-#endif /* FRAMEWORK_DEVICEHANDLERS_COMMUNICATIONMESSAGE_H_ */
diff --git a/devicehandlers/CookieIF.h b/devicehandlers/CookieIF.h
index 5fbcd198..5911bfdb 100644
--- a/devicehandlers/CookieIF.h
+++ b/devicehandlers/CookieIF.h
@@ -1,11 +1,12 @@
-#ifndef COOKIE_H_
-#define COOKIE_H_
+#ifndef FSFW_DEVICEHANDLER_COOKIE_H_
+#define FSFW_DEVICEHANDLER_COOKIE_H_
+
 #include <cstdint>
 
 /**
  * @brief Physical address type
  */
-typedef std::uint32_t address_t;
+using address_t = uint32_t;
 
 /**
  * @brief 	This datatype is used to identify different connection over a
@@ -30,4 +31,4 @@ public:
 	virtual ~CookieIF() {};
 };
 
-#endif /* COOKIE_H_ */
+#endif /* FSFW_DEVICEHANDLER_COOKIE_H_ */
diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h
index db37eade..e0b473d3 100644
--- a/devicehandlers/DeviceCommunicationIF.h
+++ b/devicehandlers/DeviceCommunicationIF.h
@@ -1,8 +1,9 @@
-#ifndef FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
-#define FRAMEWORK_DEVICES_DEVICECOMMUNICATIONIF_H_
+#ifndef FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+#define FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_
+
+#include "CookieIF.h"
+#include "DeviceHandlerIF.h"
 
-#include "../devicehandlers/CookieIF.h"
-#include "../devicehandlers/DeviceHandlerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 /**
  * @defgroup interfaces Interfaces
@@ -124,4 +125,4 @@ public:
 	        uint8_t **buffer, size_t *size) = 0;
 };
 
-#endif /* DEVICECOMMUNICATIONIF_H_ */
+#endif /* FSFW_DEVICES_DEVICECOMMUNICATIONIF_H_ */
diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp
index 25d8932f..c70f57d6 100644
--- a/devicehandlers/DeviceTmReportingWrapper.cpp
+++ b/devicehandlers/DeviceTmReportingWrapper.cpp
@@ -1,5 +1,4 @@
-#include "../serialize/SerializeAdapter.h"
-#include "../devicehandlers/DeviceTmReportingWrapper.h"
+#include "DeviceTmReportingWrapper.h"
 #include "../serialize/SerializeAdapter.h"
 
 DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId,
diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h
index a14c4261..447e95f2 100644
--- a/devicehandlers/DeviceTmReportingWrapper.h
+++ b/devicehandlers/DeviceTmReportingWrapper.h
@@ -1,5 +1,5 @@
-#ifndef DEVICETMREPORTINGWRAPPER_H_
-#define DEVICETMREPORTINGWRAPPER_H_
+#ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
+#define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
 #include "../action/HasActionsIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -24,4 +24,4 @@ private:
 	SerializeIF *data;
 };
 
-#endif /* DEVICETMREPORTINGWRAPPER_H_ */
+#endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 666f86bb..8b7d7f23 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -1,11 +1,12 @@
-#include "../devicehandlers/HealthDevice.h"
+#include "HealthDevice.h"
 #include "../ipc/QueueFactory.h"
 
 HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3, CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3,
+	        CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
 }
 
 HealthDevice::~HealthDevice() {
diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h
index 53b0ab09..738f0c7e 100644
--- a/devicehandlers/HealthDevice.h
+++ b/devicehandlers/HealthDevice.h
@@ -1,5 +1,5 @@
-#ifndef HEALTHDEVICE_H_
-#define HEALTHDEVICE_H_
+#ifndef FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
+#define FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_
 
 #include "../health/HasHealthIF.h"
 #include "../health/HealthHelper.h"
@@ -37,4 +37,4 @@ public:
 	HealthHelper healthHelper;
 };
 
-#endif /* HEALTHDEVICE_H_ */
+#endif /* FSFW_DEVICEHANDLERS_HEALTHDEVICE_H_ */

From 3af79e572ef34c8508b9d6f6315893952cfacda5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 12 Oct 2020 18:19:11 +0200
Subject: [PATCH 0891/1292] default msg size for health device

---
 devicehandlers/HealthDevice.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index 8b7d7f23..418ed257 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -5,8 +5,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId,
 		MessageQueueId_t parentQueue) :
 		SystemObject(setObjectId), lastHealth(HEALTHY), parentQueue(
 				parentQueue), commandQueue(), healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(3,
-	        CommandMessage::MINIMUM_COMMAND_MESSAGE_SIZE);
+	commandQueue = QueueFactory::instance()->createMessageQueue(3);
 }
 
 HealthDevice::~HealthDevice() {

From 72ca2bfa43e56a98a7462f9a372fe290c7e67e5e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 00:50:24 +0200
Subject: [PATCH 0892/1292] added new messages

---
 datapoollocal/HasLocalDataPoolIF.h          | 28 ++++++--
 datapoollocal/LocalDataPoolManager.h        | 69 ++++++++++++++++---
 datapoollocal/locPoolDefinitions.h          | 51 ++++++++++++++
 housekeeping/AcceptsHkPacketsIF.h           |  1 +
 housekeeping/HousekeepingMessage.cpp        | 57 +++++++++++++++-
 housekeeping/HousekeepingMessage.h          | 75 +++++++++------------
 housekeeping/PeriodicHousekeepingHelper.cpp |  3 +-
 7 files changed, 224 insertions(+), 60 deletions(-)
 create mode 100644 datapoollocal/locPoolDefinitions.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index f8f4ef4c..acb3d773 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "locPoolDefinitions.h"
+
 #include "../datapool/PoolEntryIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
@@ -10,10 +12,6 @@
 class LocalDataPoolManager;
 class LocalPoolDataSetBase;
 
-/**
- * @brief	Type definition for local pool entries.
- */
-using lp_id_t = uint32_t;
 using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
 
@@ -78,6 +76,28 @@ public:
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed datasets.
+     * @param sid
+     */
+    virtual void handleChangedDatasetOrVariable(sid_t sid) {
+        return;
+    }
+
+    /**
+     * @brief   This function will be called by the manager if an update
+     *          notification is received.
+     * @details
+     * Can be overriden by the child class to handle changed pool IDs.
+     * @param sid
+     */
+    virtual void handleChangedPoolVariable(lp_id_t poolId) {
+        return;
+    }
+
 	/* These function can be implemented by pool owner, as they are required
 	 * by the housekeeping message interface */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 779e3050..84a0d31e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -91,7 +91,8 @@ public:
 	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
 
     /**
-     * This should be called in the periodic handler of the owner.
+     * @brief   This should be called in the periodic handler of the owner.
+     * @details
      * It performs all the periodic functionalities of the data pool manager,
      * for example generating periodic HK packets.
      * @return
@@ -99,12 +100,47 @@ public:
     ReturnValue_t performHkOperation();
 
 	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This will most commonly be used to generate housekeeping packets
+	 * which are downlinked directly.
 	 * @return
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
 			object_id_t packetDestination = defaultHkDestination);
 
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool isDiagnostics,
+            object_id_t packetDestination = defaultHkDestination);
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @param sid
+	 * @param targetQueueId
+	 * @return
+	 */
+	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
+	        MessageQueueId_t targetQueueId);
+
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @param sid
+     * @param targetQueueId
+     * @return
+     */
+    ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
+            MessageQueueId_t targetQueueId);
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -116,6 +152,19 @@ public:
 	 */
 	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
 
+    /**
+     * @brief   The manager is also able to handle housekeeping messages.
+     * @details
+     * This most commonly is used to handle messages for the housekeeping
+     * interface, but the manager is also able to handle update notifications
+     * and calls a special function which can be overriden by a child class
+     * to handle data set or pool variable updates. This is relevant
+     * for classes like controllers which have their own local datapool
+     * but pull their data from other local datapools.
+     * @param message
+     * @return
+     */
+    ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.
@@ -126,16 +175,6 @@ public:
 			LocalPoolDataSetBase* dataSet, bool forDownlink,
 			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
 
-	ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * This function is used to fill the local data pool map with pool
-	 * entries. It should only be called once by the pool owner.
-	 * @param localDataPoolMap
-	 * @return
-	 */
-	ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
 	HasLocalDataPoolIF* getOwner();
 
 	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
@@ -255,6 +294,14 @@ private:
 	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
 			PoolEntry<T> **poolEntry);
 
+    /**
+     * This function is used to fill the local data pool map with pool
+     * entries. It should only be called once by the pool owner.
+     * @param localDataPoolMap
+     * @return
+     */
+    ReturnValue_t initializeHousekeepingPoolEntriesOnce();
+
 	ReturnValue_t serializeHkPacketIntoStore(
 	        HousekeepingPacketDownlink& hkPacket,
 	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
new file mode 100644
index 00000000..d1493059
--- /dev/null
+++ b/datapoollocal/locPoolDefinitions.h
@@ -0,0 +1,51 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+
+#include <cstdint>
+#include "../objectmanager/SystemObjectIF.h"
+#include "../objectmanager/frameworkObjects.h"
+
+/**
+ * @brief   Type definition for local pool entries.
+ */
+using lp_id_t = uint32_t;
+
+
+union sid_t {
+    static constexpr uint64_t INVALID_SID = -1;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    sid_t(): raw(INVALID_SID) {}
+
+    sid_t(object_id_t objectId, uint32_t setId):
+            objectId(objectId),
+            ownerSetId(setId) {}
+
+    struct {
+        object_id_t objectId ;
+        /**
+         * A generic 32 bit ID to identify unique HK packets for a single
+         * object. For example, the DeviceCommandId_t is used for
+         * DeviceHandlers
+         */
+        uint32_t ownerSetId;
+    };
+    /**
+     * Alternative access to the raw value. This is also the size of the type.
+     */
+    uint64_t raw;
+
+    bool notSet() const {
+        return raw == INVALID_SID;
+    }
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
diff --git a/housekeeping/AcceptsHkPacketsIF.h b/housekeeping/AcceptsHkPacketsIF.h
index b3ba6e7c..6fa151b1 100644
--- a/housekeeping/AcceptsHkPacketsIF.h
+++ b/housekeeping/AcceptsHkPacketsIF.h
@@ -1,5 +1,6 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
 #define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
+
 #include "../ipc/MessageQueueMessageIF.h"
 
 class AcceptsHkPacketsIF {
diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp
index d2ab546b..221f0a6f 100644
--- a/housekeeping/HousekeepingMessage.cpp
+++ b/housekeeping/HousekeepingMessage.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/objectmanager/ObjectManagerIF.h>
 #include "HousekeepingMessage.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 #include <cstring>
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -148,7 +149,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(DIAGNOSTICS_REPORT):
     case(HK_DEFINITIONS_REPORT):
     case(DIAGNOSTICS_DEFINITION_REPORT):
-    case(UPDATE_SNAPSHOT): {
+    case(UPDATE_SNAPSHOT_SET): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
         StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
@@ -160,3 +161,55 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     }
     message->setCommand(CommandMessage::CMD_NONE);
 }
+
+void HousekeepingMessage::setUpdateNotificationSetCommand(
+        CommandMessage *command, sid_t sid) {
+    command->setCommand(UPDATE_NOTIFICATION_SET);
+    setSid(command, sid);
+}
+
+void HousekeepingMessage::setUpdateNotificationVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId) {
+    command->setCommand(UPDATE_NOTIFICATION_VARIABLE);
+    command->setParameter(localPoolId);
+}
+
+void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command,
+        sid_t sid, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    setSid(command, sid);
+    command->setParameter3(storeId.raw);
+}
+
+void HousekeepingMessage::setUpdateSnapshotVariableCommand(
+        CommandMessage *command, lp_id_t localPoolId, store_address_t storeId) {
+    command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
+    command->setParameter(localPoolId);
+    command->setParameter3(storeId.raw);
+}
+
+sid_t HousekeepingMessage::getUpdateNotificationSetCommand(
+        const CommandMessage *command) {
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
+        const CommandMessage *command) {
+    return command->getParameter();
+}
+
+sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return getSid(command);
+}
+
+lp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(
+        const CommandMessage *command, store_address_t *storeId) {
+    if(storeId != nullptr) {
+        *storeId = command->getParameter3();
+    }
+    return command->getParameter();
+}
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 6dc95f54..70711be9 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,49 +1,12 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
-#include "../objectmanager/SystemObjectIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 
-union sid_t {
-	static constexpr uint64_t INVALID_SID = -1;
-	static constexpr uint32_t INVALID_SET_ID = -1;
-	static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-	sid_t(): raw(INVALID_SID) {}
-
-	sid_t(object_id_t objectId, uint32_t setId):
-			objectId(objectId),
-			ownerSetId(setId) {}
-
-	struct {
-		object_id_t objectId ;
-		/**
-		 * A generic 32 bit ID to identify unique HK packets for a single
-		 * object. For example, the DeviceCommandId_t is used for
-		 * DeviceHandlers
-		 */
-		uint32_t ownerSetId;
-	};
-	/**
-	 * Alternative access to the raw value. This is also the size of the type.
-	 */
-	uint64_t raw;
-
-	bool notSet() const {
-	    return raw == INVALID_SID;
-	}
-
-	bool operator==(const sid_t& other) const {
-		return raw == other.raw;
-	}
-
-	bool operator!=(const sid_t& other) const {
-		return not (raw == other.raw);
-	}
-};
-
 
 /**
  * @brief	Special command message type for housekeeping messages
@@ -101,14 +64,20 @@ public:
 	static constexpr Command_t HK_REQUEST_FAILURE =
 			MAKE_COMMAND_ID(129);
 
-	static constexpr Command_t UPDATE_NOTIFICATION = MAKE_COMMAND_ID(130);
-	static constexpr Command_t UPDATE_SNAPSHOT = MAKE_COMMAND_ID(131);
+	static constexpr Command_t UPDATE_NOTIFICATION_SET =
+	        MAKE_COMMAND_ID(130);
+	static constexpr Command_t UPDATE_NOTIFICATION_VARIABLE =
+	        MAKE_COMMAND_ID(131);
 
-	static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_SET = MAKE_COMMAND_ID(132);
+	static constexpr Command_t UPDATE_SNAPSHOT_VARIABLE = MAKE_COMMAND_ID(133);
+
+	//static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134);
 
 	static sid_t getSid(const CommandMessage* message);
 
-	/** Setter functions */
+	/* Housekeeping Interface Messages */
+
 	static void setToggleReportingCommand(CommandMessage* command, sid_t sid,
 			bool enableReporting, bool isDiagnostics);
 	static void setStructureReportingCommand(CommandMessage* command, sid_t sid,
@@ -148,6 +117,28 @@ public:
 	static sid_t getCollectionIntervalModificationCommand(
 			const CommandMessage* command, float* newCollectionInterval);
 
+
+    /* Update Notification Messages */
+
+    static void setUpdateNotificationSetCommand(CommandMessage* command,
+            sid_t sid);
+    static void setUpdateNotificationVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId);
+
+    static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid,
+            store_address_t storeId);
+    static void setUpdateSnapshotVariableCommand(CommandMessage* command,
+            lp_id_t localPoolId, store_address_t storeId);
+
+    sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+    lp_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
+
+    sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+            store_address_t* storeId);
+    lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+            store_address_t* storeId);
+
+    /** Utility */
 	static void clear(CommandMessage* message);
 private:
 	static void setSid(CommandMessage* message, sid_t sid);
diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp
index 37349f81..365f0004 100644
--- a/housekeeping/PeriodicHousekeepingHelper.cpp
+++ b/housekeeping/PeriodicHousekeepingHelper.cpp
@@ -1,5 +1,6 @@
-#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "PeriodicHousekeepingHelper.h"
+
+#include "../datapoollocal/LocalPoolDataSetBase.h"
 #include <cmath>
 
 PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(

From 9ca086e0269c5a09bea5dc992c9050fcd24e0dad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 01:25:15 +0200
Subject: [PATCH 0893/1292] base class extraction complete

---
 datapoollocal/LocalDataPoolManager.cpp | 46 ++++++++++++++++--
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolDataSetBase.h   |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp  | 67 ++++++++++++++++++++++++++
 datapoollocal/LocalPoolObjectBase.h    | 58 ++++++++++++++++++++++
 datapoollocal/LocalPoolVariable.h      | 21 +-------
 datapoollocal/LocalPoolVariable.tpp    | 65 +------------------------
 datapoollocal/LocalPoolVector.h        | 48 ++----------------
 datapoollocal/LocalPoolVector.tpp      | 62 +-----------------------
 9 files changed, 179 insertions(+), 192 deletions(-)
 create mode 100644 datapoollocal/LocalPoolObjectBase.cpp
 create mode 100644 datapoollocal/LocalPoolObjectBase.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4f124e7f..45ad7647 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -88,9 +88,8 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
     for(auto& receiver: hkReceiversMap) {
-        //HkReceiver* receiver = &hkReceiversIter.second;
-
         switch(receiver.reportingType) {
         case(ReportingType::PERIODIC): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
@@ -100,8 +99,46 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             performPeriodicHkGeneration(receiver);
             break;
         }
+        case(ReportingType::UPDATE_HK): {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                // Periodic packets shall only be generated from datasets.
+                continue;
+            }
+            LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                    receiver.dataId.sid);
+            if(dataSet->hasChanged()) {
+                // prepare and send update notification
+                ReturnValue_t result = generateHousekeepingPacket(
+                            receiver.dataId.sid, dataSet, true);
+                if(result != HasReturnvaluesIF::RETURN_OK) {
+                    status = result;
+                }
+            }
+            break;
+        }
+        case(ReportingType::UPDATE_NOTIFICATION): {
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+            }
+            else {
+                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                        receiver.dataId.sid);
+                if(dataSet->hasChanged()) {
+                    // prepare and send update notification
+                }
+            }
+            break;
+        }
         case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
+            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+            }
+            else {
+                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                        receiver.dataId.sid);
+                if(dataSet->hasChanged()) {
+                    // prepare and send update snapshot.
+                }
+            }
             break;
         }
         default:
@@ -109,7 +146,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
-    return HasReturnvaluesIF::RETURN_OK;
+    return status;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
@@ -368,8 +405,7 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
     // Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = dynamic_cast<LocalPoolDataSetBase*>(
-			owner->getDataSetHandle(sid));
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet == nullptr) {
 		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
 				<< " Set ID not found" << std::endl;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index da0a86b2..e9adaa5a 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -226,7 +226,7 @@ void LocalPoolDataSetBase::setChanged(bool changed) {
 	this->changed = changed;
 }
 
-bool LocalPoolDataSetBase::isChanged() const {
+bool LocalPoolDataSetBase::hasChanged() const {
 	return changed;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d00af992..2774f507 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -117,7 +117,7 @@ public:
 	bool isValid() const override;
 
 	void setChanged(bool changed);
-	bool isChanged() const;
+	bool hasChanged() const;
 
 protected:
 	sid_t sid;
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
new file mode 100644
index 00000000..b6302e7e
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -0,0 +1,67 @@
+#include "LocalPoolObjectBase.h"
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
+        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+                << "owner is a invalid!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if (dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
+    }
+    HasLocalDataPoolIF* hkOwner =
+            objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement the correct interface"
+                << " HasLocalDataPoolIF!" << std::endl;
+        return;
+    }
+    hkManager = hkOwner->getHkManagerHandle();
+    if(dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
+}
+
+pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
+    return readWriteMode;
+}
+
+bool LocalPoolObjectBase::isValid() const {
+    return valid;
+}
+
+void LocalPoolObjectBase::setValid(bool valid) {
+    this->valid = valid;
+}
+
+lp_id_t LocalPoolObjectBase::getDataPoolId() const {
+    return localPoolId;
+}
+
+void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
+    this->localPoolId = poolId;
+}
+
+void LocalPoolObjectBase::setChanged(bool changed) {
+    this->changed = changed;
+}
+
+bool LocalPoolObjectBase::hasChanged() const {
+    return changed;
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
new file mode 100644
index 00000000..8445b764
--- /dev/null
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -0,0 +1,58 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
+
+#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapool/PoolVariableIF.h"
+
+class LocalPoolObjectBase: public PoolVariableIF, HasReturnvaluesIF {
+public:
+    LocalPoolObjectBase(lp_id_t poolId,
+            HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+            pool_rwm_t setReadWriteMode);
+
+    LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+    pool_rwm_t getReadWriteMode() const;
+
+    bool isValid() const override;
+    void setValid(bool valid) override;
+
+    void setChanged(bool changed);
+    bool hasChanged() const;
+
+    lp_id_t getDataPoolId() const override;
+    void setDataPoolId(lp_id_t poolId);
+
+protected:
+    /**
+     * @brief   To access the correct data pool entry on read and commit calls,
+     *          the data pool id is stored.
+     */
+    uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
+    /**
+     * @brief   The valid information as it was stored in the data pool
+     *          is copied to this attribute.
+     */
+    bool valid = false;
+
+    /**
+     * @brief   A local pool variable can be marked as changed.
+     */
+    bool changed = false;
+
+    /**
+     * @brief   The information whether the class is read-write or
+     *          read-only is stored here.
+     */
+    ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+
+    //! @brief  Pointer to the class which manages the HK pool.
+    LocalDataPoolManager* hkManager;
+
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index ec5c8cd1..e9d94178 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
+#include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 
@@ -21,7 +22,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public PoolVariableIF, HasReturnvaluesIF {
+class LocalPoolVar: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVar() = delete;
@@ -76,15 +77,6 @@ public:
 	 */
 	T value = 0;
 
-	pool_rwm_t getReadWriteMode() const override;
-
-	lp_id_t getDataPoolId() const override;
-	void setDataPoolId(lp_id_t poolId);
-
-	bool isValid() const override;
-	void setValid(bool validity) override;
-	uint8_t getValid() const;
-
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
 	        SerializeIF::Endianness streamEndianness) const override;
 	virtual size_t getSerializedSize() const override;
@@ -145,15 +137,6 @@ protected:
 			const LocalPoolVar<U> &var);
 
 private:
-	//! @brief 	Pool ID of pool entry inside the used local pool.
-	lp_id_t localPoolId = PoolVariableIF::NO_PARAMETER;
-	//! @brief 	Read-write mode of the pool variable
-	pool_rwm_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-	//! @brief 	Specifies whether the entry is valid or invalid.
-	bool valid = false;
-
-	//! Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b0bdd7b9..3320aa5a 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -9,43 +9,12 @@ template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-		        << "which is the NO_PARAMETER value!" << std::endl;
-	}
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-		        << "owner is a invalid!" << std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-	    dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement  the correct interface "
-                << "HasLocalDataPoolIF!" << std::endl;
-        return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+        LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
@@ -111,36 +80,6 @@ inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
 }
 
 
-template<typename T>
-inline pool_rwm_t LocalPoolVar<T>::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-template<typename T>
-inline lp_id_t LocalPoolVar<T>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setDataPoolId(lp_id_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T>
-inline bool LocalPoolVar<T>::isValid() const {
-	return valid;
-}
-
-template<typename T>
-inline void LocalPoolVar<T>::setValid(bool validity) {
-	this->valid = validity;
-}
-
-template<typename T>
-inline uint8_t LocalPoolVar<T>::getValid() const {
-	return valid;
-}
-
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 57c4b90b..a7ebd3fe 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
+#include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
@@ -30,7 +31,7 @@
  * @ingroup data_pool
  */
 template<typename T, uint16_t vectorSize>
-class LocalPoolVector: public PoolVariableIF, public HasReturnvaluesIF {
+class LocalPoolVector: public LocalPoolObjectBase {
 public:
 	LocalPoolVector() = delete;
 	/**
@@ -48,8 +49,7 @@ public:
 	 */
 	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * This constructor is used by data users like controllers to have
@@ -67,8 +67,7 @@ public:
 	 */
 	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
 			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE
-			);
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -91,27 +90,6 @@ public:
 		return vectorSize;
 	}
 
-	uint32_t getDataPoolId() const override;
-	/**
-	 * @brief This operation sets the data pool ID of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	pool_rwm_t getReadWriteMode() const;
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-	void setValid(bool valid) override;
-	uint8_t getValid() const;
-
 	T& operator [](int i);
 	const T &operator [](int i) const;
 
@@ -168,23 +146,7 @@ protected:
 	ReturnValue_t commitWithoutLock() override;
 
 private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t localPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	bool valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-	//! @brief	Pointer to the class which manages the HK pool.
-	LocalDataPoolManager* hkManager;
+
 
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 2aa6fbb5..34720b97 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -9,39 +9,12 @@ template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), valid(false), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	std::memset(this->value, 0, vectorSize * sizeof(T));
-	hkManager = hkOwner->getHkManagerHandle();
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
-		sif::warning << "LocalPoolVector: PoolVariableIF::NO_PARAMETER passed "
-				<< "as pool ID, which is the NO_PARAMETER value!" << std::endl;
-	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
-		sif::error << "LocalPoolVariable: The supplied pool owner did not "
-				<< "implement the correct interface HasHkPoolParametersIF!"
-				<< std::endl;
-		return;
-	}
-	hkManager = hkOwner->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
+		LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
@@ -161,37 +134,6 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
-template<typename T, uint16_t vectorSize>
-inline pool_rwm_t LocalPoolVector<T, vectorSize>::getReadWriteMode() const {
-	return this->readWriteMode;
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline uint32_t LocalPoolVector<T, vectorSize>::getDataPoolId() const {
-	return localPoolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setDataPoolId(uint32_t poolId) {
-	this->localPoolId = poolId;
-}
-
-template<typename T, uint16_t vectorSize>
-inline void LocalPoolVector<T, vectorSize>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline uint8_t LocalPoolVector<T, vectorSize>::getValid() const {
-	return valid;
-}
-
-template<typename T, uint16_t vectorSize>
-inline bool LocalPoolVector<T, vectorSize>::isValid() const {
-	return valid;
-}
-
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {

From 45c0acec5f4744862a411c3b1852d6a7785f6b3c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 01:38:27 +0200
Subject: [PATCH 0894/1292] its all falling into places

---
 datapoollocal/HasLocalDataPoolIF.h     | 14 ++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp | 25 ++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index acb3d773..d7950b49 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -11,6 +11,7 @@
 
 class LocalDataPoolManager;
 class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
 
 using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
@@ -76,6 +77,19 @@ public:
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+	    return nullptr;
+	}
+
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 45ad7647..a33f19e5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,4 +1,5 @@
 #include "LocalDataPoolManager.h"
+#include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -101,7 +102,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         }
         case(ReportingType::UPDATE_HK): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
+                // Update packets shall only be generated from datasets.
                 continue;
             }
             LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -118,10 +119,21 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                        receiver.dataId.localPoolId);
+                if(poolObj == nullptr) {
+                    continue;
+                }
+                if(poolObj->hasChanged()) {
+                    // prepare and send update notification.
+                }
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                         receiver.dataId.sid);
+                if(dataSet == nullptr) {
+                    continue;
+                }
                 if(dataSet->hasChanged()) {
                     // prepare and send update notification
                 }
@@ -131,10 +143,21 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
         case(ReportingType::UPDATE_SNAPSHOT): {
             // check whether data has changed and send messages in case it has.
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                        receiver.dataId.localPoolId);
+                if(poolObj == nullptr) {
+                    continue;
+                }
+                if(poolObj->hasChanged()) {
+                    // prepare and send update snapshot.
+                }
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                         receiver.dataId.sid);
+                if(dataSet == nullptr) {
+                    continue;
+                }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
                 }

From 088bc35301dc87ebb7b4d30e789deda7264b973e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 12:42:30 +0200
Subject: [PATCH 0895/1292] update handler continued

---
 datapoollocal/LocalDataPoolManager.cpp | 154 +++++++++++++++++++++++++
 datapoollocal/LocalDataPoolManager.h   |  34 ++++--
 datapoollocal/LocalPoolDataSetBase.cpp |   8 ++
 datapoollocal/LocalPoolDataSetBase.h   |  16 ++-
 datapoollocal/LocalPoolObjectBase.h    |  10 +-
 datapoollocal/MarkChangedIF.h          |  17 +++
 6 files changed, 224 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/MarkChangedIF.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a33f19e5..a2a087e8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -115,9 +115,12 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     status = result;
                 }
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId,
+                    dataSet);
             break;
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
+            MarkChangedIF* toReset = nullptr;
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                         receiver.dataId.localPoolId);
@@ -125,8 +128,10 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(poolObj->hasChanged()) {
+
                     // prepare and send update notification.
                 }
+                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -135,12 +140,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(dataSet->hasChanged()) {
+
                     // prepare and send update notification
                 }
+                toReset = dataSet;
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
+            MarkChangedIF* toReset = nullptr;
             // check whether data has changed and send messages in case it has.
             if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
                 LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
@@ -151,6 +160,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
                 }
+                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -161,7 +171,9 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
                 }
+                toReset = dataSet;
             }
+            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
             break;
         }
         default:
@@ -169,9 +181,53 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
+    resetHkUpdateResetHelper();
     return status;
 }
 
+void LocalDataPoolManager::handleChangeResetLogic(
+        DataType type, DataId dataId, MarkChangedIF* toReset) {
+    if(hkUpdateResetList == nullptr) {
+        // config error!
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        if(changeInfo.dataType != type) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::DATA_SET) and
+                (changeInfo.dataId.sid != dataId.sid)) {
+            continue;
+        }
+        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+            continue;
+        }
+
+        if(changeInfo.updateCounter <= 1) {
+            toReset->setChanged(false);
+        }
+        if(changeInfo.currentUpdateCounter == 0) {
+            toReset->setChanged(false);
+        }
+        else {
+            changeInfo.currentUpdateCounter--;
+        }
+        return;
+    }
+}
+
+void LocalDataPoolManager::resetHkUpdateResetHelper() {
+    if(hkUpdateResetList == nullptr) {
+        return;
+    }
+
+    for(auto& changeInfo: *hkUpdateResetList) {
+        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+    }
+}
+
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 		bool enableReporting, float collectionInterval, bool isDiagnostics,
 		object_id_t packetDestination) {
@@ -186,6 +242,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataId.sid = sid;
 	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
 	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
@@ -200,6 +257,103 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
+        bool isDiagnostics, bool reportingEnabled,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+                objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::UPDATE_HK;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(true);
+        dataSet->setDiagnostic(isDiagnostics);
+    }
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
+        object_id_t destinationObject, MessageQueueId_t targetQueueId) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(
+        lp_id_t localPoolId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId) {
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+    hkReceiver.dataId.localPoolId = localPoolId;
+    hkReceiver.destinationQueue = targetQueueId;
+    hkReceiver.objectId = destinationObject;
+    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+
+    hkReceiversMap.push_back(hkReceiver);
+
+    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
+        DataId dataId) {
+    if(hkUpdateResetList == nullptr) {
+        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+    }
+
+    for(auto& updateResetStruct: *hkUpdateResetList) {
+        if(dataType == DataType::DATA_SET) {
+            if(updateResetStruct.dataId.sid == dataId.sid) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+        else {
+            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+                updateResetStruct.updateCounter++;
+                updateResetStruct.currentUpdateCounter++;
+                return;
+            }
+        }
+
+    }
+    HkUpdateResetHelper hkUpdateResetHelper;
+    hkUpdateResetHelper.currentUpdateCounter = 1;
+    hkUpdateResetHelper.updateCounter = 1;
+    hkUpdateResetHelper.dataType = dataType;
+    if(dataType == DataType::DATA_SET) {
+        hkUpdateResetHelper.dataId.sid = dataId.sid;
+    }
+    else {
+        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+    }
+    hkUpdateResetList->push_back(hkUpdateResetHelper);
+}
+
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 		CommandMessage* message) {
     Command_t command = message->getCommand();
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 84a0d31e..cc9364e7 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -118,7 +118,8 @@ public:
 	 * @param packetDestination
 	 * @return
 	 */
-    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool isDiagnostics,
+    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
+            bool isDiagnostics,
             object_id_t packetDestination = defaultHkDestination);
 
 	/**
@@ -129,7 +130,7 @@ public:
 	 * @return
 	 */
 	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
-	        MessageQueueId_t targetQueueId);
+	        object_id_t destinationObject, MessageQueueId_t targetQueueId);
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -139,7 +140,7 @@ public:
      * @return
      */
     ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
-            MessageQueueId_t targetQueueId);
+            object_id_t destinationObject, MessageQueueId_t targetQueueId);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -233,17 +234,18 @@ private:
 	static object_id_t defaultHkDestination;
 	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
 
+    union DataId {
+        DataId(): sid() {};
+        sid_t sid;
+        lp_id_t localPoolId;
+    };
+
     /** The data pool manager will keep an internal map of HK receivers. */
     struct HkReceiver {
 		/** Object ID of receiver */
 		object_id_t objectId = objects::NO_OBJECT;
 
 		DataType dataType = DataType::DATA_SET;
-        union DataId {
-			DataId(): sid() {};
-            sid_t sid;
-            lp_id_t localPoolId;
-        };
         DataId dataId;
 
         ReportingType reportingType = ReportingType::PERIODIC;
@@ -255,6 +257,17 @@ private:
 
     HkReceivers hkReceiversMap;
 
+    struct HkUpdateResetHelper {
+        DataType dataType = DataType::DATA_SET;
+        DataId dataId;
+        uint8_t updateCounter;
+        uint8_t currentUpdateCounter;
+    };
+
+    using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
+    // Will only be created when needed.
+    HkUpdateResetList* hkUpdateResetList = nullptr;
+
     /** This is the map holding the actual data. Should only be initialized
      * once ! */
     bool mapInitialized = false;
@@ -312,6 +325,11 @@ private:
 	ReturnValue_t changeCollectionInterval(sid_t sid,
 			float newCollectionInterval, bool isDiagnostics);
 	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
+
+	void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
+	void handleChangeResetLogic(DataType type,
+	        DataId dataId, MarkChangedIF* toReset);
+	void resetHkUpdateResetHelper();
 };
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index e9adaa5a..5bb71cb6 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -20,6 +20,8 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
+    mutex = MutexFactory::instance()->createMutex();
+
     // Data creators get a periodic helper for periodic HK data generation.
     if(not noPeriodicHandling) {
     	 periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -40,6 +42,8 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
+
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
@@ -223,10 +227,12 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	return changed;
 }
 
@@ -246,10 +252,12 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
 	if(setEntriesRecursively) {
 		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
 			registeredVariables[idx] -> setValid(valid);
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2774f507..aa155bf1 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -2,6 +2,8 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
 #include "HasLocalDataPoolIF.h"
+#include "MarkChangedIF.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 #include "../serialize/SerializeIF.h"
@@ -39,7 +41,8 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase: public PoolDataSetBase {
+class LocalPoolDataSetBase: public PoolDataSetBase,
+        public MarkChangedIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -109,18 +112,23 @@ public:
 	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
 	/**
-	 * Set the dataset valid or invalid
+	 * Set the dataset valid or invalid. These calls are mutex protected.
 	 * @param setEntriesRecursively
 	 * If this is true, all contained datasets will also be set recursively.
 	 */
 	void setValidity(bool valid, bool setEntriesRecursively);
 	bool isValid() const override;
 
-	void setChanged(bool changed);
-	bool hasChanged() const;
+	/**
+	 * These calls are mutex protected.
+	 * @param changed
+	 */
+	void setChanged(bool changed) override;
+	bool hasChanged() const override;
 
 protected:
 	sid_t sid;
+	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 8445b764..4d25b88a 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,10 +1,14 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include "MarkChangedIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../datapool/PoolVariableIF.h"
 
-class LocalPoolObjectBase: public PoolVariableIF, HasReturnvaluesIF {
+
+class LocalPoolObjectBase: public PoolVariableIF,
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
@@ -19,8 +23,8 @@ public:
     bool isValid() const override;
     void setValid(bool valid) override;
 
-    void setChanged(bool changed);
-    bool hasChanged() const;
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
 
     lp_id_t getDataPoolId() const override;
     void setDataPoolId(lp_id_t poolId);
diff --git a/datapoollocal/MarkChangedIF.h b/datapoollocal/MarkChangedIF.h
new file mode 100644
index 00000000..e575d1d3
--- /dev/null
+++ b/datapoollocal/MarkChangedIF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+#define FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_
+
+/**
+ * Common interface for local pool entities which can be marked as changed.
+ */
+class MarkChangedIF {
+public:
+    virtual~ MarkChangedIF() {};
+
+    virtual bool hasChanged() const = 0;
+    virtual void setChanged(bool changed) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_MARKCHANGEDIF_H_ */

From 5b96161331519c43d9ea8903d0ad7d7029d8f410 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 16:46:00 +0200
Subject: [PATCH 0896/1292] optimization and printout improvements

---
 datapoollocal/LocalDataPoolManager.cpp | 27 +++++++++++++------
 datapoollocal/LocalDataPoolManager.h   | 36 ++++++++++++++++++++------
 2 files changed, 47 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index a2a087e8..13225e78 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -287,14 +287,20 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
-        object_id_t destinationObject, MessageQueueId_t targetQueueId) {
+ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
+        const uint32_t setId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
     struct HkReceiver hkReceiver;
     hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid;
+    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
     hkReceiver.destinationQueue = targetQueueId;
     hkReceiver.objectId = destinationObject;
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
 
     hkReceiversMap.push_back(hkReceiver);
 
@@ -302,15 +308,20 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(sid_t sid,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::subscribeForUpdateMessages(
-        lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId) {
+ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
+        const lp_id_t localPoolId, object_id_t destinationObject,
+        MessageQueueId_t targetQueueId, bool generateSnapshot) {
     struct HkReceiver hkReceiver;
     hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
     hkReceiver.dataId.localPoolId = localPoolId;
     hkReceiver.destinationQueue = targetQueueId;
     hkReceiver.objectId = destinationObject;
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    if(generateSnapshot) {
+        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+    }
+    else {
+        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+    }
 
     hkReceiversMap.push_back(hkReceiver);
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cc9364e7..afe82760 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -102,8 +102,8 @@ public:
 	/**
 	 * @brief   Subscribe for the generation of periodic packets.
 	 * @details
-	 * This will most commonly be used to generate housekeeping packets
-	 * which are downlinked directly.
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
 	 * @return
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
@@ -113,6 +113,8 @@ public:
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
 	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
 	 * @param sid
 	 * @param isDiagnostics
 	 * @param packetDestination
@@ -125,22 +127,40 @@ public:
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
 	 *          if a dataset has changed.
-	 * @param sid
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
 	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
 	 * @return
 	 */
-	ReturnValue_t subscribeForUpdateMessages(sid_t sid,
-	        object_id_t destinationObject, MessageQueueId_t targetQueueId);
+	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+	        object_id_t destinationObject,
+	        MessageQueueId_t targetQueueId,
+	        bool generateSnapshot);
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
      *          pool variable has changed.
-     * @param sid
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
      * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
      * @return
      */
-    ReturnValue_t subscribeForUpdateMessages(lp_id_t localPoolId,
-            object_id_t destinationObject, MessageQueueId_t targetQueueId);
+    ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot);
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency

From a9a31308ae40618e49db5c6e98f131bfdebddcb7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 19:52:06 +0200
Subject: [PATCH 0897/1292] update notifications working

---
 datapoollocal/LocalDataPoolManager.cpp | 34 ++++++++++++++++++++------
 housekeeping/HousekeepingMessage.h     |  9 ++++---
 ipc/CommandMessageCleaner.cpp          |  2 +-
 pus/Service3Housekeeping.cpp           |  5 ++--
 4 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 13225e78..848ade5e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -128,10 +128,10 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(poolObj->hasChanged()) {
-
                     // prepare and send update notification.
+                    toReset = poolObj;
                 }
-                toReset = poolObj;
+
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -140,12 +140,22 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                     continue;
                 }
                 if(dataSet->hasChanged()) {
-
                     // prepare and send update notification
+                    CommandMessage notification;
+                    HousekeepingMessage::setUpdateNotificationSetCommand(
+                            &notification, receiver.dataId.sid);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
+                    toReset = dataSet;
                 }
-                toReset = dataSet;
             }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
+            if(toReset != nullptr) {
+                handleChangeResetLogic(receiver.dataType,
+                        receiver.dataId, toReset);
+            }
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
@@ -159,8 +169,8 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
+                    toReset = poolObj;
                 }
-                toReset = poolObj;
             }
             else {
                 LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
@@ -170,10 +180,13 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
+                    toReset = dataSet;
                 }
-                toReset = dataSet;
             }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
+            if(toReset != nullptr) {
+                handleChangeResetLogic(receiver.dataType,
+                        receiver.dataId, toReset);
+            }
             break;
         }
         default:
@@ -425,6 +438,11 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			dataSet, true);
     }
 
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+        owner->handleChangedDatasetOrVariable(sid);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
     default:
         return CommandMessageIF::UNKNOWN_COMMAND;
     }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 70711be9..90bbe594 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -130,12 +130,13 @@ public:
     static void setUpdateSnapshotVariableCommand(CommandMessage* command,
             lp_id_t localPoolId, store_address_t storeId);
 
-    sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
-    lp_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
+    static sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+    static lp_id_t getUpdateNotificationVariableCommand(
+            const CommandMessage* command);
 
-    sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+    static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
             store_address_t* storeId);
-    lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+    static lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
             store_address_t* storeId);
 
     /** Utility */
diff --git a/ipc/CommandMessageCleaner.cpp b/ipc/CommandMessageCleaner.cpp
index fa03a9a3..6a364069 100644
--- a/ipc/CommandMessageCleaner.cpp
+++ b/ipc/CommandMessageCleaner.cpp
@@ -12,7 +12,7 @@
 
 void CommandMessageCleaner::clearCommandMessage(CommandMessage* message) {
 	switch(message->getMessageType()){
-	case  messagetypes::MODE_COMMAND:
+	case messagetypes::MODE_COMMAND:
 		ModeMessage::clear(message);
 		break;
 	case messagetypes::HEALTH_COMMAND:
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 3f41f541..175af026 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -249,8 +249,9 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
-		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
-				<< "reply command " << command << "!" << std::endl;
+		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
+		        << "reply with " << "reply command " << command << "!"
+		        << std::endl;
 		return;
 	}
 

From ab603abada422d906a6cedb9d204ca2fe5e200ad Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 20:05:39 +0200
Subject: [PATCH 0898/1292] subscription mechanism almost complete

---
 datapoollocal/HasLocalDataPoolIF.h     | 10 ++++-
 datapoollocal/LocalDataPoolManager.cpp | 51 +++++++++++++++++++++++++-
 storagemanager/storeAddress.h          |  7 +++-
 3 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index d7950b49..9d4f2605 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -96,8 +96,11 @@ public:
      * @details
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
      */
-    virtual void handleChangedDatasetOrVariable(sid_t sid) {
+    virtual void handleChangedDataset(sid_t sid,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -107,8 +110,11 @@ public:
      * @details
      * Can be overriden by the child class to handle changed pool IDs.
      * @param sid
+     * @param storeId If a snapshot was requested, data will be located inside
+     * the IPC store with this store ID.
      */
-    virtual void handleChangedPoolVariable(lp_id_t poolId) {
+    virtual void handleChangedPoolVariable(lp_id_t poolId,
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 848ade5e..d89f597e 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -129,6 +129,14 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update notification.
+                    CommandMessage notification;
+                    HousekeepingMessage::setUpdateNotificationVariableCommand(
+                            &notification, receiver.dataId.localPoolId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = poolObj;
                 }
 
@@ -169,6 +177,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(poolObj->hasChanged()) {
                     // prepare and send update snapshot.
+                    CommandMessage notification;
+                    // todo: serialize into store with timestamp.
+                    store_address_t storeId;
+                    HousekeepingMessage::setUpdateSnapshotSetCommand(
+                            &notification, receiver.dataId.sid, storeId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = poolObj;
                 }
             }
@@ -180,6 +198,16 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
                 }
                 if(dataSet->hasChanged()) {
                     // prepare and send update snapshot.
+                    CommandMessage notification;
+                    // todo: serialize into store with timestamp.
+                    store_address_t storeId;
+                    HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                            &notification, receiver.dataId.localPoolId, storeId);
+                    ReturnValue_t result = hkQueue->sendMessage(
+                            receiver.destinationQueue, &notification);
+                    if(result != HasReturnvaluesIF::RETURN_OK) {
+                        status = result;
+                    }
                     toReset = dataSet;
                 }
             }
@@ -384,6 +412,7 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     sid_t sid = HousekeepingMessage::getSid(message);
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
+    // Houskeeping interface handling.
     case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
     	result = togglePeriodicGeneration(sid, true, true);
     	break;
@@ -438,8 +467,28 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     			dataSet, true);
     }
 
+    // Notification handling.
     case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDatasetOrVariable(sid);
+        owner->handleChangedDataset(sid);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+        lp_id_t locPoolId = HousekeepingMessage::
+                getUpdateNotificationVariableCommand(message);
+        owner->handleChangedPoolVariable(locPoolId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+        store_address_t storeId;
+        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+        owner->handleChangedDataset(sid, storeId);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+        store_address_t storeId;
+        lp_id_t localPoolId = HousekeepingMessage::
+                getUpdateSnapshotVariableCommand(message, &storeId);
+        owner->handleChangedPoolVariable(localPoolId, storeId);
         return HasReturnvaluesIF::RETURN_OK;
     }
 
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 044c0790..994998a6 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -3,16 +3,21 @@
 
 #include <cstdint>
 
+namespace storeId {
+static constexpr uint32_t INVALID_STORE_ADDRESS = 0xffffffff;
+}
+
 /**
  * This union defines the type that identifies where a data packet is
  * stored in the store. It comprises of a raw part to read it as raw value and
  * a structured part to use it in pool-like stores.
  */
 union store_address_t {
+
 	/**
 	 * Default Constructor, initializing to INVALID_ADDRESS
 	 */
-	store_address_t():raw(0xFFFFFFFF){}
+	store_address_t(): raw(storeId::INVALID_STORE_ADDRESS){}
 	/**
 	 * Constructor to create an address object using the raw address
 	 *

From 7bd536e76395a38a3a0cdecba436b7efccdc596e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:20:53 +0200
Subject: [PATCH 0899/1292] new templateless pool prototype

---
 events/EventManager.cpp                      |   9 +-
 events/EventManager.h                        |   4 +-
 storagemanager/ConstStorageAccessor.h        |   2 -
 storagemanager/LocalPool.cpp                 | 288 +++++++++++++++++++
 storagemanager/LocalPool.h                   | 167 ++++++-----
 storagemanager/PoolManager.cpp               |  51 ++++
 storagemanager/PoolManager.h                 |  11 +-
 storagemanager/StorageAccessor.h             |   2 -
 storagemanager/{ => archive}/LocalPool.tpp   |   0
 storagemanager/{ => archive}/PoolManager.tpp |   0
 storagemanager/storeAddress.h                |   6 +-
 tmtcpacket/packetmatcher/PacketMatchTree.cpp |  41 ++-
 tmtcpacket/packetmatcher/PacketMatchTree.h   |   3 +-
 13 files changed, 472 insertions(+), 112 deletions(-)
 create mode 100644 storagemanager/LocalPool.cpp
 create mode 100644 storagemanager/PoolManager.cpp
 rename storagemanager/{ => archive}/LocalPool.tpp (100%)
 rename storagemanager/{ => archive}/PoolManager.tpp (100%)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 0971dadc..289cb029 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,5 +1,4 @@
 #include "EventManager.h"
-#include "EventMessage.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -15,9 +14,15 @@ const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 // SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
+const LocalPool::LocalPoolConfig EventManager::poolConfig = {
+        LocalPool::LocalPoolCfgPair(sizeof(EventMatchTree::Node), 240),
+        LocalPool::LocalPoolCfgPair(sizeof(EventIdRangeMatcher), 120),
+        LocalPool::LocalPoolCfgPair(sizeof(ReporterRangeMatcher), 120)
+};
+
 EventManager::EventManager(object_id_t setObjectId) :
 		SystemObject(setObjectId),
-		factoryBackend(0, POOL_SIZES, N_ELEMENTS, false, true) {
+		factoryBackend(0, poolConfig, false, true) {
 	mutex = MutexFactory::instance()->createMutex();
 	eventReportQueue = QueueFactory::instance()->createMessageQueue(
 			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
diff --git a/events/EventManager.h b/events/EventManager.h
index f03c0241..fe35d9d3 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -51,7 +51,9 @@ protected:
 	MutexIF* mutex = nullptr;
 
 	static const uint8_t N_POOLS = 3;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
+	static const LocalPool::LocalPoolConfig poolConfig;
+
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 
diff --git a/storagemanager/ConstStorageAccessor.h b/storagemanager/ConstStorageAccessor.h
index 96d2dca2..570c20ce 100644
--- a/storagemanager/ConstStorageAccessor.h
+++ b/storagemanager/ConstStorageAccessor.h
@@ -20,9 +20,7 @@ class StorageManagerIF;
  */
 class ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	/**
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
new file mode 100644
index 00000000..67cdf447
--- /dev/null
+++ b/storagemanager/LocalPool.cpp
@@ -0,0 +1,288 @@
+#include "LocalPool.h"
+#include <FSFWConfig.h>
+#include <cstring>
+
+LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+            bool registered, bool spillsToHigherPools):
+            SystemObject(setObjectId), NUMBER_OF_POOLS(poolConfig.size()) {
+    uint16_t index = 0;
+    for (const auto& currentPoolConfig: poolConfig) {
+        this->elementSizes[index] = currentPoolConfig.first;
+        this->numberOfElements[index] = currentPoolConfig.second;
+        store[index] = std::vector<uint8_t>(
+                numberOfElements[index] * elementSizes[index]);
+        sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
+        //TODO checkme
+        for(auto& size: sizeLists[index]) {
+            size = STORAGE_FREE;
+        }
+//        std::memset(sizeLists[index], 0xff,
+//                numberOfElements[index] * sizeof(size_type));
+        index++;
+    }
+}
+
+LocalPool::~LocalPool(void) {}
+
+
+ReturnValue_t LocalPool::addData(store_address_t* storageId,
+        const uint8_t* data, size_t size, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        write(*storageId, data, size);
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t packetId,
+        const uint8_t **packetPtr, size_t *size) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(packetId, &tempData, size);
+    *packetPtr = tempData;
+    return status;
+}
+
+ReturnValue_t LocalPool::getData(store_address_t storeId,
+        ConstStorageAccessor& storeAccessor) {
+    uint8_t* tempData = nullptr;
+    ReturnValue_t status = modifyData(storeId, &tempData,
+            &storeAccessor.size_);
+    storeAccessor.assignStore(this);
+    storeAccessor.constDataPointer = tempData;
+    return status;
+}
+
+ConstAccessorPair LocalPool::getData(store_address_t storeId) {
+    uint8_t* tempData = nullptr;
+    ConstStorageAccessor constAccessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
+    constAccessor.constDataPointer = tempData;
+    return ConstAccessorPair(status, std::move(constAccessor));
+}
+
+ReturnValue_t LocalPool::getFreeElement(store_address_t *storageId,
+        const size_t size, uint8_t **pData, bool ignoreFault) {
+    ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
+    if (status == RETURN_OK) {
+        *pData = &store[storageId->poolIndex][getRawPosition(*storageId)];
+    }
+    else {
+        *pData = nullptr;
+    }
+    return status;
+}
+
+
+AccessorPair LocalPool::modifyData(store_address_t storeId) {
+    StorageAccessor accessor(storeId, this);
+    ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
+            &accessor.size_);
+    accessor.assignConstPointer();
+    return AccessorPair(status, std::move(accessor));
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        StorageAccessor& storeAccessor) {
+    storeAccessor.assignStore(this);
+    ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
+            &storeAccessor.size_);
+    storeAccessor.assignConstPointer();
+    return status;
+}
+
+ReturnValue_t LocalPool::modifyData(store_address_t storeId,
+        uint8_t **packetPtr, size_t *size) {
+    ReturnValue_t status = RETURN_FAILED;
+    if (storeId.poolIndex >= NUMBER_OF_POOLS) {
+        return ILLEGAL_STORAGE_ID;
+    }
+    if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
+        return ILLEGAL_STORAGE_ID;
+    }
+
+    if (sizeLists[storeId.poolIndex][storeId.packetIndex]
+            != STORAGE_FREE) {
+        uint32_t packetPosition = getRawPosition(storeId);
+        *packetPtr = &store[storeId.poolIndex][packetPosition];
+        *size = sizeLists[storeId.poolIndex][storeId.packetIndex];
+        status = RETURN_OK;
+    }
+    else {
+        status = DATA_DOES_NOT_EXIST;
+    }
+    return status;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+      sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
+              << " Index: " << storeId.packetIndex << std::endl;
+
+#endif
+    ReturnValue_t status = RETURN_OK;
+    size_type pageSize = getPageSize(storeId.poolIndex);
+    if ((pageSize != 0) and
+            (storeId.packetIndex < numberOfElements[storeId.poolIndex])) {
+        uint16_t packetPosition = getRawPosition(storeId);
+        uint8_t* ptr = &store[storeId.poolIndex][packetPosition];
+        std::memset(ptr, 0, pageSize);
+        //Set free list
+        sizeLists[storeId.poolIndex][storeId.packetIndex] = STORAGE_FREE;
+    }
+    else {
+        //pool_index or packet_index is too large
+        sif::error << "LocalPool:deleteData failed." << std::endl;
+        status = ILLEGAL_STORAGE_ID;
+    }
+    return status;
+}
+
+ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
+        store_address_t *storeId) {
+    store_address_t localId;
+    ReturnValue_t result = ILLEGAL_ADDRESS;
+    for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
+        //Not sure if new allocates all stores in order. so better be careful.
+        if ((store[n].data() <= ptr) && (&store[n][numberOfElements[n]*elementSizes[n]]) > ptr) {
+            localId.poolIndex = n;
+            uint32_t deltaAddress = ptr - store[n].data();
+            // Getting any data from the right "block" is ok.
+            // This is necessary, as IF's sometimes don't point to the first
+            // element of an object.
+            localId.packetIndex = deltaAddress / elementSizes[n];
+            result = deleteData(localId);
+#if FSFW_DEBUGGING == 1
+            if (deltaAddress % elementSizes[n] != 0) {
+                sif::error << "LocalPool::deleteData: Address not aligned!"
+                        << std::endl;
+            }
+#endif
+            break;
+        }
+    }
+    if (storeId != nullptr) {
+        *storeId = localId;
+    }
+    return result;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+
+
+ReturnValue_t LocalPool::initialize() {
+    ReturnValue_t result = SystemObject::initialize();
+    if (result != RETURN_OK) {
+        return result;
+    }
+    internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+            objects::INTERNAL_ERROR_REPORTER);
+    if (internalErrorReporter == nullptr){
+        return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
+    }
+
+    //Check if any pool size is large than the maximum allowed.
+    for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
+        if (elementSizes[count] >= STORAGE_FREE) {
+            sif::error << "LocalPool::initialize: Pool is too large! "
+                    "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+            return StorageManagerIF::POOL_TOO_LARGE;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalPool::clearStore() {
+    for(auto& sizeList: sizeLists) {
+        for(auto& size: sizeList) {
+            size = STORAGE_FREE;
+        }
+//        std::memset(sizeList[index], 0xff,
+//                numberOfElements[index] * sizeof(size_type));
+    }
+
+}
+
+ReturnValue_t LocalPool::reserveSpace(const size_t size,
+        store_address_t *storeId, bool ignoreFault) {
+    ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
+    if (status != RETURN_OK) {
+        sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
+                << " )::reserveSpace: Packet too large." << std::endl;
+        return status;
+    }
+    status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    while (status != RETURN_OK && spillsToHigherPools) {
+        status = getPoolIndex(size, &storeId->poolIndex, storeId->poolIndex + 1);
+        if (status != RETURN_OK) {
+            //We don't find any fitting pool anymore.
+            break;
+        }
+        status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
+    }
+    if (status == RETURN_OK) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "Reserve: Pool: " << std::dec
+                << storeId->poolIndex << " Index: " << storeId->packetIndex
+                << std::endl;
+#endif
+        sizeLists[storeId->poolIndex][storeId->packetIndex] = size;
+    }
+    else {
+        if ((not ignoreFault) and (internalErrorReporter != nullptr)) {
+            internalErrorReporter->storeFull();
+        }
+    }
+    return status;
+}
+
+void LocalPool::write(store_address_t storeId, const uint8_t *data,
+        size_t size) {
+    uint8_t* ptr = nullptr;
+    size_type packetPosition = getRawPosition(storeId);
+
+    // Size was checked before calling this function.
+    ptr = &store[storeId.poolIndex][packetPosition];
+    std::memcpy(ptr, data, size);
+    sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
+}
+LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
+    if (poolIndex < NUMBER_OF_POOLS) {
+        return elementSizes[poolIndex];
+    }
+    else {
+        return 0;
+    }
+}
+
+ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
+        uint16_t startAtIndex) {
+    for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
+#if FSFW_DEBUGGING == 1
+        sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
+             << n << ", Element Size: " << elementSizes[n] << std::endl;
+#endif
+        if (elementSizes[n] >= packetSize) {
+            *poolIndex = n;
+            return RETURN_OK;
+        }
+    }
+    return DATA_TOO_LARGE;
+}
+
+LocalPool::size_type LocalPool::getRawPosition(store_address_t storeId) {
+    return storeId.packetIndex * elementSizes[storeId.poolIndex];
+}
+
+ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
+    ReturnValue_t status = DATA_STORAGE_FULL;
+    for (uint16_t foundElement = 0; foundElement < numberOfElements[poolIndex];
+            foundElement++) {
+        if (sizeLists[poolIndex][foundElement] == STORAGE_FREE) {
+            *element = foundElement;
+            status = RETURN_OK;
+            break;
+        }
+    }
+    return status;
+}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 3a94c03d..f4318212 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -7,57 +7,61 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../internalError/InternalErrorReporterIF.h"
 #include "../storagemanager/StorageAccessor.h"
-#include <cstring>
 
+#include <vector>
+#include <set>
+#include <utility>
+#include <limits>
 
 /**
- * @brief	The LocalPool class provides an intermediate data storage with
- * 			a fixed pool size policy.
- * @details	The class implements the StorageManagerIF interface. While the
- * 			total number of pools is fixed, the element sizes in one pool and
- * 			the number of pool elements per pool are set on construction.
- * 			The full amount of memory is allocated on construction.
- * 			The overhead is 4 byte per pool element to store the size
- * 			information of each stored element.
- * 			To maintain an "empty" information, the pool size is limited to
- * 			0xFFFF-1 bytes.
- * 			It is possible to store empty packets in the pool.
- * 			The local pool is NOT thread-safe.
- * @author 	Bastian Baetz
+ * @brief   The LocalPool class provides an intermediate data storage with
+ *          a fixed pool size policy.
+ * @details The class implements the StorageManagerIF interface. While the
+ *          total number of pools is fixed, the element sizes in one pool and
+ *          the number of pool elements per pool are set on construction.
+ *          The full amount of memory is allocated on construction.
+ *          The overhead is 4 byte per pool element to store the size
+ *          information of each stored element.
+ *          To maintain an "empty" information, the pool size is limited to
+ *          0xFFFF-1 bytes.
+ *          It is possible to store empty packets in the pool.
+ *          The local pool is NOT thread-safe.
  */
-template<uint8_t NUMBER_OF_POOLS = 5>
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-	/**
-	 * @brief	This definition generally sets the number of different sized pools.
-	 * @details This must be less than the maximum number of pools (currently 0xff).
-	 */
-	//	static const uint32_t NUMBER_OF_POOLS;
-	/**
-	 * @brief	This is the default constructor for a pool manager instance.
-	 * @details	By passing two arrays of size NUMBER_OF_POOLS, the constructor
-	 * 			allocates memory (with @c new) for store and size_list. These
-	 * 			regions are all set to zero on start up.
-	 * @param setObjectId	The object identifier to be set. This allows for
-	 * 						multiple instances of LocalPool in the system.
-	 * @param element_sizes	An array of size NUMBER_OF_POOLS in which the size
-	 * 						of a single element in each pool is determined.
-	 * 						<b>The sizes must be provided in ascending order.
-	 * 						</b>
-	 * @param n_elements	An array of size NUMBER_OF_POOLS in which the
-	 * 						number of elements for each pool is determined.
-	 * 						The position of these values correspond to those in
-	 * 						element_sizes.
-	 * @param registered	Register the pool in object manager or not.
-	 * Default is false (local pool).
-	 * @param spillsToHigherPools A variable to determine whether
-	 * higher n pools are used if the store is full.
-	 */
-	LocalPool(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS],
-			bool registered = false,
-			bool spillsToHigherPools = false);
+    using size_type = size_t;
+
+    using poolElementSize = size_type;
+    using numberPoolElements = uint16_t;
+    using LocalPoolCfgPair = std::pair<poolElementSize, numberPoolElements>;
+    using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
+    /**
+     * @brief   This definition generally sets the number of different sized pools.
+     * @details This must be less than the maximum number of pools (currently 0xff).
+     */
+    const uint8_t NUMBER_OF_POOLS;
+    /**
+     * @brief   This is the default constructor for a pool manager instance.
+     * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
+     *          allocates memory (with @c new) for store and size_list. These
+     *          regions are all set to zero on start up.
+     * @param setObjectId   The object identifier to be set. This allows for
+     *                      multiple instances of LocalPool in the system.
+     * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
+     *                      of a single element in each pool is determined.
+     *                      <b>The sizes must be provided in ascending order.
+     *                      </b>
+     * @param n_elements    An array of size NUMBER_OF_POOLS in which the
+     *                      number of elements for each pool is determined.
+     *                      The position of these values correspond to those in
+     *                      element_sizes.
+     * @param registered    Register the pool in object manager or not.
+     * Default is false (local pool).
+     * @param spillsToHigherPools A variable to determine whether
+     * higher n pools are used if the store is full.
+     */
+    LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+            bool registered = false, bool spillsToHigherPools = false);
 	/**
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
@@ -66,24 +70,26 @@ public:
 	/**
 	 * Documentation: See StorageManagerIF.h
 	 */
-	ReturnValue_t addData(store_address_t* storageId, const uint8_t * data,
+	ReturnValue_t addData(store_address_t* storeId, const uint8_t * data,
 			size_t size, bool ignoreFault = false) override;
-	ReturnValue_t getFreeElement(store_address_t* storageId,const size_t size,
-			uint8_t** p_data, bool ignoreFault = false) override;
+	ReturnValue_t getFreeElement(store_address_t* storeId,const size_t size,
+			uint8_t** pData, bool ignoreFault = false) override;
 
-	ConstAccessorPair getData(store_address_t packet_id) override;
-	ReturnValue_t getData(store_address_t packet_id, ConstStorageAccessor&) override;
-	ReturnValue_t getData(store_address_t packet_id, const uint8_t** packet_ptr,
+	ConstAccessorPair getData(store_address_t storeId) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        ConstStorageAccessor& constAccessor) override;
+	ReturnValue_t getData(store_address_t storeId,
+	        const uint8_t** packet_ptr, size_t * size) override;
+
+	AccessorPair modifyData(store_address_t storeId) override;
+	ReturnValue_t modifyData(store_address_t storeId,
+	        StorageAccessor& storeAccessor) override;
+	ReturnValue_t modifyData(store_address_t storeId, uint8_t** packet_ptr,
 			size_t * size) override;
 
-	AccessorPair modifyData(store_address_t packet_id) override;
-	ReturnValue_t modifyData(store_address_t packet_id, StorageAccessor&) override;
-	ReturnValue_t modifyData(store_address_t packet_id, uint8_t** packet_ptr,
-			size_t * size) override;
-
-	virtual ReturnValue_t deleteData(store_address_t) override;
+	virtual ReturnValue_t deleteData(store_address_t storeId) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
-			store_address_t* storeId = NULL) override;
+			store_address_t* storeId = nullptr) override;
 	void clearStore() override;
 	ReturnValue_t initialize() override;
 protected:
@@ -94,43 +100,48 @@ protected:
 	 * @return	- #RETURN_OK on success,
 	 * 			- the return codes of #getPoolIndex or #findEmpty otherwise.
 	 */
-	virtual ReturnValue_t reserveSpace(const uint32_t size,
+	virtual ReturnValue_t reserveSpace(const size_t size,
 			store_address_t* address, bool ignoreFault);
 
-	InternalErrorReporterIF *internalErrorReporter;
 private:
-	/**
-	 * Indicates that this element is free.
-	 * This value limits the maximum size of a pool. Change to larger data type
-	 * if increase is required.
-	 */
-	static const uint32_t STORAGE_FREE = 0xFFFFFFFF;
+    /**
+     * Indicates that this element is free.
+     * This value limits the maximum size of a pool.
+     * Change to larger data type if increase is required.
+     */
+    static const size_type STORAGE_FREE = std::numeric_limits<size_type>::max();
 	/**
 	 * @brief	In this array, the element sizes of each pool is stored.
 	 * @details	The sizes are maintained for internal pool management. The sizes
 	 * 			must be set in ascending order on construction.
 	 */
-	uint32_t element_sizes[NUMBER_OF_POOLS];
+    std::vector<size_type> elementSizes =
+            std::vector<size_type>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	n_elements stores the number of elements per pool.
 	 * @details	These numbers are maintained for internal pool management.
 	 */
-	uint16_t n_elements[NUMBER_OF_POOLS];
+	std::vector<uint16_t> numberOfElements =
+	        std::vector<uint16_t>(NUMBER_OF_POOLS);
 	/**
 	 * @brief	store represents the actual memory pool.
 	 * @details	It is an array of pointers to memory, which was allocated with
 	 * 			a @c new call on construction.
 	 */
-	uint8_t* store[NUMBER_OF_POOLS];
+	std::vector<std::vector<uint8_t>> store =
+	        std::vector<std::vector<uint8_t>>(NUMBER_OF_POOLS);
+
 	/**
 	 * @brief	The size_list attribute stores the size values of every pool element.
 	 * @details	As the number of elements is determined on construction, the size list
 	 * 			is also dynamically allocated there.
 	 */
-	uint32_t* size_list[NUMBER_OF_POOLS];
+	std::vector<std::vector<size_type>> sizeLists =
+	        std::vector<std::vector<size_type>>(NUMBER_OF_POOLS);
+
 	//! A variable to determine whether higher n pools are used if
 	//! the store is full.
-	bool spillsToHigherPools;
+	bool spillsToHigherPools = false;
 	/**
 	 * @brief	This method safely stores the given data in the given packet_id.
 	 * @details	It also sets the size in size_list. The method does not perform
@@ -139,13 +150,13 @@ private:
 	 * @param data		The data to be stored.
 	 * @param size		The size of the data to be stored.
 	 */
-	void write(store_address_t packet_id, const uint8_t* data, size_t size);
+	void write(store_address_t packetId, const uint8_t* data, size_t size);
 	/**
 	 * @brief	A helper method to read the element size of a certain pool.
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	uint32_t getPageSize(uint16_t pool_index);
+	size_type getPageSize(uint16_t poolIndex);
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
 	 * @details	The pools are looked up in ascending order, so the first that
@@ -162,7 +173,7 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_TOO_LARGE otherwise.
 	 */
-	ReturnValue_t getPoolIndex(size_t packet_size, uint16_t* poolIndex,
+	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
 			uint16_t startAtIndex = 0);
 	/**
 	 * @brief	This helper method calculates the true array position in store
@@ -172,7 +183,7 @@ private:
 	 * @param packet_id	The packet id to look up.
 	 * @return	Returns the position of the data in store.
 	 */
-	uint32_t getRawPosition(store_address_t packet_id);
+	size_type getRawPosition(store_address_t storeId);
 	/**
 	 * @brief	This is a helper method to find an empty element in a given pool.
 	 * @details	The method searches size_list for the first empty element, so
@@ -182,9 +193,9 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
-	ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element);
+	ReturnValue_t findEmpty(uint16_t poolIndex, uint16_t* element);
+
+    InternalErrorReporterIF *internalErrorReporter = nullptr;
 };
 
-#include "LocalPool.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_LOCALPOOL_H_ */
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
new file mode 100644
index 00000000..e7a7d9cf
--- /dev/null
+++ b/storagemanager/PoolManager.cpp
@@ -0,0 +1,51 @@
+#include "PoolManager.h"
+#include <FSFWConfig.h>
+
+PoolManager::PoolManager(object_id_t setObjectId,
+        const LocalPoolConfig localPoolConfig):
+        LocalPool(setObjectId, localPoolConfig, true) {
+    mutex = MutexFactory::instance()->createMutex();
+}
+
+
+PoolManager::~PoolManager(void) {
+    MutexFactory::instance()->deleteMutex(mutex);
+}
+
+
+ReturnValue_t PoolManager::reserveSpace(const size_t size,
+        store_address_t* address, bool ignoreFault) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    ReturnValue_t status = LocalPool::reserveSpace(size,
+            address,ignoreFault);
+    return status;
+}
+
+
+ReturnValue_t PoolManager::deleteData(
+        store_address_t storeId) {
+#if FSFW_DEBUGGING == 1
+     sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
+           " )::deleteData from store " << storeId.poolIndex <<
+           ". id is "<< storeId.packetIndex << std::endl;
+#endif
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
+            mutexTimeoutMs);
+    return LocalPool::deleteData(storeId);
+}
+
+
+ReturnValue_t PoolManager::deleteData(uint8_t* buffer,
+        size_t size, store_address_t* storeId) {
+    MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    ReturnValue_t status = LocalPool::deleteData(buffer,
+            size, storeId);
+    return status;
+}
+
+
+void PoolManager::setMutexTimeout(
+        uint32_t mutexTimeoutMs) {
+    this->mutexTimeoutMs = mutexTimeoutMs;
+}
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index 8cc6c065..b1781b9b 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -13,12 +13,9 @@
  * 			with a lock.
  * @author 	Bastian Baetz
  */
-template <uint8_t NUMBER_OF_POOLS = 5>
-class PoolManager : public LocalPool<NUMBER_OF_POOLS> {
+class PoolManager: public LocalPool {
 public:
-	PoolManager(object_id_t setObjectId,
-			const uint16_t element_sizes[NUMBER_OF_POOLS],
-			const uint16_t n_elements[NUMBER_OF_POOLS]);
+	PoolManager(object_id_t setObjectId, const LocalPoolConfig poolConfig);
 
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory
@@ -39,7 +36,7 @@ protected:
 	//! Default mutex timeout value to prevent permanent blocking.
 	uint32_t mutexTimeoutMs = 20;
 
-	ReturnValue_t reserveSpace(const uint32_t size, store_address_t* address,
+	ReturnValue_t reserveSpace(const size_t size, store_address_t* address,
 			bool ignoreFault) override;
 
 	/**
@@ -51,6 +48,4 @@ protected:
 	MutexIF* mutex;
 };
 
-#include "PoolManager.tpp"
-
 #endif /* FSFW_STORAGEMANAGER_POOLMANAGER_H_ */
diff --git a/storagemanager/StorageAccessor.h b/storagemanager/StorageAccessor.h
index 5cf15d50..d5b383eb 100644
--- a/storagemanager/StorageAccessor.h
+++ b/storagemanager/StorageAccessor.h
@@ -10,9 +10,7 @@ class StorageManagerIF;
  */
 class StorageAccessor: public ConstStorageAccessor {
 	//! StorageManager classes have exclusive access to private variables.
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class PoolManager;
-	template<uint8_t NUMBER_OF_POOLS>
 	friend class LocalPool;
 public:
 	StorageAccessor(store_address_t storeId);
diff --git a/storagemanager/LocalPool.tpp b/storagemanager/archive/LocalPool.tpp
similarity index 100%
rename from storagemanager/LocalPool.tpp
rename to storagemanager/archive/LocalPool.tpp
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/archive/PoolManager.tpp
similarity index 100%
rename from storagemanager/PoolManager.tpp
rename to storagemanager/archive/PoolManager.tpp
diff --git a/storagemanager/storeAddress.h b/storagemanager/storeAddress.h
index 994998a6..ea72f6f8 100644
--- a/storagemanager/storeAddress.h
+++ b/storagemanager/storeAddress.h
@@ -33,7 +33,7 @@ union store_address_t {
 	 * @param packetIndex
 	 */
 	store_address_t(uint16_t poolIndex, uint16_t packetIndex):
-		pool_index(poolIndex),packet_index(packetIndex){}
+		poolIndex(poolIndex), packetIndex(packetIndex){}
 	/**
 	 * A structure with two elements to access the store address pool-like.
 	 */
@@ -41,11 +41,11 @@ union store_address_t {
 		/**
 		 * The index in which pool the packet lies.
 		 */
-		uint16_t pool_index;
+		uint16_t poolIndex;
 		/**
 		 * The position in the chosen pool.
 		 */
-		uint16_t packet_index;
+		uint16_t packetIndex;
 	};
 	/**
 	 * Alternative access to the raw value.
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 610829e5..80ec67e6 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -1,21 +1,37 @@
-#include "../../tmtcpacket/packetmatcher/ApidMatcher.h"
-#include "../../tmtcpacket/packetmatcher/PacketMatchTree.h"
-#include "../../tmtcpacket/packetmatcher/ServiceMatcher.h"
-#include "../../tmtcpacket/packetmatcher/SubserviceMatcher.h"
+#include "ApidMatcher.h"
+#include "PacketMatchTree.h"
+#include "ServiceMatcher.h"
+#include "SubserviceMatcher.h"
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+        sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+        sizeof(PacketMatchTree::Node) };
+//Maximum number of types and subtypes to filter should be more than sufficient.
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
+        LocalPool::LocalPoolCfgPair(sizeof(ServiceMatcher), 10),
+        LocalPool::LocalPoolCfgPair(sizeof(SubServiceMatcher), 20),
+        LocalPool::LocalPoolCfgPair(sizeof(ApidMatcher), 2),
+        LocalPool::LocalPoolCfgPair(sizeof(PacketMatchTree::Node), 40)
+};
 
 PacketMatchTree::PacketMatchTree(Node* root) :
-		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
-				N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree(iterator root) :
-		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>(root.element, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::PacketMatchTree() :
-		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
-				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2),
+		factoryBackend(0, poolConfig, false, true),
+		factory(&factoryBackend) {
 }
 
 PacketMatchTree::~PacketMatchTree() {
@@ -172,11 +188,6 @@ ReturnValue_t PacketMatchTree::initialize() {
 	return factoryBackend.initialize();
 }
 
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-		sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
 
 ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
 		uint8_t type, uint8_t subtype) {
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h
index 86fb087e..54fc856c 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.h
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.h
@@ -23,8 +23,9 @@ protected:
 	ReturnValue_t cleanUpElement(iterator position);
 private:
 	static const uint8_t N_POOLS = 4;
-	LocalPool<N_POOLS> factoryBackend;
+	LocalPool factoryBackend;
 	PlacementFactory factory;
+	static const LocalPool::LocalPoolConfig poolConfig;
 	static const uint16_t POOL_SIZES[N_POOLS];
 	static const uint16_t N_ELEMENTS[N_POOLS];
 	template<typename VALUE_T, typename INSERTION_T>

From 57c9775d7d9863072aa9d06e782c10184185bce3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:41:16 +0200
Subject: [PATCH 0900/1292] add fill count func added

---
 storagemanager/LocalPool.cpp      | 13 ++++++
 storagemanager/LocalPool.h        | 66 ++++++++++++++++++++-----------
 storagemanager/StorageManagerIF.h | 10 +++++
 3 files changed, 66 insertions(+), 23 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 67cdf447..86b67806 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -286,3 +286,16 @@ ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
     }
     return status;
 }
+
+size_t LocalPool::getTotalSize(size_t* additionalSize) {
+    size_t totalSize = 0;
+    size_t sizesSize = 0;
+    for(uint8_t idx = 0; idx < NUMBER_OF_POOLS; idx ++) {
+        totalSize += elementSizes[idx] * numberOfElements[idx];
+        sizesSize += numberOfElements[idx] * sizeof(size_type);
+    }
+    if(additionalSize != nullptr) {
+        *additionalSize = sizesSize;
+    }
+    return totalSize;
+}
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index f4318212..a3ccd3a3 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -16,16 +16,16 @@
 /**
  * @brief   The LocalPool class provides an intermediate data storage with
  *          a fixed pool size policy.
- * @details The class implements the StorageManagerIF interface. While the
- *          total number of pools is fixed, the element sizes in one pool and
- *          the number of pool elements per pool are set on construction.
- *          The full amount of memory is allocated on construction.
- *          The overhead is 4 byte per pool element to store the size
- *          information of each stored element.
- *          To maintain an "empty" information, the pool size is limited to
- *          0xFFFF-1 bytes.
- *          It is possible to store empty packets in the pool.
- *          The local pool is NOT thread-safe.
+ * @details
+ * The class implements the StorageManagerIF interface. While the total number
+ * of pools is fixed, the element sizes in one pool and the number of pool
+ * elements per pool are set on construction. The full amount of memory is
+ * allocated on construction.
+ * The overhead is 4 byte per pool element to store the size information of
+ * each stored element. To maintain an "empty" information, the pool size is
+ * limited to 0xFFFF-1 bytes.
+ * It is possible to store empty packets in the pool.
+ * The local pool is NOT thread-safe.
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
@@ -42,21 +42,21 @@ public:
     const uint8_t NUMBER_OF_POOLS;
     /**
      * @brief   This is the default constructor for a pool manager instance.
-     * @details By passing two arrays of size NUMBER_OF_POOLS, the constructor
-     *          allocates memory (with @c new) for store and size_list. These
-     *          regions are all set to zero on start up.
+     * @details
+     * The pool is configured by passing a set of pairs into the constructor.
+     * The first value of that pair determines the number of one element on
+     * the respective page of the pool while the second value determines how
+     * many elements with that size are created on that page.
+     * All regions are to zero on start up.
      * @param setObjectId   The object identifier to be set. This allows for
      *                      multiple instances of LocalPool in the system.
-     * @param element_sizes An array of size NUMBER_OF_POOLS in which the size
-     *                      of a single element in each pool is determined.
-     *                      <b>The sizes must be provided in ascending order.
-     *                      </b>
-     * @param n_elements    An array of size NUMBER_OF_POOLS in which the
-     *                      number of elements for each pool is determined.
-     *                      The position of these values correspond to those in
-     *                      element_sizes.
-     * @param registered    Register the pool in object manager or not.
-     * Default is false (local pool).
+     * @param poolConfig
+     * This is a set of pairs to configure the number of pages in the pool,
+     * the size of an element on a page, the number of elements on a page
+     * and the total size of the pool at once while also implicitely
+     * sorting the pairs in the right order.
+     * @param registered
+     * Determines whether the pool is registered in the object manager or not.
      * @param spillsToHigherPools A variable to determine whether
      * higher n pools are used if the store is full.
      */
@@ -90,6 +90,26 @@ public:
 	virtual ReturnValue_t deleteData(store_address_t storeId) override;
 	virtual ReturnValue_t deleteData(uint8_t* ptr, size_t size,
 			store_address_t* storeId = nullptr) override;
+
+	/**
+	 * Get the total size of allocated memory for pool data.
+	 * There is an additional overhead of the sizes of elements which will
+	 * be assigned to additionalSize
+	 * @return
+	 */
+	size_t getTotalSize(size_t* additionalSize) override;
+
+	/**
+	 * Get the fill count of the pool. Each character inside the provided
+	 * buffer will be assigned to a rounded percentage fill count for each
+	 * page. The last written byte (at the index number of pools + 1)
+	 * will contain the total fill count of the pool as a mean of the
+	 * percentages.
+	 * @param buffer
+	 * @param maxSize
+	 */
+	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
+
 	void clearStore() override;
 	ReturnValue_t initialize() override;
 protected:
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 834e7563..d22ed661 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -164,6 +164,16 @@ public:
 	 * Use with care!
 	 */
 	virtual void clearStore() = 0;
+
+	/**
+	 * Get the fill count of the pool. The exact form will be implementation
+	 * dependant.
+	 * @param buffer
+	 * @param bytesWritten
+	 */
+	virtual void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) = 0;
+
+	virtual size_t getTotalSize(size_t* additionalSize) = 0;
 };
 
 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */

From b3e5946291a7c6a5365c79b68e3ea52aa3aca497 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:42:49 +0200
Subject: [PATCH 0901/1292] implementation added

---
 storagemanager/LocalPool.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 86b67806..90975a91 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -299,3 +299,6 @@ size_t LocalPool::getTotalSize(size_t* additionalSize) {
     }
     return totalSize;
 }
+
+void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+}

From bdfea9ea38331a5c36f72100834d0fb524100b4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 14 Oct 2020 23:53:50 +0200
Subject: [PATCH 0902/1292] includes reordered

---
 tmtcservices/CommandingServiceBase.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 9f1d4c4f..3611d7c6 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -1,13 +1,13 @@
 #ifndef FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 #define FSFW_TMTCSERVICES_COMMANDINGSERVICEBASE_H_
 
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationReporter.h"
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
-#include "AcceptsTelecommandsIF.h"
-
-#include "VerificationReporter.h"
 #include "../ipc/CommandMessage.h"
 #include "../container/FixedMap.h"
 #include "../container/FIFO.h"

From d1498366122e861703ee808fdf10eae4560d802b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:34:20 +0200
Subject: [PATCH 0903/1292] better  form

---
 events/EventManager.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 289cb029..3988210f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -15,9 +15,9 @@ const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
 const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
 
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        LocalPool::LocalPoolCfgPair(sizeof(EventMatchTree::Node), 240),
-        LocalPool::LocalPoolCfgPair(sizeof(EventIdRangeMatcher), 120),
-        LocalPool::LocalPoolCfgPair(sizeof(ReporterRangeMatcher), 120)
+        {sizeof(EventMatchTree::Node), 240},
+        {sizeof(EventIdRangeMatcher), 120},
+        {sizeof(ReporterRangeMatcher), 120}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :

From 64bed475fe8976c7d84a82540b2b7e0dfa915561 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:43:23 +0200
Subject: [PATCH 0904/1292] important bugfix

---
 storagemanager/LocalPool.cpp | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 90975a91..f61ef2b8 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -3,23 +3,23 @@
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
-            bool registered, bool spillsToHigherPools):
-            SystemObject(setObjectId), NUMBER_OF_POOLS(poolConfig.size()) {
-    uint16_t index = 0;
-    for (const auto& currentPoolConfig: poolConfig) {
-        this->elementSizes[index] = currentPoolConfig.first;
-        this->numberOfElements[index] = currentPoolConfig.second;
-        store[index] = std::vector<uint8_t>(
-                numberOfElements[index] * elementSizes[index]);
-        sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
-        //TODO checkme
-        for(auto& size: sizeLists[index]) {
-            size = STORAGE_FREE;
-        }
-//        std::memset(sizeLists[index], 0xff,
-//                numberOfElements[index] * sizeof(size_type));
-        index++;
-    }
+		bool registered, bool spillsToHigherPools):
+		SystemObject(setObjectId, registered),
+		NUMBER_OF_POOLS(poolConfig.size()),
+		spillsToHigherPools(spillsToHigherPools) {
+	uint16_t index = 0;
+	for (const auto& currentPoolConfig: poolConfig) {
+		this->elementSizes[index] = currentPoolConfig.first;
+		this->numberOfElements[index] = currentPoolConfig.second;
+		store[index] = std::vector<uint8_t>(
+				numberOfElements[index] * elementSizes[index]);
+		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
+		//TODO checkme
+		for(auto& size: sizeLists[index]) {
+			size = STORAGE_FREE;
+		}
+		index++;
+	}
 }
 
 LocalPool::~LocalPool(void) {}

From 1ee01ffcdb3a8e65a6f6e227aada9a109ec8680b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 00:54:00 +0200
Subject: [PATCH 0905/1292] important bugfixes

---
 events/EventManager.cpp                      | 13 ++++---------
 storagemanager/LocalPool.cpp                 |  4 ++--
 storagemanager/LocalPool.h                   |  4 ++--
 tmtcpacket/packetmatcher/PacketMatchTree.cpp | 15 +++++----------
 4 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 3988210f..57bda13f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -4,20 +4,15 @@
 #include "../ipc/MutexFactory.h"
 
 
-const uint16_t EventManager::POOL_SIZES[N_POOLS] = {
-		sizeof(EventMatchTree::Node), sizeof(EventIdRangeMatcher),
-		sizeof(ReporterRangeMatcher) };
 // If one checks registerListener calls, there are around 40 (to max 50)
 // objects registering for certain events.
 // Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
-// SHOULDDO: Shouldn't this be in the config folder and passed via ctor?
-const uint16_t EventManager::N_ELEMENTS[N_POOLS] = { 240, 120, 120 };
-
+// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        {sizeof(EventMatchTree::Node), 240},
-        {sizeof(EventIdRangeMatcher), 120},
-        {sizeof(ReporterRangeMatcher), 120}
+        {240, sizeof(EventMatchTree::Node)},
+        {120, sizeof(EventIdRangeMatcher)},
+        {120, sizeof(ReporterRangeMatcher)}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index f61ef2b8..4a6f332c 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -9,8 +9,8 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
 		spillsToHigherPools(spillsToHigherPools) {
 	uint16_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
-		this->elementSizes[index] = currentPoolConfig.first;
-		this->numberOfElements[index] = currentPoolConfig.second;
+		this->numberOfElements[index] = currentPoolConfig.first;
+		this->elementSizes[index] = currentPoolConfig.second;
 		store[index] = std::vector<uint8_t>(
 				numberOfElements[index] * elementSizes[index]);
 		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index a3ccd3a3..494e2cbb 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -33,7 +33,7 @@ public:
 
     using poolElementSize = size_type;
     using numberPoolElements = uint16_t;
-    using LocalPoolCfgPair = std::pair<poolElementSize, numberPoolElements>;
+    using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
     using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
     /**
      * @brief   This definition generally sets the number of different sized pools.
@@ -44,7 +44,7 @@ public:
      * @brief   This is the default constructor for a pool manager instance.
      * @details
      * The pool is configured by passing a set of pairs into the constructor.
-     * The first value of that pair determines the number of one element on
+     * The first value of that pair determines the number of one elements on
      * the respective page of the pool while the second value determines how
      * many elements with that size are created on that page.
      * All regions are to zero on start up.
diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
index 80ec67e6..ac72b3e7 100644
--- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp
+++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp
@@ -3,17 +3,12 @@
 #include "ServiceMatcher.h"
 #include "SubserviceMatcher.h"
 
-const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
-        sizeof(SubServiceMatcher), sizeof(ApidMatcher),
-        sizeof(PacketMatchTree::Node) };
-//Maximum number of types and subtypes to filter should be more than sufficient.
-const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
-
+// This should be configurable..
 const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
-        LocalPool::LocalPoolCfgPair(sizeof(ServiceMatcher), 10),
-        LocalPool::LocalPoolCfgPair(sizeof(SubServiceMatcher), 20),
-        LocalPool::LocalPoolCfgPair(sizeof(ApidMatcher), 2),
-        LocalPool::LocalPoolCfgPair(sizeof(PacketMatchTree::Node), 40)
+		{10, sizeof(ServiceMatcher)},
+		{20, sizeof(SubServiceMatcher)},
+		{2, sizeof(ApidMatcher)},
+		{40, sizeof(PacketMatchTree::Node)}
 };
 
 PacketMatchTree::PacketMatchTree(Node* root) :

From 364bce90ddc44aa7e71852c458c6eff5c7aefc93 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:07:20 +0200
Subject: [PATCH 0906/1292] small fixes

---
 storagemanager/LocalPool.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 4a6f332c..3c099c6d 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -132,7 +132,8 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
-        sif::error << "LocalPool:deleteData failed." << std::endl;
+        sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
+        		<< std::endl;
         status = ILLEGAL_STORAGE_ID;
     }
     return status;
@@ -165,7 +166,6 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
         *storeId = localId;
     }
     return result;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 

From e5000abbb786f01a8664012fe52059ade71c0e61 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:31:11 +0200
Subject: [PATCH 0907/1292] custom cmp operator

---
 storagemanager/LocalPool.h | 54 +++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 15 deletions(-)

diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 494e2cbb..5c30c58f 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -13,6 +13,7 @@
 #include <utility>
 #include <limits>
 
+
 /**
  * @brief   The LocalPool class provides an intermediate data storage with
  *          a fixed pool size policy.
@@ -29,17 +30,46 @@
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-    using size_type = size_t;
-
+	using size_type = size_t;
     using poolElementSize = size_type;
     using numberPoolElements = uint16_t;
-    using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
-    using LocalPoolConfig = std::multiset<LocalPoolCfgPair>;
+	using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
+
+	// The configuration needs to be provided with the pool sizes ascending
+	// but the number of pool elements as the first value is more intuitive.
+	// Therefore, a custom comparator was provided.
+	struct LocalPoolConfigCmp
+	{
+		bool operator ()(const LocalPoolCfgPair &a,
+				const LocalPoolCfgPair &b) const
+		{
+			if(a.second < b.second) {
+				return true;
+			}
+			else if(a.second > b.second) {
+				return false;
+			}
+			else {
+				if(a.first < b.first) {
+					return true;
+				}
+				else {
+					return false;
+				}
+			}
+		}
+	};
+    using LocalPoolConfig = std::multiset<LocalPoolCfgPair, LocalPoolConfigCmp>;
+
     /**
-     * @brief   This definition generally sets the number of different sized pools.
-     * @details This must be less than the maximum number of pools (currently 0xff).
+     * @brief   This definition generally sets the number of
+     * 			different sized pools. It is derived from the number of pairs
+     * 			inside the LocalPoolConfig set on object creation.
+     * @details
+     * This must be less than the maximum number of pools (currently 0xff).
      */
     const uint8_t NUMBER_OF_POOLS;
+
     /**
      * @brief   This is the default constructor for a pool manager instance.
      * @details
@@ -177,21 +207,15 @@ private:
 	 * @return	Returns the size of an element or 0.
 	 */
 	size_type getPageSize(uint16_t poolIndex);
-	/**
-	 * @brief	This helper method looks up a fitting pool for a given size.
-	 * @details	The pools are looked up in ascending order, so the first that
-	 * 			fits is used.
-	 * @param packet_size	The size of the data to be stored.
-	 * @return	Returns the pool that fits or StorageManagerIF::INVALID_ADDRESS.
-	 */
+
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
 	 * @details	The pools are looked up in ascending order, so the first that
 	 * 			fits is used.
 	 * @param packet_size		The size of the data to be stored.
 	 * @param[out] poolIndex	The fitting pool index found.
-	 * @return	- #RETURN_OK on success,
-	 * 			- #DATA_TOO_LARGE otherwise.
+	 * @return	- @c RETURN_OK on success,
+	 * 			- @c DATA_TOO_LARGE otherwise.
 	 */
 	ReturnValue_t getPoolIndex(size_t packetSize, uint16_t* poolIndex,
 			uint16_t startAtIndex = 0);

From 56dc06e0ed1a0c0956793409aec24e5821385c42 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:51:12 +0200
Subject: [PATCH 0908/1292] some little formatting stuff

---
 storagemanager/LocalPool.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 3c099c6d..ef975029 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -14,7 +14,6 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
 		store[index] = std::vector<uint8_t>(
 				numberOfElements[index] * elementSizes[index]);
 		sizeLists[index] = std::vector<size_type>(numberOfElements[index]);
-		//TODO checkme
 		for(auto& size: sizeLists[index]) {
 			size = STORAGE_FREE;
 		}
@@ -102,7 +101,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
     if (sizeLists[storeId.poolIndex][storeId.packetIndex]
             != STORAGE_FREE) {
-        uint32_t packetPosition = getRawPosition(storeId);
+        size_type packetPosition = getRawPosition(storeId);
         *packetPtr = &store[storeId.poolIndex][packetPosition];
         *size = sizeLists[storeId.poolIndex][storeId.packetIndex];
         status = RETURN_OK;
@@ -111,7 +110,6 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
         status = DATA_DOES_NOT_EXIST;
     }
     return status;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
@@ -145,7 +143,8 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
     ReturnValue_t result = ILLEGAL_ADDRESS;
     for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
         //Not sure if new allocates all stores in order. so better be careful.
-        if ((store[n].data() <= ptr) && (&store[n][numberOfElements[n]*elementSizes[n]]) > ptr) {
+        if ((store[n].data() <= ptr) and
+        		(&store[n][numberOfElements[n]*elementSizes[n]] > ptr)) {
             localId.poolIndex = n;
             uint32_t deltaAddress = ptr - store[n].data();
             // Getting any data from the right "block" is ok.

From 48ff5dea0831610897c9aec52bea2734c68f0720 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 01:57:30 +0200
Subject: [PATCH 0909/1292] line break added

---
 storagemanager/LocalPool.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index ef975029..8bb684d7 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -245,6 +245,7 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     std::memcpy(ptr, data, size);
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
+
 LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
     if (poolIndex < NUMBER_OF_POOLS) {
         return elementSizes[poolIndex];

From 6e5f029a641ba7c77f85ea9e1d1f1a58d1a58b9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 12:47:21 +0200
Subject: [PATCH 0910/1292] type usage improved, getFillCoutn implemented

---
 storagemanager/LocalPool.cpp      | 48 ++++++++++++++++++++++++++++---
 storagemanager/LocalPool.h        | 24 +++++++++-------
 storagemanager/PoolManager.cpp    | 11 ++++++-
 storagemanager/PoolManager.h      | 32 ++++++++++++++++++---
 storagemanager/StorageManagerIF.h | 13 ++++++++-
 5 files changed, 108 insertions(+), 20 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8bb684d7..bffde367 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -2,12 +2,12 @@
 #include <FSFWConfig.h>
 #include <cstring>
 
-LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		bool registered, bool spillsToHigherPools):
 		SystemObject(setObjectId, registered),
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
-	uint16_t index = 0;
+	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
 		this->numberOfElements[index] = currentPoolConfig.first;
 		this->elementSizes[index] = currentPoolConfig.second;
@@ -246,7 +246,7 @@ void LocalPool::write(store_address_t storeId, const uint8_t *data,
     sizeLists[storeId.poolIndex][storeId.packetIndex] = size;
 }
 
-LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
+LocalPool::size_type LocalPool::getPageSize(max_pools_t poolIndex) {
     if (poolIndex < NUMBER_OF_POOLS) {
         return elementSizes[poolIndex];
     }
@@ -255,6 +255,10 @@ LocalPool::size_type LocalPool::getPageSize(uint16_t poolIndex) {
     }
 }
 
+void LocalPool::setToSpillToHigherPools(bool enable) {
+	this->spillsToHigherPools = enable;
+}
+
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
@@ -274,7 +278,7 @@ LocalPool::size_type LocalPool::getRawPosition(store_address_t storeId) {
     return storeId.packetIndex * elementSizes[storeId.poolIndex];
 }
 
-ReturnValue_t LocalPool::findEmpty(uint16_t poolIndex, uint16_t *element) {
+ReturnValue_t LocalPool::findEmpty(n_pool_elem_t poolIndex, uint16_t *element) {
     ReturnValue_t status = DATA_STORAGE_FULL;
     for (uint16_t foundElement = 0; foundElement < numberOfElements[poolIndex];
             foundElement++) {
@@ -301,4 +305,40 @@ size_t LocalPool::getTotalSize(size_t* additionalSize) {
 }
 
 void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+	if(bytesWritten == nullptr or buffer == nullptr) {
+		return;
+	}
+
+	uint16_t reservedHits = 0;
+	uint8_t idx = 0;
+	uint16_t sum = 0;
+	for(; idx < NUMBER_OF_POOLS; idx ++) {
+		for(const auto& size: sizeLists[idx]) {
+			if(size != STORAGE_FREE) {
+				reservedHits++;
+			}
+			buffer[idx] = static_cast<float>(reservedHits) /
+					numberOfElements[idx] * 100;
+			*bytesWritten += 1;
+			sum += buffer[idx];
+		}
+	}
+	idx++;
+	buffer[idx] = sum / NUMBER_OF_POOLS;
+	*bytesWritten += 1;
+}
+
+
+void LocalPool::clearPage(max_pools_t  pageIndex) {
+	if(pageIndex >= NUMBER_OF_POOLS) {
+		return;
+	}
+
+	// Mark the storage as free
+	for(auto& size: sizeLists[pageIndex]) {
+		size = STORAGE_FREE;
+	}
+
+	// Set all the page content to 0.
+	std::memset(store[pageIndex].data(), 0, elementSizes[pageIndex]);
 }
diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h
index 5c30c58f..db771152 100644
--- a/storagemanager/LocalPool.h
+++ b/storagemanager/LocalPool.h
@@ -30,10 +30,9 @@
  */
 class LocalPool: public SystemObject, public StorageManagerIF {
 public:
-	using size_type = size_t;
-    using poolElementSize = size_type;
-    using numberPoolElements = uint16_t;
-	using LocalPoolCfgPair = std::pair<numberPoolElements, poolElementSize>;
+    using pool_elem_size_t = size_type;
+    using n_pool_elem_t = uint16_t;
+	using LocalPoolCfgPair = std::pair<n_pool_elem_t, pool_elem_size_t>;
 
 	// The configuration needs to be provided with the pool sizes ascending
 	// but the number of pool elements as the first value is more intuitive.
@@ -68,7 +67,7 @@ public:
      * @details
      * This must be less than the maximum number of pools (currently 0xff).
      */
-    const uint8_t NUMBER_OF_POOLS;
+    const max_pools_t NUMBER_OF_POOLS;
 
     /**
      * @brief   This is the default constructor for a pool manager instance.
@@ -90,8 +89,11 @@ public:
      * @param spillsToHigherPools A variable to determine whether
      * higher n pools are used if the store is full.
      */
-    LocalPool(object_id_t setObjectId, const LocalPoolConfig poolConfig,
+    LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
             bool registered = false, bool spillsToHigherPools = false);
+
+    void setToSpillToHigherPools(bool enable);
+
 	/**
 	 * @brief	In the LocalPool's destructor all allocated memory is freed.
 	 */
@@ -132,15 +134,17 @@ public:
 	/**
 	 * Get the fill count of the pool. Each character inside the provided
 	 * buffer will be assigned to a rounded percentage fill count for each
-	 * page. The last written byte (at the index number of pools + 1)
+	 * page. The last written byte (at the index bytesWritten - 1)
 	 * will contain the total fill count of the pool as a mean of the
-	 * percentages.
+	 * percentages of single pages.
 	 * @param buffer
 	 * @param maxSize
 	 */
 	void getFillCount(uint8_t* buffer, uint8_t* bytesWritten) override;
 
 	void clearStore() override;
+	void clearPage(max_pools_t pageIndex) override;
+
 	ReturnValue_t initialize() override;
 protected:
 	/**
@@ -206,7 +210,7 @@ private:
 	 * @param pool_index	The pool in which to look.
 	 * @return	Returns the size of an element or 0.
 	 */
-	size_type getPageSize(uint16_t poolIndex);
+	size_type getPageSize(max_pools_t poolIndex);
 
 	/**
 	 * @brief	This helper method looks up a fitting pool for a given size.
@@ -237,7 +241,7 @@ private:
 	 * @return	- #RETURN_OK on success,
 	 * 			- #DATA_STORAGE_FULL if the store is full
 	 */
-	ReturnValue_t findEmpty(uint16_t poolIndex, uint16_t* element);
+	ReturnValue_t findEmpty(n_pool_elem_t poolIndex, uint16_t* element);
 
     InternalErrorReporterIF *internalErrorReporter = nullptr;
 };
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index e7a7d9cf..85376b28 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -2,7 +2,7 @@
 #include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
-        const LocalPoolConfig localPoolConfig):
+        const LocalPoolConfig& localPoolConfig):
         LocalPool(setObjectId, localPoolConfig, true) {
     mutex = MutexFactory::instance()->createMutex();
 }
@@ -49,3 +49,12 @@ void PoolManager::setMutexTimeout(
         uint32_t mutexTimeoutMs) {
     this->mutexTimeoutMs = mutexTimeoutMs;
 }
+
+ReturnValue_t PoolManager::lockMutex(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	return mutex->lockMutex(timeoutType, timeoutMs);
+}
+
+ReturnValue_t PoolManager::unlockMutex() {
+	return mutex->unlockMutex();
+}
diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h
index b1781b9b..5786a225 100644
--- a/storagemanager/PoolManager.h
+++ b/storagemanager/PoolManager.h
@@ -9,13 +9,20 @@
 /**
  * @brief	The PoolManager class provides an intermediate data storage with
  * 			a fixed pool size policy for inter-process communication.
- * @details	Uses local pool calls but is thread safe by protecting the call
- * 			with a lock.
+ * @details
+ * Uses local pool calls but is thread safe by protecting most calls
+ * with a lock. The developer can lock the pool with the provided API
+ * if the lock needs to persists beyond the function call.
+ *
+ * Other than that, the class provides the same interface as the LocalPool
+ * class. The class is always registered as a system object as it is assumed
+ * it will always be used concurrently (if this is not the case, it is
+ * recommended to use the LocalPool class instead).
  * @author 	Bastian Baetz
  */
 class PoolManager: public LocalPool {
 public:
-	PoolManager(object_id_t setObjectId, const LocalPoolConfig poolConfig);
+	PoolManager(object_id_t setObjectId, const LocalPoolConfig& poolConfig);
 
 	/**
 	 * @brief	In the PoolManager's destructor all allocated memory
@@ -23,6 +30,12 @@ public:
 	 */
 	virtual ~PoolManager();
 
+	/**
+	 * Set the default mutex timeout for internal calls.
+	 * @param mutexTimeoutMs
+	 */
+	void setMutexTimeout(uint32_t mutexTimeoutMs);
+
 	/**
 	 * @brief 	LocalPool overrides for thread-safety. Decorator function
 	 * 			which wraps LocalPool calls with a mutex protection.
@@ -31,7 +44,18 @@ public:
 	ReturnValue_t deleteData(uint8_t* buffer, size_t size,
 			store_address_t* storeId = nullptr) override;
 
-	void setMutexTimeout(uint32_t mutexTimeoutMs);
+	/**
+	 * The developer is allowed to lock the mutex in case the lock needs
+	 * to persist beyond the function calls which are not protected by the
+	 * class.
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t lockMutex(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+	ReturnValue_t unlockMutex();
+
 protected:
 	//! Default mutex timeout value to prevent permanent blocking.
 	uint32_t mutexTimeoutMs = 20;
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index d22ed661..769616d7 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -28,6 +28,9 @@ using ConstAccessorPair = std::pair<ReturnValue_t, ConstStorageAccessor>;
  */
 class StorageManagerIF : public HasReturnvaluesIF {
 public:
+	using size_type = size_t;
+	using max_pools_t = uint8_t;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::STORAGE_MANAGER_IF; //!< The unique ID for return codes for this interface.
 	static const ReturnValue_t DATA_TOO_LARGE = MAKE_RETURN_CODE(1); //!< This return code indicates that the data to be stored is too large for the store.
 	static const ReturnValue_t DATA_STORAGE_FULL = MAKE_RETURN_CODE(2); //!< This return code indicates that a data storage is full.
@@ -40,7 +43,9 @@ public:
 	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
 	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
 
-	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF; //!< Indicates an invalid (i.e unused) storage address.
+	//!< Indicates an invalid (i.e unused) storage address.
+	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
+
 	/**
 	 * @brief This is the empty virtual destructor as required for C++ interfaces.
 	 */
@@ -165,6 +170,12 @@ public:
 	 */
 	virtual void clearStore() = 0;
 
+	/**
+	 * Clears a page in the store. Use with care!
+	 * @param pageIndex
+	 */
+	virtual void clearPage(uint8_t pageIndex) = 0;
+
 	/**
 	 * Get the fill count of the pool. The exact form will be implementation
 	 * dependant.

From b6ae82ec2ceb33936f25a2f4c5b5a9ec483fe810 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:21:46 +0200
Subject: [PATCH 0911/1292] bugfixes

---
 storagemanager/LocalPool.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index bffde367..48934a0c 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -7,6 +7,10 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		SystemObject(setObjectId, registered),
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
+	if(NUMBER_OF_POOLS == 0) {
+		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
+				<< " invalid!" << std::endl;
+	}
 	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
 		this->numberOfElements[index] = currentPoolConfig.first;
@@ -168,7 +172,6 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
 }
 
 
-
 ReturnValue_t LocalPool::initialize() {
     ReturnValue_t result = SystemObject::initialize();
     if (result != RETURN_OK) {
@@ -317,13 +320,13 @@ void LocalPool::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
 			if(size != STORAGE_FREE) {
 				reservedHits++;
 			}
-			buffer[idx] = static_cast<float>(reservedHits) /
-					numberOfElements[idx] * 100;
-			*bytesWritten += 1;
-			sum += buffer[idx];
 		}
+		buffer[idx] = static_cast<float>(reservedHits) /
+				numberOfElements[idx] * 100;
+		*bytesWritten += 1;
+		sum += buffer[idx];
+		reservedHits = 0;
 	}
-	idx++;
 	buffer[idx] = sum / NUMBER_OF_POOLS;
 	*bytesWritten += 1;
 }

From ba02becfc9fa228ab156efeb1c39e7a15cae73ec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:38:41 +0200
Subject: [PATCH 0912/1292] deleted old files

---
 storagemanager/archive/LocalPool.tpp   | 305 -------------------------
 storagemanager/archive/PoolManager.tpp |  56 -----
 2 files changed, 361 deletions(-)
 delete mode 100644 storagemanager/archive/LocalPool.tpp
 delete mode 100644 storagemanager/archive/PoolManager.tpp

diff --git a/storagemanager/archive/LocalPool.tpp b/storagemanager/archive/LocalPool.tpp
deleted file mode 100644
index 5e61efe4..00000000
--- a/storagemanager/archive/LocalPool.tpp
+++ /dev/null
@@ -1,305 +0,0 @@
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-#define FSFW_STORAGEMANAGER_LOCALPOOL_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_LOCALPOOL_H_
-#error Include LocalPool.h before LocalPool.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::LocalPool(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS], bool registered,
-		bool spillsToHigherPools) :
-		SystemObject(setObjectId, registered),  internalErrorReporter(nullptr),
-		spillsToHigherPools(spillsToHigherPools)
-{
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		this->element_sizes[n] = element_sizes[n];
-		this->n_elements[n] = n_elements[n];
-		store[n] = new uint8_t[n_elements[n] * element_sizes[n]];
-		size_list[n] = new uint32_t[n_elements[n]];
-		memset(store[n], 0x00, (n_elements[n] * element_sizes[n]));
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::findEmpty(uint16_t pool_index,
-		uint16_t* element) {
-	ReturnValue_t status = DATA_STORAGE_FULL;
-	for (uint16_t foundElement = 0; foundElement < n_elements[pool_index];
-			foundElement++) {
-		if (size_list[pool_index][foundElement] == STORAGE_FREE) {
-			*element = foundElement;
-			status = RETURN_OK;
-			break;
-		}
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::write(store_address_t packet_id,
-		const uint8_t* data, size_t size) {
-	uint8_t* ptr;
-	uint32_t packet_position = getRawPosition(packet_id);
-
-	//check size? -> Not necessary, because size is checked before calling this function.
-	ptr = &store[packet_id.pool_index][packet_position];
-	memcpy(ptr, data, size);
-	size_list[packet_id.pool_index][packet_id.packet_index] = size;
-}
-
-//Returns page size of 0 in case store_index is illegal
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getPageSize(uint16_t pool_index) {
-	if (pool_index < NUMBER_OF_POOLS) {
-		return element_sizes[pool_index];
-	} else {
-		return 0;
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getPoolIndex(
-		size_t packet_size, uint16_t* poolIndex, uint16_t startAtIndex) {
-	for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-		//debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: " <<
-		//		n << ", Element Size: " << element_sizes[n] << std::endl;
-		if (element_sizes[n] >= packet_size) {
-			*poolIndex = n;
-			return RETURN_OK;
-		}
-	}
-	return DATA_TOO_LARGE;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline uint32_t LocalPool<NUMBER_OF_POOLS>::getRawPosition(
-		store_address_t packet_id) {
-	return packet_id.packet_index * element_sizes[packet_id.pool_index];
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	ReturnValue_t status = getPoolIndex(size, &address->pool_index);
-	if (status != RETURN_OK) {
-		sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
-				<< " )::reserveSpace: Packet too large." << std::endl;
-		return status;
-	}
-	status = findEmpty(address->pool_index, &address->packet_index);
-	while (status != RETURN_OK && spillsToHigherPools) {
-		status = getPoolIndex(size, &address->pool_index, address->pool_index + 1);
-		if (status != RETURN_OK) {
-			//We don't find any fitting pool anymore.
-			break;
-		}
-		status = findEmpty(address->pool_index, &address->packet_index);
-	}
-	if (status == RETURN_OK) {
-		// if (getObjectId() == objects::IPC_STORE && address->pool_index >= 3) {
-		//	   debug << "Reserve: Pool: " << std::dec << address->pool_index <<
-		//				" Index: " << address->packet_index << std::endl;
-		// }
-
-		size_list[address->pool_index][address->packet_index] = size;
-	} else {
-		if (!ignoreFault and internalErrorReporter != nullptr) {
-			internalErrorReporter->storeFull();
-		}
-		// error << "LocalPool( " << std::hex << getObjectId() << std::dec
-		// 			<< " )::reserveSpace: Packet store is full." << std::endl;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline LocalPool<NUMBER_OF_POOLS>::~LocalPool(void) {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		delete[] store[n];
-		delete[] size_list[n];
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::addData(
-		store_address_t* storageId, const uint8_t* data, size_t size,
-		bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		write(*storageId, data, size);
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getFreeElement(
-		store_address_t* storageId, const size_t size,
-		uint8_t** p_data, bool ignoreFault) {
-	ReturnValue_t status = reserveSpace(size, storageId, ignoreFault);
-	if (status == RETURN_OK) {
-		*p_data = &store[storageId->pool_index][getRawPosition(*storageId)];
-	} else {
-		*p_data = NULL;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ConstAccessorPair LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t storeId) {
-	uint8_t* tempData = nullptr;
-	ConstStorageAccessor constAccessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &tempData, &constAccessor.size_);
-	constAccessor.constDataPointer = tempData;
-	return ConstAccessorPair(status, std::move(constAccessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(store_address_t storeId,
-		ConstStorageAccessor& storeAccessor) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(storeId, &tempData, &storeAccessor.size_);
-	storeAccessor.assignStore(this);
-	storeAccessor.constDataPointer = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::getData(
-		store_address_t packet_id, const uint8_t** packet_ptr, size_t* size) {
-	uint8_t* tempData = nullptr;
-	ReturnValue_t status = modifyData(packet_id, &tempData, size);
-	*packet_ptr = tempData;
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline AccessorPair LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId) {
-	StorageAccessor accessor(storeId, this);
-	ReturnValue_t status = modifyData(storeId, &accessor.dataPointer,
-			&accessor.size_);
-	accessor.assignConstPointer();
-	return AccessorPair(status, std::move(accessor));
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t storeId, StorageAccessor& storeAccessor) {
-	storeAccessor.assignStore(this);
-	ReturnValue_t status = modifyData(storeId, &storeAccessor.dataPointer,
-			&storeAccessor.size_);
-	storeAccessor.assignConstPointer();
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::modifyData(
-		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	ReturnValue_t status = RETURN_FAILED;
-	if (packet_id.pool_index >= NUMBER_OF_POOLS) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if ((packet_id.packet_index >= n_elements[packet_id.pool_index])) {
-		return ILLEGAL_STORAGE_ID;
-	}
-	if (size_list[packet_id.pool_index][packet_id.packet_index]
-			!= STORAGE_FREE) {
-		uint32_t packet_position = getRawPosition(packet_id);
-		*packet_ptr = &store[packet_id.pool_index][packet_position];
-		*size = size_list[packet_id.pool_index][packet_id.packet_index];
-		status = RETURN_OK;
-	} else {
-		status = DATA_DOES_NOT_EXIST;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	//if (getObjectId() == objects::IPC_STORE && packet_id.pool_index >= 3) {
-	//	debug << "Delete: Pool: " << std::dec << packet_id.pool_index << " Index: "
-	//	         << packet_id.packet_index << std::endl;
-	//}
-	ReturnValue_t status = RETURN_OK;
-	uint32_t page_size = getPageSize(packet_id.pool_index);
-	if ((page_size != 0)
-			&& (packet_id.packet_index < n_elements[packet_id.pool_index])) {
-		uint16_t packet_position = getRawPosition(packet_id);
-		uint8_t* ptr = &store[packet_id.pool_index][packet_position];
-		memset(ptr, 0, page_size);
-		//Set free list
-		size_list[packet_id.pool_index][packet_id.packet_index] = STORAGE_FREE;
-	} else {
-		//pool_index or packet_index is too large
-		sif::error << "LocalPool:deleteData failed." << std::endl;
-		status = ILLEGAL_STORAGE_ID;
-	}
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void LocalPool<NUMBER_OF_POOLS>::clearStore() {
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//TODO checkme
-		memset(size_list[n], STORAGE_FREE, (n_elements[n] * sizeof(**size_list)));
-	}
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::deleteData(uint8_t* ptr,
-		size_t size, store_address_t* storeId) {
-	store_address_t localId;
-	ReturnValue_t result = ILLEGAL_ADDRESS;
-	for (uint16_t n = 0; n < NUMBER_OF_POOLS; n++) {
-		//Not sure if new allocates all stores in order. so better be careful.
-		if ((store[n] <= ptr) && (&store[n][n_elements[n]*element_sizes[n]]) > ptr) {
-			localId.pool_index = n;
-			uint32_t deltaAddress = ptr - store[n];
-			// Getting any data from the right "block" is ok.
-			// This is necessary, as IF's sometimes don't point to the first
-			// element of an object.
-			localId.packet_index = deltaAddress / element_sizes[n];
-			result = deleteData(localId);
-			//if (deltaAddress % element_sizes[n] != 0) {
-			//	error << "Pool::deleteData: address not aligned!" << std::endl;
-			//}
-			break;
-		}
-	}
-	if (storeId != NULL) {
-		*storeId = localId;
-	}
-	return result;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t LocalPool<NUMBER_OF_POOLS>::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-	internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-			objects::INTERNAL_ERROR_REPORTER);
-	if (internalErrorReporter == nullptr){
-		return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;
-	}
-
-	//Check if any pool size is large than the maximum allowed.
-	for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
-		if (element_sizes[count] >= STORAGE_FREE) {
-			sif::error << "LocalPool::initialize: Pool is too large! "
-					"Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
-			return StorageManagerIF::POOL_TOO_LARGE;
-		}
-	}
-	return RETURN_OK;
-}
-
-#endif /* FSFW_STORAGEMANAGER_LOCALPOOL_TPP_ */
diff --git a/storagemanager/archive/PoolManager.tpp b/storagemanager/archive/PoolManager.tpp
deleted file mode 100644
index 2be44ece..00000000
--- a/storagemanager/archive/PoolManager.tpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-#define FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_
-
-#ifndef FSFW_STORAGEMANAGER_POOLMANAGER_H_
-#error Include PoolManager.h before PoolManager.tpp!
-#endif
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::PoolManager(object_id_t setObjectId,
-		const uint16_t element_sizes[NUMBER_OF_POOLS],
-		const uint16_t n_elements[NUMBER_OF_POOLS]) :
-		LocalPool<NUMBER_OF_POOLS>(setObjectId, element_sizes, n_elements, true) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
-		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
-			address,ignoreFault);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
-		store_address_t packet_id) {
-	// debug << "PoolManager( " << translateObject(getObjectId()) <<
-	//       " )::deleteData from store " << packet_id.pool_index <<
-	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
-		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::WAITING, mutexTimeoutMs);
-	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
-			size, storeId);
-	return status;
-}
-
-template<uint8_t NUMBER_OF_POOLS>
-inline void PoolManager<NUMBER_OF_POOLS>::setMutexTimeout(
-		uint32_t mutexTimeoutMs) {
-	this->mutexTimeout = mutexTimeoutMs;
-}
-
-#endif /* FRAMEWORK_STORAGEMANAGER_POOLMANAGER_TPP_ */

From 6baa859628857c5ac0acbb115095eeac667c652f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 15 Oct 2020 13:42:35 +0200
Subject: [PATCH 0913/1292] fsfw config removed for now

---
 storagemanager/LocalPool.cpp   | 1 -
 storagemanager/PoolManager.cpp | 1 -
 2 files changed, 2 deletions(-)

diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 48934a0c..8e5f4d48 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,5 +1,4 @@
 #include "LocalPool.h"
-#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 85376b28..9c801a3d 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,5 +1,4 @@
 #include "PoolManager.h"
-#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):

From 91cf33127a1a869a7a0b959f609dea09ec735e57 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 00:41:50 +0200
Subject: [PATCH 0914/1292] bugfix

---
 datapoollocal/LocalPoolObjectBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b6302e7e..6494a222 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -2,7 +2,7 @@
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode) {
+        pool_rwm_t setReadWriteMode): localPoolId(poolId) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
@@ -19,7 +19,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode) {
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;

From 6f955ed8bad01074039de13e54b7534b248706c0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 00:42:49 +0200
Subject: [PATCH 0915/1292] another bugfix

---
 datapoollocal/LocalPoolObjectBase.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 6494a222..88027169 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -2,7 +2,8 @@
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId) {
+        pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
@@ -19,7 +20,8 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId) {
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
+        readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;

From 9a70f75a4bf043292f213b4791364a8183267fef Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 16 Oct 2020 01:45:07 +0200
Subject: [PATCH 0916/1292] returnvalues added

---
 memory/HasFileSystemIF.h | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 7ab4cc4e..20ef727e 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -16,12 +16,15 @@ public:
 
     static constexpr ReturnValue_t FILE_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x00);
     static constexpr ReturnValue_t FILE_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t FILE_LOCKED = MAKE_RETURN_CODE(0x02);
 
-    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t DIRECTORY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t DIRECTORY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x04);
+    static constexpr ReturnValue_t DIRECTORY_NOT_EMPTY = MAKE_RETURN_CODE(0x05);
 
-    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING = MAKE_RETURN_CODE(0x05);
+
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_WRITE = MAKE_RETURN_CODE(0x06); //! P1: Sequence number missing
+    static constexpr ReturnValue_t SEQUENCE_PACKET_MISSING_READ = MAKE_RETURN_CODE(0x07); //! P1: Sequence number missing
 
 	virtual ~HasFileSystemIF() {}
 	/**

From 02b7c51318f096447703d6845365aa568d280e03 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 16:54:55 +0200
Subject: [PATCH 0917/1292] HasParametersIF less confusing

---
 datapoolglob/DataPoolAdmin.cpp  |  4 ++--
 parameters/HasParametersIF.h    | 40 +++++++++++++++++++++------------
 parameters/ParameterHelper.cpp  | 17 +++++++-------
 parameters/ParameterWrapper.cpp | 24 ++++++++++++++++----
 parameters/ParameterWrapper.h   |  7 ++++++
 power/PowerComponent.cpp        |  1 +
 6 files changed, 64 insertions(+), 29 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 6ede0841..65ecdb16 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -194,7 +194,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 	case ParameterMessage::CMD_PARAMETER_DUMP: {
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
 
 		DataPoolParameterWrapper wrapper;
@@ -210,7 +210,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
 		uint8_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(command));
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 005403fa..286dcbc6 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,12 +1,16 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../parameters/ParameterWrapper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include "ParameterWrapper.h"
+#include <cstdint>
 
-/** Each parameter is identified with a unique parameter ID */
-typedef uint32_t ParameterId_t;
+/**
+ * Each parameter is identified with a unique parameter ID
+ * The first byte of the parameter ID will denote the domain ID.
+ * The second and third byte will be the unique identifier number.
+ */
+using ParameterId_t = uint32_t;
 
 /**
  * @brief	This interface is used by components which have modifiable
@@ -19,7 +23,7 @@ typedef uint32_t ParameterId_t;
  * The second and third byte represent the matrix ID, which can represent
  * a 8-bit row and column number and the last byte...
  *
- * Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
+ * Yeah, is it matrix ID or parameter ID now and is index a 16 bit number
  * of a 8 bit number now?
  */
 class HasParametersIF {
@@ -34,17 +38,24 @@ public:
 		return id >> 24;
 	}
 
-	static uint16_t getMatrixId(ParameterId_t id) {
-		return id >> 8;
+	static uint8_t getUniqueIdentifierId(ParameterId_t id) {
+		return id >> 16;
 	}
 
-	static uint8_t getIndex(ParameterId_t id) {
+	/**
+	 * Get the index of a parameter. Please note that the index is always a
+	 * linear index. For a vector, this is straightforward.
+	 * For a matrix, the linear indexing run from left to right, top to bottom.
+	 * @param id
+	 * @return
+	 */
+	static uint16_t getIndex(ParameterId_t id) {
 		return id;
 	}
 
-	static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
-			uint8_t index) {
-		return (domainId << 24) + (parameterId << 8) + index;
+	static uint32_t getFullParameterId(uint8_t domainId,
+	        uint8_t uniqueIdentifier, uint16_t linearIndex) {
+		return (domainId << 24) + (uniqueIdentifier << 16) + linearIndex;
 	}
 
 	virtual ~HasParametersIF() {}
@@ -56,11 +67,12 @@ public:
 	 * @param parameterId
 	 * @param parameterWrapper
 	 * @param newValues
-	 * @param startAtIndex
+	 * @param startAtIndex Linear index, runs left to right, top to bottom for
+	 * matrix indexes.
 	 * @return
 	 */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
+	virtual ReturnValue_t getParameter(uint8_t domainId,
+	        uint16_t uniqueIdentifier, ParameterWrapper *parameterWrapper,
 			const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
 };
 
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 659b00de..109ef556 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -15,9 +15,9 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		ParameterWrapper description;
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, parameterId,
+		result = owner->getParameter(domain, uniqueIdentifier,
 				&description, &description, 0);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
 			result = sendParameter(message->getSender(),
@@ -26,12 +26,11 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 	}
 		break;
 	case ParameterMessage::CMD_PARAMETER_LOAD: {
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint16_t parameterId = HasParametersIF::getMatrixId(
-				ParameterMessage::getParameterId(message));
-		uint8_t index = HasParametersIF::getIndex(
-				ParameterMessage::getParameterId(message));
+	    ParameterId_t parameterId = ParameterMessage::getParameterId(message);
+		uint8_t domain = HasParametersIF::getDomain(parameterId);
+		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+		        parameterId);
+		uint16_t index = HasParametersIF::getIndex(parameterId);
 
 		const uint8_t *storedStream = nullptr;
 		size_t storedStreamSize = 0;
@@ -52,7 +51,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		}
 
 		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, parameterId, &ownerWrapper,
+		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
 				&streamWrapper, index);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			storage->deleteData(ParameterMessage::getStoreId(message));
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 6adc6857..76c80887 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -202,11 +202,11 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
-	if (data == NULL) {
+	if (data == nullptr) {
 		return READONLY;
 	}
 
-	if (from->readonlyData == NULL) {
+	if (from->readonlyData == nullptr) {
 		return SOURCE_NOT_SET;
 	}
 
@@ -215,8 +215,10 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 	}
 
 	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
+	uint8_t startingRow = 0;
+	uint8_t startingColumn = 0;
+	ParameterWrapper::convertLinearIndexToRowAndColumn(startWritingAtIndex,
+	        &startingRow, &startingColumn);
 
 	if ((from->rows > (rows - startingRow))
 			|| (from->columns > (columns - startingColumn))) {
@@ -279,3 +281,17 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 
 	return result;
 }
+
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index, uint8_t *row,
+        uint8_t *column) {
+    if(row == nullptr or column == nullptr) {
+        return;
+    }
+    *row = index / columns;
+    *column = index % columns;
+}
+
+uint16_t ParameterWrapper::convertRowAndColumnToLinearIndex(uint8_t row,
+        uint8_t column) {
+    return row * columns + column;
+}
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index f07205d4..7a9145b4 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -113,6 +113,13 @@ public:
 			uint16_t startWritingAtIndex);
 
 private:
+
+    void convertLinearIndexToRowAndColumn(uint16_t index,
+            uint8_t *row, uint8_t *column);
+
+    uint16_t convertRowAndColumnToLinearIndex(uint8_t row,
+            uint8_t column);
+
 	bool pointsToStream = false;
 
 	Type type;
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index 4af7c96b..f42c3153 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -1,4 +1,5 @@
 #include "PowerComponent.h"
+#include "../serialize/SerializeAdapter.h"
 
 PowerComponent::PowerComponent(): switchId1(0xFF), switchId2(0xFF),
         doIHaveTwoSwitches(false) {

From 3b0b474ab6e5586cd81c4950d9af1b61f7c07518 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:01:49 +0200
Subject: [PATCH 0918/1292] better naming

---
 parameters/ParameterHelper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 109ef556..a3b615f8 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -30,7 +30,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 		uint8_t domain = HasParametersIF::getDomain(parameterId);
 		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 		        parameterId);
-		uint16_t index = HasParametersIF::getIndex(parameterId);
+		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
 		const uint8_t *storedStream = nullptr;
 		size_t storedStreamSize = 0;
@@ -52,13 +52,13 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 
 		ParameterWrapper ownerWrapper;
 		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
-				&streamWrapper, index);
+				&streamWrapper, linearIndex);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			storage->deleteData(ParameterMessage::getStoreId(message));
 			break;
 		}
 
-		result = ownerWrapper.copyFrom(&streamWrapper, index);
+		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
 
 		storage->deleteData(ParameterMessage::getStoreId(message));
 

From 8e498060571c89c06574f1a9aec381fb3290f886 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:23:47 +0200
Subject: [PATCH 0919/1292] some adaptions

---
 parameters/ParameterMessage.cpp | 8 ++++++--
 parameters/ParameterMessage.h   | 3 ++-
 parameters/ParameterWrapper.h   | 6 ++++--
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index e9f3191f..81bed871 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -25,10 +25,14 @@ void ParameterMessage::setParameterDumpReply(CommandMessage* message,
 }
 
 void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
-		ParameterId_t id, store_address_t storageID) {
+		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
+		uint8_t row, uint8_t column) {
 	message->setCommand(CMD_PARAMETER_LOAD);
 	message->setParameter(id);
-	message->setParameter2(storageID.raw);
+	message->setParameter2(storeId.raw);
+	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
+	        (row << 8) | column;
+	message->setParameter3(packedParameterSettings);
 }
 
 void ParameterMessage::clear(CommandMessage* message) {
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 31d7fe0b..6eb9ed8e 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -21,7 +21,8 @@ public:
 	static void setParameterDumpReply(CommandMessage* message,
 			ParameterId_t id,  store_address_t storageID);
 	static void setParameterLoadCommand(CommandMessage* message,
-			ParameterId_t id, store_address_t storageID);
+	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
+	        uint8_t pfc, uint8_t row, uint8_t column);
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 7a9145b4..75f7af9b 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -97,12 +97,14 @@ public:
 	}
 	template<typename T>
 	void setMatrix(T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
 	template<typename T>
 	void setMatrix(const T& member) {
-		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
+		this->set(member[0], sizeof(member)/sizeof(member[0]),
+		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,

From 88a89d6797a22c108d2841a1f7c835edf55afcec Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 17:32:10 +0200
Subject: [PATCH 0920/1292] added basic documentation

---
 parameters/ParameterMessage.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 6eb9ed8e..8e6e3f8e 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -20,6 +20,19 @@ public:
 			ParameterId_t id);
 	static void setParameterDumpReply(CommandMessage* message,
 			ParameterId_t id,  store_address_t storageID);
+
+	/**
+	 * Command to set a load parameter message. The CCSDS / ECSS type in
+	 * form of a PTC and a PFC is expected. See ECSS-E-ST-70-41C15 p.428
+	 * for all types or the Type class in globalfunctions.
+	 * @param message
+	 * @param id
+	 * @param storeId
+	 * @param ptc
+	 * @param pfc
+	 * @param row
+	 * @param column
+	 */
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
 	        uint8_t pfc, uint8_t row, uint8_t column);

From 8b8324f21c1b0d30ba1c5ef7919846bfeb283e62 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 18 Oct 2020 23:50:02 +0200
Subject: [PATCH 0921/1292] some stuff renamed

---
 datapoolglob/DataPoolParameterWrapper.cpp | 2 +-
 fdir/FaultCounter.cpp                     | 2 +-
 monitoring/AbsLimitMonitor.h              | 4 ++--
 monitoring/LimitMonitor.h                 | 4 ++--
 monitoring/MonitorReporter.h              | 2 +-
 monitoring/TriplexMonitor.h               | 2 +-
 parameters/HasParametersIF.h              | 2 +-
 power/PowerComponent.cpp                  | 2 +-
 thermal/CoreComponent.cpp                 | 2 +-
 thermal/Heater.cpp                        | 2 +-
 thermal/TemperatureSensor.h               | 2 +-
 thermal/ThermalComponent.cpp              | 4 ++--
 12 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/datapoolglob/DataPoolParameterWrapper.cpp
index 3a57d90d..e5d55006 100644
--- a/datapoolglob/DataPoolParameterWrapper.cpp
+++ b/datapoolglob/DataPoolParameterWrapper.cpp
@@ -23,7 +23,7 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
 	ReturnValue_t status = mySet.read();
 	if (status != HasReturnvaluesIF::RETURN_OK) {
 		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_MATRIX_ID;
+		return HasParametersIF::INVALID_IDENTIFIER_ID;
 	}
 
 	type = raw.getType();
diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp
index 443adb52..6519a3a8 100644
--- a/fdir/FaultCounter.cpp
+++ b/fdir/FaultCounter.cpp
@@ -76,7 +76,7 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(timer.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index c9c33c74..5891c36a 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -39,7 +39,7 @@ public:
 				parameterId, parameterWrapper, newValues, startAtIndex);
 		// We'll reuse the DOMAIN_ID of MonitorReporter,
 		// as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -47,7 +47,7 @@ public:
 			parameterWrapper->set(this->limit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 66e6725e..abcbe8e8 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -41,7 +41,7 @@ public:
 		ReturnValue_t result = this->MonitorBase<T>::getParameter(domainId,
 				parameterId, parameterWrapper, newValues, startAtIndex);
 		//We'll reuse the DOMAIN_ID of MonitorReporter, as we know the parameterIds used there.
-		if (result != this->INVALID_MATRIX_ID) {
+		if (result != this->INVALID_IDENTIFIER_ID) {
 			return result;
 		}
 		switch (parameterId) {
@@ -52,7 +52,7 @@ public:
 			parameterWrapper->set(this->upperLimit);
 			break;
 		default:
-			return this->INVALID_MATRIX_ID;
+			return this->INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 88fa6ede..286d82cf 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -65,7 +65,7 @@ public:
 			parameterWrapper->set(this->eventEnabled);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h
index 9b60aeb6..c4b3c537 100644
--- a/monitoring/TriplexMonitor.h
+++ b/monitoring/TriplexMonitor.h
@@ -82,7 +82,7 @@ public:
 			parameterWrapper->set(limit);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index 286dcbc6..c4fd81b3 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -29,7 +29,7 @@ using ParameterId_t = uint32_t;
 class HasParametersIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
-	static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
+	static const ReturnValue_t INVALID_IDENTIFIER_ID = MAKE_RETURN_CODE(0x01);
 	static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
 	static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
 	static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp
index f42c3153..c31b9a85 100644
--- a/power/PowerComponent.cpp
+++ b/power/PowerComponent.cpp
@@ -75,7 +75,7 @@ ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set<>(max);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/CoreComponent.cpp b/thermal/CoreComponent.cpp
index 657e79cb..90d10eda 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/CoreComponent.cpp
@@ -251,7 +251,7 @@ ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(parameters.upperOpLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp
index 2bee47f1..ce965d5e 100644
--- a/thermal/Heater.cpp
+++ b/thermal/Heater.cpp
@@ -301,7 +301,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint16_t parameterId,
 		parameterWrapper->set(heaterOnCountdown.timeout);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h
index 9b4f0e60..f41b3761 100644
--- a/thermal/TemperatureSensor.h
+++ b/thermal/TemperatureSensor.h
@@ -208,7 +208,7 @@ public:
 			parameterWrapper->set(parameters.gradient);
 			break;
 		default:
-			return INVALID_MATRIX_ID;
+			return INVALID_IDENTIFIER_ID;
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 50786654..6bc09e55 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -151,7 +151,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
 	ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_MATRIX_ID) {
+	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
 	}
 	switch (parameterId) {
@@ -162,7 +162,7 @@ ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		parameterWrapper->set(nopParameters.upperNopLimit);
 		break;
 	default:
-		return INVALID_MATRIX_ID;
+		return INVALID_IDENTIFIER_ID;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

From ad9ac7537e150150679a4104b915836f8cc0f248 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:25:03 +0200
Subject: [PATCH 0922/1292] bool is mapped to uint8 now for pod type conversion

---
 globalfunctions/Type.h         |  4 ++++
 parameters/ParameterHelper.cpp | 18 ++++++++++--------
 parameters/ParameterWrapper.h  |  2 +-
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 6910f909..8d03c467 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -59,6 +59,10 @@ struct PodTypeConversion {
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
+struct PodTypeConversion<bool> {
+    static const Type::ActualType_t type = Type::UINT8_T;
+};
+template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index a3b615f8..e2ea4eb6 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -9,6 +9,10 @@ ParameterHelper::~ParameterHelper() {
 }
 
 ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
+    if(storage == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
 	switch (message->getCommand()) {
 	case ParameterMessage::CMD_PARAMETER_DUMP: {
@@ -112,15 +116,13 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 }
 
 ReturnValue_t ParameterHelper::initialize() {
-	ownerQueueId = owner->getCommandQueue();
+    ownerQueueId = owner->getCommandQueue();
 
-
-	storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (storage == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	} else {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    if (storage == nullptr) {
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 75f7af9b..e0a2d27e 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -68,7 +68,7 @@ public:
 
 	template<typename T>
 	void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
-		this->data = NULL;
+		this->data = nullptr;
 		this->readonlyData = readonlyData;
 		this->type = PodTypeConversion<T>::type;
 		this->rows = rows;

From 75e67ce5f8e1383796de2c0c9f7754456d011625 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:37:26 +0200
Subject: [PATCH 0923/1292] small form improvements

---
 parameters/ParameterWrapper.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 76c80887..e78c52be 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -115,7 +115,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 		uint8_t fromColumns) {
 
 	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t*) from;
+	const uint8_t *fromAsStream = reinterpret_cast<const uint8_t*>(from);
 	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -123,8 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-		T *dataWithDataType = ((T*) data)
-				+ (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
 			result = SerializeAdapter::deSerialize(

From 22e4e464c79fe2924c3a2a88948b0b17c31dab9a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 00:43:10 +0200
Subject: [PATCH 0924/1292] doc improved, new returnvalue

---
 parameters/ParameterMessage.cpp |  4 ++--
 parameters/ParameterMessage.h   | 10 +++++-----
 parameters/ParameterWrapper.cpp |  7 +++++++
 parameters/ParameterWrapper.h   |  1 +
 4 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 81bed871..4a8545eb 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -26,12 +26,12 @@ void ParameterMessage::setParameterDumpReply(CommandMessage* message,
 
 void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
 		ParameterId_t id, store_address_t storeId, uint8_t ptc, uint8_t pfc,
-		uint8_t row, uint8_t column) {
+		uint8_t rows = 1, uint8_t columns = 1) {
 	message->setCommand(CMD_PARAMETER_LOAD);
 	message->setParameter(id);
 	message->setParameter2(storeId.raw);
 	uint32_t packedParameterSettings = (ptc << 24) | (pfc << 16) |
-	        (row << 8) | column;
+	        (rows << 8) | columns;
 	message->setParameter3(packedParameterSettings);
 }
 
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index 8e6e3f8e..c87c508c 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -28,14 +28,14 @@ public:
 	 * @param message
 	 * @param id
 	 * @param storeId
-	 * @param ptc
-	 * @param pfc
-	 * @param row
-	 * @param column
+	 * @param ptc Type information according to CCSDS/ECSS standards
+	 * @param pfc Type information according to CCSDS/ECSS standards
+	 * @param rows Set number of rows in parameter set, minimum one.
+	 * @param columns Set number of columns in parameter set, minimum one
 	 */
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
-	        uint8_t pfc, uint8_t row, uint8_t column);
+	        uint8_t pfc, uint8_t rows, uint8_t columns);
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index e78c52be..17fb3153 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -202,6 +202,8 @@ ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 
 ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		uint16_t startWritingAtIndex) {
+    // TODO: Optional diagnostic output (which can be disabled in FSFWConfig)
+    // to determined faulty implementations and configuration errors quickly.
 	if (data == nullptr) {
 		return READONLY;
 	}
@@ -214,6 +216,11 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		return DATATYPE_MISSMATCH;
 	}
 
+	// The smallest allowed value for rows and columns is one.
+	if(rows == 0 or columns == 0) {
+	    return COLUMN_OR_ROWS_ZERO;
+	}
+
 	//check if from fits into this
 	uint8_t startingRow = 0;
 	uint8_t startingColumn = 0;
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index e0a2d27e..46044f25 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -22,6 +22,7 @@ public:
 	static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
 	static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
 	static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
+	static const ReturnValue_t COLUMN_OR_ROWS_ZERO = MAKE_RETURN_CODE(0x08);
 
 	ParameterWrapper();
 	ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);

From 95924dd55bf9d6f1f8231fd16b8b3a54871caf32 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 19 Oct 2020 15:38:22 +0200
Subject: [PATCH 0925/1292] some more bugfixes

---
 datapoolglob/DataPoolAdmin.cpp  |  4 +--
 parameters/ParameterHelper.cpp  | 45 +++++++++++++++++----------------
 parameters/ParameterMessage.cpp | 12 +++++++++
 parameters/ParameterMessage.h   | 19 ++++++++++++++
 parameters/ParameterWrapper.cpp | 22 ++++++++++++++--
 parameters/ParameterWrapper.h   |  7 +++--
 6 files changed, 81 insertions(+), 28 deletions(-)

diff --git a/datapoolglob/DataPoolAdmin.cpp b/datapoolglob/DataPoolAdmin.cpp
index 65ecdb16..2bae75f0 100644
--- a/datapoolglob/DataPoolAdmin.cpp
+++ b/datapoolglob/DataPoolAdmin.cpp
@@ -210,9 +210,9 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
 
 		uint8_t domain = HasParametersIF::getDomain(
 				ParameterMessage::getParameterId(command));
-		uint16_t parameterId = HasParametersIF::getUniqueIdentifierId(
+		uint8_t parameterId = HasParametersIF::getUniqueIdentifierId(
 				ParameterMessage::getParameterId(command));
-		uint8_t index = HasParametersIF::getIndex(
+		uint16_t index = HasParametersIF::getIndex(
 				ParameterMessage::getParameterId(command));
 
 		const uint8_t *storedStream;
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index e2ea4eb6..d2193b28 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -10,6 +10,7 @@ ParameterHelper::~ParameterHelper() {
 
 ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
     if(storage == nullptr) {
+        // ParameterHelper was not initialized
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -30,48 +31,48 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
 	}
 		break;
 	case ParameterMessage::CMD_PARAMETER_LOAD: {
-	    ParameterId_t parameterId = ParameterMessage::getParameterId(message);
+	    ParameterId_t parameterId = 0;
+	    uint8_t ptc = 0;
+	    uint8_t pfc = 0;
+	    uint8_t rows = 0;
+	    uint8_t columns = 0;
+	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+	            message, &parameterId, &ptc, &pfc, &rows, &columns);
+	    Type type(Type::getActualType(ptc, pfc));
+
 		uint8_t domain = HasParametersIF::getDomain(parameterId);
 		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
 		        parameterId);
 		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
-		const uint8_t *storedStream = nullptr;
-		size_t storedStreamSize = 0;
-		result = storage->getData(
-				ParameterMessage::getStoreId(message), &storedStream,
-				&storedStreamSize);
+		ConstStorageAccessor accessor(storeId);
+		result = storage->getData(storeId, accessor);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					" store data failed for load command." << std::endl;
+					<< " store data failed for load command." << std::endl;
 			break;
 		}
 
 		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(storedStream, storedStreamSize);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
+		result = streamWrapper.set(type, rows, columns, accessor.data(),
+		        accessor.size());
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+		    return result;
 		}
 
 		ParameterWrapper ownerWrapper;
 		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
 				&streamWrapper, linearIndex);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			storage->deleteData(ParameterMessage::getStoreId(message));
-			break;
-		}
 
 		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
-
-		storage->deleteData(ParameterMessage::getStoreId(message));
-
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &ownerWrapper);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+		    return result;
 		}
-	}
+
+        result = sendParameter(message->getSender(),
+                ParameterMessage::getParameterId(message), &ownerWrapper);
 		break;
+	}
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp
index 4a8545eb..af1f9ce8 100644
--- a/parameters/ParameterMessage.cpp
+++ b/parameters/ParameterMessage.cpp
@@ -35,6 +35,18 @@ void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
 	message->setParameter3(packedParameterSettings);
 }
 
+store_address_t ParameterMessage::getParameterLoadCommand(
+        const CommandMessage *message, ParameterId_t* parameterId, uint8_t *ptc,
+        uint8_t *pfc, uint8_t *rows, uint8_t *columns) {
+    *parameterId = message->getParameter2();
+    uint32_t packedParamSettings = message->getParameter3();
+    *ptc = packedParamSettings >> 24 & 0xff;
+    *pfc = packedParamSettings >> 16 & 0xff;
+    *rows = packedParamSettings >> 8 & 0xff;
+    *columns = packedParamSettings & 0xff;
+    return message->getParameter2();
+}
+
 void ParameterMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_PARAMETER_LOAD:
diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h
index c87c508c..fd4481ee 100644
--- a/parameters/ParameterMessage.h
+++ b/parameters/ParameterMessage.h
@@ -5,6 +5,20 @@
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
 
+/**
+ * @brief   ParameterMessage interface
+ * @details
+ * General structure of a parameter message:
+ *  1. 4-byte Object ID
+ *  2. 4-byte Parameter ID, first byte is Domain ID, second byte is unique
+ *     identifier, third and fourth byte is linear index to start from
+ *  3. 4-byte Parameter Settings. First byte and second byte are the PTC and PFC
+ *     ECSS type identifiers (see ECSS-E-ST-70-41C15 p.428 or Type class in
+ *     globalfunctions). Third byte is the number of rows and fourth byte
+ *     is the number of columns. For single variable parameters, this will
+ *     be [1, 1].
+ *
+ */
 class ParameterMessage {
 private:
 	ParameterMessage();
@@ -36,6 +50,11 @@ public:
 	static void setParameterLoadCommand(CommandMessage* message,
 	        ParameterId_t id, store_address_t storeId, uint8_t ptc,
 	        uint8_t pfc, uint8_t rows, uint8_t columns);
+
+	static store_address_t getParameterLoadCommand(
+	        const CommandMessage* message, ParameterId_t* parameterId,
+	        uint8_t* ptc, uint8_t* pfc, uint8_t* rows, uint8_t* columns) ;
+
 	static void clear(CommandMessage* message);
 
 };
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 17fb3153..23955516 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -159,6 +159,23 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
+ReturnValue_t ParameterWrapper::set(Type type, uint8_t rows, uint8_t columns,
+        const void *data, size_t dataSize) {
+    this->type = type;
+    this->rows = rows;
+    this->columns = columns;
+
+    size_t expectedSize = type.getSize() * rows * columns;
+    if (expectedSize < dataSize) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
+    this->data = nullptr;
+    this->readonlyData = data;
+    pointsToStream = true;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
 		const uint8_t **remainingStream, size_t *remainingSize) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
@@ -289,11 +306,12 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 	return result;
 }
 
-void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index, uint8_t *row,
-        uint8_t *column) {
+void ParameterWrapper::convertLinearIndexToRowAndColumn(uint16_t index,
+        uint8_t *row, uint8_t *column) {
     if(row == nullptr or column == nullptr) {
         return;
     }
+    // Integer division.
     *row = index / columns;
     *column = index % columns;
 }
diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h
index 46044f25..168a535f 100644
--- a/parameters/ParameterWrapper.h
+++ b/parameters/ParameterWrapper.h
@@ -108,6 +108,9 @@ public:
 		        sizeof(member[0])/sizeof(member[0][0]));
 	}
 
+	ReturnValue_t set(Type type, uint8_t rows, uint8_t columns,
+	        const void *data, size_t dataSize);
+
 	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
 			const uint8_t **remainingStream = nullptr,
 			size_t *remainingSize = nullptr);
@@ -158,9 +161,9 @@ inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
 	if (pointsToStream) {
 		const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
 		streamWithType += (row * columns + column) * type.getSize();
-		int32_t size = type.getSize();
+		size_t size = type.getSize();
 		return SerializeAdapter::deSerialize(value, &streamWithType,
-				&size, true);
+				&size, SerializeIF::Endianness::BIG);
 	}
 	else {
 		const T *dataWithType = static_cast<const T*>(readonlyData);

From 7033328962e8997e1757b5ca0999a89a9d04c7fc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:12:56 +0200
Subject: [PATCH 0926/1292] unittest folder added

---
 unittest/Makefile-FSFW-Tests                  |   415 +
 unittest/README.md                            |   121 +
 unittest/catch2/LICENSE.txt                   |    23 +
 unittest/catch2/catch.hpp                     | 17618 ++++++++++++++++
 unittest/catch2/catch_reporter_automake.hpp   |    62 +
 unittest/catch2/catch_reporter_sonarqube.hpp  |   181 +
 unittest/catch2/catch_reporter_tap.hpp        |   253 +
 unittest/catch2/catch_reporter_teamcity.hpp   |   219 +
 unittest/config/FSFWConfig.h                  |    32 +
 unittest/config/TestsConfig.h                 |     8 +
 unittest/config/cdatapool/dataPoolInit.cpp    |    48 +
 unittest/config/cdatapool/dataPoolInit.h      |    29 +
 unittest/config/config.mk                     |    15 +
 unittest/config/devices/logicalAddresses.cpp  |    11 +
 unittest/config/devices/logicalAddresses.h    |    15 +
 unittest/config/devices/powerSwitcherList.cpp |    10 +
 unittest/config/devices/powerSwitcherList.h   |    22 +
 unittest/config/events/translateEvents.cpp    |    20 +
 unittest/config/events/translateEvents.h      |    16 +
 unittest/config/ipc/MissionMessageTypes.cpp   |    11 +
 unittest/config/ipc/MissionMessageTypes.h     |    22 +
 unittest/config/objects/Factory.cpp           |    37 +
 unittest/config/objects/Factory.h             |    16 +
 unittest/config/objects/systemObjectList.h    |    30 +
 unittest/config/objects/translateObjects.cpp  |   242 +
 unittest/config/objects/translateObjects.h    |    16 +
 .../PollingSequenceFactory.cpp                |    31 +
 .../pollingsequence/PollingSequenceFactory.h  |    31 +
 unittest/config/returnvalues/classIds.h       |    28 +
 unittest/config/tmtc/PusIds.hpp               |    29 +
 unittest/config/tmtc/apid.h                   |    19 +
 unittest/config/tmtc/pusIds.h                 |    23 +
 unittest/config/tmtc/subsystemIdRanges.h      |    34 +
 unittest/config/tmtc/tmTcSize.h               |    10 +
 unittest/config/version.h                     |     7 +
 unittest/core/CatchDefinitions.cpp            |    11 +
 unittest/core/CatchDefinitions.h              |    19 +
 unittest/core/CatchRunner.cpp                 |    27 +
 unittest/core/CatchSetup.cpp                  |    41 +
 unittest/core/core.mk                         |     3 +
 unittest/core/printChar.cpp                   |    10 +
 unittest/core/printChar.h                     |     8 +
 unittest/internal/InternalUnitTester.cpp      |    26 +
 unittest/internal/InternalUnitTester.h        |    29 +
 unittest/internal/UnittDefinitions.cpp        |     7 +
 unittest/internal/UnittDefinitions.h          |    33 +
 unittest/internal/osal/IntTestMq.cpp          |    52 +
 unittest/internal/osal/IntTestMq.h            |     9 +
 unittest/internal/osal/IntTestMutex.cpp       |    41 +
 unittest/internal/osal/IntTestMutex.h         |    10 +
 unittest/internal/osal/IntTestSemaphore.cpp   |   159 +
 unittest/internal/osal/IntTestSemaphore.h     |    15 +
 .../serialize/IntTestSerialization.cpp        |   230 +
 .../internal/serialize/IntTestSerialization.h |    15 +
 unittest/lcov.sh                              |     3 +
 unittest/tests/action/TestActionHelper.cpp    |   105 +
 unittest/tests/action/TestActionHelper.h      |   131 +
 unittest/tests/container/RingBufferTest.cpp   |   327 +
 unittest/tests/container/TestArrayList.cpp    |    90 +
 unittest/tests/container/TestDynamicFifo.cpp  |   149 +
 unittest/tests/container/TestFifo.cpp         |   138 +
 .../tests/container/TestFixedArrayList.cpp    |    41 +
 unittest/tests/container/TestFixedMap.cpp     |   172 +
 .../container/TestFixedOrderedMultimap.cpp    |   203 +
 .../tests/container/TestPlacementFactory.cpp  |    45 +
 unittest/tests/osal/TestMessageQueue.cpp      |    40 +
 unittest/tests/osal/TestSemaphore.cpp         |    46 +
 .../serialize/TestSerialBufferAdapter.cpp     |   143 +
 .../serialize/TestSerialLinkedPacket.cpp      |    73 +
 .../tests/serialize/TestSerialLinkedPacket.h  |    61 +
 .../tests/serialize/TestSerialization.cpp     |   129 +
 .../tests/storagemanager/TestNewAccessor.cpp  |   161 +
 unittest/tests/storagemanager/TestPool.cpp    |   105 +
 unittest/tests/tests.mk                       |     8 +
 unittest/testtemplate/TestTemplate.cpp        |    31 +
 unittest/unlockRealtime.sh                    |    34 +
 76 files changed, 22684 insertions(+)
 create mode 100644 unittest/Makefile-FSFW-Tests
 create mode 100644 unittest/README.md
 create mode 100644 unittest/catch2/LICENSE.txt
 create mode 100644 unittest/catch2/catch.hpp
 create mode 100644 unittest/catch2/catch_reporter_automake.hpp
 create mode 100644 unittest/catch2/catch_reporter_sonarqube.hpp
 create mode 100644 unittest/catch2/catch_reporter_tap.hpp
 create mode 100644 unittest/catch2/catch_reporter_teamcity.hpp
 create mode 100644 unittest/config/FSFWConfig.h
 create mode 100644 unittest/config/TestsConfig.h
 create mode 100644 unittest/config/cdatapool/dataPoolInit.cpp
 create mode 100644 unittest/config/cdatapool/dataPoolInit.h
 create mode 100644 unittest/config/config.mk
 create mode 100644 unittest/config/devices/logicalAddresses.cpp
 create mode 100644 unittest/config/devices/logicalAddresses.h
 create mode 100644 unittest/config/devices/powerSwitcherList.cpp
 create mode 100644 unittest/config/devices/powerSwitcherList.h
 create mode 100644 unittest/config/events/translateEvents.cpp
 create mode 100644 unittest/config/events/translateEvents.h
 create mode 100644 unittest/config/ipc/MissionMessageTypes.cpp
 create mode 100644 unittest/config/ipc/MissionMessageTypes.h
 create mode 100644 unittest/config/objects/Factory.cpp
 create mode 100644 unittest/config/objects/Factory.h
 create mode 100644 unittest/config/objects/systemObjectList.h
 create mode 100644 unittest/config/objects/translateObjects.cpp
 create mode 100644 unittest/config/objects/translateObjects.h
 create mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.cpp
 create mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.h
 create mode 100644 unittest/config/returnvalues/classIds.h
 create mode 100644 unittest/config/tmtc/PusIds.hpp
 create mode 100644 unittest/config/tmtc/apid.h
 create mode 100644 unittest/config/tmtc/pusIds.h
 create mode 100644 unittest/config/tmtc/subsystemIdRanges.h
 create mode 100644 unittest/config/tmtc/tmTcSize.h
 create mode 100644 unittest/config/version.h
 create mode 100644 unittest/core/CatchDefinitions.cpp
 create mode 100644 unittest/core/CatchDefinitions.h
 create mode 100644 unittest/core/CatchRunner.cpp
 create mode 100644 unittest/core/CatchSetup.cpp
 create mode 100644 unittest/core/core.mk
 create mode 100644 unittest/core/printChar.cpp
 create mode 100644 unittest/core/printChar.h
 create mode 100644 unittest/internal/InternalUnitTester.cpp
 create mode 100644 unittest/internal/InternalUnitTester.h
 create mode 100644 unittest/internal/UnittDefinitions.cpp
 create mode 100644 unittest/internal/UnittDefinitions.h
 create mode 100644 unittest/internal/osal/IntTestMq.cpp
 create mode 100644 unittest/internal/osal/IntTestMq.h
 create mode 100644 unittest/internal/osal/IntTestMutex.cpp
 create mode 100644 unittest/internal/osal/IntTestMutex.h
 create mode 100644 unittest/internal/osal/IntTestSemaphore.cpp
 create mode 100644 unittest/internal/osal/IntTestSemaphore.h
 create mode 100644 unittest/internal/serialize/IntTestSerialization.cpp
 create mode 100644 unittest/internal/serialize/IntTestSerialization.h
 create mode 100644 unittest/lcov.sh
 create mode 100644 unittest/tests/action/TestActionHelper.cpp
 create mode 100644 unittest/tests/action/TestActionHelper.h
 create mode 100644 unittest/tests/container/RingBufferTest.cpp
 create mode 100644 unittest/tests/container/TestArrayList.cpp
 create mode 100644 unittest/tests/container/TestDynamicFifo.cpp
 create mode 100644 unittest/tests/container/TestFifo.cpp
 create mode 100644 unittest/tests/container/TestFixedArrayList.cpp
 create mode 100644 unittest/tests/container/TestFixedMap.cpp
 create mode 100644 unittest/tests/container/TestFixedOrderedMultimap.cpp
 create mode 100644 unittest/tests/container/TestPlacementFactory.cpp
 create mode 100644 unittest/tests/osal/TestMessageQueue.cpp
 create mode 100644 unittest/tests/osal/TestSemaphore.cpp
 create mode 100644 unittest/tests/serialize/TestSerialBufferAdapter.cpp
 create mode 100644 unittest/tests/serialize/TestSerialLinkedPacket.cpp
 create mode 100644 unittest/tests/serialize/TestSerialLinkedPacket.h
 create mode 100644 unittest/tests/serialize/TestSerialization.cpp
 create mode 100644 unittest/tests/storagemanager/TestNewAccessor.cpp
 create mode 100644 unittest/tests/storagemanager/TestPool.cpp
 create mode 100644 unittest/tests/tests.mk
 create mode 100644 unittest/testtemplate/TestTemplate.cpp
 create mode 100644 unittest/unlockRealtime.sh

diff --git a/unittest/Makefile-FSFW-Tests b/unittest/Makefile-FSFW-Tests
new file mode 100644
index 00000000..d43a6edc
--- /dev/null
+++ b/unittest/Makefile-FSFW-Tests
@@ -0,0 +1,415 @@
+#-------------------------------------------------------------------------------
+# Makefile  for FSFW Test
+#-------------------------------------------------------------------------------
+#		User-modifiable options
+#-------------------------------------------------------------------------------
+# Fundamentals on the build process of C/C++ Software:
+# https://www3.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html
+
+# Make documentation: https://www.gnu.org/software/make/manual/make.pdf
+# Online: https://www.gnu.org/software/make/manual/make.html
+# General rules: http://make.mad-scientist.net/papers/rules-of-makefiles/#rule3
+SHELL = /bin/sh
+
+# Chip & board used for compilation
+# (can be overriden by adding CHIP=chip and BOARD=board to the command-line)
+# Unit Test can only be run on host machine for now (Linux)
+FRAMEWORK_PATH = fsfw
+FILE_ROOT = $(FRAMEWORK_PATH)/unittest
+BOARD = unittest
+LINUX = 1
+OS_FSFW = linux
+CUSTOM_DEFINES += -D$(OS_FSFW)
+
+# Copied from stackoverflow, can be used to differentiate between Windows
+# and Linux
+ifeq ($(OS),Windows_NT)
+    CUSTOM_DEFINES += -DWIN32
+    ifeq ($(PROCESSOR_ARCHITEW6432),AMD64)
+        CUSTOM_DEFINES += -DAMD64
+    else
+        ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
+            CUSTOM_DEFINES += -DAMD64
+        endif
+        ifeq ($(PROCESSOR_ARCHITECTURE),x86)
+            CUSTOM_DEFINES += -DIA32
+        endif
+    endif
+else
+    UNAME_S := $(shell uname -s)
+    ifeq ($(UNAME_S),Linux)
+    	DETECTED_OS = LINUX
+        CUSTOM_DEFINES += -DLINUX
+    endif
+    ifeq ($(UNAME_S),Darwin)
+        CUSTOM_DEFINES += -DOSX
+    endif
+    UNAME_P := $(shell uname -p)
+    ifeq ($(UNAME_P),x86_64)
+        CUSTOM_DEFINES += -DAMD64
+    endif
+    ifneq ($(filter %86,$(UNAME_P)),)
+        CUSTOM_DEFINES += -DIA32
+    endif
+    ifneq ($(filter arm%,$(UNAME_P)),)
+        CUSTOM_DEFINES += -DARM
+    endif
+endif
+
+UNIT_TEST = 1
+# General folder paths
+CONFIG_PATH = $(FILE_ROOT)/config
+UNIT_TEST_PATH = $(FILE_ROOT)/tests
+CORE_PATH = $(FILE_ROOT)/core
+
+# Output file basename
+BASENAME = fsfw
+BINARY_NAME := $(BASENAME)-$(BOARD)
+# Output files will be put in this directory inside
+OUTPUT_FOLDER = $(OS)
+
+# Optimization level. Optimized for debugging.
+OPTIMIZATION = -O0
+
+# Default debug output. Optimized for debugging.
+DEBUG_LEVEL = -g3
+
+ifdef GCOV
+CUSTOM_DEFINES += -DGCOV
+endif
+
+
+# Output directories
+BUILDPATH = _bin
+DEPENDPATH = _dep
+OBJECTPATH = _obj
+
+ifeq ($(MAKECMDGOALS),mission)
+BUILD_FOLDER = mission
+else 
+BUILD_FOLDER = devel
+endif
+
+DEPENDDIR = $(DEPENDPATH)/$(OUTPUT_FOLDER)/$(BUILD_FOLDER)
+OBJDIR = $(OBJECTPATH)/$(OUTPUT_FOLDER)/$(BUILD_FOLDER)
+BINDIR = $(BUILDPATH)
+
+CLEANDEP = $(DEPENDPATH)/$(OUTPUT_FOLDER)
+CLEANOBJ = $(OBJECTPATH)/$(OUTPUT_FOLDER)
+CLEANBIN = $(BUILDPATH)
+#-------------------------------------------------------------------------------
+#		Tools and Includes
+#-------------------------------------------------------------------------------
+
+# Tool suffix when cross-compiling
+CROSS_COMPILE =
+
+# C Compiler
+CC = $(CROSS_COMPILE)gcc
+
+# C++ compiler
+CXX = $(CROSS_COMPILE)g++
+
+# Additional Tools
+SIZE = $(CROSS_COMPILE)size
+STRIP = $(CROSS_COMPILE)strip
+CP = $(CROSS_COMPILE)objcopy
+
+HEXCOPY = $(CP) -O ihex
+BINCOPY = $(CP) -O binary
+# files to be compiled, will be filled in by include makefiles
+# := assignment is neccessary so we get all paths right
+# https://www.gnu.org/software/make/manual/html_node/Flavors.html
+CSRC := 
+CXXSRC := 
+ASRC := 
+INCLUDES := 
+
+# Directories where $(directoryname).mk files should be included from
+SUBDIRS :=  $(FRAMEWORK_PATH) $(TEST_PATH) $(UNIT_TEST_PATH) $(CONFIG_PATH) \
+		$(CORE_PATH)
+
+
+I_INCLUDES += $(addprefix -I, $(INCLUDES))
+
+# This is a hack from http://make.mad-scientist.net/the-eval-function/
+#
+# The problem is, that included makefiles should be aware of their relative path
+# but not need to guess or hardcode it. So we set $(CURRENTPATH) for them. If
+# we do this globally and the included makefiles want to include other makefiles as
+# well, they would overwrite $(CURRENTPATH), screwing the include after them.
+#
+# By using a for-loop with an eval'd macro, we can generate the code to include all
+# sub-makefiles (with the correct $(CURRENTPATH) set) before actually evaluating
+# (and by this possibly changing $(CURRENTPATH)) them.
+#
+# This works recursively, if an included makefile wants to include, it can safely set 
+# $(SUBDIRS) (which has already been evaluated here) and do
+# "$(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))"
+# $(SUBDIRS) must be relative to the project root, so to include subdir foo, set
+# $(SUBDIRS) = $(CURRENTPATH)/foo.
+define INCLUDE_FILE
+CURRENTPATH := $S
+include $(S)/$(notdir $S).mk
+endef
+$(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))
+
+INCLUDES += $(FILE_ROOT)
+INCLUDES += $(FILE_ROOT)/catch2/
+
+#-------------------------------------------------------------------------------
+#		Source Files
+#-------------------------------------------------------------------------------
+
+# All source files which are not includes by the .mk files are added here
+# Please ensure that no files are included by both .mk file and here !
+
+# if a target is not listed in the current directory, 
+# make searches in the directories specified with VPATH
+
+# All C Sources included by .mk files are assigned here
+# Add the objects to sources so dependency handling works
+C_OBJECTS += $(CSRC:.c=.o)
+
+# Objects built from Assembly source files
+ASM_OBJECTS = $(ASRC:.S=.o)
+
+# Objects built from C++ source files
+CXX_OBJECTS +=  $(CXXSRC:.cpp=.o)
+
+#-------------------------------------------------------------------------------
+#		Build Configuration + Output
+#-------------------------------------------------------------------------------
+
+TARGET = Debug build.
+DEBUG_MESSAGE = Off
+OPTIMIZATION_MESSAGE = Off
+
+# Define Messages
+MSG_INFO = Software: Hosted unittest \(Catch2\) for the FSFW.
+MSG_OPTIMIZATION = Optimization: $(OPTIMIZATION), $(OPTIMIZATION_MESSAGE)
+MSG_TARGET = Target Build: $(TARGET)
+MSG_DEBUG = Debug level: $(DEBUG_LEVEL), FSFW Debugging: $(DEBUG_MESSAGE)
+
+MSG_LINKING = Linking:
+MSG_COMPILING = Compiling:
+MSG_ASSEMBLING = Assembling:
+MSG_DEPENDENCY = Collecting dependencies for:
+MSG_BINARY = Generate binary: 
+
+# See https://stackoverflow.com/questions/6687630/how-to-remove-unused-c-c-symbols-with-gcc-and-ld
+# Used to throw away unused code. Reduces code size significantly !
+# -Wl,--gc-sections: needs to be passed to the linker to throw aways unused code
+ifdef KEEP_UNUSED_CODE
+PROTOTYPE_OPTIMIZATION = 
+UNUSED_CODE_REMOVAL = 
+else
+PROTOTYPE_OPTIMIZATION = -ffunction-sections -fdata-sections
+UNUSED_CODE_REMOVAL = -Wl,--gc-sections
+# Link time optimization
+# See https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html for reference
+# Link time is larger and size of object files can not be retrieved
+# but resulting binary is smaller. Could be used in mission/deployment build
+# Requires -ffunction-section in linker call
+LINK_TIME_OPTIMIZATION = -flto
+OPTIMIZATION += $(PROTOTYPE_OPTIMIZATION) 
+endif 
+
+# Dependency Flags
+# These flags tell the compiler to build dependencies
+# See: https://www.gnu.org/software/make/manual/html_node/Automatic-Prerequisites.html
+# Using following guide: http://make.mad-scientist.net/papers/advanced-auto-dependency-generation/#combine
+DEPFLAGS = -MT $@ -MMD -MP -MF $(DEPENDDIR)/$*.d
+
+# Flags for the compiler call
+# - std: Which C++ version to use. Common versions: c++11, c++14 and c++17
+# - Wall: enable all warnings
+# - Wextra: enable extra warnings
+# - g: defines debug level
+# - fmessage-length: to control the formatting algorithm for diagnostic messages;
+#    =0 means  no line-wrapping is done; each error message appears on a single line
+# - fno-exceptions: stops generating extra code needed to propagate exceptions, 
+#    which can produce significant data size overhead
+CUSTOM_DEFINES += -DUNIT_TEST
+WARNING_FLAGS = -Wall -Wshadow=local -Wextra -Wimplicit-fallthrough=1 \
+		-Wno-unused-parameter 
+		
+CXXDEFINES := $(CUSTOM_DEFINES)
+CFLAGS += 
+CXXFLAGS += -I. $(DEBUG_LEVEL) $(WARNING_FLAGS) $(DEPFLAGS) -fmessage-length=0 $(OPTIMIZATION)\
+		 $(I_INCLUDES) $(CXXDEFINES)
+CPPFLAGS += -std=c++11  
+
+# Flags for the linker call
+# LINK_INCLUDES specify the path to used libraries and the linker script
+# LINK_LIBRARIES: Link real time support
+LDFLAGS := $(DEBUG_LEVEL) $(UNUSED_CODE_REMOVAL) $(OPTIMIZATION) -pthread 
+LINK_INCLUDES := 
+LINK_LIBRARIES :=
+
+ifdef LINUX
+LINK_LIBRARIES += -lrt
+endif
+
+ifeq ($(OS),Windows_NT)
+LINK_LIBRARIES += -lwsock32 -lws2_32
+LDFLASGS += -fuse-ld=lld
+endif
+
+# Gnu Coverage Tools Flags
+ifdef GCOV
+GCOV_CXXFLAGS = -fprofile-arcs -ftest-coverage --coverage -fno-inline \
+		-fno-inline-small-functions -fno-default-inline
+CXXFLAGS += $(GCOV_CXXFLAGS)
+GCOV_LINKER_LIBS = -lgcov -fprofile-arcs -ftest-coverage
+LINK_LIBRARIES += $(GCOV_LINKER_LIBS)
+endif
+
+# $(info $${CXXFLAGS} is [${CXXFLAGS}])
+
+#-------------------------------------------------------------------------------
+#		Rules
+#-------------------------------------------------------------------------------
+# the call function assigns parameters to temporary variables
+# https://www.gnu.org/software/make/manual/make.html#Call-Function
+# $(1) = Memory names
+# Rules are called for each memory type
+# Two Expansion Symbols $$ are to escape the dollar sign for eval.
+# See: http://make.mad-scientist.net/the-eval-function/
+
+default: all
+
+# Cleans all files 
+hardclean: 
+	-rm -rf $(BUILDPATH)
+	-rm -rf $(OBJECTPATH)
+	-rm -rf $(DEPENDPATH)
+
+# Only clean files for current build
+clean:
+	-rm -rf $(CLEANOBJ)
+	-rm -rf $(CLEANBIN)
+	-rm -rf $(CLEANDEP)
+
+# Only clean binaries. Useful for changing the binary type when object files 
+# are already compiled so complete rebuild is not necessary
+cleanbin:
+	-rm -rf $(CLEANBIN)
+
+# In this section, the binaries are built for all selected memories
+# notestfw: all
+all: executable 
+
+# Build target configuration
+release: OPTIMIZATION = -Os $(PROTOTYPE_OPTIMIZATION) $(LINK_TIME_OPTIMIZATION)
+release: LINK_TIME_OPTIMIZATION = -flto
+release: TARGET = Mission build.
+release: OPTIMIZATION_MESSAGE = On with Link Time Optimization
+
+debug: CXXDEFINES += -DDEBUG
+debug: TARGET = Debug
+debug: DEBUG_MESSAGE = On
+
+ifndef KEEP_UNUSED_CODE
+debug release: OPTIMIZATION_MESSAGE += , no unused code removal
+endif
+
+debug release notestfw: executable
+	
+executable: $(BINDIR)/$(BINARY_NAME).elf	
+	@echo
+	@echo $(MSG_INFO)
+	@echo $(MSG_TARGET)
+	@echo $(MSG_OPTIMIZATION)
+	@echo $(MSG_DEBUG)
+
+C_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(C_OBJECTS))
+CXX_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(CXX_OBJECTS))
+ASM_OBJECTS_PREFIXED = $(addprefix $(OBJDIR)/, $(ASM_OBJECTS))
+ALL_OBJECTS = $(ASM_OBJECTS_PREFIXED) $(C_OBJECTS_PREFIXED) \
+		$(CXX_OBJECTS_PREFIXED) 
+
+# Useful for debugging the Makefile
+# Also see: https://www.oreilly.com/openbook/make3/book/ch12.pdf
+# $(info $${ALL_OBJECTS} is [${ALL_OBJECTS}])
+# $(info $${CXXSRC} is [${CXXSRC}])
+
+# Automatic variables are used here extensively. Some of them
+# are escaped($$) to suppress immediate evaluation. The most important ones are:
+# $@: Name of Target (left side of rule)
+# $<: Name of the first prerequisite (right side of rule)
+# @^: List of all prerequisite, omitting duplicates
+# @D: Directory and file-within-directory part of $@
+
+# Generates binary and displays all build properties
+# -p with mkdir ignores error and creates directory when needed.
+
+# SHOW_DETAILS = 1
+
+
+# Link with required libraries: HAL (Hardware Abstraction Layer) and 
+# HCC (File System Library)
+$(BINDIR)/$(BINARY_NAME).elf: $(ALL_OBJECTS)
+	@echo
+	@echo $(MSG_LINKING) Target $@
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CXX) $(LDFLAGS) $(LINK_INCLUDES) -o $@ $^ $(LINK_LIBRARIES)
+else
+	@$(CXX) $(LDFLAGS) $(LINK_INCLUDES) -o $@ $^ $(LINK_LIBRARIES)
+endif	
+ifeq ($(BUILD_FOLDER), mission)
+# With Link Time Optimization, section size is not available
+	$(SIZE) $@
+else
+	$(SIZE) $^ $@
+endif
+
+$(BINDIR)/$(BINARY_NAME).hex: $(BINDIR)/$(BINARY_NAME).elf
+	@echo
+	@echo $(MSG_BINARY)
+	@mkdir -p $(@D)
+	$(HEXCOPY) $< $@
+	
+# Build new objects for changed dependencies. 
+$(OBJDIR)/%.o: %.cpp
+$(OBJDIR)/%.o: %.cpp $(DEPENDDIR)/%.d | $(DEPENDDIR)
+	@echo 
+	@echo $(MSG_COMPILING) $<
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+else
+	@$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+endif
+
+$(OBJDIR)/%.o: %.c 
+$(OBJDIR)/%.o: %.c $(DEPENDDIR)/%.d | $(DEPENDDIR) 
+	@echo 
+	@echo $(MSG_COMPILING) $<
+	@mkdir -p $(@D)
+ifdef SHOW_DETAILS
+	$(CC)  $(CXXFLAGS) $(CFLAGS) -c -o $@ $<
+else
+	@$(CC)  $(CXXFLAGS) $(CFLAGS) -c -o $@ $<
+endif
+
+#-------------------------------------------------------------------------------
+#		Dependency Handling
+#-------------------------------------------------------------------------------
+
+# Dependency Handling according to following guide:
+# http://make.mad-scientist.net/papers/advanced-auto-dependency-generation/
+$(DEPENDDIR):
+	@mkdir -p $(@D)
+DEPENDENCY_RELATIVE = $(CSRC:.c=.d) $(CXXSRC:.cpp=.d)
+# This is the list of all dependencies
+DEPFILES = $(addprefix $(DEPENDDIR)/, $(DEPENDENCY_RELATIVE))
+# Create subdirectories for dependencies
+$(DEPFILES):
+	@mkdir -p $(@D)
+# Include all dependencies
+include $(wildcard $(DEPFILES))
+	
+# .PHONY tells make that these targets aren't files
+.PHONY: clean release debug all hardclean cleanbin
diff --git a/unittest/README.md b/unittest/README.md
new file mode 100644
index 00000000..091dd3cb
--- /dev/null
+++ b/unittest/README.md
@@ -0,0 +1,121 @@
+## FSFW Testing
+This repository contains testing and unit testing components.
+
+[Catch2](https://github.com/catchorg/Catch2) has been used as a framework,
+and these unit tests can only be run on a linux host machine.
+The makefile with default settings creates the unit test binary which can be
+run in the terminal or in eclipse.
+
+### Instructions
+Basic steps:
+
+1. Clone this branch
+   ```sh
+   git clone https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests.git
+   ```
+
+2. Inititate the framework submodule (need to only be done once)
+   ```sh
+   git submodule init
+   git submodule sync
+   git submodule update
+   ```
+   
+2. Run the makefile With
+
+   ```sh
+   make all -j<Number Of Processors>
+   ```
+   This will build the debug version of the unit tests.
+   The release version can be built with the target `release`
+
+4. Run the binary located in the \_bin folder in the terminal or in eclipse.
+
+   ```sh
+   _bin/<binaryName>.elf [--success]
+   ```
+   The success parameter is optional. Leaving it out ommits the success messages.
+
+5. To clear the binary, object and dependency folder, run
+
+   ```sh
+   make clean
+   ```
+
+Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities used by the UNIX pthread module are restricted, which will lead to permission errors when creating these tasks.
+
+To solve this issues, try following steps:
+
+1. Edit the /etc/security/limits.conf 
+   file and add following lines at the end (worked on Ubuntu 19.10):
+   ```sh
+   <username>   hard   rtprio  99
+   <username>   soft   rtprio  99
+   ```
+   Then restart the computer. <br>
+   The soft limit can also be set in the console with `ulimit -Sr` if the hard
+   limit has been increased,
+   but it is recommended to add it to the file as well for convenience.
+   If adding the second line is not desired for security reasons,
+   the soft limit needs to be set for each session. If using an IDE like eclipse 
+   in that case, the IDE needs to be started from the console after setting
+   the soft limit higher there.
+2. Run the shell script inside the linux folder (worked on Ubuntu 18.04)
+   ```sh
+   ./unlockRealtime
+   ```
+   This script executes the `setcap` command on bash and on the binaries.
+   It also increases the soft real time limit of the current shell instance
+   to the maximum. If running the script before executing the binary does
+   not help, try the following step.
+   
+### Eclipse CDT settings
+
+The default eclipse terminal has issues displaying the colors used
+when running the unit test binary by catch2. To fix this issue,
+install the ANSI Escape In Console package from the eclipse marketplace.
+
+### GCOV integration
+
+GCOV has been integrated as a code coverage tool.
+It can be enabled by adding `GCOV=1` to the build process as an additional argument.
+Coverage data will be provided in form of .gcno and .gcda files.
+These can be displayed in eclipse by looking
+for a .gcno or .gcda file in the \_obj folder, double-clicking it
+and picking the right source-binary. This will generate 
+information about which lines of a file have run, provided it is open in 
+eclipse.
+
+### LCOV integration
+
+The files generated by GCOV can also be processed by the tool LCOV.
+On ubuntu, the tool can be installed with the following command:
+
+```sh 
+sudo apt-get install lcov
+```` 
+
+After that, the tool can be run by building the unit tests with `GCOV=1`,
+running them at least one time and then executing the `lcov.sh` script.
+
+### Adding unit tests
+
+The catch unit tests are located in unittest/testfw. To add new unit tests,
+add them to the UnitTestCatch.cpp file or add a new source file which
+includes catch.hpp.
+
+For writing basics tests, the [assertion documentation](https://github.com/catchorg/Catch2/blob/master/docs/assertions.md#top)
+or the existing examples are a good guideliens.
+For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
+
+### Compile without test framework
+Alternatively, the unit tests can also be run internally without
+a framework. This can be used to perform unit tests on the real hardware.
+To do this, run
+```sh
+make -j<Number Of Processors> notestfw
+```
+This will instruct the makefile to exclude the test framework main.cpp
+and include our own. This will also create a binary which can be used
+outside the host machine (a Makefile adaptions might be neccessary
+if another OS than linux is required)
diff --git a/unittest/catch2/LICENSE.txt b/unittest/catch2/LICENSE.txt
new file mode 100644
index 00000000..36b7cd93
--- /dev/null
+++ b/unittest/catch2/LICENSE.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/unittest/catch2/catch.hpp b/unittest/catch2/catch.hpp
new file mode 100644
index 00000000..51618b38
--- /dev/null
+++ b/unittest/catch2/catch.hpp
@@ -0,0 +1,17618 @@
+/*
+ *  Catch v2.11.3
+ *  Generated: 2020-03-19 13:44:21.042491
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+// start catch.hpp
+
+
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 11
+#define CATCH_VERSION_PATCH 3
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// start catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+// end catch_suppress_warnings.h
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
+#endif
+
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+// start catch_platform.h
+
+#ifdef __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_OSX == 1
+#  define CATCH_PLATFORM_MAC
+# elif TARGET_OS_IPHONE == 1
+#  define CATCH_PLATFORM_IPHONE
+# endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+#endif
+
+// end catch_platform.h
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// start catch_user_interfaces.h
+
+namespace Catch {
+    unsigned int rngSeed();
+}
+
+// end catch_user_interfaces.h
+// start catch_tag_alias_autoregistrar.h
+
+// start catch_common.h
+
+// start catch_compiler_capabilities.h
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+#ifdef __cplusplus
+
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
+#  endif
+
+#endif
+
+#if defined(CATCH_CPP17_OR_GREATER)
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+// We have to avoid both ICC and Clang, because they try to mask themselves
+// as gcc, and we want only GCC in this block
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use of __COUNTER__ is suppressed during code analysis in
+// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
+// handled by it.
+// Otherwise all supported compilers support COUNTER macro,
+// but user still might want to turn it off
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+// end catch_compiler_capabilities.h
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <cstdint>
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+
+    protected:
+        NonCopyable();
+        virtual ~NonCopyable();
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo() = delete;
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
+            line( _line )
+        {}
+
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
+
+        bool empty() const noexcept { return file[0] == '\0'; }
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() const;
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+// end catch_common.h
+namespace Catch {
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_tag_alias_autoregistrar.h
+// start catch_test_registry.h
+
+// start catch_interfaces_testcase.h
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestInvoker {
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+// end catch_interfaces_testcase.h
+// start catch_stringref.h
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
+        auto c_str() const -> char const*;
+
+    public: // substrings and searches
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
+
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
+
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
+
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
+
+    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+// end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
+public:
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+    void invoke() const override {
+        C obj;
+        (obj.*m_testAsMethod)();
+    }
+};
+
+auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
+
+template<typename C>
+auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+}
+
+struct NameAndTags {
+    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+    StringRef name;
+    StringRef tags;
+};
+
+struct AutoReg : NonCopyable {
+    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+    ~AutoReg();
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
+
+// end catch_test_registry.h
+// start catch_capture.hpp
+
+// start catch_assertionhandler.h
+
+// start catch_assertioninfo.h
+
+// start catch_result_type.h
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+// end catch_result_type.h
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+
+        // We want to delete this constructor but a compiler bug in 4.8 means
+        // the struct is then treated as non-aggregate
+        //AssertionInfo() = delete;
+    };
+
+} // end namespace Catch
+
+// end catch_assertioninfo.h
+// start catch_decomposer.h
+
+// start catch_tostring.h
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+// start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    class StringRef;
+
+    struct IStream {
+        virtual ~IStream();
+        virtual std::ostream& stream() const = 0;
+    };
+
+    auto makeStream( StringRef const &filename ) -> IStream const*;
+
+    class ReusableStringStream : NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        auto str() const -> std::string;
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+// end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef __OBJC__
+// start catch_objc_arc.hpp
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+// end catch_objc_arc.hpp
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+namespace Catch {
+    namespace Detail {
+
+        extern const std::string unprintableString;
+
+        std::string rawMemoryToString( const void *object, std::size_t size );
+
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
+
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string>::type convertUnstreamable( T const& ) {
+            return Detail::unprintableString;
+        }
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string>::type convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+        template<typename T>
+        typename std::enable_if<
+            std::is_enum<T>::value
+        , std::string>::type convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
+#endif
+
+    } // namespace Detail
+
+    // If we decide for C++14, change these to enable_if_ts
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
+
+        template <typename Fake = T>
+        static
+        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
+#else
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+        }
+    };
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
+        }
+#endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif
+
+    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+    //      while keeping string semantics?
+    template<int SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return ::Catch::Detail::stringify(std::string{ str });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
+    };
+
+    template<>
+    struct StringMaker<bool> {
+        static std::string convert(bool b);
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char c);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char c);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t);
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
+
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
+
+    namespace Detail {
+        template<typename InputIterator>
+        std::string rangeToString(InputIterator first, InputIterator last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
+        }
+    }
+
+#ifdef __OBJC__
+    template<>
+    struct StringMaker<NSString*> {
+        static std::string convert(NSString * nsstring) {
+            if (!nsstring)
+                return "nil";
+            return std::string("@") + [nsstring UTF8String];
+        }
+    };
+    template<>
+    struct StringMaker<NSObject*> {
+        static std::string convert(NSObject* nsObject) {
+            return ::Catch::Detail::stringify([nsObject description]);
+        }
+
+    };
+    namespace Detail {
+        inline std::string stringify( NSString* nsstring ) {
+            return StringMaker<NSString*>::convert( nsstring );
+        }
+
+    } // namespace Detail
+#endif // __OBJC__
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
+
+    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
+    using std::begin;
+    using std::end;
+
+    not_this_one begin( ... );
+    not_this_one end( ... );
+
+    template <typename T>
+    struct is_range {
+        static const bool value =
+            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
+            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+    };
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, int SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol();
+};
+
+template <class Ratio>
+std::string ratio_string<Ratio>::symbol() {
+    Catch::ReusableStringStream rss;
+    rss << '[' << Ratio::num << '/'
+        << Ratio::den << ']';
+    return rss.str();
+}
+template <>
+struct ratio_string<std::atto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::femto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::pico> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::nano> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::micro> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::milli> {
+    static std::string symbol();
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_tostring.h
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+namespace Catch {
+
+    struct ITransientExpression {
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+        ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression();
+
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+    template<typename LhsT, typename RhsT>
+    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+    template<typename T>
+    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+    template<typename LhsT, typename RhsT>
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+    template<typename T>
+    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+        template<typename RhsT>
+        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+        }
+        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs == rhs, m_lhs, "==", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+        }
+        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs != rhs, m_lhs, "!=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+        }
+        template<typename RhsT>
+        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+        }
+        template<typename RhsT>
+        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+        }
+        template<typename RhsT>
+        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    void handleExpression( ITransientExpression const& expr );
+
+    template<typename T>
+    void handleExpression( ExprLhs<T> const& expr ) {
+        handleExpression( expr.makeUnaryExpr() );
+    }
+
+    struct Decomposer {
+        template<typename T>
+        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<T const&>{ lhs };
+        }
+
+        auto operator <=( bool value ) -> ExprLhs<bool> {
+            return ExprLhs<bool>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_decomposer.h
+// start catch_interfaces_capture.h
+
+#include <string>
+#include <chrono>
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// end catch_interfaces_capture.h
+namespace Catch {
+
+    struct TestFailureException{};
+    struct AssertionResultData;
+    struct IResultCapture;
+    class RunContext;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated );
+        LazyExpression( LazyExpression const& other );
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const;
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef const& macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+        template<typename T>
+        void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+        void setCompleted();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+
+} // namespace Catch
+
+// end catch_assertionhandler.h
+// start catch_message.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    StringRef const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        StringRef macroName;
+        std::string message;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const;
+        bool operator < ( MessageInfo const& other ) const;
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type );
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+    };
+
+    class ScopedMessage {
+    public:
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
+    };
+
+} // end namespace Catch
+
+// end catch_message.h
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+#else
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
+
+#endif
+
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        try { \
+            static_cast<void>(__VA_ARGS__); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+        } \
+        catch( ... ) { \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
+        } \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_capture.hpp
+// start catch_section.h
+
+// start catch_section_info.h
+
+// start catch_totals.h
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
+
+        std::size_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
+
+        std::size_t passed = 0;
+        std::size_t failed = 0;
+        std::size_t failedButOk = 0;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
+
+        Totals delta( Totals const& prevTotals ) const;
+
+        int error = 0;
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// end catch_totals.h
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
+
+        std::string name;
+        std::string description; // !Deprecated: this will always be empty
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// end catch_section_info.h
+// start catch_timer.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+    auto getEstimatedClockResolution() -> uint64_t;
+
+    class Timer {
+        uint64_t m_nanoseconds = 0;
+    public:
+        void start();
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
+    };
+
+} // namespace Catch
+
+// end catch_timer.h
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        explicit operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+// end catch_section.h
+// start catch_interfaces_exception.h
+
+// start catch_interfaces_registry_hub.h
+
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
+    class StartupExceptionRegistry;
+
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+    };
+
+    IRegistryHub const& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+// end catch_interfaces_registry_hub.h
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
+
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
+
+    struct IExceptionTranslator;
+    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+                try {
+                    if( it == itEnd )
+                        std::rethrow_exception(std::current_exception());
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// end catch_interfaces_exception.h
+// start catch_approx.h
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
+
+    public:
+        explicit Approx ( double value );
+
+        static Approx custom();
+
+        Approx operator-() const;
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T const& value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T const& newEpsilon ) {
+            double epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T const& newMargin ) {
+            double marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
+            return *this;
+        }
+
+        std::string toString() const;
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Detail::Approx> {
+    static std::string convert(Catch::Detail::Approx const& value);
+};
+
+} // end namespace Catch
+
+// end catch_approx.h
+// start catch_string_manip.h
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+}
+
+// end catch_string_manip.h
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+// start catch_capture_matchers.h
+
+// start catch_matchers.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            MatcherUntypedBase() = default;
+            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+            std::string toString() const;
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        };
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
+        };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<T> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename T>
+        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<T>() && *this && other;
+        }
+        template<typename T>
+        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<T>() || *this || other;
+        }
+        template<typename T>
+        MatchNotOf<T> MatcherBase<T>::operator ! () const {
+            return MatchNotOf<T>( *this );
+        }
+
+    } // namespace Impl
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+// end catch_matchers.h
+// start catch_matchers_exception.hpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Floating {
+
+        enum class FloatingPointKind : uint8_t;
+
+        struct WithinAbsMatcher : MatcherBase<double> {
+            WithinAbsMatcher(double target, double margin);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_margin;
+        };
+
+        struct WithinUlpsMatcher : MatcherBase<double> {
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            uint64_t m_ulps;
+            FloatingPointKind m_type;
+        };
+
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
+    } // namespace Floating
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.h
+// start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+namespace Generic {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+}
+
+template <typename T>
+class PredicateMatcher : public MatcherBase<T> {
+    std::function<bool(T const&)> m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+        :m_predicate(std::move(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+} // namespace Generic
+
+    // The following functions create the actual matcher objects.
+    // The user has to explicitly specify type to the function, because
+    // inferring std::function<bool(T const&)> is hard (but possible) and
+    // requires a lot of TMP.
+    template<typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+        return Generic::PredicateMatcher<T>(predicate, description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_generic.hpp
+// start catch_matchers_string.h
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            std::string describe() const override;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            bool match( std::string const& source ) const override;
+        };
+
+        struct RegexMatcher : MatcherBase<std::string> {
+            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+            bool match( std::string const& matchee ) const override;
+            std::string describe() const override;
+
+        private:
+            std::string m_regex;
+            CaseSensitive::Choice m_caseSensitivity;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_string.h
+// start catch_matchers_vector.h
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const override {
+                for (auto const& el : v) {
+                    if (el == m_comparator) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>> {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (auto const& comparator : m_comparator) {
+                    auto present = false;
+                    for (const auto& el : v) {
+                        if (el == comparator) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>> {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct ApproxMatcher : MatcherBase<std::vector<T>> {
+
+            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
+            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
+            bool match(std::vector<T> const& vec) const override {
+                // Note: This is a reimplementation of std::is_permutation,
+                //       because I don't want to include <algorithm> inside the common path
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
+
+            std::string describe() const override {
+                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+            }
+        private:
+            std::vector<T> const& m_target;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
+        return Vector::ApproxMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
+        return Vector::UnorderedEqualsMatcher<T>(target);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_vector.h
+namespace Catch {
+
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT const& m_arg;
+        MatcherT m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) },
+            m_arg( arg ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            auto matcherAsString = m_matcher.toString();
+            os << Catch::Detail::stringify( m_arg ) << ' ';
+            if( matcherAsString == Detail::unprintableString )
+                os << m_matcherString;
+            else
+                os << matcherAsString;
+        }
+    };
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    }
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__ ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+// end catch_capture_matchers.h
+#endif
+// start catch_generators.hpp
+
+// start catch_interfaces_generatortracker.h
+
+
+#include <memory>
+
+namespace Catch {
+
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
+        };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
+
+    } // namespace Generators
+
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
+
+} // namespace Catch
+
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+#include <exception>
+
+namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
+namespace Generators {
+
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
+
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
+
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
+
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
+    public:
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
+
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
+
+// start catch_context.h
+
+#include <memory>
+
+namespace Catch {
+
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
+
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
+
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
+
+    private:
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : NonCopyable {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestInvoker;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
+    };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
+
+#ifdef __OBJC__
+// start catch_objc.hpp
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    struct IConfig;
+
+    class TestSpec {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidArgs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void reportInvalidArguments(std::string const&) {}
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved = false;
+    };
+
+    std::ostream& operator << ( std::ostream& os, Colour const& );
+
+} // end namespace Catch
+
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
+
+
+namespace Catch {
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public IReporterFactory {
+
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
+
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
+
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
+    };
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
+
+// start catch_xmlwriter.h
+
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        void writeStylesheetRef( std::string const& url );
+
+        XmlWriter& writeBlankLine();
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+// end catch_xmlwriter.h
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
+
+        ~JunitReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& /*spec*/) override;
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEndedCumulative() override;
+
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void noMatchingTestCases(std::string const& s) override;
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_xml.h
+
+// end catch_external_interfaces.h
+#endif
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
+
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
+
+// start catch_benchmark.hpp
+
+ // Benchmark
+
+// start catch_chronometer.hpp
+
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
+
+// Invoke with a special case for void
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+            template <typename Sig>
+            using ResultOf_t = typename std::result_of<Sig>::type;
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
+
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return k; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
+
+ // Execution plan
+
+
+// start catch_benchmark_function.hpp
+
+ // Dumb std::function implementation for consistent call overhead
+
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
+
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
+
+// Run a function for a minimum amount of time
+
+
+// start catch_measure.hpp
+
+// Measure
+
+
+// start catch_timing.hpp
+
+// Timing
+
+
+#include <tuple>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), std::move(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_run_for_at_least.hpp
+#include <algorithm>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
+
+// Statistical analysis tools
+
+
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
+
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
+
+ // Run and analyse one benchmark
+
+
+// start catch_sample_analysis.hpp
+
+// Benchmark results
+
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
+
+// Constructor and destructor helpers
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+
+                ObjectStorage() : data() {}
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                TStorage data;
+            };
+        }
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
+
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+// start catch_impl.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// Keep these here for external reporters
+// start catch_test_case_tracker.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+    };
+
+    struct ITracker;
+
+    using ITrackerPtr = std::shared_ptr<ITracker>;
+
+    struct ITracker {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( ITrackerPtr const& child ) = 0;
+        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
+    };
+
+    class TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
+
+    public:
+
+        ITracker& startRun();
+        void endRun();
+
+        void startCycle();
+        void completeCycle();
+
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+
+        using Children = std::vector<ITrackerPtr>;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState = NotStarted;
+
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        NameAndLocation const& nameAndLocation() const override;
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
+
+        void addChild( ITrackerPtr const& child ) override;
+
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
+
+        void openChild() override;
+
+        bool isSectionTracker() const override;
+        bool isGeneratorTracker() const override;
+
+        void open();
+
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
+
+    private:
+        void moveToParent();
+        void moveToThis();
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+        bool isSectionTracker() const override;
+
+        bool isComplete() const override;
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+
+        void tryOpen();
+
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<std::string> const& filters );
+    };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+// end catch_test_case_tracker.h
+
+// start catch_leak_detector.h
+
+namespace Catch {
+
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+namespace Detail {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
+// start catch_debugger.h
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+// end catch_debugger.h
+// start catch_run_context.h
+
+// start catch_fatal_condition.h
+
+// start catch_windows_h_proxy.h
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#  define CATCH_DEFINED_NOMINMAX
+#  define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINED_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+// end catch_windows_h_proxy.h
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
+        FatalConditionHandler();
+        static void reset();
+        ~FatalConditionHandler();
+
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+} // namespace Catch
+
+#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions[];
+        static stack_t oldSigStack;
+        static char altStackMem[];
+
+        static void handleSignal( int sig );
+
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+        static void reset();
+    };
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset();
+    };
+}
+
+#endif
+
+// end catch_fatal_condition.h
+#include <string>
+
+namespace Catch {
+
+    struct IMutableContext;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
+
+        ~RunContext() override;
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
+
+        Totals runTest(TestCase const& testCase);
+
+        IConfigPtr config() const;
+        IStreamingReporter& reporter() const;
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const final;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Option<AssertionResult> m_lastResult;
+
+        IConfigPtr m_config;
+        Totals m_totals;
+        IStreamingReporterPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+// end catch_run_context.h
+namespace Catch {
+
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
+    }
+
+    LazyExpression::LazyExpression( bool isNegated )
+    :   m_isNegated( isNegated )
+    {}
+
+    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+
+    LazyExpression::operator bool() const {
+        return m_transientExpression != nullptr;
+    }
+
+    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+        if( lazyExpr.m_isNegated )
+            os << "!";
+
+        if( lazyExpr ) {
+            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+                os << "(" << *lazyExpr.m_transientExpression << ")";
+            else
+                os << *lazyExpr.m_transientExpression;
+        }
+        else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+    AssertionHandler::AssertionHandler
+        (   StringRef const& macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {}
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+            throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
+    }
+    void AssertionHandler::setCompleted() {
+        m_completed = true;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+    }
+
+} // namespace Catch
+// end catch_assertionhandler.cpp
+// start catch_assertionresult.cpp
+
+namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
+
+    std::string AssertionResultData::reconstructExpression() const {
+
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
+        else {
+            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+            expr += m_info.macroName;
+            expr += "( ";
+            expr += m_info.capturedExpression;
+            expr += " )";
+        }
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+// end catch_assertionresult.cpp
+// start catch_capture_matchers.cpp
+
+namespace Catch {
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+// end catch_capture_matchers.cpp
+// start catch_commandline.cpp
+
+// start catch_commandline.h
+
+// start catch_clara.h
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
+
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.5
+
+
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+namespace clara {
+namespace TextFlow {
+
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
+
+class Columns;
+
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
+
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
+
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto operator + (Column const& other)->Columns;
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+class Spacer : public Column {
+
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
+
+class Columns {
+	std::vector<Column> m_columns;
+
+public:
+
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
+
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
+
+}
+}
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+#include <cctype>
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+namespace Catch { namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char const* const* argv )
+            : m_exeName(argv[0]),
+              m_args(argv + 1, argv + argc) {}
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+
+            // Errors shouldn't reach this point, but if they do
+            // the actual error message will be in m_errorMessage
+            assert( m_type != ResultBase::LogicError );
+            assert( m_type != ResultBase::RuntimeError );
+            if( m_type != ResultBase::Ok )
+                std::abort();
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+    template<typename T>
+    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+        T temp;
+        auto result = convertInto( source, temp );
+        if( result )
+            target = std::move(temp);
+        return result;
+    }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+}} // namespace Catch::clara
+
+// end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// end catch_clara.h
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+// end catch_commandline.h
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+                auto warningSet = [&]() {
+                    if( warning == "NoAssertions" )
+                        return WarnAbout::NoAssertions;
+
+                    if ( warning == "NoTests" )
+                        return WarnAbout::NoTests;
+
+                    return WarnAbout::Nothing;
+                }();
+
+                if (warningSet == WarnAbout::Nothing)
+                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + line + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = RunTests::InDeclarationOrder;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = RunTests::InLexicographicalOrder;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = RunTests::InRandomOrder;
+                else
+                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed != "time" )
+                    return clara::detail::convertInto( seed, config.rngSeed );
+                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setColourUsage = [&]( std::string const& useColour ) {
+                    auto mode = toLower( useColour );
+
+                    if( mode == "yes" )
+                        config.useColour = UseColour::Yes;
+                    else if( mode == "no" )
+                        config.useColour = UseColour::No;
+                    else if( mode == "auto" )
+                        config.useColour = UseColour::Auto;
+                    else
+                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.listTests )
+                ["-l"]["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["-t"]["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.outputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "output filename" )
+            | Opt( setReporter, "name" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTestNamesOnly )
+                ["--list-test-names-only"]
+                ( "list all/matching test cases names only" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all reporters" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setColourUsage, "yes|no" )
+                ["--use-colour"]
+                ( "should output be colourised" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+// end catch_commandline.cpp
+// start catch_common.cpp
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    std::string StreamEndStop::operator+() const {
+        return std::string();
+    }
+
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}
+// end catch_common.cpp
+// start catch_config.cpp
+
+namespace Catch {
+
+    Config::Config( ConfigData const& data )
+    :   m_data( data ),
+        m_stream( openStream() )
+    {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+    }
+
+    std::string const& Config::getFilename() const {
+        return m_data.outputFilename ;
+    }
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+
+    std::string Config::getProcessName() const { return m_data.processName; }
+    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    std::ostream& Config::stream() const               { return m_stream->stream(); }
+    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    IStream const* Config::openStream() {
+        return Catch::makeStream(m_data.outputFilename);
+    }
+
+} // end namespace Catch
+// end catch_config.cpp
+// start catch_console_colour.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+// start catch_errno_guard.h
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+// end catch_errno_guard.h
+#include <sstream>
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() = default;
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) override {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = UseColour::Yes;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        void use( Colour::Code _colourCode ) override {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
+
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
+        }
+    };
+
+    bool useColourOnPlatform() {
+        return
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+            !isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+            isatty(STDOUT_FILENO)
+#else
+            false
+#endif
+            ;
+    }
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        IConfigPtr config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = useColourOnPlatform()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
+    }
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
+        return *this;
+    }
+
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, Colour const& ) {
+        return os;
+    }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_console_colour.cpp
+// start catch_context.cpp
+
+namespace Catch {
+
+    class Context : public IMutableContext, NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+        IRunner* getRunner() override {
+            return m_runner;
+        }
+
+        IConfigPtr const& getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setRunner( IRunner* runner ) override {
+            m_runner = runner;
+        }
+        void setConfig( IConfigPtr const& config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfigPtr m_config;
+        IRunner* m_runner = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
+
+// start catch_debug_console.h
+
+#include <string>
+
+namespace Catch {
+    void writeToDebugConsole( std::string const& text );
+}
+
+// end catch_debug_console.h
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+
+#else
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <assert.h>
+#  include <stdbool.h>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
+
+    namespace Catch {
+        #ifdef __apple_build_version__
+        // The following function is taken directly from the following technical note:
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+            int                 mib[4];
+            struct kinfo_proc   info;
+            std::size_t         size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
+
+namespace Catch {
+
+    ITransientExpression::~ITransientExpression() = default;
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << " " << op << " " << rhs;
+        else
+            os << lhs << "\n" << op << "\n" << rhs;
+    }
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
+
+#include <stdexcept>
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
+// start catch_errno_guard.cpp
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
+
+// start catch_exception_translator_registry.h
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry();
+        virtual void registerTranslator( const IExceptionTranslator* translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+    };
+}
+
+// end catch_exception_translator_registry.h
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
+    }
+
+    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                return tryTranslators();
+            }
+            @catch (NSException *exception) {
+                return Catch::Detail::stringify( [exception description] );
+            }
+#else
+            // Compiling a mixed mode project with MSVC means that CLR
+            // exceptions will be caught in (...) as well. However, these
+            // do not fill-in std::current_exception and thus lead to crash
+            // when attempting rethrow.
+            // /EHa switch also causes structured exceptions to be caught
+            // here, but they fill-in current_exception properly, so
+            // at worst the output should be a little weird, instead of
+            // causing a crash.
+            if (std::current_exception() == nullptr) {
+                return "Non C++ exception. Possibly a CLR exception.";
+            }
+            return tryTranslators();
+#endif
+        }
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
+}
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    // Report the error condition
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+}
+
+#endif // signals/SEH handling
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
+    };
+
+    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        // 32k seems enough for Catch to handle stack overflow,
+        // but the value was found experimentally, so there is no strong guarantee
+        guaranteeSize = 32 * 1024;
+        exceptionHandlerHandle = nullptr;
+        // Register as first handler in current chain
+        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+        // Pass in guarantee size to be filled
+        SetThreadStackGuarantee(&guaranteeSize);
+    }
+
+    void FatalConditionHandler::reset() {
+        if (isSet) {
+            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+            SetThreadStackGuarantee(&guaranteeSize);
+            exceptionHandlerHandle = nullptr;
+            isSet = false;
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+bool FatalConditionHandler::isSet = false;
+ULONG FatalConditionHandler::guaranteeSize = 0;
+PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
+
+} // namespace Catch
+
+#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    // 32kb for the alternate stack seems to be sufficient. However, this value
+    // is experimentally determined, so that's not guaranteed.
+    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    void FatalConditionHandler::handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        reset();
+        reportFatal(name);
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        isSet = true;
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = sigStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        reset();
+    }
+
+    void FatalConditionHandler::reset() {
+        if( isSet ) {
+            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+            }
+            // Return the old stack
+            sigaltstack(&oldSigStack, nullptr);
+            isSet = false;
+        }
+    }
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[sigStackSize] = {};
+
+} // namespace Catch
+
+#else
+
+namespace Catch {
+    void FatalConditionHandler::reset() {}
+}
+
+#endif // signals/SEH handling
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
+// start catch_interfaces_capture.cpp
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
+
+// start catch_reporter_listening.h
+
+namespace Catch {
+
+    class ListeningReporter : public IStreamingReporter {
+        using Reporters = std::vector<IStreamingReporterPtr>;
+        Reporters m_listeners;
+        IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
+
+    public:
+        ListeningReporter();
+
+        void addListener( IStreamingReporterPtr&& listener );
+        void addReporter( IStreamingReporterPtr&& reporter );
+
+    public: // IStreamingReporter
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases( std::string const& spec ) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        // The return value indicates if the messages buffer should be cleared:
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_listening.h
+namespace Catch {
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+    std::ostream& ReporterConfig::stream() const { return *m_stream; }
+    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+
+    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+
+    GroupInfo::GroupInfo(  std::string const& _name,
+                           std::size_t _groupIndex,
+                           std::size_t _groupsCount )
+    :   name( _name ),
+        groupIndex( _groupIndex ),
+        groupsCounts( _groupsCount )
+    {}
+
+     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                     std::vector<MessageInfo> const& _infoMessages,
+                                     Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
+    {
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
+
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder << assertionResult.getMessage();
+            builder.m_info.message = builder.m_stream.str();
+
+            infoMessages.push_back( builder.m_info );
+        }
+    }
+
+     AssertionStats::~AssertionStats() = default;
+
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
+
+    SectionStats::~SectionStats() = default;
+
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string const& _stdOut,
+                                   std::string const& _stdErr,
+                                   bool _aborting )
+    : testInfo( _testInfo ),
+        totals( _totals ),
+        stdOut( _stdOut ),
+        stdErr( _stdErr ),
+        aborting( _aborting )
+    {}
+
+    TestCaseStats::~TestCaseStats() = default;
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+                                    Totals const& _totals,
+                                    bool _aborting )
+    :   groupInfo( _groupInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+    :   groupInfo( _groupInfo ),
+        aborting( false )
+    {}
+
+    TestGroupStats::~TestGroupStats() = default;
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestRunStats::~TestRunStats() = default;
+
+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+    bool IStreamingReporter::isMulti() const { return false; }
+
+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
+
+} // end namespace Catch
+// end catch_interfaces_reporter.cpp
+// start catch_interfaces_runner.cpp
+
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+}
+
+#else
+
+    Catch::LeakDetector::LeakDetector() {}
+
+#endif
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
+
+// start catch_list.h
+
+#include <set>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config );
+
+    std::size_t listTestsNamesOnly( Config const& config );
+
+    struct TagInfo {
+        void add( std::string const& spelling );
+        std::string all() const;
+
+        std::set<std::string> spellings;
+        std::size_t count = 0;
+    };
+
+    std::size_t listTags( Config const& config );
+
+    std::size_t listReporters();
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
+
+} // end namespace Catch
+
+// end catch_list.h
+// start catch_text.h
+
+namespace Catch {
+    using namespace clara::TextFlow;
+}
+
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+        }
+
+        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+            if( config.verbosity() >= Verbosity::High ) {
+                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Column( description ).indent(4) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+        }
+
+        if( !config.hasTestFilters() )
+            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+        return matchedTestCases.size();
+    }
+
+    std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            matchedTests++;
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.verbosity() >= Verbosity::High )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    void TagInfo::add( std::string const& spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    std::size_t listTags( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCase : matchedTestCases ) {
+            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+                std::string lcaseTagName = toLower( tagName );
+                auto countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( auto const& tagCount : tagCounts ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+            auto str = rss.str();
+            auto wrapper = Column( tagCount.second.all() )
+                                                    .initialIndent( 0 )
+                                                    .indent( str.size() )
+                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+            Catch::cout() << str << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    std::size_t listReporters() {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        std::size_t maxNameLen = 0;
+        for( auto const& factoryKvp : factories )
+            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+        for( auto const& factoryKvp : factories ) {
+            Catch::cout()
+                    << Column( factoryKvp.first + ":" )
+                            .indent(2)
+                            .width( 5+maxNameLen )
+                    +  Column( factoryKvp.second->getDescription() )
+                            .initialIndent(0)
+                            .indent(2)
+                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+                    << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
+        Option<std::size_t> listedCount;
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
+        return listedCount;
+    }
+
+} // end namespace Catch
+// end catch_list.cpp
+// start catch_matchers.cpp
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        std::string MatcherUntypedBase::toString() const {
+            if( m_cachedToString.empty() )
+                m_cachedToString = describe();
+            return m_cachedToString;
+        }
+
+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+    } // namespace Impl
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+// end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
+// start catch_matchers_floating.cpp
+
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+// end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
+
+namespace Catch {
+namespace {
+
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
+        std::memcpy(&i, &f, sizeof(f));
+        return i;
+    }
+
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
+        std::memcpy(&i, &d, sizeof(d));
+        return i;
+    }
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+}// namespace Floating
+
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+}
+
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+}
+
+Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+    return Floating::WithinAbsMatcher(target, margin);
+}
+
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.cpp
+// start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+        bool RegexMatcher::match(std::string const& matchee) const {
+            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+            if (m_caseSensitivity == CaseSensitive::Choice::No) {
+                flags |= std::regex::icase;
+            }
+            auto reg = std::regex(m_regex, flags);
+            return std::regex_match(matchee, reg);
+        }
+
+        std::string RegexMatcher::describe() const {
+            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+        return StdString::RegexMatcher(regex, caseSensitivity);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_string.cpp
+// start catch_message.cpp
+
+// start catch_uncaught_exceptions.h
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+// end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    bool MessageInfo::operator==( MessageInfo const& other ) const {
+        return sequence == other.sequence;
+    }
+
+    bool MessageInfo::operator<( MessageInfo const& other ) const {
+        return sequence < other.sequence;
+    }
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+                                           SourceLineInfo const& lineInfo,
+                                           ResultWas::OfType type )
+        :m_info(macroName, lineInfo, type) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info ), m_moved()
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(names[start])) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(names[end])) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+// end catch_message.cpp
+// start catch_output_redirect.cpp
+
+// start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+    class RedirectedStream {
+        std::ostream& m_originalStream;
+        std::ostream& m_redirectionStream;
+        std::streambuf* m_prevBuf;
+
+    public:
+        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+        ~RedirectedStream();
+    };
+
+    class RedirectedStdOut {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cout;
+    public:
+        RedirectedStdOut();
+        auto str() const -> std::string;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes
+    class RedirectedStdErr {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cerr;
+        RedirectedStream m_clog;
+    public:
+        RedirectedStdErr();
+        auto str() const -> std::string;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+    // Windows's implementation of std::tmpfile is terrible (it tries
+    // to create a file inside system folder, thus requiring elevated
+    // privileges for the binary), so we have to use tmpnam(_s) and
+    // create the file ourselves there.
+    class TempFile {
+    public:
+        TempFile(TempFile const&) = delete;
+        TempFile& operator=(TempFile const&) = delete;
+        TempFile(TempFile&&) = delete;
+        TempFile& operator=(TempFile&&) = delete;
+
+        TempFile();
+        ~TempFile();
+
+        std::FILE* getFile();
+        std::string getContents();
+
+    private:
+        std::FILE* m_file = nullptr;
+    #if defined(_MSC_VER)
+        char m_buffer[L_tmpnam] = { 0 };
+    #endif
+    };
+
+    class OutputRedirect {
+    public:
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+        ~OutputRedirect();
+
+    private:
+        int m_originalStdout = -1;
+        int m_originalStderr = -1;
+        TempFile m_stdoutFile;
+        TempFile m_stderrFile;
+        std::string& m_stdoutDest;
+        std::string& m_stderrDest;
+    };
+
+#endif
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+// end catch_output_redirect.h
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
+#endif
+
+namespace Catch {
+
+    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }
+
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }
+
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStdErr::RedirectedStdErr()
+    :   m_cerr( Catch::cerr(), m_rss.get() ),
+        m_clog( Catch::clog(), m_rss.get() )
+    {}
+    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+    TempFile::TempFile() {
+        if (tmpnam_s(m_buffer)) {
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+        }
+        if (fopen_s(&m_file, m_buffer, "w")) {
+            char buffer[100];
+            if (strerror_s(buffer, errno)) {
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            }
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+        }
+    }
+#else
+    TempFile::TempFile() {
+        m_file = std::tmpfile();
+        if (!m_file) {
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+        }
+    }
+
+#endif
+
+    TempFile::~TempFile() {
+         // TBD: What to do about errors here?
+         std::fclose(m_file);
+         // We manually create the file on Windows only, on Linux
+         // it will be autodeleted
+#if defined(_MSC_VER)
+         std::remove(m_buffer);
+#endif
+    }
+
+    FILE* TempFile::getFile() {
+        return m_file;
+    }
+
+    std::string TempFile::getContents() {
+        std::stringstream sstr;
+        char buffer[100] = {};
+        std::rewind(m_file);
+        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            sstr << buffer;
+        }
+        return sstr.str();
+    }
+
+    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+        m_originalStdout(dup(1)),
+        m_originalStderr(dup(2)),
+        m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest) {
+        dup2(fileno(m_stdoutFile.getFile()), 1);
+        dup2(fileno(m_stderrFile.getFile()), 2);
+    }
+
+    OutputRedirect::~OutputRedirect() {
+        Catch::cout() << std::flush;
+        fflush(stdout);
+        // Since we support overriding these streams, we flush cerr
+        // even though std::cerr is unbuffered
+        Catch::cerr() << std::flush;
+        Catch::clog() << std::flush;
+        fflush(stderr);
+
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);
+
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
+#endif
+// end catch_output_redirect.cpp
+// start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+    class TestCase;
+    struct IConfig;
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        virtual ~TestRegistry() = default;
+
+        virtual void registerTest( TestCase const& testCase );
+
+        std::vector<TestCase> const& getAllTests() const override;
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        std::size_t m_unnamedCount = 0;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction : public ITestInvoker {
+        void(*m_testAsFunction)();
+    public:
+        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+        void invoke() const override;
+    };
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+// end catch_test_case_registry_impl.h
+// start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias_registry.h
+// start catch_startup_exception_registry.h
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+    };
+
+} // end namespace Catch
+
+// end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+                            private NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            IReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            void registerListener( IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerListener( factory );
+            }
+            void registerTest( TestCase const& testInfo ) override {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            void registerTranslator( const IExceptionTranslator* translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+                m_exceptionRegistry.add(std::current_exception());
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+// end catch_registry_hub.cpp
+// start catch_reporter_registry.cpp
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+// end catch_result_type.cpp
+// start catch_run_context.cpp
+
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                }
+                else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // Generator interface only finds out if it has another item on atual move
+                if (m_runState == CompletedSuccessfully && m_generator->next()) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
+    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(std::move(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setRunner(this);
+        m_context.setConfig(m_config);
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+    }
+
+    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCase const& testCase) {
+        Totals prevTotals = m_totals;
+
+        std::string redirectedCout;
+        std::string redirectedCerr;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+
+        m_reporter->testCaseStarting(testInfo);
+
+        m_activeTestCase = &testCase;
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+            runCurrentTest(redirectedCout, redirectedCerr);
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  redirectedCout,
+                                  redirectedCerr,
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+    IConfigPtr RunContext::config() const {
+        return m_config;
+    }
+
+    IStreamingReporter& RunContext::reporter() const {
+        return *m_reporter;
+    }
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.isOk()) {
+            m_lastAssertionPassed = false;
+            if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+        // and should be let to clear themselves out.
+        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // Reset working state
+        resetAssertionInfo();
+        m_lastResult = result;
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+    }
+
+    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        m_reporter->sectionStarting(sectionInfo);
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
+        assert( tracker.isOpen() );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+        if (m_unfinishedSections.empty())
+            m_activeSections.back()->fail();
+        else
+            m_activeSections.back()->close();
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(endInfo);
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+		m_reporter->benchmarkPreparing(name);
+	}
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+	void RunContext::benchmarkFailed(std::string const & error) {
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered(message);
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, tempResult);
+
+        assertionEnded(result);
+
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+        m_reporter->sectionEnded(testCaseSectionStats);
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        testGroupEnded(std::string(), m_totals, 1, 1);
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        seedRng(*m_config);
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#else
+                OutputRedirect r(redirectedCout, redirectedCerr);
+                timer.start();
+                invokeActiveTestCase();
+#endif
+            } else {
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        FatalConditionHandler fatalConditionHandler; // Handle signals
+        m_activeTestCase->invoke();
+        fatalConditionHandler.reset();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for (auto it = m_unfinishedSections.rbegin(),
+             itEnd = m_unfinishedSections.rend();
+             it != itEnd;
+             ++it)
+            sectionEnded(*it);
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, data };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( assertionResult );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            StringRef const& message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(message);
+        AssertionResult assertionResult{ m_lastAssertionInfo, data };
+        assertionEnded( assertionResult );
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string const& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = message;
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+        populateReaction( reaction );
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+            if( uncaught_exceptions() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+// end catch_section.cpp
+// start catch_section_info.cpp
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name )
+    :   name( _name ),
+        lineInfo( _lineInfo )
+    {}
+
+} // end namespace Catch
+// end catch_section_info.cpp
+// start catch_session.cpp
+
+// start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+// end catch_session.h
+// start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+#include <set>
+#include <iterator>
+
+namespace Catch {
+
+    namespace {
+        const int MaxExitCode = 255;
+
+        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
+
+            return reporter;
+        }
+
+        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+                return createReporter(config->getReporterName(), config);
+            }
+
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
+            }
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
+        }
+
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
+                }
+            }
+
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
+                }
+
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
+            }
+
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
+
+        void applyFilenamesAsTags(Catch::IConfig const& config) {
+            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+            for (auto& testCase : tests) {
+                auto tags = testCase.tags;
+
+                std::string filename = testCase.lineInfo.file;
+                auto lastSlash = filename.find_last_of("\\/");
+                if (lastSlash != std::string::npos) {
+                    filename.erase(0, lastSlash);
+                    filename[0] = '#';
+                }
+
+                auto lastDot = filename.find_last_of('.');
+                if (lastDot != std::string::npos) {
+                    filename.erase(lastDot);
+                }
+
+                tags.push_back(std::move(filename));
+                setTags(testCase, tags);
+            }
+        }
+
+    } // anon namespace
+
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+        }
+
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
+            m_startupExceptions = true;
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+                }
+            }
+        }
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
+    }
+
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
+
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if( m_startupExceptions )
+            return 1;
+
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
+        }
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( m_config ) )
+                return static_cast<int>( *listed );
+
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+#endif
+    }
+
+} // end namespace Catch
+// end catch_session.cpp
+// start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
+// start catch_startup_exception_registry.cpp
+
+namespace Catch {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+
+} // end namespace Catch
+// end catch_startup_exception_registry.cpp
+// start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+    namespace Detail { namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
+            }
+
+            ~StreamBufImpl() noexcept {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        struct OutputDebugWriter {
+
+            void operator()( std::string const&str ) {
+                writeToDebugConsole( str );
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class FileStream : public IStream {
+            mutable std::ofstream m_ofs;
+        public:
+            FileStream( StringRef filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
+            }
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() const override {
+                return m_ofs;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class CoutStream : public IStream {
+            mutable std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+            ~CoutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            mutable std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+    }} // namespace anon::detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( StringRef const &filename ) -> IStream const* {
+        if( filename.empty() )
+            return new Detail::CoutStream();
+        else if( filename[0] == '%' ) {
+            if( filename == "%debug" )
+                return new Detail::DebugOutStream();
+            else
+                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+        }
+        else
+            return new Detail::FileStream( filename );
+    }
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
+        }
+    };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    auto ReusableStringStream::str() const -> std::string {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
+}
+// end catch_stream.cpp
+// start catch_string_manip.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+    {}
+
+    auto StringRef::c_str() const -> char const* {
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
+        return m_start;
+    }
+    auto StringRef::data() const noexcept -> char const* {
+        return m_start;
+    }
+
+    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
+            return StringRef();
+        }
+    }
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+        return os.write(str.data(), str.size());
+    }
+
+    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+// end catch_stringref.cpp
+// start catch_tag_alias.cpp
+
+namespace Catch {
+    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+// end catch_tag_alias_registry.cpp
+// start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+    }
+
+    TestCase makeTestCase(  ITestInvoker* _testCase,
+                            std::string const& _className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden = false;
+
+        // Parse out tags
+        std::vector<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for (char c : nameAndTags.tags) {
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
+                    tags.push_back( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
+        }
+
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, std::move(info) );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+        testCaseInfo.lcaseTags.clear();
+
+        for( auto const& tag : tags ) {
+            std::string lcaseTag = toLower( tag );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.push_back( lcaseTag );
+        }
+        testCaseInfo.tags = std::move(tags);
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::vector<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret.append(tag);
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+// end catch_test_case_info.cpp
+// start catch_test_case_registry_impl.cpp
+
+#include <sstream>
+
+namespace Catch {
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                seedRng( config );
+                std::shuffle( sorted.begin(), sorted.end(), rng() );
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( auto const& function : functions ) {
+            auto prev = seenFunctions.insert( function );
+            CATCH_ENFORCE( prev.second,
+                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest( TestCase const& testCase ) {
+        std::string name = testCase.getTestCaseInfo().name;
+        if( name.empty() ) {
+            ReusableStringStream rss;
+            rss << "Anonymous test case " << ++m_unnamedCount;
+            return registerTest( testCase.withName( rss.str() ) );
+        }
+        m_functions.push_back( testCase );
+    }
+
+    std::vector<TestCase> const& TestRegistry::getAllTests() const {
+        return m_functions;
+    }
+    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_functions );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_functions );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+        std::string className(classOrQualifiedMethodName);
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+} // end namespace Catch
+// end catch_test_case_registry_impl.cpp
+// start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+    :   name( _name ),
+        location( _location )
+    {}
+
+    ITracker::~ITracker() = default;
+
+    ITracker& TrackerContext::startRun() {
+        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::endRun() {
+        m_rootTracker.reset();
+        m_currentTracker = nullptr;
+        m_runState = NotStarted;
+    }
+
+    void TrackerContext::startCycle() {
+        m_currentTracker = m_rootTracker.get();
+        m_runState = Executing;
+    }
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    ITracker& TrackerContext::currentTracker() {
+        return *m_currentTracker;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   m_nameAndLocation( nameAndLocation ),
+        m_ctx( ctx ),
+        m_parent( parent )
+    {}
+
+    NameAndLocation const& TrackerBase::nameAndLocation() const {
+        return m_nameAndLocation;
+    }
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+    bool TrackerBase::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+    bool TrackerBase::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+    bool TrackerBase::hasChildren() const {
+        return !m_children.empty();
+    }
+
+    void TrackerBase::addChild( ITrackerPtr const& child ) {
+        m_children.push_back( child );
+    }
+
+    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
+        return( it != m_children.end() )
+            ? *it
+            : nullptr;
+    }
+    ITracker& TrackerBase::parent() {
+        assert( m_parent ); // Should always be non-null except for root
+        return *m_parent;
+    }
+
+    void TrackerBase::openChild() {
+        if( m_runState != ExecutingChildren ) {
+            m_runState = ExecutingChildren;
+            if( m_parent )
+                m_parent->openChild();
+        }
+    }
+
+    bool TrackerBase::isSectionTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = &parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if ((m_filters.empty() || m_filters[0] == "")
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        std::shared_ptr<SectionTracker> section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = std::static_pointer_cast<SectionTracker>( childTracker );
+        }
+        else {
+            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+            currentTracker.addChild( section );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+// end catch_test_case_tracker.cpp
+// start catch_test_registry.cpp
+
+namespace Catch {
+
+    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+    }
+
+    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCase(
+                            invoker,
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo));
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+    AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find(begin(testCase.lcaseTags),
+                         end(testCase.lcaseTags),
+                         m_tag) != end(testCase.lcaseTags);
+    }
+
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
+    }
+
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return m_testSpec;
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_patterns.empty() ) {
+            m_testSpec.m_filters.push_back( m_currentFilter );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+// end catch_test_spec_parser.cpp
+// start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+    }
+
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
+
+            auto startTime = getCurrentNanosecondsSinceEpoch();
+
+            for( std::size_t i = 0; i < iterations; ++i ) {
+
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
+
+                auto delta = ticks - baseTicks;
+                sum += delta;
+
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
+            }
+
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
+    }
+    auto getEstimatedClockResolution() -> uint64_t {
+        static auto s_resolution = estimateClockResolution();
+        return s_resolution;
+    }
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+// end catch_timer.cpp
+// start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+// Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    if (Catch::isnan(value)) {
+        return "nan";
+    }
+
+    ReusableStringStream rss;
+    rss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = rss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    if (!getCurrentContext().getConfig()->showInvisibles()) {
+        return '"' + str + '"';
+    }
+
+    std::string s("\"");
+    for (char c : str) {
+        switch (c) {
+        case '\n':
+            s.append("\\n");
+            break;
+        case '\t':
+            s.append("\\t");
+            break;
+        default:
+            s.push_back(c);
+            break;
+        }
+    }
+    s.append("\"");
+    return s;
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
+
+std::string StringMaker<bool>::convert(bool b) {
+    return b ? "true" : "false";
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
+}
+
+std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+    return "nullptr";
+}
+
+int StringMaker<float>::precision = 5;
+
+std::string StringMaker<float>::convert(float value) {
+    return fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = 10;
+
+std::string StringMaker<double>::convert(double value) {
+    return fpToString(value, precision);
+}
+
+std::string ratio_string<std::atto>::symbol() { return "a"; }
+std::string ratio_string<std::femto>::symbol() { return "f"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::micro>::symbol() { return "u"; }
+std::string ratio_string<std::milli>::symbol() { return "m"; }
+
+} // end namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_tostring.cpp
+// start catch_totals.cpp
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        return *this;
+    }
+
+    std::size_t Counts::total() const {
+        return passed + failed + failedButOk;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+// end catch_uncaught_exceptions.cpp
+// start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 2, 11, 3, "", 0 );
+        return version;
+    }
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive::Choice caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = m_str[idx];
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = m_str[idx + n];
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( std::string const& url ) {
+        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+    }
+
+    XmlWriter& XmlWriter::writeBlankLine() {
+        ensureTagClosed();
+        m_os << '\n';
+        return *this;
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << std::endl;
+            m_needsNewline = false;
+        }
+    }
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result) {
+        result.getExpandedExpression();
+    }
+
+    // Because formatting using c++ streams is stateful, drop down to C is required
+    // Alternatively we could use stringstream, but its performance is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
+
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        sprintf_s(buffer, "%.3f", duration);
+#else
+        std::sprintf(buffer, "%.3f", duration);
+#endif
+        return std::string(buffer);
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
+    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+        :StreamingReporterBase(_config) {}
+
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
+
+    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
+
+    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+        return false;
+    }
+
+} // end namespace Catch
+// end catch_reporter_bases.cpp
+// start catch_reporter_compact.cpp
+
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+    const char* failedString() { return "FAILED"; }
+    const char* passedString() { return "PASSED"; }
+#else
+    const char* failedString() { return "failed"; }
+    const char* passedString() { return "passed"; }
+#endif
+
+    // Colour::LightGrey
+    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+
+    std::string bothOrAll( std::size_t count ) {
+        return count == 1 ? std::string() :
+               count == 2 ? "both " : "all " ;
+    }
+
+} // anon namespace
+
+namespace Catch {
+namespace {
+// Colour, message variants:
+// - white: No tests ran.
+// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+// - white: Passed [both/all] N test cases (no assertions).
+// -   red: Failed N tests cases, failed M assertions.
+// - green: Passed [both/all] N tests cases with M assertions.
+void printTotals(std::ostream& out, const Totals& totals) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour colour(Colour::ResultError);
+        const std::string qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : std::string();
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion") << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case")
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        Colour colour(Colour::ResultError);
+        out <<
+            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+    } else {
+        Colour colour(Colour::ResultSuccess);
+        out <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") <<
+            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+    }
+}
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages) {}
+
+    void print() {
+        printSourceInfo();
+
+        itMessage = messages.begin();
+
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, passedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+            else
+                printResultType(Colour::Error, failedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, failedString());
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, failedString());
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, failedString());
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, failedString());
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+        if (!passOrFail.empty()) {
+            {
+                Colour colourGuard(colour);
+                stream << ' ' << passOrFail;
+            }
+            stream << ':';
+        }
+    }
+
+    void printIssue(std::string const& issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                Colour colour(dimColour());
+                stream << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            {
+                Colour colour(dimColour());
+                stream << " for: ";
+            }
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = dimColour()) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        {
+            Colour colourGuard(colour);
+            stream << " with " << pluralise(N, "message") << ':';
+        }
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    Colour colourGuard(dimColour());
+                    stream << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        ReporterPreferences CompactReporter::getPreferences() const {
+            return m_reporterPrefs;
+        }
+
+        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
+
+        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( stream, _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+        CompactReporter::~CompactReporter() {}
+
+    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+// end catch_reporter_compact.cpp
+// start catch_reporter_console.cpp
+
+#include <cfloat>
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED";
+            //if( result.hasMessage() )
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok";
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED";
+            }
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to unexpected exception with ";
+            if (_stats.infoMessages.size() == 1)
+                messageLabel += "message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel += "messages";
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "because no exception was thrown where one was expected";
+            break;
+        case ResultWas::Info:
+            messageLabel = "info";
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning";
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED";
+            colour = Colour::Error;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "explicitly with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "explicitly with messages";
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **";
+            colour = Colour::Error;
+            break;
+        }
+    }
+
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
+        }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            Colour colourGuard(colour);
+            stream << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            Colour colourGuard(Colour::OriginalExpression);
+            stream << "  ";
+            stream << result.getExpressionInMacro();
+            stream << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            Colour colourGuard(Colour::ReconstructedExpression);
+            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    std::string passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio(std::size_t number, std::size_t total) {
+    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : ratio;
+}
+
+std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+    if (i > j && i > k)
+        return i;
+    else if (j > k)
+        return j;
+    else
+        return k;
+}
+
+struct ColumnInfo {
+    enum Justification { Left, Right };
+    std::string name;
+    int width;
+    Justification justification;
+};
+struct ColumnBreak {};
+struct RowBreak {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
+    };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    auto unitsAsString() const -> std::string {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns";
+        case Unit::Microseconds:
+            return "us";
+        case Unit::Milliseconds:
+            return "ms";
+        case Unit::Seconds:
+            return "s";
+        case Unit::Minutes:
+            return "m";
+        default:
+            return "** internal error **";
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    std::ostringstream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( std::move( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << std::endl;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == ColumnInfo::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+    : StreamingReporterBase(config),
+    m_tablePrinter(new TablePrinter(config.stream(),
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+}
+
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+        return false;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+    printer.print();
+    stream << std::endl;
+    return true;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        Colour colour(Colour::ResultError);
+        if (m_sectionStack.size() > 1)
+            stream << "\nNo assertions in section";
+        else
+            stream << "\nNo assertions in test case";
+        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+    }
+    if (m_config->showDurations() == ShowDurations::Always) {
+        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+    if (currentGroupInfo.used) {
+        printSummaryDivider();
+        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+        printTotals(_testGroupStats.totals);
+        stream << '\n' << std::endl;
+    }
+    StreamingReporterBase::testGroupEnded(_testGroupStats);
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    stream << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if (!currentTestRunInfo.used)
+        lazyPrintRunInfo();
+    if (!currentGroupInfo.used)
+        lazyPrintGroupInfo();
+
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    stream << '\n' << getLineOfChars<'~'>() << '\n';
+    Colour colour(Colour::SecondaryText);
+    stream << currentTestRunInfo->name
+        << " is a Catch v" << libraryVersion() << " host application.\n"
+        << "Run with -? for options\n\n";
+
+    if (m_config->rngSeed() != 0)
+        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+    currentTestRunInfo.used = true;
+}
+void ConsoleReporter::lazyPrintGroupInfo() {
+    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+        printClosedHeader("Group: " + currentGroupInfo->name);
+        currentGroupInfo.used = true;
+    }
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        Colour colourGuard(Colour::Headers);
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
+    stream << getLineOfChars<'.'>() << '\n' << std::endl;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    stream << getLineOfChars<'.'>() << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    stream << getLineOfChars<'-'>() << '\n';
+    {
+        Colour colourGuard(Colour::Headers);
+        printHeaderString(_name);
+    }
+}
+
+// if string has a : in first line will set indent to follow it on
+// subsequent lines
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    std::size_t i = _string.find(": ");
+    if (i != std::string::npos)
+        i += 2;
+    else
+        i = 0;
+    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( std::move( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::size_t count ) {
+        ReusableStringStream rss;
+        rss << count;
+        std::string row = rss.str();
+        for (auto& oldRow : rows) {
+            while (oldRow.size() < row.size())
+                oldRow = ' ' + oldRow;
+            while (oldRow.size() > row.size())
+                row = ' ' + row;
+        }
+        rows.push_back(row);
+        return *this;
+    }
+
+    std::string label;
+    Colour::Code colour;
+    std::vector<std::string> rows;
+
+};
+
+void ConsoleReporter::printTotals( Totals const& totals ) {
+    if (totals.testCases.total() == 0) {
+        stream << Colour(Colour::Warning) << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        stream << Colour(Colour::ResultSuccess) << "All tests passed";
+        stream << " ("
+            << pluralise(totals.assertions.passed, "assertion") << " in "
+            << pluralise(totals.testCases.passed, "test case") << ')'
+            << '\n';
+    } else {
+
+        std::vector<SummaryColumn> columns;
+        columns.push_back(SummaryColumn("", Colour::None)
+                          .addRow(totals.testCases.total())
+                          .addRow(totals.assertions.total()));
+        columns.push_back(SummaryColumn("passed", Colour::Success)
+                          .addRow(totals.testCases.passed)
+                          .addRow(totals.assertions.passed));
+        columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                          .addRow(totals.testCases.failed)
+                          .addRow(totals.assertions.failed));
+        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                          .addRow(totals.testCases.failedButOk)
+                          .addRow(totals.assertions.failedButOk));
+
+        printSummaryRow("test cases", columns, 0);
+        printSummaryRow("assertions", columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string value = col.rows[row];
+        if (col.label.empty()) {
+            stream << label << ": ";
+            if (value != "0")
+                stream << value;
+            else
+                stream << Colour(Colour::Warning) << "- none -";
+        } else if (value != "0") {
+            stream << Colour(Colour::LightGrey) << " | ";
+            stream << Colour(col.colour)
+                << value << ' ' << col.label;
+        }
+    }
+    stream << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+        if (totals.testCases.allPassed())
+            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+        else
+            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    } else {
+        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+    }
+    stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    stream << getLineOfChars<'-'>() << '\n';
+}
+
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
+CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+// end catch_reporter_console.cpp
+// start catch_reporter_junit.cpp
+
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+        std::string fileNameTag(const std::vector<std::string> &tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (std::string const& tag) {return tag.front() == '#'; });
+            if (it != tags.end())
+                return it->substr(1);
+            return std::string();
+        }
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+    JunitReporter::~JunitReporter() {}
+
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
+    }
+
+    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+    }
+
+    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+        CumulativeReporterBase::testGroupStarting( groupInfo );
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        return CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        double suiteTime = suiteTimer.getElapsedSeconds();
+        CumulativeReporterBase::testGroupEnded( testGroupStats );
+        writeGroup( *m_testGroups.back(), suiteTime );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        xml.endElement();
+    }
+
+    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestGroupStats const& stats = groupNode.value;
+        xml.writeAttribute( "name", stats.groupInfo.name );
+        xml.writeAttribute( "errors", unexpectedExceptions );
+        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests", stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname", "tbd" ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time", "" );
+        else
+            xml.writeAttribute( "time", suiteTime );
+        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : groupNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className = stats.testInfo.className;
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo.tags);
+            if ( className.empty() )
+                className = "global";
+        }
+
+        if ( !m_config->name().empty() )
+            className = m_config->name() + "." + className;
+
+        writeSection( className, "", rootSection );
+    }
+
+    void JunitReporter::writeSection(  std::string const& className,
+                        std::string const& rootName,
+                        SectionNode const& sectionNode ) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( !sectionNode.assertions.empty() ||
+            !sectionNode.stdOut.empty() ||
+            !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname", name );
+                xml.writeAttribute( "name", "root" );
+            }
+            else {
+                xml.writeAttribute( "classname", className );
+                xml.writeAttribute( "name", name );
+            }
+            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+
+            writeAssertions( sectionNode );
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode );
+            else
+                writeSection( className, name, *childNode );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for( auto const& assertion : sectionNode.assertions )
+            writeAssertion( assertion );
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if( !result.isOk() ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message", result.getExpression() );
+            xml.writeAttribute( "type", result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            if( !result.getMessage().empty() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+// end catch_reporter_junit.cpp
+// start catch_reporter_listening.cpp
+
+#include <cassert>
+
+namespace Catch {
+
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+        m_listeners.push_back( std::move( listener ) );
+    }
+
+    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+        m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    }
+
+    ReporterPreferences ListeningReporter::getPreferences() const {
+        return m_preferences;
+    }
+
+    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+        return std::set<Verbosity>{ };
+    }
+
+    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->noMatchingTestCases( spec );
+        }
+        m_reporter->noMatchingTestCases( spec );
+    }
+
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
+    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkStarting( benchmarkInfo );
+        }
+        m_reporter->benchmarkStarting( benchmarkInfo );
+    }
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkEnded( benchmarkStats );
+        }
+        m_reporter->benchmarkEnded( benchmarkStats );
+    }
+
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunStarting( testRunInfo );
+        }
+        m_reporter->testRunStarting( testRunInfo );
+    }
+
+    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupStarting( groupInfo );
+        }
+        m_reporter->testGroupStarting( groupInfo );
+    }
+
+    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseStarting( testInfo );
+        }
+        m_reporter->testCaseStarting( testInfo );
+    }
+
+    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionStarting( sectionInfo );
+        }
+        m_reporter->sectionStarting( sectionInfo );
+    }
+
+    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->assertionStarting( assertionInfo );
+        }
+        m_reporter->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        for( auto const& listener : m_listeners ) {
+            static_cast<void>( listener->assertionEnded( assertionStats ) );
+        }
+        return m_reporter->assertionEnded( assertionStats );
+    }
+
+    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionEnded( sectionStats );
+        }
+        m_reporter->sectionEnded( sectionStats );
+    }
+
+    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseEnded( testCaseStats );
+        }
+        m_reporter->testCaseEnded( testCaseStats );
+    }
+
+    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupEnded( testGroupStats );
+        }
+        m_reporter->testGroupEnded( testGroupStats );
+    }
+
+    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunEnded( testRunStats );
+        }
+        m_reporter->testRunEnded( testRunStats );
+    }
+
+    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->skipTest( testInfo );
+        }
+        m_reporter->skipTest( testInfo );
+    }
+
+    bool ListeningReporter::isMulti() const {
+        return true;
+    }
+
+} // end namespace Catch
+// end catch_reporter_listening.cpp
+// start catch_reporter_xml.cpp
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig const& _config )
+    :   StreamingReporterBase( _config ),
+        m_xml(_config.stream())
+    {
+        m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename", sourceInfo.file )
+            .writeAttribute( "line", sourceInfo.line );
+    }
+
+    void XmlReporter::noMatchingTestCases( std::string const& s ) {
+        StreamingReporterBase::noMatchingTestCases( s );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement( "Catch" );
+        if( !m_config->name().empty() )
+            m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
+    }
+
+    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        StreamingReporterBase::testGroupStarting( groupInfo );
+        m_xml.startElement( "Group" )
+            .writeAttribute( "name", groupInfo.name );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name", trim( testInfo.name ) )
+            .writeAttribute( "description", testInfo.description )
+            .writeAttribute( "tags", testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name", trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    m_xml.scopedElement( "Info" )
+                            .writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    m_xml.scopedElement( "Warning" )
+                            .writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if( !includeResults && result.getResultType() != ResultWas::Warning )
+            return true;
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success", result.succeeded() )
+                .writeAttribute( "type", result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                    .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+
+        return true;
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes", sectionStats.assertions.passed );
+            e.writeAttribute( "failures", sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        StreamingReporterBase::testGroupEnded( testGroupStats );
+        // TODO: Check testGroupStats.aborting and act accordingly.
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+// end catch_reporter_xml.cpp
+
+namespace Catch {
+    LeakDetector leakDetector;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_impl.hpp
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// start catch_default_main.hpp
+
+#ifndef __OBJC__
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char**)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+// end catch_default_main.hpp
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
+
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+using Catch::Detail::Approx;
+
+#else // CATCH_CONFIG_DISABLE
+
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... )        (void)(0)
+#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CATCH_CHECK( ... )         (void)(0)
+#define CATCH_CHECK_FALSE( ... )   (void)(0)
+#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+#define CATCH_CHECK_THROWS( ... )  (void)(0)
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CHECK( ... ) (void)(0)
+#define CHECK_FALSE( ... ) (void)(0)
+#define CHECKED_IF( ... ) if (__VA_ARGS__)
+#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL( ... ) (void)(0)
+
+#define CHECK_THROWS( ... )  (void)(0)
+#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
+
+#define GIVEN( desc )
+#define AND_GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+// start catch_reenable_warnings.h
+
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+// end catch_reenable_warnings.h
+// end catch.hpp
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/unittest/catch2/catch_reporter_automake.hpp b/unittest/catch2/catch_reporter_automake.hpp
new file mode 100644
index 00000000..dbebe975
--- /dev/null
+++ b/unittest/catch2/catch_reporter_automake.hpp
@@ -0,0 +1,62 @@
+/*
+ *  Created by Justin R. Wilson on 2/19/2017.
+ *  Copyright 2017 Justin R. Wilson. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+namespace Catch {
+
+    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
+        AutomakeReporter( ReporterConfig const& _config )
+          :   StreamingReporterBase( _config )
+        {}
+
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the format of Automake .trs files";
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+            stream << ":test-result: ";
+            if (_testCaseStats.totals.assertions.allPassed()) {
+                stream << "PASS";
+            } else if (_testCaseStats.totals.assertions.allOk()) {
+                stream << "XFAIL";
+            } else {
+                stream << "FAIL";
+            }
+            stream << ' ' << _testCaseStats.testInfo.name << '\n';
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+        }
+
+        void skipTest( TestCaseInfo const& testInfo ) override {
+            stream << ":test-result: SKIP " << testInfo.name << '\n';
+        }
+
+    };
+
+#ifdef CATCH_IMPL
+    AutomakeReporter::~AutomakeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_sonarqube.hpp b/unittest/catch2/catch_reporter_sonarqube.hpp
new file mode 100644
index 00000000..bf7d9299
--- /dev/null
+++ b/unittest/catch2/catch_reporter_sonarqube.hpp
@@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/unittest/catch2/catch_reporter_tap.hpp b/unittest/catch2/catch_reporter_tap.hpp
new file mode 100644
index 00000000..1bfe4f5e
--- /dev/null
+++ b/unittest/catch2/catch_reporter_tap.hpp
@@ -0,0 +1,253 @@
+/*
+ *  Created by Colton Wolkins on 2015-08-15.
+ *  Copyright 2015 Martin Moene. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct TAPReporter : StreamingReporterBase<TAPReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~TAPReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in TAP format, suitable for test harnesses";
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        void noMatchingTestCases( std::string const& spec ) override {
+            stream << "# No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
+            ++counter;
+
+            stream << "# " << currentTestCaseInfo->name << std::endl;
+            AssertionPrinter printer( stream, _assertionStats, counter );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        std::size_t counter = 0;
+        class AssertionPrinter {
+        public:
+            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
+            AssertionPrinter( AssertionPrinter const& ) = delete;
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
+            : stream( _stream )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( true )
+            , counter(_counter)
+            {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if (result.isOk()) {
+                            printResultType(passedString());
+                        } else {
+                            printResultType(failedString());
+                        }
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if (result.isOk()) {
+                            printIssue(" # TODO");
+                        }
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+            static const char* failedString() { return "not ok"; }
+            static const char* passedString() { return "ok"; }
+
+            void printSourceInfo() const {
+                Colour colourGuard( dimColour() );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    std::string expr = result.getExpandedExpression();
+                    std::replace( expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+        };
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "1..0 # Skipped: No tests ran.";
+            } else {
+                stream << "1.." << counter;
+            }
+        }
+    };
+
+#ifdef CATCH_IMPL
+    TAPReporter::~TAPReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_teamcity.hpp b/unittest/catch2/catch_reporter_teamcity.hpp
new file mode 100644
index 00000000..47b7e4aa
--- /dev/null
+++ b/unittest/catch2/catch_reporter_teamcity.hpp
@@ -0,0 +1,219 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
+        TeamCityReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape( std::string const& str ) {
+            std::string escaped = str;
+            replaceInPlace( escaped, "|", "||" );
+            replaceInPlace( escaped, "'", "|'" );
+            replaceInPlace( escaped, "\n", "|n" );
+            replaceInPlace( escaped, "\r", "|r" );
+            replaceInPlace( escaped, "[", "|[" );
+            replaceInPlace( escaped, "]", "|]" );
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        }
+
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
+
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            stream << "##teamcity[testSuiteStarted name='"
+                << escape( groupInfo.name ) << "']\n";
+        }
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            stream << "##teamcity[testSuiteFinished name='"
+                << escape( testGroupStats.groupInfo.name ) << "']\n";
+        }
+
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if( !result.isOk() ) {
+
+                ReusableStringStream msg;
+                if( !m_headerPrintedForThisSection )
+                    printSectionHeader( msg.get() );
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch( result.getResultType() ) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR( "Internal error in TeamCity reporter" );
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR( "Not implemented" );
+                }
+                if( assertionStats.infoMessages.size() == 1 )
+                    msg << " with message:";
+                if( assertionStats.infoMessages.size() > 1 )
+                    msg << " with messages:";
+                for( auto const& messageInfo : assertionStats.infoMessages )
+                    msg << "\n  \"" << messageInfo.message << "\"";
+
+
+                if( result.hasExpression() ) {
+                    msg <<
+                        "\n  " << result.getExpressionInMacro() << "\n"
+                        "with expansion:\n" <<
+                        "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting( testInfo );
+            stream << "##teamcity[testStarted name='"
+                << escape( testInfo.name ) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            if( !testCaseStats.stdOut.empty() )
+                stream << "##teamcity[testStdOut name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
+            if( !testCaseStats.stdErr.empty() )
+                stream << "##teamcity[testStdErr name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
+            stream << "##teamcity[testFinished name='"
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader( std::ostream& os ) {
+            assert( !m_sectionStack.empty() );
+
+            if( m_sectionStack.size() > 1 ) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin()+1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( os, it->name );
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            os << Column( _string )
+                           .indent( indent+i)
+                           .initialIndent( indent ) << "\n";
+        }
+    private:
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
diff --git a/unittest/config/FSFWConfig.h b/unittest/config/FSFWConfig.h
new file mode 100644
index 00000000..665c939f
--- /dev/null
+++ b/unittest/config/FSFWConfig.h
@@ -0,0 +1,32 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <fsfw/unittest/config/version.h>
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NEWLIB_NANO_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/config/TestsConfig.h b/unittest/config/TestsConfig.h
new file mode 100644
index 00000000..7bf667f7
--- /dev/null
+++ b/unittest/config/TestsConfig.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+#define FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+
+
+
+
+
+#endif /* FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_ */
diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
new file mode 100644
index 00000000..6c2278ab
--- /dev/null
+++ b/unittest/config/cdatapool/dataPoolInit.cpp
@@ -0,0 +1,48 @@
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+
+void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
+	uint8_t UINT8T_INIT[1] = {0};
+	uint16_t UINT16T_INIT[1] = {0};
+	uint32_t UINT32T_INIT[1] = {0};
+	float FLOAT_INIT[2] = {0.0, 0.0};
+	/* FSFW */
+	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+
+	/* TEST */
+	poolMap->emplace(datapool::TEST_UINT8,
+			new PoolEntry<uint8_t>(UINT8T_INIT,1));
+	poolMap->emplace(datapool::TEST_UINT16,
+			new PoolEntry<uint16_t>(UINT16T_INIT,1));
+	poolMap->emplace(datapool::TEST_UINT32,
+			new PoolEntry<uint32_t>(UINT32T_INIT,1));
+	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
+			new PoolEntry<float>(FLOAT_INIT,2));
+
+	// With new initializer list feature and boolean entries.
+
+//	/* FSFW */
+//	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+//			new PoolEntry<uint32_t>({0},1));
+//
+//	/* TEST */
+//	poolMap->emplace(datapool::TEST_BOOLEAN,
+//			new PoolEntry<bool>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT8,
+//			new PoolEntry<uint8_t>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT16,
+//			new PoolEntry<uint16_t>({0},1));
+//	poolMap->emplace(datapool::TEST_UINT32,
+//			new PoolEntry<uint32_t>({0},1));
+//	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
+//			new PoolEntry<float>({0, 0},2));
+
+}
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
new file mode 100644
index 00000000..d482cc35
--- /dev/null
+++ b/unittest/config/cdatapool/dataPoolInit.h
@@ -0,0 +1,29 @@
+#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+
+#include <fsfw/datapool/DataPool.h>
+#include <fsfw/datapool/PoolEntryIF.h>
+#include <map>
+#include <cstdint>
+
+
+namespace datapool {
+	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
+
+	enum datapoolvariables {
+		NO_PARAMETER = 0,
+
+		/** [EXPORT] : [GROUP] FSFW */
+		INTERNAL_ERROR_STORE_FULL = 0xEE000001, 	 //!< [EXPORT] : [NAME] Internal Error Store Entry [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		INTERNAL_ERROR_MISSED_LIVE_TM = 0xEE000001,  //!< [EXPORT] : [NAME] Internal Error Missed Live Tm [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		INTERNAL_ERROR_FULL_MSG_QUEUES = 0xEE000001, //!< [EXPORT] : [NAME] Internal Error Full Msg Queue [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+
+		/** [EXPORT] : [GROUP] TEST */
+		TEST_BOOLEAN = 0x01010102, 				//!< [EXPORT] : [NAME] Test Boolean [UNIT] (-) [SIZE] 1 [TYPE] bool
+		TEST_UINT8 = 0x02020204,				//!< [EXPORT] : [NAME] Test Byte [UNIT] (-) [SIZE] 1 [TYPE] uint8_t
+		TEST_UINT16 = 0x03030306,				//!< [EXPORT] : [NAME] Test UINT16 [UNIT] (-) [SIZE] 1 [TYPE] uint16_t
+		TEST_UINT32 = 0x04040408,				//!< [EXPORT] : [NAME] Test UINT32 [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
+		TEST_FLOAT_VECTOR = 0x05050510,			//!< [EXPORT] : [NAME] Test Float [UNIT] (-) [SIZE] 2 [TYPE] float
+	};
+}
+#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/config.mk b/unittest/config/config.mk
new file mode 100644
index 00000000..64fa87f6
--- /dev/null
+++ b/unittest/config/config.mk
@@ -0,0 +1,15 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/objects
+INCLUDES += $(CURRENTPATH)/ipc
+INCLUDES += $(CURRENTPATH)/pollingsequence
+INCLUDES += $(CURRENTPATH)/returnvalues
+INCLUDES += $(CURRENTPATH)/tmtc
+INCLUDES += $(CURRENTPATH)/events
+INCLUDES += $(CURRENTPATH)/devices
+INCLUDES += $(CURRENTPATH)/cdatapool
diff --git a/unittest/config/devices/logicalAddresses.cpp b/unittest/config/devices/logicalAddresses.cpp
new file mode 100644
index 00000000..15776275
--- /dev/null
+++ b/unittest/config/devices/logicalAddresses.cpp
@@ -0,0 +1,11 @@
+/**
+ * \file logicalAddresses.cpp
+ *
+ * \date 06.11.2019
+ */
+
+#include <fsfw/unittest/config/devices/logicalAddresses.h>
+
+
+
+
diff --git a/unittest/config/devices/logicalAddresses.h b/unittest/config/devices/logicalAddresses.h
new file mode 100644
index 00000000..cdf87025
--- /dev/null
+++ b/unittest/config/devices/logicalAddresses.h
@@ -0,0 +1,15 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/unittest/config/objects/systemObjectList.h>
+#include <cstdint>
+
+namespace addresses {
+	/* Logical addresses have uint32_t datatype */
+	enum logicalAddresses: address_t {
+	};
+}
+
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */
diff --git a/unittest/config/devices/powerSwitcherList.cpp b/unittest/config/devices/powerSwitcherList.cpp
new file mode 100644
index 00000000..cb568522
--- /dev/null
+++ b/unittest/config/devices/powerSwitcherList.cpp
@@ -0,0 +1,10 @@
+/**
+ * @file switcherList.cpp
+ *
+ * @date 28.11.2019
+ */
+
+#include <fsfw/unittest/config/devices/powerSwitcherList.h>
+
+
+
diff --git a/unittest/config/devices/powerSwitcherList.h b/unittest/config/devices/powerSwitcherList.h
new file mode 100644
index 00000000..f5b0eb11
--- /dev/null
+++ b/unittest/config/devices/powerSwitcherList.h
@@ -0,0 +1,22 @@
+/**
+ * @file switcherList.h
+ *
+ * @date 28.11.2019
+ */
+
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+		PCDU,
+		GPS0,
+		GPS1,
+		DUMMY = 129
+	};
+
+}
+
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */
diff --git a/unittest/config/events/translateEvents.cpp b/unittest/config/events/translateEvents.cpp
new file mode 100644
index 00000000..bfcbe2bc
--- /dev/null
+++ b/unittest/config/events/translateEvents.cpp
@@ -0,0 +1,20 @@
+/**
+ * @brief    Auto-generated event translation file. Contains 80 translations.
+ * Generated on: 2020-05-02 20:13:41 
+ */
+#include <fsfw/unittest/config/events/translateEvents.h>
+
+const char *TEST_EVENT_SERVICE_1_STRING = "TEST_EVENT_SERVICE_1";
+const char *TEST2_STRING = "TEST2";
+
+const char * translateEvents(Event event){
+	switch((event&0xFFFF)){
+		case 8000:
+			return TEST_EVENT_SERVICE_1_STRING;
+		case 9100:
+			return TEST2_STRING;
+		default:
+			return "UNKNOWN_EVENT";
+	}
+	return 0;
+}
diff --git a/unittest/config/events/translateEvents.h b/unittest/config/events/translateEvents.h
new file mode 100644
index 00000000..0e40ef8b
--- /dev/null
+++ b/unittest/config/events/translateEvents.h
@@ -0,0 +1,16 @@
+/*
+ * translateEvent.h
+ *
+ *  Created on: 28 May 2019
+ *      Author: Robin
+ */
+
+#ifndef CONFIG_EVENTS_TRANSLATEEVENTS_H_
+#define CONFIG_EVENTS_TRANSLATEEVENTS_H_
+
+#include <fsfw/events/Event.h>
+
+const char * translateEvents(Event event);
+
+
+#endif /* CONFIG_EVENTS_TRANSLATEEVENTS_H_ */
diff --git a/unittest/config/ipc/MissionMessageTypes.cpp b/unittest/config/ipc/MissionMessageTypes.cpp
new file mode 100644
index 00000000..304ca439
--- /dev/null
+++ b/unittest/config/ipc/MissionMessageTypes.cpp
@@ -0,0 +1,11 @@
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch((message->getCommand()>>8) & 0xff) {
+	default:
+		break;
+	}
+}
+
+
diff --git a/unittest/config/ipc/MissionMessageTypes.h b/unittest/config/ipc/MissionMessageTypes.h
new file mode 100644
index 00000000..832d8e58
--- /dev/null
+++ b/unittest/config/ipc/MissionMessageTypes.h
@@ -0,0 +1,22 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/FwMessageTypes.h>
+
+class CommandMessage;
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes{
+enum MESSAGE_TYPE {
+	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
+};
+
+void clearMissionMessage(CommandMessage* message);
+}
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
diff --git a/unittest/config/objects/Factory.cpp b/unittest/config/objects/Factory.cpp
new file mode 100644
index 00000000..e325b891
--- /dev/null
+++ b/unittest/config/objects/Factory.cpp
@@ -0,0 +1,37 @@
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include <fsfw/unittest/config/objects/Factory.h>
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER,
+				datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
+				datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
+				datapool::INTERNAL_ERROR_STORE_FULL);
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/config/objects/Factory.h b/unittest/config/objects/Factory.h
new file mode 100644
index 00000000..84f9207e
--- /dev/null
+++ b/unittest/config/objects/Factory.h
@@ -0,0 +1,16 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace Factory {
+	/**
+	 * @brief 	Creates all SystemObject elements which are persistent
+	 * 			during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+#endif /* FACTORY_H_ */
diff --git a/unittest/config/objects/systemObjectList.h b/unittest/config/objects/systemObjectList.h
new file mode 100644
index 00000000..9793305e
--- /dev/null
+++ b/unittest/config/objects/systemObjectList.h
@@ -0,0 +1,30 @@
+#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* First Byte 0x50-0x52 reserved for PUS Services **/
+		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
+		PUS_PACKET_DISTRIBUTOR = 0x50000200,
+		UDP_BRIDGE = 0x50000300,
+		UDP_POLLING_TASK = 0x50000400,
+
+		PUS_SERVICE_3 = 0x51000300,
+		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
+		PUS_SERVICE_23 = 0x51002300,
+		PUS_SERVICE_201_HEALTH = 0x51020100,
+
+		PUS_TIME = 0x52000001,
+		PUS_FUNNEL = 0x52000002,
+
+		/* Test Task */
+		TEST_TASK = 0x42694269,
+		DUMMY_INTERFACE = 0xCAFECAFE,
+		DUMMY_HANDLER = 0x4400AFFE,
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/objects/translateObjects.cpp b/unittest/config/objects/translateObjects.cpp
new file mode 100644
index 00000000..abcb1b40
--- /dev/null
+++ b/unittest/config/objects/translateObjects.cpp
@@ -0,0 +1,242 @@
+/* Auto-generated event translation file. Contains 77 translations. */
+#include <fsfw/unittest/config/objects/translateObjects.h>
+
+const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
+const char *ARDUINO_0_STRING = "ARDUINO_0";
+const char *ARDUINO_1_STRING = "ARDUINO_1";
+const char *ARDUINO_2_STRING = "ARDUINO_2";
+const char *ARDUINO_3_STRING = "ARDUINO_3";
+const char *ARDUINO_4_STRING = "ARDUINO_4";
+const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *S_ADC1_DEC2_STRING = "S_ADC1_DEC2";
+const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
+const char *DLR_PVCH_STRING = "DLR_PVCH";
+const char *GYRO1_STRING = "GYRO1";
+const char *DLR_IRAS_STRING = "DLR_IRAS";
+const char *_DEC1_O1_STRING = "_DEC1_O1";
+const char *_DEC1_O2_STRING = "_DEC1_O2";
+const char *S1_DEC1_O3_STRING = "S1_DEC1_O3";
+const char *S2_DEC1_O4_STRING = "S2_DEC1_O4";
+const char *S3_DEC1_O5_STRING = "S3_DEC1_O5";
+const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
+const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
+const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
+const char *S4_DEC2_STRING = "S4_DEC2";
+const char *S5_DEC2_STRING = "S5_DEC2";
+const char *S6_DEC2_STRING = "S6_DEC2";
+const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
+const char *_DEC3_STRING = "_DEC3";
+const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
+const char *S7_DEC3_STRING = "S7_DEC3";
+const char *S8_DEC3_STRING = "S8_DEC3";
+const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
+const char *GYRO2_STRING = "GYRO2";
+const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
+const char *S9_DEC4_STRING = "S9_DEC4";
+const char *S10_DEC4_STRING = "S10_DEC4";
+const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
+const char *S_ADC_DEC4_STRING = "S_ADC_DEC4";
+const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
+const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
+const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
+const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
+const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
+const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
+const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
+const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
+const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
+const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
+const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
+const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
+const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
+const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
+const char *UART_TMTC_BRIDGE_STRING = "UART_TMTC_BRIDGE";
+const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
+const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
+const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
+const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
+const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
+const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
+const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
+const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
+const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
+const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *PUS_TIME_STRING = "PUS_TIME";
+const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
+const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
+const char *MODE_STORE_STRING = "MODE_STORE";
+const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
+const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
+const char *TC_STORE_STRING = "TC_STORE";
+const char *TM_STORE_STRING = "TM_STORE";
+const char *IPC_STORE_STRING = "IPC_STORE";
+const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
+const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
+const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
+const char *NO_OBJECT_STRING = "NO_OBJECT";
+
+const char* translateObject(object_id_t object){
+	switch((object&0xFFFFFFFF)){
+		case 0x000123336:
+			return AT91_UART2_TEST_TASK_STRING;
+		case 0x01010100:
+			return ARDUINO_0_STRING;
+		case 0x01010101:
+			return ARDUINO_1_STRING;
+		case 0x01010102:
+			return ARDUINO_2_STRING;
+		case 0x01010103:
+			return ARDUINO_3_STRING;
+		case 0x01010104:
+			return ARDUINO_4_STRING;
+		case 0x12345678:
+			return AT91_I2C_TEST_TASK_STRING;
+		case 0x42694269:
+			return TEST_TASK_STRING;
+		case 0x44003200:
+			return PCDU_HANDLER_STRING;
+		case 0x4400AFFE:
+			return DUMMY_HANDLER_STRING;
+		case 0x44020108:
+			return S_ADC1_DEC2_STRING;
+		case 0x44101F00:
+			return GPS0_HANDLER_STRING;
+		case 0x44104000:
+			return DLR_PVCH_STRING;
+		case 0x44105000:
+			return GYRO1_STRING;
+		case 0x44106000:
+			return DLR_IRAS_STRING;
+		case 0x44115401:
+			return _DEC1_O1_STRING;
+		case 0x44115402:
+			return _DEC1_O2_STRING;
+		case 0x44115404:
+			return S1_DEC1_O3_STRING;
+		case 0x44115405:
+			return S2_DEC1_O4_STRING;
+		case 0x44115406:
+			return S3_DEC1_O5_STRING;
+		case 0x44115407:
+			return PT1000_PVHC_DEC1_O6_STRING;
+		case 0x44125401:
+			return PT1000_CCSDS1_DEC2_STRING;
+		case 0x44125403:
+			return PT1000_MGT1_DEC2_STRING;
+		case 0x44125404:
+			return S4_DEC2_STRING;
+		case 0x44125405:
+			return S5_DEC2_STRING;
+		case 0x44125406:
+			return S6_DEC2_STRING;
+		case 0x44125407:
+			return PT1000_PVCH_DEC2_STRING;
+		case 0x44130301:
+			return _DEC3_STRING;
+		case 0x44130302:
+			return PT1000_CCSDS2_DEC3_STRING;
+		case 0x44130305:
+			return S7_DEC3_STRING;
+		case 0x44130306:
+			return S8_DEC3_STRING;
+		case 0x44130307:
+			return PT1000_PVCH_DEC3_STRING;
+		case 0x44130308:
+			return GYRO2_STRING;
+		case 0x44145401:
+			return PT1000_PLOC_DEC4_STRING;
+		case 0x44145404:
+			return S9_DEC4_STRING;
+		case 0x44145405:
+			return S10_DEC4_STRING;
+		case 0x44145406:
+			return PT1000_PVHC_DEC4_STRING;
+		case 0x44145407:
+			return S_ADC_DEC4_STRING;
+		case 0x44202000:
+			return GPS1_HANDLER_STRING;
+		case 0x49001F00:
+			return DUMMY_GPS_COM_IF_STRING;
+		case 0x49005200:
+			return RS232_DEVICE_COM_IF_STRING;
+		case 0x49005300:
+			return I2C_DEVICE_COM_IF_STRING;
+		case 0x49005400:
+			return GPIO_DEVICE_COM_IF_STRING;
+		case 0x49005410:
+			return SPI_POLLING_TASK_STRING;
+		case 0x49005600:
+			return SPI_DEVICE_COM_IF_STRING;
+		case 0x4900AFFE:
+			return DUMMY_ECHO_COM_IF_STRING;
+		case 0x4D0073AD:
+			return SD_CARD_HANDLER_STRING;
+		case 0x50000100:
+			return CCSDS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000200:
+			return PUS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000300:
+			return UDP_TMTC_BRIDGE_STRING;
+		case 0x50000400:
+			return EMAC_POLLING_TASK_STRING;
+		case 0x50000600:
+			return SERIAL_POLLING_TASK_STRING;
+		case 0x5000500:
+			return UART_TMTC_BRIDGE_STRING;
+		case 0x51000100:
+			return PUS_SERVICE_1_STRING;
+		case 0x51000200:
+			return PUS_SERVICE_2_STRING;
+		case 0x51000300:
+			return PUS_SERVICE_3_STRING;
+		case 0x51000400:
+			return PUS_SERVICE_5_STRING;
+		case 0x51000500:
+			return PUS_SERVICE_6_STRING;
+		case 0x51000800:
+			return PUS_SERVICE_8_STRING;
+		case 0x51000900:
+			return PUS_SERVICE_9_STRING;
+		case 0x51001700:
+			return PUS_SERVICE_17_STRING;
+		case 0x51002300:
+			return PUS_SERVICE_23_STRING;
+		case 0x51020000:
+			return PUS_SERVICE_200_STRING;
+		case 0x51020100:
+			return PUS_SERVICE_201_STRING;
+		case 0x52000001:
+			return PUS_TIME_STRING;
+		case 0x52000002:
+			return PUS_FUNNEL_STRING;
+		case 0x53010000:
+			return HEALTH_TABLE_STRING;
+		case 0x53010100:
+			return MODE_STORE_STRING;
+		case 0x53030000:
+			return EVENT_MANAGER_STRING;
+		case 0x53040000:
+			return INTERNAL_ERROR_REPORTER_STRING;
+		case 0x534f0100:
+			return TC_STORE_STRING;
+		case 0x534f0200:
+			return TM_STORE_STRING;
+		case 0x534f0300:
+			return IPC_STORE_STRING;
+		case 0x66666666:
+			return AT91_SPI_TEST_TASK_STRING;
+		case 0x77777777:
+			return STM32_TEST_TASK_STRING;
+		case 0x87654321:
+			return AT91_UART0_TEST_TASK_STRING;
+		case 0xFFFFFFFF:
+			return NO_OBJECT_STRING;
+		default:
+			return "UNKNOWN_OBJECT";
+	}
+	return 0;
+}
diff --git a/unittest/config/objects/translateObjects.h b/unittest/config/objects/translateObjects.h
new file mode 100644
index 00000000..18c237eb
--- /dev/null
+++ b/unittest/config/objects/translateObjects.h
@@ -0,0 +1,16 @@
+/*
+ * translateObjects.h
+ *
+ *  Created on: 28 May 2019
+ *      Author: Robin
+ */
+
+#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+
+const char* translateObject(object_id_t object);
+
+
+#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.cpp b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 00000000..dbe13add
--- /dev/null
+++ b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,31 @@
+#include <PollingSequenceFactory.h>
+#include <systemObjectList.h>
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
+{
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0,  DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.25, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.5,  DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::DUMMY_HANDLER,
+            length * 0.75, DeviceHandlerIF::GET_READ);
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "PollingSequence::initialize has errors!" << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.h b/unittest/config/pollingsequence/PollingSequenceFactory.h
new file mode 100644
index 00000000..b6cc2f1e
--- /dev/null
+++ b/unittest/config/pollingsequence/PollingSequenceFactory.h
@@ -0,0 +1,31 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into
+ * Polling Sequence Tables (PST) to satisfy stricter timing requirements of
+ * device communication, a device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the
+ * 					   Factory class when creating the PST
+ * @return
+ */
+namespace pst {
+
+/* 0.4 second period init*/
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/unittest/config/returnvalues/classIds.h b/unittest/config/returnvalues/classIds.h
new file mode 100644
index 00000000..a024e3d7
--- /dev/null
+++ b/unittest/config/returnvalues/classIds.h
@@ -0,0 +1,28 @@
+/*
+ * classIds.h
+ *
+ *  Created on: 16.07.2018
+ *      Author: mohr
+ */
+
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+/**
+ * Source IDs starts at 73 for now
+ * Framework IDs for ReturnValues run from 0 to 56
+ * and are located inside <fsfw/returnvalues/FwClassIds.h>
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+	RS232_CHANNEL, //!< RS232
+	I2C_CHANNEL, //!< I2C
+	SPI_CHANNEL, //!< SPI
+	GPS_HANDLER,  //!< GPS
+	PUS_SERVICE_3 //!< HKS
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/tmtc/PusIds.hpp b/unittest/config/tmtc/PusIds.hpp
new file mode 100644
index 00000000..fd37c7f4
--- /dev/null
+++ b/unittest/config/tmtc/PusIds.hpp
@@ -0,0 +1,29 @@
+/*
+ * PusIds.hpp
+ *
+ *  Created on: 27.02.2019
+ *      Author: jakob
+ */
+
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace PUS{
+enum Ids{
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/apid.h b/unittest/config/tmtc/apid.h
new file mode 100644
index 00000000..77e55952
--- /dev/null
+++ b/unittest/config/tmtc/apid.h
@@ -0,0 +1,19 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <stdint.h>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets
+ *
+ * SOURCE APID: 0x73 / 115 / s
+ * APID is a 11 bit number
+ */
+namespace apid {
+	static const uint16_t SOURCE_OBSW = 0x73;
+}
+
+
+#endif /* CONFIG_TMTC_APID_H_ */
diff --git a/unittest/config/tmtc/pusIds.h b/unittest/config/tmtc/pusIds.h
new file mode 100644
index 00000000..a2dd7575
--- /dev/null
+++ b/unittest/config/tmtc/pusIds.h
@@ -0,0 +1,23 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace pus {
+enum Ids{
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_3_PSB = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_19 = 19,
+	PUS_SERVICE_20 = 20,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/subsystemIdRanges.h b/unittest/config/tmtc/subsystemIdRanges.h
new file mode 100644
index 00000000..e32de74c
--- /dev/null
+++ b/unittest/config/tmtc/subsystemIdRanges.h
@@ -0,0 +1,34 @@
+#ifndef CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+#define CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
+
+#include <fsfw/events/fwSubsystemIdRanges.h>
+#include <cstdint>
+
+/**
+ * These IDs are part of the ID for an event thrown by a subsystem.
+ * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTE_ID_START = FW_SUBSYSTEM_ID_RANGE,
+	/**
+	 * 80-105: PUS Services
+	 */
+	PUS_SERVICE_2 = 82,
+	PUS_SERVICE_3 = 83,
+	PUS_SERVICE_5 = 85,
+	PUS_SERVICE_6 = 86,
+	PUS_SERVICE_8 = 88,
+	PUS_SERVICE_23 = 91,
+	DUMMY_DEVICE = 100,
+	/**
+	 * 105-115: AOCS
+	 */
+	GPS_DEVICE = 105,
+
+	SPI_COM_IF = 128,
+	I2C_COM_IF = 138
+};
+}
+
+#endif /* CONFIG_TMTC_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/tmtc/tmTcSize.h b/unittest/config/tmtc/tmTcSize.h
new file mode 100644
index 00000000..de7f4adc
--- /dev/null
+++ b/unittest/config/tmtc/tmTcSize.h
@@ -0,0 +1,10 @@
+#ifndef CONFIG_TMTC_TMTCSIZE_H_
+#define CONFIG_TMTC_TMTCSIZE_H_
+
+#include <cstdint>
+
+namespace tmtcsize {
+static const uint32_t MAX_TM_PACKET = 50;
+}
+
+#endif /* CONFIG_TMTC_TMTCSIZE_H_ */
diff --git a/unittest/config/version.h b/unittest/config/version.h
new file mode 100644
index 00000000..f53345c1
--- /dev/null
+++ b/unittest/config/version.h
@@ -0,0 +1,7 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+#define SW_VERSION      1
+#define SW_SUBVERSION   6
+
+#endif /* CONFIG_VERSION_H_ */
diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/core/CatchDefinitions.cpp
new file mode 100644
index 00000000..3f4614e8
--- /dev/null
+++ b/unittest/core/CatchDefinitions.cpp
@@ -0,0 +1,11 @@
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+StorageManagerIF* tglob::getIpcStoreHandle() {
+	if(objectManager != nullptr) {
+		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	} else {
+		sif::error << "Global object manager uninitialized" << std::endl;
+		return nullptr;
+	}
+}
diff --git a/unittest/core/CatchDefinitions.h b/unittest/core/CatchDefinitions.h
new file mode 100644
index 00000000..cdc025fa
--- /dev/null
+++ b/unittest/core/CatchDefinitions.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+
+namespace retval {
+static constexpr int CATCH_OK = static_cast<int>(HasReturnvaluesIF::RETURN_OK);
+static constexpr int CATCH_FAILED = static_cast<int>(HasReturnvaluesIF::RETURN_FAILED);
+}
+
+namespace tconst {
+	static constexpr MessageQueueId_t testQueueId = 42;
+}
+
+namespace tglob {
+	StorageManagerIF* getIpcStoreHandle();
+}
+
diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
new file mode 100644
index 00000000..566db692
--- /dev/null
+++ b/unittest/core/CatchRunner.cpp
@@ -0,0 +1,27 @@
+/**
+ * @file 	CatchSource.cpp
+ * @brief 	Source file to compile catch framework.
+ * @details	All tests should be written in other files.
+ * For eclipse console output, install ANSI Escape in Console
+ * from the eclipse market place to get colored characters.
+ */
+
+#ifndef NO_UNIT_TEST_FRAMEWORK
+
+#define CATCH_CONFIG_RUNNER
+#include <fsfw/unittest/catch2/catch.hpp>
+
+extern int customSetup();
+
+int main( int argc, char* argv[] ) {
+    customSetup();
+
+    // Catch internal function call
+    int result = Catch::Session().run( argc, argv );
+
+    // global clean-up
+    return result;
+}
+
+
+#endif
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
new file mode 100644
index 00000000..5436fd5d
--- /dev/null
+++ b/unittest/core/CatchSetup.cpp
@@ -0,0 +1,41 @@
+#include "../config/cdatapool/dataPoolInit.h"
+#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include <fsfw/unittest/config/objects/Factory.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+#ifdef GCOV
+#include <gcov.h>
+#endif
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/datapool/DataPool.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+
+/* Global instantiations normally done in main.cpp */
+/* Initialize Data Pool */
+//namespace glob {
+DataPool dataPool(datapool::dataPoolInit);
+//}
+
+
+namespace sif {
+/* Set up output streams */
+ServiceInterfaceStream debug("DEBUG");
+ServiceInterfaceStream info("INFO");
+ServiceInterfaceStream error("ERROR");
+ServiceInterfaceStream warning("WARNING");
+}
+
+/* Global object manager */
+ObjectManagerIF *objectManager;
+
+int customSetup() {
+    // global setup
+    objectManager = new ObjectManager(Factory::produce);
+    objectManager -> initialize();
+    return 0;
+}
+
diff --git a/unittest/core/core.mk b/unittest/core/core.mk
new file mode 100644
index 00000000..3e5626d3
--- /dev/null
+++ b/unittest/core/core.mk
@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
\ No newline at end of file
diff --git a/unittest/core/printChar.cpp b/unittest/core/printChar.cpp
new file mode 100644
index 00000000..755a13b2
--- /dev/null
+++ b/unittest/core/printChar.cpp
@@ -0,0 +1,10 @@
+#include <fsfw/unittest/core/printChar.h>
+#include <cstdio>
+
+void printChar(const char* character, bool errStream) {
+	if(errStream) {
+		std::putc(*character, stderr);
+		return;
+	}
+	std::putc(*character, stdout);
+}
diff --git a/unittest/core/printChar.h b/unittest/core/printChar.h
new file mode 100644
index 00000000..80e867f6
--- /dev/null
+++ b/unittest/core/printChar.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_CORE_PRINTCHAR_H_
+#define FSFW_UNITTEST_CORE_PRINTCHAR_H_
+
+
+extern "C" void printChar(const char*, bool errStream);
+
+
+#endif /* FSFW_UNITTEST_CORE_PRINTCHAR_H_ */
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
new file mode 100644
index 00000000..9b219f09
--- /dev/null
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -0,0 +1,26 @@
+#include <unittest/internal/InternalUnitTester.h>
+#include <unittest/internal/IntTestMq.h>
+#include <unittest/internal/IntTestSemaphore.h>
+#include <unittest/internal/IntTestSerialization.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <unittest/internal/IntTestMutex.h>
+
+#include <cstdlib>
+
+InternalUnitTester::InternalUnitTester() {}
+
+InternalUnitTester::~InternalUnitTester() {}
+
+ReturnValue_t InternalUnitTester::performTests() {
+	sif::info << "Running internal unit tests..\r\n" << std::flush;
+	testserialize::test_serialization();
+	testmq::testMq();
+	testsemaph::testBinSemaph();
+	testsemaph::testCountingSemaph();
+	testmutex::testMutex();
+	sif::info << "Internal unit tests finished.\r\n" << std::flush;
+	return RETURN_OK;
+}
+
+
+
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
new file mode 100644
index 00000000..b61c8bfe
--- /dev/null
+++ b/unittest/internal/InternalUnitTester.h
@@ -0,0 +1,29 @@
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief	Can be used for internal testing, for example for hardware specific
+ * 			tests which can not be run on a host-machine.
+ *
+ * TODO: A lot of ways to improve this class. A way for tests to subscribe
+ * 		 in this central class would be nice. Right now, this is the class
+ * 		 which simply calls all other tests from other files manually.
+ * 		 Maybe there is a better way..
+ */
+class InternalUnitTester: public HasReturnvaluesIF {
+public:
+	InternalUnitTester();
+	virtual~ InternalUnitTester();
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	ReturnValue_t performTests();
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
new file mode 100644
index 00000000..0bdbfcc7
--- /dev/null
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -0,0 +1,7 @@
+#include <fsfw/unittest/internal/UnittDefinitions.h>
+
+ ReturnValue_t unitt::put_error(std::string errorId) {
+	sif::error << "Unit Tester error: Failed at test ID "
+			<< errorId << "\n" << std::flush;
+	return HasReturnvaluesIF::RETURN_FAILED;
+}
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
new file mode 100644
index 00000000..ea36fea4
--- /dev/null
+++ b/unittest/internal/UnittDefinitions.h
@@ -0,0 +1,33 @@
+#ifndef UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+#define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <cstdint>
+#include <cstddef>
+
+namespace tv {
+// POD test values
+static const bool tv_bool = true;
+static const uint8_t tv_uint8   {5};
+static const uint16_t tv_uint16 {283};
+static const uint32_t tv_uint32 {929221};
+static const uint64_t tv_uint64 {2929329429};
+
+static const int8_t tv_int8 {-16};
+static const int16_t tv_int16 {-829};
+static const int32_t tv_int32 {-2312};
+
+static const float tv_float {8.2149214};
+static const float tv_sfloat = {-922.2321321};
+static const double tv_double {9.2132142141e8};
+static const double tv_sdouble {-2.2421e19};
+}
+
+namespace unitt {
+ReturnValue_t put_error(std::string errorId);
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_UNITTDEFINITIONS_H_ */
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
new file mode 100644
index 00000000..265aa62a
--- /dev/null
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -0,0 +1,52 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <unittest/internal/IntTestMq.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#include <array>
+
+using retval = HasReturnvaluesIF;
+
+void testmq::testMq() {
+	std::string id = "[testMq]";
+	MessageQueueIF* testSenderMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+	MessageQueueIF* testReceiverMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+	std::array<uint8_t, 20> testData { 0 };
+	testData[0] = 42;
+	MessageQueueMessage testMessage(testData.data(), 1);
+	testSenderMq->setDefaultDestination(testReceiverMqId);
+
+
+	auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueMessage recvMessage;
+	result = testReceiverMq->receiveMessage(&recvMessage);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+
+	result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+	if(result != retval::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	MessageQueueId_t senderId = 0;
+	result = testReceiverMq->receiveMessage(&recvMessage,&senderId);
+	if(result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+		unitt::put_error(id);
+	}
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+	senderId = testReceiverMq->getLastPartner();
+	if(senderId != testSenderMqId) {
+		unitt::put_error(id);
+	}
+
+}
diff --git a/unittest/internal/osal/IntTestMq.h b/unittest/internal/osal/IntTestMq.h
new file mode 100644
index 00000000..bc12a9b0
--- /dev/null
+++ b/unittest/internal/osal/IntTestMq.h
@@ -0,0 +1,9 @@
+#ifndef UNITTEST_INTERNAL_INTESTMQ_H_
+#define UNITTEST_INTERNAL_INTESTMQ_H_
+
+namespace testmq {
+void testMq();
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTESTMQ_H_ */
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
new file mode 100644
index 00000000..bf0b827d
--- /dev/null
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -0,0 +1,41 @@
+#include <unittest/internal/IntTestMutex.h>
+#include <fsfw/ipc/MutexFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#if defined(hosted)
+#include <fsfw/osal/hosted/Mutex.h>
+#include <thread>
+#include <future>
+#endif
+
+
+void testmutex::testMutex() {
+	std::string id = "[testMutex]";
+	MutexIF* mutex = MutexFactory::instance()->createMutex();
+	auto result = mutex->lockMutex(MutexIF::POLLING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	// timed_mutex from the C++ library specifies undefined behaviour if
+	// the timed mutex is locked twice from the same thread.
+#if defined(hosted)
+	// hold on, this actually worked ? :-D This calls the function from
+	// another thread and stores the returnvalue in a future.
+	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
+	result = future.get();
+#else
+	result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 1);
+#endif
+	if(result != MutexIF::MUTEX_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	result = mutex->unlockMutex();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+	result = mutex->unlockMutex();
+	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
+		unitt::put_error(id);
+	}
+}
diff --git a/unittest/internal/osal/IntTestMutex.h b/unittest/internal/osal/IntTestMutex.h
new file mode 100644
index 00000000..b467ea63
--- /dev/null
+++ b/unittest/internal/osal/IntTestMutex.h
@@ -0,0 +1,10 @@
+#ifndef UNITTEST_INTERNAL_INTTESTMUTEX_H_
+#define UNITTEST_INTERNAL_INTTESTMUTEX_H_
+
+namespace testmutex {
+void testMutex();
+}
+
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTMUTEX_H_ */
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
new file mode 100644
index 00000000..176db4de
--- /dev/null
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -0,0 +1,159 @@
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <unittest/internal/IntTestSemaphore.h>
+
+void testsemaph::testBinSemaph() {
+	std::string id = "[BinSemaphore]";
+	SemaphoreIF* binSemaph =
+			SemaphoreFactory::instance()->createBinarySemaphore();
+	if(binSemaph == nullptr) {
+		return;
+	}
+	testBinSemaphoreImplementation(binSemaph, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+#if defined(freeRTOS)
+	SemaphoreIF* binSemaphUsingTask =
+			SemaphoreFactory::instance()->createBinarySemaphore(1);
+	testBinSemaphoreImplementation(binSemaphUsingTask, id);
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaphUsingTask);
+#endif
+}
+
+
+void testsemaph::testCountingSemaph() {
+	std::string id = "[CountingSemaph]";
+	{
+		// First test: create a binary semaphore by using a counting semaphore.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1,1);
+		if(countingSemaph == nullptr) {
+			return;
+		}
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(1, 1, 1);
+		testBinSemaphoreImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+
+	{
+		// Second test: counting semaphore with count 3 and init count of 3.
+		SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3,3);
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined(freeRTOS)
+		countingSemaph = SemaphoreFactory::instance()->
+				createCountingSemaphore(3, 0, 1);
+		uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+		if(semaphCount != 0) {
+			unitt::put_error(id);
+		}
+		// release 3 times in a row
+		for(int i = 0; i < 3; i++) {
+			auto result = countingSemaph->release();
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				unitt::put_error(id);
+			}
+		}
+		testCountingSemaphImplementation(countingSemaph, id);
+		SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+	}
+}
+
+
+void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
+		std::string id) {
+	uint8_t semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 1) {
+		unitt::put_error(id);
+	}
+
+	ReturnValue_t result = binSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	result = binSemaph->acquire(SemaphoreIF::BLOCKING);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+
+	// There is not really a point in testing time related, the task
+	// might get interrupted..
+	{
+		//Stopwatch stopwatch(false);
+		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		//dur_millis_t time = stopwatch.stop();
+//		if(abs(time - 10) > 2) {
+//		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
+//		            << std::endl;
+//			unitt::put_error(id);
+//		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	semaphCount = binSemaph->getSemaphoreCounter();
+	if(semaphCount != 0) {
+		unitt::put_error(id);
+	}
+
+	result = binSemaph->release();
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		unitt::put_error(id);
+	}
+}
+
+void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id) {
+	// check count getter function
+	uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+	if(semaphCount != 3) {
+		unitt::put_error(id);
+	}
+	ReturnValue_t result = countingSemaph->release();
+	if(result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+		unitt::put_error(id);
+	}
+	// acquire 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->acquire(SemaphoreIF::BLOCKING);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+
+	{
+		Stopwatch stopwatch(false);
+		// attempt to take when count is 0, measure time
+		result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+		dur_millis_t time = stopwatch.stop();
+		if(abs(time - 10) > 1) {
+			unitt::put_error(id);
+		}
+	}
+
+	if(result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+		unitt::put_error(id);
+	}
+
+	// release 3 times in a row
+	for(int i = 0; i < 3; i++) {
+		result = countingSemaph->release();
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			unitt::put_error(id);
+		}
+	}
+	// assert correct full count
+	if(countingSemaph->getSemaphoreCounter() != 3) {
+		unitt::put_error(id);
+	}
+}
diff --git a/unittest/internal/osal/IntTestSemaphore.h b/unittest/internal/osal/IntTestSemaphore.h
new file mode 100644
index 00000000..af26c131
--- /dev/null
+++ b/unittest/internal/osal/IntTestSemaphore.h
@@ -0,0 +1,15 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+#define UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+class SemaphoreIF;
+#include <string>
+
+namespace testsemaph {
+void testBinSemaph();
+void testBinSemaphoreImplementation(SemaphoreIF* binSemaph, std::string id);
+void testCountingSemaph();
+void testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
+		std::string id);
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_ */
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
new file mode 100644
index 00000000..2452ac6d
--- /dev/null
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -0,0 +1,230 @@
+#include <unittest/internal/IntTestSerialization.h>
+#include <fsfw/serialize/SerializeElement.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serialize/SerializeIF.h>
+#include <array>
+
+using retval = HasReturnvaluesIF;
+std::array<uint8_t, 512> testserialize::test_array = { 0 };
+
+ReturnValue_t testserialize::test_serialization() {
+	// Here, we test all serialization tools. First test basic cases.
+	ReturnValue_t result = test_endianness_tools();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	result = test_autoserialization();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	result = test_serial_buffer_adapter();
+	if(result != retval::RETURN_OK) {
+		return result;
+	}
+	return retval::RETURN_OK;
+}
+
+ReturnValue_t testserialize::test_endianness_tools() {
+	std::string id = "[test_endianness_tools]";
+	test_array[0] = 0;
+	test_array[1] = 0;
+	uint16_t two_byte_value = 1;
+	size_t size = 0;
+	uint8_t* p_array = test_array.data();
+	SerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2,
+	        SerializeIF::Endianness::MACHINE);
+	// Little endian: Value one on first byte
+	if(test_array[0] != 1 and test_array[1] != 0) {
+		return unitt::put_error(id);
+
+	}
+
+	p_array = test_array.data();
+	size = 0;
+	SerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2,
+	        SerializeIF::Endianness::BIG);
+	// Big endian: Value one on second byte
+	if(test_array[0] != 0 and test_array[1] != 1) {
+		return unitt::put_error(id);
+	}
+	return retval::RETURN_OK;
+}
+
+ReturnValue_t testserialize::test_autoserialization() {
+	std::string id = "[test_autoserialization]";
+	// Unit Test getSerializedSize
+	if(SerializeAdapter::
+			getSerializedSize(&tv::tv_bool) != sizeof(tv::tv_bool) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint8) != sizeof(tv::tv_uint8) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint16) != sizeof(tv::tv_uint16) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint32) != sizeof(tv::tv_uint32) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_uint64) != sizeof(tv::tv_uint64) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int8) != sizeof(tv::tv_int8) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_double) != sizeof(tv::tv_double) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int16) != sizeof(tv::tv_int16) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_int32) != sizeof(tv::tv_int32) or
+			SerializeAdapter::
+			getSerializedSize(&tv::tv_float) != sizeof(tv::tv_float))
+	{
+		return unitt::put_error(id);
+	}
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint8, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint16, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint32, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int8, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int16, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_int32, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_uint64, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_float, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_double, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_sfloat, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv::tv_sdouble, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
+	if(serialized_size != 47) {
+		return unitt::put_error(id);
+	}
+
+	p_array = test_array.data();
+	size_t remaining_size = serialized_size;
+	bool tv_bool;
+	uint8_t tv_uint8;
+	uint16_t tv_uint16;
+	uint32_t tv_uint32;
+	int8_t tv_int8;
+	int16_t tv_int16;
+	int32_t tv_int32;
+	uint64_t tv_uint64;
+	float tv_float;
+	double tv_double;
+	float tv_sfloat;
+	double tv_sdouble;
+
+	SerializeAdapter::deSerialize(&tv_bool,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_int32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_uint64,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_float,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_double,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_sfloat,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::deSerialize(&tv_sdouble,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+
+	if(tv_bool != tv::tv_bool or tv_uint8 != tv::tv_uint8 or
+			tv_uint16 != tv::tv_uint16 or tv_uint32 != tv::tv_uint32 or
+			tv_uint64 != tv::tv_uint64 or tv_int8 != tv::tv_int8 or
+			tv_int16 != tv::tv_int16 or tv_int32 != tv::tv_int32)
+	{
+		return unitt::put_error(id);
+	}
+
+	// These epsilon values were just guessed.. It appears to work though.
+	if(abs(tv_float - tv::tv_float) > 0.0001 or
+			abs(tv_double - tv::tv_double) > 0.01 or
+			abs(tv_sfloat - tv::tv_sfloat) > 0.0001 or
+			abs(tv_sdouble - tv::tv_sdouble) > 0.01) {
+		return unitt::put_error(id);
+	}
+
+	// Check overflow
+	return retval::RETURN_OK;
+}
+
+// TODO: Also test for constant buffers.
+ReturnValue_t testserialize::test_serial_buffer_adapter() {
+	std::string id = "[test_serial_buffer_adapter]";
+
+	// I will skip endian swapper testing, its going to be changed anyway..
+	// uint8_t tv::tv_uint8_swapped = EndianSwapper::swap(tv::tv_uint8);
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	uint16_t testUint16 = 16;
+
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,&serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&testUint16, &p_array, &serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return unitt::put_error(id);
+	}
+	memcpy(&testUint16, test_array.data() + 6, sizeof(testUint16));
+	if(testUint16 != 16) {
+		return unitt::put_error(id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), true);
+	serialized_size = 0;
+	p_array = test_array.data();
+	SerializeAdapter::serialize(&tv::tv_bool, &p_array,&serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
+			&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+	SerializeAdapter::serialize(&testUint16, &p_array, &serialized_size,
+			test_array.size(), SerializeIF::Endianness::MACHINE);
+
+	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
+			or test_array[5] != 2 or test_array[6] != 1)
+	{
+		return unitt::put_error(id);
+	}
+	memcpy(&testUint16, test_array.data() + 7, sizeof(testUint16));
+	if(testUint16 != 16) {
+		return unitt::put_error(id);
+	}
+	return retval::RETURN_OK;
+}
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
new file mode 100644
index 00000000..f8841b82
--- /dev/null
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -0,0 +1,15 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#define UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <array>
+
+namespace testserialize {
+ReturnValue_t test_serialization();
+ReturnValue_t test_endianness_tools();
+ReturnValue_t test_autoserialization();
+ReturnValue_t test_serial_buffer_adapter();
+
+extern std::array<uint8_t, 512> test_array;
+}
+
+#endif /* UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
diff --git a/unittest/lcov.sh b/unittest/lcov.sh
new file mode 100644
index 00000000..4db16e5f
--- /dev/null
+++ b/unittest/lcov.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+lcov --capture --directory . --output-file coverage.info
+genhtml coverage.info --output-directory _coverage
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
new file mode 100644
index 00000000..33c6b425
--- /dev/null
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -0,0 +1,105 @@
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <fsfw/unittest/tests/action/TestActionHelper.h>
+
+TEST_CASE( "Action Helper" , "[ActionHelper]") {
+	ActionHelperOwnerMockBase testDhMock;
+	MessageQueueMockBase testMqMock;
+	ActionHelper actionHelper = ActionHelper(
+			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+	CommandMessage actionMessage;
+	ActionId_t testActionId = 777;
+	std::array <uint8_t, 3> testParams {1, 2, 3};
+	store_address_t paramAddress;
+	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+	ipcStore->addData(&paramAddress, testParams.data(), 3);
+	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+	SECTION ("Simple tests") {
+		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+		 CHECK(not testDhMock.executeActionCalled);
+		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		 CHECK(testDhMock.executeActionCalled);
+		 // No message is sent if everything is alright.
+		 CHECK(not testMqMock.wasMessageSent());
+		 store_address_t invalidAddress;
+		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+		 actionHelper.handleActionMessage(&actionMessage);
+		 CHECK(testMqMock.wasMessageSent());
+		 const uint8_t* ptr = nullptr;
+		 size_t size = 0;
+		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		 REQUIRE(ptr == nullptr);
+		 REQUIRE(size == 0);
+		 testDhMock.getBuffer(&ptr, &size);
+		 REQUIRE(size == 3);
+		 for(uint8_t i = 0; i<3;i++){
+			 REQUIRE(ptr[i] == (i+1));
+		 }
+		 testDhMock.clearBuffer();
+	}
+
+	SECTION("Handle failures"){
+		actionMessage.setCommand(1234);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+		CHECK(not testMqMock.wasMessageSent());
+		uint16_t step = 5;
+		ReturnValue_t status = 0x1234;
+		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+		step += 1;
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+		REQUIRE(testMessage.getParameter2() == parameter2);
+		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+	}
+
+	SECTION("Handle finish"){
+		CHECK(not testMqMock.wasMessageSent());
+		ReturnValue_t status = 0x9876;
+		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+	}
+
+	SECTION("Handle failed"){
+		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+	}
+
+	SECTION("Missing IPC Data"){
+		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+	}
+
+
+	SECTION("Data Reply"){
+
+	}
+}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
new file mode 100644
index 00000000..fcc20f90
--- /dev/null
+++ b/unittest/tests/action/TestActionHelper.h
@@ -0,0 +1,131 @@
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class ActionHelperOwnerMockBase: public HasActionsIF {
+public:
+	bool getCommandQueueCalled = false;
+	bool executeActionCalled = false;
+	static const size_t MAX_SIZE = 3;
+	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+	size_t size = 0;
+
+	MessageQueueId_t getCommandQueue() const override {
+		return tconst::testQueueId;
+	}
+
+	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) override {
+		executeActionCalled = true;
+		if(size > MAX_SIZE){
+			return 0xAFFE;
+		}
+		this->size = size;
+		memcpy(buffer, data, size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clearBuffer(){
+		this->size = 0;
+		for(size_t i = 0; i<MAX_SIZE; i++){
+			buffer[i] = 0;
+		}
+	}
+
+	void getBuffer(const uint8_t** ptr, size_t* size){
+		if(size != nullptr){
+			*size = this->size;
+		}
+		if(ptr != nullptr){
+			*ptr = buffer;
+		}
+	}
+};
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessage* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
+		messageSent = true;
+		lastMessage = (*message);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
new file mode 100644
index 00000000..07d6bc1f
--- /dev/null
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -0,0 +1,327 @@
+#include <fsfw/container/SimpleRingBuffer.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+#include <cstring>
+
+TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	SimpleRingBuffer ringBuffer(10, false, 5);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+}
+
+TEST_CASE("Ring Buffer Test2" , "[RingBufferTest2]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	uint8_t* newBuffer = new uint8_t[10];
+	SimpleRingBuffer ringBuffer(newBuffer, 10, true, 5);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+
+	SECTION("Overflow"){
+		REQUIRE(ringBuffer.availableWriteSpace()==9);
+		//Writing more than the buffer is large, technically thats allowed
+		//But it is senseless and has undesired impact on read call
+		REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		ringBuffer.clear();
+		uint8_t * ptr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+		REQUIRE(ptr != nullptr);
+		memcpy(ptr, testData, 13);
+		ringBuffer.confirmBytesWritten(13);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		REQUIRE(ringBuffer.readData(readBuffer, 3, true)== retval::CATCH_OK);
+		for(auto i =0;i<3;i++){
+			REQUIRE(readBuffer[i] == testData[i+10]);
+		}
+	}
+}
+
+TEST_CASE("Ring Buffer Test3" , "[RingBufferTest3]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	uint8_t* newBuffer = new uint8_t[10];
+	SimpleRingBuffer ringBuffer(newBuffer, 10, true, 15);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 8);
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		// too many excess bytes.
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_FAILED);
+		// Less Execss bytes overwrites before
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 1);
+		std::memcpy(testPtr, testData, 3);
+		ringBuffer.confirmBytesWritten(3);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		ringBuffer.readData(readBuffer, 3, true);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+
+	SECTION("Overflow"){
+		REQUIRE(ringBuffer.availableWriteSpace()==9);
+		//Writing more than the buffer is large, technically thats allowed
+		//But it is senseless and has undesired impact on read call
+		REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		ringBuffer.clear();
+		uint8_t * ptr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+		REQUIRE(ptr != nullptr);
+		memcpy(ptr, testData, 13);
+		ringBuffer.confirmBytesWritten(13);
+		REQUIRE(ringBuffer.getAvailableReadData()==3);
+		REQUIRE(ringBuffer.readData(readBuffer, 3, true)== retval::CATCH_OK);
+		for(auto i =0;i<3;i++){
+			REQUIRE(readBuffer[i] == testData[i+10]);
+		}
+	}
+}
+
+TEST_CASE("Ring Buffer Test4" , "[RingBufferTest4]") {
+	uint8_t testData[13]= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+	SimpleRingBuffer ringBuffer(10, false, 15);
+
+	SECTION("Simple Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.availableWriteSpace() == 5);
+		ringBuffer.clear();
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 4; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+		for(uint8_t i = 0; i< 9; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+
+	}
+
+	SECTION("Get Free Element Test") {
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 1);
+		REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.availableWriteSpace() == 9);
+		uint8_t *testPtr = nullptr;
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) ==  retval::CATCH_FAILED);
+
+
+		REQUIRE(ringBuffer.writeTillWrap() == 2);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) ==  retval::CATCH_OK);
+		REQUIRE(ringBuffer.getExcessBytes() == 3);
+		std::memcpy(testPtr, testData, 5);
+		ringBuffer.confirmBytesWritten(5);
+		REQUIRE(ringBuffer.getAvailableReadData() == 5);
+		ringBuffer.readData(readBuffer, 5, true);
+		for(uint8_t i = 0; i< 5; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+	}
+
+	SECTION("Read Remaining Test") {
+		REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+		REQUIRE(ringBuffer.getAvailableReadData() == 3);
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) ==  retval::CATCH_FAILED);
+		size_t trueSize = 0;
+		REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) ==  retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+		for(uint8_t i = 0; i< 3; i++) {
+			CHECK(readBuffer[i] == i);
+		}
+		trueSize = 0;
+		REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+		REQUIRE(trueSize == 0);
+		REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+		REQUIRE(trueSize == 3);
+	}
+}
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
new file mode 100644
index 00000000..b0ec0abb
--- /dev/null
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -0,0 +1,90 @@
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+/**
+ * @brief 	Array List test
+ */
+TEST_CASE("Array List" , "[ArrayListTest]") {
+	//perform set-up here
+	ArrayList<uint16_t> list(20);
+	struct TestClass{
+	public:
+		TestClass(){};
+		TestClass(uint32_t number1,	uint64_t number2):
+			number1(number1), number2(number2){};
+		uint32_t number1 = -1;
+		uint64_t number2 = -1;
+		bool operator==(const TestClass& other){
+			return ((this->number1 == other.number1) and (this->number2 == other.number2));
+		};
+	};
+	ArrayList<TestClass> complexList(20);
+	SECTION("SimpleTest") {
+		REQUIRE(list.maxSize()==20);
+		REQUIRE(list.size == 0);
+		REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(list[0] == 10);
+		REQUIRE(list.front() != nullptr);
+		REQUIRE((*list.front()) == 10);
+		REQUIRE(list.back() != nullptr);
+		REQUIRE((*list.back()) == 10);
+		// Need to test the const version of back as well
+		const uint16_t* number = const_cast<const ArrayList<uint16_t>*>(&list)->back();
+		REQUIRE(*number == 10);
+		list.clear();
+		REQUIRE(list.size == 0);
+	}
+	SECTION("Fill and check"){
+		//This is an invalid element but its not a nullptr
+		REQUIRE(list.back() != nullptr);
+		for (auto i =0; i < 20; i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		REQUIRE(list.insert(20) == static_cast<int>(ArrayList<uint16_t>::FULL));
+		ArrayList<uint16_t>::Iterator it = list.begin();
+		REQUIRE((*it) == 0);
+		it++;
+		REQUIRE((*it) == 1);
+		it--;
+		REQUIRE((*it) == 0);
+		it++;
+		for(auto it2 = list.begin(); it2!=list.end(); it2++){
+			if (it == it2){
+				REQUIRE((*it) == (*it2));
+				break;
+			}else{
+				REQUIRE((*it2) == 0);
+				REQUIRE(it2 != it);
+			}
+		}
+	}
+	SECTION("Const Iterator"){
+		ArrayList<uint16_t>::Iterator it = list.begin();
+		for (auto i =0; i < 10; i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		it++;
+		const uint16_t* number = it.value;
+		REQUIRE(*number == 1);
+	}
+
+	SECTION("Const Iterator"){
+		ArrayList<TestClass>::Iterator it = complexList.begin();
+		for (auto i =0; i < 10; i++){
+			REQUIRE(complexList.insert(TestClass(i, i+1)) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		it++;
+		const TestClass* secondTest = it.value;
+		bool compare = TestClass(1, 2) == *secondTest;
+		REQUIRE(compare);
+		it++;
+		REQUIRE(it->number1 == 2);
+		REQUIRE(it->number2 == 3);
+		const ArrayList<TestClass>::Iterator it4(&(complexList[2]));
+		REQUIRE(it4->number1 == 2);
+		REQUIRE((*it4).number2 == 3);
+		REQUIRE(complexList.remaining()==10);
+	}
+}
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
new file mode 100644
index 00000000..6c9b7415
--- /dev/null
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -0,0 +1,149 @@
+
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch.hpp>
+#include <CatchDefinitions.h>
+
+TEST_CASE( "Dynamic Fifo Tests", "[TestDynamicFifo]") {
+	INFO("Dynamic Fifo Tests");
+	struct Test{
+		uint64_t number1;
+		uint32_t number2;
+		uint8_t number3;
+		bool operator==(struct Test& other){
+			if ((other.number1 == this->number1) and
+					(other.number1 == this->number1) and
+					(other.number1 == this->number1)){
+				return true;
+			}
+			return false;
+		}
+	};
+	DynamicFIFO<Test> fifo(3);
+	std::vector<Test> list;
+
+	struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+	struct Test structTwo({0, 1, 2});
+	struct Test structThree({42, 43, 44});
+	list.push_back(structThree);
+	list.push_back(structTwo);
+	list.push_back(structOne);
+	SECTION("Insert, retrieval test"){
+		REQUIRE(fifo.getMaxCapacity()==3);
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		REQUIRE(not fifo.full());
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(FIFOBase<Test>::FULL));
+
+		struct Test testptr;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		bool equal = testptr == structOne;
+		REQUIRE(equal);
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		for(size_t i=2;i<3;i--){
+			testptr.number1 = 0;
+			testptr.number2 = 0;
+			testptr.number3 = 0;
+			REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo.size()==i);
+		}
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(not fifo.full());
+		REQUIRE(fifo.empty());
+		REQUIRE(fifo.pop()==static_cast<int>(FIFOBase<Test>::EMPTY));
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==2);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		equal = testptr == structTwo;
+		REQUIRE(equal);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		//struct Test* ptr = nullptr;
+		//REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+		//REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	};
+	SECTION("Copy Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(fifo);
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+
+	};
+
+	SECTION("Assignment Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(6);
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+
+	};
+
+	SECTION("Assignment Test Smaller"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		DynamicFIFO<Test> fifo2(2);
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+	};
+
+};
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
new file mode 100644
index 00000000..ac0900c8
--- /dev/null
+++ b/unittest/tests/container/TestFifo.cpp
@@ -0,0 +1,138 @@
+
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
+	INFO("Fifo Tests");
+	struct Test{
+		uint64_t number1;
+		uint32_t number2;
+		uint8_t number3;
+		bool operator==(struct Test& other){
+			if ((other.number1 == this->number1) and
+					(other.number1 == this->number1) and
+					(other.number1 == this->number1)){
+				return true;
+			}
+			return false;
+		}
+	};
+	FIFO<Test, 3> fifo;
+	std::vector<Test> list;
+
+	struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+	struct Test structTwo({0, 1, 2});
+	struct Test structThree({42, 43, 44});
+	list.push_back(structThree);
+	list.push_back(structTwo);
+	list.push_back(structOne);
+	SECTION("Insert, retrieval test"){
+		REQUIRE(fifo.getMaxCapacity()==3);
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+		REQUIRE(not fifo.full());
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(FIFOBase<Test>::FULL));
+
+		struct Test testptr;
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		bool equal = testptr == structOne;
+		REQUIRE(equal);
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		for(size_t i=2;i<3;i--){
+			testptr.number1 = 0;
+			testptr.number2 = 0;
+			testptr.number3 = 0;
+			REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo.size()==i);
+		}
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+		REQUIRE(fifo.retrieve(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(FIFOBase<Test>::EMPTY));
+		REQUIRE(not fifo.full());
+		REQUIRE(fifo.empty());
+		REQUIRE(fifo.pop()==static_cast<int>(FIFOBase<Test>::EMPTY));
+
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==2);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==1);
+		testptr.number1 = 0;
+		testptr.number2 = 0;
+		testptr.number3 = 0;
+
+		// Test that retrieve and peek will not cause a nullptr dereference
+		struct Test* ptr = nullptr;
+		REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+		REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+
+
+		REQUIRE(fifo.peek(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		equal = testptr == structTwo;
+		REQUIRE(equal);
+		REQUIRE(fifo.pop()==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==0);
+		REQUIRE(fifo.empty());
+
+
+	};
+	SECTION("Copy Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		FIFO<Test, 3> fifo2(fifo);
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+
+	};
+
+	SECTION("Assignment Test"){
+		REQUIRE(fifo.insert(structOne)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structTwo)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.insert(structThree)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(fifo.size()==3);
+		REQUIRE(fifo.full());
+		REQUIRE(not fifo.empty());
+
+		FIFO<Test, 3> fifo2;
+		fifo2 = fifo;
+		REQUIRE(fifo2.size()==3);
+		REQUIRE(fifo2.full());
+		REQUIRE(not fifo2.empty());
+		for(size_t i=2;i<3;i--){
+			struct Test testptr = {0, 0, 0};
+			REQUIRE(fifo2.retrieve(&testptr)==static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool equal = testptr == list[i];
+			REQUIRE(equal);
+			REQUIRE(fifo2.size()==i);
+		}
+	};
+};
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
new file mode 100644
index 00000000..5d1d5817
--- /dev/null
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -0,0 +1,41 @@
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
+	INFO("FixedArrayList Tests");
+	using testList = FixedArrayList<uint32_t, 260, uint16_t>;
+	testList list;
+	REQUIRE(list.size==0);
+	REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(list.size==1);
+	REQUIRE(list.maxSize()==260);
+	SECTION("Copy Constructor"){
+		testList list2(list);
+		REQUIRE(list2.size==1);
+		REQUIRE(list2[0] == 10);
+		REQUIRE(list.maxSize()==260);
+	};
+	SECTION("Assignment copy"){
+		testList list2;
+		REQUIRE(list2.size==0);
+		list2 = list;
+		REQUIRE(list2.size==1);
+		REQUIRE(list2[0] == 10);
+		REQUIRE(list.maxSize()==260);
+	};
+	SECTION("Fill"){
+		for(auto i=1;i<260;i++){
+			REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+		REQUIRE(list.insert(260) == static_cast<int>(ArrayList<uint32_t, uint16_t>::FULL));
+		list.clear();
+		REQUIRE(list.size == 0);
+	}
+}
+
+
+
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
new file mode 100644
index 00000000..04656525
--- /dev/null
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -0,0 +1,172 @@
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+template class FixedMap<unsigned int, unsigned short>;
+
+TEST_CASE( "FixedMap Tests", "[TestFixedMap]") {
+	INFO("FixedMap Tests");
+
+	FixedMap<unsigned int, unsigned short> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+	REQUIRE(map.getSerializedSize() == sizeof(uint32_t));
+	REQUIRE(map.empty());
+	REQUIRE(not map.full());
+
+	SECTION("Fill and erase"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, i+1))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.find(i)->second==i+1);
+			REQUIRE(not map.empty());
+		}
+		REQUIRE(map.insert(0, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+		REQUIRE(map.insert(31, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		REQUIRE(map.full());
+		{
+			uint16_t* ptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(*ptr == 6);
+			REQUIRE(*(map.findValue(6)) == 7);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+
+		REQUIRE(map.getSerializedSize() == (sizeof(uint32_t)+ 30*(sizeof(uint32_t) + sizeof(uint16_t))));
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				REQUIRE(element.second == 6);
+			}
+		}
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(it->second == it->first + 1);
+			REQUIRE((*it).second == (*it).first + 1);
+			it->second = it->second + 1;
+			REQUIRE(it->second == it->first + 2);
+		}
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		}
+
+		REQUIRE(map.size() == 0);
+
+		for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Insert variants"){
+		FixedMap<uint32_t, uint16_t>::Iterator it = map.end();
+		REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		REQUIRE(it->second == 37);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+		REQUIRE(map.find(37)->second != 24);
+		REQUIRE(map.size() == 2);
+	};
+	SECTION("Serialize and DeSerialize") {
+		REQUIRE(map.insert(36, 37, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		uint8_t buffer[sizeof(uint32_t)
+				+ 2 * (sizeof(uint32_t) + sizeof(uint16_t))];
+		REQUIRE(
+				map.getSerializedSize()
+						== (sizeof(uint32_t)
+								+ 2 * (sizeof(uint32_t) + sizeof(uint16_t))));
+		uint8_t *loc_ptr = buffer;
+		size_t size = 0;
+		REQUIRE(
+				map.serialize(&loc_ptr, &size, 10, SerializeIF::Endianness::BIG)
+						== static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+		loc_ptr = buffer;
+		size = 0;
+		REQUIRE(
+				map.serialize(&loc_ptr, &size,
+						sizeof(uint32_t)
+								+ 2 * (sizeof(uint32_t) + sizeof(uint16_t)),
+						SerializeIF::Endianness::BIG)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(size == 16);
+
+		uint32_t internal_size = 0;
+		const uint8_t *ptr2 = buffer;
+		REQUIRE(
+				SerializeAdapter::deSerialize(&internal_size, &ptr2, &size,
+						SerializeIF::Endianness::BIG)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(internal_size == 2);
+		for (uint8_t i = 36; i < 38; i++) {
+			uint32_t first_element = 0;
+			REQUIRE(
+					SerializeAdapter::deSerialize(&first_element, &ptr2, &size,
+							SerializeIF::Endianness::BIG)
+							== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(first_element == i);
+			uint16_t second_element = 0;
+			REQUIRE(
+					SerializeAdapter::deSerialize(&second_element, &ptr2, &size,
+							SerializeIF::Endianness::BIG)
+							== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(second_element == i + 1);
+		}
+		REQUIRE(size == 0);
+		map.clear();
+		const uint8_t* constPtr = buffer;
+		size = 16;
+		REQUIRE(map.size() == 0);
+		REQUIRE(map.deSerialize(&constPtr, &size,
+				SerializeIF::Endianness::BIG) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.find(36)->second == 37);
+		for(auto& element: map){
+			REQUIRE((element.first+1) == element.second);
+		}
+	};
+
+
+	SECTION("Failed erase and deSerialize"){
+		FixedMap<uint32_t, uint16_t>::Iterator it;
+		std::pair<uint32_t, uint16_t> pair = std::make_pair(44, 43);
+		it = FixedMap<uint32_t, uint16_t>::Iterator(&pair);
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(45) == map.end());
+		size_t toLargeMap = 100;
+		const uint8_t* ptr = reinterpret_cast<uint8_t*>(&toLargeMap);
+		size_t size = sizeof(size_t);
+		REQUIRE(map.deSerialize(&ptr, &size, SerializeIF::Endianness::BIG) ==
+				static_cast<int>(SerializeIF::TOO_MANY_ELEMENTS));
+	};
+	SECTION("Little Endianess"){
+		map.clear();
+		map.insert(10,20, nullptr);
+		uint8_t newBuffer[sizeof(uint32_t)+ 1*(sizeof(uint32_t) + sizeof(uint16_t))];
+		uint8_t* ptr = newBuffer;
+		size_t size =  0;
+		size_t max_size = sizeof(uint32_t)+ 1*(sizeof(uint32_t) + sizeof(uint16_t));
+		REQUIRE(map.serialize(&ptr, &size, max_size,
+				SerializeIF::Endianness::LITTLE) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		map.clear();
+		REQUIRE(map.size()==0);
+		const uint8_t* ptr2 = newBuffer;
+		REQUIRE(map.deSerialize(&ptr2, &size,
+				SerializeIF::Endianness::LITTLE) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.size()==1);
+		REQUIRE(map.find(10)->second == 20);
+	};
+}
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
new file mode 100644
index 00000000..953cb5a8
--- /dev/null
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -0,0 +1,203 @@
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
+	INFO("FixedOrderedMultimap Tests");
+
+	FixedOrderedMultimap<unsigned int, unsigned short> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+
+	SECTION("Test insert, find, exists"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, i+1))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.find(i)->second==i+1);
+		}
+		REQUIRE(map.insert(0, 0) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		{
+			uint16_t* ptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(*ptr == 6);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				REQUIRE(element.second == 6);
+			}
+		}
+
+		for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			REQUIRE(it->second == it->first + 1);
+			REQUIRE((*it).second == (*it).first + 1);
+			it->second = it->second + 1;
+			REQUIRE(it->second == it->first + 2);
+		}
+
+		{
+			FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin();
+			while(it != map.end()){
+				REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			}
+			REQUIRE(map.size() == 0);
+		}
+
+		for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Test different insert variants")
+	{
+		FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.end();
+		REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		REQUIRE(it->second == 37);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(37)->second == 38);
+		REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.find(0)->second == 1);
+		REQUIRE(map.size() == 4);
+		map.clear();
+		REQUIRE(map.size() == 0);
+	}
+	SECTION("Test different erase and find with no entries"){
+		FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it;
+		it = map.end();
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(1)== map.end());
+	}
+}
+
+TEST_CASE( "FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNonTrivial]") {
+	INFO("FixedOrderedMultimap Non Trivial Type");
+
+	class TestClass{
+	public:
+		TestClass(){};
+		TestClass(uint32_t number1,	uint64_t number2):
+		number1(number1),number2(number2){};
+		~TestClass(){};
+
+		bool operator==(const TestClass& lhs){
+			return ((this->number1 == lhs.number1) and (this->number2 == lhs.number2));
+		}
+		bool operator!=(const TestClass& lhs){
+			return not(this->operator ==(lhs));
+		}
+
+		TestClass(const TestClass& other){
+			this->number1 = other.number1;
+			this->number2 = other.number2;
+		};
+		TestClass& operator=(const TestClass& other){
+			this->number1 = other.number1;
+			this->number2 = other.number2;
+			return *this;
+		};
+
+	private:
+		uint32_t number1 = 0;
+		uint64_t number2 = 5;
+	};
+	FixedOrderedMultimap<unsigned int, TestClass> map(30);
+	REQUIRE(map.size() == 0);
+	REQUIRE(map.maxSize() == 30);
+
+	SECTION("Test insert, find, exists"){
+		for (uint16_t i=0;i<30;i++){
+			REQUIRE(map.insert(std::make_pair(i, TestClass(i+1,i)))== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool compare = map.find(i)->second == TestClass(i+1,i);
+			REQUIRE(compare);
+		}
+		REQUIRE(map.insert(0, TestClass()) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+		REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 30);
+		{
+			TestClass* ptr = nullptr;
+			REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			bool compare = *ptr == TestClass(6, 5);
+			REQUIRE(compare);
+			REQUIRE(map.find(31,&ptr) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		}
+		REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(map.erase(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.size() == 29);
+
+		for (auto element: map){
+			if (element.first == 5){
+				bool compare = element.second == TestClass(6, 5);
+				REQUIRE(compare);
+			}
+		}
+
+		for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
+			bool compare = it->second == TestClass(it->first + 1, it->first);
+			REQUIRE(compare);
+			compare = (*it).second == TestClass((*it).first + 1, (*it).first);
+			REQUIRE(compare);
+			it->second = TestClass(it->first + 2, it->first);
+			compare = it->second == TestClass(it->first + 2, it->first);
+			REQUIRE(compare);
+		}
+
+		{
+			FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin();
+			while(it != map.end()){
+				REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+			}
+			REQUIRE(map.size() == 0);
+		}
+
+		for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
+			// This line should never executed if begin and end is correct
+			FAIL("Should never be reached, Iterators invalid");
+		}
+	};
+
+	SECTION("Test different insert variants")
+	{
+		FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.end();
+		REQUIRE(map.insert(36, TestClass(37, 36), &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(it->first == 36);
+		bool compare = it->second == TestClass(37, 36);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 1);
+		REQUIRE(map.insert(37, TestClass(38, 37), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(37)->second == TestClass(38, 37);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 2);
+		REQUIRE(map.insert(37, TestClass(24, 37), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(37)->second == TestClass(38, 37);
+		REQUIRE(compare);
+		REQUIRE(map.insert(0, TestClass(1, 0), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		compare = map.find(0)->second == TestClass(1, 0);
+		REQUIRE(compare);
+		REQUIRE(map.size() == 4);
+		map.clear();
+		REQUIRE(map.size() == 0);
+	}
+	SECTION("Test different erase and find with no entries"){
+		FixedOrderedMultimap<uint32_t, TestClass>::Iterator it;
+		it = map.end();
+		REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, TestClass>::KEY_DOES_NOT_EXIST));
+		REQUIRE(map.find(1)== map.end());
+	}
+}
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
new file mode 100644
index 00000000..aa8e7375
--- /dev/null
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -0,0 +1,45 @@
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
new file mode 100644
index 00000000..8e59fa08
--- /dev/null
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -0,0 +1,40 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include "catch.hpp"
+#include <array>
+#include "core/CatchDefinitions.h"
+
+TEST_CASE("MessageQueue Basic Test","[TestMq]") {
+	MessageQueueIF* testSenderMq =
+			QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+	MessageQueueIF* testReceiverMq =
+				QueueFactory::instance()->createMessageQueue(1);
+	MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+	std::array<uint8_t, 20> testData { 0 };
+	testData[0] = 42;
+	MessageQueueMessage testMessage(testData.data(), 1);
+	testSenderMq->setDefaultDestination(testReceiverMqId);
+
+	SECTION("Simple Tests") {
+		auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		MessageQueueMessage recvMessage;
+		result = testReceiverMq->receiveMessage(&recvMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(recvMessage.getData()[0] == 42);
+
+		result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+		REQUIRE(result == retval::CATCH_OK);
+		MessageQueueId_t senderId = 0;
+		result = testReceiverMq->receiveMessage(&recvMessage,&senderId);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(recvMessage.getData()[0] == 42);
+		CHECK(senderId == testSenderMqId);
+		senderId = testReceiverMq->getLastPartner();
+		CHECK(senderId == testSenderMqId);
+	}
+
+
+}
diff --git a/unittest/tests/osal/TestSemaphore.cpp b/unittest/tests/osal/TestSemaphore.cpp
new file mode 100644
index 00000000..f7b25534
--- /dev/null
+++ b/unittest/tests/osal/TestSemaphore.cpp
@@ -0,0 +1,46 @@
+
+#ifdef LINUX
+
+/*
+#include "core/CatchDefinitions.h"
+#include "catch.hpp"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
+	//perform set-up here
+	SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
+			createBinarySemaphore();
+	REQUIRE(binSemaph != nullptr);
+	SECTION("Simple Test") {
+		// set-up is run for each section
+		REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+		REQUIRE(binSemaph->release() ==
+				static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+		REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
+				retval::CATCH_OK);
+		{
+			// not precise enough on linux.. should use clock instead..
+			//Stopwatch stopwatch(false);
+			//REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+			//		SemaphoreIF::SEMAPHORE_TIMEOUT);
+			//dur_millis_t time = stopwatch.stop();
+			//CHECK(time == 5);
+		}
+		REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+		REQUIRE(binSemaph->release() == retval::CATCH_OK);
+	}
+	SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+	// perform tear-down here
+}
+
+
+TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
+	SECTION("Simple Test") {
+
+	}
+}
+*/
+
+#endif
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
new file mode 100644
index 00000000..39c1ba61
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -0,0 +1,143 @@
+#include <fsfw/serialize/SerialBufferAdapter.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+static bool test_value_bool = true;
+static uint16_t tv_uint16 {283};
+static std::array<uint8_t, 512> testArray;
+
+TEST_CASE("Serial Buffer Adapter", "[single-file]") {
+	size_t serialized_size = 0;
+	test_value_bool = true;
+	uint8_t * arrayPtr = testArray.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	tv_uint16 = 16;
+
+	SECTION("Serialize without size field") {
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(serialized_size == 8);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 4);
+		REQUIRE(testArray[3] == 3);
+		REQUIRE(testArray[4] == 2);
+		REQUIRE(testArray[5] == 1);
+		memcpy(&tv_uint16, testArray.data() + 6, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Serialize with size field") {
+		SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+				SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+						test_serial_buffer.size(), true);
+		serialized_size = 0;
+		arrayPtr = testArray.data();
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,&serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(serialized_size == 9);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 5);
+		REQUIRE(testArray[3] == 4);
+		REQUIRE(testArray[4] == 3);
+		REQUIRE(testArray[5] == 2);
+		REQUIRE(testArray[6] == 1);
+		memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Test set buffer function") {
+		SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+					SerialBufferAdapter<uint8_t>((uint8_t*)nullptr,
+					0, true);
+		tv_serial_buffer_adapter_loc.setBuffer(test_serial_buffer.data(),
+				test_serial_buffer.size());
+		serialized_size = 0;
+		arrayPtr = testArray.data();
+		SerializeAdapter::serialize(&test_value_bool, &arrayPtr,&serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr,
+				&serialized_size, testArray.size(),
+				SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size,
+				testArray.size(), SerializeIF::Endianness::MACHINE);
+		REQUIRE(serialized_size == 9);
+		REQUIRE(testArray[0] == true);
+		REQUIRE(testArray[1] == 5);
+		REQUIRE(testArray[2] == 5);
+		REQUIRE(testArray[3] == 4);
+		REQUIRE(testArray[4] == 3);
+		REQUIRE(testArray[5] == 2);
+		REQUIRE(testArray[6] == 1);
+		memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+		REQUIRE(tv_uint16 == 16);
+	}
+
+	SECTION("Deserialization with size field") {
+		size_t buffer_size = 4;
+		memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+		testArray[2] = 1;
+		testArray[3] = 1;
+		testArray[4] = 1;
+		testArray[5] = 0;
+		std::array<uint8_t, 4> test_recv_array;
+		arrayPtr = testArray.data();
+		// copy testArray[1] to testArray[4] into receive buffer, skip
+		// size field (testArray[0]) for deSerialization.
+		SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+				SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, true);
+		// Deserialization
+		size_t size = 6;
+		auto result = tv_serial_buffer_adapter3.deSerialize(
+				const_cast<const uint8_t**>(&arrayPtr), &size,
+				SerializeIF::Endianness::MACHINE);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(test_recv_array[0] == 1);
+		CHECK(test_recv_array[1] == 1);
+		CHECK(test_recv_array[2] == 1);
+		CHECK(test_recv_array[3] == 0);
+	}
+
+	SECTION("Deserialization without size field") {
+		size_t buffer_size = 4;
+		memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+		testArray[2] = 1;
+		testArray[3] = 1;
+		testArray[4] = 1;
+		testArray[5] = 0;
+		std::array<uint8_t, 4> test_recv_array;
+		arrayPtr = testArray.data() + 2;
+		// copy testArray[1] to testArray[4] into receive buffer, skip
+		// size field (testArray[0])
+		SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+				SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, false);
+		// Deserialization
+		size_t size = 4;
+		tv_serial_buffer_adapter3.deSerialize(
+				const_cast<const uint8_t**>(&arrayPtr), &size,
+				SerializeIF::Endianness::MACHINE);
+		CHECK(test_recv_array[0] == 1);
+		CHECK(test_recv_array[1] == 1);
+		CHECK(test_recv_array[2] == 1);
+		CHECK(test_recv_array[3] == 0);
+	}
+}
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
new file mode 100644
index 00000000..932b62ab
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -0,0 +1,73 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
+
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <fsfw/unittest/tests/serialize/TestSerialLinkedPacket.h>
+
+
+TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
+	// perform set-up here
+	uint32_t header = 42;
+	std::array<uint8_t, 3> testArray {1,2,3};
+	uint32_t tail = 96;
+	size_t packetMaxSize = 256;
+	uint8_t packet [packetMaxSize] = {};
+	size_t packetLen = 0;
+
+	SECTION("Test Deserialization with Serial Buffer Adapter.") {
+		// This is a serialization of a packet, made "manually".
+		// We generate a packet which store data big-endian by swapping some
+		// values. (like coming from ground).
+		header = EndianConverter::convertBigEndian(header);
+		std::memcpy(packet, &header, sizeof(header));
+		packetLen += sizeof(header);
+
+		std::copy(testArray.data(), testArray.data() + testArray.size(),
+				packet + packetLen);
+		packetLen += testArray.size();
+
+		tail = EndianConverter::convertBigEndian(tail);
+		std::memcpy(packet + packetLen, &tail, sizeof(tail));
+		packetLen += sizeof(tail);
+
+		//arrayprinter::print(packet, packetLen, OutputType::DEC);
+
+		// This is the buffer which will be filled when testClass.deSerialize
+		// is called.
+		std::array<uint8_t, 3> bufferAdaptee = {};
+		TestPacket testClass(packet, packetLen, bufferAdaptee.data(),
+					bufferAdaptee.size());
+		const uint8_t* readOnlyPointer = packet;
+		// Deserialize big endian packet by setting bigEndian to true.
+		ReturnValue_t result = testClass.deSerialize(&readOnlyPointer,
+				&packetLen, SerializeIF::Endianness::BIG);
+		REQUIRE(result == retval::CATCH_OK);
+		CHECK(testClass.getHeader() == 42);
+		// Equivalent check.
+		// CHECK(testClass.getBuffer()[0] == 1);
+		CHECK(bufferAdaptee[0] == 1);
+		CHECK(bufferAdaptee[1] == 2);
+		CHECK(bufferAdaptee[2] == 3);
+		CHECK(testClass.getTail() == 96);
+	}
+
+	SECTION("Test Serialization") {
+		// Same process as performed in setup, this time using the class
+		// instead of doing it manually.
+		TestPacket testClass(header, tail, testArray.data(), testArray.size());
+		size_t serializedSize = 0;
+		uint8_t* packetPointer = packet;
+		// serialize for ground: bigEndian = true.
+		ReturnValue_t result = testClass.serialize(&packetPointer,
+				&serializedSize, packetMaxSize, SerializeIF::Endianness::BIG);
+		REQUIRE(result == retval::CATCH_OK);
+		// Result should be big endian now.
+		CHECK(packet[3] == 42);
+		CHECK(packet[4] == 1);
+		CHECK(packet[5] == 2);
+		CHECK(packet[6] == 3);
+		CHECK(packet[10] == 96);
+	}
+
+	// perform tear-down here
+}
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.h b/unittest/tests/serialize/TestSerialLinkedPacket.h
new file mode 100644
index 00000000..6c720577
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.h
@@ -0,0 +1,61 @@
+#ifndef UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+#define UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerialLinkedListAdapter.h>
+#include <cstdint>
+
+class TestPacket: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	/**
+	 * For Deserialization
+	 */
+	TestPacket(const uint8_t *somePacket, size_t size, uint8_t * storePointer,
+			size_t storeSize):
+			buffer(storePointer, storeSize)
+	{
+		setLinks();
+	}
+
+	/**
+	 * For Serialization
+	 */
+	TestPacket(uint32_t header, uint32_t tail,
+			const uint8_t* parameters, size_t paramSize):
+			header(header), buffer(parameters, paramSize),
+			tail(tail) {
+		setLinks();
+	}
+
+	uint32_t getHeader() const {
+		return header.entry;
+	}
+
+	const uint8_t * getBuffer() {
+		return buffer.entry.getConstBuffer();
+	}
+
+	const size_t getBufferLength() {
+		return buffer.getSerializedSize();
+	}
+
+
+	uint16_t getTail() const {
+		return tail.entry;
+	}
+private:
+	void setLinks() {
+		setStart(&header);
+		header.setNext(&buffer);
+		buffer.setNext(&tail);
+		tail.setEnd();
+	}
+
+	SerializeElement<uint32_t> header = 0;
+	SerializeElement<SerialBufferAdapter<uint8_t>> buffer;
+	SerializeElement<uint32_t> tail = 0;
+};
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTTEMPLATE_H_ */
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
new file mode 100644
index 00000000..7ac7b796
--- /dev/null
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -0,0 +1,129 @@
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#include "catch.hpp"
+#include <array>
+#include "core/CatchDefinitions.h"
+
+static bool test_value_bool = true;
+static uint8_t tv_uint8   {5};
+static uint16_t tv_uint16 {283};
+static uint32_t tv_uint32 {929221};
+static uint64_t tv_uint64 {2929329429};
+
+static int8_t tv_int8 {-16};
+static int16_t tv_int16 {-829};
+static int32_t tv_int32 {-2312};
+
+static float tv_float {8.2149214};
+static float tv_sfloat = {-922.2321321};
+static double tv_double {9.2132142141e8};
+static double tv_sdouble {-2.2421e19};
+
+static std::array<uint8_t, 512> test_array;
+
+TEST_CASE( "Serialization size tests", "[TestSerialization]") {
+	//REQUIRE(unitTestClass.test_autoserialization() == 0);
+	REQUIRE(SerializeAdapter::getSerializedSize(&test_value_bool) ==
+			sizeof(test_value_bool));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint8) ==
+			sizeof(tv_uint8));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint16) ==
+			sizeof(tv_uint16));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint32 ) ==
+			sizeof(tv_uint32));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_uint64) ==
+			sizeof(tv_uint64));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int8) ==
+			sizeof(tv_int8));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int16) ==
+			sizeof(tv_int16));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_int32) ==
+			sizeof(tv_int32));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_float) ==
+			sizeof(tv_float));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_sfloat) ==
+			sizeof(tv_sfloat ));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_double) ==
+			sizeof(tv_double));
+	REQUIRE(SerializeAdapter::getSerializedSize(&tv_sdouble) ==
+			sizeof(tv_sdouble));
+}
+
+
+TEST_CASE("Auto Serialize Adapter testing", "[single-file]") {
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	SECTION("Serializing...") {
+		SerializeAdapter::serialize(&test_value_bool, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint8, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint16, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint32, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int8, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int16, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_int32, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_uint64, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_float, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_double, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_sfloat, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::serialize(&tv_sdouble, &p_array,
+				&serialized_size, test_array.size(), SerializeIF::Endianness::MACHINE);
+		REQUIRE (serialized_size == 47);
+	}
+
+	SECTION("Deserializing") {
+		p_array = test_array.data();
+		size_t remaining_size = serialized_size;
+		SerializeAdapter::deSerialize(&test_value_bool,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint8,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint16,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint32,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int8,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int16,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_int32,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_uint64,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_float,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_double,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_sfloat,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+		SerializeAdapter::deSerialize(&tv_sdouble,
+				const_cast<const uint8_t**>(&p_array), &remaining_size, SerializeIF::Endianness::MACHINE);
+
+		REQUIRE(test_value_bool == true);
+		REQUIRE(tv_uint8 == 5);
+		REQUIRE(tv_uint16 == 283);
+		REQUIRE(tv_uint32 == 929221);
+		REQUIRE(tv_uint64 == 2929329429);
+		REQUIRE(tv_int8 == -16);
+		REQUIRE(tv_int16 == -829);
+		REQUIRE(tv_int32 == -2312);
+
+		REQUIRE(tv_float == Approx(8.214921));
+		REQUIRE(tv_double == Approx(9.2132142141e8));
+		REQUIRE(tv_sfloat == Approx(-922.2321321));
+		REQUIRE(tv_sdouble == Approx(-2.2421e19));
+	}
+}
+
+
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
new file mode 100644
index 00000000..7685afb3
--- /dev/null
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -0,0 +1,161 @@
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <array>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	uint16_t numberOfElements[1] = {1};
+	uint16_t sizeofElements[1] = {10};
+	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
new file mode 100644
index 00000000..5b22118e
--- /dev/null
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -0,0 +1,105 @@
+#include <config/objects/Factory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch.hpp>
+#include "core/CatchDefinitions.h"
+
+TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
+	uint16_t numberOfElements[1] = {1};
+	uint16_t sizeofElements[1] = {10};
+	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	uint8_t *pointer = nullptr;
+	const uint8_t * constPointer = nullptr;
+	uint8_t test = 0;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ( "Basic tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		memset(receptionArray.data(), 0, size);
+		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		memcpy(receptionArray.data(), pointer, size);
+		REQUIRE(result == retval::CATCH_OK);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		result = SimplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), 15);
+		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
+	}
+
+	SECTION ( "Reservation Tests ") {
+		pointer = nullptr;
+		result = SimplePool.getFreeElement(&testStoreId, size, &pointer);
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(pointer, testDataArray.data(), size);
+		constPointer = nullptr;
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+
+		REQUIRE (result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+	SECTION ( "Add, delete, add, add when full") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		result = SimplePool.deleteData(testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		REQUIRE( result == retval::CATCH_OK);
+		memcpy(receptionArray.data(), constPointer, size);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		store_address_t newAddress;
+		result = SimplePool.addData(&newAddress, testDataArray.data(), size);
+		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
+	}
+
+	SECTION ( "Initialize and clear store, delete with pointer") {
+		result = SimplePool.initialize();
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		SimplePool.clearStore();
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		REQUIRE(result == retval::CATCH_OK);
+		store_address_t newId;
+		result = SimplePool.deleteData(pointer, size, &testStoreId);
+		REQUIRE(result == retval::CATCH_OK);
+		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+	}
+}
diff --git a/unittest/tests/tests.mk b/unittest/tests/tests.mk
new file mode 100644
index 00000000..47e634a2
--- /dev/null
+++ b/unittest/tests/tests.mk
@@ -0,0 +1,8 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/container/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/action/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/storagemanager/*.cpp)
+
+# OSAL not included for now.
+
+INCLUDES += $(CURRENTPATH)
\ No newline at end of file
diff --git a/unittest/testtemplate/TestTemplate.cpp b/unittest/testtemplate/TestTemplate.cpp
new file mode 100644
index 00000000..6b5fc3d2
--- /dev/null
+++ b/unittest/testtemplate/TestTemplate.cpp
@@ -0,0 +1,31 @@
+#include <fsfw/unittest/catch2/catch.hpp>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+
+
+/**
+ * @brief 	Template test file
+ * @details
+ * In each test case, the code outside the sections is executed
+ * for EACH section.
+ * The most common macros to perform tests are:
+ *  - CHECK(...): assert expression and continues even if it fails
+ *  - REQUIRE(...): test case fails if assertion fails
+ *
+ *  Tests are generally sturctured in test cases and sections, see example
+ *  below.
+ *
+ *  More Documentation:
+ *  - https://github.com/catchorg/Catch2
+ *  - https://github.com/catchorg/Catch2/blob/master/docs/assertions.md
+ *  - https://github.com/catchorg/Catch2/blob/master/docs/test-cases-and-sections.md
+ */
+TEST_CASE("Dummy Test" , "[DummyTest]") {
+	uint8_t testVariable = 1;
+	//perform set-up here
+	CHECK(testVariable == 1);
+	SECTION("TestSection") {
+		// set-up is run for each section
+		REQUIRE(testVariable == 1);
+	}
+	// perform tear-down here
+}
diff --git a/unittest/unlockRealtime.sh b/unittest/unlockRealtime.sh
new file mode 100644
index 00000000..b28d5490
--- /dev/null
+++ b/unittest/unlockRealtime.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+# Run this script to unlock all permissions to run the linux binaries
+# and create threads
+
+binaries=$(find $directory -type f -name "*.elf")
+
+echo Unlocking real time permissions for binaries and bash console...
+
+# Set up the soft realtime limit to maximum (99)
+# Please note that the hard limit needs to be set to 99 too 
+# for this to work (check with ulimit -Hr).
+# If that has not been done yet, add
+# <username>	hard     rtprio          99
+# to /etc/security/limits.conf
+# It is also necessary and recommended to add
+# <username>    soft     rtprio         99
+# as well. This can also be done in the command line
+# but would need to be done for each session.
+ulimit -Sr 99
+
+for binary in ${binaries}; do
+	sudo setcap 'cap_sys_nice=eip' ${binary}
+	result=$?
+	if [ ${result} = 0 ];then
+		echo ${binary} was unlocked
+	fi
+done
+
+# sudo setcap 'cap_sys_nice=eip' /bin/bash
+# result=$?
+# if [ ${result} = 0 ];then
+# 	echo /bin/bash was unlocked
+# fi
+

From bb53c71f70132beae2dcf7f39201df769be697d8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:21:20 +0200
Subject: [PATCH 0927/1292] fsfs config update

---
 unittest/config/FSFWConfig.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/unittest/config/FSFWConfig.h b/unittest/config/FSFWConfig.h
index 665c939f..bb285472 100644
--- a/unittest/config/FSFWConfig.h
+++ b/unittest/config/FSFWConfig.h
@@ -11,6 +11,12 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
 //! If -DDEBUG is supplied in the build defines, there will be
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)

From 9309562716da79a49e9d04a4f9081eb730216581 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:24:53 +0200
Subject: [PATCH 0928/1292] defaultcfg folder added

---
 defaultcfg/FSFWConfig.h | 41 +++++++++++++++++++++++++++++++++++++++++
 defaultcfg/version.h    | 11 +++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 defaultcfg/FSFWConfig.h
 create mode 100644 defaultcfg/version.h

diff --git a/defaultcfg/FSFWConfig.h b/defaultcfg/FSFWConfig.h
new file mode 100644
index 00000000..2001f306
--- /dev/null
+++ b/defaultcfg/FSFWConfig.h
@@ -0,0 +1,41 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include "version.h"
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/version.h b/defaultcfg/version.h
new file mode 100644
index 00000000..b3ef8318
--- /dev/null
+++ b/defaultcfg/version.h
@@ -0,0 +1,11 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+static const char* FSFW_VERSION_NAME = "fsfw";
+
+#define FSFW_VERSION 		0
+#define	FSFW_SUBVERSION 	0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */

From 057f3b859e9857d7139be783c9fb89987fc8fa15 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:39:48 +0200
Subject: [PATCH 0929/1292] added readme and efaultcfg

---
 README.md                                     |   4 +
 defaultcfg/README.md                          |   6 +
 defaultcfg/config.mk                          |  17 ++
 defaultcfg/config/FSFWConfig.h                |  41 +++
 defaultcfg/config/OBSWConfig.h                |  14 +
 .../config/devices/logicalAddresses.cpp       |   5 +
 defaultcfg/config/devices/logicalAddresses.h  |  18 ++
 .../config/devices/powerSwitcherList.cpp      |   4 +
 defaultcfg/config/devices/powerSwitcherList.h |  12 +
 defaultcfg/config/events/subsystemIdRanges.h  |  18 ++
 defaultcfg/config/ipc/missionMessageTypes.cpp |  11 +
 defaultcfg/config/ipc/missionMessageTypes.h   |  21 ++
 defaultcfg/config/objects/Factory.cpp         |  57 ++++
 defaultcfg/config/objects/Factory.h           |  20 ++
 defaultcfg/config/objects/systemObjectList.h  | 138 +++++++++
 .../config/objects/translateObjects.cpp       | 271 ++++++++++++++++++
 defaultcfg/config/objects/translateObjects.h  |   9 +
 .../PollingSequenceFactory.cpp                |  23 ++
 .../pollingsequence/PollingSequenceFactory.h  |  32 +++
 defaultcfg/config/returnvalues/classIds.h     |  16 ++
 defaultcfg/config/tmtc/apid.h                 |  18 ++
 defaultcfg/config/tmtc/pusIds.h               |  23 ++
 defaultcfg/config/version.h                   |   9 +
 23 files changed, 787 insertions(+)
 create mode 100644 README.md
 create mode 100644 defaultcfg/README.md
 create mode 100644 defaultcfg/config.mk
 create mode 100644 defaultcfg/config/FSFWConfig.h
 create mode 100644 defaultcfg/config/OBSWConfig.h
 create mode 100644 defaultcfg/config/devices/logicalAddresses.cpp
 create mode 100644 defaultcfg/config/devices/logicalAddresses.h
 create mode 100644 defaultcfg/config/devices/powerSwitcherList.cpp
 create mode 100644 defaultcfg/config/devices/powerSwitcherList.h
 create mode 100644 defaultcfg/config/events/subsystemIdRanges.h
 create mode 100644 defaultcfg/config/ipc/missionMessageTypes.cpp
 create mode 100644 defaultcfg/config/ipc/missionMessageTypes.h
 create mode 100644 defaultcfg/config/objects/Factory.cpp
 create mode 100644 defaultcfg/config/objects/Factory.h
 create mode 100644 defaultcfg/config/objects/systemObjectList.h
 create mode 100644 defaultcfg/config/objects/translateObjects.cpp
 create mode 100644 defaultcfg/config/objects/translateObjects.h
 create mode 100644 defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
 create mode 100644 defaultcfg/config/pollingsequence/PollingSequenceFactory.h
 create mode 100644 defaultcfg/config/returnvalues/classIds.h
 create mode 100644 defaultcfg/config/tmtc/apid.h
 create mode 100644 defaultcfg/config/tmtc/pusIds.h
 create mode 100644 defaultcfg/config/version.h

diff --git a/README.md b/README.md
new file mode 100644
index 00000000..fc86fca7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,4 @@
+Flight Software Framework (FSFW)
+======
+
+I want to be written!
diff --git a/defaultcfg/README.md b/defaultcfg/README.md
new file mode 100644
index 00000000..8446cda4
--- /dev/null
+++ b/defaultcfg/README.md
@@ -0,0 +1,6 @@
+# How to setup configuration folder for FSFW
+
+It is recommended to copy the content of the defaultcfg folder
+into a config folder which is in the same directory as the Flight
+Software Framework submodule. After that, the config.mk folder should be
+included by the primary Makefile with CURRENTPATH set correctly.
diff --git a/defaultcfg/config.mk b/defaultcfg/config.mk
new file mode 100644
index 00000000..fcf3b799
--- /dev/null
+++ b/defaultcfg/config.mk
@@ -0,0 +1,17 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/config/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/tmtc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/config/devices/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/config/
+INCLUDES += $(CURRENTPATH)/config/objects
+INCLUDES += $(CURRENTPATH)/config/returnvalues
+INCLUDES += $(CURRENTPATH)/config/tmtc
+INCLUDES += $(CURRENTPATH)/config/events
+INCLUDES += $(CURRENTPATH)/config/devices
+INCLUDES += $(CURRENTPATH)/config/pollingsequence
+INCLUDES += $(CURRENTPATH)/config/ipc
+INCLUDES += $(CURRENTPATH)/config/
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
new file mode 100644
index 00000000..2001f306
--- /dev/null
+++ b/defaultcfg/config/FSFWConfig.h
@@ -0,0 +1,41 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include "version.h"
+
+//! Used to determine whether C++ ostreams are used
+//! Those can lead to code bloat.
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! Reduced printout to further decrese code size
+//! Be careful, this also turns off most diagnostic prinouts!
+#define FSFW_REDUCED_PRINTOUT		0
+
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+#define FSFW_CSB_FIFO_DEPTH			6
+
+//! If -DDEBUG is supplied in the build defines, there will be
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiles source files)
+#ifdef DEBUG
+#define FSFW_DEBUG_OUTPUT 			1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include <translateObjects.h>
+#include <translateEvents.h>
+#else
+#define FSFW_DEBUG_OUTPUT			0
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	1
+
+
+#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/config/OBSWConfig.h
new file mode 100644
index 00000000..d186da7d
--- /dev/null
+++ b/defaultcfg/config/OBSWConfig.h
@@ -0,0 +1,14 @@
+#ifndef CONFIG_OBSWCONFIG_H_
+#define CONFIG_OBSWCONFIG_H_
+
+#ifdef __cplusplus
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONFIG_OBSWCONFIG_H_ */
diff --git a/defaultcfg/config/devices/logicalAddresses.cpp b/defaultcfg/config/devices/logicalAddresses.cpp
new file mode 100644
index 00000000..c7ce314d
--- /dev/null
+++ b/defaultcfg/config/devices/logicalAddresses.cpp
@@ -0,0 +1,5 @@
+#include "logicalAddresses.h"
+
+
+
+
diff --git a/defaultcfg/config/devices/logicalAddresses.h b/defaultcfg/config/devices/logicalAddresses.h
new file mode 100644
index 00000000..174fa788
--- /dev/null
+++ b/defaultcfg/config/devices/logicalAddresses.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <config/objects/systemObjectList.h>
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <cstdint>
+
+/**
+ * Can be used for addresses for physical devices like I2C adresses.
+ */
+namespace addresses {
+	/* Logical addresses have uint32_t datatype */
+	enum logicalAddresses: address_t {
+	};
+}
+
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */
diff --git a/defaultcfg/config/devices/powerSwitcherList.cpp b/defaultcfg/config/devices/powerSwitcherList.cpp
new file mode 100644
index 00000000..343f78d0
--- /dev/null
+++ b/defaultcfg/config/devices/powerSwitcherList.cpp
@@ -0,0 +1,4 @@
+#include "powerSwitcherList.h"
+
+
+
diff --git a/defaultcfg/config/devices/powerSwitcherList.h b/defaultcfg/config/devices/powerSwitcherList.h
new file mode 100644
index 00000000..86ddea57
--- /dev/null
+++ b/defaultcfg/config/devices/powerSwitcherList.h
@@ -0,0 +1,12 @@
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+	};
+
+}
+
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */
diff --git a/defaultcfg/config/events/subsystemIdRanges.h b/defaultcfg/config/events/subsystemIdRanges.h
new file mode 100644
index 00000000..24eee819
--- /dev/null
+++ b/defaultcfg/config/events/subsystemIdRanges.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+#include <fsfw/events/fwSubsystemIdRanges.h>
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
diff --git a/defaultcfg/config/ipc/missionMessageTypes.cpp b/defaultcfg/config/ipc/missionMessageTypes.cpp
new file mode 100644
index 00000000..e2edbf9c
--- /dev/null
+++ b/defaultcfg/config/ipc/missionMessageTypes.cpp
@@ -0,0 +1,11 @@
+#include <config/ipc/MissionMessageTypes.h>
+#include <fsfw/ipc/CommandMessageIF.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+	switch(message->getMessageType()) {
+	default:
+		break;
+	}
+}
+
+
diff --git a/defaultcfg/config/ipc/missionMessageTypes.h b/defaultcfg/config/ipc/missionMessageTypes.h
new file mode 100644
index 00000000..8b2e2fcc
--- /dev/null
+++ b/defaultcfg/config/ipc/missionMessageTypes.h
@@ -0,0 +1,21 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/ipc/FwMessageTypes.h>
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes {
+enum CustomMessageTypes {
+	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT
+};
+
+void clearMissionMessage(CommandMessage* message);
+}
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
new file mode 100644
index 00000000..ea187a5e
--- /dev/null
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -0,0 +1,57 @@
+#include "Factory.h"
+
+/* Config */
+#include <tmtc/apid.h>
+#include <objects/systemObjectList.h>
+#include <devices/logicalAddresses.h>
+#include <devices/powerSwitcherList.h>
+#include <tmtc/pusIds.h>
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <mission/utility/TmFunnel.h>
+
+
+#include <cstdint>
+
+
+/**
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the nterface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::PUS_TIME;
+	TmFunnel::downlinkDestination = objects::NO_OBJECT;
+}
+
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/config/objects/Factory.h
new file mode 100644
index 00000000..8b99ae99
--- /dev/null
+++ b/defaultcfg/config/objects/Factory.h
@@ -0,0 +1,20 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <cstddef>
+
+namespace Factory {
+    size_t calculateStorage(uint8_t numberOfPools, uint16_t* numberOfElements,
+            uint16_t* sizeOfElements);
+	/**
+	 * @brief   Creates all SystemObject elements which are persistent
+	 *          during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+
+#endif /* FACTORY_H_ */
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/config/objects/systemObjectList.h
new file mode 100644
index 00000000..2448efbd
--- /dev/null
+++ b/defaultcfg/config/objects/systemObjectList.h
@@ -0,0 +1,138 @@
+#ifndef CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* First Byte 0x50-0x52 reserved for PUS Services **/
+		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
+		PUS_PACKET_DISTRIBUTOR = 0x50000200,
+		/* UDP ID must come after CCSDS Distributor  **/
+		UDP_TMTC_BRIDGE = 0x50000300,
+		EMAC_POLLING_TASK = 0x50000400,
+		SERIAL_TMTC_BRIDGE = 0x50000500,
+		SERIAL_RING_BUFFER = 0x50000550,
+		SERIAL_POLLING_TASK = 0x50000600,
+
+		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
+		PUS_SERVICE_20_PARAM_MGMT = 0x51002000,
+		PUS_SERVICE_23_FILE_MGMT = 0x51002300,
+		PUS_SERVICE_201_HEALTH = 0x51020100,
+
+		PUS_TIME = 0x52000001,
+		TM_FUNNEL = 0x52000002,
+		FREERTOS_TASK_MONITOR = 0x53000003,
+
+		CORE_CONTROLLER = 0x40001000,
+        SYSTEM_STATE_TASK = 0x40001005,
+        THERMAL_CONTROLLER = 0x40002000,
+		RS485_CONTROLLER = 0x40005000,
+
+        /* 0x44 ('D') for Device Handlers **/
+        /* Second Byte: ComIF -> 0x00: UART,0x10 SPI,0x20: I2C,30: GPIO,40: PWM */
+        /* Third Byte: Device ID */
+		PCDU_HANDLER = 0x44003200,
+		GPS0_HANDLER = 0x44101F00,
+		GPS1_HANDLER = 0x44202000,
+
+		DLR_PVCH = 0x44104000,
+		GYRO1 = 0x44105000,
+		DLR_IRAS = 0x44106000,
+
+		/* fourth byte decoder output ID */
+
+		// Devices connected to decoder 1
+		SPI_Test_PT1000 = 0x44115400,
+		SPI_Test_Gyro = 0x44115500,
+		PT1000_Syrlinks_DEC1_O1 = 0x44115401,
+		PT1000_Camera_DEC1_O2 = 0x44115402,
+		PT1000_SuS1_DEC1_O3 = 0x44115404,
+		PT1000_SuS2_DEC1_O4 = 0x44115405,
+		PT1000_SuS3_DEC1_O5 = 0x44115406,
+		PT1000_PVHC_DEC1_O6 = 0x44115407,
+
+		// Devices connected to decoder 2
+		PT1000_CCSDS1_DEC2 = 0x44125401,
+		PT1000_MGT1_DEC2 = 0x44125403,
+		PT1000_SuS4_DEC2 = 0x44125404,
+		PT1000_SuS5_DEC2 = 0x44125405,
+		PT1000_SuS6_DEC2 = 0x44125406,
+		PT1000_PVCH_DEC2 = 0x44125407,
+		SuS_ADC1_DEC2 = 0x44020108,
+
+		// Devices connected to decoder 3
+		PT1000_Iridium_DEC3 = 0x44130301,
+		PT1000_CCSDS2_DEC3 = 0x44130302,
+		PT1000_SuS7_DEC3 = 0x44130305,
+		PT1000_SuS8_DEC3 = 0x44130306,
+		PT1000_PVCH_DEC3 = 0x44130307,
+		GYRO2 = 0x44130308,
+
+		// Devices connected to decoder 4
+		PT1000_PLOC_DEC4 = 0x44145401,
+		PT1000_SuS9_DEC4 = 0x44145404,
+		PT1000_SuS10_DEC4 = 0x44145405,
+		PT1000_PVHC_DEC4 = 0x44145406,
+		SuS_ADC_DEC4 = 0x44145407,
+
+		/* 0x49 ('I') for Communication Interfaces **/
+		DUMMY_ECHO_COM_IF = 0x4900AFFE,
+		DUMMY_GPS_COM_IF = 0x49001F00,
+		RS232_DEVICE_COM_IF = 0x49005200,
+		I2C_DEVICE_COM_IF = 0x49005300,
+		GPIO_DEVICE_COM_IF = 0x49005400,
+		SPI_DEVICE_COM_IF = 0x49005600,
+		//SPI_POLLING_TASK = 0x49005410,
+
+		/* 0x4d ('M') for Memory Handlers **/
+		SD_CARD_HANDLER = 0x4D0073AD,
+		FRAM_HANDLER = 0x4D008000,
+		SOFTWARE_IMAGE_HANDLER = 0x4D009000,
+
+		/* Board Specific */
+		AT91_I2C_TEST_TASK = 0x12345678,
+		AT91_UART0_TEST_TASK = 0x87654321,
+		AT91_UART2_TEST_TASK = 0x000123336,
+		AT91_SPI_TEST_TASK = 0x66666666,
+		STM32_TEST_TASK = 0x77777777,
+		LED_TASK = 0x12345777,
+
+		/* Test Task */
+		ARDUINO_0 = 0x01010100,
+		ARDUINO_1 = 0x01010101,
+		ARDUINO_2 = 0x01010102,
+		ARDUINO_3 = 0x01010103,
+		ARDUINO_4 = 0x01010104,
+		TEST_TASK = 0x42694269,
+		DUMMY_HANDLER = 0x4400AFFE,
+		TC_INJECTOR	= 0x99000001
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
+
+
+/**
+                   â–„              â–„
+                  ▌▒█           ▄▀▒▌
+                  ▌▒▒█        ▄▀▒▒▒�
+                 �▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒�
+               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒�
+             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
+            �▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
+            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒�
+           �░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
+           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
+          ▌▒▀�▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒�
+          �▒▒�▀�▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
+          �▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒�
+           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
+           �▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒�
+            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
+              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
+                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
+                   ▒▒▒▒▒▒▒▒▒▒▀▀
+*/
+
diff --git a/defaultcfg/config/objects/translateObjects.cpp b/defaultcfg/config/objects/translateObjects.cpp
new file mode 100644
index 00000000..73cd02bf
--- /dev/null
+++ b/defaultcfg/config/objects/translateObjects.cpp
@@ -0,0 +1,271 @@
+/** 
+ * @brief	Auto-generated object translation file. Contains 86 translations. 
+ * Generated on: 2020-08-25 00:57:14
+ **/ 
+#include "translateObjects.h"
+
+const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
+const char *ARDUINO_0_STRING = "ARDUINO_0";
+const char *ARDUINO_1_STRING = "ARDUINO_1";
+const char *ARDUINO_2_STRING = "ARDUINO_2";
+const char *ARDUINO_3_STRING = "ARDUINO_3";
+const char *ARDUINO_4_STRING = "ARDUINO_4";
+const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
+const char *LED_TASK_STRING = "LED_TASK";
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *SuS_ADC1_DEC2_STRING = "SuS_ADC1_DEC2";
+const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
+const char *DLR_PVCH_STRING = "DLR_PVCH";
+const char *GYRO1_STRING = "GYRO1";
+const char *DLR_IRAS_STRING = "DLR_IRAS";
+const char *SPI_Test_PT1000_STRING = "SPI_Test_PT1000";
+const char *PT1000_Syrlinks_DEC1_O1_STRING = "PT1000_Syrlinks_DEC1_O1";
+const char *PT1000_Camera_DEC1_O2_STRING = "PT1000_Camera_DEC1_O2";
+const char *PT1000_SuS1_DEC1_O3_STRING = "PT1000_SuS1_DEC1_O3";
+const char *PT1000_SuS2_DEC1_O4_STRING = "PT1000_SuS2_DEC1_O4";
+const char *PT1000_SuS3_DEC1_O5_STRING = "PT1000_SuS3_DEC1_O5";
+const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
+const char *SPI_Test_Gyro_STRING = "SPI_Test_Gyro";
+const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
+const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
+const char *PT1000_SuS4_DEC2_STRING = "PT1000_SuS4_DEC2";
+const char *PT1000_SuS5_DEC2_STRING = "PT1000_SuS5_DEC2";
+const char *PT1000_SuS6_DEC2_STRING = "PT1000_SuS6_DEC2";
+const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
+const char *PT1000_Iridium_DEC3_STRING = "PT1000_Iridium_DEC3";
+const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
+const char *PT1000_SuS7_DEC3_STRING = "PT1000_SuS7_DEC3";
+const char *PT1000_SuS8_DEC3_STRING = "PT1000_SuS8_DEC3";
+const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
+const char *GYRO2_STRING = "GYRO2";
+const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
+const char *PT1000_SuS9_DEC4_STRING = "PT1000_SuS9_DEC4";
+const char *PT1000_SuS10_DEC4_STRING = "PT1000_SuS10_DEC4";
+const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
+const char *SuS_ADC_DEC4_STRING = "SuS_ADC_DEC4";
+const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
+const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
+const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
+const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
+const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
+const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
+const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
+const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
+const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
+const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
+const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
+const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
+const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
+const char *SERIAL_TMTC_BRIDGE_STRING = "SERIAL_TMTC_BRIDGE";
+const char *SERIAL_RING_BUFFER_STRING = "SERIAL_RING_BUFFER";
+const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
+const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
+const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
+const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
+const char *PUS_SERVICE_3_PSB_STRING = "PUS_SERVICE_3_PSB";
+const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
+const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
+const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
+const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
+const char *PUS_SERVICE_20_STRING = "PUS_SERVICE_20";
+const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
+const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
+const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *PUS_TIME_STRING = "PUS_TIME";
+const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
+const char *FREERTOS_TASK_MONITOR_STRING = "FREERTOS_TASK_MONITOR";
+const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
+const char *MODE_STORE_STRING = "MODE_STORE";
+const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
+const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
+const char *TC_STORE_STRING = "TC_STORE";
+const char *TM_STORE_STRING = "TM_STORE";
+const char *IPC_STORE_STRING = "IPC_STORE";
+const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
+const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
+const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
+const char *TC_INJECTOR_STRING = "TC_INJECTOR";
+const char *NO_OBJECT_STRING = "NO_OBJECT";
+
+const char* translateObject(object_id_t object){
+	switch((object&0xFFFFFFFF)){
+		case 0x000123336:
+			return AT91_UART2_TEST_TASK_STRING;
+		case 0x01010100:
+			return ARDUINO_0_STRING;
+		case 0x01010101:
+			return ARDUINO_1_STRING;
+		case 0x01010102:
+			return ARDUINO_2_STRING;
+		case 0x01010103:
+			return ARDUINO_3_STRING;
+		case 0x01010104:
+			return ARDUINO_4_STRING;
+		case 0x12345678:
+			return AT91_I2C_TEST_TASK_STRING;
+		case 0x12345777:
+			return LED_TASK_STRING;
+		case 0x42694269:
+			return TEST_TASK_STRING;
+		case 0x44003200:
+			return PCDU_HANDLER_STRING;
+		case 0x4400AFFE:
+			return DUMMY_HANDLER_STRING;
+		case 0x44020108:
+			return SuS_ADC1_DEC2_STRING;
+		case 0x44101F00:
+			return GPS0_HANDLER_STRING;
+		case 0x44104000:
+			return DLR_PVCH_STRING;
+		case 0x44105000:
+			return GYRO1_STRING;
+		case 0x44106000:
+			return DLR_IRAS_STRING;
+		case 0x44115400:
+			return SPI_Test_PT1000_STRING;
+		case 0x44115401:
+			return PT1000_Syrlinks_DEC1_O1_STRING;
+		case 0x44115402:
+			return PT1000_Camera_DEC1_O2_STRING;
+		case 0x44115404:
+			return PT1000_SuS1_DEC1_O3_STRING;
+		case 0x44115405:
+			return PT1000_SuS2_DEC1_O4_STRING;
+		case 0x44115406:
+			return PT1000_SuS3_DEC1_O5_STRING;
+		case 0x44115407:
+			return PT1000_PVHC_DEC1_O6_STRING;
+		case 0x44115500:
+			return SPI_Test_Gyro_STRING;
+		case 0x44125401:
+			return PT1000_CCSDS1_DEC2_STRING;
+		case 0x44125403:
+			return PT1000_MGT1_DEC2_STRING;
+		case 0x44125404:
+			return PT1000_SuS4_DEC2_STRING;
+		case 0x44125405:
+			return PT1000_SuS5_DEC2_STRING;
+		case 0x44125406:
+			return PT1000_SuS6_DEC2_STRING;
+		case 0x44125407:
+			return PT1000_PVCH_DEC2_STRING;
+		case 0x44130301:
+			return PT1000_Iridium_DEC3_STRING;
+		case 0x44130302:
+			return PT1000_CCSDS2_DEC3_STRING;
+		case 0x44130305:
+			return PT1000_SuS7_DEC3_STRING;
+		case 0x44130306:
+			return PT1000_SuS8_DEC3_STRING;
+		case 0x44130307:
+			return PT1000_PVCH_DEC3_STRING;
+		case 0x44130308:
+			return GYRO2_STRING;
+		case 0x44145401:
+			return PT1000_PLOC_DEC4_STRING;
+		case 0x44145404:
+			return PT1000_SuS9_DEC4_STRING;
+		case 0x44145405:
+			return PT1000_SuS10_DEC4_STRING;
+		case 0x44145406:
+			return PT1000_PVHC_DEC4_STRING;
+		case 0x44145407:
+			return SuS_ADC_DEC4_STRING;
+		case 0x44202000:
+			return GPS1_HANDLER_STRING;
+		case 0x49001F00:
+			return DUMMY_GPS_COM_IF_STRING;
+		case 0x49005200:
+			return RS232_DEVICE_COM_IF_STRING;
+		case 0x49005300:
+			return I2C_DEVICE_COM_IF_STRING;
+		case 0x49005400:
+			return GPIO_DEVICE_COM_IF_STRING;
+		case 0x49005410:
+			return SPI_POLLING_TASK_STRING;
+		case 0x49005600:
+			return SPI_DEVICE_COM_IF_STRING;
+		case 0x4900AFFE:
+			return DUMMY_ECHO_COM_IF_STRING;
+		case 0x4D0073AD:
+			return SD_CARD_HANDLER_STRING;
+		case 0x50000100:
+			return CCSDS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000200:
+			return PUS_PACKET_DISTRIBUTOR_STRING;
+		case 0x50000300:
+			return UDP_TMTC_BRIDGE_STRING;
+		case 0x50000400:
+			return EMAC_POLLING_TASK_STRING;
+		case 0x50000500:
+			return SERIAL_TMTC_BRIDGE_STRING;
+		case 0x50000550:
+			return SERIAL_RING_BUFFER_STRING;
+		case 0x50000600:
+			return SERIAL_POLLING_TASK_STRING;
+		case 0x51000100:
+			return PUS_SERVICE_1_STRING;
+		case 0x51000200:
+			return PUS_SERVICE_2_STRING;
+		case 0x51000300:
+			return PUS_SERVICE_3_STRING;
+		case 0x51000310:
+			return PUS_SERVICE_3_PSB_STRING;
+		case 0x51000400:
+			return PUS_SERVICE_5_STRING;
+		case 0x51000500:
+			return PUS_SERVICE_6_STRING;
+		case 0x51000800:
+			return PUS_SERVICE_8_STRING;
+		case 0x51000900:
+			return PUS_SERVICE_9_STRING;
+		case 0x51001700:
+			return PUS_SERVICE_17_STRING;
+		case 0x51002000:
+			return PUS_SERVICE_20_STRING;
+		case 0x51002300:
+			return PUS_SERVICE_23_STRING;
+		case 0x51020000:
+			return PUS_SERVICE_200_STRING;
+		case 0x51020100:
+			return PUS_SERVICE_201_STRING;
+		case 0x52000001:
+			return PUS_TIME_STRING;
+		case 0x52000002:
+			return PUS_FUNNEL_STRING;
+		case 0x53000000:
+			return PUS_SERVICE_1_STRING;
+		case 0x53000003:
+			return FREERTOS_TASK_MONITOR_STRING;
+		case 0x53010000:
+			return HEALTH_TABLE_STRING;
+		case 0x53010100:
+			return MODE_STORE_STRING;
+		case 0x53030000:
+			return EVENT_MANAGER_STRING;
+		case 0x53040000:
+			return INTERNAL_ERROR_REPORTER_STRING;
+		case 0x534f0100:
+			return TC_STORE_STRING;
+		case 0x534f0200:
+			return TM_STORE_STRING;
+		case 0x534f0300:
+			return IPC_STORE_STRING;
+		case 0x66666666:
+			return AT91_SPI_TEST_TASK_STRING;
+		case 0x77777777:
+			return STM32_TEST_TASK_STRING;
+		case 0x87654321:
+			return AT91_UART0_TEST_TASK_STRING;
+		case 0x99000001:
+			return TC_INJECTOR_STRING;
+		case 0xFFFFFFFF:
+			return NO_OBJECT_STRING;
+		default:
+			return "UNKNOWN_OBJECT";
+	}
+	return 0;
+}
diff --git a/defaultcfg/config/objects/translateObjects.h b/defaultcfg/config/objects/translateObjects.h
new file mode 100644
index 00000000..5b656940
--- /dev/null
+++ b/defaultcfg/config/objects/translateObjects.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
+
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+
+const char* translateObject(object_id_t object);
+
+
+#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 00000000..f836a746
--- /dev/null
+++ b/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,23 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(
+        FixedTimeslotTaskIF *thisSequence) {
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+	/* Add polling sequence table here */
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
+		        << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.h b/defaultcfg/config/pollingsequence/PollingSequenceFactory.h
new file mode 100644
index 00000000..c5d41b7d
--- /dev/null
+++ b/defaultcfg/config/pollingsequence/PollingSequenceFactory.h
@@ -0,0 +1,32 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating the PST
+ * @return
+ */
+namespace pst {
+
+/* Default PST */
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+
+}
+
+#endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/defaultcfg/config/returnvalues/classIds.h b/defaultcfg/config/returnvalues/classIds.h
new file mode 100644
index 00000000..606cc60b
--- /dev/null
+++ b/defaultcfg/config/returnvalues/classIds.h
@@ -0,0 +1,16 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <fsfw/returnvalues/FwClassIds.h>
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/defaultcfg/config/tmtc/apid.h b/defaultcfg/config/tmtc/apid.h
new file mode 100644
index 00000000..c0231bca
--- /dev/null
+++ b/defaultcfg/config/tmtc/apid.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <cstdint>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets.
+ *
+ * Chose APID(s) for mission and define it here.
+ */
+namespace apid {
+	static const uint16_t DEFAULT_APID = 0x00;
+}
+
+
+#endif /* CONFIG_TMTC_APID_H_ */
diff --git a/defaultcfg/config/tmtc/pusIds.h b/defaultcfg/config/tmtc/pusIds.h
new file mode 100644
index 00000000..cc0db9f0
--- /dev/null
+++ b/defaultcfg/config/tmtc/pusIds.h
@@ -0,0 +1,23 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+namespace pus {
+enum Ids: uint8_t {
+	PUS_SERVICE_1 = 1,
+	PUS_SERVICE_2 = 2,
+	PUS_SERVICE_3 = 3,
+	PUS_SERVICE_5 = 5,
+	PUS_SERVICE_6 = 6,
+	PUS_SERVICE_8 = 8,
+	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_11 = 11,
+	PUS_SERVICE_17 = 17,
+	PUS_SERVICE_19 = 19,
+	PUS_SERVICE_20 = 20,
+	PUS_SERVICE_23 = 23,
+	PUS_SERVICE_200 = 200,
+	PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/defaultcfg/config/version.h b/defaultcfg/config/version.h
new file mode 100644
index 00000000..3c60317c
--- /dev/null
+++ b/defaultcfg/config/version.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+/* OBSW versioning can be specified in this file */
+
+#define OBSW_VERSION      0
+#define OBSW_SUBVERSION   0
+
+#endif /* CONFIG_VERSION_H_ */

From b9f3c1ee84e331e0c5d52f88c313643d43dbf3c4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 20 Oct 2020 17:53:47 +0200
Subject: [PATCH 0930/1292] takne over defaultcfg

---
 FSFWVersion.h                                |  11 ++
 defaultcfg/config/FSFWConfig.h               |   2 +-
 defaultcfg/config/OBSWConfig.h               |   2 +
 defaultcfg/config/OBSWVersion.h              |   9 ++
 defaultcfg/config/objects/Factory.cpp        |  31 ++---
 defaultcfg/config/objects/Factory.h          |   3 -
 defaultcfg/config/objects/systemObjectList.h | 130 +------------------
 7 files changed, 41 insertions(+), 147 deletions(-)
 create mode 100644 FSFWVersion.h
 create mode 100644 defaultcfg/config/OBSWVersion.h

diff --git a/FSFWVersion.h b/FSFWVersion.h
new file mode 100644
index 00000000..b3ef8318
--- /dev/null
+++ b/FSFWVersion.h
@@ -0,0 +1,11 @@
+#ifndef FSFW_DEFAULTCFG_VERSION_H_
+#define FSFW_DEFAULTCFG_VERSION_H_
+
+static const char* FSFW_VERSION_NAME = "fsfw";
+
+#define FSFW_VERSION 		0
+#define	FSFW_SUBVERSION 	0
+
+
+
+#endif /* FSFW_DEFAULTCFG_VERSION_H_ */
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index 2001f306..cfe89864 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -1,7 +1,7 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include "version.h"
+#include <FSFWVersion.h>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/config/OBSWConfig.h
index d186da7d..a9f57638 100644
--- a/defaultcfg/config/OBSWConfig.h
+++ b/defaultcfg/config/OBSWConfig.h
@@ -1,6 +1,8 @@
 #ifndef CONFIG_OBSWCONFIG_H_
 #define CONFIG_OBSWCONFIG_H_
 
+#include "OBSWVersion.h"
+
 #ifdef __cplusplus
 namespace config {
 #endif
diff --git a/defaultcfg/config/OBSWVersion.h b/defaultcfg/config/OBSWVersion.h
new file mode 100644
index 00000000..3c60317c
--- /dev/null
+++ b/defaultcfg/config/OBSWVersion.h
@@ -0,0 +1,9 @@
+#ifndef CONFIG_VERSION_H_
+#define CONFIG_VERSION_H_
+
+/* OBSW versioning can be specified in this file */
+
+#define OBSW_VERSION      0
+#define OBSW_SUBVERSION   0
+
+#endif /* CONFIG_VERSION_H_ */
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
index ea187a5e..51dd6130 100644
--- a/defaultcfg/config/objects/Factory.cpp
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -1,11 +1,9 @@
 #include "Factory.h"
-
-/* Config */
-#include <tmtc/apid.h>
-#include <objects/systemObjectList.h>
-#include <devices/logicalAddresses.h>
-#include <devices/powerSwitcherList.h>
-#include <tmtc/pusIds.h>
+#include "../tmtc/apid.h"
+#include "../tmtc/pusIds.h"
+#include "../objects/systemObjectList.h"
+#include "../devices/logicalAddresses.h"
+#include "../devices/powerSwitcherList.h"
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
@@ -13,21 +11,20 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <mission/utility/TmFunnel.h>
-
 
 #include <cstdint>
 
-
 /**
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the nterface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ * This class should be used to create all system objects required for
+ * the on-board software, using the object ID list from the configuration
+ * folder.
+ *
+ * The objects are registered in the internal object manager automatically.
+ * This is used later to add objects to tasks.
+ *
+ * This file also sets static framework IDs.
  *
  * Framework objects are created first.
- *
  * @ingroup init
  */
 void Factory::produce(void) {
@@ -52,6 +49,6 @@ void Factory::setStaticFrameworkObjectIds() {
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
 	TmPacketStored::timeStamperId = objects::PUS_TIME;
-	TmFunnel::downlinkDestination = objects::NO_OBJECT;
+	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
 }
 
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/config/objects/Factory.h
index 8b99ae99..fe55deff 100644
--- a/defaultcfg/config/objects/Factory.h
+++ b/defaultcfg/config/objects/Factory.h
@@ -5,15 +5,12 @@
 #include <cstddef>
 
 namespace Factory {
-    size_t calculateStorage(uint8_t numberOfPools, uint16_t* numberOfElements,
-            uint16_t* sizeOfElements);
 	/**
 	 * @brief   Creates all SystemObject elements which are persistent
 	 *          during execution.
 	 */
 	void produce();
 	void setStaticFrameworkObjectIds();
-
 }
 
 
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/config/objects/systemObjectList.h
index 2448efbd..f4292f6d 100644
--- a/defaultcfg/config/objects/systemObjectList.h
+++ b/defaultcfg/config/objects/systemObjectList.h
@@ -2,137 +2,15 @@
 #define CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
 #include <cstdint>
+#include <fsfw/objectmanager/frameworkObjects.h>
 
 // The objects will be instantiated in the ID order
 namespace objects {
 	enum sourceObjects: uint32_t {
-		/* First Byte 0x50-0x52 reserved for PUS Services **/
-		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-		PUS_PACKET_DISTRIBUTOR = 0x50000200,
-		/* UDP ID must come after CCSDS Distributor  **/
-		UDP_TMTC_BRIDGE = 0x50000300,
-		EMAC_POLLING_TASK = 0x50000400,
-		SERIAL_TMTC_BRIDGE = 0x50000500,
-		SERIAL_RING_BUFFER = 0x50000550,
-		SERIAL_POLLING_TASK = 0x50000600,
-
-		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
-		PUS_SERVICE_20_PARAM_MGMT = 0x51002000,
-		PUS_SERVICE_23_FILE_MGMT = 0x51002300,
-		PUS_SERVICE_201_HEALTH = 0x51020100,
-
-		PUS_TIME = 0x52000001,
-		TM_FUNNEL = 0x52000002,
-		FREERTOS_TASK_MONITOR = 0x53000003,
-
-		CORE_CONTROLLER = 0x40001000,
-        SYSTEM_STATE_TASK = 0x40001005,
-        THERMAL_CONTROLLER = 0x40002000,
-		RS485_CONTROLLER = 0x40005000,
-
-        /* 0x44 ('D') for Device Handlers **/
-        /* Second Byte: ComIF -> 0x00: UART,0x10 SPI,0x20: I2C,30: GPIO,40: PWM */
-        /* Third Byte: Device ID */
-		PCDU_HANDLER = 0x44003200,
-		GPS0_HANDLER = 0x44101F00,
-		GPS1_HANDLER = 0x44202000,
-
-		DLR_PVCH = 0x44104000,
-		GYRO1 = 0x44105000,
-		DLR_IRAS = 0x44106000,
-
-		/* fourth byte decoder output ID */
-
-		// Devices connected to decoder 1
-		SPI_Test_PT1000 = 0x44115400,
-		SPI_Test_Gyro = 0x44115500,
-		PT1000_Syrlinks_DEC1_O1 = 0x44115401,
-		PT1000_Camera_DEC1_O2 = 0x44115402,
-		PT1000_SuS1_DEC1_O3 = 0x44115404,
-		PT1000_SuS2_DEC1_O4 = 0x44115405,
-		PT1000_SuS3_DEC1_O5 = 0x44115406,
-		PT1000_PVHC_DEC1_O6 = 0x44115407,
-
-		// Devices connected to decoder 2
-		PT1000_CCSDS1_DEC2 = 0x44125401,
-		PT1000_MGT1_DEC2 = 0x44125403,
-		PT1000_SuS4_DEC2 = 0x44125404,
-		PT1000_SuS5_DEC2 = 0x44125405,
-		PT1000_SuS6_DEC2 = 0x44125406,
-		PT1000_PVCH_DEC2 = 0x44125407,
-		SuS_ADC1_DEC2 = 0x44020108,
-
-		// Devices connected to decoder 3
-		PT1000_Iridium_DEC3 = 0x44130301,
-		PT1000_CCSDS2_DEC3 = 0x44130302,
-		PT1000_SuS7_DEC3 = 0x44130305,
-		PT1000_SuS8_DEC3 = 0x44130306,
-		PT1000_PVCH_DEC3 = 0x44130307,
-		GYRO2 = 0x44130308,
-
-		// Devices connected to decoder 4
-		PT1000_PLOC_DEC4 = 0x44145401,
-		PT1000_SuS9_DEC4 = 0x44145404,
-		PT1000_SuS10_DEC4 = 0x44145405,
-		PT1000_PVHC_DEC4 = 0x44145406,
-		SuS_ADC_DEC4 = 0x44145407,
-
-		/* 0x49 ('I') for Communication Interfaces **/
-		DUMMY_ECHO_COM_IF = 0x4900AFFE,
-		DUMMY_GPS_COM_IF = 0x49001F00,
-		RS232_DEVICE_COM_IF = 0x49005200,
-		I2C_DEVICE_COM_IF = 0x49005300,
-		GPIO_DEVICE_COM_IF = 0x49005400,
-		SPI_DEVICE_COM_IF = 0x49005600,
-		//SPI_POLLING_TASK = 0x49005410,
-
-		/* 0x4d ('M') for Memory Handlers **/
-		SD_CARD_HANDLER = 0x4D0073AD,
-		FRAM_HANDLER = 0x4D008000,
-		SOFTWARE_IMAGE_HANDLER = 0x4D009000,
-
-		/* Board Specific */
-		AT91_I2C_TEST_TASK = 0x12345678,
-		AT91_UART0_TEST_TASK = 0x87654321,
-		AT91_UART2_TEST_TASK = 0x000123336,
-		AT91_SPI_TEST_TASK = 0x66666666,
-		STM32_TEST_TASK = 0x77777777,
-		LED_TASK = 0x12345777,
-
-		/* Test Task */
-		ARDUINO_0 = 0x01010100,
-		ARDUINO_1 = 0x01010101,
-		ARDUINO_2 = 0x01010102,
-		ARDUINO_3 = 0x01010103,
-		ARDUINO_4 = 0x01010104,
-		TEST_TASK = 0x42694269,
-		DUMMY_HANDLER = 0x4400AFFE,
-		TC_INJECTOR	= 0x99000001
+		/* All addresses between start and end are reserved for the FSFW */
+		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+		FSFW_CONFIG_RESERVED_END = TM_STORE
 	};
 }
 
 #endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
-
-
-/**
-                   â–„              â–„
-                  ▌▒█           ▄▀▒▌
-                  ▌▒▒█        ▄▀▒▒▒�
-                 �▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒�
-               ▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒�
-             ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
-            �▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒▌
-            ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒�
-           �░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
-           ▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
-          ▌▒▀�▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒�
-          �▒▒�▀�▀▒░▄▄▒▄▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
-          �▒▒▒▀▀▄▄▒▒▒▄▒▒▒▒▒▒▒▒░▒░▒░▒▒�
-           ▌▒▒▒▒▒▒▀▀▀▒▒▒▒▒▒░▒░▒░▒░▒▒▒▌
-           �▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▄▒▒�
-            ▀▄▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▄▒▒▒▒▌
-              ▀▄▒▒▒▒▒▒▒▒▒▒▄▄▄▀▒▒▒▒▄▀
-                ▀▄▄▄▄▄▄▀▀▀▒▒▒▒▒▄▄▀
-                   ▒▒▒▒▒▒▒▒▒▒▀▀
-*/
-

From 742cc6eb7660adbff54e498b29afe73bfca4bbdd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 21 Oct 2020 18:19:51 +0200
Subject: [PATCH 0931/1292] no command added

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 088c1b45..f64e1589 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -21,7 +21,7 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-
+    static const DeviceCommandId_t NO_COMMAND = 0xffffffff;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;

From e7210a34f95cfa2ef4a980c18e37629f54aa0bd6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 22 Oct 2020 14:34:52 +0200
Subject: [PATCH 0932/1292] output tweaked

---
 unittest/internal/InternalUnitTester.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 9b219f09..7b72d645 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -12,13 +12,13 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
-	sif::info << "Running internal unit tests..\r\n" << std::flush;
+	sif::info << "Running internal unit tests.." << std::endl;
 	testserialize::test_serialization();
 	testmq::testMq();
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
-	sif::info << "Internal unit tests finished.\r\n" << std::flush;
+	sif::info << "Internal unit tests finished." << std::endl;
 	return RETURN_OK;
 }
 

From 90bdb844e703951ef783f0a025799efefcf6fc98 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 19:27:00 +0100
Subject: [PATCH 0933/1292] taken over some changes

---
 tmtcpacket/pus/PacketTimestampInterpreterIF.h |   3 +-
 tmtcpacket/pus/TcPacketBase.cpp               |  37 ++---
 tmtcpacket/pus/TcPacketBase.h                 | 131 ++++++++----------
 tmtcpacket/pus/TcPacketStored.cpp             |  47 +++----
 tmtcpacket/pus/TcPacketStored.h               |  75 +++++-----
 tmtcpacket/pus/TmPacketBase.cpp               |  78 +++++------
 tmtcpacket/pus/TmPacketBase.h                 | 120 ++++++++--------
 tmtcpacket/pus/TmPacketMinimal.cpp            |   4 +-
 8 files changed, 243 insertions(+), 252 deletions(-)

diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
index dd0c0328..40e7a2ea 100644
--- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h
+++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h
@@ -7,7 +7,8 @@ class TmPacketMinimal;
 class PacketTimestampInterpreterIF {
 public:
 	virtual ~PacketTimestampInterpreterIF() {}
-	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
+	virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet,
+	        timeval* timestamp) const = 0;
 	virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr, uint32_t* size) const = 0;
 };
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index b62db535..eaa8416a 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -1,11 +1,14 @@
-#include "../../globalfunctions/CRC.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
-#include <string.h>
+#include "TcPacketBase.h"
 
-TcPacketBase::TcPacketBase(const uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tcData = (TcPacketPointer*) set_data;
+#include "../../globalfunctions/CRC.h"
+#include "../../globalfunctions/arrayprinter.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include <cstring>
+
+TcPacketBase::TcPacketBase(const uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tcData = reinterpret_cast<TcPacketPointer*>(const_cast<uint8_t*>(setData));
 }
 
 TcPacketBase::~TcPacketBase() {
@@ -51,12 +54,6 @@ void TcPacketBase::setData(const uint8_t* pData) {
 	tcData = (TcPacketPointer*) pData;
 }
 
-void TcPacketBase::setAppData(uint8_t * appData, uint16_t dataLen) {
-	memcpy(&tcData->appData, appData, dataLen);
-	SpacePacketBase::setPacketDataLength(dataLen +
-				sizeof(PUSTcDataFieldHeader) + TcPacketBase::CRC_SIZE - 1);
-}
-
 uint8_t TcPacketBase::getSecondaryHeaderFlag() {
 	return (tcData->dataField.version_type_ack & 0b10000000) >> 7;
 }
@@ -66,21 +63,17 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
-	uint8_t * wholeData = getWholeData();
-	sif::debug << "TcPacket contains: " << std::endl;
-	for (uint8_t count = 0; count < getFullSize(); ++count) {
-		sif::debug << std::hex << (uint16_t) wholeData[count] << " ";
-	}
-	sif::debug << std::dec << std::endl;
+    sif::debug << "TcPacketBase::print: " << std::endl;
+	arrayprinter::print(getWholeData(), getFullSize());
 }
 
 void TcPacketBase::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-		uint8_t ack, uint8_t service, uint8_t subservice) {
+        uint8_t ack, uint8_t service, uint8_t subservice) {
 	initSpacePacketHeader(true, true, apid, sequenceCount);
-	memset(&tcData->dataField, 0, sizeof(tcData->dataField));
+	std::memset(&tcData->dataField, 0, sizeof(tcData->dataField));
 	setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
 	//Data Field Header:
-	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	//Set CCSDS_secondary_header_flag to 0 and version number to 001
 	tcData->dataField.version_type_ack = 0b00010000;
 	tcData->dataField.version_type_ack |= (ack & 0x0F);
 	tcData->dataField.service_type = service;
diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h
index b3ef5fe7..582a2214 100644
--- a/tmtcpacket/pus/TcPacketBase.h
+++ b/tmtcpacket/pus/TcPacketBase.h
@@ -1,9 +1,10 @@
-#ifndef TCPACKETBASE_H_
-#define TCPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TCPACKETBASE_H_
+#define TMTCPACKET_PUS_TCPACKETBASE_H_
 
 #include "../../tmtcpacket/SpacePacketBase.h"
 #include <cstddef>
 
+
 /**
  * This struct defines a byte-wise structured PUS TC Data Field Header.
  * Any optional fields in the header must be added or removed here.
@@ -31,7 +32,7 @@ struct TcPacketPointer {
 /**
  * This class is the basic data handler for any ECSS PUS Telecommand packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TC Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -40,68 +41,38 @@ struct TcPacketPointer {
  * @ingroup tmtcpackets
  */
 class TcPacketBase : public SpacePacketBase {
-protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet's data.
-	 *
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	TcPacketPointer* tcData;
 public:
-	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2);
-	/**
-	 * With this constant for the acknowledge field responses on all levels are expected.
-	 */
-	static const uint8_t ACK_ALL = 0b1111;
-	/**
-	 * With this constant for the acknowledge field a response on acceptance is expected.
-	 */
-	static const uint8_t ACK_ACCEPTANCE = 0b0001;
-	/**
-	 * With this constant for the acknowledge field a response on start of execution is expected.
-	 */
-	static const uint8_t ACK_START = 0b0010;
-	/**
-	 * With this constant for the acknowledge field responses on execution steps are expected.
-	 */
-	static const uint8_t ACK_STEP = 0b0100;
-	/**
-	 * With this constant for the acknowledge field a response on completion is expected.
-	 */
-	static const uint8_t ACK_COMPLETION = 0b1000;
-	/**
-	 * With this constant for the acknowledge field no responses are expected.
-	 */
-	static const uint8_t ACK_NONE = 0b000;
+	static const uint16_t TC_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
+	        sizeof(PUSTcDataFieldHeader) + 2);
+
+	enum AckField {
+		//! No acknowledgements are expected.
+		ACK_NONE = 0b0000,
+		//! Acknowledgements on acceptance are expected.
+		ACK_ACCEPTANCE = 0b0001,
+		//! Acknowledgements on start are expected.
+		ACK_START = 0b0010,
+		//! Acknowledgements on step are expected.
+		ACK_STEP = 0b0100,
+		//! Acknowledfgement on completion are expected.
+		ACK_COMPLETION = 0b1000
+	};
+
+	static constexpr uint8_t ACK_ALL = ACK_ACCEPTANCE | ACK_START | ACK_STEP |
+			ACK_COMPLETION;
+
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
-	 * @param set_address	The position where the packet data lies.
+	 * @param setData	The position where the packet data lies.
 	 */
-	TcPacketBase( const uint8_t* set_data );
+	TcPacketBase( const uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TcPacketBase();
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	/**
-	 * Initializes the Tc Packet header.
-	 * @param apid APID used.
-	 * @param sequenceCount Sequence Count in the primary header.
-	 * @param ack Which acknowledeges are expected from the receiver.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 */
-	void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-			uint8_t service, uint8_t subservice);
+
 	/**
 	 * This command returns the CCSDS Secondary Header Flag.
 	 * It shall always be zero for PUS Packets. This is the
@@ -169,24 +140,6 @@ public:
 	 */
 	void setErrorControl();
 
-	/**
-	 * Copies the supplied data to the internal TC application data field.
-	 * @param pData
-	 * @param dataLen
-	 */
-	void setAppData(uint8_t * appData, uint16_t dataLen);
-
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telecommand Packet.
-	 */
-	void setData( const uint8_t* pData );
-
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
@@ -198,7 +151,37 @@ public:
 	 * @return
 	 */
 	static size_t calculateFullPacketLength(size_t appDataLen);
+
+protected:
+    /**
+     * A pointer to a structure which defines the data structure of
+     * the packet's data.
+     *
+     * To be hardware-safe, all elements are of byte size.
+     */
+    TcPacketPointer* tcData;
+
+    /**
+     * Initializes the Tc Packet header.
+     * @param apid APID used.
+     * @param sequenceCount Sequence Count in the primary header.
+     * @param ack Which acknowledeges are expected from the receiver.
+     * @param service   PUS Service
+     * @param subservice PUS Subservice
+     */
+    void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
+            uint8_t service, uint8_t subservice);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telecommand Packet.
+     */
+    void setData( const uint8_t* pData );
 };
 
 
-#endif /* TCPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index d3474569..fffc86ae 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -1,32 +1,34 @@
+#include "TcPacketStored.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TcPacketStored.h"
 
 #include <cstring>
 
+StorageManagerIF* TcPacketStored::store = nullptr;
+
 TcPacketStored::TcPacketStored(store_address_t setAddress) :
 		TcPacketBase(nullptr), storeAddress(setAddress) {
-	this->setStoreAddress(this->storeAddress);
+	setStoreAddress(storeAddress);
 }
 
-TcPacketStored::TcPacketStored(uint8_t service, uint8_t subservice,
-		uint16_t apid, uint8_t sequence_count, const uint8_t* data,
-		size_t size, uint8_t ack ) :
+TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
+        uint8_t subservice, uint8_t sequenceCount, const uint8_t* data,
+		size_t size, uint8_t ack) :
 		TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!this->checkAndSetStore()) {
+	if (not this->checkAndSetStore()) {
 		return;
 	}
-	uint8_t* p_data = nullptr;
+	uint8_t* pData = nullptr;
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
-			(TC_PACKET_MIN_SIZE + size), &p_data);
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::warning << "TcPacketStored::TcPacketStored: Could not get "
-				"free element from store!" << std::endl;
+			(TC_PACKET_MIN_SIZE + size), &pData);
+	if (returnValue != this->store->RETURN_OK) {
+		sif::warning << "TcPacketStored: Could not get free element from store!"
+				<< std::endl;
 		return;
 	}
-	this->setData(p_data);
-	initializeTcPacket(apid, sequence_count, ack, service, subservice);
+	this->setData(pData);
+	initializeTcPacket(apid, sequenceCount, ack, service, subservice);
 	memcpy(&tcData->appData, data, size);
 	this->setPacketDataLength(
 			size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
@@ -42,8 +44,7 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 	return result;
 }
 
-TcPacketStored::TcPacketStored() :
-		TcPacketBase(NULL) {
+TcPacketStored::TcPacketStored(): TcPacketBase(nullptr) {
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	this->checkAndSetStore();
 
@@ -52,7 +53,7 @@ TcPacketStored::TcPacketStored() :
 ReturnValue_t TcPacketStored::deletePacket() {
 	ReturnValue_t result = this->store->deleteData(this->storeAddress);
 	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	this->setData( NULL);
+	this->setData(nullptr);
 	return result;
 }
 
@@ -70,17 +71,17 @@ bool TcPacketStored::checkAndSetStore() {
 
 void TcPacketStored::setStoreAddress(store_address_t setAddress) {
 	this->storeAddress = setAddress;
-	const uint8_t* temp_data = NULL;
+	const uint8_t* tempData = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
 	if (this->checkAndSetStore()) {
-		status = this->store->getData(this->storeAddress, &temp_data,
+		status = this->store->getData(this->storeAddress, &tempData,
 				&temp_size);
 	}
 	if (status == StorageManagerIF::RETURN_OK) {
-		this->setData(temp_data);
+		this->setData(tempData);
 	} else {
-		this->setData(NULL);
+		this->setData(nullptr);
 		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
@@ -90,7 +91,7 @@ store_address_t TcPacketStored::getStoreAddress() {
 }
 
 bool TcPacketStored::isSizeCorrect() {
-	const uint8_t* temp_data = NULL;
+	const uint8_t* temp_data = nullptr;
 	size_t temp_size;
 	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data,
 			&temp_size);
@@ -102,8 +103,6 @@ bool TcPacketStored::isSizeCorrect() {
 	return false;
 }
 
-StorageManagerIF* TcPacketStored::store = NULL;
-
 TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 		TcPacketBase(data) {
 	if (getFullSize() != size) {
@@ -112,7 +111,7 @@ TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) :
 	if (this->checkAndSetStore()) {
 		ReturnValue_t status = store->addData(&storeAddress, data, size);
 		if (status != HasReturnvaluesIF::RETURN_OK) {
-			this->setData(NULL);
+			this->setData(nullptr);
 		}
 	}
 }
diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h
index c81b71b7..1666107b 100644
--- a/tmtcpacket/pus/TcPacketStored.h
+++ b/tmtcpacket/pus/TcPacketStored.h
@@ -1,8 +1,8 @@
-#ifndef TCPACKETSTORED_H_
-#define TCPACKETSTORED_H_
+#ifndef TMTCPACKET_PUS_TCPACKETSTORED_H_
+#define TMTCPACKET_PUS_TCPACKETSTORED_H_
 
+#include "TcPacketBase.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../tmtcpacket/pus/TcPacketBase.h"
 
 /**
  *	This class generates a ECSS PUS Telecommand packet within a given
@@ -15,26 +15,6 @@
  *	@ingroup tmtcpackets
  */
 class TcPacketStored : public TcPacketBase {
-private:
-	/**
-	 * This is a pointer to the store all instances of the class use.
-	 * If the store is not yet set (i.e. \c store is NULL), every constructor
-	 * call tries to set it and throws an error message in case of failures.
-	 * The default store is objects::TC_STORE.
-	 */
-	static StorageManagerIF* store;
-	/**
-	 * The address where the packet data of the object instance is stored.
-	 */
-	store_address_t storeAddress;
-	/**
-	 * A helper method to check if a store is assigned to the class.
-	 * If not, the method tries to retrieve the store from the global
-	 * ObjectManager.
-	 * @return	@li	\c true if the store is linked or could be created.
-	 * 			@li \c false otherwise.
-	 */
-	bool checkAndSetStore();
 public:
 	/**
 	 * This is a default constructor which does not set the data pointer.
@@ -53,20 +33,20 @@ public:
 	 * a new PUS Telecommand Packet is created there.
 	 * Packet Application Data passed in data is copied into the packet.
 	 * @param apid			Sets the packet's APID field.
-	 * @param ack			Set's the packet's Ack field,
-	 * 		which specifies number and size of verification packets returned
-	 * 		for this command.
 	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the destination service.
+	 *                      This specifies the destination service.
 	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the destination sub-service.
-	 * @param sequence_count	Sets the packet's Source Sequence Count field.
+	 * 		                This specifies the destination sub-service.
+	 * @param sequence_count Sets the packet's Source Sequence Count field.
 	 * @param data		The data to be copied to the Application Data Field.
 	 * @param size		The amount of data to be copied.
+	 * @param ack           Set's the packet's Ack field, which specifies
+	 *                      number of verification packets returned
+     *                      for this command.
 	 */
-	TcPacketStored( uint8_t service, uint8_t subservice, uint16_t apid,
+	TcPacketStored(uint16_t apid, uint8_t service, uint8_t subservice,
 			uint8_t sequence_count = 0, const uint8_t* data = nullptr,
-			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL );
+			size_t size = 0, uint8_t ack = TcPacketBase::ACK_ALL);
 	/**
 	 * Another constructor to create a TcPacket from a raw packet stream.
 	 * Takes the data and adds it unchecked to the TcStore.
@@ -75,12 +55,18 @@ public:
 	 */
 	TcPacketStored( const uint8_t* data, uint32_t size);
 
+	/**
+	 * Getter function for the raw data.
+	 * @param dataPtr [out] Pointer to the data pointer to set
+	 * @param dataSize [out] Address of size to set.
+	 * @return -@c RETURN_OK if data was retrieved successfully.
+	 */
 	ReturnValue_t getData(const uint8_t ** dataPtr,
 			size_t* dataSize);
 	/**
 	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is \c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
+	 * @return	The current store address. The (raw) value is
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
 	 */
 	store_address_t getStoreAddress();
 	/**
@@ -104,7 +90,28 @@ public:
 	 * 			store or size is incorrect.
 	 */
 	bool isSizeCorrect();
+
+private:
+    /**
+     * This is a pointer to the store all instances of the class use.
+     * If the store is not yet set (i.e. @c store is NULL), every constructor
+     * call tries to set it and throws an error message in case of failures.
+     * The default store is objects::TC_STORE.
+     */
+    static StorageManagerIF* store;
+    /**
+     * The address where the packet data of the object instance is stored.
+     */
+    store_address_t storeAddress;
+    /**
+     * A helper method to check if a store is assigned to the class.
+     * If not, the method tries to retrieve the store from the global
+     * ObjectManager.
+     * @return  @li @c true if the store is linked or could be created.
+     *          @li @c false otherwise.
+     */
+    bool checkAndSetStore();
 };
 
 
-#endif /* TCPACKETSTORED_H_ */
+#endif /* TMTCPACKET_PUS_TCPACKETSTORED_H_ */
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 66d67600..f3bc3f00 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -1,13 +1,19 @@
+#include "TmPacketBase.h"
+
 #include "../../globalfunctions/CRC.h"
+#include "../../globalfunctions/arrayprinter.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../tmtcpacket/pus/TmPacketBase.h"
 #include "../../timemanager/CCSDSTime.h"
-#include <string.h>
 
-TmPacketBase::TmPacketBase(uint8_t* set_data) :
-		SpacePacketBase(set_data) {
-	tm_data = (TmPacketPointer*) set_data;
+#include <cstring>
+
+TimeStamperIF* TmPacketBase::timeStamper = nullptr;
+object_id_t TmPacketBase::timeStamperId = 0;
+
+TmPacketBase::TmPacketBase(uint8_t* setData) :
+		SpacePacketBase(setData) {
+	tmData = reinterpret_cast<TmPacketPointer*>(setData);
 }
 
 TmPacketBase::~TmPacketBase() {
@@ -15,25 +21,25 @@ TmPacketBase::~TmPacketBase() {
 }
 
 uint8_t TmPacketBase::getService() {
-	return tm_data->data_field.service_type;
+	return tmData->data_field.service_type;
 }
 
 uint8_t TmPacketBase::getSubService() {
-	return tm_data->data_field.service_subtype;
+	return tmData->data_field.service_subtype;
 }
 
 uint8_t* TmPacketBase::getSourceData() {
-	return &tm_data->data;
+	return &tmData->data;
 }
 
 uint16_t TmPacketBase::getSourceDataSize() {
-	return getPacketDataLength() - sizeof(tm_data->data_field)
+	return getPacketDataLength() - sizeof(tmData->data_field)
 			- CRC_SIZE + 1;
 }
 
 uint16_t TmPacketBase::getErrorControl() {
 	uint32_t size = getSourceDataSize() + CRC_SIZE;
-	uint8_t* p_to_buffer = &tm_data->data;
+	uint8_t* p_to_buffer = &tmData->data;
 	return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
 }
 
@@ -47,16 +53,12 @@ void TmPacketBase::setErrorControl() {
 
 void TmPacketBase::setData(const uint8_t* p_Data) {
 	SpacePacketBase::setData(p_Data);
-	tm_data = (TmPacketPointer*) p_Data;
+	tmData = (TmPacketPointer*) p_Data;
 }
 
 void TmPacketBase::print() {
-	/*uint8_t * wholeData = getWholeData();
-	 debug << "TmPacket contains: " << std::endl;
-	 for (uint8_t count = 0; count < getFullSize(); ++count ) {
-	 debug << std::hex << (uint16_t)wholeData[count] << " ";
-	 }
-	 debug << std::dec << std::endl;*/
+	 sif::debug << "TmPacketBase::print: " << std::endl;
+	 arrayprinter::print(getWholeData(), getFullSize());
 }
 
 bool TmPacketBase::checkAndSetStamper() {
@@ -73,47 +75,43 @@ bool TmPacketBase::checkAndSetStamper() {
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
 	uint32_t tempSize = 0;
-	return CCSDSTime::convertFromCcsds(timestamp, tm_data->data_field.time,
-			&tempSize, sizeof(tm_data->data_field.time));
+	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
+			&tempSize, sizeof(tmData->data_field.time));
 }
 
 uint8_t* TmPacketBase::getPacketTimeRaw() const{
-	return tm_data->data_field.time;
+	return tmData->data_field.time;
 
 }
 
-void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter) {
+void TmPacketBase::initializeTmPacket(uint16_t apid, uint8_t service,
+        uint8_t subservice, uint8_t packetSubcounter) {
 	//Set primary header:
 	initSpacePacketHeader(false, true, apid);
 	//Set data Field Header:
 	//First, set to zero.
-	memset(&tm_data->data_field, 0, sizeof(tm_data->data_field));
-	//Set CCSDS_secondary header flag to 0, version number to 001 and ack to 0000
+	memset(&tmData->data_field, 0, sizeof(tmData->data_field));
+
 	// NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-	// The other 4 bits of the first byte are the spacecraft time reference status
-	// To change to PUS-C, set 0b00100000
-	tm_data->data_field.version_type_ack = 0b00010000;
-	tm_data->data_field.service_type = service;
-	tm_data->data_field.service_subtype = subservice;
-	tm_data->data_field.subcounter = packetSubcounter;
+	// The other 4 bits of the first byte are the spacecraft time reference
+	// status. To change to PUS-C, set 0b00100000.
+    // Set CCSDS_secondary header flag to 0, version number to 001 and ack
+    // to 0000
+	tmData->data_field.version_type_ack = 0b00010000;
+	tmData->data_field.service_type = service;
+	tmData->data_field.service_subtype = subservice;
+	tmData->data_field.subcounter = packetSubcounter;
 	//Timestamp packet
 	if (checkAndSetStamper()) {
-		timeStamper->addTimeStamp(tm_data->data_field.time, sizeof(tm_data->data_field.time));
+		timeStamper->addTimeStamp(tmData->data_field.time,
+		        sizeof(tmData->data_field.time));
 	}
 }
 
-void TmPacketBase::setSourceData(uint8_t* sourceData, size_t sourceSize) {
-	memcpy(getSourceData(), sourceData, sourceSize);
-	setSourceDataSize(sourceSize);
-}
-
 void TmPacketBase::setSourceDataSize(uint16_t size) {
 	setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
-uint32_t TmPacketBase::getTimestampSize() const {
-	return sizeof(tm_data->data_field.time);
+size_t TmPacketBase::getTimestampSize() const {
+	return sizeof(tmData->data_field.time);
 }
-
-TimeStamperIF* TmPacketBase::timeStamper = NULL;
-object_id_t TmPacketBase::timeStamperId = 0;
diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h
index 96dbd5c6..6efc0165 100644
--- a/tmtcpacket/pus/TmPacketBase.h
+++ b/tmtcpacket/pus/TmPacketBase.h
@@ -1,8 +1,8 @@
-#ifndef TMPACKETBASE_H_
-#define TMPACKETBASE_H_
+#ifndef TMTCPACKET_PUS_TMPACKETBASE_H_
+#define TMTCPACKET_PUS_TMPACKETBASE_H_
 
+#include "../SpacePacketBase.h"
 #include "../../timemanager/TimeStamperIF.h"
-#include "../../tmtcpacket/SpacePacketBase.h"
 #include "../../timemanager/Clock.h"
 #include "../../objectmanager/SystemObjectIF.h"
 
@@ -14,7 +14,7 @@ void setStaticFrameworkObjectIds();
  * This struct defines a byte-wise structured PUS TM Data Field Header.
  * Any optional fields in the header must be added or removed here.
  * Currently, no Destination field is present, but an eigth-byte representation
- * for a time tag [TBD].
+ * for a time tag.
  * @ingroup tmtcpackets
  */
 struct PUSTmDataFieldHeader {
@@ -40,7 +40,7 @@ struct TmPacketPointer {
 /**
  * This class is the basic data handler for any ECSS PUS Telemetry packet.
  *
- * In addition to \SpacePacketBase, the class provides methods to handle
+ * In addition to #SpacePacketBase, the class provides methods to handle
  * the standardized entries of the PUS TM Packet Data Field Header.
  * It does not contain the packet data itself but a pointer to the
  * data must be set on instantiation. An invalid pointer may cause
@@ -54,29 +54,27 @@ public:
 	/**
 	 * This constant defines the minimum size of a valid PUS Telemetry Packet.
 	 */
-	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTmDataFieldHeader) + 2); //!< Minimum size of a valid PUS Telemetry Packet.
-	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
-	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000; //!< First byte of secondary header for PUS-A packets.
+	static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
+	        sizeof(PUSTmDataFieldHeader) + 2);
+	//! Maximum size of a TM Packet in this mission.
+	//! TODO: Make this dependant on a config variable.
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
+	//! First byte of secondary header for PUS-A packets.
+	//! TODO: Maybe also support PUS-C via config?
+	static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000;
+
 	/**
 	 * This is the default constructor.
 	 * It sets its internal data pointer to the address passed and also
 	 * forwards the data pointer to the parent SpacePacketBase class.
 	 * @param set_address	The position where the packet data lies.
 	 */
-	TmPacketBase( uint8_t* set_data );
+	TmPacketBase( uint8_t* setData );
 	/**
 	 * This is the empty default destructor.
 	 */
 	virtual ~TmPacketBase();
-	/**
-	 * Initializes the Tm Packet header.
-	 * Does set the timestamp (to now), but not the error control field.
-	 * @param apid APID used.
-	 * @param service	PUS Service
-	 * @param subservice PUS Subservice
-	 * @param packetSubcounter Additional subcounter used.
-	 */
-	void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packetSubcounter);
+
 	/**
 	 * This is a getter for the packet's PUS Service ID, which is the second
 	 * byte of the Data Field Header.
@@ -106,11 +104,14 @@ public:
 	 */
 	uint16_t getSourceDataSize();
 
-	/**
-	 * In case data was filled manually (almost never the case).
-	 * @param size Size of source data (without CRC and data filed header!).
-	 */
-	void setSourceDataSize(uint16_t size);
+    /**
+     * With this method, the Error Control Field is updated to match the
+     * current content of the packet. This method is not protected because
+     * a recalculation by the user might be necessary when manipulating fields
+     * like the sequence count.
+     */
+    void setErrorControl();
+
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *
@@ -120,35 +121,15 @@ public:
 	 * @return	The PUS Error Control
 	 */
 	uint16_t getErrorControl();
-	/**
-	 * With this method, the Error Control Field is updated to match the
-	 * current content of the packet.
-	 */
-	void setErrorControl();
-	/**
-	 * This sets the source data. It copies the provided data to
-	 * the internal TmPacketPointer source data location.
-	 * @param sourceData
-	 * @param sourceSize
-	 */
-	void setSourceData(uint8_t* sourceData, size_t sourceSize);
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 *
-	 * This call overwrites the parent's setData method to set both its
-	 * \c tc_data pointer and the parent's \c data pointer.
-	 *
-	 * @param p_data	A pointer to another PUS Telemetry Packet.
-	 */
-	void setData( const uint8_t* p_Data );
+
 	/**
 	 * This is a debugging helper method that prints the whole packet content
 	 * to the screen.
 	 */
 	void print();
 	/**
-	 * Interprets the "time"-field in the secondary header and returns it in timeval format.
+	 * Interprets the "time"-field in the secondary header and returns it in
+	 * timeval format.
 	 * @return Converted timestamp of packet.
 	 */
 	ReturnValue_t getPacketTime(timeval* timestamp) const;
@@ -158,7 +139,7 @@ public:
 	 */
 	uint8_t* getPacketTimeRaw() const;
 
-	uint32_t getTimestampSize() const;
+	size_t getTimestampSize() const;
 
 protected:
 	/**
@@ -167,20 +148,49 @@ protected:
 	 *
 	 * To be hardware-safe, all elements are of byte size.
 	 */
-	TmPacketPointer* tm_data;
+	TmPacketPointer* tmData;
 	/**
 	 * The timeStamper is responsible for adding a timestamp to the packet.
 	 * It is initialized lazy.
 	 */
 	static TimeStamperIF* timeStamper;
+	//! The ID to use when looking for a time stamper.
+	static object_id_t timeStamperId;
 
-	static object_id_t timeStamperId; //!< The ID to use when looking for a time stamper.
-	/**
-	 * Checks if a time stamper is available and tries to set it if not.
-	 * @return Returns false if setting failed.
-	 */
-	bool checkAndSetStamper();
+    /**
+     * Initializes the Tm Packet header.
+     * Does set the timestamp (to now), but not the error control field.
+     * @param apid APID used.
+     * @param service   PUS Service
+     * @param subservice PUS Subservice
+     * @param packetSubcounter Additional subcounter used.
+     */
+    void initializeTmPacket(uint16_t apid, uint8_t service, uint8_t subservice,
+            uint8_t packetSubcounter);
+
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     *
+     * This call overwrites the parent's setData method to set both its
+     * @c tc_data pointer and the parent's @c data pointer.
+     *
+     * @param p_data    A pointer to another PUS Telemetry Packet.
+     */
+    void setData( const uint8_t* pData );
+
+    /**
+     * In case data was filled manually (almost never the case).
+     * @param size Size of source data (without CRC and data filed header!).
+     */
+    void setSourceDataSize(uint16_t size);
+
+    /**
+     * Checks if a time stamper is available and tries to set it if not.
+     * @return Returns false if setting failed.
+     */
+    bool checkAndSetStamper();
 };
 
 
-#endif /* TMPACKETBASE_H_ */
+#endif /* TMTCPACKET_PUS_TMPACKETBASE_H_ */
diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp
index c7c495ae..18e9dda1 100644
--- a/tmtcpacket/pus/TmPacketMinimal.cpp
+++ b/tmtcpacket/pus/TmPacketMinimal.cpp
@@ -1,7 +1,7 @@
-#include "../../tmtcpacket/pus/TmPacketMinimal.h"
+#include "TmPacketMinimal.h"
 #include <stddef.h>
 #include <time.h>
-#include "../../tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+#include "PacketTimestampInterpreterIF.h"
 
 TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) {
 	this->tm_data = (TmPacketMinimalPointer*)set_data;

From d1a399a1a8c55a83a932cd326fea87141ddf9d44 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 19:46:27 +0100
Subject: [PATCH 0934/1292] tm packet store update

---
 tmtcpacket/pus/TmPacketStored.cpp |  46 ++++++-----
 tmtcpacket/pus/TmPacketStored.h   | 123 +++++++++++++++---------------
 2 files changed, 84 insertions(+), 85 deletions(-)

diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 4cf76589..0fb789aa 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -3,28 +3,30 @@
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tmtcservices/TmTcMessage.h"
+
 #include <cstring>
 
+StorageManagerIF *TmPacketStored::store = nullptr;
+InternalErrorReporterIF *TmPacketStored::internalErrorReporter = nullptr;
+
 TmPacketStored::TmPacketStored(store_address_t setAddress) :
-		TmPacketBase(NULL), storeAddress(setAddress) {
+		TmPacketBase(nullptr), storeAddress(setAddress) {
 	setStoreAddress(storeAddress);
 }
 
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		size_t size, const uint8_t *headerData, size_t headerSize) :
+		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
-	uint8_t *pData = NULL;
+	uint8_t *pData = nullptr;
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
 
-	if (returnValue != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "TmPacketStored::TmPacketStored: "
-				"Issue getting free storage" << std::endl;
+	if (returnValue != store->RETURN_OK) {
 		checkAndReportLostTm();
 		return;
 	}
@@ -36,13 +38,12 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
 }
 
-// todo: Endianness flags as optional parameter?
 TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
 		SerializeIF *header) :
 		TmPacketBase(NULL) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (!checkAndSetStore()) {
+	if (not checkAndSetStore()) {
 		return;
 	}
 	size_t sourceDataSize = 0;
@@ -81,29 +82,29 @@ store_address_t TmPacketStored::getStoreAddress() {
 void TmPacketStored::deletePacket() {
 	store->deleteData(storeAddress);
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(NULL);
+	setData(nullptr);
 }
 
 void TmPacketStored::setStoreAddress(store_address_t setAddress) {
 	storeAddress = setAddress;
-	const uint8_t *temp_data = NULL;
-	size_t temp_size;
-	if (!checkAndSetStore()) {
+	const uint8_t* tempData = nullptr;
+	size_t tempSize;
+	if (not checkAndSetStore()) {
 		return;
 	}
-	ReturnValue_t status = store->getData(storeAddress, &temp_data, &temp_size);
+	ReturnValue_t status = store->getData(storeAddress, &tempData, &tempSize);
 	if (status == StorageManagerIF::RETURN_OK) {
-		setData(temp_data);
+		setData(tempData);
 	} else {
-		setData(NULL);
+		setData(nullptr);
 		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
 	}
 }
 
 bool TmPacketStored::checkAndSetStore() {
-	if (store == NULL) {
+	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == NULL) {
+		if (store == nullptr) {
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
 			return false;
@@ -112,12 +113,9 @@ bool TmPacketStored::checkAndSetStore() {
 	return true;
 }
 
-StorageManagerIF *TmPacketStored::store = NULL;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
-
 ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == NULL) {
+	if (getWholeData() == nullptr) {
 		//SHOULDDO: More decent code.
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -137,11 +135,11 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
 }
 
 void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == NULL) {
+	if (internalErrorReporter == nullptr) {
 		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 				objects::INTERNAL_ERROR_REPORTER);
 	}
-	if (internalErrorReporter != NULL) {
+	if (internalErrorReporter != nullptr) {
 		internalErrorReporter->lostTm();
 	}
 }
diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h
index 81a6f6e5..b231407d 100644
--- a/tmtcpacket/pus/TmPacketStored.h
+++ b/tmtcpacket/pus/TmPacketStored.h
@@ -1,7 +1,8 @@
-#ifndef FSFW_TMTCPACKET_TMPACKETSTORED_H_
-#define FSFW_TMTCPACKET_TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
 
 #include "TmPacketBase.h"
+
 #include "../../serialize/SerializeIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
 #include "../../internalError/InternalErrorReporterIF.h"
@@ -18,6 +19,64 @@
  *	@ingroup tmtcpackets
  */
 class TmPacketStored : public TmPacketBase {
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TmPacketStored( store_address_t setAddress );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet.
+	 * The Application data is passed in two parts, first a header, then a
+	 * data field. This allows building a Telemetry Packet from two separate
+	 * data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the
+	 * 						Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field,
+	 * 						 will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+			uint32_t size = 0, const uint8_t* headerData = nullptr,
+			uint32_t headerSize = 0);
+	/**
+	 * Another ctor to directly pass structured content and header data to the
+	 * packet to avoid additional buffers.
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+			uint8_t packet_counter, SerializeIF* content,
+			SerializeIF* header = nullptr);
+	/**
+	 * This is a getter for the current store address of the packet.
+	 * @return	The current store address. The (raw) value is
+	 * 			@c StorageManagerIF::INVALID_ADDRESS if
+	 * 			the packet is not linked.
+	 */
+	store_address_t getStoreAddress();
+	/**
+	 * With this call, the packet is deleted.
+	 * It removes itself from the store and sets its data pointer to NULL.
+	 */
+	void deletePacket();
+	/**
+	 * With this call, a packet can be linked to another store. This is useful
+	 * if the packet is a class member and used for more than one packet.
+	 * @param setAddress	The new packet id to link to.
+	 */
+	void setStoreAddress( store_address_t setAddress );
+
+	ReturnValue_t sendPacket( MessageQueueId_t destination,
+			MessageQueueId_t sentFrom, bool doErrorReporting = true );
 private:
 	/**
 	 * This is a pointer to the store all instances of the class use.
@@ -43,65 +102,7 @@ private:
 	bool checkAndSetStore();
 
 	void checkAndReportLostTm();
-public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStored( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * The Application data is passed in two parts, first a header, then a
-	 * data field. This allows building a Telemetry
-	 * Packet from two separate data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the Application
-	 * 						Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field; will be
-	 * 						copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
-			size_t size = 0, const uint8_t* headerData = nullptr,
-			size_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the
-	 * packet to avoid additional buffers.
-	 */
-	TmPacketStored(uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter, SerializeIF* content,
-			SerializeIF* header = nullptr);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return
-	 * The current store address. The (raw) value is
-	 * @c StorageManagerIF::INVALID_ADDRESS if the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress(store_address_t setAddress);
-
-	ReturnValue_t sendPacket(MessageQueueId_t destination,
-			MessageQueueId_t sentFrom, bool doErrorReporting = true);
 };
 
 
-#endif /* FSFW_TMTCPACKET_TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_ */

From dcb24360d85b94a8124e697c3b5640c8dc220dd1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 20:17:50 +0100
Subject: [PATCH 0935/1292] form improvements taken over

---
 tmtcpacket/SpacePacketBase.cpp |  4 ++--
 tmtcpacket/SpacePacketBase.h   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp
index 044ce510..e13af8d0 100644
--- a/tmtcpacket/SpacePacketBase.cpp
+++ b/tmtcpacket/SpacePacketBase.cpp
@@ -1,6 +1,6 @@
+#include "SpacePacketBase.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/SpacePacketBase.h"
-#include <string.h>
+#include <cstring>
 
 SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
 	this->data = (SpacePacketPointer*) set_address;
diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h
index c7a63ae6..19cbd074 100644
--- a/tmtcpacket/SpacePacketBase.h
+++ b/tmtcpacket/SpacePacketBase.h
@@ -1,7 +1,7 @@
-#ifndef SPACEPACKETBASE_H_
-#define SPACEPACKETBASE_H_
+#ifndef FSFW_TMTCPACKET_SPACEPACKETBASE_H_
+#define FSFW_TMTCPACKET_SPACEPACKETBASE_H_
 
-#include "../tmtcpacket/ccsds_header.h"
+#include "ccsds_header.h"
 #include <cstddef>
 
 /**
@@ -82,7 +82,8 @@ public:
 	 */
 	bool isTelecommand( void );
 
-	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount = 0);
+	void initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader,
+	        uint16_t apid, uint16_t sequenceCount = 0);
 	/**
 	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
 	 *  which is checked with this method.
@@ -174,4 +175,4 @@ public:
 
 };
 
-#endif /* SPACEPACKETBASE_H_ */
+#endif /* FSFW_TMTCPACKET_SPACEPACKETBASE_H_ */

From 3244487eaec76a8cf014d35df062daacc24edf41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 20:18:58 +0100
Subject: [PATCH 0936/1292] slight improvements

---
 tmtcpacket/SpacePacket.cpp | 4 ++--
 tmtcpacket/SpacePacket.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp
index 2bf6e3dc..b8ba27e9 100644
--- a/tmtcpacket/SpacePacket.cpp
+++ b/tmtcpacket/SpacePacket.cpp
@@ -1,6 +1,6 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../tmtcpacket/ccsds_header.h"
-#include "../tmtcpacket/SpacePacket.h"
+#include "ccsds_header.h"
+#include "SpacePacket.h"
 #include <string.h>
 
 SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ):
diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h
index ea1d0468..49dd5ae5 100644
--- a/tmtcpacket/SpacePacket.h
+++ b/tmtcpacket/SpacePacket.h
@@ -1,7 +1,7 @@
 #ifndef SPACEPACKET_H_
 #define SPACEPACKET_H_
 
-#include "../tmtcpacket/SpacePacketBase.h"
+#include "SpacePacketBase.h"
 
 /**
  * The SpacePacket class is a representation of a simple CCSDS Space Packet

From ea04e7d4d644c7c50faf862902fceafb8490d994 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:13:00 +0100
Subject: [PATCH 0937/1292] removed catch2

---
 unittest/catch2/LICENSE.txt                  |    23 -
 unittest/catch2/catch.hpp                    | 17618 -----------------
 unittest/catch2/catch_reporter_automake.hpp  |    62 -
 unittest/catch2/catch_reporter_sonarqube.hpp |   181 -
 unittest/catch2/catch_reporter_tap.hpp       |   253 -
 unittest/catch2/catch_reporter_teamcity.hpp  |   219 -
 6 files changed, 18356 deletions(-)
 delete mode 100644 unittest/catch2/LICENSE.txt
 delete mode 100644 unittest/catch2/catch.hpp
 delete mode 100644 unittest/catch2/catch_reporter_automake.hpp
 delete mode 100644 unittest/catch2/catch_reporter_sonarqube.hpp
 delete mode 100644 unittest/catch2/catch_reporter_tap.hpp
 delete mode 100644 unittest/catch2/catch_reporter_teamcity.hpp

diff --git a/unittest/catch2/LICENSE.txt b/unittest/catch2/LICENSE.txt
deleted file mode 100644
index 36b7cd93..00000000
--- a/unittest/catch2/LICENSE.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/unittest/catch2/catch.hpp b/unittest/catch2/catch.hpp
deleted file mode 100644
index 51618b38..00000000
--- a/unittest/catch2/catch.hpp
+++ /dev/null
@@ -1,17618 +0,0 @@
-/*
- *  Catch v2.11.3
- *  Generated: 2020-03-19 13:44:21.042491
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-// start catch.hpp
-
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 11
-#define CATCH_VERSION_PATCH 3
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-// start catch_suppress_warnings.h
-
-#ifdef __clang__
-#   ifdef __ICC // icpc defines the __clang__ macro
-#       pragma warning(push)
-#       pragma warning(disable: 161 1682)
-#   else // __ICC
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wswitch-enum"
-#       pragma clang diagnostic ignored "-Wcovered-switch-default"
-#    endif
-#elif defined __GNUC__
-     // Because REQUIREs trigger GCC's -Wparentheses, and because still
-     // supported version of g++ have only buggy support for _Pragmas,
-     // Wparentheses have to be suppressed globally.
-#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
-
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wpadded"
-#endif
-// end catch_suppress_warnings.h
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#  define CATCH_CONFIG_ALL_PARTS
-#endif
-
-// In the impl file, we want to have access to all parts of the headers
-// Can also be used to sanely support PCHs
-#if defined(CATCH_CONFIG_ALL_PARTS)
-#  define CATCH_CONFIG_EXTERNAL_INTERFACES
-#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#    undef CATCH_CONFIG_DISABLE_MATCHERS
-#  endif
-#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  endif
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-// start catch_platform.h
-
-#ifdef __APPLE__
-# include <TargetConditionals.h>
-# if TARGET_OS_OSX == 1
-#  define CATCH_PLATFORM_MAC
-# elif TARGET_OS_IPHONE == 1
-#  define CATCH_PLATFORM_IPHONE
-# endif
-
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
-#  define CATCH_PLATFORM_WINDOWS
-#endif
-
-// end catch_platform.h
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// start catch_user_interfaces.h
-
-namespace Catch {
-    unsigned int rngSeed();
-}
-
-// end catch_user_interfaces.h
-// start catch_tag_alias_autoregistrar.h
-
-// start catch_common.h
-
-// start catch_compiler_capabilities.h
-
-// Detect a number of compiler features - by compiler
-// The following features are defined:
-//
-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
-// ****************
-// Note to maintainers: if new toggles are added please document them
-// in configuration.md, too
-// ****************
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-#ifdef __cplusplus
-
-#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
-#    define CATCH_CPP14_OR_GREATER
-#  endif
-
-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
-#endif
-
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#endif
-
-#if defined(__clang__)
-
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
-    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
-    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#endif
-
-#ifdef __OS400__
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#       define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Android somehow still does not support std::to_string
-#if defined(__ANDROID__)
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Not all Windows environments support SEH properly
-#if defined(__MINGW32__)
-#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// PS4
-#if defined(__ORBIS__)
-#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Cygwin
-#ifdef __CYGWIN__
-
-// Required for some versions of Cygwin to declare gettimeofday
-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
-#   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
-
-#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-
-# endif
-#endif // __CYGWIN__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#if defined(_MSC_VER)
-
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
-
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-
-// Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
-#    define CATCH_CONFIG_COLOUR_NONE
-#  else
-#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
-#  endif
-
-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
-#endif // _MSC_VER
-
-#if defined(_REENTRANT) || defined(_MSC_VER)
-// Enable async processing, as -pthread is specified or no additional linking is required
-# define CATCH_INTERNAL_CONFIG_USE_ASYNC
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// Check if we are compiled with -fno-exceptions or equivalent
-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
-#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// DJGPP
-#ifdef __DJGPP__
-#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
-#endif // __DJGPP__
-
-////////////////////////////////////////////////////////////////////////////////
-// Embarcadero C++Build
-#if defined(__BORLANDC__)
-    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Use of __COUNTER__ is suppressed during code analysis in
-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
-// handled by it.
-// Otherwise all supported compilers support COUNTER macro,
-// but user still might want to turn it off
-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
-    #define CATCH_INTERNAL_CONFIG_COUNTER
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
-#   define CATCH_CONFIG_COUNTER
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
-#   define CATCH_CONFIG_WINDOWS_SEH
-#endif
-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#   define CATCH_CONFIG_POSIX_SIGNALS
-#endif
-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
-#   define CATCH_CONFIG_WCHAR
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
-#    define CATCH_CONFIG_CPP11_TO_STRING
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-
-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
-#  define CATCH_CONFIG_NEW_CAPTURE
-#endif
-
-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-#  define CATCH_CONFIG_POLYFILL_ISNAN
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
-#  define CATCH_CONFIG_USE_ASYNC
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
-#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-#define CATCH_TRY if ((true))
-#define CATCH_CATCH_ALL if ((false))
-#define CATCH_CATCH_ANON(type) if ((false))
-#else
-#define CATCH_TRY try
-#define CATCH_CATCH_ALL catch (...)
-#define CATCH_CATCH_ANON(type) catch (type)
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#endif
-
-// end catch_compiler_capabilities.h
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#ifdef CATCH_CONFIG_COUNTER
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
-#else
-#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-#endif
-
-#include <iosfwd>
-#include <string>
-#include <cstdint>
-
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
-namespace Catch {
-
-    struct CaseSensitive { enum Choice {
-        Yes,
-        No
-    }; };
-
-    class NonCopyable {
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-
-    protected:
-        NonCopyable();
-        virtual ~NonCopyable();
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo() = delete;
-        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
-        :   file( _file ),
-            line( _line )
-        {}
-
-        SourceLineInfo( SourceLineInfo const& other )            = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
-        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
-        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
-
-        bool empty() const noexcept { return file[0] == '\0'; }
-        bool operator == ( SourceLineInfo const& other ) const noexcept;
-        bool operator < ( SourceLineInfo const& other ) const noexcept;
-
-        char const* file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // Bring in operator<< from global namespace into Catch namespace
-    // This is necessary because the overload of operator<< above makes
-    // lookup stop at namespace Catch
-    using ::operator<<;
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() const;
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO \
-    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-// end catch_common.h
-namespace Catch {
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_tag_alias_autoregistrar.h
-// start catch_test_registry.h
-
-// start catch_interfaces_testcase.h
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestInvoker {
-        virtual void invoke () const = 0;
-        virtual ~ITestInvoker();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
-    };
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-}
-
-// end catch_interfaces_testcase.h
-// start catch_stringref.h
-
-#include <cstddef>
-#include <string>
-#include <iosfwd>
-#include <cassert>
-
-namespace Catch {
-
-    /// A non-owning string class (similar to the forthcoming std::string_view)
-    /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated.
-    class StringRef {
-    public:
-        using size_type = std::size_t;
-        using const_iterator = const char*;
-
-    private:
-        static constexpr char const* const s_empty = "";
-
-        char const* m_start = s_empty;
-        size_type m_size = 0;
-
-    public: // construction
-        constexpr StringRef() noexcept = default;
-
-        StringRef( char const* rawChars ) noexcept;
-
-        constexpr StringRef( char const* rawChars, size_type size ) noexcept
-        :   m_start( rawChars ),
-            m_size( size )
-        {}
-
-        StringRef( std::string const& stdString ) noexcept
-        :   m_start( stdString.c_str() ),
-            m_size( stdString.size() )
-        {}
-
-        explicit operator std::string() const {
-            return std::string(m_start, m_size);
-        }
-
-    public: // operators
-        auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != (StringRef const& other) const noexcept -> bool {
-            return !(*this == other);
-        }
-
-        auto operator[] ( size_type index ) const noexcept -> char {
-            assert(index < m_size);
-            return m_start[index];
-        }
-
-    public: // named queries
-        constexpr auto empty() const noexcept -> bool {
-            return m_size == 0;
-        }
-        constexpr auto size() const noexcept -> size_type {
-            return m_size;
-        }
-
-        // Returns the current start pointer. If the StringRef is not
-        // null-terminated, throws std::domain_exception
-        auto c_str() const -> char const*;
-
-    public: // substrings and searches
-        // Returns a substring of [start, start + length).
-        // If start + length > size(), then the substring is [start, size()).
-        // If start > size(), then the substring is empty.
-        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
-
-        // Returns the current start pointer. May not be null-terminated.
-        auto data() const noexcept -> char const*;
-
-        constexpr auto isNullTerminated() const noexcept -> bool {
-            return m_start[m_size] == '\0';
-        }
-
-    public: // iterators
-        constexpr const_iterator begin() const { return m_start; }
-        constexpr const_iterator end() const { return m_start + m_size; }
-    };
-
-    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
-    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
-
-    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
-        return StringRef( rawChars, size );
-    }
-} // namespace Catch
-
-constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
-    return Catch::StringRef( rawChars, size );
-}
-
-// end catch_stringref.h
-// start catch_preprocessor.hpp
-
-
-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
-
-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
-// MSVC needs more evaluations
-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
-#else
-#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
-#endif
-
-#define CATCH_REC_END(...)
-#define CATCH_REC_OUT
-
-#define CATCH_EMPTY()
-#define CATCH_DEFER(id) id CATCH_EMPTY()
-
-#define CATCH_REC_GET_END2() 0, CATCH_REC_END
-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
-#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
-
-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
-
-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
-
-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
-// and passes userdata as the first parameter to each invocation,
-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
-#else
-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
-#endif
-
-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
-
-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
-#else
-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
-#endif
-
-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
-    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
-
-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6)
-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-
-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-
-#define INTERNAL_CATCH_TYPE_GEN\
-    template<typename...> struct TypeList {};\
-    template<typename...Ts>\
-    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
-    template<template<typename...> class...> struct TemplateTypeList{};\
-    template<template<typename...> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
-    template<typename...>\
-    struct append;\
-    template<typename...>\
-    struct rewrap;\
-    template<template<typename...> class, typename...>\
-    struct create;\
-    template<template<typename...> class, typename>\
-    struct convert;\
-    \
-    template<typename T> \
-    struct append<T> { using type = T; };\
-    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
-    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
-    template< template<typename...> class L1, typename...E1, typename...Rest>\
-    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
-    \
-    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
-    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
-    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
-    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
-    \
-    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
-    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
-    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
-    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
-
-#define INTERNAL_CATCH_NTTP_1(signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
-    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
-    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
-    \
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
-    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
-    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
-    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
-    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    static void TestName()
-
-#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
-    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
-    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
-    template<typename TestType> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
-        void test();\
-    }
-
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
-    template<typename TestType> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
-    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
-    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define INTERNAL_CATCH_NTTP_0
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
-#else
-#define INTERNAL_CATCH_NTTP_0(signature)
-#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
-#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
-#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
-#endif
-
-// end catch_preprocessor.hpp
-// start catch_meta.hpp
-
-
-#include <type_traits>
-
-namespace Catch {
-    template<typename T>
-    struct always_false : std::false_type {};
-
-    template <typename> struct true_given : std::true_type {};
-    struct is_callable_tester {
-        template <typename Fun, typename... Args>
-        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-        template <typename...>
-        std::false_type static test(...);
-    };
-
-    template <typename T>
-    struct is_callable;
-
-    template <typename Fun, typename... Args>
-    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here. Also *_t format is preferred over
-    // typename *::type format.
-    template <typename Func, typename U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
-#else
-    template <typename Func, typename U>
-    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
-#endif
-
-} // namespace Catch
-
-namespace mpl_{
-    struct na;
-}
-
-// end catch_meta.hpp
-namespace Catch {
-
-template<typename C>
-class TestInvokerAsMethod : public ITestInvoker {
-    void (C::*m_testAsMethod)();
-public:
-    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
-
-    void invoke() const override {
-        C obj;
-        (obj.*m_testAsMethod)();
-    }
-};
-
-auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
-
-template<typename C>
-auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
-    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
-}
-
-struct NameAndTags {
-    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
-    StringRef name;
-    StringRef tags;
-};
-
-struct AutoReg : NonCopyable {
-    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
-    ~AutoReg();
-};
-
-} // end namespace Catch
-
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
-        namespace{                        \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test();              \
-            };                            \
-        }                                 \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
-        namespace{                                                                                  \
-            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        }                                                                                           \
-        }                                                                                           \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-    #endif
-
-    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-    #else
-        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
-            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-    #endif
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
-        static void TestName(); \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        void TestName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestName{\
-                TestName(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-            return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
-        template<typename TestType> static void TestFuncName();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
-            INTERNAL_CATCH_TYPE_GEN                                                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
-            template<typename... Types>                               \
-            struct TestName {                                         \
-                void reg_tests() {                                          \
-                    int index = 0;                                    \
-                    using expander = int[];                           \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */\
-                }                                                     \
-            };                                                        \
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }                                                             \
-        }                                                             \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFuncName()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> static void TestFunc();       \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
-        INTERNAL_CATCH_TYPE_GEN\
-        template<typename... Types>                               \
-        struct TestName {                                         \
-            void reg_tests() {                                          \
-                int index = 0;                                    \
-                using expander = int[];                           \
-                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */\
-            }                                                     \
-        };\
-        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
-                using TestInit = typename convert<TestName, TmplList>::type; \
-                TestInit t;                                           \
-                t.reg_tests();                                        \
-                return 0;                                             \
-            }();                                                      \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
-        template<typename TestType>                                   \
-        static void TestFunc()
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
-
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
-            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types> \
-            struct TestNameClass{\
-                TestNameClass(){\
-                    int index = 0;                                    \
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
-                    using expander = int[];\
-                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
-                return 0;\
-        }();\
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-                void test();\
-            };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
-            INTERNAL_CATCH_TYPE_GEN                  \
-            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
-                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
-                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }\
-        }\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
-#endif
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
-#else
-    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
-        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
-#endif
-
-    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-        template<typename TestType> \
-        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
-            void test();\
-        };\
-        namespace {\
-        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
-            INTERNAL_CATCH_TYPE_GEN\
-            template<typename...Types>\
-            struct TestNameClass{\
-                void reg_tests(){\
-                    int index = 0;\
-                    using expander = int[];\
-                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++, 0)... };/* NOLINT */ \
-                }\
-            };\
-            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
-                using TestInit = typename convert<TestNameClass, TmplList>::type;\
-                TestInit t;\
-                t.reg_tests();\
-                return 0;\
-            }(); \
-        }}\
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        template<typename TestType> \
-        void TestName<TestType>::test()
-
-#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
-        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
-
-// end catch_test_registry.h
-// start catch_capture.hpp
-
-// start catch_assertionhandler.h
-
-// start catch_assertioninfo.h
-
-// start catch_result_type.h
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    bool isOk( ResultWas::OfType resultType );
-    bool isJustInfo( int flags );
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x01,
-
-        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
-        FalseTest = 0x04,           // Prefix expression with !
-        SuppressFail = 0x08         // Failures are reported but do not fail the test
-    }; };
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
-
-    bool shouldContinueOnFailure( int flags );
-    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    bool shouldSuppressFailure( int flags );
-
-} // end namespace Catch
-
-// end catch_result_type.h
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-
-        // We want to delete this constructor but a compiler bug in 4.8 means
-        // the struct is then treated as non-aggregate
-        //AssertionInfo() = delete;
-    };
-
-} // end namespace Catch
-
-// end catch_assertioninfo.h
-// start catch_decomposer.h
-
-// start catch_tostring.h
-
-#include <vector>
-#include <cstddef>
-#include <type_traits>
-#include <string>
-// start catch_stream.h
-
-#include <iosfwd>
-#include <cstddef>
-#include <ostream>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    class StringRef;
-
-    struct IStream {
-        virtual ~IStream();
-        virtual std::ostream& stream() const = 0;
-    };
-
-    auto makeStream( StringRef const &filename ) -> IStream const*;
-
-    class ReusableStringStream : NonCopyable {
-        std::size_t m_index;
-        std::ostream* m_oss;
-    public:
-        ReusableStringStream();
-        ~ReusableStringStream();
-
-        auto str() const -> std::string;
-
-        template<typename T>
-        auto operator << ( T const& value ) -> ReusableStringStream& {
-            *m_oss << value;
-            return *this;
-        }
-        auto get() -> std::ostream& { return *m_oss; }
-    };
-}
-
-// end catch_stream.h
-// start catch_interfaces_enum_values_registry.h
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    struct IMutableEnumValuesRegistry {
-        virtual ~IMutableEnumValuesRegistry();
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
-            std::vector<int> intValues;
-            intValues.reserve( values.size() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-// end catch_interfaces_enum_values_registry.h
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-#include <string_view>
-#endif
-
-#ifdef __OBJC__
-// start catch_objc_arc.hpp
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-// end catch_objc_arc.hpp
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
-#endif
-
-namespace Catch {
-    namespace Detail {
-
-        extern const std::string unprintableString;
-
-        std::string rawMemoryToString( const void *object, std::size_t size );
-
-        template<typename T>
-        std::string rawMemoryToString( const T& object ) {
-          return rawMemoryToString( &object, sizeof(object) );
-        }
-
-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
-
-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e );
-
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
-            return Detail::unprintableString;
-        }
-        template<typename T>
-        typename std::enable_if<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
-            return ex.what();
-        }
-
-        template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
-            return convertUnknownEnumToString( value );
-        }
-
-#if defined(_MANAGED)
-        //! Convert a CLR string to a utf8 std::string
-        template<typename T>
-        std::string clrReferenceToString( T^ ref ) {
-            if (ref == nullptr)
-                return std::string("null");
-            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
-            cli::pin_ptr<System::Byte> p = &bytes[0];
-            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
-        }
-#endif
-
-    } // namespace Detail
-
-    // If we decide for C++14, change these to enable_if_ts
-    template <typename T, typename = void>
-    struct StringMaker {
-        template <typename Fake = T>
-        static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert(const Fake& value) {
-                ReusableStringStream rss;
-                // NB: call using the function-like syntax to avoid ambiguity with
-                // user-defined templated operator<< under clang.
-                rss.operator<<(value);
-                return rss.str();
-        }
-
-        template <typename Fake = T>
-        static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
-            convert( const Fake& value ) {
-#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
-            return Detail::convertUnstreamable(value);
-#else
-            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
-#endif
-        }
-    };
-
-    namespace Detail {
-
-        // This function dispatches all stringification requests inside of Catch.
-        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
-        template <typename T>
-        std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
-        }
-
-        template<typename E>
-        std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
-        }
-
-#if defined(_MANAGED)
-        template <typename T>
-        std::string stringify( T^ e ) {
-            return ::Catch::StringMaker<T^>::convert(e);
-        }
-#endif
-
-    } // namespace Detail
-
-    // Some predefined specializations
-
-    template<>
-    struct StringMaker<std::string> {
-        static std::string convert(const std::string& str);
-    };
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::string_view> {
-        static std::string convert(std::string_view str);
-    };
-#endif
-
-    template<>
-    struct StringMaker<char const *> {
-        static std::string convert(char const * str);
-    };
-    template<>
-    struct StringMaker<char *> {
-        static std::string convert(char * str);
-    };
-
-#ifdef CATCH_CONFIG_WCHAR
-    template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
-    };
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-    template<>
-    struct StringMaker<std::wstring_view> {
-        static std::string convert(std::wstring_view str);
-    };
-# endif
-
-    template<>
-    struct StringMaker<wchar_t const *> {
-        static std::string convert(wchar_t const * str);
-    };
-    template<>
-    struct StringMaker<wchar_t *> {
-        static std::string convert(wchar_t * str);
-    };
-#endif
-
-    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
-    //      while keeping string semantics?
-    template<int SZ>
-    struct StringMaker<char[SZ]> {
-        static std::string convert(char const* str) {
-            return ::Catch::Detail::stringify(std::string{ str });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<signed char[SZ]> {
-        static std::string convert(signed char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-    template<int SZ>
-    struct StringMaker<unsigned char[SZ]> {
-        static std::string convert(unsigned char const* str) {
-            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
-        }
-    };
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<std::byte> {
-        static std::string convert(std::byte value);
-    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-    template<>
-    struct StringMaker<int> {
-        static std::string convert(int value);
-    };
-    template<>
-    struct StringMaker<long> {
-        static std::string convert(long value);
-    };
-    template<>
-    struct StringMaker<long long> {
-        static std::string convert(long long value);
-    };
-    template<>
-    struct StringMaker<unsigned int> {
-        static std::string convert(unsigned int value);
-    };
-    template<>
-    struct StringMaker<unsigned long> {
-        static std::string convert(unsigned long value);
-    };
-    template<>
-    struct StringMaker<unsigned long long> {
-        static std::string convert(unsigned long long value);
-    };
-
-    template<>
-    struct StringMaker<bool> {
-        static std::string convert(bool b);
-    };
-
-    template<>
-    struct StringMaker<char> {
-        static std::string convert(char c);
-    };
-    template<>
-    struct StringMaker<signed char> {
-        static std::string convert(signed char c);
-    };
-    template<>
-    struct StringMaker<unsigned char> {
-        static std::string convert(unsigned char c);
-    };
-
-    template<>
-    struct StringMaker<std::nullptr_t> {
-        static std::string convert(std::nullptr_t);
-    };
-
-    template<>
-    struct StringMaker<float> {
-        static std::string convert(float value);
-        static int precision;
-    };
-
-    template<>
-    struct StringMaker<double> {
-        static std::string convert(double value);
-        static int precision;
-    };
-
-    template <typename T>
-    struct StringMaker<T*> {
-        template <typename U>
-        static std::string convert(U* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-    template <typename R, typename C>
-    struct StringMaker<R C::*> {
-        static std::string convert(R C::* p) {
-            if (p) {
-                return ::Catch::Detail::rawMemoryToString(p);
-            } else {
-                return "nullptr";
-            }
-        }
-    };
-
-#if defined(_MANAGED)
-    template <typename T>
-    struct StringMaker<T^> {
-        static std::string convert( T^ ref ) {
-            return ::Catch::Detail::clrReferenceToString(ref);
-        }
-    };
-#endif
-
-    namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
-            ReusableStringStream rss;
-            rss << "{ ";
-            if (first != last) {
-                rss << ::Catch::Detail::stringify(*first);
-                for (++first; first != last; ++first)
-                    rss << ", " << ::Catch::Detail::stringify(*first);
-            }
-            rss << " }";
-            return rss.str();
-        }
-    }
-
-#ifdef __OBJC__
-    template<>
-    struct StringMaker<NSString*> {
-        static std::string convert(NSString * nsstring) {
-            if (!nsstring)
-                return "nil";
-            return std::string("@") + [nsstring UTF8String];
-        }
-    };
-    template<>
-    struct StringMaker<NSObject*> {
-        static std::string convert(NSObject* nsObject) {
-            return ::Catch::Detail::stringify([nsObject description]);
-        }
-
-    };
-    namespace Detail {
-        inline std::string stringify( NSString* nsstring ) {
-            return StringMaker<NSString*>::convert( nsstring );
-        }
-
-    } // namespace Detail
-#endif // __OBJC__
-
-} // namespace Catch
-
-//////////////////////////////////////////////////////
-// Separate std-lib types stringification, so it can be selectively enabled
-// This means that we do not bring in
-
-#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
-#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-#endif
-
-// Separate std::pair specialization
-#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
-#include <utility>
-namespace Catch {
-    template<typename T1, typename T2>
-    struct StringMaker<std::pair<T1, T2> > {
-        static std::string convert(const std::pair<T1, T2>& pair) {
-            ReusableStringStream rss;
-            rss << "{ "
-                << ::Catch::Detail::stringify(pair.first)
-                << ", "
-                << ::Catch::Detail::stringify(pair.second)
-                << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#include <optional>
-namespace Catch {
-    template<typename T>
-    struct StringMaker<std::optional<T> > {
-        static std::string convert(const std::optional<T>& optional) {
-            ReusableStringStream rss;
-            if (optional.has_value()) {
-                rss << ::Catch::Detail::stringify(*optional);
-            } else {
-                rss << "{ }";
-            }
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
-
-// Separate std::tuple specialization
-#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
-#include <tuple>
-namespace Catch {
-    namespace Detail {
-        template<
-            typename Tuple,
-            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
-            >
-            struct TupleElementPrinter {
-            static void print(const Tuple& tuple, std::ostream& os) {
-                os << (N ? ", " : " ")
-                    << ::Catch::Detail::stringify(std::get<N>(tuple));
-                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
-            }
-        };
-
-        template<
-            typename Tuple,
-            std::size_t N
-        >
-            struct TupleElementPrinter<Tuple, N, false> {
-            static void print(const Tuple&, std::ostream&) {}
-        };
-
-    }
-
-    template<typename ...Types>
-    struct StringMaker<std::tuple<Types...>> {
-        static std::string convert(const std::tuple<Types...>& tuple) {
-            ReusableStringStream rss;
-            rss << '{';
-            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
-            rss << " }";
-            return rss.str();
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
-
-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
-#include <variant>
-namespace Catch {
-    template<>
-    struct StringMaker<std::monostate> {
-        static std::string convert(const std::monostate&) {
-            return "{ }";
-        }
-    };
-
-    template<typename... Elements>
-    struct StringMaker<std::variant<Elements...>> {
-        static std::string convert(const std::variant<Elements...>& variant) {
-            if (variant.valueless_by_exception()) {
-                return "{valueless variant}";
-            } else {
-                return std::visit(
-                    [](const auto& value) {
-                        return ::Catch::Detail::stringify(value);
-                    },
-                    variant
-                );
-            }
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
-
-namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
-    using std::end;
-
-    not_this_one begin( ... );
-    not_this_one end( ... );
-
-    template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
-    };
-
-#if defined(_MANAGED) // Managed types are never ranges
-    template <typename T>
-    struct is_range<T^> {
-        static const bool value = false;
-    };
-#endif
-
-    template<typename Range>
-    std::string rangeToString( Range const& range ) {
-        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
-    }
-
-    // Handle vector<bool> specially
-    template<typename Allocator>
-    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
-        ReusableStringStream rss;
-        rss << "{ ";
-        bool first = true;
-        for( bool b : v ) {
-            if( first )
-                first = false;
-            else
-                rss << ", ";
-            rss << ::Catch::Detail::stringify( b );
-        }
-        rss << " }";
-        return rss.str();
-    }
-
-    template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
-        static std::string convert( R const& range ) {
-            return rangeToString( range );
-        }
-    };
-
-    template <typename T, int SZ>
-    struct StringMaker<T[SZ]> {
-        static std::string convert(T const(&arr)[SZ]) {
-            return rangeToString(arr);
-        }
-    };
-
-} // namespace Catch
-
-// Separate std::chrono::duration specialization
-#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#include <ctime>
-#include <ratio>
-#include <chrono>
-
-namespace Catch {
-
-template <class Ratio>
-struct ratio_string {
-    static std::string symbol();
-};
-
-template <class Ratio>
-std::string ratio_string<Ratio>::symbol() {
-    Catch::ReusableStringStream rss;
-    rss << '[' << Ratio::num << '/'
-        << Ratio::den << ']';
-    return rss.str();
-}
-template <>
-struct ratio_string<std::atto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::femto> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::pico> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::nano> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::micro> {
-    static std::string symbol();
-};
-template <>
-struct ratio_string<std::milli> {
-    static std::string symbol();
-};
-
-    ////////////
-    // std::chrono::duration specializations
-    template<typename Value, typename Ratio>
-    struct StringMaker<std::chrono::duration<Value, Ratio>> {
-        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " s";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " m";
-            return rss.str();
-        }
-    };
-    template<typename Value>
-    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
-        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
-            ReusableStringStream rss;
-            rss << duration.count() << " h";
-            return rss.str();
-        }
-    };
-
-    ////////////
-    // std::chrono::time_point specialization
-    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
-    template<typename Clock, typename Duration>
-    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
-        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
-            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
-        }
-    };
-    // std::chrono::time_point<system_clock> specialization
-    template<typename Duration>
-    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
-            auto converted = std::chrono::system_clock::to_time_t(time_point);
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
-#else
-            std::tm* timeInfo = std::gmtime(&converted);
-#endif
-
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-    };
-}
-#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-
-#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
-namespace Catch { \
-    template<> struct StringMaker<enumName> { \
-        static std::string convert( enumName value ) { \
-            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
-            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
-        } \
-    }; \
-}
-
-#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_tostring.h
-#include <iosfwd>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#pragma warning(disable:4180) // qualifier applied to function type has no meaning
-#pragma warning(disable:4800) // Forcing result to true or false
-#endif
-
-namespace Catch {
-
-    struct ITransientExpression {
-        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
-        auto getResult() const -> bool { return m_result; }
-        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
-
-        ITransientExpression( bool isBinaryExpression, bool result )
-        :   m_isBinaryExpression( isBinaryExpression ),
-            m_result( result )
-        {}
-
-        // We don't actually need a virtual destructor, but many static analysers
-        // complain if it's not here :-(
-        virtual ~ITransientExpression();
-
-        bool m_isBinaryExpression;
-        bool m_result;
-
-    };
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
-
-    template<typename LhsT, typename RhsT>
-    class BinaryExpr  : public ITransientExpression {
-        LhsT m_lhs;
-        StringRef m_op;
-        RhsT m_rhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            formatReconstructedExpression
-                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
-        }
-
-    public:
-        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
-        :   ITransientExpression{ true, comparisonResult },
-            m_lhs( lhs ),
-            m_op( op ),
-            m_rhs( rhs )
-        {}
-
-        template<typename T>
-        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename T>
-        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<T>::value,
-            "chained comparisons are not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-    };
-
-    template<typename LhsT>
-    class UnaryExpr : public ITransientExpression {
-        LhsT m_lhs;
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            os << Catch::Detail::stringify( m_lhs );
-        }
-
-    public:
-        explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, static_cast<bool>(lhs) },
-            m_lhs( lhs )
-        {}
-    };
-
-    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
-    template<typename LhsT, typename RhsT>
-    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-    template<typename T>
-    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
-    template<typename LhsT, typename RhsT>
-    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
-    template<typename T>
-    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-    template<typename T>
-    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-    template<typename LhsT>
-    class ExprLhs {
-        LhsT m_lhs;
-    public:
-        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
-
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
-        }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "==", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
-        }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
-        }
-
-        template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator&& is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
-            static_assert(always_false<RhsT>::value,
-            "operator|| is not supported inside assertions, "
-            "wrap the expression inside parentheses, or decompose it");
-        }
-
-        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
-            return UnaryExpr<LhsT>{ m_lhs };
-        }
-    };
-
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
-    struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
-        }
-
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
-        }
-    };
-
-} // end namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// end catch_decomposer.h
-// start catch_interfaces_capture.h
-
-#include <string>
-#include <chrono>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    struct ITransientExpression;
-    struct IGeneratorTracker;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo;
-    template <typename Duration = std::chrono::duration<double, std::nano>>
-    struct BenchmarkStats;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
-        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( std::string const& error ) = 0;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// end catch_interfaces_capture.h
-namespace Catch {
-
-    struct TestFailureException{};
-    struct AssertionResultData;
-    struct IResultCapture;
-    class RunContext;
-
-    class LazyExpression {
-        friend class AssertionHandler;
-        friend struct AssertionStats;
-        friend class RunContext;
-
-        ITransientExpression const* m_transientExpression = nullptr;
-        bool m_isNegated;
-    public:
-        LazyExpression( bool isNegated );
-        LazyExpression( LazyExpression const& other );
-        LazyExpression& operator = ( LazyExpression const& ) = delete;
-
-        explicit operator bool() const;
-
-        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
-    };
-
-    struct AssertionReaction {
-        bool shouldDebugBreak = false;
-        bool shouldThrow = false;
-    };
-
-    class AssertionHandler {
-        AssertionInfo m_assertionInfo;
-        AssertionReaction m_reaction;
-        bool m_completed = false;
-        IResultCapture& m_resultCapture;
-
-    public:
-        AssertionHandler
-            (   StringRef const& macroName,
-                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
-                ResultDisposition::Flags resultDisposition );
-        ~AssertionHandler() {
-            if ( !m_completed ) {
-                m_resultCapture.handleIncomplete( m_assertionInfo );
-            }
-        }
-
-        template<typename T>
-        void handleExpr( ExprLhs<T> const& expr ) {
-            handleExpr( expr.makeUnaryExpr() );
-        }
-        void handleExpr( ITransientExpression const& expr );
-
-        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
-
-        void handleExceptionThrownAsExpected();
-        void handleUnexpectedExceptionNotThrown();
-        void handleExceptionNotThrownAsExpected();
-        void handleThrowingCallSkipped();
-        void handleUnexpectedInflightException();
-
-        void complete();
-        void setCompleted();
-
-        // query
-        auto allowThrows() const -> bool;
-    };
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
-
-} // namespace Catch
-
-// end catch_assertionhandler.h
-// start catch_message.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    StringRef const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        StringRef macroName;
-        std::string message;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const;
-        bool operator < ( MessageInfo const& other ) const;
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageStream {
-
-        template<typename T>
-        MessageStream& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        ReusableStringStream m_stream;
-    };
-
-    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type );
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-    };
-
-    class ScopedMessage {
-    public:
-        explicit ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage& duplicate ) = delete;
-        ScopedMessage( ScopedMessage&& old );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-        bool m_moved;
-    };
-
-    class Capturer {
-        std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture = getResultCapture();
-        size_t m_captured = 0;
-    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
-        ~Capturer();
-
-        void captureValue( size_t index, std::string const& value );
-
-        template<typename T>
-        void captureValues( size_t index, T const& value ) {
-            captureValue( index, Catch::Detail::stringify( value ) );
-        }
-
-        template<typename T, typename... Ts>
-        void captureValues( size_t index, T const& value, Ts const&... values ) {
-            captureValue( index, Catch::Detail::stringify(value) );
-            captureValues( index+1, values... );
-        }
-    };
-
-} // end namespace Catch
-
-// end catch_message.h
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
-#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-
-///////////////////////////////////////////////////////////////////////////////
-// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
-// macros.
-#define INTERNAL_CATCH_TRY
-#define INTERNAL_CATCH_CATCH( capturer )
-
-#else // CATCH_CONFIG_FAST_COMPILE
-
-#define INTERNAL_CATCH_TRY try
-#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
-
-#endif
-
-#define INTERNAL_CATCH_REACT( handler ) handler.complete();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
-    do { \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
-    if( !Catch::getResultCapture().lastAssertionPassed() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
-        try { \
-            static_cast<void>(__VA_ARGS__); \
-            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
-        } \
-        catch( ... ) { \
-            catchAssertionHandler.handleUnexpectedInflightException(); \
-        } \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(expr); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ) { \
-                catchAssertionHandler.handleExceptionThrownAsExpected(); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
-        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
-    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
-    varName.captureValues( 0, __VA_ARGS__ )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
-
-///////////////////////////////////////////////////////////////////////////////
-// Although this is matcher-based, it can be used with just a string
-#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_capture.hpp
-// start catch_section.h
-
-// start catch_section_info.h
-
-// start catch_totals.h
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts operator - ( Counts const& other ) const;
-        Counts& operator += ( Counts const& other );
-
-        std::size_t total() const;
-        bool allPassed() const;
-        bool allOk() const;
-
-        std::size_t passed = 0;
-        std::size_t failed = 0;
-        std::size_t failedButOk = 0;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const;
-        Totals& operator += ( Totals const& other );
-
-        Totals delta( Totals const& prevTotals ) const;
-
-        int error = 0;
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// end catch_totals.h
-#include <string>
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name );
-
-        // Deprecated
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
-
-        std::string name;
-        std::string description; // !Deprecated: this will always be empty
-        SourceLineInfo lineInfo;
-    };
-
-    struct SectionEndInfo {
-        SectionInfo sectionInfo;
-        Counts prevAssertions;
-        double durationInSeconds;
-    };
-
-} // end namespace Catch
-
-// end catch_section_info.h
-// start catch_timer.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
-    auto getEstimatedClockResolution() -> uint64_t;
-
-    class Timer {
-        uint64_t m_nanoseconds = 0;
-    public:
-        void start();
-        auto getElapsedNanoseconds() const -> uint64_t;
-        auto getElapsedMicroseconds() const -> uint64_t;
-        auto getElapsedMilliseconds() const -> unsigned int;
-        auto getElapsedSeconds() const -> double;
-    };
-
-} // namespace Catch
-
-// end catch_timer.h
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        explicit operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-// end catch_section.h
-// start catch_interfaces_exception.h
-
-// start catch_interfaces_registry_hub.h
-
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-    struct ITagAliasRegistry;
-    struct IMutableEnumValuesRegistry;
-
-    class StartupExceptionRegistry;
-
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-// end catch_interfaces_registry_hub.h
-#if defined(CATCH_CONFIG_DISABLE)
-    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
-        static std::string translatorName( signature )
-#endif
-
-#include <exception>
-#include <string>
-#include <vector>
-
-namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
-    struct IExceptionTranslator;
-    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-                try {
-                    if( it == itEnd )
-                        std::rethrow_exception(std::current_exception());
-                    else
-                        return (*it)->translate( it+1, itEnd );
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
-    static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
-    static std::string translatorName( signature )
-
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// end catch_interfaces_exception.h
-// start catch_approx.h
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    private:
-        bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
-        void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
-        void setEpsilon(double epsilon);
-
-    public:
-        explicit Approx ( double value );
-
-        static Approx custom();
-
-        Approx operator-() const;
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T const& value ) {
-            Approx approx( static_cast<double>(value) );
-            approx.m_epsilon = m_epsilon;
-            approx.m_margin = m_margin;
-            approx.m_scale = m_scale;
-            return approx;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T const& value ): Approx(static_cast<double>(value))
-        {}
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            auto lhs_v = static_cast<double>(lhs);
-            return rhs.equalityComparisonImpl(lhs_v);
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator == ( Approx const& lhs, const T& rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T const& lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T const& rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
-            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
-            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T const& newEpsilon ) {
-            double epsilonAsDouble = static_cast<double>(newEpsilon);
-            setEpsilon(epsilonAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T const& newMargin ) {
-            double marginAsDouble = static_cast<double>(newMargin);
-            setMargin(marginAsDouble);
-            return *this;
-        }
-
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T const& newScale ) {
-            m_scale = static_cast<double>(newScale);
-            return *this;
-        }
-
-        std::string toString() const;
-
-    private:
-        double m_epsilon;
-        double m_margin;
-        double m_scale;
-        double m_value;
-    };
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
-} // end namespace literals
-
-template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
-};
-
-} // end namespace Catch
-
-// end catch_approx.h
-// start catch_string_manip.h
-
-#include <string>
-#include <iosfwd>
-#include <vector>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    //! Returns a new string without whitespace at the start/end
-    std::string trim( std::string const& str );
-    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
-    StringRef trim(StringRef ref);
-
-    // !!! Be aware, returns refs into original string - make sure original string outlives them
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-}
-
-// end catch_string_manip.h
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-// start catch_capture_matchers.h
-
-// start catch_matchers.h
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            MatcherUntypedBase() = default;
-            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
-            std::string toString() const;
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        };
-
-#ifdef __clang__
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-
-#if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
-#endif
-
-#ifdef __clang__
-#    pragma clang diagnostic pop
-#endif
-
-        template<typename T>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
-
-            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<T> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (!matcher->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " and ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            bool match( ArgT const& arg ) const override {
-                for( auto matcher : m_matchers ) {
-                    if (matcher->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            std::string describe() const override {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                bool first = true;
-                for( auto matcher : m_matchers ) {
-                    if( first )
-                        first = false;
-                    else
-                        description += " or ";
-                    description += matcher->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            bool match( ArgT const& arg ) const override {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            std::string describe() const override {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename T>
-        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<T>() && *this && other;
-        }
-        template<typename T>
-        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<T>() || *this || other;
-        }
-        template<typename T>
-        MatchNotOf<T> MatcherBase<T>::operator ! () const {
-            return MatchNotOf<T>( *this );
-        }
-
-    } // namespace Impl
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-// end catch_matchers.h
-// start catch_matchers_exception.hpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-class ExceptionMessageMatcher : public MatcherBase<std::exception> {
-    std::string m_message;
-public:
-
-    ExceptionMessageMatcher(std::string const& message):
-        m_message(message)
-    {}
-
-    bool match(std::exception const& ex) const override;
-
-    std::string describe() const override;
-};
-
-} // namespace Exception
-
-Exception::ExceptionMessageMatcher Message(std::string const& message);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_exception.hpp
-// start catch_matchers_floating.h
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Floating {
-
-        enum class FloatingPointKind : uint8_t;
-
-        struct WithinAbsMatcher : MatcherBase<double> {
-            WithinAbsMatcher(double target, double margin);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_margin;
-        };
-
-        struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            uint64_t m_ulps;
-            FloatingPointKind m_type;
-        };
-
-        // Given IEEE-754 format for floats and doubles, we can assume
-        // that float -> double promotion is lossless. Given this, we can
-        // assume that if we do the standard relative comparison of
-        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
-        // the same result if we do this for floats, as if we do this for
-        // doubles that were promoted from floats.
-        struct WithinRelMatcher : MatcherBase<double> {
-            WithinRelMatcher(double target, double epsilon);
-            bool match(double const& matchee) const override;
-            std::string describe() const override;
-        private:
-            double m_target;
-            double m_epsilon;
-        };
-
-    } // namespace Floating
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
-    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
-    Floating::WithinRelMatcher WithinRel(double target, double eps);
-    // defaults epsilon to 100*numeric_limits<double>::epsilon()
-    Floating::WithinRelMatcher WithinRel(double target);
-    Floating::WithinRelMatcher WithinRel(float target, float eps);
-    // defaults epsilon to 100*numeric_limits<float>::epsilon()
-    Floating::WithinRelMatcher WithinRel(float target);
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.h
-// start catch_matchers_generic.hpp
-
-#include <functional>
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-namespace Generic {
-
-namespace Detail {
-    std::string finalizeDescription(const std::string& desc);
-}
-
-template <typename T>
-class PredicateMatcher : public MatcherBase<T> {
-    std::function<bool(T const&)> m_predicate;
-    std::string m_description;
-public:
-
-    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
-        :m_predicate(std::move(elem)),
-        m_description(Detail::finalizeDescription(descr))
-    {}
-
-    bool match( T const& item ) const override {
-        return m_predicate(item);
-    }
-
-    std::string describe() const override {
-        return m_description;
-    }
-};
-
-} // namespace Generic
-
-    // The following functions create the actual matcher objects.
-    // The user has to explicitly specify type to the function, because
-    // inferring std::function<bool(T const&)> is hard (but possible) and
-    // requires a lot of TMP.
-    template<typename T>
-    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
-        return Generic::PredicateMatcher<T>(predicate, description);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_generic.hpp
-// start catch_matchers_string.h
-
-#include <string>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
-            std::string adjustString( std::string const& str ) const;
-            std::string caseSensitivitySuffix() const;
-
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        struct StringMatcherBase : MatcherBase<std::string> {
-            StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            std::string describe() const override;
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator );
-            bool match( std::string const& source ) const override;
-        };
-
-        struct RegexMatcher : MatcherBase<std::string> {
-            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
-            bool match( std::string const& matchee ) const override;
-            std::string describe() const override;
-
-        private:
-            std::string m_regex;
-            CaseSensitive::Choice m_caseSensitivity;
-        };
-
-    } // namespace StdString
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_string.h
-// start catch_matchers_vector.h
-
-#include <algorithm>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace Vector {
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
-
-            bool match(std::vector<T> const &v) const override {
-                for (auto const& el : v) {
-                    if (el == m_comparator) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            T const& m_comparator;
-        };
-
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
-
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: see note in EqualsMatcher
-                if (m_comparator.size() > v.size())
-                    return false;
-                for (auto const& comparator : m_comparator) {
-                    auto present = false;
-                    for (const auto& el : v) {
-                        if (el == comparator) {
-                            present = true;
-                            break;
-                        }
-                    }
-                    if (!present) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            std::string describe() const override {
-                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
-            }
-
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
-
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                // !TBD: This currently works if all elements can be compared using !=
-                // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
-                // - then just call that directly
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != v[i])
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            std::vector<T> const& m_comparator;
-        };
-
-        template<typename T>
-        struct ApproxMatcher : MatcherBase<std::vector<T>> {
-
-            ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {}
-
-            bool match(std::vector<T> const &v) const override {
-                if (m_comparator.size() != v.size())
-                    return false;
-                for (std::size_t i = 0; i < v.size(); ++i)
-                    if (m_comparator[i] != approx(v[i]))
-                        return false;
-                return true;
-            }
-            std::string describe() const override {
-                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& epsilon( T const& newEpsilon ) {
-                approx.epsilon(newEpsilon);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& margin( T const& newMargin ) {
-                approx.margin(newMargin);
-                return *this;
-            }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-            ApproxMatcher& scale( T const& newScale ) {
-                approx.scale(newScale);
-                return *this;
-            }
-
-            std::vector<T> const& m_comparator;
-            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
-        };
-
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
-            }
-
-            std::string describe() const override {
-                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
-            }
-        private:
-            std::vector<T> const& m_target;
-        };
-
-    } // namespace Vector
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) {
-        return Vector::ApproxMatcher<T>( comparator );
-    }
-
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_vector.h
-namespace Catch {
-
-    template<typename ArgT, typename MatcherT>
-    class MatchExpr : public ITransientExpression {
-        ArgT const& m_arg;
-        MatcherT m_matcher;
-        StringRef m_matcherString;
-    public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
-        :   ITransientExpression{ true, matcher.match( arg ) },
-            m_arg( arg ),
-            m_matcher( matcher ),
-            m_matcherString( matcherString )
-        {}
-
-        void streamReconstructedExpression( std::ostream &os ) const override {
-            auto matcherAsString = m_matcher.toString();
-            os << Catch::Detail::stringify( m_arg ) << ' ';
-            if( matcherAsString == Detail::unprintableString )
-                os << m_matcherString;
-            else
-                os << matcherAsString;
-        }
-    };
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
-
-    template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
-        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
-    }
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
-        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
-    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        if( catchAssertionHandler.allowThrows() ) \
-            try { \
-                static_cast<void>(__VA_ARGS__ ); \
-                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
-            } \
-            catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
-            } \
-            catch( ... ) { \
-                catchAssertionHandler.handleUnexpectedInflightException(); \
-            } \
-        else \
-            catchAssertionHandler.handleThrowingCallSkipped(); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( false )
-
-// end catch_capture_matchers.h
-#endif
-// start catch_generators.hpp
-
-// start catch_interfaces_generatortracker.h
-
-
-#include <memory>
-
-namespace Catch {
-
-    namespace Generators {
-        class GeneratorUntypedBase {
-        public:
-            GeneratorUntypedBase() = default;
-            virtual ~GeneratorUntypedBase();
-            // Attempts to move the generator to the next element
-             //
-             // Returns true iff the move succeeded (and a valid element
-             // can be retrieved).
-            virtual bool next() = 0;
-        };
-        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
-
-    } // namespace Generators
-
-    struct IGeneratorTracker {
-        virtual ~IGeneratorTracker();
-        virtual auto hasGenerator() const -> bool = 0;
-        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
-        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
-    };
-
-} // namespace Catch
-
-// end catch_interfaces_generatortracker.h
-// start catch_enforce.h
-
-#include <exception>
-
-namespace Catch {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    template <typename Ex>
-    [[noreturn]]
-    void throw_exception(Ex const& e) {
-        throw e;
-    }
-#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
-    [[noreturn]]
-    void throw_exception(std::exception const& e);
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg);
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg);
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg);
-
-} // namespace Catch;
-
-#define CATCH_MAKE_MSG(...) \
-    (Catch::ReusableStringStream() << __VA_ARGS__).str()
-
-#define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
-
-#define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
-
-#define CATCH_ENFORCE( condition, ... ) \
-    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
-
-// end catch_enforce.h
-#include <memory>
-#include <vector>
-#include <cassert>
-
-#include <utility>
-#include <exception>
-
-namespace Catch {
-
-class GeneratorException : public std::exception {
-    const char* const m_msg = "";
-
-public:
-    GeneratorException(const char* msg):
-        m_msg(msg)
-    {}
-
-    const char* what() const noexcept override final;
-};
-
-namespace Generators {
-
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
-    template<typename T>
-    struct IGenerator : GeneratorUntypedBase {
-        virtual ~IGenerator() = default;
-
-        // Returns the current element of the generator
-        //
-        // \Precondition The generator is either freshly constructed,
-        // or the last call to `next()` returned true
-        virtual T const& get() const = 0;
-        using type = T;
-    };
-
-    template<typename T>
-    class SingleValueGenerator final : public IGenerator<T> {
-        T m_value;
-    public:
-        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
-
-        T const& get() const override {
-            return m_value;
-        }
-        bool next() override {
-            return false;
-        }
-    };
-
-    template<typename T>
-    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
-            "specialization, use SingleValue Generator instead.");
-        std::vector<T> m_values;
-        size_t m_idx = 0;
-    public:
-        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
-
-        T const& get() const override {
-            return m_values[m_idx];
-        }
-        bool next() override {
-            ++m_idx;
-            return m_idx < m_values.size();
-        }
-    };
-
-    template <typename T>
-    class GeneratorWrapper final {
-        std::unique_ptr<IGenerator<T>> m_generator;
-    public:
-        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
-            m_generator(std::move(generator))
-        {}
-        T const& get() const {
-            return m_generator->get();
-        }
-        bool next() {
-            return m_generator->next();
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
-    }
-    template <typename T>
-    GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
-    }
-
-    template<typename T>
-    class Generators : public IGenerator<T> {
-        std::vector<GeneratorWrapper<T>> m_generators;
-        size_t m_current = 0;
-
-        void populate(GeneratorWrapper<T>&& generator) {
-            m_generators.emplace_back(std::move(generator));
-        }
-        void populate(T&& val) {
-            m_generators.emplace_back(value(std::forward<T>(val)));
-        }
-        template<typename U>
-        void populate(U&& val) {
-            populate(T(std::forward<U>(val)));
-        }
-        template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
-            populate(std::forward<U>(valueOrGenerator));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-    public:
-        template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
-            m_generators.reserve(sizeof...(Gs));
-            populate(std::forward<Gs>(moreGenerators)...);
-        }
-
-        T const& get() const override {
-            return m_generators[m_current].get();
-        }
-
-        bool next() override {
-            if (m_current >= m_generators.size()) {
-                return false;
-            }
-            const bool current_status = m_generators[m_current].next();
-            if (!current_status) {
-                ++m_current;
-            }
-            return m_current < m_generators.size();
-        }
-    };
-
-    template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
-        return values<std::tuple<Ts...>>( tuples );
-    }
-
-    // Tag type to signal that a generator sequence should convert arguments to a specific type
-    template <typename T>
-    struct as {};
-
-    template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
-        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
-    }
-    template<typename T>
-    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
-        return Generators<T>(std::move(generator));
-    }
-    template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
-    }
-    template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
-        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
-    }
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
-
-    template<typename L>
-    // Note: The type after -> is weird, because VS2015 cannot parse
-    //       the expression used in the typedef inside, when it is in
-    //       return type. Yeah.
-    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
-        using UnderlyingType = typename decltype(generatorExpression())::type;
-
-        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
-        if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
-        }
-
-        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
-        return generator.get();
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-#define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-#define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
-
-// end catch_generators.hpp
-// start catch_generators_generic.hpp
-
-namespace Catch {
-namespace Generators {
-
-    template <typename T>
-    class TakeGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        size_t m_returned = 0;
-        size_t m_target;
-    public:
-        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target(target)
-        {
-            assert(target != 0 && "Empty generators are not allowed");
-        }
-        T const& get() const override {
-            return m_generator.get();
-        }
-        bool next() override {
-            ++m_returned;
-            if (m_returned >= m_target) {
-                return false;
-            }
-
-            const auto success = m_generator.next();
-            // If the underlying generator does not contain enough values
-            // then we cut short as well
-            if (!success) {
-                m_returned = m_target;
-            }
-            return success;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
-    }
-
-    template <typename T, typename Predicate>
-    class FilterGenerator : public IGenerator<T> {
-        GeneratorWrapper<T> m_generator;
-        Predicate m_predicate;
-    public:
-        template <typename P = Predicate>
-        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_predicate(std::forward<P>(pred))
-        {
-            if (!m_predicate(m_generator.get())) {
-                // It might happen that there are no values that pass the
-                // filter. In that case we throw an exception.
-                auto has_initial_value = next();
-                if (!has_initial_value) {
-                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
-                }
-            }
-        }
-
-        T const& get() const override {
-            return m_generator.get();
-        }
-
-        bool next() override {
-            bool success = m_generator.next();
-            if (!success) {
-                return false;
-            }
-            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
-            return success;
-        }
-    };
-
-    template <typename T, typename Predicate>
-    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
-    }
-
-    template <typename T>
-    class RepeatGenerator : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
-            "RepeatGenerator currently does not support bools"
-            "because of std::vector<bool> specialization");
-        GeneratorWrapper<T> m_generator;
-        mutable std::vector<T> m_returned;
-        size_t m_target_repeats;
-        size_t m_current_repeat = 0;
-        size_t m_repeat_index = 0;
-    public:
-        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
-            m_generator(std::move(generator)),
-            m_target_repeats(repeats)
-        {
-            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
-        }
-
-        T const& get() const override {
-            if (m_current_repeat == 0) {
-                m_returned.push_back(m_generator.get());
-                return m_returned.back();
-            }
-            return m_returned[m_repeat_index];
-        }
-
-        bool next() override {
-            // There are 2 basic cases:
-            // 1) We are still reading the generator
-            // 2) We are reading our own cache
-
-            // In the first case, we need to poke the underlying generator.
-            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
-            if (m_current_repeat == 0) {
-                const auto success = m_generator.next();
-                if (!success) {
-                    ++m_current_repeat;
-                }
-                return m_current_repeat < m_target_repeats;
-            }
-
-            // In the second case, we need to move indices forward and check that we haven't run up against the end
-            ++m_repeat_index;
-            if (m_repeat_index == m_returned.size()) {
-                m_repeat_index = 0;
-                ++m_current_repeat;
-            }
-            return m_current_repeat < m_target_repeats;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
-    }
-
-    template <typename T, typename U, typename Func>
-    class MapGenerator : public IGenerator<T> {
-        // TBD: provide static assert for mapping function, for friendly error message
-        GeneratorWrapper<U> m_generator;
-        Func m_function;
-        // To avoid returning dangling reference, we have to save the values
-        T m_cache;
-    public:
-        template <typename F2 = Func>
-        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
-            m_generator(std::move(generator)),
-            m_function(std::forward<F2>(function)),
-            m_cache(m_function(m_generator.get()))
-        {}
-
-        T const& get() const override {
-            return m_cache;
-        }
-        bool next() override {
-            const auto success = m_generator.next();
-            if (success) {
-                m_cache = m_function(m_generator.get());
-            }
-            return success;
-        }
-    };
-
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T, typename U, typename Func>
-    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
-        return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
-        );
-    }
-
-    template <typename T>
-    class ChunkGenerator final : public IGenerator<std::vector<T>> {
-        std::vector<T> m_chunk;
-        size_t m_chunk_size;
-        GeneratorWrapper<T> m_generator;
-        bool m_used_up = false;
-    public:
-        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
-            m_chunk_size(size), m_generator(std::move(generator))
-        {
-            m_chunk.reserve(m_chunk_size);
-            if (m_chunk_size != 0) {
-                m_chunk.push_back(m_generator.get());
-                for (size_t i = 1; i < m_chunk_size; ++i) {
-                    if (!m_generator.next()) {
-                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
-                    }
-                    m_chunk.push_back(m_generator.get());
-                }
-            }
-        }
-        std::vector<T> const& get() const override {
-            return m_chunk;
-        }
-        bool next() override {
-            m_chunk.clear();
-            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
-                if (!m_generator.next()) {
-                    return false;
-                }
-                m_chunk.push_back(m_generator.get());
-            }
-            return true;
-        }
-    };
-
-    template <typename T>
-    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
-        );
-    }
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_generic.hpp
-// start catch_generators_specific.hpp
-
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
-}
-
-// end catch_context.h
-// start catch_interfaces_config.h
-
-// start catch_option.hpp
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-    private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <chrono>
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
-    };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-
-        virtual bool benchmarkNoAnalysis() const = 0;
-        virtual int benchmarkSamples() const = 0;
-        virtual double benchmarkConfidenceInterval() const = 0;
-        virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
-    };
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
-
-// end catch_interfaces_config.h
-// start catch_random_number_generator.h
-
-#include <cstdint>
-
-namespace Catch {
-
-    // This is a simple implementation of C++11 Uniform Random Number
-    // Generator. It does not provide all operators, because Catch2
-    // does not use it, but it should behave as expected inside stdlib's
-    // distributions.
-    // The implementation is based on the PCG family (http://pcg-random.org)
-    class SimplePcg32 {
-        using state_type = std::uint64_t;
-    public:
-        using result_type = std::uint32_t;
-        static constexpr result_type (min)() {
-            return 0;
-        }
-        static constexpr result_type (max)() {
-            return static_cast<result_type>(-1);
-        }
-
-        // Provide some default initial state for the default constructor
-        SimplePcg32():SimplePcg32(0xed743cc4U) {}
-
-        explicit SimplePcg32(result_type seed_);
-
-        void seed(result_type seed_);
-        void discard(uint64_t skip);
-
-        result_type operator()();
-
-    private:
-        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
-
-        // In theory we also need operator<< and operator>>
-        // In practice we do not use them, so we will skip them for now
-
-        std::uint64_t m_state;
-        // This part of the state determines which "stream" of the numbers
-        // is chosen -- we take it as a constant for Catch2, so we only
-        // need to deal with seeding the main state.
-        // Picked by reading 8 bytes from `/dev/random` :-)
-        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
-    };
-
-} // end namespace Catch
-
-// end catch_random_number_generator.h
-#include <random>
-
-namespace Catch {
-namespace Generators {
-
-template <typename Float>
-class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_real_distribution<Float> m_dist;
-    Float m_current_number;
-public:
-
-    RandomFloatingGenerator(Float a, Float b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Float const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-template <typename Integer>
-class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32& m_rng;
-    std::uniform_int_distribution<Integer> m_dist;
-    Integer m_current_number;
-public:
-
-    RandomIntegerGenerator(Integer a, Integer b):
-        m_rng(rng()),
-        m_dist(a, b) {
-        static_cast<void>(next());
-    }
-
-    Integer const& get() const override {
-        return m_current_number;
-    }
-    bool next() override {
-        m_current_number = m_dist(m_rng);
-        return true;
-    }
-};
-
-// TODO: Ideally this would be also constrained against the various char types,
-//       but I don't expect users to run into that in practice.
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
-random(T a, T b) {
-    return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
-    );
-}
-
-template <typename T>
-class RangeGenerator final : public IGenerator<T> {
-    T m_current;
-    T m_end;
-    T m_step;
-    bool m_positive;
-
-public:
-    RangeGenerator(T const& start, T const& end, T const& step):
-        m_current(start),
-        m_end(end),
-        m_step(step),
-        m_positive(m_step > T(0))
-    {
-        assert(m_current != m_end && "Range start and end cannot be equal");
-        assert(m_step != T(0) && "Step size cannot be zero");
-        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
-    }
-
-    RangeGenerator(T const& start, T const& end):
-        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
-    {}
-
-    T const& get() const override {
-        return m_current;
-    }
-
-    bool next() override {
-        m_current += m_step;
-        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
-    }
-};
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
-}
-
-template <typename T>
-GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
-}
-
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container,
-          typename ResultType = typename Container::value_type>
-GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
-}
-
-} // namespace Generators
-} // namespace Catch
-
-// end catch_generators_specific.hpp
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string tagsAsString() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
-
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
-
-namespace Catch {
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public ITestInvoker {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                bool match( NSString* str ) const override {
-                    return false;
-                }
-
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
-
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
-
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
-
-// end catch_objc.hpp
-#endif
-
-// Benchmarking needs the externally-facing parts of reporters to work
-#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_external_interfaces.h
-
-// start catch_reporter_bases.hpp
-
-// start catch_interfaces_reporter.h
-
-// start catch_config.hpp
-
-// start catch_test_spec_parser.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_test_spec.h
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// start catch_wildcard_pattern.h
-
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
-
-    public:
-
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
-
-    private:
-        std::string normaliseString( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
-    };
-}
-
-// end catch_wildcard_pattern.h
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    struct IConfig;
-
-    class TestSpec {
-        class Pattern {
-        public:
-            explicit Pattern( std::string const& name );
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-            std::string const& name() const;
-        private:
-            std::string const m_name;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            explicit NamePattern( std::string const& name, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
-
-        class TagPattern : public Pattern {
-        public:
-            explicit TagPattern( std::string const& tag, std::string const& filterString );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
-
-        class ExcludedPattern : public Pattern {
-        public:
-            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
-            bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const;
-            std::string name() const;
-        };
-
-    public:
-        struct FilterMatch {
-            std::string name;
-            std::vector<TestCase const*> tests;
-        };
-        using Matches = std::vector<FilterMatch>;
-        using vectorStrings = std::vector<std::string>;
-
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
-        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
-        const vectorStrings & getInvalidArgs() const;
-
-    private:
-        std::vector<Filter> m_filters;
-        std::vector<std::string> m_invalidArgs;
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        Mode lastMode = None;
-        bool m_exclusion = false;
-        std::size_t m_pos = 0;
-        std::size_t m_realPatternPos = 0;
-        std::string m_arg;
-        std::string m_substring;
-        std::string m_patternName;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
-
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
-
-    private:
-        bool visitChar( char c );
-        void startNewMode( Mode mode );
-        bool processNoneChar( char c );
-        void processNameChar( char c );
-        bool processOtherChar( char c );
-        void endMode();
-        void escape();
-        bool isControlChar( char c ) const;
-        void saveLastMode();
-        void revertBackToLastMode();
-        void addFilter();
-        bool separate();
-
-        // Handles common preprocessing of the pattern for name/tag patterns
-        std::string preprocessPattern();
-        // Adds the current pattern as a test name
-        void addNamePattern();
-        // Adds the current pattern as a tag
-        void addTagPattern();
-
-        inline void addCharToPattern(char c) {
-            m_substring += c;
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-
-    };
-    TestSpec parseTestSpec( std::string const& arg );
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_test_spec_parser.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
-
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
-
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-
-        bool benchmarkNoAnalysis = false;
-        unsigned int benchmarkSamples = 100;
-        double benchmarkConfidenceInterval = 0.95;
-        unsigned int benchmarkResamples = 100000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
-
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
-
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
-
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
-
-    class Config : public IConfig {
-    public:
-
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
-
-        std::string const& getFilename() const;
-
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
-
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
-
-        std::vector<std::string> const& getTestsOrTags() const override;
-        std::vector<std::string> const& getSectionsToRun() const override;
-
-        TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
-
-        bool showHelp() const;
-
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
-        bool benchmarkNoAnalysis() const override;
-        int benchmarkSamples() const override;
-        double benchmarkConfidenceInterval() const override;
-        unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
-
-    private:
-
-        IStream const* openStream();
-        ConfigData m_data;
-
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
-
-} // end namespace Catch
-
-// end catch_config.hpp
-// start catch_assertionresult.h
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
-
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
-
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
-
-        std::string reconstructExpression() const;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
-
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-// end catch_assertionresult.h
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_estimate.hpp
-
- // Statistics estimates
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct Estimate {
-            Duration point;
-            Duration lower_bound;
-            Duration upper_bound;
-            double confidence_interval;
-
-            template <typename Duration2>
-            operator Estimate<Duration2>() const {
-                return { point, lower_bound, upper_bound, confidence_interval };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate.hpp
-// start catch_outlier_classification.hpp
-
-// Outlier information
-
-namespace Catch {
-    namespace Benchmark {
-        struct OutlierClassification {
-            int samples_seen = 0;
-            int low_severe = 0;     // more than 3 times IQR below Q1
-            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
-            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
-            int high_severe = 0;    // more than 3 times IQR above Q3
-
-            int total() const {
-                return low_severe + low_mild + high_mild + high_severe;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_outlier_classification.hpp
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-#include <algorithm>
-
-namespace Catch {
-
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
-
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
-
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
-
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-        bool shouldReportAllAssertions = false;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
-
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = delete;
-        AssertionStats& operator = ( AssertionStats && )     = delete;
-        virtual ~AssertionStats();
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
-
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
-
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-            return {
-                info,
-                std::move(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
-
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void reportInvalidArguments(std::string const&) {}
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        virtual void benchmarkPreparing( std::string const& ) {}
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
-        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
-        virtual void benchmarkFailed( std::string const& ) {}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
-
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
-
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
-
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
-
-    std::string serializeFilters( std::vector<std::string> const& container );
-
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        ~StreamingReporterBase() override = default;
-
-        void noMatchingTestCases(std::string const&) override {}
-
-        void reportInvalidArguments(std::string const&) override {}
-
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
-
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
-
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
-
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
-
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
-
-        private:
-            SectionInfo const& m_other;
-        };
-
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                CATCH_ERROR( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
-
-        void testCaseStarting( TestCaseInfo const& ) override {}
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
-
-        void assertionStarting(AssertionInfo const&) override {}
-
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
-
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
-        }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        void skipTest(TestCaseInfo const&) override {}
-
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
-
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
-
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved = false;
-    };
-
-    std::ostream& operator << ( std::ostream& os, Colour const& );
-
-} // end namespace Catch
-
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
-
-
-namespace Catch {
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-
-            std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public IReporterFactory {
-
-            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            std::string getDescription() const override {
-                return std::string();
-            }
-        };
-
-    public:
-
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
-
-#if !defined(CATCH_CONFIG_DISABLE)
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#else // CATCH_CONFIG_DISABLE
-
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
-
-#endif // CATCH_CONFIG_DISABLE
-
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~CompactReporter() override;
-
-        static std::string getDescription();
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
-
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
-
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& spec) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
-
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats<> const& stats) override;
-        void benchmarkFailed(std::string const& error) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
-        void testRunStarting(TestRunInfo const& _testRunInfo) override;
-    private:
-
-        void lazyPrint();
-
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
-
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
-        void printTestFilters();
-
-    private:
-        bool m_headerPrinted = false;
-    };
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
-
-// start catch_xmlwriter.h
-
-#include <vector>
-
-namespace Catch {
-    enum class XmlFormatting {
-        None = 0x00,
-        Indent = 0x01,
-        Newline = 0x02,
-    };
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
-
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
-
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
-
-            ~ScopedElement();
-
-            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-            XmlFormatting m_fmt;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
-
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
-
-        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
-
-        void writeStylesheetRef( std::string const& url );
-
-        XmlWriter& writeBlankLine();
-
-        void ensureTagClosed();
-
-    private:
-
-        void applyFormatting(XmlFormatting fmt);
-
-        void writeDeclaration();
-
-        void newlineIfNecessary();
-
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-// end catch_xmlwriter.h
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
-
-        void noMatchingTestCases(std::string const& /*spec*/) override;
-
-        void testRunStarting(TestRunInfo const& runInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEndedCumulative() override;
-
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
-
-        void writeTestCase(TestCaseNode const& testCaseNode);
-
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
-
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
-
-        ~XmlReporter() override;
-
-        static std::string getDescription();
-
-        virtual std::string getStylesheetRef() const;
-
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
-
-    public: // StreamingReporterBase
-
-        void noMatchingTestCases(std::string const& s) override;
-
-        void testRunStarting(TestRunInfo const& testInfo) override;
-
-        void testGroupStarting(GroupInfo const& groupInfo) override;
-
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
-
-        void sectionStarting(SectionInfo const& sectionInfo) override;
-
-        void assertionStarting(AssertionInfo const&) override;
-
-        bool assertionEnded(AssertionStats const& assertionStats) override;
-
-        void sectionEnded(SectionStats const& sectionStats) override;
-
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
-
-        void testRunEnded(TestRunStats const& testRunStats) override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting(BenchmarkInfo const&) override;
-        void benchmarkEnded(BenchmarkStats<> const&) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_xml.h
-
-// end catch_external_interfaces.h
-#endif
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-// start catch_benchmarking_all.hpp
-
-// A proxy header that includes all of the benchmarking headers to allow
-// concise include of the benchmarking features. You should prefer the
-// individual includes in standard use.
-
-// start catch_benchmark.hpp
-
- // Benchmark
-
-// start catch_chronometer.hpp
-
-// User-facing chronometer
-
-
-// start catch_clock.hpp
-
-// Clocks
-
-
-#include <chrono>
-#include <ratio>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Clock>
-        using ClockDuration = typename Clock::duration;
-        template <typename Clock>
-        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
-
-        template <typename Clock>
-        using TimePoint = typename Clock::time_point;
-
-        using default_clock = std::chrono::steady_clock;
-
-        template <typename Clock>
-        struct now {
-            TimePoint<Clock> operator()() const {
-                return Clock::now();
-            }
-        };
-
-        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_clock.hpp
-// start catch_optimizer.hpp
-
- // Hinting the optimizer
-
-
-#if defined(_MSC_VER)
-#   include <atomic> // atomic_thread_fence
-#endif
-
-namespace Catch {
-    namespace Benchmark {
-#if defined(__GNUC__) || defined(__clang__)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            asm volatile("" : : "g"(p) : "memory");
-        }
-        inline void keep_memory() {
-            asm volatile("" : : : "memory");
-        }
-
-        namespace Detail {
-            inline void optimizer_barrier() { keep_memory(); }
-        } // namespace Detail
-#elif defined(_MSC_VER)
-
-#pragma optimize("", off)
-        template <typename T>
-        inline void keep_memory(T* p) {
-            // thanks @milleniumbug
-            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
-        }
-        // TODO equivalent keep_memory()
-#pragma optimize("", on)
-
-        namespace Detail {
-            inline void optimizer_barrier() {
-                std::atomic_thread_fence(std::memory_order_seq_cst);
-            }
-        } // namespace Detail
-
-#endif
-
-        template <typename T>
-        inline void deoptimize_value(T&& x) {
-            keep_memory(&x);
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
-            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
-        }
-
-        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
-            std::forward<Fn>(fn) (std::forward<Args...>(args...));
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_optimizer.hpp
-// start catch_complete_invoke.hpp
-
-// Invoke with a special case for void
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            struct CompleteType { using type = T; };
-            template <>
-            struct CompleteType<void> { struct type {}; };
-
-            template <typename T>
-            using CompleteType_t = typename CompleteType<T>::type;
-
-            template <typename Result>
-            struct CompleteInvoker {
-                template <typename Fun, typename... Args>
-                static Result invoke(Fun&& fun, Args&&... args) {
-                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                }
-            };
-            template <>
-            struct CompleteInvoker<void> {
-                template <typename Fun, typename... Args>
-                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
-                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
-                    return {};
-                }
-            };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
-
-            // invoke and not return void :(
-            template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
-            }
-
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
-        } // namespace Detail
-
-        template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
-            CATCH_TRY{
-                return Detail::complete_invoke(std::forward<Fun>(fun));
-            } CATCH_CATCH_ALL{
-                getResultCapture().benchmarkFailed(translateActiveException());
-                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
-            }
-        }
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_complete_invoke.hpp
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            struct ChronometerConcept {
-                virtual void start() = 0;
-                virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
-            };
-            template <typename Clock>
-            struct ChronometerModel final : public ChronometerConcept {
-                void start() override { started = Clock::now(); }
-                void finish() override { finished = Clock::now(); }
-
-                ClockDuration<Clock> elapsed() const { return finished - started; }
-
-                TimePoint<Clock> started;
-                TimePoint<Clock> finished;
-            };
-        } // namespace Detail
-
-        struct Chronometer {
-        public:
-            template <typename Fun>
-            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
-
-            int runs() const { return k; }
-
-            Chronometer(Detail::ChronometerConcept& meter, int k)
-                : impl(&meter)
-                , k(k) {}
-
-        private:
-            template <typename Fun>
-            void measure(Fun&& fun, std::false_type) {
-                measure([&fun](int) { return fun(); }, std::true_type());
-            }
-
-            template <typename Fun>
-            void measure(Fun&& fun, std::true_type) {
-                Detail::optimizer_barrier();
-                impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
-                impl->finish();
-                Detail::optimizer_barrier();
-            }
-
-            Detail::ChronometerConcept* impl;
-            int k;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_chronometer.hpp
-// start catch_environment.hpp
-
-// Environment information
-
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct EnvironmentEstimate {
-            Duration mean;
-            OutlierClassification outliers;
-
-            template <typename Duration2>
-            operator EnvironmentEstimate<Duration2>() const {
-                return { mean, outliers };
-            }
-        };
-        template <typename Clock>
-        struct Environment {
-            using clock_type = Clock;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
-            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_environment.hpp
-// start catch_execution_plan.hpp
-
- // Execution plan
-
-
-// start catch_benchmark_function.hpp
-
- // Dumb std::function implementation for consistent call overhead
-
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-#include <memory>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T>
-            using Decay = typename std::decay<T>::type;
-            template <typename T, typename U>
-            struct is_related
-                : std::is_same<Decay<T>, Decay<U>> {};
-
-            /// We need to reinvent std::function because every piece of code that might add overhead
-            /// in a measurement context needs to have consistent performance characteristics so that we
-            /// can account for it in the measurement.
-            /// Implementations of std::function with optimizations that aren't always applicable, like
-            /// small buffer optimizations, are not uncommon.
-            /// This is effectively an implementation of std::function without any such optimizations;
-            /// it may be slow, but it is consistently slow.
-            struct BenchmarkFunction {
-            private:
-                struct callable {
-                    virtual void call(Chronometer meter) const = 0;
-                    virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
-                };
-                template <typename Fun>
-                struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
-
-                    model<Fun>* clone() const override { return new model<Fun>(*this); }
-
-                    void call(Chronometer meter) const override {
-                        call(meter, is_callable<Fun(Chronometer)>());
-                    }
-                    void call(Chronometer meter, std::true_type) const {
-                        fun(meter);
-                    }
-                    void call(Chronometer meter, std::false_type) const {
-                        meter.measure(fun);
-                    }
-
-                    Fun fun;
-                };
-
-                struct do_nothing { void operator()() const {} };
-
-                template <typename T>
-                BenchmarkFunction(model<T>* c) : f(c) {}
-
-            public:
-                BenchmarkFunction()
-                    : f(new model<do_nothing>{ {} }) {}
-
-                template <typename Fun,
-                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
-                    BenchmarkFunction(Fun&& fun)
-                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
-
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
-
-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
-                    return *this;
-                }
-
-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f.reset(that.f->clone());
-                    return *this;
-                }
-
-                void operator()(Chronometer meter) const { f->call(meter); }
-
-            private:
-                std::unique_ptr<callable> f;
-            };
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_benchmark_function.hpp
-// start catch_repeat.hpp
-
-// repeat algorithm
-
-
-#include <type_traits>
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Fun>
-            struct repeater {
-                void operator()(int k) const {
-                    for (int i = 0; i < k; ++i) {
-                        fun();
-                    }
-                }
-                Fun fun;
-            };
-            template <typename Fun>
-            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
-                return { std::forward<Fun>(fun) };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_repeat.hpp
-// start catch_run_for_at_least.hpp
-
-// Run a function for a minimum amount of time
-
-
-// start catch_measure.hpp
-
-// Measure
-
-
-// start catch_timing.hpp
-
-// Timing
-
-
-#include <tuple>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration, typename Result>
-        struct Timing {
-            Duration elapsed;
-            Result result;
-            int iterations;
-        };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_timing.hpp
-#include <utility>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
-                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
-                auto end = Clock::now();
-                auto delta = end - start;
-                return { delta, std::forward<decltype(r)>(r), 1 };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_measure.hpp
-#include <utility>
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
-                return Detail::measure<Clock>(fun, iters);
-            }
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
-                Detail::ChronometerModel<Clock> meter;
-                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
-
-                return { meter.elapsed(), std::move(result), iters };
-            }
-
-            template <typename Clock, typename Fun>
-            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
-
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
-
-            template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
-                auto iters = seed;
-                while (iters < (1 << 30)) {
-                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
-
-                    if (Timing.elapsed >= how_long) {
-                        return { Timing.elapsed, std::move(Timing.result), iters };
-                    }
-                    iters *= 2;
-                }
-                throw optimized_away_error{};
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_run_for_at_least.hpp
-#include <algorithm>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct ExecutionPlan {
-            int iterations_per_sample;
-            Duration estimated_duration;
-            Detail::BenchmarkFunction benchmark;
-            Duration warmup_time;
-            int warmup_iterations;
-
-            template <typename Duration2>
-            operator ExecutionPlan<Duration2>() const {
-                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
-            }
-
-            template <typename Clock>
-            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                // warmup a bit
-                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
-
-                std::vector<FloatDuration<Clock>> times;
-                times.reserve(cfg.benchmarkSamples());
-                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
-                    Detail::ChronometerModel<Clock> model;
-                    this->benchmark(Chronometer(model, iterations_per_sample));
-                    auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
-                    return sample_time / iterations_per_sample;
-                });
-                return times;
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_execution_plan.hpp
-// start catch_estimate_clock.hpp
-
- // Environment measurement
-
-
-// start catch_stats.hpp
-
-// Statistical analysis tools
-
-
-#include <algorithm>
-#include <functional>
-#include <vector>
-#include <iterator>
-#include <numeric>
-#include <tuple>
-#include <cmath>
-#include <utility>
-#include <cstddef>
-#include <random>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            using sample = std::vector<double>;
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
-
-            template <typename Iterator>
-            OutlierClassification classify_outliers(Iterator first, Iterator last) {
-                std::vector<double> copy(first, last);
-
-                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
-                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
-                auto iqr = q3 - q1;
-                auto los = q1 - (iqr * 3.);
-                auto lom = q1 - (iqr * 1.5);
-                auto him = q3 + (iqr * 1.5);
-                auto his = q3 + (iqr * 3.);
-
-                OutlierClassification o;
-                for (; first != last; ++first) {
-                    auto&& t = *first;
-                    if (t < los) ++o.low_severe;
-                    else if (t < lom) ++o.low_mild;
-                    else if (t > his) ++o.high_severe;
-                    else if (t > him) ++o.high_mild;
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            template <typename Iterator>
-            double mean(Iterator first, Iterator last) {
-                auto count = last - first;
-                double sum = std::accumulate(first, last, 0.);
-                return sum / count;
-            }
-
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                sample out;
-                out.reserve(resamples);
-                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
-                    std::vector<double> resampled;
-                    resampled.reserve(n);
-                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
-            template <typename Estimator, typename Iterator>
-            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
-                auto n = last - first;
-                auto second = std::next(first);
-                sample results;
-                results.reserve(n);
-
-                for (auto it = first; it != last; ++it) {
-                    std::iter_swap(it, first);
-                    results.push_back(estimator(second, last));
-                }
-
-                return results;
-            }
-
-            inline double normal_cdf(double x) {
-                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
-            }
-
-            double erfc_inv(double x);
-
-            double normal_quantile(double p);
-
-            template <typename Iterator, typename Estimator>
-            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
-                auto n_samples = last - first;
-
-                double point = estimator(first, last);
-                // Degenerate case with a single sample
-                if (n_samples == 1) return { point, point, point, confidence_level };
-
-                sample jack = jackknife(estimator, first, last);
-                double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares, sum_cubes;
-                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
-                    auto d = jack_mean - x;
-                    auto d2 = d * d;
-                    auto d3 = d2 * d;
-                    return { sqcb.first + d2, sqcb.second + d3 };
-                });
-
-                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
-                int n = static_cast<int>(resample.size());
-                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
-                // degenerate case with uniform samples
-                if (prob_n == 0) return { point, point, point, confidence_level };
-
-                double bias = normal_quantile(prob_n);
-                double z1 = normal_quantile((1. - confidence_level) / 2.);
-
-                auto cumn = [n](double x) -> int {
-                    return std::lround(normal_cdf(x) * n); };
-                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
-                double b1 = bias + z1;
-                double b2 = bias - z1;
-                double a1 = a(b1);
-                double a2 = a(b2);
-                auto lo = std::max(cumn(a1), 0);
-                auto hi = std::min(cumn(a2), n - 1);
-
-                return { point, resample[lo], resample[hi], confidence_level };
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
-            struct bootstrap_analysis {
-                Estimate<double> mean;
-                Estimate<double> standard_deviation;
-                double outlier_variance;
-            };
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_stats.hpp
-#include <algorithm>
-#include <iterator>
-#include <tuple>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Clock>
-            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(k + 1);
-                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
-
-                std::vector<double> deltas;
-                deltas.reserve(k);
-                std::transform(std::next(times.begin()), times.end(), times.begin(),
-                    std::back_inserter(deltas),
-                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
-
-                return deltas;
-            }
-
-            const auto warmup_iterations = 10000;
-            const auto warmup_time = std::chrono::milliseconds(100);
-            const auto minimum_ticks = 1000;
-            const auto warmup_seed = 10000;
-            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            const auto clock_cost_estimation_tick_limit = 100000;
-            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            const auto clock_cost_estimation_iterations = 10000;
-
-            template <typename Clock>
-            int warmup() {
-                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
-                    .iterations;
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
-                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
-                    .result;
-                return {
-                    FloatDuration<Clock>(mean(r.begin(), r.end())),
-                    classify_outliers(r.begin(), r.end()),
-                };
-            }
-            template <typename Clock>
-            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
-                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
-                auto time_clock = [](int k) {
-                    return Detail::measure<Clock>([k] {
-                        for (int i = 0; i < k; ++i) {
-                            volatile auto ignored = Clock::now();
-                            (void)ignored;
-                        }
-                    }).elapsed;
-                };
-                time_clock(1);
-                int iters = clock_cost_estimation_iterations;
-                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
-                std::vector<double> times;
-                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
-                times.reserve(nsamples);
-                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
-                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
-                });
-                return {
-                    FloatDuration<Clock>(mean(times.begin(), times.end())),
-                    classify_outliers(times.begin(), times.end()),
-                };
-            }
-
-            template <typename Clock>
-            Environment<FloatDuration<Clock>> measure_environment() {
-                static Environment<FloatDuration<Clock>>* env = nullptr;
-                if (env) {
-                    return *env;
-                }
-
-                auto iters = Detail::warmup<Clock>();
-                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
-                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
-
-                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
-                return *env;
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_estimate_clock.hpp
-// start catch_analyse.hpp
-
- // Run and analyse one benchmark
-
-
-// start catch_sample_analysis.hpp
-
-// Benchmark results
-
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <iterator>
-
-namespace Catch {
-    namespace Benchmark {
-        template <typename Duration>
-        struct SampleAnalysis {
-            std::vector<Duration> samples;
-            Estimate<Duration> mean;
-            Estimate<Duration> standard_deviation;
-            OutlierClassification outliers;
-            double outlier_variance;
-
-            template <typename Duration2>
-            operator SampleAnalysis<Duration2>() const {
-                std::vector<Duration2> samples2;
-                samples2.reserve(samples.size());
-                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
-                return {
-                    std::move(samples2),
-                    mean,
-                    standard_deviation,
-                    outliers,
-                    outlier_variance,
-                };
-            }
-        };
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_sample_analysis.hpp
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename Duration, typename Iterator>
-            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
-                if (!cfg.benchmarkNoAnalysis()) {
-                    std::vector<double> samples;
-                    samples.reserve(last - first);
-                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
-
-                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
-                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
-
-                    auto wrap_estimate = [](Estimate<double> e) {
-                        return Estimate<Duration> {
-                            Duration(e.point),
-                                Duration(e.lower_bound),
-                                Duration(e.upper_bound),
-                                e.confidence_interval,
-                        };
-                    };
-                    std::vector<Duration> samples2;
-                    samples2.reserve(samples.size());
-                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
-                    return {
-                        std::move(samples2),
-                        wrap_estimate(analysis.mean),
-                        wrap_estimate(analysis.standard_deviation),
-                        outliers,
-                        analysis.outlier_variance,
-                    };
-                } else {
-                    std::vector<Duration> samples;
-                    samples.reserve(last - first);
-
-                    Duration mean = Duration(0);
-                    int i = 0;
-                    for (auto it = first; it < last; ++it, ++i) {
-                        samples.push_back(Duration(*it));
-                        mean += Duration(*it);
-                    }
-                    mean /= i;
-
-                    return {
-                        std::move(samples),
-                        Estimate<Duration>{mean, mean, mean, 0.0},
-                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
-                        OutlierClassification{},
-                        0.0
-                    };
-                }
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-// end catch_analyse.hpp
-#include <algorithm>
-#include <functional>
-#include <string>
-#include <vector>
-#include <cmath>
-
-namespace Catch {
-    namespace Benchmark {
-        struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
-
-            template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
-
-            template <typename Clock>
-            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
-                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
-                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
-                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
-            }
-
-            template <typename Clock = default_clock>
-            void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
-
-                auto env = Detail::measure_environment<Clock>();
-
-                getResultCapture().benchmarkPreparing(name);
-                CATCH_TRY{
-                    auto plan = user_code([&] {
-                        return prepare<Clock>(*cfg, env);
-                    });
-
-                    BenchmarkInfo info {
-                        name,
-                        plan.estimated_duration.count(),
-                        plan.iterations_per_sample,
-                        cfg->benchmarkSamples(),
-                        cfg->benchmarkResamples(),
-                        env.clock_resolution.mean.count(),
-                        env.clock_cost.mean.count()
-                    };
-
-                    getResultCapture().benchmarkStarting(info);
-
-                    auto samples = user_code([&] {
-                        return plan.template run<Clock>(*cfg, env);
-                    });
-
-                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
-                    getResultCapture().benchmarkEnded(stats);
-
-                } CATCH_CATCH_ALL{
-                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
-                        std::rethrow_exception(std::current_exception());
-                }
-            }
-
-            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun,
-                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
-                Benchmark & operator=(Fun func) {
-                fun = Detail::BenchmarkFunction(func);
-                run();
-                return *this;
-            }
-
-            explicit operator bool() {
-                return true;
-            }
-
-        private:
-            Detail::BenchmarkFunction fun;
-            std::string name;
-        };
-    }
-} // namespace Catch
-
-#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
-#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
-
-#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&](int benchmarkIndex)
-
-#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
-    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
-        BenchmarkName = [&]
-
-// end catch_benchmark.hpp
-// start catch_constructor.hpp
-
-// Constructor and destructor helpers
-
-
-#include <type_traits>
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
-            {
-                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-                ObjectStorage() : data() {}
-
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
-
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(&data) T(std::move(other.stored_object()));
-                }
-
-                ~ObjectStorage() { destruct_on_exit<T>(); }
-
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (&data) T(std::forward<Args>(args)...);
-                }
-
-                template <bool AllowManualDestruction = !Destruct>
-                typename std::enable_if<AllowManualDestruction>::type destruct()
-                {
-                    stored_object().~T();
-                }
-
-            private:
-                // If this is a constructor benchmark, destruct the underlying object
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-                // Otherwise, don't
-                template <typename U>
-                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
-
-                T& stored_object() {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                T const& stored_object() const {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                TStorage data;
-            };
-        }
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
-    }
-}
-
-// end catch_constructor.hpp
-// end catch_benchmarking_all.hpp
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#ifdef CATCH_IMPL
-// start catch_impl.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// Keep these here for external reporters
-// start catch_test_case_tracker.h
-
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    struct NameAndLocation {
-        std::string name;
-        SourceLineInfo location;
-
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
-    };
-
-    struct ITracker;
-
-    using ITrackerPtr = std::shared_ptr<ITracker>;
-
-    struct ITracker {
-        virtual ~ITracker();
-
-        // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
-
-        // dynamic queries
-        virtual bool isComplete() const = 0; // Successfully completed or failed
-        virtual bool isSuccessfullyCompleted() const = 0;
-        virtual bool isOpen() const = 0; // Started but not complete
-        virtual bool hasChildren() const = 0;
-
-        virtual ITracker& parent() = 0;
-
-        // actions
-        virtual void close() = 0; // Successfully complete
-        virtual void fail() = 0;
-        virtual void markAsNeedingAnotherRun() = 0;
-
-        virtual void addChild( ITrackerPtr const& child ) = 0;
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
-        virtual void openChild() = 0;
-
-        // Debug/ checking
-        virtual bool isSectionTracker() const = 0;
-        virtual bool isGeneratorTracker() const = 0;
-    };
-
-    class TrackerContext {
-
-        enum RunState {
-            NotStarted,
-            Executing,
-            CompletedCycle
-        };
-
-        ITrackerPtr m_rootTracker;
-        ITracker* m_currentTracker = nullptr;
-        RunState m_runState = NotStarted;
-
-    public:
-
-        ITracker& startRun();
-        void endRun();
-
-        void startCycle();
-        void completeCycle();
-
-        bool completedCycle() const;
-        ITracker& currentTracker();
-        void setCurrentTracker( ITracker* tracker );
-    };
-
-    class TrackerBase : public ITracker {
-    protected:
-        enum CycleState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            NeedsAnotherRun,
-            CompletedSuccessfully,
-            Failed
-        };
-
-        using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
-        TrackerContext& m_ctx;
-        ITracker* m_parent;
-        Children m_children;
-        CycleState m_runState = NotStarted;
-
-    public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        NameAndLocation const& nameAndLocation() const override;
-        bool isComplete() const override;
-        bool isSuccessfullyCompleted() const override;
-        bool isOpen() const override;
-        bool hasChildren() const override;
-
-        void addChild( ITrackerPtr const& child ) override;
-
-        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        ITracker& parent() override;
-
-        void openChild() override;
-
-        bool isSectionTracker() const override;
-        bool isGeneratorTracker() const override;
-
-        void open();
-
-        void close() override;
-        void fail() override;
-        void markAsNeedingAnotherRun() override;
-
-    private:
-        void moveToParent();
-        void moveToThis();
-    };
-
-    class SectionTracker : public TrackerBase {
-        std::vector<std::string> m_filters;
-        std::string m_trimmed_name;
-    public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-
-        bool isSectionTracker() const override;
-
-        bool isComplete() const override;
-
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
-
-        void tryOpen();
-
-        void addInitialFilters( std::vector<std::string> const& filters );
-        void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-// end catch_test_case_tracker.h
-
-// start catch_leak_detector.h
-
-namespace Catch {
-
-    struct LeakDetector {
-        LeakDetector();
-        ~LeakDetector();
-    };
-
-}
-// end catch_leak_detector.h
-// Cpp files will be included in the single-header file here
-// start catch_stats.cpp
-
-// Statistical analysis tools
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-
-#include <cassert>
-#include <random>
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-#include <future>
-#endif
-
-namespace {
-    double erf_inv(double x) {
-        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
-        double w, p;
-
-        w = -log((1.0 - x) * (1.0 + x));
-
-        if (w < 6.250000) {
-            w = w - 3.125000;
-            p = -3.6444120640178196996e-21;
-            p = -1.685059138182016589e-19 + p * w;
-            p = 1.2858480715256400167e-18 + p * w;
-            p = 1.115787767802518096e-17 + p * w;
-            p = -1.333171662854620906e-16 + p * w;
-            p = 2.0972767875968561637e-17 + p * w;
-            p = 6.6376381343583238325e-15 + p * w;
-            p = -4.0545662729752068639e-14 + p * w;
-            p = -8.1519341976054721522e-14 + p * w;
-            p = 2.6335093153082322977e-12 + p * w;
-            p = -1.2975133253453532498e-11 + p * w;
-            p = -5.4154120542946279317e-11 + p * w;
-            p = 1.051212273321532285e-09 + p * w;
-            p = -4.1126339803469836976e-09 + p * w;
-            p = -2.9070369957882005086e-08 + p * w;
-            p = 4.2347877827932403518e-07 + p * w;
-            p = -1.3654692000834678645e-06 + p * w;
-            p = -1.3882523362786468719e-05 + p * w;
-            p = 0.0001867342080340571352 + p * w;
-            p = -0.00074070253416626697512 + p * w;
-            p = -0.0060336708714301490533 + p * w;
-            p = 0.24015818242558961693 + p * w;
-            p = 1.6536545626831027356 + p * w;
-        } else if (w < 16.000000) {
-            w = sqrt(w) - 3.250000;
-            p = 2.2137376921775787049e-09;
-            p = 9.0756561938885390979e-08 + p * w;
-            p = -2.7517406297064545428e-07 + p * w;
-            p = 1.8239629214389227755e-08 + p * w;
-            p = 1.5027403968909827627e-06 + p * w;
-            p = -4.013867526981545969e-06 + p * w;
-            p = 2.9234449089955446044e-06 + p * w;
-            p = 1.2475304481671778723e-05 + p * w;
-            p = -4.7318229009055733981e-05 + p * w;
-            p = 6.8284851459573175448e-05 + p * w;
-            p = 2.4031110387097893999e-05 + p * w;
-            p = -0.0003550375203628474796 + p * w;
-            p = 0.00095328937973738049703 + p * w;
-            p = -0.0016882755560235047313 + p * w;
-            p = 0.0024914420961078508066 + p * w;
-            p = -0.0037512085075692412107 + p * w;
-            p = 0.005370914553590063617 + p * w;
-            p = 1.0052589676941592334 + p * w;
-            p = 3.0838856104922207635 + p * w;
-        } else {
-            w = sqrt(w) - 5.000000;
-            p = -2.7109920616438573243e-11;
-            p = -2.5556418169965252055e-10 + p * w;
-            p = 1.5076572693500548083e-09 + p * w;
-            p = -3.7894654401267369937e-09 + p * w;
-            p = 7.6157012080783393804e-09 + p * w;
-            p = -1.4960026627149240478e-08 + p * w;
-            p = 2.9147953450901080826e-08 + p * w;
-            p = -6.7711997758452339498e-08 + p * w;
-            p = 2.2900482228026654717e-07 + p * w;
-            p = -9.9298272942317002539e-07 + p * w;
-            p = 4.5260625972231537039e-06 + p * w;
-            p = -1.9681778105531670567e-05 + p * w;
-            p = 7.5995277030017761139e-05 + p * w;
-            p = -0.00021503011930044477347 + p * w;
-            p = -0.00013871931833623122026 + p * w;
-            p = 1.0103004648645343977 + p * w;
-            p = 4.8499064014085844221 + p * w;
-        }
-        return p * x;
-    }
-
-    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
-        auto m = Catch::Benchmark::Detail::mean(first, last);
-        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
-            double diff = b - m;
-            return a + diff * diff;
-            }) / (last - first);
-            return std::sqrt(variance);
-    }
-
-}
-
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-
-            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
-                int j = static_cast<int>(idx);
-                double g = idx - j;
-                std::nth_element(first, first + j, last);
-                auto xj = first[j];
-                if (g == 0) return xj;
-
-                auto xj1 = *std::min_element(first + (j + 1), last);
-                return xj + g * (xj1 - xj);
-            }
-
-            double erfc_inv(double x) {
-                return erf_inv(1.0 - x);
-            }
-
-            double normal_quantile(double p) {
-                static const double ROOT_TWO = std::sqrt(2.0);
-
-                double result = 0.0;
-                assert(p >= 0 && p <= 1);
-                if (p < 0 || p > 1) {
-                    return result;
-                }
-
-                result = -erfc_inv(2.0 * p);
-                // result *= normal distribution standard deviation (1.0) * sqrt(2)
-                result *= /*sd * */ ROOT_TWO;
-                // result += normal disttribution mean (0)
-                return result;
-            }
-
-            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
-                double sb = stddev.point;
-                double mn = mean.point / n;
-                double mg_min = mn / 2.;
-                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
-                double sg2 = sg * sg;
-                double sb2 = sb * sb;
-
-                auto c_max = [n, mn, sb2, sg2](double x) -> double {
-                    double k = mn - x;
-                    double d = k * k;
-                    double nd = n * d;
-                    double k0 = -n * nd;
-                    double k1 = sb2 - n * sg2 + nd;
-                    double det = k1 * k1 - 4 * sg2 * k0;
-                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
-                };
-
-                auto var_out = [n, sb2, sg2](double c) {
-                    double nc = n - c;
-                    return (nc / n) * (sb2 - nc * sg2);
-                };
-
-                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
-            }
-
-            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-                static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
-
-                auto mean = &Detail::mean<std::vector<double>::iterator>;
-                auto stddev = &standard_deviation;
-
-#if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    return std::async(std::launch::async, [=] {
-                        std::mt19937 rng(seed);
-                        auto resampled = resample(rng, n_resamples, first, last, f);
-                        return bootstrap(confidence_level, first, last, resampled, f);
-                    });
-                };
-
-                auto mean_future = Estimate(mean);
-                auto stddev_future = Estimate(stddev);
-
-                auto mean_estimate = mean_future.get();
-                auto stddev_estimate = stddev_future.get();
-#else
-                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
-                    auto seed = entropy();
-                    std::mt19937 rng(seed);
-                    auto resampled = resample(rng, n_resamples, first, last, f);
-                    return bootstrap(confidence_level, first, last, resampled, f);
-                };
-
-                auto mean_estimate = Estimate(mean);
-                auto stddev_estimate = Estimate(stddev);
-#endif // CATCH_USE_ASYNC
-
-                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
-
-                return { mean_estimate, stddev_estimate, outlier_variance };
-            }
-        } // namespace Detail
-    } // namespace Benchmark
-} // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-// end catch_stats.cpp
-// start catch_approx.cpp
-
-#include <cmath>
-#include <limits>
-
-namespace {
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-}
-
-namespace Catch {
-namespace Detail {
-
-    Approx::Approx ( double value )
-    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-        m_margin( 0.0 ),
-        m_scale( 0.0 ),
-        m_value( value )
-    {}
-
-    Approx Approx::custom() {
-        return Approx( 0 );
-    }
-
-    Approx Approx::operator-() const {
-        auto temp(*this);
-        temp.m_value = -temp.m_value;
-        return temp;
-    }
-
-    std::string Approx::toString() const {
-        ReusableStringStream rss;
-        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
-        return rss.str();
-    }
-
-    bool Approx::equalityComparisonImpl(const double other) const {
-        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-        // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
-    }
-
-    void Approx::setMargin(double newMargin) {
-        CATCH_ENFORCE(newMargin >= 0,
-            "Invalid Approx::margin: " << newMargin << '.'
-            << " Approx::Margin has to be non-negative.");
-        m_margin = newMargin;
-    }
-
-    void Approx::setEpsilon(double newEpsilon) {
-        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
-            "Invalid Approx::epsilon: " << newEpsilon << '.'
-            << " Approx::epsilon has to be in [0, 1]");
-        m_epsilon = newEpsilon;
-    }
-
-} // end namespace Detail
-
-namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
-    }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
-    }
-} // end namespace literals
-
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
-    return value.toString();
-}
-
-} // end namespace Catch
-// end catch_approx.cpp
-// start catch_assertionhandler.cpp
-
-// start catch_debugger.h
-
-namespace Catch {
-    bool isDebuggerActive();
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
-#endif
-
-// end catch_debugger.h
-// start catch_run_context.h
-
-// start catch_fatal_condition.h
-
-// start catch_windows_h_proxy.h
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#  define CATCH_DEFINED_NOMINMAX
-#  define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#ifdef CATCH_DEFINED_NOMINMAX
-#  undef NOMINMAX
-#endif
-#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
-#  undef WIN32_LEAN_AND_MEAN
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-// end catch_windows_h_proxy.h
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo);
-        FatalConditionHandler();
-        static void reset();
-        ~FatalConditionHandler();
-
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-} // namespace Catch
-
-#elif defined ( CATCH_CONFIG_POSIX_SIGNALS )
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions[];
-        static stack_t oldSigStack;
-        static char altStackMem[];
-
-        static void handleSignal( int sig );
-
-        FatalConditionHandler();
-        ~FatalConditionHandler();
-        static void reset();
-    };
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset();
-    };
-}
-
-#endif
-
-// end catch_fatal_condition.h
-#include <string>
-
-namespace Catch {
-
-    struct IMutableContext;
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-    public:
-        RunContext( RunContext const& ) = delete;
-        RunContext& operator =( RunContext const& ) = delete;
-
-        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
-
-        ~RunContext() override;
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
-
-        Totals runTest(TestCase const& testCase);
-
-        IConfigPtr config() const;
-        IStreamingReporter& reporter() const;
-
-    public: // IResultCapture
-
-        // Assertion handlers
-        void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
-        void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef const& message,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
-        void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string const& message,
-                    AssertionReaction& reaction ) override;
-        void handleIncomplete
-                (   AssertionInfo const& info ) override;
-        void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
-
-        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
-
-        void sectionEnded( SectionEndInfo const& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
-
-        auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing( std::string const& name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( std::string const& error ) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
-
-        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
-
-        std::string getCurrentTestName() const override;
-
-        const AssertionResult* getLastResult() const override;
-
-        void exceptionEarlyReported() override;
-
-        void handleFatalErrorCondition( StringRef message ) override;
-
-        bool lastAssertionPassed() override;
-
-        void assertionPassed() override;
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const final;
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
-        void invokeActiveTestCase();
-
-        void resetAssertionInfo();
-        bool testForMissingAssertions( Counts& assertions );
-
-        void assertionEnded( AssertionResult const& result );
-        void reportExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    ITransientExpression const *expr,
-                    bool negated );
-
-        void populateReaction( AssertionReaction& reaction );
-
-    private:
-
-        void handleUnfinishedSections();
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker = nullptr;
-        Option<AssertionResult> m_lastResult;
-
-        IConfigPtr m_config;
-        Totals m_totals;
-        IStreamingReporterPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        bool m_lastAssertionPassed = false;
-        bool m_shouldReportUnexpected = true;
-        bool m_includeSuccessfulResults;
-    };
-
-    void seedRng(IConfig const& config);
-    unsigned int rngSeed();
-} // end namespace Catch
-
-// end catch_run_context.h
-namespace Catch {
-
-    namespace {
-        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-            expr.streamReconstructedExpression( os );
-            return os;
-        }
-    }
-
-    LazyExpression::LazyExpression( bool isNegated )
-    :   m_isNegated( isNegated )
-    {}
-
-    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
-
-    LazyExpression::operator bool() const {
-        return m_transientExpression != nullptr;
-    }
-
-    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
-        if( lazyExpr.m_isNegated )
-            os << "!";
-
-        if( lazyExpr ) {
-            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
-                os << "(" << *lazyExpr.m_transientExpression << ")";
-            else
-                os << *lazyExpr.m_transientExpression;
-        }
-        else {
-            os << "{** error - unchecked empty expression requested **}";
-        }
-        return os;
-    }
-
-    AssertionHandler::AssertionHandler
-        (   StringRef const& macroName,
-            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
-            ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
-        m_resultCapture( getResultCapture() )
-    {}
-
-    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
-        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
-    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
-    }
-
-    auto AssertionHandler::allowThrows() const -> bool {
-        return getCurrentContext().getConfig()->allowThrows();
-    }
-
-    void AssertionHandler::complete() {
-        setCompleted();
-        if( m_reaction.shouldDebugBreak ) {
-
-            // If you find your debugger stopping you here then go one level up on the
-            // call-stack for the code that caused it (typically a failed assertion)
-
-            // (To go back to the test and change execution, jump over the throw, next)
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-        if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-            throw Catch::TestFailureException();
-#else
-            CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
-        }
-    }
-    void AssertionHandler::setCompleted() {
-        m_completed = true;
-    }
-
-    void AssertionHandler::handleUnexpectedInflightException() {
-        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
-    }
-
-    void AssertionHandler::handleExceptionThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-    void AssertionHandler::handleExceptionNotThrownAsExpected() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
-        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
-    }
-
-    void AssertionHandler::handleThrowingCallSkipped() {
-        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
-    }
-
-    // This is the overload that takes a string and infers the Equals matcher from it
-    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
-        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
-    }
-
-} // namespace Catch
-// end catch_assertionhandler.cpp
-// start catch_assertionresult.cpp
-
-namespace Catch {
-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
-        lazyExpression(_lazyExpression),
-        resultType(_resultType) {}
-
-    std::string AssertionResultData::reconstructExpression() const {
-
-        if( reconstructedExpression.empty() ) {
-            if( lazyExpression ) {
-                ReusableStringStream rss;
-                rss << lazyExpression;
-                reconstructedExpression = rss.str();
-            }
-        }
-        return reconstructedExpression;
-    }
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
-    }
-
-    std::string AssertionResult::getExpressionInMacro() const {
-        std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
-        else {
-            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
-            expr += m_info.macroName;
-            expr += "( ";
-            expr += m_info.capturedExpression;
-            expr += " )";
-        }
-        return expr;
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        std::string expr = m_resultData.reconstructExpression();
-        return expr.empty()
-                ? getExpression()
-                : expr;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    StringRef AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-// end catch_assertionresult.cpp
-// start catch_capture_matchers.cpp
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch
-// end catch_capture_matchers.cpp
-// start catch_commandline.cpp
-
-// start catch_commandline.h
-
-// start catch_clara.h
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.5
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-namespace clara {
-namespace TextFlow {
-
-inline auto isWhitespace(char c) -> bool {
-	static std::string chars = " \t\n\r";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableBefore(char c) -> bool {
-	static std::string chars = "[({<|";
-	return chars.find(c) != std::string::npos;
-}
-inline auto isBreakableAfter(char c) -> bool {
-	static std::string chars = "])}>.,:;*+-=&/\\";
-	return chars.find(c) != std::string::npos;
-}
-
-class Columns;
-
-class Column {
-	std::vector<std::string> m_strings;
-	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-	size_t m_indent = 0;
-	size_t m_initialIndent = std::string::npos;
-
-public:
-	class iterator {
-		friend Column;
-
-		Column const& m_column;
-		size_t m_stringIndex = 0;
-		size_t m_pos = 0;
-
-		size_t m_len = 0;
-		size_t m_end = 0;
-		bool m_suffix = false;
-
-		iterator(Column const& column, size_t stringIndex)
-			: m_column(column),
-			m_stringIndex(stringIndex) {}
-
-		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-		auto isBoundary(size_t at) const -> bool {
-			assert(at > 0);
-			assert(at <= line().size());
-
-			return at == line().size() ||
-				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-				isBreakableBefore(line()[at]) ||
-				isBreakableAfter(line()[at - 1]);
-		}
-
-		void calcLength() {
-			assert(m_stringIndex < m_column.m_strings.size());
-
-			m_suffix = false;
-			auto width = m_column.m_width - indent();
-			m_end = m_pos;
-			if (line()[m_pos] == '\n') {
-				++m_end;
-			}
-			while (m_end < line().size() && line()[m_end] != '\n')
-				++m_end;
-
-			if (m_end < m_pos + width) {
-				m_len = m_end - m_pos;
-			} else {
-				size_t len = width;
-				while (len > 0 && !isBoundary(m_pos + len))
-					--len;
-				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
-					--len;
-
-				if (len > 0) {
-					m_len = len;
-				} else {
-					m_suffix = true;
-					m_len = width - 1;
-				}
-			}
-		}
-
-		auto indent() const -> size_t {
-			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-			return initial == std::string::npos ? m_column.m_indent : initial;
-		}
-
-		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Column const& column) : m_column(column) {
-			assert(m_column.m_width > m_column.m_indent);
-			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
-			calcLength();
-			if (m_len == 0)
-				m_stringIndex++; // Empty string
-		}
-
-		auto operator *() const -> std::string {
-			assert(m_stringIndex < m_column.m_strings.size());
-			assert(m_pos <= m_end);
-			return addIndentAndSuffix(line().substr(m_pos, m_len));
-		}
-
-		auto operator ++() -> iterator& {
-			m_pos += m_len;
-			if (m_pos < line().size() && line()[m_pos] == '\n')
-				m_pos += 1;
-			else
-				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
-					++m_pos;
-
-			if (m_pos == line().size()) {
-				m_pos = 0;
-				++m_stringIndex;
-			}
-			if (m_stringIndex < m_column.m_strings.size())
-				calcLength();
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return
-				m_pos == other.m_pos &&
-				m_stringIndex == other.m_stringIndex &&
-				&m_column == &other.m_column;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return !operator==(other);
-		}
-	};
-	using const_iterator = iterator;
-
-	explicit Column(std::string const& text) { m_strings.push_back(text); }
-
-	auto width(size_t newWidth) -> Column& {
-		assert(newWidth > 0);
-		m_width = newWidth;
-		return *this;
-	}
-	auto indent(size_t newIndent) -> Column& {
-		m_indent = newIndent;
-		return *this;
-	}
-	auto initialIndent(size_t newIndent) -> Column& {
-		m_initialIndent = newIndent;
-		return *this;
-	}
-
-	auto width() const -> size_t { return m_width; }
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, m_strings.size() }; }
-
-	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
-		bool first = true;
-		for (auto line : col) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto operator + (Column const& other)->Columns;
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-class Spacer : public Column {
-
-public:
-	explicit Spacer(size_t spaceWidth) : Column("") {
-		width(spaceWidth);
-	}
-};
-
-class Columns {
-	std::vector<Column> m_columns;
-
-public:
-
-	class iterator {
-		friend Columns;
-		struct EndTag {};
-
-		std::vector<Column> const& m_columns;
-		std::vector<Column::iterator> m_iterators;
-		size_t m_activeIterators;
-
-		iterator(Columns const& columns, EndTag)
-			: m_columns(columns.m_columns),
-			m_activeIterators(0) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.end());
-		}
-
-	public:
-		using difference_type = std::ptrdiff_t;
-		using value_type = std::string;
-		using pointer = value_type * ;
-		using reference = value_type & ;
-		using iterator_category = std::forward_iterator_tag;
-
-		explicit iterator(Columns const& columns)
-			: m_columns(columns.m_columns),
-			m_activeIterators(m_columns.size()) {
-			m_iterators.reserve(m_columns.size());
-
-			for (auto const& col : m_columns)
-				m_iterators.push_back(col.begin());
-		}
-
-		auto operator ==(iterator const& other) const -> bool {
-			return m_iterators == other.m_iterators;
-		}
-		auto operator !=(iterator const& other) const -> bool {
-			return m_iterators != other.m_iterators;
-		}
-		auto operator *() const -> std::string {
-			std::string row, padding;
-
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				auto width = m_columns[i].width();
-				if (m_iterators[i] != m_columns[i].end()) {
-					std::string col = *m_iterators[i];
-					row += padding + col;
-					if (col.size() < width)
-						padding = std::string(width - col.size(), ' ');
-					else
-						padding = "";
-				} else {
-					padding += std::string(width, ' ');
-				}
-			}
-			return row;
-		}
-		auto operator ++() -> iterator& {
-			for (size_t i = 0; i < m_columns.size(); ++i) {
-				if (m_iterators[i] != m_columns[i].end())
-					++m_iterators[i];
-			}
-			return *this;
-		}
-		auto operator ++(int) -> iterator {
-			iterator prev(*this);
-			operator++();
-			return prev;
-		}
-	};
-	using const_iterator = iterator;
-
-	auto begin() const -> iterator { return iterator(*this); }
-	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
-
-	auto operator += (Column const& col) -> Columns& {
-		m_columns.push_back(col);
-		return *this;
-	}
-	auto operator + (Column const& col) -> Columns {
-		Columns combined = *this;
-		combined += col;
-		return combined;
-	}
-
-	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
-
-		bool first = true;
-		for (auto line : cols) {
-			if (first)
-				first = false;
-			else
-				os << "\n";
-			os << line;
-		}
-		return os;
-	}
-
-	auto toString() const -> std::string {
-		std::ostringstream oss;
-		oss << *this;
-		return oss.str();
-	}
-};
-
-inline auto Column::operator + (Column const& other) -> Columns {
-	Columns cols;
-	cols += *this;
-	cols += other;
-	return cols;
-}
-}
-
-}
-}
-
-// ----------- end of #include from clara_textflow.hpp -----------
-// ........... back in clara.hpp
-
-#include <cctype>
-#include <string>
-#include <memory>
-#include <set>
-#include <algorithm>
-
-#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-namespace Catch { namespace clara {
-namespace detail {
-
-    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
-    template<typename L>
-    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
-
-    template<typename ClassT, typename ReturnT, typename... Args>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
-        static const bool isValid = false;
-    };
-
-    template<typename ClassT, typename ReturnT, typename ArgT>
-    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
-        static const bool isValid = true;
-        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
-        using ReturnType = ReturnT;
-    };
-
-    class TokenStream;
-
-    // Transport for raw args (copied from main args, or supplied via init list for testing)
-    class Args {
-        friend TokenStream;
-        std::string m_exeName;
-        std::vector<std::string> m_args;
-
-    public:
-        Args( int argc, char const* const* argv )
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
-
-        Args( std::initializer_list<std::string> args )
-        :   m_exeName( *args.begin() ),
-            m_args( args.begin()+1, args.end() )
-        {}
-
-        auto exeName() const -> std::string {
-            return m_exeName;
-        }
-    };
-
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
-    // may encode an option + its argument if the : or = form is used
-    enum class TokenType {
-        Option, Argument
-    };
-    struct Token {
-        TokenType type;
-        std::string token;
-    };
-
-    inline auto isOptPrefix( char c ) -> bool {
-        return c == '-'
-#ifdef CATCH_PLATFORM_WINDOWS
-            || c == '/'
-#endif
-        ;
-    }
-
-    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
-    class TokenStream {
-        using Iterator = std::vector<std::string>::const_iterator;
-        Iterator it;
-        Iterator itEnd;
-        std::vector<Token> m_tokenBuffer;
-
-        void loadBuffer() {
-            m_tokenBuffer.resize( 0 );
-
-            // Skip any empty strings
-            while( it != itEnd && it->empty() )
-                ++it;
-
-            if( it != itEnd ) {
-                auto const &next = *it;
-                if( isOptPrefix( next[0] ) ) {
-                    auto delimiterPos = next.find_first_of( " :=" );
-                    if( delimiterPos != std::string::npos ) {
-                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
-                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
-                    } else {
-                        if( next[1] != '-' && next.size() > 2 ) {
-                            std::string opt = "- ";
-                            for( size_t i = 1; i < next.size(); ++i ) {
-                                opt[1] = next[i];
-                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
-                            }
-                        } else {
-                            m_tokenBuffer.push_back( { TokenType::Option, next } );
-                        }
-                    }
-                } else {
-                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
-                }
-            }
-        }
-
-    public:
-        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
-
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
-            loadBuffer();
-        }
-
-        explicit operator bool() const {
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
-
-        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
-
-        auto operator*() const -> Token {
-            assert( !m_tokenBuffer.empty() );
-            return m_tokenBuffer.front();
-        }
-
-        auto operator->() const -> Token const * {
-            assert( !m_tokenBuffer.empty() );
-            return &m_tokenBuffer.front();
-        }
-
-        auto operator++() -> TokenStream & {
-            if( m_tokenBuffer.size() >= 2 ) {
-                m_tokenBuffer.erase( m_tokenBuffer.begin() );
-            } else {
-                if( it != itEnd )
-                    ++it;
-                loadBuffer();
-            }
-            return *this;
-        }
-    };
-
-    class ResultBase {
-    public:
-        enum Type {
-            Ok, LogicError, RuntimeError
-        };
-
-    protected:
-        ResultBase( Type type ) : m_type( type ) {}
-        virtual ~ResultBase() = default;
-
-        virtual void enforceOk() const = 0;
-
-        Type m_type;
-    };
-
-    template<typename T>
-    class ResultValueBase : public ResultBase {
-    public:
-        auto value() const -> T const & {
-            enforceOk();
-            return m_value;
-        }
-
-    protected:
-        ResultValueBase( Type type ) : ResultBase( type ) {}
-
-        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-        }
-
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
-            new( &m_value ) T( value );
-        }
-
-        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
-                m_value.~T();
-            ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
-                new( &m_value ) T( other.m_value );
-            return *this;
-        }
-
-        ~ResultValueBase() override {
-            if( m_type == Ok )
-                m_value.~T();
-        }
-
-        union {
-            T m_value;
-        };
-    };
-
-    template<>
-    class ResultValueBase<void> : public ResultBase {
-    protected:
-        using ResultBase::ResultBase;
-    };
-
-    template<typename T = void>
-    class BasicResult : public ResultValueBase<T> {
-    public:
-        template<typename U>
-        explicit BasicResult( BasicResult<U> const &other )
-        :   ResultValueBase<T>( other.type() ),
-            m_errorMessage( other.errorMessage() )
-        {
-            assert( type() != ResultBase::Ok );
-        }
-
-        template<typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
-        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
-
-        explicit operator bool() const { return m_type == ResultBase::Ok; }
-        auto type() const -> ResultBase::Type { return m_type; }
-        auto errorMessage() const -> std::string { return m_errorMessage; }
-
-    protected:
-        void enforceOk() const override {
-
-            // Errors shouldn't reach this point, but if they do
-            // the actual error message will be in m_errorMessage
-            assert( m_type != ResultBase::LogicError );
-            assert( m_type != ResultBase::RuntimeError );
-            if( m_type != ResultBase::Ok )
-                std::abort();
-        }
-
-        std::string m_errorMessage; // Only populated if resultType is an error
-
-        BasicResult( ResultBase::Type type, std::string const &message )
-        :   ResultValueBase<T>(type),
-            m_errorMessage(message)
-        {
-            assert( m_type != ResultBase::Ok );
-        }
-
-        using ResultValueBase<T>::ResultValueBase;
-        using ResultBase::m_type;
-    };
-
-    enum class ParseResultType {
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
-
-    class ParseState {
-    public:
-
-        ParseState( ParseResultType type, TokenStream const &remainingTokens )
-        : m_type(type),
-          m_remainingTokens( remainingTokens )
-        {}
-
-        auto type() const -> ParseResultType { return m_type; }
-        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
-
-    private:
-        ParseResultType m_type;
-        TokenStream m_remainingTokens;
-    };
-
-    using Result = BasicResult<void>;
-    using ParserResult = BasicResult<ParseResultType>;
-    using InternalParseResult = BasicResult<ParseState>;
-
-    struct HelpColumns {
-        std::string left;
-        std::string right;
-    };
-
-    template<typename T>
-    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
-        std::stringstream ss;
-        ss << source;
-        ss >> target;
-        if( ss.fail() )
-            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
-        else
-            return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
-        target = source;
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
-        std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
-        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
-            target = true;
-        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
-            target = false;
-        else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
-        return ParserResult::ok( ParseResultType::Matched );
-    }
-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
-    template<typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
-        T temp;
-        auto result = convertInto( source, temp );
-        if( result )
-            target = std::move(temp);
-        return result;
-    }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE
-
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable( NonCopyable const & ) = delete;
-        NonCopyable( NonCopyable && ) = delete;
-        NonCopyable &operator=( NonCopyable const & ) = delete;
-        NonCopyable &operator=( NonCopyable && ) = delete;
-    };
-
-    struct BoundRef : NonCopyable {
-        virtual ~BoundRef() = default;
-        virtual auto isContainer() const -> bool { return false; }
-        virtual auto isFlag() const -> bool { return false; }
-    };
-    struct BoundValueRefBase : BoundRef {
-        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
-    };
-    struct BoundFlagRefBase : BoundRef {
-        virtual auto setFlag( bool flag ) -> ParserResult = 0;
-        virtual auto isFlag() const -> bool { return true; }
-    };
-
-    template<typename T>
-    struct BoundValueRef : BoundValueRefBase {
-        T &m_ref;
-
-        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return convertInto( arg, m_ref );
-        }
-    };
-
-    template<typename T>
-    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-        std::vector<T> &m_ref;
-
-        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
-
-        auto isContainer() const -> bool override { return true; }
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            T temp;
-            auto result = convertInto( arg, temp );
-            if( result )
-                m_ref.push_back( temp );
-            return result;
-        }
-    };
-
-    struct BoundFlagRef : BoundFlagRefBase {
-        bool &m_ref;
-
-        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            m_ref = flag;
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ReturnType>
-    struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
-
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            return lambda( arg );
-        }
-    };
-
-    template<>
-    struct LambdaInvoker<void> {
-        template<typename L, typename ArgType>
-        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
-            lambda( arg );
-            return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    template<typename ArgType, typename L>
-    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
-        ArgType temp{};
-        auto result = convertInto( arg, temp );
-        return !result
-           ? result
-           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
-    }
-
-    template<typename L>
-    struct BoundLambda : BoundValueRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setValue( std::string const &arg ) -> ParserResult override {
-            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
-        }
-    };
-
-    template<typename L>
-    struct BoundFlagLambda : BoundFlagRefBase {
-        L m_lambda;
-
-        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
-
-        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
-
-        auto setFlag( bool flag ) -> ParserResult override {
-            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
-        }
-    };
-
-    enum class Optionality { Optional, Required };
-
-    struct Parser;
-
-    class ParserBase {
-    public:
-        virtual ~ParserBase() = default;
-        virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
-        virtual auto cardinality() const -> size_t { return 1; }
-
-        auto parse( Args const &args ) const -> InternalParseResult {
-            return parse( args.exeName(), TokenStream( args ) );
-        }
-    };
-
-    template<typename DerivedT>
-    class ComposableParserImpl : public ParserBase {
-    public:
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser;
-
-		template<typename T>
-        auto operator+( T const &other ) const -> Parser;
-    };
-
-    // Common code and state for Args and Opts
-    template<typename DerivedT>
-    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
-    protected:
-        Optionality m_optionality = Optionality::Optional;
-        std::shared_ptr<BoundRef> m_ref;
-        std::string m_hint;
-        std::string m_description;
-
-        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
-
-    public:
-        template<typename T>
-        ParserRefImpl( T &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
-            m_hint( hint )
-        {}
-
-        template<typename LambdaT>
-        ParserRefImpl( LambdaT const &ref, std::string const &hint )
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
-            m_hint(hint)
-        {}
-
-        auto operator()( std::string const &description ) -> DerivedT & {
-            m_description = description;
-            return static_cast<DerivedT &>( *this );
-        }
-
-        auto optional() -> DerivedT & {
-            m_optionality = Optionality::Optional;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto required() -> DerivedT & {
-            m_optionality = Optionality::Required;
-            return static_cast<DerivedT &>( *this );
-        };
-
-        auto isOptional() const -> bool {
-            return m_optionality == Optionality::Optional;
-        }
-
-        auto cardinality() const -> size_t override {
-            if( m_ref->isContainer() )
-                return 0;
-            else
-                return 1;
-        }
-
-        auto hint() const -> std::string { return m_hint; }
-    };
-
-    class ExeName : public ComposableParserImpl<ExeName> {
-        std::shared_ptr<std::string> m_name;
-        std::shared_ptr<BoundValueRefBase> m_ref;
-
-        template<typename LambdaT>
-        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
-            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
-        }
-
-    public:
-        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
-
-        explicit ExeName( std::string &ref ) : ExeName() {
-            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
-        }
-
-        template<typename LambdaT>
-        explicit ExeName( LambdaT const& lambda ) : ExeName() {
-            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
-        }
-
-        // The exe name is not parsed out of the normal tokens, but is handled specially
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-        }
-
-        auto name() const -> std::string { return *m_name; }
-        auto set( std::string const& newName ) -> ParserResult {
-
-            auto lastSlash = newName.find_last_of( "\\/" );
-            auto filename = ( lastSlash == std::string::npos )
-                    ? newName
-                    : newName.substr( lastSlash+1 );
-
-            *m_name = filename;
-            if( m_ref )
-                return m_ref->setValue( filename );
-            else
-                return ParserResult::ok( ParseResultType::Matched );
-        }
-    };
-
-    class Arg : public ParserRefImpl<Arg> {
-    public:
-        using ParserRefImpl::ParserRefImpl;
-
-        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            auto const &token = *remainingTokens;
-            if( token.type != TokenType::Argument )
-                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-
-            assert( !m_ref->isFlag() );
-            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-
-            auto result = valueRef->setValue( remainingTokens->token );
-            if( !result )
-                return InternalParseResult( result );
-            else
-                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-        }
-    };
-
-    inline auto normaliseOpt( std::string const &optName ) -> std::string {
-#ifdef CATCH_PLATFORM_WINDOWS
-        if( optName[0] == '/' )
-            return "-" + optName.substr( 1 );
-        else
-#endif
-            return optName;
-    }
-
-    class Opt : public ParserRefImpl<Opt> {
-    protected:
-        std::vector<std::string> m_optNames;
-
-    public:
-        template<typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
-
-        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
-
-        template<typename LambdaT>
-        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        template<typename T>
-        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
-
-        auto operator[]( std::string const &optName ) -> Opt & {
-            m_optNames.push_back( optName );
-            return *this;
-        }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::ostringstream oss;
-            bool first = true;
-            for( auto const &opt : m_optNames ) {
-                if (first)
-                    first = false;
-                else
-                    oss << ", ";
-                oss << opt;
-            }
-            if( !m_hint.empty() )
-                oss << " <" << m_hint << ">";
-            return { { oss.str(), m_description } };
-        }
-
-        auto isMatch( std::string const &optToken ) const -> bool {
-            auto normalisedToken = normaliseOpt( optToken );
-            for( auto const &name : m_optNames ) {
-                if( normaliseOpt( name ) == normalisedToken )
-                    return true;
-            }
-            return false;
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
-            auto validationResult = validate();
-            if( !validationResult )
-                return InternalParseResult( validationResult );
-
-            auto remainingTokens = tokens;
-            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
-                auto const &token = *remainingTokens;
-                if( isMatch(token.token ) ) {
-                    if( m_ref->isFlag() ) {
-                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
-                        auto result = flagRef->setFlag( true );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    } else {
-                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
-                        ++remainingTokens;
-                        if( !remainingTokens )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto const &argToken = *remainingTokens;
-                        if( argToken.type != TokenType::Argument )
-                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
-                        auto result = valueRef->setValue( argToken.token );
-                        if( !result )
-                            return InternalParseResult( result );
-                        if( result.value() == ParseResultType::ShortCircuitAll )
-                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
-                    }
-                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
-                }
-            }
-            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
-        }
-
-        auto validate() const -> Result override {
-            if( m_optNames.empty() )
-                return Result::logicError( "No options supplied to Opt" );
-            for( auto const &name : m_optNames ) {
-                if( name.empty() )
-                    return Result::logicError( "Option name cannot be empty" );
-#ifdef CATCH_PLATFORM_WINDOWS
-                if( name[0] != '-' && name[0] != '/' )
-                    return Result::logicError( "Option name must begin with '-' or '/'" );
-#else
-                if( name[0] != '-' )
-                    return Result::logicError( "Option name must begin with '-'" );
-#endif
-            }
-            return ParserRefImpl::validate();
-        }
-    };
-
-    struct Help : Opt {
-        Help( bool &showHelpFlag )
-        :   Opt([&]( bool flag ) {
-                showHelpFlag = flag;
-                return ParserResult::ok( ParseResultType::ShortCircuitAll );
-            })
-        {
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
-        }
-    };
-
-    struct Parser : ParserBase {
-
-        mutable ExeName m_exeName;
-        std::vector<Opt> m_options;
-        std::vector<Arg> m_args;
-
-        auto operator|=( ExeName const &exeName ) -> Parser & {
-            m_exeName = exeName;
-            return *this;
-        }
-
-        auto operator|=( Arg const &arg ) -> Parser & {
-            m_args.push_back(arg);
-            return *this;
-        }
-
-        auto operator|=( Opt const &opt ) -> Parser & {
-            m_options.push_back(opt);
-            return *this;
-        }
-
-        auto operator|=( Parser const &other ) -> Parser & {
-            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
-            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
-            return *this;
-        }
-
-        template<typename T>
-        auto operator|( T const &other ) const -> Parser {
-            return Parser( *this ) |= other;
-        }
-
-        // Forward deprecated interface with '+' instead of '|'
-        template<typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
-        template<typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
-
-        auto getHelpColumns() const -> std::vector<HelpColumns> {
-            std::vector<HelpColumns> cols;
-            for (auto const &o : m_options) {
-                auto childCols = o.getHelpColumns();
-                cols.insert( cols.end(), childCols.begin(), childCols.end() );
-            }
-            return cols;
-        }
-
-        void writeToStream( std::ostream &os ) const {
-            if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
-                bool required = true, first = true;
-                for( auto const &arg : m_args ) {
-                    if (first)
-                        first = false;
-                    else
-                        os << " ";
-                    if( arg.isOptional() && required ) {
-                        os << "[";
-                        required = false;
-                    }
-                    os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
-                        os << " ... ";
-                }
-                if( !required )
-                    os << "]";
-                if( !m_options.empty() )
-                    os << " options";
-                os << "\n\nwhere options are:" << std::endl;
-            }
-
-            auto rows = getHelpColumns();
-            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
-            size_t optWidth = 0;
-            for( auto const &cols : rows )
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
-
-            optWidth = (std::min)(optWidth, consoleWidth/2);
-
-            for( auto const &cols : rows ) {
-                auto row =
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
-                os << row << std::endl;
-            }
-        }
-
-        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
-            parser.writeToStream( os );
-            return os;
-        }
-
-        auto validate() const -> Result override {
-            for( auto const &opt : m_options ) {
-                auto result = opt.validate();
-                if( !result )
-                    return result;
-            }
-            for( auto const &arg : m_args ) {
-                auto result = arg.validate();
-                if( !result )
-                    return result;
-            }
-            return Result::ok();
-        }
-
-        using ParserBase::parse;
-
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
-
-            struct ParserInfo {
-                ParserBase const* parser = nullptr;
-                size_t count = 0;
-            };
-            const size_t totalParsers = m_options.size() + m_args.size();
-            assert( totalParsers < 512 );
-            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
-            ParserInfo parseInfos[512];
-
-            {
-                size_t i = 0;
-                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
-            }
-
-            m_exeName.set( exeName );
-
-            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
-            while( result.value().remainingTokens() ) {
-                bool tokenParsed = false;
-
-                for( size_t i = 0; i < totalParsers; ++i ) {
-                    auto&  parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
-                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
-                            return result;
-                        if (result.value().type() != ParseResultType::NoMatch) {
-                            tokenParsed = true;
-                            ++parseInfo.count;
-                            break;
-                        }
-                    }
-                }
-
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
-                    return result;
-                if( !tokenParsed )
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
-            }
-            // !TBD Check missing required options
-            return result;
-        }
-    };
-
-    template<typename DerivedT>
-    template<typename T>
-    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
-        return Parser() | static_cast<DerivedT const &>( *this ) | other;
-    }
-} // namespace detail
-
-// A Combined parser
-using detail::Parser;
-
-// A parser for options
-using detail::Opt;
-
-// A parser for arguments
-using detail::Arg;
-
-// Wrapper for argc, argv from main()
-using detail::Args;
-
-// Specifies the name of the executable
-using detail::ExeName;
-
-// Convenience wrapper for option parser that specifies the help option
-using detail::Help;
-
-// enum of result types from a parse
-using detail::ParseResultType;
-
-// Result type for parser operation
-using detail::ParserResult;
-
-}} // namespace Catch::clara
-
-// end clara.hpp
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-// end catch_clara.h
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config );
-
-} // end namespace Catch
-
-// end catch_commandline.h
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    clara::Parser makeCommandLineParser( ConfigData& config ) {
-
-        using namespace clara;
-
-        auto const setWarning = [&]( std::string const& warning ) {
-                auto warningSet = [&]() {
-                    if( warning == "NoAssertions" )
-                        return WarnAbout::NoAssertions;
-
-                    if ( warning == "NoTests" )
-                        return WarnAbout::NoTests;
-
-                    return WarnAbout::Nothing;
-                }();
-
-                if (warningSet == WarnAbout::Nothing)
-                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
-                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
-                std::ifstream f( filename.c_str() );
-                if( !f.is_open() )
-                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
-
-                std::string line;
-                while( std::getline( f, line ) ) {
-                    line = trim(line);
-                    if( !line.empty() && !startsWith( line, '#' ) ) {
-                        if( !startsWith( line, '"' ) )
-                            line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
-                    }
-                }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setTestOrder = [&]( std::string const& order ) {
-                if( startsWith( "declared", order ) )
-                    config.runOrder = RunTests::InDeclarationOrder;
-                else if( startsWith( "lexical", order ) )
-                    config.runOrder = RunTests::InLexicographicalOrder;
-                else if( startsWith( "random", order ) )
-                    config.runOrder = RunTests::InRandomOrder;
-                else
-                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setRngSeed = [&]( std::string const& seed ) {
-                if( seed != "time" )
-                    return clara::detail::convertInto( seed, config.rngSeed );
-                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setColourUsage = [&]( std::string const& useColour ) {
-                    auto mode = toLower( useColour );
-
-                    if( mode == "yes" )
-                        config.useColour = UseColour::Yes;
-                    else if( mode == "no" )
-                        config.useColour = UseColour::No;
-                    else if( mode == "auto" )
-                        config.useColour = UseColour::Auto;
-                    else
-                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
-                return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
-                auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStart;
-                else if( keypressLc == "exit" )
-                    config.waitForKeypress = WaitForKeypress::BeforeExit;
-                else if( keypressLc == "both" )
-                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-                else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
-            return ParserResult::ok( ParseResultType::Matched );
-            };
-        auto const setVerbosity = [&]( std::string const& verbosity ) {
-            auto lcVerbosity = toLower( verbosity );
-            if( lcVerbosity == "quiet" )
-                config.verbosity = Verbosity::Quiet;
-            else if( lcVerbosity == "normal" )
-                config.verbosity = Verbosity::Normal;
-            else if( lcVerbosity == "high" )
-                config.verbosity = Verbosity::High;
-            else
-                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-        auto const setReporter = [&]( std::string const& reporter ) {
-            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-
-            auto lcReporter = toLower( reporter );
-            auto result = factories.find( lcReporter );
-
-            if( factories.end() != result )
-                config.reporterName = lcReporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
-            return ParserResult::ok( ParseResultType::Matched );
-        };
-
-        auto cli
-            = ExeName( config.processName )
-            | Help( config.showHelp )
-            | Opt( config.listTests )
-                ["-l"]["--list-tests"]
-                ( "list all/matching test cases" )
-            | Opt( config.listTags )
-                ["-t"]["--list-tags"]
-                ( "list all/matching tags" )
-            | Opt( config.showSuccessfulTests )
-                ["-s"]["--success"]
-                ( "include successful tests in output" )
-            | Opt( config.shouldDebugBreak )
-                ["-b"]["--break"]
-                ( "break into debugger on failure" )
-            | Opt( config.noThrow )
-                ["-e"]["--nothrow"]
-                ( "skip exception tests" )
-            | Opt( config.showInvisibles )
-                ["-i"]["--invisibles"]
-                ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
-                ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
-                ["-r"]["--reporter"]
-                ( "reporter to use (defaults to console)" )
-            | Opt( config.name, "name" )
-                ["-n"]["--name"]
-                ( "suite name" )
-            | Opt( [&]( bool ){ config.abortAfter = 1; } )
-                ["-a"]["--abort"]
-                ( "abort at first failure" )
-            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
-                ["-x"]["--abortx"]
-                ( "abort after x failures" )
-            | Opt( setWarning, "warning name" )
-                ["-w"]["--warn"]
-                ( "enable warnings" )
-            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
-                ["-d"]["--durations"]
-                ( "show test durations" )
-            | Opt( loadTestNamesFromFile, "filename" )
-                ["-f"]["--input-file"]
-                ( "load test names to run from a file" )
-            | Opt( config.filenamesAsTags )
-                ["-#"]["--filenames-as-tags"]
-                ( "adds a tag for the filename" )
-            | Opt( config.sectionsToRun, "section name" )
-                ["-c"]["--section"]
-                ( "specify section to run" )
-            | Opt( setVerbosity, "quiet|normal|high" )
-                ["-v"]["--verbosity"]
-                ( "set output verbosity" )
-            | Opt( config.listTestNamesOnly )
-                ["--list-test-names-only"]
-                ( "list all/matching test cases names only" )
-            | Opt( config.listReporters )
-                ["--list-reporters"]
-                ( "list all reporters" )
-            | Opt( setTestOrder, "decl|lex|rand" )
-                ["--order"]
-                ( "test case order (defaults to decl)" )
-            | Opt( setRngSeed, "'time'|number" )
-                ["--rng-seed"]
-                ( "set a specific seed for random numbers" )
-            | Opt( setColourUsage, "yes|no" )
-                ["--use-colour"]
-                ( "should output be colourised" )
-            | Opt( config.libIdentify )
-                ["--libidentify"]
-                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
-                ["--wait-for-keypress"]
-                ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkSamples, "samples" )
-                ["--benchmark-samples"]
-                ( "number of samples to collect (default: 100)" )
-            | Opt( config.benchmarkResamples, "resamples" )
-                ["--benchmark-resamples"]
-                ( "number of resamples for the bootstrap (default: 100000)" )
-            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
-                ["--benchmark-confidence-interval"]
-                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
-            | Opt( config.benchmarkNoAnalysis )
-                ["--benchmark-no-analysis"]
-                ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
-                ( "which test or tests to use" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-// end catch_commandline.cpp
-// start catch_common.cpp
-
-#include <cstring>
-#include <ostream>
-
-namespace Catch {
-
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        // We can assume that the same file will usually have the same pointer.
-        // Thus, if the pointers are the same, there is no point in calling the strcmp
-        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    std::string StreamEndStop::operator+() const {
-        return std::string();
-    }
-
-    NonCopyable::NonCopyable() = default;
-    NonCopyable::~NonCopyable() = default;
-
-}
-// end catch_common.cpp
-// start catch_config.cpp
-
-namespace Catch {
-
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( openStream() )
-    {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
-            m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
-        }
-        m_testSpec = parser.testSpec();
-    }
-
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
-    bool Config::listTests() const          { return m_data.listTests; }
-    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
-    bool Config::listTags() const           { return m_data.listTags; }
-    bool Config::listReporters() const      { return m_data.listReporters; }
-
-    std::string Config::getProcessName() const { return m_data.processName; }
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
-    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
-    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
-
-    TestSpec const& Config::testSpec() const { return m_testSpec; }
-    bool Config::hasTestFilters() const { return m_hasTestFilters; }
-
-    bool Config::showHelp() const { return m_data.showHelp; }
-
-    // IConfig interface
-    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
-    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
-    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
-    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
-    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
-    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
-    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
-    int Config::abortAfter() const                     { return m_data.abortAfter; }
-    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
-    Verbosity Config::verbosity() const                { return m_data.verbosity; }
-
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
-
-    IStream const* Config::openStream() {
-        return Catch::makeStream(m_data.outputFilename);
-    }
-
-} // end namespace Catch
-// end catch_config.cpp
-// start catch_console_colour.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-// start catch_errno_guard.h
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard();
-        ~ErrnoGuard();
-    private:
-        int m_oldErrno;
-    };
-
-}
-
-// end catch_errno_guard.h
-#include <sstream>
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() = default;
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) override {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
-            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
-        }
-
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-
-                default:
-                    CATCH_ERROR( "Unknown colour requested" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
-        }
-        HANDLE stdoutHandle;
-        WORD originalForegroundAttributes;
-        WORD originalBackgroundAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = UseColour::Yes;
-        return colourMode == UseColour::Yes
-            ? &s_instance
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        void use( Colour::Code _colourCode ) override {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0;34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-                case Colour::BrightYellow:  return setColour( "[1;33m" );
-
-                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
-                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            getCurrentContext().getConfig()->stream()
-                << '\033' << _escapeCode;
-        }
-    };
-
-    bool useColourOnPlatform() {
-        return
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-            !isDebuggerActive() &&
-#endif
-#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
-            isatty(STDOUT_FILENO)
-#else
-            false
-#endif
-            ;
-    }
-    IColourImpl* platformColourInstance() {
-        ErrnoGuard guard;
-        IConfigPtr config = getCurrentContext().getConfig();
-        UseColour::YesOrNo colourMode = config
-            ? config->useColour()
-            : UseColour::Auto;
-        if( colourMode == UseColour::Auto )
-            colourMode = useColourOnPlatform()
-                ? UseColour::Yes
-                : UseColour::No;
-        return colourMode == UseColour::Yes
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved = true;
-    }
-    Colour& Colour::operator=( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved  = true;
-        return *this;
-    }
-
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = platformColourInstance();
-        // Strictly speaking, this cannot possibly happen.
-        // However, under some conditions it does happen (see #1626),
-        // and this change is small enough that we can let practicality
-        // triumph over purity in this case.
-        if (impl != nullptr) {
-            impl->use( _colourCode );
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, Colour const& ) {
-        return os;
-    }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_console_colour.cpp
-// start catch_context.cpp
-
-namespace Catch {
-
-    class Context : public IMutableContext, NonCopyable {
-
-    public: // IContext
-        IResultCapture* getResultCapture() override {
-            return m_resultCapture;
-        }
-        IRunner* getRunner() override {
-            return m_runner;
-        }
-
-        IConfigPtr const& getConfig() const override {
-            return m_config;
-        }
-
-        ~Context() override;
-
-    public: // IMutableContext
-        void setResultCapture( IResultCapture* resultCapture ) override {
-            m_resultCapture = resultCapture;
-        }
-        void setRunner( IRunner* runner ) override {
-            m_runner = runner;
-        }
-        void setConfig( IConfigPtr const& config ) override {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IConfigPtr m_config;
-        IRunner* m_runner = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
-    };
-
-    IMutableContext *IMutableContext::currentContext = nullptr;
-
-    void IMutableContext::createContext()
-    {
-        currentContext = new Context();
-    }
-
-    void cleanUpContext() {
-        delete IMutableContext::currentContext;
-        IMutableContext::currentContext = nullptr;
-    }
-    IContext::~IContext() = default;
-    IMutableContext::~IMutableContext() = default;
-    Context::~Context() = default;
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
-}
-// end catch_context.cpp
-// start catch_debug_console.cpp
-
-// start catch_debug_console.h
-
-#include <string>
-
-namespace Catch {
-    void writeToDebugConsole( std::string const& text );
-}
-
-// end catch_debug_console.h
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-
-#else
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-
-#endif // Platform
-// end catch_debug_console.cpp
-// start catch_debugger.cpp
-
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
-
-#  include <assert.h>
-#  include <stdbool.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  include <cstddef>
-#  include <ostream>
-
-#ifdef __apple_build_version__
-    // These headers will only compile with AppleClang (XCode)
-    // For other compilers (Clang, GCC, ... ) we need to exclude them
-#  include <sys/sysctl.h>
-#endif
-
-    namespace Catch {
-        #ifdef __apple_build_version__
-        // The following function is taken directly from the following technical note:
-        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-            int                 mib[4];
-            struct kinfo_proc   info;
-            std::size_t         size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-        #else
-        bool isDebuggerActive() {
-            // We need to find another way to determine this for non-appleclang compilers on macOS
-            return false;
-        }
-        #endif
-    } // namespace Catch
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    #include <fstream>
-    #include <string>
-
-    namespace Catch{
-        // The standard POSIX way of detecting a debugger is to attempt to
-        // ptrace() the process, but this needs to be done from a child and not
-        // this process itself to still allow attaching to this process later
-        // if wanted, so is rather heavy. Under Linux we have the PID of the
-        // "debugger" (which doesn't need to be gdb, of course, it could also
-        // be strace, for example) in /proc/$PID/status, so just get it from
-        // there instead.
-        bool isDebuggerActive(){
-            // Libstdc++ has a bug, where std::ifstream sets errno to 0
-            // This way our users can properly assert over errno values
-            ErrnoGuard guard;
-            std::ifstream in("/proc/self/status");
-            for( std::string line; std::getline(in, line); ) {
-                static const int PREFIX_LEN = 11;
-                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
-                    // We're traced if the PID is not 0 and no other PID starts
-                    // with 0 digit, so it's enough to check for just a single
-                    // character.
-                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
-                }
-            }
-
-            return false;
-        }
-    } // namespace Catch
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-// end catch_debugger.cpp
-// start catch_decomposer.cpp
-
-namespace Catch {
-
-    ITransientExpression::~ITransientExpression() = default;
-
-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
-        if( lhs.size() + rhs.size() < 40 &&
-                lhs.find('\n') == std::string::npos &&
-                rhs.find('\n') == std::string::npos )
-            os << lhs << " " << op << " " << rhs;
-        else
-            os << lhs << "\n" << op << "\n" << rhs;
-    }
-}
-// end catch_decomposer.cpp
-// start catch_enforce.cpp
-
-#include <stdexcept>
-
-namespace Catch {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
-    [[noreturn]]
-    void throw_exception(std::exception const& e) {
-        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
-                      << "The message was: " << e.what() << '\n';
-        std::terminate();
-    }
-#endif
-
-    [[noreturn]]
-    void throw_logic_error(std::string const& msg) {
-        throw_exception(std::logic_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_domain_error(std::string const& msg) {
-        throw_exception(std::domain_error(msg));
-    }
-
-    [[noreturn]]
-    void throw_runtime_error(std::string const& msg) {
-        throw_exception(std::runtime_error(msg));
-    }
-
-} // namespace Catch;
-// end catch_enforce.cpp
-// start catch_enum_values_registry.cpp
-// start catch_enum_values_registry.h
-
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    namespace Detail {
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
-
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
-        };
-
-        std::vector<StringRef> parseEnums( StringRef enums );
-
-    } // Detail
-
-} // Catch
-
-// end catch_enum_values_registry.h
-
-#include <map>
-#include <cassert>
-
-namespace Catch {
-
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
-
-    namespace Detail {
-
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
-            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
-            parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
-            }
-            return parsed;
-        }
-
-        EnumInfo::~EnumInfo() {}
-
-        StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
-            }
-            return "{** unexpected enum value **}"_sr;
-        }
-
-        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
-            enumInfo->m_name = enumName;
-            enumInfo->m_values.reserve( values.size() );
-
-            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
-            assert( valueNames.size() == values.size() );
-            std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
-
-            return enumInfo;
-        }
-
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
-
-    } // Detail
-} // Catch
-
-// end catch_enum_values_registry.cpp
-// start catch_errno_guard.cpp
-
-#include <cerrno>
-
-namespace Catch {
-        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
-        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
-}
-// end catch_errno_guard.cpp
-// start catch_exception_translator_registry.cpp
-
-// start catch_exception_translator_registry.h
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry();
-        virtual void registerTranslator( const IExceptionTranslator* translator );
-        std::string translateActiveException() const override;
-        std::string tryTranslators() const;
-
-    private:
-        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
-    };
-}
-
-// end catch_exception_translator_registry.h
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
-
-    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
-        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
-    }
-
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        try {
-#ifdef __OBJC__
-            // In Objective-C try objective-c exceptions first
-            @try {
-                return tryTranslators();
-            }
-            @catch (NSException *exception) {
-                return Catch::Detail::stringify( [exception description] );
-            }
-#else
-            // Compiling a mixed mode project with MSVC means that CLR
-            // exceptions will be caught in (...) as well. However, these
-            // do not fill-in std::current_exception and thus lead to crash
-            // when attempting rethrow.
-            // /EHa switch also causes structured exceptions to be caught
-            // here, but they fill-in current_exception properly, so
-            // at worst the output should be a little weird, instead of
-            // causing a crash.
-            if (std::current_exception() == nullptr) {
-                return "Non C++ exception. Possibly a CLR exception.";
-            }
-            return tryTranslators();
-#endif
-        }
-        catch( TestFailureException& ) {
-            std::rethrow_exception(std::current_exception());
-        }
-        catch( std::exception& ex ) {
-            return ex.what();
-        }
-        catch( std::string& msg ) {
-            return msg;
-        }
-        catch( const char* msg ) {
-            return msg;
-        }
-        catch(...) {
-            return "Unknown exception";
-        }
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if (m_translators.empty()) {
-            std::rethrow_exception(std::current_exception());
-        } else {
-            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
-        }
-    }
-
-#else // ^^ Exceptions are enabled // Exceptions are disabled vv
-    std::string ExceptionTranslatorRegistry::translateActiveException() const {
-        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-
-    std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
-    }
-#endif
-
-}
-// end catch_exception_translator_registry.cpp
-// start catch_fatal_condition.cpp
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace {
-    // Report the error condition
-    void reportFatal( char const * const message ) {
-        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
-    }
-}
-
-#endif // signals/SEH handling
-
-#if defined( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct SignalDefs { DWORD id; const char* name; };
-
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    static SignalDefs signalDefs[] = {
-        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
-        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
-        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
-        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
-    };
-
-    LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-        for (auto const& def : signalDefs) {
-            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
-                reportFatal(def.name);
-            }
-        }
-        // If its not an exception we care about, pass it along.
-        // This stops us from eating debugger breaks etc.
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        // 32k seems enough for Catch to handle stack overflow,
-        // but the value was found experimentally, so there is no strong guarantee
-        guaranteeSize = 32 * 1024;
-        exceptionHandlerHandle = nullptr;
-        // Register as first handler in current chain
-        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-        // Pass in guarantee size to be filled
-        SetThreadStackGuarantee(&guaranteeSize);
-    }
-
-    void FatalConditionHandler::reset() {
-        if (isSet) {
-            RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-            SetThreadStackGuarantee(&guaranteeSize);
-            exceptionHandlerHandle = nullptr;
-            isSet = false;
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-bool FatalConditionHandler::isSet = false;
-ULONG FatalConditionHandler::guaranteeSize = 0;
-PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;
-
-} // namespace Catch
-
-#elif defined( CATCH_CONFIG_POSIX_SIGNALS )
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-
-    // 32kb for the alternate stack seems to be sufficient. However, this value
-    // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
-
-    static SignalDefs signalDefs[] = {
-        { SIGINT,  "SIGINT - Terminal interrupt signal" },
-        { SIGILL,  "SIGILL - Illegal instruction signal" },
-        { SIGFPE,  "SIGFPE - Floating point error signal" },
-        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-        { SIGTERM, "SIGTERM - Termination request signal" },
-        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    void FatalConditionHandler::handleSignal( int sig ) {
-        char const * name = "<unknown signal>";
-        for (auto const& def : signalDefs) {
-            if (sig == def.id) {
-                name = def.name;
-                break;
-            }
-        }
-        reset();
-        reportFatal(name);
-        raise( sig );
-    }
-
-    FatalConditionHandler::FatalConditionHandler() {
-        isSet = true;
-        stack_t sigStack;
-        sigStack.ss_sp = altStackMem;
-        sigStack.ss_size = sigStackSize;
-        sigStack.ss_flags = 0;
-        sigaltstack(&sigStack, &oldSigStack);
-        struct sigaction sa = { };
-
-        sa.sa_handler = handleSignal;
-        sa.sa_flags = SA_ONSTACK;
-        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-        }
-    }
-
-    FatalConditionHandler::~FatalConditionHandler() {
-        reset();
-    }
-
-    void FatalConditionHandler::reset() {
-        if( isSet ) {
-            // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
-            }
-            // Return the old stack
-            sigaltstack(&oldSigStack, nullptr);
-            isSet = false;
-        }
-    }
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[sigStackSize] = {};
-
-} // namespace Catch
-
-#else
-
-namespace Catch {
-    void FatalConditionHandler::reset() {}
-}
-
-#endif // signals/SEH handling
-
-#if defined(__GNUC__)
-#    pragma GCC diagnostic pop
-#endif
-// end catch_fatal_condition.cpp
-// start catch_generators.cpp
-
-#include <limits>
-#include <set>
-
-namespace Catch {
-
-IGeneratorTracker::~IGeneratorTracker() {}
-
-const char* GeneratorException::what() const noexcept {
-    return m_msg;
-}
-
-namespace Generators {
-
-    GeneratorUntypedBase::~GeneratorUntypedBase() {}
-
-    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( lineInfo );
-    }
-
-} // namespace Generators
-} // namespace Catch
-// end catch_generators.cpp
-// start catch_interfaces_capture.cpp
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}
-// end catch_interfaces_capture.cpp
-// start catch_interfaces_config.cpp
-
-namespace Catch {
-    IConfig::~IConfig() = default;
-}
-// end catch_interfaces_config.cpp
-// start catch_interfaces_exception.cpp
-
-namespace Catch {
-    IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
-}
-// end catch_interfaces_exception.cpp
-// start catch_interfaces_registry_hub.cpp
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}
-// end catch_interfaces_registry_hub.cpp
-// start catch_interfaces_reporter.cpp
-
-// start catch_reporter_listening.h
-
-namespace Catch {
-
-    class ListeningReporter : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
-        ReporterPreferences m_preferences;
-
-    public:
-        ListeningReporter();
-
-        void addListener( IStreamingReporterPtr&& listener );
-        void addReporter( IStreamingReporterPtr&& reporter );
-
-    public: // IStreamingReporter
-
-        ReporterPreferences getPreferences() const override;
-
-        void noMatchingTestCases( std::string const& spec ) override;
-
-        void reportInvalidArguments(std::string const&arg) override;
-
-        static std::set<Verbosity> getSupportedVerbosities();
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-        void benchmarkPreparing(std::string const& name) override;
-        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-        void benchmarkFailed(std::string const&) override;
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-        void testRunStarting( TestRunInfo const& testRunInfo ) override;
-        void testGroupStarting( GroupInfo const& groupInfo ) override;
-        void testCaseStarting( TestCaseInfo const& testInfo ) override;
-        void sectionStarting( SectionInfo const& sectionInfo ) override;
-        void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
-        // The return value indicates if the messages buffer should be cleared:
-        bool assertionEnded( AssertionStats const& assertionStats ) override;
-        void sectionEnded( SectionStats const& sectionStats ) override;
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-        void testRunEnded( TestRunStats const& testRunStats ) override;
-
-        void skipTest( TestCaseInfo const& testInfo ) override;
-        bool isMulti() const override;
-
-    };
-
-} // end namespace Catch
-
-// end catch_reporter_listening.h
-namespace Catch {
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
-    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-    std::ostream& ReporterConfig::stream() const { return *m_stream; }
-    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
-
-    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
-
-    GroupInfo::GroupInfo(  std::string const& _name,
-                           std::size_t _groupIndex,
-                           std::size_t _groupsCount )
-    :   name( _name ),
-        groupIndex( _groupIndex ),
-        groupsCounts( _groupsCount )
-    {}
-
-     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
-                                     std::vector<MessageInfo> const& _infoMessages,
-                                     Totals const& _totals )
-    :   assertionResult( _assertionResult ),
-        infoMessages( _infoMessages ),
-        totals( _totals )
-    {
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
-        if( assertionResult.hasMessage() ) {
-            // Copy message into messages list.
-            // !TBD This should have been done earlier, somewhere
-            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-            builder << assertionResult.getMessage();
-            builder.m_info.message = builder.m_stream.str();
-
-            infoMessages.push_back( builder.m_info );
-        }
-    }
-
-     AssertionStats::~AssertionStats() = default;
-
-    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
-                                 Counts const& _assertions,
-                                 double _durationInSeconds,
-                                 bool _missingAssertions )
-    :   sectionInfo( _sectionInfo ),
-        assertions( _assertions ),
-        durationInSeconds( _durationInSeconds ),
-        missingAssertions( _missingAssertions )
-    {}
-
-    SectionStats::~SectionStats() = default;
-
-    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
-                                   Totals const& _totals,
-                                   std::string const& _stdOut,
-                                   std::string const& _stdErr,
-                                   bool _aborting )
-    : testInfo( _testInfo ),
-        totals( _totals ),
-        stdOut( _stdOut ),
-        stdErr( _stdErr ),
-        aborting( _aborting )
-    {}
-
-    TestCaseStats::~TestCaseStats() = default;
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
-                                    Totals const& _totals,
-                                    bool _aborting )
-    :   groupInfo( _groupInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
-    :   groupInfo( _groupInfo ),
-        aborting( false )
-    {}
-
-    TestGroupStats::~TestGroupStats() = default;
-
-    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
-                    Totals const& _totals,
-                    bool _aborting )
-    :   runInfo( _runInfo ),
-        totals( _totals ),
-        aborting( _aborting )
-    {}
-
-    TestRunStats::~TestRunStats() = default;
-
-    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
-    bool IStreamingReporter::isMulti() const { return false; }
-
-    IReporterFactory::~IReporterFactory() = default;
-    IReporterRegistry::~IReporterRegistry() = default;
-
-} // end namespace Catch
-// end catch_interfaces_reporter.cpp
-// start catch_interfaces_runner.cpp
-
-namespace Catch {
-    IRunner::~IRunner() = default;
-}
-// end catch_interfaces_runner.cpp
-// start catch_interfaces_testcase.cpp
-
-namespace Catch {
-    ITestInvoker::~ITestInvoker() = default;
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
-}
-// end catch_interfaces_testcase.cpp
-// start catch_leak_detector.cpp
-
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-
-namespace Catch {
-
-    LeakDetector::LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-}
-
-#else
-
-    Catch::LeakDetector::LeakDetector() {}
-
-#endif
-
-Catch::LeakDetector::~LeakDetector() {
-    Catch::cleanUp();
-}
-// end catch_leak_detector.cpp
-// start catch_list.cpp
-
-// start catch_list.h
-
-#include <set>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config );
-
-    std::size_t listTestsNamesOnly( Config const& config );
-
-    struct TagInfo {
-        void add( std::string const& spelling );
-        std::string all() const;
-
-        std::set<std::string> spellings;
-        std::size_t count = 0;
-    };
-
-    std::size_t listTags( Config const& config );
-
-    std::size_t listReporters();
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config );
-
-} // end namespace Catch
-
-// end catch_list.h
-// start catch_text.h
-
-namespace Catch {
-    using namespace clara::TextFlow;
-}
-
-// end catch_text.h
-#include <limits>
-#include <algorithm>
-#include <iomanip>
-
-namespace Catch {
-
-    std::size_t listTests( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-        }
-
-        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
-            if( config.verbosity() >= Verbosity::High ) {
-                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Column( description ).indent(4) << std::endl;
-            }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
-        }
-
-        if( !config.hasTestFilters() )
-            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
-        return matchedTestCases.size();
-    }
-
-    std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCaseInfo : matchedTestCases ) {
-            matchedTests++;
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.verbosity() >= Verbosity::High )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
-
-    void TagInfo::add( std::string const& spelling ) {
-        ++count;
-        spellings.insert( spelling );
-    }
-
-    std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
-        return out;
-    }
-
-    std::size_t listTags( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
-        if( config.hasTestFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( auto const& testCase : matchedTestCases ) {
-            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
-                std::string lcaseTagName = toLower( tagName );
-                auto countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( auto const& tagCount : tagCounts ) {
-            ReusableStringStream rss;
-            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
-            auto str = rss.str();
-            auto wrapper = Column( tagCount.second.all() )
-                                                    .initialIndent( 0 )
-                                                    .indent( str.size() )
-                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
-            Catch::cout() << str << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
-
-    std::size_t listReporters() {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        std::size_t maxNameLen = 0;
-        for( auto const& factoryKvp : factories )
-            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
-
-        for( auto const& factoryKvp : factories ) {
-            Catch::cout()
-                    << Column( factoryKvp.first + ":" )
-                            .indent(2)
-                            .width( 5+maxNameLen )
-                    +  Column( factoryKvp.second->getDescription() )
-                            .initialIndent(0)
-                            .indent(2)
-                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
-                    << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
-        Option<std::size_t> listedCount;
-        getCurrentMutableContext().setConfig( config );
-        if( config->listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( *config );
-        if( config->listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
-        if( config->listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( *config );
-        if( config->listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters();
-        return listedCount;
-    }
-
-} // end namespace Catch
-// end catch_list.cpp
-// start catch_matchers.cpp
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-        std::string MatcherUntypedBase::toString() const {
-            if( m_cachedToString.empty() )
-                m_cachedToString = describe();
-            return m_cachedToString;
-        }
-
-        MatcherUntypedBase::~MatcherUntypedBase() = default;
-
-    } // namespace Impl
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-// end catch_matchers.cpp
-// start catch_matchers_exception.cpp
-
-namespace Catch {
-namespace Matchers {
-namespace Exception {
-
-bool ExceptionMessageMatcher::match(std::exception const& ex) const {
-    return ex.what() == m_message;
-}
-
-std::string ExceptionMessageMatcher::describe() const {
-    return "exception message matches \"" + m_message + "\"";
-}
-
-}
-Exception::ExceptionMessageMatcher Message(std::string const& message) {
-    return Exception::ExceptionMessageMatcher(message);
-}
-
-// namespace Exception
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_exception.cpp
-// start catch_matchers_floating.cpp
-
-// start catch_polyfills.hpp
-
-namespace Catch {
-    bool isnan(float f);
-    bool isnan(double d);
-}
-
-// end catch_polyfills.hpp
-// start catch_to_string.hpp
-
-#include <string>
-
-namespace Catch {
-    template <typename T>
-    std::string to_string(T const& t) {
-#if defined(CATCH_CONFIG_CPP11_TO_STRING)
-        return std::to_string(t);
-#else
-        ReusableStringStream rss;
-        rss << t;
-        return rss.str();
-#endif
-    }
-} // end namespace Catch
-
-// end catch_to_string.hpp
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-#include <sstream>
-#include <type_traits>
-#include <iomanip>
-#include <limits>
-
-namespace Catch {
-namespace {
-
-    int32_t convert(float f) {
-        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-        int32_t i;
-        std::memcpy(&i, &f, sizeof(f));
-        return i;
-    }
-
-    int64_t convert(double d) {
-        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-        int64_t i;
-        std::memcpy(&i, &d, sizeof(d));
-        return i;
-    }
-
-    template <typename FP>
-    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
-        // Comparison with NaN should always be false.
-        // This way we can rule it out before getting into the ugly details
-        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
-            return false;
-        }
-
-        auto lc = convert(lhs);
-        auto rc = convert(rhs);
-
-        if ((lc < 0) != (rc < 0)) {
-            // Potentially we can have +0 and -0
-            return lhs == rhs;
-        }
-
-        auto ulpDiff = std::abs(lc - rc);
-        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
-    }
-
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-
-    float nextafter(float x, float y) {
-        return ::nextafterf(x, y);
-    }
-
-    double nextafter(double x, double y) {
-        return ::nextafter(x, y);
-    }
-
-#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
-
-template <typename FP>
-FP step(FP start, FP direction, uint64_t steps) {
-    for (uint64_t i = 0; i < steps; ++i) {
-#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-        start = Catch::nextafter(start, direction);
-#else
-        start = std::nextafter(start, direction);
-#endif
-    }
-    return start;
-}
-
-// Performs equivalent check of std::fabs(lhs - rhs) <= margin
-// But without the subtraction to allow for INFINITY in comparison
-bool marginComparison(double lhs, double rhs, double margin) {
-    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-}
-
-template <typename FloatingPoint>
-void write(std::ostream& out, FloatingPoint num) {
-    out << std::scientific
-        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
-        << num;
-}
-
-} // end anonymous namespace
-
-namespace Matchers {
-namespace Floating {
-
-    enum class FloatingPointKind : uint8_t {
-        Float,
-        Double
-    };
-
-    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
-        :m_target{ target }, m_margin{ margin } {
-        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
-            << " Margin has to be non-negative.");
-    }
-
-    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-    // But without the subtraction to allow for INFINITY in comparison
-    bool WithinAbsMatcher::match(double const& matchee) const {
-        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
-    }
-
-    std::string WithinAbsMatcher::describe() const {
-        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
-    }
-
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
-        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        CATCH_ENFORCE(m_type == FloatingPointKind::Double
-                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
-            "Provided ULP is impossibly large for a float comparison.");
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-// Clang <3.5 reports on the default branch in the switch below
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-
-    bool WithinUlpsMatcher::match(double const& matchee) const {
-        switch (m_type) {
-        case FloatingPointKind::Float:
-            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
-        case FloatingPointKind::Double:
-            return almostEqualUlps<double>(matchee, m_target, m_ulps);
-        default:
-            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
-        }
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    std::string WithinUlpsMatcher::describe() const {
-        std::stringstream ret;
-
-        ret << "is within " << m_ulps << " ULPs of ";
-
-        if (m_type == FloatingPointKind::Float) {
-            write(ret, static_cast<float>(m_target));
-            ret << 'f';
-        } else {
-            write(ret, m_target);
-        }
-
-        ret << " ([";
-        if (m_type == FloatingPointKind::Double) {
-            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
-        } else {
-            // We have to cast INFINITY to float because of MinGW, see #1782
-            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
-            ret << ", ";
-            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
-        }
-        ret << "])";
-
-        return ret.str();
-    }
-
-    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
-        m_target(target),
-        m_epsilon(epsilon){
-        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
-        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
-    }
-
-    bool WithinRelMatcher::match(double const& matchee) const {
-        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
-        return marginComparison(matchee, m_target,
-                                std::isinf(relMargin)? 0 : relMargin);
-    }
-
-    std::string WithinRelMatcher::describe() const {
-        Catch::ReusableStringStream sstr;
-        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
-        return sstr.str();
-    }
-
-}// namespace Floating
-
-Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
-}
-
-Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
-    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
-}
-
-Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
-    return Floating::WithinAbsMatcher(target, margin);
-}
-
-Floating::WithinRelMatcher WithinRel(double target, double eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(double target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
-}
-
-Floating::WithinRelMatcher WithinRel(float target, float eps) {
-    return Floating::WithinRelMatcher(target, eps);
-}
-
-Floating::WithinRelMatcher WithinRel(float target) {
-    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
-}
-
-} // namespace Matchers
-} // namespace Catch
-
-// end catch_matchers_floating.cpp
-// start catch_matchers_generic.cpp
-
-std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
-    if (desc.empty()) {
-        return "matches undescribed predicate";
-    } else {
-        return "matches predicate: \"" + desc + '"';
-    }
-}
-// end catch_matchers_generic.cpp
-// start catch_matchers_string.cpp
-
-#include <regex>
-
-namespace Catch {
-namespace Matchers {
-
-    namespace StdString {
-
-        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_str( adjustString( str ) )
-        {}
-        std::string CasedString::adjustString( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? toLower( str )
-                   : str;
-        }
-        std::string CasedString::caseSensitivitySuffix() const {
-            return m_caseSensitivity == CaseSensitive::No
-                   ? " (case insensitive)"
-                   : std::string();
-        }
-
-        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
-        : m_comparator( comparator ),
-          m_operation( operation ) {
-        }
-
-        std::string StringMatcherBase::describe() const {
-            std::string description;
-            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                        m_comparator.caseSensitivitySuffix().size());
-            description += m_operation;
-            description += ": \"";
-            description += m_comparator.m_str;
-            description += "\"";
-            description += m_comparator.caseSensitivitySuffix();
-            return description;
-        }
-
-        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-        bool EqualsMatcher::match( std::string const& source ) const {
-            return m_comparator.adjustString( source ) == m_comparator.m_str;
-        }
-
-        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-        bool ContainsMatcher::match( std::string const& source ) const {
-            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-        bool StartsWithMatcher::match( std::string const& source ) const {
-            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-        bool EndsWithMatcher::match( std::string const& source ) const {
-            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-        }
-
-        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
-
-        bool RegexMatcher::match(std::string const& matchee) const {
-            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-            if (m_caseSensitivity == CaseSensitive::Choice::No) {
-                flags |= std::regex::icase;
-            }
-            auto reg = std::regex(m_regex, flags);
-            return std::regex_match(matchee, reg);
-        }
-
-        std::string RegexMatcher::describe() const {
-            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
-        }
-
-    } // namespace StdString
-
-    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
-        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
-    }
-
-    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
-        return StdString::RegexMatcher(regex, caseSensitivity);
-    }
-
-} // namespace Matchers
-} // namespace Catch
-// end catch_matchers_string.cpp
-// start catch_message.cpp
-
-// start catch_uncaught_exceptions.h
-
-namespace Catch {
-    bool uncaught_exceptions();
-} // end namespace Catch
-
-// end catch_uncaught_exceptions.h
-#include <cassert>
-#include <stack>
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   StringRef const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    bool MessageInfo::operator==( MessageInfo const& other ) const {
-        return sequence == other.sequence;
-    }
-
-    bool MessageInfo::operator<( MessageInfo const& other ) const {
-        return sequence < other.sequence;
-    }
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
-                                           SourceLineInfo const& lineInfo,
-                                           ResultWas::OfType type )
-        :m_info(macroName, lineInfo, type) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info ), m_moved()
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-
-    ScopedMessage::ScopedMessage( ScopedMessage&& old )
-    : m_info( old.m_info ), m_moved()
-    {
-        old.m_moved = true;
-    }
-
-    ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() && !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
-    }
-
-    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
-        auto trimmed = [&] (size_t start, size_t end) {
-            while (names[start] == ',' || isspace(names[start])) {
-                ++start;
-            }
-            while (names[end] == ',' || isspace(names[end])) {
-                --end;
-            }
-            return names.substr(start, end - start + 1);
-        };
-        auto skipq = [&] (size_t start, char quote) {
-            for (auto i = start + 1; i < names.size() ; ++i) {
-                if (names[i] == quote)
-                    return i;
-                if (names[i] == '\\')
-                    ++i;
-            }
-            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
-        };
-
-        size_t start = 0;
-        std::stack<char> openings;
-        for (size_t pos = 0; pos < names.size(); ++pos) {
-            char c = names[pos];
-            switch (c) {
-            case '[':
-            case '{':
-            case '(':
-            // It is basically impossible to disambiguate between
-            // comparison and start of template args in this context
-//            case '<':
-                openings.push(c);
-                break;
-            case ']':
-            case '}':
-            case ')':
-//           case '>':
-                openings.pop();
-                break;
-            case '"':
-            case '\'':
-                pos = skipq(pos, c);
-                break;
-            case ',':
-                if (start != pos && openings.empty()) {
-                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
-                    start = pos;
-                }
-            }
-        }
-        assert(openings.empty() && "Mismatched openings");
-        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
-    }
-    Capturer::~Capturer() {
-        if ( !uncaught_exceptions() ){
-            assert( m_captured == m_messages.size() );
-            for( size_t i = 0; i < m_captured; ++i  )
-                m_resultCapture.popScopedMessage( m_messages[i] );
-        }
-    }
-
-    void Capturer::captureValue( size_t index, std::string const& value ) {
-        assert( index < m_messages.size() );
-        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
-        m_captured++;
-    }
-
-} // end namespace Catch
-// end catch_message.cpp
-// start catch_output_redirect.cpp
-
-// start catch_output_redirect.h
-#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-
-#include <cstdio>
-#include <iosfwd>
-#include <string>
-
-namespace Catch {
-
-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-    class OutputRedirect {
-    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
-    };
-
-#endif
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
-// end catch_output_redirect.h
-#include <cstdio>
-#include <cstring>
-#include <fstream>
-#include <sstream>
-#include <stdexcept>
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
-#endif
-
-namespace Catch {
-
-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
-        m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
-        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
-    }
-
-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
-    }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
-    }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
-        }
-        if (fopen_s(&m_file, m_buffer, "w")) {
-            char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
-            }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
-        }
-    }
-#else
-    TempFile::TempFile() {
-        m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
-        }
-    }
-
-#endif
-
-    TempFile::~TempFile() {
-         // TBD: What to do about errors here?
-         std::fclose(m_file);
-         // We manually create the file on Windows only, on Linux
-         // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
-    }
-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
-            sstr << buffer;
-        }
-        return sstr.str();
-    }
-
-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
-
-    OutputRedirect::~OutputRedirect() {
-        Catch::cout() << std::flush;
-        fflush(stdout);
-        // Since we support overriding these streams, we flush cerr
-        // even though std::cerr is unbuffered
-        Catch::cerr() << std::flush;
-        Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
-    }
-
-#endif // CATCH_CONFIG_NEW_CAPTURE
-
-} // namespace Catch
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
-#endif
-// end catch_output_redirect.cpp
-// start catch_polyfills.cpp
-
-#include <cmath>
-
-namespace Catch {
-
-#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
-    bool isnan(float f) {
-        return std::isnan(f);
-    }
-    bool isnan(double d) {
-        return std::isnan(d);
-    }
-#else
-    // For now we only use this for embarcadero
-    bool isnan(float f) {
-        return std::_isnan(f);
-    }
-    bool isnan(double d) {
-        return std::_isnan(d);
-    }
-#endif
-
-} // end namespace Catch
-// end catch_polyfills.cpp
-// start catch_random_number_generator.cpp
-
-namespace Catch {
-
-namespace {
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4146) // we negate uint32 during the rotate
-#endif
-        // Safe rotr implementation thanks to John Regehr
-        uint32_t rotate_right(uint32_t val, uint32_t count) {
-            const uint32_t mask = 31;
-            count &= mask;
-            return (val >> count) | (val << (-count & mask));
-        }
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-}
-
-    SimplePcg32::SimplePcg32(result_type seed_) {
-        seed(seed_);
-    }
-
-    void SimplePcg32::seed(result_type seed_) {
-        m_state = 0;
-        (*this)();
-        m_state += seed_;
-        (*this)();
-    }
-
-    void SimplePcg32::discard(uint64_t skip) {
-        // We could implement this to run in O(log n) steps, but this
-        // should suffice for our use case.
-        for (uint64_t s = 0; s < skip; ++s) {
-            static_cast<void>((*this)());
-        }
-    }
-
-    SimplePcg32::result_type SimplePcg32::operator()() {
-        // prepare the output value
-        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
-
-        // advance state
-        m_state = m_state * 6364136223846793005ULL + s_inc;
-
-        return output;
-    }
-
-    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state == rhs.m_state;
-    }
-
-    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
-        return lhs.m_state != rhs.m_state;
-    }
-}
-// end catch_random_number_generator.cpp
-// start catch_registry_hub.cpp
-
-// start catch_test_case_registry_impl.h
-
-#include <vector>
-#include <set>
-#include <algorithm>
-#include <ios>
-
-namespace Catch {
-
-    class TestCase;
-    struct IConfig;
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        virtual ~TestRegistry() = default;
-
-        virtual void registerTest( TestCase const& testCase );
-
-        std::vector<TestCase> const& getAllTests() const override;
-        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        std::size_t m_unnamedCount = 0;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class TestInvokerAsFunction : public ITestInvoker {
-        void(*m_testAsFunction)();
-    public:
-        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
-
-        void invoke() const override;
-    };
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
-
-    ///////////////////////////////////////////////////////////////////////////
-
-} // end namespace Catch
-
-// end catch_test_case_registry_impl.h
-// start catch_reporter_registry.h
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        ~ReporterRegistry() override;
-
-        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
-
-        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
-        void registerListener( IReporterFactoryPtr const& factory );
-
-        FactoryMap const& getFactories() const override;
-        Listeners const& getListeners() const override;
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// end catch_reporter_registry.h
-// start catch_tag_alias_registry.h
-
-// start catch_tag_alias.h
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias.h
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-// end catch_tag_alias_registry.h
-// start catch_startup_exception_registry.h
-
-#include <vector>
-#include <exception>
-
-namespace Catch {
-
-    class StartupExceptionRegistry {
-    public:
-        void add(std::exception_ptr const& exception) noexcept;
-        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
-    private:
-        std::vector<std::exception_ptr> m_exceptions;
-    };
-
-} // end namespace Catch
-
-// end catch_startup_exception_registry.h
-// start catch_singletons.hpp
-
-namespace Catch {
-
-    struct ISingleton {
-        virtual ~ISingleton();
-    };
-
-    void addSingleton( ISingleton* singleton );
-    void cleanupSingletons();
-
-    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
-    class Singleton : SingletonImplT, public ISingleton {
-
-        static auto getInternal() -> Singleton* {
-            static Singleton* s_instance = nullptr;
-            if( !s_instance ) {
-                s_instance = new Singleton;
-                addSingleton( s_instance );
-            }
-            return s_instance;
-        }
-
-    public:
-        static auto get() -> InterfaceT const& {
-            return *getInternal();
-        }
-        static auto getMutable() -> MutableInterfaceT& {
-            return *getInternal();
-        }
-    };
-
-} // namespace Catch
-
-// end catch_singletons.hpp
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
-                            private NonCopyable {
-
-        public: // IRegistryHub
-            RegistryHub() = default;
-            IReporterRegistry const& getReporterRegistry() const override {
-                return m_reporterRegistry;
-            }
-            ITestCaseRegistry const& getTestCaseRegistry() const override {
-                return m_testCaseRegistry;
-            }
-            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
-                return m_exceptionTranslatorRegistry;
-            }
-            ITagAliasRegistry const& getTagAliasRegistry() const override {
-                return m_tagAliasRegistry;
-            }
-            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
-                return m_exceptionRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            void registerListener( IReporterFactoryPtr const& factory ) override {
-                m_reporterRegistry.registerListener( factory );
-            }
-            void registerTest( TestCase const& testInfo ) override {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            void registerTranslator( const IExceptionTranslator* translator ) override {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-            void registerStartupException() noexcept override {
-                m_exceptionRegistry.add(std::current_exception());
-            }
-            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
-                return m_enumValuesRegistry;
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-            StartupExceptionRegistry m_exceptionRegistry;
-            Detail::EnumValuesRegistry m_enumValuesRegistry;
-        };
-    }
-
-    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
-
-    IRegistryHub const& getRegistryHub() {
-        return RegistryHubSingleton::get();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return RegistryHubSingleton::getMutable();
-    }
-    void cleanUp() {
-        cleanupSingletons();
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-// end catch_registry_hub.cpp
-// start catch_reporter_registry.cpp
-
-namespace Catch {
-
-    ReporterRegistry::~ReporterRegistry() = default;
-
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
-        auto it =  m_factories.find( name );
-        if( it == m_factories.end() )
-            return nullptr;
-        return it->second->create( ReporterConfig( config ) );
-    }
-
-    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
-        m_factories.emplace(name, factory);
-    }
-    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
-        m_listeners.push_back( factory );
-    }
-
-    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
-        return m_factories;
-    }
-    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
-        return m_listeners;
-    }
-
-}
-// end catch_reporter_registry.cpp
-// start catch_result_type.cpp
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-// end catch_result_type.cpp
-// start catch_run_context.cpp
-
-#include <cassert>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace Generators {
-        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
-            GeneratorBasePtr m_generator;
-
-            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-            :   TrackerBase( nameAndLocation, ctx, parent )
-            {}
-            ~GeneratorTracker();
-
-            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
-                std::shared_ptr<GeneratorTracker> tracker;
-
-                ITracker& currentTracker = ctx.currentTracker();
-                if( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                    assert( childTracker );
-                    assert( childTracker->isGeneratorTracker() );
-                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
-                }
-                else {
-                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
-                    currentTracker.addChild( tracker );
-                }
-
-                if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                    tracker->open();
-                }
-
-                return *tracker;
-            }
-
-            // TrackerBase interface
-            bool isGeneratorTracker() const override { return true; }
-            auto hasGenerator() const -> bool override {
-                return !!m_generator;
-            }
-            void close() override {
-                TrackerBase::close();
-                // Generator interface only finds out if it has another item on atual move
-                if (m_runState == CompletedSuccessfully && m_generator->next()) {
-                    m_children.clear();
-                    m_runState = Executing;
-                }
-            }
-
-            // IGeneratorTracker interface
-            auto getGenerator() const -> GeneratorBasePtr const& override {
-                return m_generator;
-            }
-            void setGenerator( GeneratorBasePtr&& generator ) override {
-                m_generator = std::move( generator );
-            }
-        };
-        GeneratorTracker::~GeneratorTracker() {}
-    }
-
-    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
-    :   m_runInfo(_config->name()),
-        m_context(getCurrentMutableContext()),
-        m_config(_config),
-        m_reporter(std::move(reporter)),
-        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
-    {
-        m_context.setRunner(this);
-        m_context.setConfig(m_config);
-        m_context.setResultCapture(this);
-        m_reporter->testRunStarting(m_runInfo);
-    }
-
-    RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
-    }
-
-    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
-    }
-
-    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
-        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
-    }
-
-    Totals RunContext::runTest(TestCase const& testCase) {
-        Totals prevTotals = m_totals;
-
-        std::string redirectedCout;
-        std::string redirectedCerr;
-
-        auto const& testInfo = testCase.getTestCaseInfo();
-
-        m_reporter->testCaseStarting(testInfo);
-
-        m_activeTestCase = &testCase;
-
-        ITracker& rootTracker = m_trackerContext.startRun();
-        assert(rootTracker.isSectionTracker());
-        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
-        do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
-            runCurrentTest(redirectedCout, redirectedCerr);
-        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
-
-        Totals deltaTotals = m_totals.delta(prevTotals);
-        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
-            deltaTotals.assertions.failed++;
-            deltaTotals.testCases.passed--;
-            deltaTotals.testCases.failed++;
-        }
-        m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  redirectedCout,
-                                  redirectedCerr,
-                                  aborting()));
-
-        m_activeTestCase = nullptr;
-        m_testCaseTracker = nullptr;
-
-        return deltaTotals;
-    }
-
-    IConfigPtr RunContext::config() const {
-        return m_config;
-    }
-
-    IStreamingReporter& RunContext::reporter() const {
-        return *m_reporter;
-    }
-
-    void RunContext::assertionEnded(AssertionResult const & result) {
-        if (result.getResultType() == ResultWas::Ok) {
-            m_totals.assertions.passed++;
-            m_lastAssertionPassed = true;
-        } else if (!result.isOk()) {
-            m_lastAssertionPassed = false;
-            if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                m_totals.assertions.failedButOk++;
-            else
-                m_totals.assertions.failed++;
-        }
-        else {
-            m_lastAssertionPassed = true;
-        }
-
-        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-        // and should be let to clear themselves out.
-        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-        if (result.getResultType() != ResultWas::Warning)
-            m_messageScopes.clear();
-
-        // Reset working state
-        resetAssertionInfo();
-        m_lastResult = result;
-    }
-    void RunContext::resetAssertionInfo() {
-        m_lastAssertionInfo.macroName = StringRef();
-        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
-    }
-
-    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
-        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
-        if (!sectionTracker.isOpen())
-            return false;
-        m_activeSections.push_back(&sectionTracker);
-
-        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-        m_reporter->sectionStarting(sectionInfo);
-
-        assertions = m_totals.assertions;
-
-        return true;
-    }
-    auto RunContext::acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        using namespace Generators;
-        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
-        assert( tracker.isOpen() );
-        m_lastAssertionInfo.lineInfo = lineInfo;
-        return tracker;
-    }
-
-    bool RunContext::testForMissingAssertions(Counts& assertions) {
-        if (assertions.total() != 0)
-            return false;
-        if (!m_config->warnAboutMissingAssertions())
-            return false;
-        if (m_trackerContext.currentTracker().hasChildren())
-            return false;
-        m_totals.assertions.failed++;
-        assertions.failed++;
-        return true;
-    }
-
-    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
-        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
-        }
-
-        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
-    }
-
-    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
-        if (m_unfinishedSections.empty())
-            m_activeSections.back()->fail();
-        else
-            m_activeSections.back()->close();
-        m_activeSections.pop_back();
-
-        m_unfinishedSections.push_back(endInfo);
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void RunContext::benchmarkPreparing(std::string const& name) {
-		m_reporter->benchmarkPreparing(name);
-	}
-    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
-    }
-    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
-    }
-	void RunContext::benchmarkFailed(std::string const & error) {
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
-    }
-
-    void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
-    }
-
-    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
-        m_messageScopes.emplace_back( builder );
-    }
-
-    std::string RunContext::getCurrentTestName() const {
-        return m_activeTestCase
-            ? m_activeTestCase->getTestCaseInfo().name
-            : std::string();
-    }
-
-    const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
-    }
-
-    void RunContext::exceptionEarlyReported() {
-        m_shouldReportUnexpected = false;
-    }
-
-    void RunContext::handleFatalErrorCondition( StringRef message ) {
-        // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
-
-        // Don't rebuild the result -- the stringification itself can cause more fatal errors
-        // Instead, fake a result data.
-        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = static_cast<std::string>(message);
-        AssertionResult result(m_lastAssertionInfo, tempResult);
-
-        assertionEnded(result);
-
-        handleUnfinishedSections();
-
-        // Recreate section for test case (as we will lose the one that was in scope)
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-
-        Counts assertions;
-        assertions.failed = 1;
-        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
-
-        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
-
-        Totals deltaTotals;
-        deltaTotals.testCases.failed = 1;
-        deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  std::string(),
-                                  std::string(),
-                                  false));
-        m_totals.testCases.failed++;
-        testGroupEnded(std::string(), m_totals, 1, 1);
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
-    }
-
-    bool RunContext::lastAssertionPassed() {
-         return m_lastAssertionPassed;
-    }
-
-    void RunContext::assertionPassed() {
-        m_lastAssertionPassed = true;
-        ++m_totals.assertions.passed;
-        resetAssertionInfo();
-        m_messageScopes.clear();
-    }
-
-    bool RunContext::aborting() const {
-        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
-    }
-
-    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
-        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
-        Counts prevAssertions = m_totals.assertions;
-        double duration = 0;
-        m_shouldReportUnexpected = true;
-        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
-
-        seedRng(*m_config);
-
-        Timer timer;
-        CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
-
-                timer.start();
-                invokeActiveTestCase();
-#else
-                OutputRedirect r(redirectedCout, redirectedCerr);
-                timer.start();
-                invokeActiveTestCase();
-#endif
-            } else {
-                timer.start();
-                invokeActiveTestCase();
-            }
-            duration = timer.getElapsedSeconds();
-        } CATCH_CATCH_ANON (TestFailureException&) {
-            // This just means the test was aborted due to failure
-        } CATCH_CATCH_ALL {
-            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-            // are reported without translation at the point of origin.
-            if( m_shouldReportUnexpected ) {
-                AssertionReaction dummyReaction;
-                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
-            }
-        }
-        Counts assertions = m_totals.assertions - prevAssertions;
-        bool missingAssertions = testForMissingAssertions(assertions);
-
-        m_testCaseTracker->close();
-        handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
-
-        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
-    }
-
-    void RunContext::invokeActiveTestCase() {
-        FatalConditionHandler fatalConditionHandler; // Handle signals
-        m_activeTestCase->invoke();
-        fatalConditionHandler.reset();
-    }
-
-    void RunContext::handleUnfinishedSections() {
-        // If sections ended prematurely due to an exception we stored their
-        // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
-             it != itEnd;
-             ++it)
-            sectionEnded(*it);
-        m_unfinishedSections.clear();
-    }
-
-    void RunContext::handleExpr(
-        AssertionInfo const& info,
-        ITransientExpression const& expr,
-        AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        bool negated = isFalseTest( info.resultDisposition );
-        bool result = expr.getResult() != negated;
-
-        if( result ) {
-            if (!m_includeSuccessfulResults) {
-                assertionPassed();
-            }
-            else {
-                reportExpr(info, ResultWas::Ok, &expr, negated);
-            }
-        }
-        else {
-            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
-            populateReaction( reaction );
-        }
-    }
-    void RunContext::reportExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            ITransientExpression const *expr,
-            bool negated ) {
-
-        m_lastAssertionInfo = info;
-        AssertionResultData data( resultType, LazyExpression( negated ) );
-
-        AssertionResult assertionResult{ info, data };
-        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
-
-        assertionEnded( assertionResult );
-    }
-
-    void RunContext::handleMessage(
-            AssertionInfo const& info,
-            ResultWas::OfType resultType,
-            StringRef const& message,
-            AssertionReaction& reaction
-    ) {
-        m_reporter->assertionStarting( info );
-
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = static_cast<std::string>(message);
-        AssertionResult assertionResult{ m_lastAssertionInfo, data };
-        assertionEnded( assertionResult );
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-    void RunContext::handleUnexpectedExceptionNotThrown(
-            AssertionInfo const& info,
-            AssertionReaction& reaction
-    ) {
-        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
-    }
-
-    void RunContext::handleUnexpectedInflightException(
-            AssertionInfo const& info,
-            std::string const& message,
-            AssertionReaction& reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = message;
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-        populateReaction( reaction );
-    }
-
-    void RunContext::populateReaction( AssertionReaction& reaction ) {
-        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
-        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
-    }
-
-    void RunContext::handleIncomplete(
-            AssertionInfo const& info
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
-        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-    }
-    void RunContext::handleNonExpr(
-            AssertionInfo const &info,
-            ResultWas::OfType resultType,
-            AssertionReaction &reaction
-    ) {
-        m_lastAssertionInfo = info;
-
-        AssertionResultData data( resultType, LazyExpression( false ) );
-        AssertionResult assertionResult{ info, data };
-        assertionEnded( assertionResult );
-
-        if( !assertionResult.isOk() )
-            populateReaction( reaction );
-    }
-
-    IResultCapture& getResultCapture() {
-        if (auto* capture = getCurrentContext().getResultCapture())
-            return *capture;
-        else
-            CATCH_INTERNAL_ERROR("No result capture instance");
-    }
-
-    void seedRng(IConfig const& config) {
-        if (config.rngSeed() != 0) {
-            std::srand(config.rngSeed());
-            rng().seed(config.rngSeed());
-        }
-    }
-
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-}
-// end catch_run_context.cpp
-// start catch_section.cpp
-
-namespace Catch {
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
-            if( uncaught_exceptions() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
-        }
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-// end catch_section.cpp
-// start catch_section_info.cpp
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name )
-    :   name( _name ),
-        lineInfo( _lineInfo )
-    {}
-
-} // end namespace Catch
-// end catch_section_info.cpp
-// start catch_session.cpp
-
-// start catch_session.h
-
-#include <memory>
-
-namespace Catch {
-
-    class Session : NonCopyable {
-    public:
-
-        Session();
-        ~Session() override;
-
-        void showHelp() const;
-        void libIdentify();
-
-        int applyCommandLine( int argc, char const * const * argv );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-        int applyCommandLine( int argc, wchar_t const * const * argv );
-    #endif
-
-        void useConfigData( ConfigData const& configData );
-
-        template<typename CharT>
-        int run(int argc, CharT const * const argv[]) {
-            if (m_startupExceptions)
-                return 1;
-            int returnCode = applyCommandLine(argc, argv);
-            if (returnCode == 0)
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run();
-
-        clara::Parser const& cli() const;
-        void cli( clara::Parser const& newParser );
-        ConfigData& configData();
-        Config& config();
-    private:
-        int runInternal();
-
-        clara::Parser m_cli;
-        ConfigData m_configData;
-        std::shared_ptr<Config> m_config;
-        bool m_startupExceptions = false;
-    };
-
-} // end namespace Catch
-
-// end catch_session.h
-// start catch_version.h
-
-#include <iosfwd>
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version( Version const& ) = delete;
-        Version& operator=( Version const& ) = delete;
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-    };
-
-    Version const& libraryVersion();
-}
-
-// end catch_version.h
-#include <cstdlib>
-#include <iomanip>
-#include <set>
-#include <iterator>
-
-namespace Catch {
-
-    namespace {
-        const int MaxExitCode = 255;
-
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
-            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
-            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
-
-            return reporter;
-        }
-
-        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
-            }
-
-            // On older platforms, returning std::unique_ptr<ListeningReporter>
-            // when the return type is std::unique_ptr<IStreamingReporter>
-            // doesn't compile without a std::move call. However, this causes
-            // a warning on newer platforms. Thus, we have to work around
-            // it a bit and downcast the pointer manually.
-            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
-            auto& multi = static_cast<ListeningReporter&>(*ret);
-            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
-            for (auto const& listener : listeners) {
-                multi.addListener(listener->create(Catch::ReporterConfig(config)));
-            }
-            multi.addReporter(createReporter(config->getReporterName(), config));
-            return ret;
-        }
-
-        class TestGroup {
-        public:
-            explicit TestGroup(std::shared_ptr<Config> const& config)
-            : m_config{config}
-            , m_context{config, makeReporter(config)}
-            {
-                auto const& allTestCases = getAllTestCasesSorted(*m_config);
-                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-
-                if (m_matches.empty() && invalidArgs.empty()) {
-                    for (auto const& test : allTestCases)
-                        if (!test.isHidden())
-                            m_tests.emplace(&test);
-                } else {
-                    for (auto const& match : m_matches)
-                        m_tests.insert(match.tests.begin(), match.tests.end());
-                }
-            }
-
-            Totals execute() {
-                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-                Totals totals;
-                m_context.testGroupStarting(m_config->name(), 1, 1);
-                for (auto const& testCase : m_tests) {
-                    if (!m_context.aborting())
-                        totals += m_context.runTest(*testCase);
-                    else
-                        m_context.reporter().skipTest(*testCase);
-                }
-
-                for (auto const& match : m_matches) {
-                    if (match.tests.empty()) {
-                        m_context.reporter().noMatchingTestCases(match.name);
-                        totals.error = -1;
-                    }
-                }
-
-                if (!invalidArgs.empty()) {
-                    for (auto const& invalidArg: invalidArgs)
-                         m_context.reporter().reportInvalidArguments(invalidArg);
-                }
-
-                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
-                return totals;
-            }
-
-        private:
-            using Tests = std::set<TestCase const*>;
-
-            std::shared_ptr<Config> m_config;
-            RunContext m_context;
-            Tests m_tests;
-            TestSpec::Matches m_matches;
-        };
-
-        void applyFilenamesAsTags(Catch::IConfig const& config) {
-            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
-            for (auto& testCase : tests) {
-                auto tags = testCase.tags;
-
-                std::string filename = testCase.lineInfo.file;
-                auto lastSlash = filename.find_last_of("\\/");
-                if (lastSlash != std::string::npos) {
-                    filename.erase(0, lastSlash);
-                    filename[0] = '#';
-                }
-
-                auto lastDot = filename.find_last_of('.');
-                if (lastDot != std::string::npos) {
-                    filename.erase(lastDot);
-                }
-
-                tags.push_back(std::move(filename));
-                setTags(testCase, tags);
-            }
-        }
-
-    } // anon namespace
-
-    Session::Session() {
-        static bool alreadyInstantiated = false;
-        if( alreadyInstantiated ) {
-            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
-        }
-
-        // There cannot be exceptions at startup in no-exception mode.
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
-        if ( !exceptions.empty() ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-
-            m_startupExceptions = true;
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << "Errors occurred during startup!" << '\n';
-            // iterate over all exceptions and notify user
-            for ( const auto& ex_ptr : exceptions ) {
-                try {
-                    std::rethrow_exception(ex_ptr);
-                } catch ( std::exception const& ex ) {
-                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
-                }
-            }
-        }
-#endif
-
-        alreadyInstantiated = true;
-        m_cli = makeCommandLineParser( m_configData );
-    }
-    Session::~Session() {
-        Catch::cleanUp();
-    }
-
-    void Session::showHelp() const {
-        Catch::cout()
-                << "\nCatch v" << libraryVersion() << "\n"
-                << m_cli << std::endl
-                << "For more detailed usage please see the project docs\n" << std::endl;
-    }
-    void Session::libIdentify() {
-        Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
-                << std::left << std::setw(16) << "category: " << "testframework\n"
-                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-    }
-
-    int Session::applyCommandLine( int argc, char const * const * argv ) {
-        if( m_startupExceptions )
-            return 1;
-
-        auto result = m_cli.parse( clara::Args( argc, argv ) );
-        if( !result ) {
-            config();
-            getCurrentMutableContext().setConfig(m_config);
-            Catch::cerr()
-                << Colour( Colour::Red )
-                << "\nError(s) in input:\n"
-                << Column( result.errorMessage() ).indent( 2 )
-                << "\n\n";
-            Catch::cerr() << "Run with -? for usage\n" << std::endl;
-            return MaxExitCode;
-        }
-
-        if( m_configData.showHelp )
-            showHelp();
-        if( m_configData.libIdentify )
-            libIdentify();
-        m_config.reset();
-        return 0;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
-    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
-
-        char **utf8Argv = new char *[ argc ];
-
-        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
-
-            utf8Argv[ i ] = new char[ bufSize ];
-
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
-        }
-
-        int returnCode = applyCommandLine( argc, utf8Argv );
-
-        for ( int i = 0; i < argc; ++i )
-            delete [] utf8Argv[ i ];
-
-        delete [] utf8Argv;
-
-        return returnCode;
-    }
-#endif
-
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run() {
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        int exitCode = runInternal();
-        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-            static_cast<void>(std::getchar());
-        }
-        return exitCode;
-    }
-
-    clara::Parser const& Session::cli() const {
-        return m_cli;
-    }
-    void Session::cli( clara::Parser const& newParser ) {
-        m_cli = newParser;
-    }
-    ConfigData& Session::configData() {
-        return m_configData;
-    }
-    Config& Session::config() {
-        if( !m_config )
-            m_config = std::make_shared<Config>( m_configData );
-        return *m_config;
-    }
-
-    int Session::runInternal() {
-        if( m_startupExceptions )
-            return 1;
-
-        if (m_configData.showHelp || m_configData.libIdentify) {
-            return 0;
-        }
-
-        CATCH_TRY {
-            config(); // Force config to be constructed
-
-            seedRng( *m_config );
-
-            if( m_configData.filenamesAsTags )
-                applyFilenamesAsTags( *m_config );
-
-            // Handle list request
-            if( Option<std::size_t> listed = list( m_config ) )
-                return static_cast<int>( *listed );
-
-            TestGroup tests { m_config };
-            auto const totals = tests.execute();
-
-            if( m_config->warnAboutNoTests() && totals.error == -1 )
-                return 2;
-
-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
-        }
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-        catch( std::exception& ex ) {
-            Catch::cerr() << ex.what() << std::endl;
-            return MaxExitCode;
-        }
-#endif
-    }
-
-} // end namespace Catch
-// end catch_session.cpp
-// start catch_singletons.cpp
-
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        static auto getSingletons() -> std::vector<ISingleton*>*& {
-            static std::vector<ISingleton*>* g_singletons = nullptr;
-            if( !g_singletons )
-                g_singletons = new std::vector<ISingleton*>();
-            return g_singletons;
-        }
-    }
-
-    ISingleton::~ISingleton() {}
-
-    void addSingleton(ISingleton* singleton ) {
-        getSingletons()->push_back( singleton );
-    }
-    void cleanupSingletons() {
-        auto& singletons = getSingletons();
-        for( auto singleton : *singletons )
-            delete singleton;
-        delete singletons;
-        singletons = nullptr;
-    }
-
-} // namespace Catch
-// end catch_singletons.cpp
-// start catch_startup_exception_registry.cpp
-
-namespace Catch {
-void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        CATCH_TRY {
-            m_exceptions.push_back(exception);
-        } CATCH_CATCH_ALL {
-            // If we run out of memory during start-up there's really not a lot more we can do about it
-            std::terminate();
-        }
-    }
-
-    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
-        return m_exceptions;
-    }
-
-} // end namespace Catch
-// end catch_startup_exception_registry.cpp
-// start catch_stream.cpp
-
-#include <cstdio>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    Catch::IStream::~IStream() = default;
-
-    namespace Detail { namespace {
-        template<typename WriterF, std::size_t bufferSize=256>
-        class StreamBufImpl : public std::streambuf {
-            char data[bufferSize];
-            WriterF m_writer;
-
-        public:
-            StreamBufImpl() {
-                setp( data, data + sizeof(data) );
-            }
-
-            ~StreamBufImpl() noexcept {
-                StreamBufImpl::sync();
-            }
-
-        private:
-            int overflow( int c ) override {
-                sync();
-
-                if( c != EOF ) {
-                    if( pbase() == epptr() )
-                        m_writer( std::string( 1, static_cast<char>( c ) ) );
-                    else
-                        sputc( static_cast<char>( c ) );
-                }
-                return 0;
-            }
-
-            int sync() override {
-                if( pbase() != pptr() ) {
-                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                    setp( pbase(), epptr() );
-                }
-                return 0;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        struct OutputDebugWriter {
-
-            void operator()( std::string const&str ) {
-                writeToDebugConsole( str );
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class FileStream : public IStream {
-            mutable std::ofstream m_ofs;
-        public:
-            FileStream( StringRef filename ) {
-                m_ofs.open( filename.c_str() );
-                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
-            }
-            ~FileStream() override = default;
-        public: // IStream
-            std::ostream& stream() const override {
-                return m_ofs;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class CoutStream : public IStream {
-            mutable std::ostream m_os;
-        public:
-            // Store the streambuf from cout up-front because
-            // cout may get redirected when running tests
-            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
-            ~CoutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        class DebugOutStream : public IStream {
-            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
-            mutable std::ostream m_os;
-        public:
-            DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-                m_os( m_streamBuf.get() )
-            {}
-
-            ~DebugOutStream() override = default;
-
-        public: // IStream
-            std::ostream& stream() const override { return m_os; }
-        };
-
-    }} // namespace anon::detail
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    auto makeStream( StringRef const &filename ) -> IStream const* {
-        if( filename.empty() )
-            return new Detail::CoutStream();
-        else if( filename[0] == '%' ) {
-            if( filename == "%debug" )
-                return new Detail::DebugOutStream();
-            else
-                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
-        }
-        else
-            return new Detail::FileStream( filename );
-    }
-
-    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
-    struct StringStreams {
-        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
-        std::vector<std::size_t> m_unused;
-        std::ostringstream m_referenceStream; // Used for copy state/ flags from
-
-        auto add() -> std::size_t {
-            if( m_unused.empty() ) {
-                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
-                return m_streams.size()-1;
-            }
-            else {
-                auto index = m_unused.back();
-                m_unused.pop_back();
-                return index;
-            }
-        }
-
-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
-        }
-    };
-
-    ReusableStringStream::ReusableStringStream()
-    :   m_index( Singleton<StringStreams>::getMutable().add() ),
-        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
-    {}
-
-    ReusableStringStream::~ReusableStringStream() {
-        static_cast<std::ostringstream*>( m_oss )->str("");
-        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
-    }
-
-    auto ReusableStringStream::str() const -> std::string {
-        return static_cast<std::ostringstream*>( m_oss )->str();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() { return std::cout; }
-    std::ostream& cerr() { return std::cerr; }
-    std::ostream& clog() { return std::clog; }
-#endif
-}
-// end catch_stream.cpp
-// start catch_string_manip.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cctype>
-#include <vector>
-
-namespace Catch {
-
-    namespace {
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    StringRef trim(StringRef ref) {
-        const auto is_ws = [](char c) {
-            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-        };
-        size_t real_begin = 0;
-        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
-        size_t real_end = ref.size();
-        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
-
-        return ref.substr(real_begin, real_end - real_begin);
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
-        std::vector<StringRef> subStrings;
-        std::size_t start = 0;
-        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
-            if( str[pos] == delimiter ) {
-                if( pos - start > 1 )
-                    subStrings.push_back( str.substr( start, pos-start ) );
-                start = pos+1;
-            }
-        }
-        if( start < str.size() )
-            subStrings.push_back( str.substr( start, str.size()-start ) );
-        return subStrings;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-}
-// end catch_string_manip.cpp
-// start catch_stringref.cpp
-
-#include <algorithm>
-#include <ostream>
-#include <cstring>
-#include <cstdint>
-
-namespace Catch {
-    StringRef::StringRef( char const* rawChars ) noexcept
-    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
-    {}
-
-    auto StringRef::c_str() const -> char const* {
-        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
-        return m_start;
-    }
-    auto StringRef::data() const noexcept -> char const* {
-        return m_start;
-    }
-
-    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if (start < m_size) {
-            return StringRef(m_start + start, (std::min)(m_size - start, size));
-        } else {
-            return StringRef();
-        }
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return m_size == other.m_size
-            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
-    }
-
-    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.data(), str.size());
-    }
-
-    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.data(), rhs.size());
-        return lhs;
-    }
-
-} // namespace Catch
-// end catch_stringref.cpp
-// start catch_tag_alias.cpp
-
-namespace Catch {
-    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
-}
-// end catch_tag_alias.cpp
-// start catch_tag_alias_autoregistrar.cpp
-
-namespace Catch {
-
-    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        CATCH_TRY {
-            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-}
-// end catch_tag_alias_autoregistrar.cpp
-// start catch_tag_alias_registry.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return &(it->second);
-        else
-            return nullptr;
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
-            std::size_t pos = expandedTestSpec.find( registryKvp.first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    registryKvp.second.tag +
-                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
-        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
-                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
-
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
-                      "error: tag alias, '" << alias << "' already registered.\n"
-                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
-                      << "\tRedefined at: " << lineInfo );
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
-
-} // end namespace Catch
-// end catch_tag_alias_registry.cpp
-// start catch_test_case_info.cpp
-
-#include <cctype>
-#include <exception>
-#include <algorithm>
-#include <sstream>
-
-namespace Catch {
-
-    namespace {
-        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-            if( startsWith( tag, '.' ) ||
-                tag == "!hide" )
-                return TestCaseInfo::IsHidden;
-            else if( tag == "!throws" )
-                return TestCaseInfo::Throws;
-            else if( tag == "!shouldfail" )
-                return TestCaseInfo::ShouldFail;
-            else if( tag == "!mayfail" )
-                return TestCaseInfo::MayFail;
-            else if( tag == "!nonportable" )
-                return TestCaseInfo::NonPortable;
-            else if( tag == "!benchmark" )
-                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-            else
-                return TestCaseInfo::None;
-        }
-        bool isReservedTag( std::string const& tag ) {
-            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-        }
-        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-            CATCH_ENFORCE( !isReservedTag(tag),
-                          "Tag name: [" << tag << "] is not allowed.\n"
-                          << "Tag names starting with non alphanumeric characters are reserved\n"
-                          << _lineInfo );
-        }
-    }
-
-    TestCase makeTestCase(  ITestInvoker* _testCase,
-                            std::string const& _className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden = false;
-
-        // Parse out tags
-        std::vector<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for (char c : nameAndTags.tags) {
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    // Merged hide tags like `[.approvals]` should be added as
-                    // `[.][approvals]`. The `[.]` is added at later point, so
-                    // we only strip the prefix
-                    if (startsWith(tag, '.') && tag.size() > 1) {
-                        tag.erase(0, 1);
-                    }
-                    tags.push_back( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            // Add all "hidden" tags to make them behave identically
-            tags.insert( tags.end(), { ".", "!hide" } );
-        }
-
-        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, std::move(info) );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
-        std::sort(begin(tags), end(tags));
-        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
-        testCaseInfo.lcaseTags.clear();
-
-        for( auto const& tag : tags ) {
-            std::string lcaseTag = toLower( tag );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.push_back( lcaseTag );
-        }
-        testCaseInfo.tags = std::move(tags);
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::vector<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    std::string TestCaseInfo::tagsAsString() const {
-        std::string ret;
-        // '[' and ']' per tag
-        std::size_t full_size = 2 * tags.size();
-        for (const auto& tag : tags) {
-            full_size += tag.size();
-        }
-        ret.reserve(full_size);
-        for (const auto& tag : tags) {
-            ret.push_back('[');
-            ret.append(tag);
-            ret.push_back(']');
-        }
-
-        return ret;
-    }
-
-    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-// end catch_test_case_info.cpp
-// start catch_test_case_registry_impl.cpp
-
-#include <sstream>
-
-namespace Catch {
-
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                std::shuffle( sorted.begin(), sorted.end(), rng() );
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
-        return !testCase.throws() || config.allowThrows();
-    }
-
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( auto const& function : functions ) {
-            auto prev = seenFunctions.insert( function );
-            CATCH_ENFORCE( prev.second,
-                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
-                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for (auto const& testCase : testCases) {
-            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
-                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
-                filtered.push_back(testCase);
-            }
-        }
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    void TestRegistry::registerTest( TestCase const& testCase ) {
-        std::string name = testCase.getTestCaseInfo().name;
-        if( name.empty() ) {
-            ReusableStringStream rss;
-            rss << "Anonymous test case " << ++m_unnamedCount;
-            return registerTest( testCase.withName( rss.str() ) );
-        }
-        m_functions.push_back( testCase );
-    }
-
-    std::vector<TestCase> const& TestRegistry::getAllTests() const {
-        return m_functions;
-    }
-    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_functions );
-
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_functions );
-            m_currentSortOrder = config.runOrder();
-        }
-        return m_sortedFunctions;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
-
-    void TestInvokerAsFunction::invoke() const {
-        m_testAsFunction();
-    }
-
-    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className(classOrQualifiedMethodName);
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-} // end namespace Catch
-// end catch_test_case_registry_impl.cpp
-// start catch_test_case_tracker.cpp
-
-#include <algorithm>
-#include <cassert>
-#include <stdexcept>
-#include <memory>
-#include <sstream>
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
-namespace Catch {
-namespace TestCaseTracking {
-
-    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-    :   name( _name ),
-        location( _location )
-    {}
-
-    ITracker::~ITracker() = default;
-
-    ITracker& TrackerContext::startRun() {
-        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
-        m_currentTracker = nullptr;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
-    void TrackerContext::endRun() {
-        m_rootTracker.reset();
-        m_currentTracker = nullptr;
-        m_runState = NotStarted;
-    }
-
-    void TrackerContext::startCycle() {
-        m_currentTracker = m_rootTracker.get();
-        m_runState = Executing;
-    }
-    void TrackerContext::completeCycle() {
-        m_runState = CompletedCycle;
-    }
-
-    bool TrackerContext::completedCycle() const {
-        return m_runState == CompletedCycle;
-    }
-    ITracker& TrackerContext::currentTracker() {
-        return *m_currentTracker;
-    }
-    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
-        m_currentTracker = tracker;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
-        m_ctx( ctx ),
-        m_parent( parent )
-    {}
-
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
-    bool TrackerBase::isComplete() const {
-        return m_runState == CompletedSuccessfully || m_runState == Failed;
-    }
-    bool TrackerBase::isSuccessfullyCompleted() const {
-        return m_runState == CompletedSuccessfully;
-    }
-    bool TrackerBase::isOpen() const {
-        return m_runState != NotStarted && !isComplete();
-    }
-    bool TrackerBase::hasChildren() const {
-        return !m_children.empty();
-    }
-
-    void TrackerBase::addChild( ITrackerPtr const& child ) {
-        m_children.push_back( child );
-    }
-
-    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(),
-            [&nameAndLocation]( ITrackerPtr const& tracker ){
-                return
-                    tracker->nameAndLocation().location == nameAndLocation.location &&
-                    tracker->nameAndLocation().name == nameAndLocation.name;
-            } );
-        return( it != m_children.end() )
-            ? *it
-            : nullptr;
-    }
-    ITracker& TrackerBase::parent() {
-        assert( m_parent ); // Should always be non-null except for root
-        return *m_parent;
-    }
-
-    void TrackerBase::openChild() {
-        if( m_runState != ExecutingChildren ) {
-            m_runState = ExecutingChildren;
-            if( m_parent )
-                m_parent->openChild();
-        }
-    }
-
-    bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isGeneratorTracker() const { return false; }
-
-    void TrackerBase::open() {
-        m_runState = Executing;
-        moveToThis();
-        if( m_parent )
-            m_parent->openChild();
-    }
-
-    void TrackerBase::close() {
-
-        // Close any still open children (e.g. generators)
-        while( &m_ctx.currentTracker() != this )
-            m_ctx.currentTracker().close();
-
-        switch( m_runState ) {
-            case NeedsAnotherRun:
-                break;
-
-            case Executing:
-                m_runState = CompletedSuccessfully;
-                break;
-            case ExecutingChildren:
-                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
-                    m_runState = CompletedSuccessfully;
-                break;
-
-            case NotStarted:
-            case CompletedSuccessfully:
-            case Failed:
-                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
-
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
-        }
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::fail() {
-        m_runState = Failed;
-        if( m_parent )
-            m_parent->markAsNeedingAnotherRun();
-        moveToParent();
-        m_ctx.completeCycle();
-    }
-    void TrackerBase::markAsNeedingAnotherRun() {
-        m_runState = NeedsAnotherRun;
-    }
-
-    void TrackerBase::moveToParent() {
-        assert( m_parent );
-        m_ctx.setCurrentTracker( m_parent );
-    }
-    void TrackerBase::moveToThis() {
-        m_ctx.setCurrentTracker( this );
-    }
-
-    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_trimmed_name(trim(nameAndLocation.name))
-    {
-        if( parent ) {
-            while( !parent->isSectionTracker() )
-                parent = &parent->parent();
-
-            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-            addNextFilters( parentSection.m_filters );
-        }
-    }
-
-    bool SectionTracker::isComplete() const {
-        bool complete = true;
-
-        if ((m_filters.empty() || m_filters[0] == "")
-            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
-            complete = TrackerBase::isComplete();
-        }
-        return complete;
-    }
-
-    bool SectionTracker::isSectionTracker() const { return true; }
-
-    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-        std::shared_ptr<SectionTracker> section;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isSectionTracker() );
-            section = std::static_pointer_cast<SectionTracker>( childTracker );
-        }
-        else {
-            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
-            currentTracker.addChild( section );
-        }
-        if( !ctx.completedCycle() )
-            section->tryOpen();
-        return *section;
-    }
-
-    void SectionTracker::tryOpen() {
-        if( !isComplete() )
-            open();
-    }
-
-    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
-        if( !filters.empty() ) {
-            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.emplace_back(""); // Root - should never be consulted
-            m_filters.emplace_back(""); // Test Case - not a section filter
-            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-        }
-    }
-    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
-        if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
-    }
-
-} // namespace TestCaseTracking
-
-using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
-using TestCaseTracking::SectionTracker;
-
-} // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-// end catch_test_case_tracker.cpp
-// start catch_test_registry.cpp
-
-namespace Catch {
-
-    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
-        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
-    }
-
-    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
-
-    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        CATCH_TRY {
-            getMutableRegistryHub()
-                    .registerTest(
-                        makeTestCase(
-                            invoker,
-                            extractClassName( classOrMethod ),
-                            nameAndTags,
-                            lineInfo));
-        } CATCH_CATCH_ALL {
-            // Do not throw when constructing global objects, instead register the exception to be processed later
-            getMutableRegistryHub().registerStartupException();
-        }
-    }
-
-    AutoReg::~AutoReg() = default;
-}
-// end catch_test_registry.cpp
-// start catch_test_spec.cpp
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <memory>
-
-namespace Catch {
-
-    TestSpec::Pattern::Pattern( std::string const& name )
-    : m_name( name )
-    {}
-
-    TestSpec::Pattern::~Pattern() = default;
-
-    std::string const& TestSpec::Pattern::name() const {
-        return m_name;
-    }
-
-    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
-    : Pattern( filterString )
-    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
-    {}
-
-    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( testCase.name );
-    }
-
-    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
-    : Pattern( filterString )
-    , m_tag( toLower( tag ) )
-    {}
-
-    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
-        return std::find(begin(testCase.lcaseTags),
-                         end(testCase.lcaseTags),
-                         m_tag) != end(testCase.lcaseTags);
-    }
-
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
-    : Pattern( underlyingPattern->name() )
-    , m_underlyingPattern( underlyingPattern )
-    {}
-
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
-        return !m_underlyingPattern->matches( testCase );
-    }
-
-    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
-    }
-
-    std::string TestSpec::Filter::name() const {
-        std::string name;
-        for( auto const& p : m_patterns )
-            name += p->name();
-        return name;
-    }
-
-    bool TestSpec::hasFilters() const {
-        return !m_filters.empty();
-    }
-
-    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
-    }
-
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
-    {
-        Matches matches( m_filters.size() );
-        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
-            std::vector<TestCase const*> currentMatches;
-            for( auto const& test : testCases )
-                if( isThrowSafe( test, config ) && filter.matches( test ) )
-                    currentMatches.emplace_back( &test );
-            return FilterMatch{ filter.name(), currentMatches };
-        } );
-        return matches;
-    }
-
-    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
-        return  (m_invalidArgs);
-    }
-
-}
-// end catch_test_spec.cpp
-// start catch_test_spec_parser.cpp
-
-namespace Catch {
-
-    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
-        m_mode = None;
-        m_exclusion = false;
-        m_arg = m_tagAliases->expandAliases( arg );
-        m_escapeChars.clear();
-        m_substring.reserve(m_arg.size());
-        m_patternName.reserve(m_arg.size());
-        m_realPatternPos = 0;
-
-        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){
-               m_testSpec.m_invalidArgs.push_back(arg);
-               break;
-           }
-        endMode();
-        return *this;
-    }
-    TestSpec TestSpecParser::testSpec() {
-        addFilter();
-        return m_testSpec;
-    }
-    bool TestSpecParser::visitChar( char c ) {
-        if( (m_mode != EscapedName) && (c == '\\') ) {
-            escape();
-            addCharToPattern(c);
-            return true;
-        }else if((m_mode != EscapedName) && (c == ',') )  {
-            return separate();
-        }
-
-        switch( m_mode ) {
-        case None:
-            if( processNoneChar( c ) )
-                return true;
-            break;
-        case Name:
-            processNameChar( c );
-            break;
-        case EscapedName:
-            endMode();
-            addCharToPattern(c);
-            return true;
-        default:
-        case Tag:
-        case QuotedName:
-            if( processOtherChar( c ) )
-                return true;
-            break;
-        }
-
-        m_substring += c;
-        if( !isControlChar( c ) ) {
-            m_patternName += c;
-            m_realPatternPos++;
-        }
-        return true;
-    }
-    // Two of the processing methods return true to signal the caller to return
-    // without adding the given character to the current pattern strings
-    bool TestSpecParser::processNoneChar( char c ) {
-        switch( c ) {
-        case ' ':
-            return true;
-        case '~':
-            m_exclusion = true;
-            return false;
-        case '[':
-            startNewMode( Tag );
-            return false;
-        case '"':
-            startNewMode( QuotedName );
-            return false;
-        default:
-            startNewMode( Name );
-            return false;
-        }
-    }
-    void TestSpecParser::processNameChar( char c ) {
-        if( c == '[' ) {
-            if( m_substring == "exclude:" )
-                m_exclusion = true;
-            else
-                endMode();
-            startNewMode( Tag );
-        }
-    }
-    bool TestSpecParser::processOtherChar( char c ) {
-        if( !isControlChar( c ) )
-            return false;
-        m_substring += c;
-        endMode();
-        return true;
-    }
-    void TestSpecParser::startNewMode( Mode mode ) {
-        m_mode = mode;
-    }
-    void TestSpecParser::endMode() {
-        switch( m_mode ) {
-        case Name:
-        case QuotedName:
-            return addNamePattern();
-        case Tag:
-            return addTagPattern();
-        case EscapedName:
-            revertBackToLastMode();
-            return;
-        case None:
-        default:
-            return startNewMode( None );
-        }
-    }
-    void TestSpecParser::escape() {
-        saveLastMode();
-        m_mode = EscapedName;
-        m_escapeChars.push_back(m_realPatternPos);
-    }
-    bool TestSpecParser::isControlChar( char c ) const {
-        switch( m_mode ) {
-            default:
-                return false;
-            case None:
-                return c == '~';
-            case Name:
-                return c == '[';
-            case EscapedName:
-                return true;
-            case QuotedName:
-                return c == '"';
-            case Tag:
-                return c == '[' || c == ']';
-        }
-    }
-
-    void TestSpecParser::addFilter() {
-        if( !m_currentFilter.m_patterns.empty() ) {
-            m_testSpec.m_filters.push_back( m_currentFilter );
-            m_currentFilter = TestSpec::Filter();
-        }
-    }
-
-    void TestSpecParser::saveLastMode() {
-      lastMode = m_mode;
-    }
-
-    void TestSpecParser::revertBackToLastMode() {
-      m_mode = lastMode;
-    }
-
-    bool TestSpecParser::separate() {
-      if( (m_mode==QuotedName) || (m_mode==Tag) ){
-         //invalid argument, signal failure to previous scope.
-         m_mode = None;
-         m_pos = m_arg.size();
-         m_substring.clear();
-         m_patternName.clear();
-         return false;
-      }
-      endMode();
-      addFilter();
-      return true; //success
-    }
-
-    std::string TestSpecParser::preprocessPattern() {
-        std::string token = m_patternName;
-        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
-            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
-        m_escapeChars.clear();
-        if (startsWith(token, "exclude:")) {
-            m_exclusion = true;
-            token = token.substr(8);
-        }
-
-        m_patternName.clear();
-
-        return token;
-    }
-
-    void TestSpecParser::addNamePattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
-            if (m_exclusion)
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    void TestSpecParser::addTagPattern() {
-        auto token = preprocessPattern();
-
-        if (!token.empty()) {
-            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
-            // we have to create a separate hide tag and shorten the real one
-            if (token.size() > 1 && token[0] == '.') {
-                token.erase(token.begin());
-                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
-                if (m_exclusion) {
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-                }
-                m_currentFilter.m_patterns.push_back(pattern);
-            }
-
-            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
-
-            if (m_exclusion) {
-                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
-            }
-            m_currentFilter.m_patterns.push_back(pattern);
-        }
-        m_substring.clear();
-        m_exclusion = false;
-        m_mode = None;
-    }
-
-    TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-// end catch_test_spec_parser.cpp
-// start catch_timer.cpp
-
-#include <chrono>
-
-static const uint64_t nanosecondsInSecond = 1000000000;
-
-namespace Catch {
-
-    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
-    }
-
-    namespace {
-        auto estimateClockResolution() -> uint64_t {
-            uint64_t sum = 0;
-            static const uint64_t iterations = 1000000;
-
-            auto startTime = getCurrentNanosecondsSinceEpoch();
-
-            for( std::size_t i = 0; i < iterations; ++i ) {
-
-                uint64_t ticks;
-                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-                do {
-                    ticks = getCurrentNanosecondsSinceEpoch();
-                } while( ticks == baseTicks );
-
-                auto delta = ticks - baseTicks;
-                sum += delta;
-
-                // If we have been calibrating for over 3 seconds -- the clock
-                // is terrible and we should move on.
-                // TBD: How to signal that the measured resolution is probably wrong?
-                if (ticks > startTime + 3 * nanosecondsInSecond) {
-                    return sum / ( i + 1u );
-                }
-            }
-
-            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-            // - and potentially do more iterations if there's a high variance.
-            return sum/iterations;
-        }
-    }
-    auto getEstimatedClockResolution() -> uint64_t {
-        static auto s_resolution = estimateClockResolution();
-        return s_resolution;
-    }
-
-    void Timer::start() {
-       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
-    }
-    auto Timer::getElapsedNanoseconds() const -> uint64_t {
-        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
-    }
-    auto Timer::getElapsedMicroseconds() const -> uint64_t {
-        return getElapsedNanoseconds()/1000;
-    }
-    auto Timer::getElapsedMilliseconds() const -> unsigned int {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-// end catch_timer.cpp
-// start catch_tostring.cpp
-
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#    pragma clang diagnostic ignored "-Wglobal-constructors"
-#endif
-
-// Enable specific decls locally
-#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
-#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
-#endif
-
-#include <cmath>
-#include <iomanip>
-
-namespace Catch {
-
-namespace Detail {
-
-    const std::string unprintableString = "{?}";
-
-    namespace {
-        const int hexThreshold = 255;
-
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                int one = 1;
-                // If the lowest byte we read is non-zero, we can assume
-                // that little endian format is used.
-                auto value = *reinterpret_cast<char*>(&one);
-                return value ? Little : Big;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size ) {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        ReusableStringStream rss;
-        rss << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return rss.str();
-    }
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    if (Catch::isnan(value)) {
-        return "nan";
-    }
-
-    ReusableStringStream rss;
-    rss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = rss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-//// ======================================================= ////
-//
-//   Out-of-line defs for full specialization of StringMaker
-//
-//// ======================================================= ////
-
-std::string StringMaker<std::string>::convert(const std::string& str) {
-    if (!getCurrentContext().getConfig()->showInvisibles()) {
-        return '"' + str + '"';
-    }
-
-    std::string s("\"");
-    for (char c : str) {
-        switch (c) {
-        case '\n':
-            s.append("\\n");
-            break;
-        case '\t':
-            s.append("\\t");
-            break;
-        default:
-            s.push_back(c);
-            break;
-        }
-    }
-    s.append("\"");
-    return s;
-}
-
-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return ::Catch::Detail::stringify(std::string{ str });
-}
-#endif
-
-std::string StringMaker<char const*>::convert(char const* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<char*>::convert(char* str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::string{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
-}
-
-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
-std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
-    return StringMaker<std::wstring>::convert(std::wstring(str));
-}
-# endif
-
-std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
-    if (str) {
-        return ::Catch::Detail::stringify(std::wstring{ str });
-    } else {
-        return{ "{null string}" };
-    }
-}
-#endif
-
-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
-std::string StringMaker<std::byte>::convert(std::byte value) {
-    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
-}
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
-
-std::string StringMaker<int>::convert(int value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long>::convert(long value) {
-    return ::Catch::Detail::stringify(static_cast<long long>(value));
-}
-std::string StringMaker<long long>::convert(long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<unsigned int>::convert(unsigned int value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long>::convert(unsigned long value) {
-    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
-}
-std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
-    ReusableStringStream rss;
-    rss << value;
-    if (value > Detail::hexThreshold) {
-        rss << " (0x" << std::hex << value << ')';
-    }
-    return rss.str();
-}
-
-std::string StringMaker<bool>::convert(bool b) {
-    return b ? "true" : "false";
-}
-
-std::string StringMaker<signed char>::convert(signed char value) {
-    if (value == '\r') {
-        return "'\\r'";
-    } else if (value == '\f') {
-        return "'\\f'";
-    } else if (value == '\n') {
-        return "'\\n'";
-    } else if (value == '\t') {
-        return "'\\t'";
-    } else if ('\0' <= value && value < ' ') {
-        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
-    } else {
-        char chstr[] = "' '";
-        chstr[1] = value;
-        return chstr;
-    }
-}
-std::string StringMaker<char>::convert(char c) {
-    return ::Catch::Detail::stringify(static_cast<signed char>(c));
-}
-std::string StringMaker<unsigned char>::convert(unsigned char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
-}
-
-std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
-    return "nullptr";
-}
-
-int StringMaker<float>::precision = 5;
-
-std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, precision) + 'f';
-}
-
-int StringMaker<double>::precision = 10;
-
-std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, precision);
-}
-
-std::string ratio_string<std::atto>::symbol() { return "a"; }
-std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string ratio_string<std::pico>::symbol() { return "p"; }
-std::string ratio_string<std::nano>::symbol() { return "n"; }
-std::string ratio_string<std::micro>::symbol() { return "u"; }
-std::string ratio_string<std::milli>::symbol() { return "m"; }
-
-} // end namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
-
-// end catch_tostring.cpp
-// start catch_totals.cpp
-
-namespace Catch {
-
-    Counts Counts::operator - ( Counts const& other ) const {
-        Counts diff;
-        diff.passed = passed - other.passed;
-        diff.failed = failed - other.failed;
-        diff.failedButOk = failedButOk - other.failedButOk;
-        return diff;
-    }
-
-    Counts& Counts::operator += ( Counts const& other ) {
-        passed += other.passed;
-        failed += other.failed;
-        failedButOk += other.failedButOk;
-        return *this;
-    }
-
-    std::size_t Counts::total() const {
-        return passed + failed + failedButOk;
-    }
-    bool Counts::allPassed() const {
-        return failed == 0 && failedButOk == 0;
-    }
-    bool Counts::allOk() const {
-        return failed == 0;
-    }
-
-    Totals Totals::operator - ( Totals const& other ) const {
-        Totals diff;
-        diff.assertions = assertions - other.assertions;
-        diff.testCases = testCases - other.testCases;
-        return diff;
-    }
-
-    Totals& Totals::operator += ( Totals const& other ) {
-        assertions += other.assertions;
-        testCases += other.testCases;
-        return *this;
-    }
-
-    Totals Totals::delta( Totals const& prevTotals ) const {
-        Totals diff = *this - prevTotals;
-        if( diff.assertions.failed > 0 )
-            ++diff.testCases.failed;
-        else if( diff.assertions.failedButOk > 0 )
-            ++diff.testCases.failedButOk;
-        else
-            ++diff.testCases.passed;
-        return diff;
-    }
-
-}
-// end catch_totals.cpp
-// start catch_uncaught_exceptions.cpp
-
-#include <exception>
-
-namespace Catch {
-    bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-        return std::uncaught_exceptions() > 0;
-#else
-        return std::uncaught_exception();
-#endif
-  }
-} // end namespace Catch
-// end catch_uncaught_exceptions.cpp
-// start catch_version.cpp
-
-#include <ostream>
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    Version const& libraryVersion() {
-        static Version version( 2, 11, 3, "", 0 );
-        return version;
-    }
-
-}
-// end catch_version.cpp
-// start catch_wildcard_pattern.cpp
-
-namespace Catch {
-
-    WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
-    :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( normaliseString( pattern ) )
-    {
-        if( startsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 1 );
-            m_wildcard = WildcardAtStart;
-        }
-        if( endsWith( m_pattern, '*' ) ) {
-            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-        }
-    }
-
-    bool WildcardPattern::matches( std::string const& str ) const {
-        switch( m_wildcard ) {
-            case NoWildcard:
-                return m_pattern == normaliseString( str );
-            case WildcardAtStart:
-                return endsWith( normaliseString( str ), m_pattern );
-            case WildcardAtEnd:
-                return startsWith( normaliseString( str ), m_pattern );
-            case WildcardAtBothEnds:
-                return contains( normaliseString( str ), m_pattern );
-            default:
-                CATCH_INTERNAL_ERROR( "Unknown enum" );
-        }
-    }
-
-    std::string WildcardPattern::normaliseString( std::string const& str ) const {
-        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
-    }
-}
-// end catch_wildcard_pattern.cpp
-// start catch_xmlwriter.cpp
-
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-
-namespace {
-
-    size_t trailingBytes(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return 2;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return 3;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return 4;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    uint32_t headerValue(unsigned char c) {
-        if ((c & 0xE0) == 0xC0) {
-            return c & 0x1F;
-        }
-        if ((c & 0xF0) == 0xE0) {
-            return c & 0x0F;
-        }
-        if ((c & 0xF8) == 0xF0) {
-            return c & 0x07;
-        }
-        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
-    }
-
-    void hexEscapeChar(std::ostream& os, unsigned char c) {
-        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
-            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-            << static_cast<int>(c);
-        os.flags(f);
-    }
-
-    bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
-    }
-
-    bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
-    }
-
-} // anonymous namespace
-
-    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
-        return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
-        );
-    }
-
-    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
-    :   m_str( str ),
-        m_forWhat( forWhat )
-    {}
-
-    void XmlEncode::encodeTo( std::ostream& os ) const {
-        // Apostrophe escaping not necessary if we always use " to write attributes
-        // (see: http://www.w3.org/TR/xml/#syntax)
-
-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = m_str[idx];
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
-
-            case '>':
-                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
-                break;
-
-            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
-                break;
-
-            default:
-                // Check for control characters and invalid utf-8
-
-                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
-                    break;
-                }
-
-                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
-                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-                // The header is valid, check data
-                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
-                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = m_str[idx + n];
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
-                }
-
-                if (
-                    // Wrong bit pattern of following bytes
-                    (!valid) ||
-                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
-                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
-                    break;
-                }
-
-                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
-                idx += encBytes - 1;
-                break;
-            }
-        }
-    }
-
-    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-        xmlEncode.encodeTo( os );
-        return os;
-    }
-
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
-    :   m_writer( writer ),
-        m_fmt(fmt)
-    {}
-
-    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ),
-        m_fmt(other.m_fmt)
-    {
-        other.m_writer = nullptr;
-        other.m_fmt = XmlFormatting::None;
-    }
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
-        if ( m_writer ) {
-            m_writer->endElement();
-        }
-        m_writer = other.m_writer;
-        other.m_writer = nullptr;
-        m_fmt = other.m_fmt;
-        other.m_fmt = XmlFormatting::None;
-        return *this;
-    }
-
-    XmlWriter::ScopedElement::~ScopedElement() {
-        if (m_writer) {
-            m_writer->endElement(m_fmt);
-        }
-    }
-
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
-        m_writer->writeText( text, fmt );
-        return *this;
-    }
-
-    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
-    {
-        writeDeclaration();
-    }
-
-    XmlWriter::~XmlWriter() {
-        while (!m_tags.empty()) {
-            endElement();
-        }
-        newlineIfNecessary();
-    }
-
-    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
-        ensureTagClosed();
-        newlineIfNecessary();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-            m_indent += "  ";
-        }
-        m_os << '<' << name;
-        m_tags.push_back( name );
-        m_tagIsOpen = true;
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
-        ScopedElement scoped( this, fmt );
-        startElement( name, fmt );
-        return scoped;
-    }
-
-    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
-        m_indent = m_indent.substr(0, m_indent.size() - 2);
-
-        if( m_tagIsOpen ) {
-            m_os << "/>";
-            m_tagIsOpen = false;
-        } else {
-            newlineIfNecessary();
-            if (shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << "</" << m_tags.back() << ">";
-        }
-        m_os << std::flush;
-        applyFormatting(fmt);
-        m_tags.pop_back();
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
-        if( !name.empty() && !attribute.empty() )
-            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
-        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
-        if( !text.empty() ){
-            bool tagWasOpen = m_tagIsOpen;
-            ensureTagClosed();
-            if (tagWasOpen && shouldIndent(fmt)) {
-                m_os << m_indent;
-            }
-            m_os << XmlEncode( text );
-            applyFormatting(fmt);
-        }
-        return *this;
-    }
-
-    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
-        ensureTagClosed();
-        if (shouldIndent(fmt)) {
-            m_os << m_indent;
-        }
-        m_os << "<!--" << text << "-->";
-        applyFormatting(fmt);
-        return *this;
-    }
-
-    void XmlWriter::writeStylesheetRef( std::string const& url ) {
-        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-    }
-
-    XmlWriter& XmlWriter::writeBlankLine() {
-        ensureTagClosed();
-        m_os << '\n';
-        return *this;
-    }
-
-    void XmlWriter::ensureTagClosed() {
-        if( m_tagIsOpen ) {
-            m_os << '>' << std::flush;
-            newlineIfNecessary();
-            m_tagIsOpen = false;
-        }
-    }
-
-    void XmlWriter::applyFormatting(XmlFormatting fmt) {
-        m_needsNewline = shouldNewline(fmt);
-    }
-
-    void XmlWriter::writeDeclaration() {
-        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-    }
-
-    void XmlWriter::newlineIfNecessary() {
-        if( m_needsNewline ) {
-            m_os << std::endl;
-            m_needsNewline = false;
-        }
-    }
-}
-// end catch_xmlwriter.cpp
-// start catch_reporter_bases.cpp
-
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-
-namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result) {
-        result.getExpandedExpression();
-    }
-
-    // Because formatting using c++ streams is stateful, drop down to C is required
-    // Alternatively we could use stringstream, but its performance is... not good.
-    std::string getFormattedDuration( double duration ) {
-        // Max exponent + 1 is required to represent the whole part
-        // + 1 for decimal point
-        // + 3 for the 3 decimal places
-        // + 1 for null terminator
-        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-        char buffer[maxDoubleSize];
-
-        // Save previous errno, to prevent sprintf from overwriting it
-        ErrnoGuard guard;
-#ifdef _MSC_VER
-        sprintf_s(buffer, "%.3f", duration);
-#else
-        std::sprintf(buffer, "%.3f", duration);
-#endif
-        return std::string(buffer);
-    }
-
-    std::string serializeFilters( std::vector<std::string> const& container ) {
-        ReusableStringStream oss;
-        bool first = true;
-        for (auto&& filter : container)
-        {
-            if (!first)
-                oss << ' ';
-            else
-                first = false;
-
-            oss << filter;
-        }
-        return oss.str();
-    }
-
-    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
-        :StreamingReporterBase(_config) {}
-
-    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
-        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
-    }
-
-    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
-
-    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_reporter_bases.cpp
-// start catch_reporter_compact.cpp
-
-namespace {
-
-#ifdef CATCH_PLATFORM_MAC
-    const char* failedString() { return "FAILED"; }
-    const char* passedString() { return "PASSED"; }
-#else
-    const char* failedString() { return "failed"; }
-    const char* passedString() { return "passed"; }
-#endif
-
-    // Colour::LightGrey
-    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
-
-    std::string bothOrAll( std::size_t count ) {
-        return count == 1 ? std::string() :
-               count == 2 ? "both " : "all " ;
-    }
-
-} // anon namespace
-
-namespace Catch {
-namespace {
-// Colour, message variants:
-// - white: No tests ran.
-// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// -   red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals) {
-    if (totals.testCases.total() == 0) {
-        out << "No tests ran.";
-    } else if (totals.testCases.failed == totals.testCases.total()) {
-        Colour colour(Colour::ResultError);
-        const std::string qualify_assertions_failed =
-            totals.assertions.failed == totals.assertions.total() ?
-            bothOrAll(totals.assertions.failed) : std::string();
-        out <<
-            "Failed " << bothOrAll(totals.testCases.failed)
-            << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << qualify_assertions_failed <<
-            pluralise(totals.assertions.failed, "assertion") << '.';
-    } else if (totals.assertions.total() == 0) {
-        out <<
-            "Passed " << bothOrAll(totals.testCases.total())
-            << pluralise(totals.testCases.total(), "test case")
-            << " (no assertions).";
-    } else if (totals.assertions.failed) {
-        Colour colour(Colour::ResultError);
-        out <<
-            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
-            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
-    } else {
-        Colour colour(Colour::ResultSuccess);
-        out <<
-            "Passed " << bothOrAll(totals.testCases.passed)
-            << pluralise(totals.testCases.passed, "test case") <<
-            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
-    }
-}
-
-// Implementation of CompactReporter formatting
-class AssertionPrinter {
-public:
-    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
-    AssertionPrinter(AssertionPrinter const&) = delete;
-    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream)
-        , result(_stats.assertionResult)
-        , messages(_stats.infoMessages)
-        , itMessage(_stats.infoMessages.begin())
-        , printInfoMessages(_printInfoMessages) {}
-
-    void print() {
-        printSourceInfo();
-
-        itMessage = messages.begin();
-
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            printResultType(Colour::ResultSuccess, passedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            if (!result.hasExpression())
-                printRemainingMessages(Colour::None);
-            else
-                printRemainingMessages();
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk())
-                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
-            else
-                printResultType(Colour::Error, failedString());
-            printOriginalExpression();
-            printReconstructedExpression();
-            printRemainingMessages();
-            break;
-        case ResultWas::ThrewException:
-            printResultType(Colour::Error, failedString());
-            printIssue("unexpected exception with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::FatalErrorCondition:
-            printResultType(Colour::Error, failedString());
-            printIssue("fatal error condition with message:");
-            printMessage();
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::DidntThrowException:
-            printResultType(Colour::Error, failedString());
-            printIssue("expected exception, got none");
-            printExpressionWas();
-            printRemainingMessages();
-            break;
-        case ResultWas::Info:
-            printResultType(Colour::None, "info");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::Warning:
-            printResultType(Colour::None, "warning");
-            printMessage();
-            printRemainingMessages();
-            break;
-        case ResultWas::ExplicitFailure:
-            printResultType(Colour::Error, failedString());
-            printIssue("explicitly");
-            printRemainingMessages(Colour::None);
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            printResultType(Colour::Error, "** internal error **");
-            break;
-        }
-    }
-
-private:
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ':';
-    }
-
-    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
-        if (!passOrFail.empty()) {
-            {
-                Colour colourGuard(colour);
-                stream << ' ' << passOrFail;
-            }
-            stream << ':';
-        }
-    }
-
-    void printIssue(std::string const& issue) const {
-        stream << ' ' << issue;
-    }
-
-    void printExpressionWas() {
-        if (result.hasExpression()) {
-            stream << ';';
-            {
-                Colour colour(dimColour());
-                stream << " expression was:";
-            }
-            printOriginalExpression();
-        }
-    }
-
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            stream << ' ' << result.getExpression();
-        }
-    }
-
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            {
-                Colour colour(dimColour());
-                stream << " for: ";
-            }
-            stream << result.getExpandedExpression();
-        }
-    }
-
-    void printMessage() {
-        if (itMessage != messages.end()) {
-            stream << " '" << itMessage->message << '\'';
-            ++itMessage;
-        }
-    }
-
-    void printRemainingMessages(Colour::Code colour = dimColour()) {
-        if (itMessage == messages.end())
-            return;
-
-        const auto itEnd = messages.cend();
-        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
-
-        {
-            Colour colourGuard(colour);
-            stream << " with " << pluralise(N, "message") << ':';
-        }
-
-        while (itMessage != itEnd) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                printMessage();
-                if (itMessage != itEnd) {
-                    Colour colourGuard(dimColour());
-                    stream << " and";
-                }
-                continue;
-            }
-            ++itMessage;
-        }
-    }
-
-private:
-    std::ostream& stream;
-    AssertionResult const& result;
-    std::vector<MessageInfo> messages;
-    std::vector<MessageInfo>::const_iterator itMessage;
-    bool printInfoMessages;
-};
-
-} // anon namespace
-
-        std::string CompactReporter::getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        ReporterPreferences CompactReporter::getPreferences() const {
-            return m_reporterPrefs;
-        }
-
-        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
-
-        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-        }
-
-        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( stream, _testRunStats.totals );
-            stream << '\n' << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-        CompactReporter::~CompactReporter() {}
-
-    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-// end catch_reporter_compact.cpp
-// start catch_reporter_console.cpp
-
-#include <cfloat>
-#include <cstdio>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled and default is missing) is enabled
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic push
-// For simplicity, benchmarking-only helpers are always enabled
-#  pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-namespace Catch {
-
-namespace {
-
-// Formatter impl for ConsoleReporter
-class ConsoleAssertionPrinter {
-public:
-    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
-    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
-        : stream(_stream),
-        stats(_stats),
-        result(_stats.assertionResult),
-        colour(Colour::None),
-        message(result.getMessage()),
-        messages(_stats.infoMessages),
-        printInfoMessages(_printInfoMessages) {
-        switch (result.getResultType()) {
-        case ResultWas::Ok:
-            colour = Colour::Success;
-            passOrFail = "PASSED";
-            //if( result.hasMessage() )
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ExpressionFailed:
-            if (result.isOk()) {
-                colour = Colour::Success;
-                passOrFail = "FAILED - but was ok";
-            } else {
-                colour = Colour::Error;
-                passOrFail = "FAILED";
-            }
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "with messages";
-            break;
-        case ResultWas::ThrewException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to unexpected exception with ";
-            if (_stats.infoMessages.size() == 1)
-                messageLabel += "message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel += "messages";
-            break;
-        case ResultWas::FatalErrorCondition:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "due to a fatal error condition";
-            break;
-        case ResultWas::DidntThrowException:
-            colour = Colour::Error;
-            passOrFail = "FAILED";
-            messageLabel = "because no exception was thrown where one was expected";
-            break;
-        case ResultWas::Info:
-            messageLabel = "info";
-            break;
-        case ResultWas::Warning:
-            messageLabel = "warning";
-            break;
-        case ResultWas::ExplicitFailure:
-            passOrFail = "FAILED";
-            colour = Colour::Error;
-            if (_stats.infoMessages.size() == 1)
-                messageLabel = "explicitly with message";
-            if (_stats.infoMessages.size() > 1)
-                messageLabel = "explicitly with messages";
-            break;
-            // These cases are here to prevent compiler warnings
-        case ResultWas::Unknown:
-        case ResultWas::FailureBit:
-        case ResultWas::Exception:
-            passOrFail = "** internal error **";
-            colour = Colour::Error;
-            break;
-        }
-    }
-
-    void print() const {
-        printSourceInfo();
-        if (stats.totals.assertions.total() > 0) {
-            printResultType();
-            printOriginalExpression();
-            printReconstructedExpression();
-        } else {
-            stream << '\n';
-        }
-        printMessage();
-    }
-
-private:
-    void printResultType() const {
-        if (!passOrFail.empty()) {
-            Colour colourGuard(colour);
-            stream << passOrFail << ":\n";
-        }
-    }
-    void printOriginalExpression() const {
-        if (result.hasExpression()) {
-            Colour colourGuard(Colour::OriginalExpression);
-            stream << "  ";
-            stream << result.getExpressionInMacro();
-            stream << '\n';
-        }
-    }
-    void printReconstructedExpression() const {
-        if (result.hasExpandedExpression()) {
-            stream << "with expansion:\n";
-            Colour colourGuard(Colour::ReconstructedExpression);
-            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
-        }
-    }
-    void printMessage() const {
-        if (!messageLabel.empty())
-            stream << messageLabel << ':' << '\n';
-        for (auto const& msg : messages) {
-            // If this assertion is a warning ignore any INFO messages
-            if (printInfoMessages || msg.type != ResultWas::Info)
-                stream << Column(msg.message).indent(2) << '\n';
-        }
-    }
-    void printSourceInfo() const {
-        Colour colourGuard(Colour::FileName);
-        stream << result.getSourceInfo() << ": ";
-    }
-
-    std::ostream& stream;
-    AssertionStats const& stats;
-    AssertionResult const& result;
-    Colour::Code colour;
-    std::string passOrFail;
-    std::string messageLabel;
-    std::string message;
-    std::vector<MessageInfo> messages;
-    bool printInfoMessages;
-};
-
-std::size_t makeRatio(std::size_t number, std::size_t total) {
-    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
-    return (ratio == 0 && number > 0) ? 1 : ratio;
-}
-
-std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
-    if (i > j && i > k)
-        return i;
-    else if (j > k)
-        return j;
-    else
-        return k;
-}
-
-struct ColumnInfo {
-    enum Justification { Left, Right };
-    std::string name;
-    int width;
-    Justification justification;
-};
-struct ColumnBreak {};
-struct RowBreak {};
-
-class Duration {
-    enum class Unit {
-        Auto,
-        Nanoseconds,
-        Microseconds,
-        Milliseconds,
-        Seconds,
-        Minutes
-    };
-    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
-    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
-    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
-    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
-
-    double m_inNanoseconds;
-    Unit m_units;
-
-public:
-    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : m_inNanoseconds(inNanoseconds),
-        m_units(units) {
-        if (m_units == Unit::Auto) {
-            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
-                m_units = Unit::Nanoseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
-                m_units = Unit::Microseconds;
-            else if (m_inNanoseconds < s_nanosecondsInASecond)
-                m_units = Unit::Milliseconds;
-            else if (m_inNanoseconds < s_nanosecondsInAMinute)
-                m_units = Unit::Seconds;
-            else
-                m_units = Unit::Minutes;
-        }
-
-    }
-
-    auto value() const -> double {
-        switch (m_units) {
-        case Unit::Microseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
-        case Unit::Milliseconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
-        case Unit::Seconds:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
-        case Unit::Minutes:
-            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
-        default:
-            return m_inNanoseconds;
-        }
-    }
-    auto unitsAsString() const -> std::string {
-        switch (m_units) {
-        case Unit::Nanoseconds:
-            return "ns";
-        case Unit::Microseconds:
-            return "us";
-        case Unit::Milliseconds:
-            return "ms";
-        case Unit::Seconds:
-            return "s";
-        case Unit::Minutes:
-            return "m";
-        default:
-            return "** internal error **";
-        }
-
-    }
-    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << ' ' << duration.unitsAsString();
-    }
-};
-} // end anon namespace
-
-class TablePrinter {
-    std::ostream& m_os;
-    std::vector<ColumnInfo> m_columnInfos;
-    std::ostringstream m_oss;
-    int m_currentColumn = -1;
-    bool m_isOpen = false;
-
-public:
-    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
-    :   m_os( os ),
-        m_columnInfos( std::move( columnInfos ) ) {}
-
-    auto columnInfos() const -> std::vector<ColumnInfo> const& {
-        return m_columnInfos;
-    }
-
-    void open() {
-        if (!m_isOpen) {
-            m_isOpen = true;
-            *this << RowBreak();
-
-			Columns headerCols;
-			Spacer spacer(2);
-			for (auto const& info : m_columnInfos) {
-				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
-				headerCols += spacer;
-			}
-			m_os << headerCols << '\n';
-
-            m_os << Catch::getLineOfChars<'-'>() << '\n';
-        }
-    }
-    void close() {
-        if (m_isOpen) {
-            *this << RowBreak();
-            m_os << std::endl;
-            m_isOpen = false;
-        }
-    }
-
-    template<typename T>
-    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
-        tp.m_oss << value;
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
-        auto colStr = tp.m_oss.str();
-        const auto strSize = colStr.size();
-        tp.m_oss.str("");
-        tp.open();
-        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
-            tp.m_currentColumn = -1;
-            tp.m_os << '\n';
-        }
-        tp.m_currentColumn++;
-
-        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 1), ' ')
-            : std::string();
-        if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << ' ';
-        else
-            tp.m_os << padding << colStr << ' ';
-        return tp;
-    }
-
-    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
-        if (tp.m_currentColumn > 0) {
-            tp.m_os << '\n';
-            tp.m_currentColumn = -1;
-        }
-        return tp;
-    }
-};
-
-ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
-    : StreamingReporterBase(config),
-    m_tablePrinter(new TablePrinter(config.stream(),
-        [&config]() -> std::vector<ColumnInfo> {
-        if (config.fullConfig()->benchmarkNoAnalysis())
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
-                { "     samples", 14, ColumnInfo::Right },
-                { "  iterations", 14, ColumnInfo::Right },
-                { "        mean", 14, ColumnInfo::Right }
-            };
-        }
-        else
-        {
-            return{
-                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-                { "samples      mean       std dev", 14, ColumnInfo::Right },
-                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
-                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
-            };
-        }
-    }())) {}
-ConsoleReporter::~ConsoleReporter() = default;
-
-std::string ConsoleReporter::getDescription() {
-    return "Reports test results as plain lines of text";
-}
-
-void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
-    stream << "No test cases matched '" << spec << '\'' << std::endl;
-}
-
-void ConsoleReporter::reportInvalidArguments(std::string const&arg){
-    stream << "Invalid Filter: " << arg << std::endl;
-}
-
-void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
-
-bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
-    AssertionResult const& result = _assertionStats.assertionResult;
-
-    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-    // Drop out if result was successful but we're not printing them.
-    if (!includeResults && result.getResultType() != ResultWas::Warning)
-        return false;
-
-    lazyPrint();
-
-    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
-    printer.print();
-    stream << std::endl;
-    return true;
-}
-
-void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
-    m_tablePrinter->close();
-    m_headerPrinted = false;
-    StreamingReporterBase::sectionStarting(_sectionInfo);
-}
-void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
-    m_tablePrinter->close();
-    if (_sectionStats.missingAssertions) {
-        lazyPrint();
-        Colour colour(Colour::ResultError);
-        if (m_sectionStack.size() > 1)
-            stream << "\nNo assertions in section";
-        else
-            stream << "\nNo assertions in test case";
-        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-    }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-    }
-    if (m_headerPrinted) {
-        m_headerPrinted = false;
-    }
-    StreamingReporterBase::sectionEnded(_sectionStats);
-}
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-void ConsoleReporter::benchmarkPreparing(std::string const& name) {
-	lazyPrintWithoutClosingBenchmarkTable();
-
-	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
-
-	bool firstLine = true;
-	for (auto line : nameCol) {
-		if (!firstLine)
-			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-		else
-			firstLine = false;
-
-		(*m_tablePrinter) << line << ColumnBreak();
-	}
-}
-
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    (*m_tablePrinter) << info.samples << ColumnBreak()
-        << info.iterations << ColumnBreak();
-    if (!m_config->benchmarkNoAnalysis())
-        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
-}
-void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
-    if (m_config->benchmarkNoAnalysis())
-    {
-        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
-    }
-    else
-    {
-        (*m_tablePrinter) << ColumnBreak()
-            << Duration(stats.mean.point.count()) << ColumnBreak()
-            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
-            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
-            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
-    }
-}
-
-void ConsoleReporter::benchmarkFailed(std::string const& error) {
-	Colour colour(Colour::Red);
-    (*m_tablePrinter)
-        << "Benchmark failed (" << error << ')'
-        << ColumnBreak() << RowBreak();
-}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
-    m_tablePrinter->close();
-    StreamingReporterBase::testCaseEnded(_testCaseStats);
-    m_headerPrinted = false;
-}
-void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
-    if (currentGroupInfo.used) {
-        printSummaryDivider();
-        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-        printTotals(_testGroupStats.totals);
-        stream << '\n' << std::endl;
-    }
-    StreamingReporterBase::testGroupEnded(_testGroupStats);
-}
-void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
-    printTotalsDivider(_testRunStats.totals);
-    printTotals(_testRunStats.totals);
-    stream << std::endl;
-    StreamingReporterBase::testRunEnded(_testRunStats);
-}
-void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
-    StreamingReporterBase::testRunStarting(_testInfo);
-    printTestFilters();
-}
-
-void ConsoleReporter::lazyPrint() {
-
-    m_tablePrinter->close();
-    lazyPrintWithoutClosingBenchmarkTable();
-}
-
-void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
-
-    if (!currentTestRunInfo.used)
-        lazyPrintRunInfo();
-    if (!currentGroupInfo.used)
-        lazyPrintGroupInfo();
-
-    if (!m_headerPrinted) {
-        printTestCaseAndSectionHeader();
-        m_headerPrinted = true;
-    }
-}
-void ConsoleReporter::lazyPrintRunInfo() {
-    stream << '\n' << getLineOfChars<'~'>() << '\n';
-    Colour colour(Colour::SecondaryText);
-    stream << currentTestRunInfo->name
-        << " is a Catch v" << libraryVersion() << " host application.\n"
-        << "Run with -? for options\n\n";
-
-    if (m_config->rngSeed() != 0)
-        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-    currentTestRunInfo.used = true;
-}
-void ConsoleReporter::lazyPrintGroupInfo() {
-    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
-        printClosedHeader("Group: " + currentGroupInfo->name);
-        currentGroupInfo.used = true;
-    }
-}
-void ConsoleReporter::printTestCaseAndSectionHeader() {
-    assert(!m_sectionStack.empty());
-    printOpenHeader(currentTestCaseInfo->name);
-
-    if (m_sectionStack.size() > 1) {
-        Colour colourGuard(Colour::Headers);
-
-        auto
-            it = m_sectionStack.begin() + 1, // Skip first section (test case)
-            itEnd = m_sectionStack.end();
-        for (; it != itEnd; ++it)
-            printHeaderString(it->name, 2);
-    }
-
-    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-    stream << getLineOfChars<'-'>() << '\n';
-    Colour colourGuard(Colour::FileName);
-    stream << lineInfo << '\n';
-    stream << getLineOfChars<'.'>() << '\n' << std::endl;
-}
-
-void ConsoleReporter::printClosedHeader(std::string const& _name) {
-    printOpenHeader(_name);
-    stream << getLineOfChars<'.'>() << '\n';
-}
-void ConsoleReporter::printOpenHeader(std::string const& _name) {
-    stream << getLineOfChars<'-'>() << '\n';
-    {
-        Colour colourGuard(Colour::Headers);
-        printHeaderString(_name);
-    }
-}
-
-// if string has a : in first line will set indent to follow it on
-// subsequent lines
-void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
-    std::size_t i = _string.find(": ");
-    if (i != std::string::npos)
-        i += 2;
-    else
-        i = 0;
-    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
-}
-
-struct SummaryColumn {
-
-    SummaryColumn( std::string _label, Colour::Code _colour )
-    :   label( std::move( _label ) ),
-        colour( _colour ) {}
-    SummaryColumn addRow( std::size_t count ) {
-        ReusableStringStream rss;
-        rss << count;
-        std::string row = rss.str();
-        for (auto& oldRow : rows) {
-            while (oldRow.size() < row.size())
-                oldRow = ' ' + oldRow;
-            while (oldRow.size() > row.size())
-                row = ' ' + row;
-        }
-        rows.push_back(row);
-        return *this;
-    }
-
-    std::string label;
-    Colour::Code colour;
-    std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
-    if (totals.testCases.total() == 0) {
-        stream << Colour(Colour::Warning) << "No tests ran\n";
-    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
-        stream << Colour(Colour::ResultSuccess) << "All tests passed";
-        stream << " ("
-            << pluralise(totals.assertions.passed, "assertion") << " in "
-            << pluralise(totals.testCases.passed, "test case") << ')'
-            << '\n';
-    } else {
-
-        std::vector<SummaryColumn> columns;
-        columns.push_back(SummaryColumn("", Colour::None)
-                          .addRow(totals.testCases.total())
-                          .addRow(totals.assertions.total()));
-        columns.push_back(SummaryColumn("passed", Colour::Success)
-                          .addRow(totals.testCases.passed)
-                          .addRow(totals.assertions.passed));
-        columns.push_back(SummaryColumn("failed", Colour::ResultError)
-                          .addRow(totals.testCases.failed)
-                          .addRow(totals.assertions.failed));
-        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
-                          .addRow(totals.testCases.failedButOk)
-                          .addRow(totals.assertions.failedButOk));
-
-        printSummaryRow("test cases", columns, 0);
-        printSummaryRow("assertions", columns, 1);
-    }
-}
-void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
-    for (auto col : cols) {
-        std::string value = col.rows[row];
-        if (col.label.empty()) {
-            stream << label << ": ";
-            if (value != "0")
-                stream << value;
-            else
-                stream << Colour(Colour::Warning) << "- none -";
-        } else if (value != "0") {
-            stream << Colour(Colour::LightGrey) << " | ";
-            stream << Colour(col.colour)
-                << value << ' ' << col.label;
-        }
-    }
-    stream << '\n';
-}
-
-void ConsoleReporter::printTotalsDivider(Totals const& totals) {
-    if (totals.testCases.total() > 0) {
-        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
-        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
-        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
-        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)++;
-        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
-            findMax(failedRatio, failedButOkRatio, passedRatio)--;
-
-        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
-        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
-        if (totals.testCases.allPassed())
-            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
-        else
-            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
-    } else {
-        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
-    }
-    stream << '\n';
-}
-void ConsoleReporter::printSummaryDivider() {
-    stream << getLineOfChars<'-'>() << '\n';
-}
-
-void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters()) {
-        Colour guard(Colour::BrightYellow);
-        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
-    }
-}
-
-CATCH_REGISTER_REPORTER("console", ConsoleReporter)
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#if defined(__clang__)
-#  pragma clang diagnostic pop
-#endif
-// end catch_reporter_console.cpp
-// start catch_reporter_junit.cpp
-
-#include <cassert>
-#include <sstream>
-#include <ctime>
-#include <algorithm>
-
-namespace Catch {
-
-    namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
-
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
-
-        std::string fileNameTag(const std::vector<std::string> &tags) {
-            auto it = std::find_if(begin(tags),
-                                   end(tags),
-                                   [] (std::string const& tag) {return tag.front() == '#'; });
-            if (it != tags.end())
-                return it->substr(1);
-            return std::string();
-        }
-    } // anonymous namespace
-
-    JunitReporter::JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-    JunitReporter::~JunitReporter() {}
-
-    std::string JunitReporter::getDescription() {
-        return "Reports test results in an XML format that looks like Ant's junitreport target";
-    }
-
-    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
-        CumulativeReporterBase::testRunStarting( runInfo );
-        xml.startElement( "testsuites" );
-    }
-
-    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        suiteTimer.start();
-        stdOutForSuite.clear();
-        stdErrForSuite.clear();
-        unexpectedExceptions = 0;
-        CumulativeReporterBase::testGroupStarting( groupInfo );
-    }
-
-    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
-        m_okToFail = testCaseInfo.okToFail();
-    }
-
-    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-            unexpectedExceptions++;
-        return CumulativeReporterBase::assertionEnded( assertionStats );
-    }
-
-    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        stdOutForSuite += testCaseStats.stdOut;
-        stdErrForSuite += testCaseStats.stdErr;
-        CumulativeReporterBase::testCaseEnded( testCaseStats );
-    }
-
-    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        double suiteTime = suiteTimer.getElapsedSeconds();
-        CumulativeReporterBase::testGroupEnded( testGroupStats );
-        writeGroup( *m_testGroups.back(), suiteTime );
-    }
-
-    void JunitReporter::testRunEndedCumulative() {
-        xml.endElement();
-    }
-
-    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-
-        TestGroupStats const& stats = groupNode.value;
-        xml.writeAttribute( "name", stats.groupInfo.name );
-        xml.writeAttribute( "errors", unexpectedExceptions );
-        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-        xml.writeAttribute( "tests", stats.totals.assertions.total() );
-        xml.writeAttribute( "hostname", "tbd" ); // !TBD
-        if( m_config->showDurations() == ShowDurations::Never )
-            xml.writeAttribute( "time", "" );
-        else
-            xml.writeAttribute( "time", suiteTime );
-        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
-
-        // Write properties if there are any
-        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
-            auto properties = xml.scopedElement("properties");
-            if (m_config->hasTestFilters()) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "filters")
-                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
-            }
-            if (m_config->rngSeed() != 0) {
-                xml.scopedElement("property")
-                    .writeAttribute("name", "random-seed")
-                    .writeAttribute("value", m_config->rngSeed());
-            }
-        }
-
-        // Write test cases
-        for( auto const& child : groupNode.children )
-            writeTestCase( *child );
-
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
-    }
-
-    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
-        TestCaseStats const& stats = testCaseNode.value;
-
-        // All test cases have exactly one section - which represents the
-        // test case itself. That section may have 0-n nested sections
-        assert( testCaseNode.children.size() == 1 );
-        SectionNode const& rootSection = *testCaseNode.children.front();
-
-        std::string className = stats.testInfo.className;
-
-        if( className.empty() ) {
-            className = fileNameTag(stats.testInfo.tags);
-            if ( className.empty() )
-                className = "global";
-        }
-
-        if ( !m_config->name().empty() )
-            className = m_config->name() + "." + className;
-
-        writeSection( className, "", rootSection );
-    }
-
-    void JunitReporter::writeSection(  std::string const& className,
-                        std::string const& rootName,
-                        SectionNode const& sectionNode ) {
-        std::string name = trim( sectionNode.stats.sectionInfo.name );
-        if( !rootName.empty() )
-            name = rootName + '/' + name;
-
-        if( !sectionNode.assertions.empty() ||
-            !sectionNode.stdOut.empty() ||
-            !sectionNode.stdErr.empty() ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-            if( className.empty() ) {
-                xml.writeAttribute( "classname", name );
-                xml.writeAttribute( "name", "root" );
-            }
-            else {
-                xml.writeAttribute( "classname", className );
-                xml.writeAttribute( "name", name );
-            }
-            xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
-
-            writeAssertions( sectionNode );
-
-            if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
-            if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
-        }
-        for( auto const& childNode : sectionNode.childSections )
-            if( className.empty() )
-                writeSection( name, "", *childNode );
-            else
-                writeSection( className, name, *childNode );
-    }
-
-    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
-        for( auto const& assertion : sectionNode.assertions )
-            writeAssertion( assertion );
-    }
-
-    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
-        AssertionResult const& result = stats.assertionResult;
-        if( !result.isOk() ) {
-            std::string elementName;
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                case ResultWas::FatalErrorCondition:
-                    elementName = "error";
-                    break;
-                case ResultWas::ExplicitFailure:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::DidntThrowException:
-                    elementName = "failure";
-                    break;
-
-                // We should never see these here:
-                case ResultWas::Info:
-                case ResultWas::Warning:
-                case ResultWas::Ok:
-                case ResultWas::Unknown:
-                case ResultWas::FailureBit:
-                case ResultWas::Exception:
-                    elementName = "internalError";
-                    break;
-            }
-
-            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-            xml.writeAttribute( "message", result.getExpression() );
-            xml.writeAttribute( "type", result.getTestMacroName() );
-
-            ReusableStringStream rss;
-            if (stats.totals.assertions.total() > 0) {
-                rss << "FAILED" << ":\n";
-                if (result.hasExpression()) {
-                    rss << "  ";
-                    rss << result.getExpressionInMacro();
-                    rss << '\n';
-                }
-                if (result.hasExpandedExpression()) {
-                    rss << "with expansion:\n";
-                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
-                }
-            } else {
-                rss << '\n';
-            }
-
-            if( !result.getMessage().empty() )
-                rss << result.getMessage() << '\n';
-            for( auto const& msg : stats.infoMessages )
-                if( msg.type == ResultWas::Info )
-                    rss << msg.message << '\n';
-
-            rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), XmlFormatting::Newline );
-        }
-    }
-
-    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-// end catch_reporter_junit.cpp
-// start catch_reporter_listening.cpp
-
-#include <cassert>
-
-namespace Catch {
-
-    ListeningReporter::ListeningReporter() {
-        // We will assume that listeners will always want all assertions
-        m_preferences.shouldReportAllAssertions = true;
-    }
-
-    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( std::move( listener ) );
-    }
-
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = std::move( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
-    }
-
-    ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_preferences;
-    }
-
-    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
-        return std::set<Verbosity>{ };
-    }
-
-    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->noMatchingTestCases( spec );
-        }
-        m_reporter->noMatchingTestCases( spec );
-    }
-
-    void ListeningReporter::reportInvalidArguments(std::string const&arg){
-        for ( auto const& listener : m_listeners ) {
-            listener->reportInvalidArguments( arg );
-        }
-        m_reporter->reportInvalidArguments( arg );
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkPreparing(name);
-		}
-		m_reporter->benchmarkPreparing(name);
-	}
-    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
-        }
-        m_reporter->benchmarkStarting( benchmarkInfo );
-    }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
-        }
-        m_reporter->benchmarkEnded( benchmarkStats );
-    }
-
-	void ListeningReporter::benchmarkFailed( std::string const& error ) {
-		for (auto const& listener : m_listeners) {
-			listener->benchmarkFailed(error);
-		}
-		m_reporter->benchmarkFailed(error);
-	}
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
-        }
-        m_reporter->testRunStarting( testRunInfo );
-    }
-
-    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupStarting( groupInfo );
-        }
-        m_reporter->testGroupStarting( groupInfo );
-    }
-
-    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
-        }
-        m_reporter->testCaseStarting( testInfo );
-    }
-
-    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
-        }
-        m_reporter->sectionStarting( sectionInfo );
-    }
-
-    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
-        }
-        m_reporter->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto const& listener : m_listeners ) {
-            static_cast<void>( listener->assertionEnded( assertionStats ) );
-        }
-        return m_reporter->assertionEnded( assertionStats );
-    }
-
-    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
-        }
-        m_reporter->sectionEnded( sectionStats );
-    }
-
-    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
-        }
-        m_reporter->testCaseEnded( testCaseStats );
-    }
-
-    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testGroupEnded( testGroupStats );
-        }
-        m_reporter->testGroupEnded( testGroupStats );
-    }
-
-    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
-        }
-        m_reporter->testRunEnded( testRunStats );
-    }
-
-    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto const& listener : m_listeners ) {
-            listener->skipTest( testInfo );
-        }
-        m_reporter->skipTest( testInfo );
-    }
-
-    bool ListeningReporter::isMulti() const {
-        return true;
-    }
-
-} // end namespace Catch
-// end catch_reporter_listening.cpp
-// start catch_reporter_xml.cpp
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
-
-namespace Catch {
-    XmlReporter::XmlReporter( ReporterConfig const& _config )
-    :   StreamingReporterBase( _config ),
-        m_xml(_config.stream())
-    {
-        m_reporterPrefs.shouldRedirectStdOut = true;
-        m_reporterPrefs.shouldReportAllAssertions = true;
-    }
-
-    XmlReporter::~XmlReporter() = default;
-
-    std::string XmlReporter::getDescription() {
-        return "Reports test results as an XML document";
-    }
-
-    std::string XmlReporter::getStylesheetRef() const {
-        return std::string();
-    }
-
-    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-        m_xml
-            .writeAttribute( "filename", sourceInfo.file )
-            .writeAttribute( "line", sourceInfo.line );
-    }
-
-    void XmlReporter::noMatchingTestCases( std::string const& s ) {
-        StreamingReporterBase::noMatchingTestCases( s );
-    }
-
-    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
-        StreamingReporterBase::testRunStarting( testInfo );
-        std::string stylesheetRef = getStylesheetRef();
-        if( !stylesheetRef.empty() )
-            m_xml.writeStylesheetRef( stylesheetRef );
-        m_xml.startElement( "Catch" );
-        if( !m_config->name().empty() )
-            m_xml.writeAttribute( "name", m_config->name() );
-        if (m_config->testSpec().hasFilters())
-            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
-        if( m_config->rngSeed() != 0 )
-            m_xml.scopedElement( "Randomness" )
-                .writeAttribute( "seed", m_config->rngSeed() );
-    }
-
-    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
-        StreamingReporterBase::testGroupStarting( groupInfo );
-        m_xml.startElement( "Group" )
-            .writeAttribute( "name", groupInfo.name );
-    }
-
-    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        StreamingReporterBase::testCaseStarting(testInfo);
-        m_xml.startElement( "TestCase" )
-            .writeAttribute( "name", trim( testInfo.name ) )
-            .writeAttribute( "description", testInfo.description )
-            .writeAttribute( "tags", testInfo.tagsAsString() );
-
-        writeSourceInfo( testInfo.lineInfo );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            m_testCaseTimer.start();
-        m_xml.ensureTagClosed();
-    }
-
-    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        StreamingReporterBase::sectionStarting( sectionInfo );
-        if( m_sectionDepth++ > 0 ) {
-            m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) );
-            writeSourceInfo( sectionInfo.lineInfo );
-            m_xml.ensureTagClosed();
-        }
-    }
-
-    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
-
-    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
-
-        AssertionResult const& result = assertionStats.assertionResult;
-
-        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-        if( includeResults || result.getResultType() == ResultWas::Warning ) {
-            // Print any info messages in <Info> tags.
-            for( auto const& msg : assertionStats.infoMessages ) {
-                if( msg.type == ResultWas::Info && includeResults ) {
-                    m_xml.scopedElement( "Info" )
-                            .writeText( msg.message );
-                } else if ( msg.type == ResultWas::Warning ) {
-                    m_xml.scopedElement( "Warning" )
-                            .writeText( msg.message );
-                }
-            }
-        }
-
-        // Drop out if result was successful but we're not printing them.
-        if( !includeResults && result.getResultType() != ResultWas::Warning )
-            return true;
-
-        // Print the expression if there is one.
-        if( result.hasExpression() ) {
-            m_xml.startElement( "Expression" )
-                .writeAttribute( "success", result.succeeded() )
-                .writeAttribute( "type", result.getTestMacroName() );
-
-            writeSourceInfo( result.getSourceInfo() );
-
-            m_xml.scopedElement( "Original" )
-                .writeText( result.getExpression() );
-            m_xml.scopedElement( "Expanded" )
-                .writeText( result.getExpandedExpression() );
-        }
-
-        // And... Print a result applicable to each result type.
-        switch( result.getResultType() ) {
-            case ResultWas::ThrewException:
-                m_xml.startElement( "Exception" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::FatalErrorCondition:
-                m_xml.startElement( "FatalErrorCondition" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            case ResultWas::Info:
-                m_xml.scopedElement( "Info" )
-                    .writeText( result.getMessage() );
-                break;
-            case ResultWas::Warning:
-                // Warning will already have been written
-                break;
-            case ResultWas::ExplicitFailure:
-                m_xml.startElement( "Failure" );
-                writeSourceInfo( result.getSourceInfo() );
-                m_xml.writeText( result.getMessage() );
-                m_xml.endElement();
-                break;
-            default:
-                break;
-        }
-
-        if( result.hasExpression() )
-            m_xml.endElement();
-
-        return true;
-    }
-
-    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
-        StreamingReporterBase::sectionEnded( sectionStats );
-        if( --m_sectionDepth > 0 ) {
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-            e.writeAttribute( "successes", sectionStats.assertions.passed );
-            e.writeAttribute( "failures", sectionStats.assertions.failed );
-            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-            m_xml.endElement();
-        }
-    }
-
-    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        StreamingReporterBase::testCaseEnded( testCaseStats );
-        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-        if ( m_config->showDurations() == ShowDurations::Always )
-            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-        if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
-        if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
-
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        StreamingReporterBase::testGroupEnded( testGroupStats );
-        // TODO: Check testGroupStats.aborting and act accordingly.
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        StreamingReporterBase::testRunEnded( testRunStats );
-        m_xml.scopedElement( "OverallResults" )
-            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-        m_xml.endElement();
-    }
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-    void XmlReporter::benchmarkPreparing(std::string const& name) {
-        m_xml.startElement("BenchmarkResults")
-            .writeAttribute("name", name);
-    }
-
-    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
-        m_xml.writeAttribute("samples", info.samples)
-            .writeAttribute("resamples", info.resamples)
-            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", info.clockResolution)
-            .writeAttribute("estimatedDuration", info.estimatedDuration)
-            .writeComment("All values in nano seconds");
-    }
-
-    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
-        m_xml.startElement("mean")
-            .writeAttribute("value", benchmarkStats.mean.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("standardDeviation")
-            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
-            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
-            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
-            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
-        m_xml.endElement();
-        m_xml.startElement("outliers")
-            .writeAttribute("variance", benchmarkStats.outlierVariance)
-            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
-            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
-            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
-            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
-        m_xml.endElement();
-        m_xml.endElement();
-    }
-
-    void XmlReporter::benchmarkFailed(std::string const &error) {
-        m_xml.scopedElement("failed").
-            writeAttribute("message", error);
-        m_xml.endElement();
-    }
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-// end catch_reporter_xml.cpp
-
-namespace Catch {
-    LeakDetector leakDetector;
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// end catch_impl.hpp
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// start catch_default_main.hpp
-
-#ifndef __OBJC__
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
-// Standard C/C++ Win32 Unicode wmain entry point
-extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
-#else
-// Standard C/C++ main entry point
-int main (int argc, char * argv[]) {
-#endif
-
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char**)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-// end catch_default_main.hpp
-#endif
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-// start catch_reenable_warnings.h
-
-
-#ifdef __clang__
-#    ifdef __ICC // icpc defines the __clang__ macro
-#        pragma warning(pop)
-#    else
-#        pragma clang diagnostic pop
-#    endif
-#elif defined __GNUC__
-#    pragma GCC diagnostic pop
-#endif
-
-// end catch_reenable_warnings.h
-// end catch.hpp
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/unittest/catch2/catch_reporter_automake.hpp b/unittest/catch2/catch_reporter_automake.hpp
deleted file mode 100644
index dbebe975..00000000
--- a/unittest/catch2/catch_reporter_automake.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *  Created by Justin R. Wilson on 2/19/2017.
- *  Copyright 2017 Justin R. Wilson. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-namespace Catch {
-
-    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
-        AutomakeReporter( ReporterConfig const& _config )
-          :   StreamingReporterBase( _config )
-        {}
-
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the format of Automake .trs files";
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-            stream << ":test-result: ";
-            if (_testCaseStats.totals.assertions.allPassed()) {
-                stream << "PASS";
-            } else if (_testCaseStats.totals.assertions.allOk()) {
-                stream << "XFAIL";
-            } else {
-                stream << "FAIL";
-            }
-            stream << ' ' << _testCaseStats.testInfo.name << '\n';
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-        }
-
-        void skipTest( TestCaseInfo const& testInfo ) override {
-            stream << ":test-result: SKIP " << testInfo.name << '\n';
-        }
-
-    };
-
-#ifdef CATCH_IMPL
-    AutomakeReporter::~AutomakeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_sonarqube.hpp b/unittest/catch2/catch_reporter_sonarqube.hpp
deleted file mode 100644
index bf7d9299..00000000
--- a/unittest/catch2/catch_reporter_sonarqube.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Created by Daniel Garcia on 2018-12-04.
- *  Copyright Social Point SL. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <map>
-
-namespace Catch {
-
-    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
-
-        SonarQubeReporter(ReporterConfig const& config)
-        : CumulativeReporterBase(config)
-        , xml(config.stream()) {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-            m_reporterPrefs.shouldReportAllAssertions = true;
-        }
-
-        ~SonarQubeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the Generic Test Data SonarQube XML format";
-        }
-
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
-
-        void noMatchingTestCases(std::string const& /*spec*/) override {}
-
-        void testRunStarting(TestRunInfo const& testRunInfo) override {
-            CumulativeReporterBase::testRunStarting(testRunInfo);
-            xml.startElement("testExecutions");
-            xml.writeAttribute("version", "1");
-        }
-
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            CumulativeReporterBase::testGroupEnded(testGroupStats);
-            writeGroup(*m_testGroups.back());
-        }
-
-        void testRunEndedCumulative() override {
-            xml.endElement();
-        }
-
-        void writeGroup(TestGroupNode const& groupNode) {
-            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
-            for(auto const& child : groupNode.children)
-                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
-
-            for(auto const& kv : testsPerFile)
-                writeTestFile(kv.first.c_str(), kv.second);
-        }
-
-        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
-            XmlWriter::ScopedElement e = xml.scopedElement("file");
-            xml.writeAttribute("path", filename);
-
-            for(auto const& child : testCaseNodes)
-                writeTestCase(*child);
-        }
-
-        void writeTestCase(TestCaseNode const& testCaseNode) {
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert(testCaseNode.children.size() == 1);
-            SectionNode const& rootSection = *testCaseNode.children.front();
-            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
-        }
-
-        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
-            std::string name = trim(sectionNode.stats.sectionInfo.name);
-            if(!rootName.empty())
-                name = rootName + '/' + name;
-
-            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
-                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
-                xml.writeAttribute("name", name);
-                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
-
-                writeAssertions(sectionNode, okToFail);
-            }
-
-            for(auto const& childNode : sectionNode.childSections)
-                writeSection(name, *childNode, okToFail);
-        }
-
-        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
-            for(auto const& assertion : sectionNode.assertions)
-                writeAssertion( assertion, okToFail);
-        }
-
-        void writeAssertion(AssertionStats const& stats, bool okToFail) {
-            AssertionResult const& result = stats.assertionResult;
-            if(!result.isOk()) {
-                std::string elementName;
-                if(okToFail) {
-                    elementName = "skipped";
-                }
-                else {
-                    switch(result.getResultType()) {
-                        case ResultWas::ThrewException:
-                        case ResultWas::FatalErrorCondition:
-                            elementName = "error";
-                            break;
-                        case ResultWas::ExplicitFailure:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::ExpressionFailed:
-                            elementName = "failure";
-                            break;
-                        case ResultWas::DidntThrowException:
-                            elementName = "failure";
-                            break;
-
-                            // We should never see these here:
-                        case ResultWas::Info:
-                        case ResultWas::Warning:
-                        case ResultWas::Ok:
-                        case ResultWas::Unknown:
-                        case ResultWas::FailureBit:
-                        case ResultWas::Exception:
-                            elementName = "internalError";
-                            break;
-                    }
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
-
-                ReusableStringStream messageRss;
-                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
-                xml.writeAttribute("message", messageRss.str());
-
-                ReusableStringStream textRss;
-                if (stats.totals.assertions.total() > 0) {
-                    textRss << "FAILED:\n";
-                    if (result.hasExpression()) {
-                        textRss << "\t" << result.getExpressionInMacro() << "\n";
-                    }
-                    if (result.hasExpandedExpression()) {
-                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
-                    }
-                }
-
-                if(!result.getMessage().empty())
-                    textRss << result.getMessage() << "\n";
-
-                for(auto const& msg : stats.infoMessages)
-                    if(msg.type == ResultWas::Info)
-                        textRss << msg.message << "\n";
-
-                textRss << "at " << result.getSourceInfo();
-                xml.writeText(textRss.str(), XmlFormatting::Newline);
-            }
-        }
-
-    private:
-        XmlWriter xml;
-    };
-
-#ifdef CATCH_IMPL
-    SonarQubeReporter::~SonarQubeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
-
-} // end namespace Catch
-
-#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
\ No newline at end of file
diff --git a/unittest/catch2/catch_reporter_tap.hpp b/unittest/catch2/catch_reporter_tap.hpp
deleted file mode 100644
index 1bfe4f5e..00000000
--- a/unittest/catch2/catch_reporter_tap.hpp
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- *  Created by Colton Wolkins on 2015-08-15.
- *  Copyright 2015 Martin Moene. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <algorithm>
-
-namespace Catch {
-
-    struct TAPReporter : StreamingReporterBase<TAPReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~TAPReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in TAP format, suitable for test harnesses";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "# No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            ++counter;
-
-            stream << "# " << currentTestCaseInfo->name << std::endl;
-            AssertionPrinter printer( stream, _assertionStats, counter );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        std::size_t counter = 0;
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( true )
-            , counter(_counter)
-            {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if (result.isOk()) {
-                            printResultType(passedString());
-                        } else {
-                            printResultType(failedString());
-                        }
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if (result.isOk()) {
-                            printIssue(" # TODO");
-                        }
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-            static const char* failedString() { return "not ok"; }
-            static const char* passedString() { return "ok"; }
-
-            void printSourceInfo() const {
-                Colour colourGuard( dimColour() );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    std::string expr = result.getExpandedExpression();
-                    std::replace( expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-        };
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "1..0 # Skipped: No tests ran.";
-            } else {
-                stream << "1.." << counter;
-            }
-        }
-    };
-
-#ifdef CATCH_IMPL
-    TAPReporter::~TAPReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
diff --git a/unittest/catch2/catch_reporter_teamcity.hpp b/unittest/catch2/catch_reporter_teamcity.hpp
deleted file mode 100644
index 47b7e4aa..00000000
--- a/unittest/catch2/catch_reporter_teamcity.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- *  Created by Phil Nash on 19th December 2014
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
-        TeamCityReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        static std::string escape( std::string const& str ) {
-            std::string escaped = str;
-            replaceInPlace( escaped, "|", "||" );
-            replaceInPlace( escaped, "'", "|'" );
-            replaceInPlace( escaped, "\n", "|n" );
-            replaceInPlace( escaped, "\r", "|r" );
-            replaceInPlace( escaped, "[", "|[" );
-            replaceInPlace( escaped, "]", "|]" );
-            return escaped;
-        }
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as TeamCity service messages";
-        }
-
-        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
-        }
-
-        void noMatchingTestCases( std::string const& /* spec */ ) override {}
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            stream << "##teamcity[testSuiteStarted name='"
-                << escape( groupInfo.name ) << "']\n";
-        }
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            stream << "##teamcity[testSuiteFinished name='"
-                << escape( testGroupStats.groupInfo.name ) << "']\n";
-        }
-
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            AssertionResult const& result = assertionStats.assertionResult;
-            if( !result.isOk() ) {
-
-                ReusableStringStream msg;
-                if( !m_headerPrintedForThisSection )
-                    printSectionHeader( msg.get() );
-                m_headerPrintedForThisSection = true;
-
-                msg << result.getSourceInfo() << "\n";
-
-                switch( result.getResultType() ) {
-                    case ResultWas::ExpressionFailed:
-                        msg << "expression failed";
-                        break;
-                    case ResultWas::ThrewException:
-                        msg << "unexpected exception";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        msg << "fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        msg << "no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        msg << "explicit failure";
-                        break;
-
-                    // We shouldn't get here because of the isOk() test
-                    case ResultWas::Ok:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                        CATCH_ERROR( "Internal error in TeamCity reporter" );
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        CATCH_ERROR( "Not implemented" );
-                }
-                if( assertionStats.infoMessages.size() == 1 )
-                    msg << " with message:";
-                if( assertionStats.infoMessages.size() > 1 )
-                    msg << " with messages:";
-                for( auto const& messageInfo : assertionStats.infoMessages )
-                    msg << "\n  \"" << messageInfo.message << "\"";
-
-
-                if( result.hasExpression() ) {
-                    msg <<
-                        "\n  " << result.getExpressionInMacro() << "\n"
-                        "with expansion:\n" <<
-                        "  " << result.getExpandedExpression() << "\n";
-                }
-
-                if( currentTestCaseInfo->okToFail() ) {
-                    msg << "- failure ignore as test marked as 'ok to fail'\n";
-                    stream << "##teamcity[testIgnored"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-                else {
-                    stream << "##teamcity[testFailed"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-            }
-            stream.flush();
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            m_testTimer.start();
-            StreamingReporterBase::testCaseStarting( testInfo );
-            stream << "##teamcity[testStarted name='"
-                << escape( testInfo.name ) << "']\n";
-            stream.flush();
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            if( !testCaseStats.stdOut.empty() )
-                stream << "##teamcity[testStdOut name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
-            if( !testCaseStats.stdErr.empty() )
-                stream << "##teamcity[testStdErr name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
-            stream << "##teamcity[testFinished name='"
-                    << escape( testCaseStats.testInfo.name ) << "' duration='"
-                    << m_testTimer.getElapsedMilliseconds() << "']\n";
-            stream.flush();
-        }
-
-    private:
-        void printSectionHeader( std::ostream& os ) {
-            assert( !m_sectionStack.empty() );
-
-            if( m_sectionStack.size() > 1 ) {
-                os << getLineOfChars<'-'>() << "\n";
-
-                std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin()+1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( os, it->name );
-                os << getLineOfChars<'-'>() << "\n";
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            os << lineInfo << "\n";
-            os << getLineOfChars<'.'>() << "\n\n";
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            os << Column( _string )
-                           .indent( indent+i)
-                           .initialIndent( indent ) << "\n";
-        }
-    private:
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-#ifdef CATCH_IMPL
-    TeamCityReporter::~TeamCityReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

From 82ccd146927f80e154e430ab5ce13b966a596263 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:25:11 +0100
Subject: [PATCH 0938/1292] added new tests

---
 unittest/tests/storagemanager/TestPool.cpp | 243 ++++++++++++++++++---
 1 file changed, 217 insertions(+), 26 deletions(-)

diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index 5b22118e..3f5341e9 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,20 +1,26 @@
+#include "CatchDefinitions.h"
+
 #include <config/objects/Factory.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
-#include <catch2/catch.hpp>
-#include "core/CatchDefinitions.h"
+
+#include <catch.hpp>
+#include <CatchDefinitions.h>
+
+#include <cstring>
+
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-	uint16_t numberOfElements[1] = {1};
-	uint16_t sizeofElements[1] = {10};
-	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+//	uint16_t numberOfElements[1] = {1};
+//	uint16_t sizeofElements[1] = {10};
+	LocalPool::LocalPoolConfig config = {{1, 10}};
+	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;
 	std::array<uint8_t, 20> receptionArray;
 	store_address_t testStoreId;
 	ReturnValue_t result = retval::CATCH_FAILED;
 	uint8_t *pointer = nullptr;
 	const uint8_t * constPointer = nullptr;
-	uint8_t test = 0;
 
 	for(size_t i = 0; i < testDataArray.size(); i++) {
 		testDataArray[i] = i;
@@ -22,34 +28,34 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 	size_t size = 10;
 
 	SECTION ( "Basic tests") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE(result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
 		memset(receptionArray.data(), 0, size);
-		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
 		memcpy(receptionArray.data(), pointer, size);
 		REQUIRE(result == retval::CATCH_OK);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
-		result = SimplePool.deleteData(testStoreId);
+		result = simplePool.deleteData(testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), 15);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), 15);
 		CHECK (result == (int) StorageManagerIF::DATA_TOO_LARGE);
 	}
 
 	SECTION ( "Reservation Tests ") {
 		pointer = nullptr;
-		result = SimplePool.getFreeElement(&testStoreId, size, &pointer);
+		result = simplePool.getFreeElement(&testStoreId, size, &pointer);
 		REQUIRE (result == retval::CATCH_OK);
 		memcpy(pointer, testDataArray.data(), size);
 		constPointer = nullptr;
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 
 		REQUIRE (result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
@@ -59,21 +65,21 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 	}
 
 	SECTION ( "Add, delete, add, add when full") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE( result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
 			CHECK(receptionArray[i] == i );
 		}
 
-		result = SimplePool.deleteData(testStoreId);
+		result = simplePool.deleteData(testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
 
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.getData(testStoreId, &constPointer, &size);
+		result = simplePool.getData(testStoreId, &constPointer, &size);
 		REQUIRE( result == retval::CATCH_OK);
 		memcpy(receptionArray.data(), constPointer, size);
 		for(size_t i = 0; i < size; i++) {
@@ -81,25 +87,210 @@ TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
 		}
 
 		store_address_t newAddress;
-		result = SimplePool.addData(&newAddress, testDataArray.data(), size);
+		result = simplePool.addData(&newAddress, testDataArray.data(), size);
 		REQUIRE(result == (int) StorageManagerIF::DATA_STORAGE_FULL);
+
+		// Packet Index to high intentionally
+		newAddress.packetIndex = 2;
+		pointer = testDataArray.data();
+		result = simplePool.modifyData(newAddress, &pointer, &size);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+		newAddress.packetIndex = 0;
+		newAddress.poolIndex = 2;
+		result = simplePool.deleteData(newAddress);
+		REQUIRE(result == (int) StorageManagerIF::ILLEGAL_STORAGE_ID);
 	}
 
 	SECTION ( "Initialize and clear store, delete with pointer") {
-		result = SimplePool.initialize();
+		result = simplePool.initialize();
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		SimplePool.clearStore();
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		simplePool.clearStore();
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
-		result = SimplePool.modifyData(testStoreId, &pointer, &size);
+		result = simplePool.modifyData(testStoreId, &pointer, &size);
 		REQUIRE(result == retval::CATCH_OK);
 		store_address_t newId;
-		result = SimplePool.deleteData(pointer, size, &testStoreId);
+		result = simplePool.deleteData(pointer, size, &testStoreId);
 		REQUIRE(result == retval::CATCH_OK);
 		REQUIRE(testStoreId.raw != (uint32_t) StorageManagerIF::INVALID_ADDRESS);
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
 		REQUIRE(result == retval::CATCH_OK);
 	}
 }
+
+int runIdx = 0;
+
+TEST_CASE( "Local Pool Extended Tests [3 Pools]" , "[TestPool2]") {
+	LocalPool::LocalPoolConfig* config;
+	if(runIdx == 0) {
+		config = new LocalPool::LocalPoolConfig{{10, 5}, {5, 10}, {2, 20}};
+	}
+	else {
+		// shufle the order, they should be sort implictely so that the
+		// order is ascending for the page sizes.
+		config = new LocalPool::LocalPoolConfig{{5, 10}, {2, 20}, {10, 5}};
+		size_t lastSize = 0;
+		for(const auto& pair: *config) {
+			CHECK(pair.second > lastSize);
+			lastSize = pair.second;
+		}
+	}
+	runIdx++;
+
+	LocalPool simplePool(0, *config);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 0;
+
+	SECTION ("Basic tests") {
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on second page of the pool now for 8 bytes
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 0);
+
+		size = 15;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 0);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should be on third page of the pool now for 15 bytes
+		CHECK(testStoreId.poolIndex == 2);
+		CHECK(testStoreId.packetIndex == 1);
+
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		// Should be on third page of the pool now for 15 bytes
+		REQUIRE(result == (int) LocalPool::DATA_STORAGE_FULL);
+
+		size = 8;
+		result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		// Should still work
+		CHECK(testStoreId.poolIndex == 1);
+		CHECK(testStoreId.packetIndex == 1);
+
+		// fill the rest of the pool
+		for(uint8_t idx = 2; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+	}
+
+	SECTION ("Fill Count and Clearing") {
+		//SECTION("Basic tests");
+		uint8_t bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all zeros now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill the store completely.
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		size = 20;
+		for(uint8_t idx = 0; idx < 2; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 2);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// fill count should be all 100 now.
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 100);
+		CHECK(receptionArray[3] == 100);
+
+		// now clear the store
+		simplePool.clearStore();
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 0);
+
+		// now fill one page
+		size = 5;
+		for(uint8_t idx = 0; idx < 10; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 0);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 0);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+
+		// now fill second page
+		size = 10;
+		for(uint8_t idx = 0; idx < 5; idx++) {
+			result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(testStoreId.poolIndex == 1);
+			CHECK(testStoreId.packetIndex == idx);
+		}
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// First and second page full, median fill count is 66 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 100);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 66);
+
+		// now clear first page
+		simplePool.clearPage(0);
+		bytesWritten = 0;
+		simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+		// Second page full, median fill count is 33 %
+		CHECK(bytesWritten == 4);
+		CHECK(receptionArray[0] == 0);
+		CHECK(receptionArray[1] == 100);
+		CHECK(receptionArray[2] == 0);
+		CHECK(receptionArray[3] == 33);
+	}
+
+	delete(config);
+}

From 24cb83498ae4c8a50db33ce6f235913fbe2695bc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 21:28:59 +0100
Subject: [PATCH 0939/1292] include fix

---
 unittest/core/CatchRunner.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
index 566db692..e15c8b2a 100644
--- a/unittest/core/CatchRunner.cpp
+++ b/unittest/core/CatchRunner.cpp
@@ -9,7 +9,7 @@
 #ifndef NO_UNIT_TEST_FRAMEWORK
 
 #define CATCH_CONFIG_RUNNER
-#include <fsfw/unittest/catch2/catch.hpp>
+#include <catch2/catch.hpp>
 
 extern int customSetup();
 

From 6325eb764717af8470715cb34934c2e7e0953f0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:11:13 +0100
Subject: [PATCH 0940/1292] include fixes

---
 unittest/core/CatchSetup.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 5436fd5d..ca5c456d 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,24 +1,24 @@
+#include "CatchDefinitions.h"
 #include "../config/cdatapool/dataPoolInit.h"
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
-#include <fsfw/unittest/config/objects/Factory.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include "../config/objects/Factory.h"
+
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/storagemanager/StorageManagerIF.h>
-#include <fsfw/datapool/DataPool.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include "../../objectmanager/ObjectManager.h"
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../datapoolglob/GlobalDataPool.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-//namespace glob {
-DataPool dataPool(datapool::dataPoolInit);
-//}
+namespace glob {
+GlobalDataPool dataPool(datapool::dataPoolInit);
+}
 
 
 namespace sif {

From b860d8bce788c3f530282721d63fea3995e7a376 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:34:41 +0100
Subject: [PATCH 0941/1292] include fixes

---
 unittest/config/cdatapool/dataPoolInit.cpp    |   2 +-
 unittest/config/cdatapool/dataPoolInit.h      |   2 +-
 unittest/config/objects/Factory.cpp           |   5 +-
 unittest/tests/action/TestActionHelper.cpp    | 211 ++++++------
 unittest/tests/action/TestActionHelper.h      | 262 +++++++-------
 unittest/tests/container/RingBufferTest.cpp   |   4 +-
 unittest/tests/container/TestArrayList.cpp    |   4 +-
 unittest/tests/container/TestFifo.cpp         |   4 +-
 .../tests/container/TestFixedArrayList.cpp    |   5 +-
 unittest/tests/container/TestFixedMap.cpp     |   4 +-
 .../container/TestFixedOrderedMultimap.cpp    |   4 +-
 .../tests/container/TestPlacementFactory.cpp  |  90 ++---
 .../serialize/TestSerialBufferAdapter.cpp     |   4 +-
 .../serialize/TestSerialLinkedPacket.cpp      |   6 +-
 .../tests/serialize/TestSerialization.cpp     |   2 +-
 .../tests/storagemanager/TestNewAccessor.cpp  | 322 +++++++++---------
 16 files changed, 465 insertions(+), 466 deletions(-)

diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
index 6c2278ab..f24d6cc5 100644
--- a/unittest/config/cdatapool/dataPoolInit.cpp
+++ b/unittest/config/cdatapool/dataPoolInit.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
+#include "dataPoolInit.h"
 
 void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
 	uint8_t UINT8T_INIT[1] = {0};
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
index d482cc35..6fd32371 100644
--- a/unittest/config/cdatapool/dataPoolInit.h
+++ b/unittest/config/cdatapool/dataPoolInit.h
@@ -1,7 +1,7 @@
 #ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 #define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 
-#include <fsfw/datapool/DataPool.h>
+#include <fsfw/datapoolglob/GlobalDataPool.h>
 #include <fsfw/datapool/PoolEntryIF.h>
 #include <map>
 #include <cstdint>
diff --git a/unittest/config/objects/Factory.cpp b/unittest/config/objects/Factory.cpp
index e325b891..612527c9 100644
--- a/unittest/config/objects/Factory.cpp
+++ b/unittest/config/objects/Factory.cpp
@@ -23,10 +23,7 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER,
-				datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-				datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-				datapool::INTERNAL_ERROR_STORE_FULL);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
 }
 
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 33c6b425..d5b2e467 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,105 +1,106 @@
-#include <fsfw/action/ActionHelper.h>
-#include <fsfw/ipc/CommandMessage.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <fsfw/unittest/tests/action/TestActionHelper.h>
-
-TEST_CASE( "Action Helper" , "[ActionHelper]") {
-	ActionHelperOwnerMockBase testDhMock;
-	MessageQueueMockBase testMqMock;
-	ActionHelper actionHelper = ActionHelper(
-			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
-	CommandMessage actionMessage;
-	ActionId_t testActionId = 777;
-	std::array <uint8_t, 3> testParams {1, 2, 3};
-	store_address_t paramAddress;
-	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
-	ipcStore->addData(&paramAddress, testParams.data(), 3);
-	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
-
-	SECTION ("Simple tests") {
-		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
-		 CHECK(not testDhMock.executeActionCalled);
-		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		 CHECK(testDhMock.executeActionCalled);
-		 // No message is sent if everything is alright.
-		 CHECK(not testMqMock.wasMessageSent());
-		 store_address_t invalidAddress;
-		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-		 actionHelper.handleActionMessage(&actionMessage);
-		 CHECK(testMqMock.wasMessageSent());
-		 const uint8_t* ptr = nullptr;
-		 size_t size = 0;
-		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-		 REQUIRE(ptr == nullptr);
-		 REQUIRE(size == 0);
-		 testDhMock.getBuffer(&ptr, &size);
-		 REQUIRE(size == 3);
-		 for(uint8_t i = 0; i<3;i++){
-			 REQUIRE(ptr[i] == (i+1));
-		 }
-		 testDhMock.clearBuffer();
-	}
-
-	SECTION("Handle failures"){
-		actionMessage.setCommand(1234);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
-		CHECK(not testMqMock.wasMessageSent());
-		uint16_t step = 5;
-		ReturnValue_t status = 0x1234;
-		actionHelper.step(step, testMqMock.getId(), testActionId, status);
-		step += 1;
-		CHECK(testMqMock.wasMessageSent());
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
-		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
-		REQUIRE(testMessage.getParameter2() == parameter2);
-		REQUIRE(ActionMessage::getStep(&testMessage) == step);
-	}
-
-	SECTION("Handle finish"){
-		CHECK(not testMqMock.wasMessageSent());
-		ReturnValue_t status = 0x9876;
-		actionHelper.finish(testMqMock.getId(), testActionId, status);
-		CHECK(testMqMock.wasMessageSent());
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
-		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
-	}
-
-	SECTION("Handle failed"){
-		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
-		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
-		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
-		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
-		CHECK(not testDhMock.executeActionCalled);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
-		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-	}
-
-	SECTION("Missing IPC Data"){
-		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
-		CHECK(not testDhMock.executeActionCalled);
-		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-		CommandMessage testMessage;
-		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
-		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-	}
-
-
-	SECTION("Data Reply"){
-
-	}
-}
+//#include "TestActionHelper.h"
+//#include <fsfw/action/ActionHelper.h>
+//#include <fsfw/ipc/CommandMessage.h>
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//
+//
+//TEST_CASE( "Action Helper" , "[ActionHelper]") {
+//	ActionHelperOwnerMockBase testDhMock;
+//	MessageQueueMockBase testMqMock;
+//	ActionHelper actionHelper = ActionHelper(
+//			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+//	CommandMessage actionMessage;
+//	ActionId_t testActionId = 777;
+//	std::array <uint8_t, 3> testParams {1, 2, 3};
+//	store_address_t paramAddress;
+//	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+//	ipcStore->addData(&paramAddress, testParams.data(), 3);
+//	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+//
+//	SECTION ("Simple tests") {
+//		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+//		 CHECK(not testDhMock.executeActionCalled);
+//		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		 CHECK(testDhMock.executeActionCalled);
+//		 // No message is sent if everything is alright.
+//		 CHECK(not testMqMock.wasMessageSent());
+//		 store_address_t invalidAddress;
+//		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+//		 actionHelper.handleActionMessage(&actionMessage);
+//		 CHECK(testMqMock.wasMessageSent());
+//		 const uint8_t* ptr = nullptr;
+//		 size_t size = 0;
+//		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+//		 REQUIRE(ptr == nullptr);
+//		 REQUIRE(size == 0);
+//		 testDhMock.getBuffer(&ptr, &size);
+//		 REQUIRE(size == 3);
+//		 for(uint8_t i = 0; i<3;i++){
+//			 REQUIRE(ptr[i] == (i+1));
+//		 }
+//		 testDhMock.clearBuffer();
+//	}
+//
+//	SECTION("Handle failures"){
+//		actionMessage.setCommand(1234);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+//		CHECK(not testMqMock.wasMessageSent());
+//		uint16_t step = 5;
+//		ReturnValue_t status = 0x1234;
+//		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+//		step += 1;
+//		CHECK(testMqMock.wasMessageSent());
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+//		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+//		REQUIRE(testMessage.getParameter2() == parameter2);
+//		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+//	}
+//
+//	SECTION("Handle finish"){
+//		CHECK(not testMqMock.wasMessageSent());
+//		ReturnValue_t status = 0x9876;
+//		actionHelper.finish(testMqMock.getId(), testActionId, status);
+//		CHECK(testMqMock.wasMessageSent());
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+//	}
+//
+//	SECTION("Handle failed"){
+//		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+//		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+//		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+//		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+//		CHECK(not testDhMock.executeActionCalled);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+//	}
+//
+//	SECTION("Missing IPC Data"){
+//		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+//		CHECK(not testDhMock.executeActionCalled);
+//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+//		CommandMessage testMessage;
+//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+//	}
+//
+//
+//	SECTION("Data Reply"){
+//
+//	}
+//}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index fcc20f90..9bc93d3e 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -1,131 +1,131 @@
-#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
-#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
-
-#include <fsfw/action/HasActionsIF.h>
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <cstring>
-
-
-class ActionHelperOwnerMockBase: public HasActionsIF {
-public:
-	bool getCommandQueueCalled = false;
-	bool executeActionCalled = false;
-	static const size_t MAX_SIZE = 3;
-	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
-	size_t size = 0;
-
-	MessageQueueId_t getCommandQueue() const override {
-		return tconst::testQueueId;
-	}
-
-	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-			const uint8_t* data, size_t size) override {
-		executeActionCalled = true;
-		if(size > MAX_SIZE){
-			return 0xAFFE;
-		}
-		this->size = size;
-		memcpy(buffer, data, size);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	void clearBuffer(){
-		this->size = 0;
-		for(size_t i = 0; i<MAX_SIZE; i++){
-			buffer[i] = 0;
-		}
-	}
-
-	void getBuffer(const uint8_t** ptr, size_t* size){
-		if(size != nullptr){
-			*size = this->size;
-		}
-		if(ptr != nullptr){
-			*ptr = buffer;
-		}
-	}
-};
-
-
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
-		messageSent = true;
-		lastMessage = (*message);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
-#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
+//#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+//#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+//
+//#include <fsfw/action/HasActionsIF.h>
+//#include <fsfw/ipc/MessageQueueIF.h>
+//#include <fsfw/unittest/core/CatchDefinitions.h>
+//#include <cstring>
+//
+//
+//class ActionHelperOwnerMockBase: public HasActionsIF {
+//public:
+//	bool getCommandQueueCalled = false;
+//	bool executeActionCalled = false;
+//	static const size_t MAX_SIZE = 3;
+//	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+//	size_t size = 0;
+//
+//	MessageQueueId_t getCommandQueue() const override {
+//		return tconst::testQueueId;
+//	}
+//
+//	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+//			const uint8_t* data, size_t size) override {
+//		executeActionCalled = true;
+//		if(size > MAX_SIZE){
+//			return 0xAFFE;
+//		}
+//		this->size = size;
+//		memcpy(buffer, data, size);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//
+//	void clearBuffer(){
+//		this->size = 0;
+//		for(size_t i = 0; i<MAX_SIZE; i++){
+//			buffer[i] = 0;
+//		}
+//	}
+//
+//	void getBuffer(const uint8_t** ptr, size_t* size){
+//		if(size != nullptr){
+//			*size = this->size;
+//		}
+//		if(ptr != nullptr){
+//			*ptr = buffer;
+//		}
+//	}
+//};
+//
+//
+//class MessageQueueMockBase: public MessageQueueIF {
+//public:
+//	MessageQueueId_t myQueueId = 0;
+//	bool defaultDestSet = false;
+//	bool messageSent = false;
+//
+//
+//
+//	bool wasMessageSent() {
+//		bool tempMessageSent = messageSent;
+//		messageSent = false;
+//		return tempMessageSent;
+//	}
+//
+//	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	};
+//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
+//			MessageQueueId_t *receivedFrom) {
+//		(*message) = lastMessage;
+//		lastMessage.clear();
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
+//		(*message) = lastMessage;
+//		lastMessage.clear();
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t flush(uint32_t* count) {
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual MessageQueueId_t getLastPartner() const {
+//		return tconst::testQueueId;
+//	}
+//	virtual MessageQueueId_t getId() const {
+//		return tconst::testQueueId;
+//	}
+//	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+//			MessageQueueMessage* message, MessageQueueId_t sentFrom,
+//			bool ignoreFault = false ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+//			MessageQueueMessage* message, bool ignoreFault = false ) override {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
+//			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
+//		messageSent = true;
+//		lastMessage = (*message);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	}
+//	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+//		myQueueId = defaultDestination;
+//		defaultDestSet = true;
+//	}
+//
+//	virtual MessageQueueId_t getDefaultDestination() const {
+//		return myQueueId;
+//	}
+//	virtual bool isDefaultDestinationSet() const {
+//		return defaultDestSet;
+//	}
+//private:
+//	MessageQueueMessage lastMessage;
+//
+//};
+//
+//
+//#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 07d6bc1f..8b82d407 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,6 +1,6 @@
 #include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 #include <cstring>
 
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index b0ec0abb..914188cb 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/container/ArrayList.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 /**
  * @brief 	Array List test
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index ac0900c8..3775f424 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -3,8 +3,8 @@
 #include <fsfw/container/FIFO.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
 	INFO("Fifo Tests");
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 5d1d5817..737932e3 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,8 +1,9 @@
+#include "../../core/CatchDefinitions.h"
+
 #include <fsfw/container/FixedArrayList.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
 
 
 TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index 04656525..079062f0 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/container/FixedMap.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 template class FixedMap<unsigned int, unsigned short>;
 
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index 953cb5a8..95194cb5 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/container/FixedOrderedMultimap.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
 	INFO("FixedOrderedMultimap Tests");
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index aa8e7375..5edbb9d2 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,45 @@
-#include <fsfw/container/PlacementFactory.h>
-#include <fsfw/storagemanager/LocalPool.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/container/ArrayList.h>
-
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-
-TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-	INFO("PlacementFactory Tests");
-
-	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-	const uint16_t n_elements[3] = {1, 1, 1};
-	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-	PlacementFactory factory(&storagePool);
-
-	SECTION("Pool overload"){
-		store_address_t address;
-		uint8_t* ptr = nullptr;
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-		REQUIRE(list2 == nullptr);
-	}
-
-	SECTION("Test generate and destroy"){
-		uint64_t* number = factory.generate<uint64_t>(32000);
-		REQUIRE(number != nullptr);
-		REQUIRE(*number == 32000);
-		store_address_t address;
-		uint8_t* ptr = nullptr;
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-		uint64_t* number2 = factory.generate<uint64_t>(12345);
-		REQUIRE(number2 == nullptr);
-		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-
-		//Check that PlacementFactory checks for nullptr
-		ptr = nullptr;
-		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-	}
-}
+//#include <fsfw/container/PlacementFactory.h>
+//#include <fsfw/storagemanager/LocalPool.h>
+//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+//#include <fsfw/container/ArrayList.h>
+//
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//
+//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+//	INFO("PlacementFactory Tests");
+//
+//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+//	const uint16_t n_elements[3] = {1, 1, 1};
+//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
+//	PlacementFactory factory(&storagePool);
+//
+//	SECTION("Pool overload"){
+//		store_address_t address;
+//		uint8_t* ptr = nullptr;
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+//		REQUIRE(list2 == nullptr);
+//	}
+//
+//	SECTION("Test generate and destroy"){
+//		uint64_t* number = factory.generate<uint64_t>(32000);
+//		REQUIRE(number != nullptr);
+//		REQUIRE(*number == 32000);
+//		store_address_t address;
+//		uint8_t* ptr = nullptr;
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+//		uint64_t* number2 = factory.generate<uint64_t>(12345);
+//		REQUIRE(number2 == nullptr);
+//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+//
+//		//Check that PlacementFactory checks for nullptr
+//		ptr = nullptr;
+//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+//	}
+//}
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 39c1ba61..9919ed84 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/serialize/SerialBufferAdapter.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
 
 
 static bool test_value_bool = true;
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 932b62ab..0a09e430 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,8 +1,8 @@
 #include <fsfw/globalfunctions/arrayprinter.h>
 
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <fsfw/unittest/tests/serialize/TestSerialLinkedPacket.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
+#include "TestSerialLinkedPacket.h"
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 7ac7b796..4c9ba181 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -2,7 +2,7 @@
 
 #include "catch.hpp"
 #include <array>
-#include "core/CatchDefinitions.h"
+#include "../../core/CatchDefinitions.h"
 
 static bool test_value_bool = true;
 static uint8_t tv_uint8   {5};
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7685afb3..7bd0dee2 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,161 @@
-#include <fsfw/storagemanager/LocalPool.h>
-#include <fsfw/unittest/catch2/catch.hpp>
-#include <fsfw/unittest/core/CatchDefinitions.h>
-#include <array>
-
-TEST_CASE( "New Accessor" , "[NewAccessor]") {
-	uint16_t numberOfElements[1] = {1};
-	uint16_t sizeofElements[1] = {10};
-	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-	std::array<uint8_t, 20> testDataArray;
-	std::array<uint8_t, 20> receptionArray;
-	store_address_t testStoreId;
-	ReturnValue_t result = retval::CATCH_FAILED;
-
-	for(size_t i = 0; i < testDataArray.size(); i++) {
-		testDataArray[i] = i;
-	}
-	size_t size = 10;
-
-	SECTION ("Simple tests getter functions") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		auto resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		CHECK(resultPair.second.getId() == testStoreId);
-		CHECK(resultPair.second.size() == 10);
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-
-		std::copy(resultPair.second.data(), resultPair.second.data() +
-				resultPair.second.size(), receptionArray.data());
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-
-		{
-			auto resultPairLoc = SimplePool.getData(testStoreId);
-			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-			// data should be deleted when accessor goes out of scope.
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			ConstStorageAccessor constAccessor(testStoreId);
-			result = SimplePool.getData(testStoreId, constAccessor);
-			REQUIRE(result == retval::CATCH_OK);
-			constAccessor.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			// likewise, data should be deleted when accessor gets out of scope.
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		{
-			resultPair = SimplePool.getData(testStoreId);
-			REQUIRE(resultPair.first == retval::CATCH_OK);
-			resultPair.second.release();
-			// now data should not be deleted anymore
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		for(size_t i = 0; i < size; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-	}
-
-
-	SECTION("Simple tests modify functions") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			StorageAccessor accessor(testStoreId);
-			result = SimplePool.modifyData(testStoreId, accessor);
-			REQUIRE(result == retval::CATCH_OK);
-			CHECK(accessor.getId() == testStoreId);
-			CHECK(accessor.size() == 10);
-			accessor.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			std::copy(accessor.data(), accessor.data() +
-					accessor.size(), receptionArray.data());
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			// data should be deleted when accessor goes out of scope
-		}
-		auto resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-			CHECK(resultPairLoc.second.getId() == testStoreId);
-			CHECK(resultPairLoc.second.size() == 10);
-			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-					resultPairLoc.second.size(), receptionArray.data());
-			for(size_t i = 0; i < size; i++) {
-				CHECK(receptionArray[i] == i );
-			}
-			resultPairLoc.second.release();
-			// data should not be deleted when accessor goes out of scope
-		}
-		resultPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-	}
-
-
-	SECTION("Write tests") {
-		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-		REQUIRE(result == retval::CATCH_OK);
-		{
-			auto resultPair = SimplePool.modifyData(testStoreId);
-			REQUIRE(resultPair.first == retval::CATCH_OK);
-			testDataArray[9] = 42;
-			resultPair.second.write(testDataArray.data(), 10, 0);
-			// now data should not be deleted
-			resultPair.second.release();
-		}
-		auto resultConstPair = SimplePool.getData(testStoreId);
-		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-
-		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-		for(size_t i = 0; i < size-1; i++) {
-			CHECK(receptionArray[i] == i );
-		}
-		CHECK(receptionArray[9] == 42 );
-
-		auto resultPair = SimplePool.modifyData(testStoreId);
-		REQUIRE(resultPair.first == retval::CATCH_OK);
-		result = resultPair.second.write(testDataArray.data(), 20, 0);
-		REQUIRE(result == retval::CATCH_FAILED);
-		result = resultPair.second.write(testDataArray.data(), 10, 5);
-		REQUIRE(result == retval::CATCH_FAILED);
-
-		memset(testDataArray.data(), 42, 5);
-		result = resultPair.second.write(testDataArray.data(), 5, 5);
-		REQUIRE(result == retval::CATCH_OK);
-		resultConstPair = SimplePool.getData(testStoreId);
-		resultPair.second.getDataCopy(receptionArray.data(), 20);
-		for(size_t i = 5; i < 10; i++) {
-			CHECK(receptionArray[i] == 42 );
-		}
-
-	}
-}
+//#include <fsfw/storagemanager/LocalPool.h>
+//#include <catch2/catch.hpp>
+//#include "../../core/CatchDefinitions.h"
+//#include <array>
+//
+//TEST_CASE( "New Accessor" , "[NewAccessor]") {
+//	uint16_t numberOfElements[1] = {1};
+//	uint16_t sizeofElements[1] = {10};
+//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
+//	std::array<uint8_t, 20> testDataArray;
+//	std::array<uint8_t, 20> receptionArray;
+//	store_address_t testStoreId;
+//	ReturnValue_t result = retval::CATCH_FAILED;
+//
+//	for(size_t i = 0; i < testDataArray.size(); i++) {
+//		testDataArray[i] = i;
+//	}
+//	size_t size = 10;
+//
+//	SECTION ("Simple tests getter functions") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		auto resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		CHECK(resultPair.second.getId() == testStoreId);
+//		CHECK(resultPair.second.size() == 10);
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//
+//		std::copy(resultPair.second.data(), resultPair.second.data() +
+//				resultPair.second.size(), receptionArray.data());
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//
+//		{
+//			auto resultPairLoc = SimplePool.getData(testStoreId);
+//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+//			// data should be deleted when accessor goes out of scope.
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			ConstStorageAccessor constAccessor(testStoreId);
+//			result = SimplePool.getData(testStoreId, constAccessor);
+//			REQUIRE(result == retval::CATCH_OK);
+//			constAccessor.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			// likewise, data should be deleted when accessor gets out of scope.
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		{
+//			resultPair = SimplePool.getData(testStoreId);
+//			REQUIRE(resultPair.first == retval::CATCH_OK);
+//			resultPair.second.release();
+//			// now data should not be deleted anymore
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		for(size_t i = 0; i < size; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//	}
+//
+//
+//	SECTION("Simple tests modify functions") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			StorageAccessor accessor(testStoreId);
+//			result = SimplePool.modifyData(testStoreId, accessor);
+//			REQUIRE(result == retval::CATCH_OK);
+//			CHECK(accessor.getId() == testStoreId);
+//			CHECK(accessor.size() == 10);
+//			accessor.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			std::copy(accessor.data(), accessor.data() +
+//					accessor.size(), receptionArray.data());
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			// data should be deleted when accessor goes out of scope
+//		}
+//		auto resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+//
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+//			CHECK(resultPairLoc.second.getId() == testStoreId);
+//			CHECK(resultPairLoc.second.size() == 10);
+//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+//					resultPairLoc.second.size(), receptionArray.data());
+//			for(size_t i = 0; i < size; i++) {
+//				CHECK(receptionArray[i] == i );
+//			}
+//			resultPairLoc.second.release();
+//			// data should not be deleted when accessor goes out of scope
+//		}
+//		resultPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//	}
+//
+//
+//	SECTION("Write tests") {
+//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+//		REQUIRE(result == retval::CATCH_OK);
+//		{
+//			auto resultPair = SimplePool.modifyData(testStoreId);
+//			REQUIRE(resultPair.first == retval::CATCH_OK);
+//			testDataArray[9] = 42;
+//			resultPair.second.write(testDataArray.data(), 10, 0);
+//			// now data should not be deleted
+//			resultPair.second.release();
+//		}
+//		auto resultConstPair = SimplePool.getData(testStoreId);
+//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+//
+//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+//		for(size_t i = 0; i < size-1; i++) {
+//			CHECK(receptionArray[i] == i );
+//		}
+//		CHECK(receptionArray[9] == 42 );
+//
+//		auto resultPair = SimplePool.modifyData(testStoreId);
+//		REQUIRE(resultPair.first == retval::CATCH_OK);
+//		result = resultPair.second.write(testDataArray.data(), 20, 0);
+//		REQUIRE(result == retval::CATCH_FAILED);
+//		result = resultPair.second.write(testDataArray.data(), 10, 5);
+//		REQUIRE(result == retval::CATCH_FAILED);
+//
+//		memset(testDataArray.data(), 42, 5);
+//		result = resultPair.second.write(testDataArray.data(), 5, 5);
+//		REQUIRE(result == retval::CATCH_OK);
+//		resultConstPair = SimplePool.getData(testStoreId);
+//		resultPair.second.getDataCopy(receptionArray.data(), 20);
+//		for(size_t i = 5; i < 10; i++) {
+//			CHECK(receptionArray[i] == 42 );
+//		}
+//
+//	}
+//}

From a9b48749048c128e128ee77c4fc59e0deb68d871 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 28 Oct 2020 22:49:19 +0100
Subject: [PATCH 0942/1292] new defines added

---
 unittest/config/TestsConfig.h | 2 +-
 unittest/core/CatchRunner.cpp | 4 ++++
 unittest/core/CatchSetup.cpp  | 1 +
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/unittest/config/TestsConfig.h b/unittest/config/TestsConfig.h
index 7bf667f7..cd967fa7 100644
--- a/unittest/config/TestsConfig.h
+++ b/unittest/config/TestsConfig.h
@@ -2,7 +2,7 @@
 #define FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
 
 
-
+#define CUSTOM_UNITTEST_RUNNER 0
 
 
 #endif /* FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_ */
diff --git a/unittest/core/CatchRunner.cpp b/unittest/core/CatchRunner.cpp
index e15c8b2a..35c53cd4 100644
--- a/unittest/core/CatchRunner.cpp
+++ b/unittest/core/CatchRunner.cpp
@@ -11,6 +11,8 @@
 #define CATCH_CONFIG_RUNNER
 #include <catch2/catch.hpp>
 
+#if CUSTOM_UNITTEST_RUNNER == 0
+
 extern int customSetup();
 
 int main( int argc, char* argv[] ) {
@@ -23,5 +25,7 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
+#endif
+
 
 #endif
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index ca5c456d..a623fb77 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+
 #include "../config/cdatapool/dataPoolInit.h"
 #include "../config/objects/Factory.h"
 

From a38c3e5005eb96ea7dd3be1e50896f9e1fd5329f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 11:47:03 +0100
Subject: [PATCH 0943/1292] config folder renamed

---
 unittest/config/cdatapool/dataPoolInit.cpp    | 48 -------------------
 unittest/config/cdatapool/dataPoolInit.h      | 29 -----------
 unittest/config/events/translateEvents.cpp    | 20 --------
 unittest/config/events/translateEvents.h      | 16 -------
 unittest/config/objects/systemObjectList.h    | 30 ------------
 .../PollingSequenceFactory.cpp                | 31 ------------
 unittest/config/returnvalues/classIds.h       | 28 -----------
 unittest/config/tmtc/PusIds.hpp               | 29 -----------
 unittest/config/tmtc/subsystemIdRanges.h      | 34 -------------
 unittest/config/tmtc/tmTcSize.h               | 10 ----
 unittest/{config => testcfg}/FSFWConfig.h     |  0
 unittest/{config => testcfg}/TestsConfig.h    |  0
 unittest/testcfg/cdatapool/dataPoolInit.cpp   |  5 ++
 unittest/testcfg/cdatapool/dataPoolInit.h     | 17 +++++++
 .../devices/logicalAddresses.cpp              |  0
 .../devices/logicalAddresses.h                |  0
 .../devices/powerSwitcherList.cpp             |  0
 .../devices/powerSwitcherList.h               |  0
 unittest/testcfg/events/subsystemIdRanges.h   | 18 +++++++
 .../ipc/MissionMessageTypes.cpp               |  2 +-
 .../ipc/MissionMessageTypes.h                 |  0
 .../{config => testcfg}/objects/Factory.cpp   |  0
 .../{config => testcfg}/objects/Factory.h     |  0
 unittest/testcfg/objects/systemObjectList.h   | 16 +++++++
 .../objects/translateObjects.cpp              |  0
 .../objects/translateObjects.h                |  0
 .../PollingSequenceFactory.cpp                | 23 +++++++++
 .../pollingsequence/PollingSequenceFactory.h  | 13 ++---
 unittest/testcfg/returnvalues/classIds.h      | 16 +++++++
 .../{config/config.mk => testcfg/testcfg.mk}  |  0
 unittest/{config => testcfg}/tmtc/apid.h      |  9 ++--
 unittest/{config => testcfg}/tmtc/pusIds.h    |  6 ++-
 unittest/{config => testcfg}/version.h        |  0
 33 files changed, 111 insertions(+), 289 deletions(-)
 delete mode 100644 unittest/config/cdatapool/dataPoolInit.cpp
 delete mode 100644 unittest/config/cdatapool/dataPoolInit.h
 delete mode 100644 unittest/config/events/translateEvents.cpp
 delete mode 100644 unittest/config/events/translateEvents.h
 delete mode 100644 unittest/config/objects/systemObjectList.h
 delete mode 100644 unittest/config/pollingsequence/PollingSequenceFactory.cpp
 delete mode 100644 unittest/config/returnvalues/classIds.h
 delete mode 100644 unittest/config/tmtc/PusIds.hpp
 delete mode 100644 unittest/config/tmtc/subsystemIdRanges.h
 delete mode 100644 unittest/config/tmtc/tmTcSize.h
 rename unittest/{config => testcfg}/FSFWConfig.h (100%)
 rename unittest/{config => testcfg}/TestsConfig.h (100%)
 create mode 100644 unittest/testcfg/cdatapool/dataPoolInit.cpp
 create mode 100644 unittest/testcfg/cdatapool/dataPoolInit.h
 rename unittest/{config => testcfg}/devices/logicalAddresses.cpp (100%)
 rename unittest/{config => testcfg}/devices/logicalAddresses.h (100%)
 rename unittest/{config => testcfg}/devices/powerSwitcherList.cpp (100%)
 rename unittest/{config => testcfg}/devices/powerSwitcherList.h (100%)
 create mode 100644 unittest/testcfg/events/subsystemIdRanges.h
 rename unittest/{config => testcfg}/ipc/MissionMessageTypes.cpp (80%)
 rename unittest/{config => testcfg}/ipc/MissionMessageTypes.h (100%)
 rename unittest/{config => testcfg}/objects/Factory.cpp (100%)
 rename unittest/{config => testcfg}/objects/Factory.h (100%)
 create mode 100644 unittest/testcfg/objects/systemObjectList.h
 rename unittest/{config => testcfg}/objects/translateObjects.cpp (100%)
 rename unittest/{config => testcfg}/objects/translateObjects.h (100%)
 create mode 100644 unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
 rename unittest/{config => testcfg}/pollingsequence/PollingSequenceFactory.h (74%)
 create mode 100644 unittest/testcfg/returnvalues/classIds.h
 rename unittest/{config/config.mk => testcfg/testcfg.mk} (100%)
 rename unittest/{config => testcfg}/tmtc/apid.h (61%)
 rename unittest/{config => testcfg}/tmtc/pusIds.h (86%)
 rename unittest/{config => testcfg}/version.h (100%)

diff --git a/unittest/config/cdatapool/dataPoolInit.cpp b/unittest/config/cdatapool/dataPoolInit.cpp
deleted file mode 100644
index f24d6cc5..00000000
--- a/unittest/config/cdatapool/dataPoolInit.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "dataPoolInit.h"
-
-void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
-	uint8_t UINT8T_INIT[1] = {0};
-	uint16_t UINT16T_INIT[1] = {0};
-	uint32_t UINT32T_INIT[1] = {0};
-	float FLOAT_INIT[2] = {0.0, 0.0};
-	/* FSFW */
-	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-
-	/* TEST */
-	poolMap->emplace(datapool::TEST_UINT8,
-			new PoolEntry<uint8_t>(UINT8T_INIT,1));
-	poolMap->emplace(datapool::TEST_UINT16,
-			new PoolEntry<uint16_t>(UINT16T_INIT,1));
-	poolMap->emplace(datapool::TEST_UINT32,
-			new PoolEntry<uint32_t>(UINT32T_INIT,1));
-	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
-			new PoolEntry<float>(FLOAT_INIT,2));
-
-	// With new initializer list feature and boolean entries.
-
-//	/* FSFW */
-//	poolMap->emplace(datapool::INTERNAL_ERROR_STORE_FULL,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::INTERNAL_ERROR_MISSED_LIVE_TM,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::INTERNAL_ERROR_FULL_MSG_QUEUES,
-//			new PoolEntry<uint32_t>({0},1));
-//
-//	/* TEST */
-//	poolMap->emplace(datapool::TEST_BOOLEAN,
-//			new PoolEntry<bool>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT8,
-//			new PoolEntry<uint8_t>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT16,
-//			new PoolEntry<uint16_t>({0},1));
-//	poolMap->emplace(datapool::TEST_UINT32,
-//			new PoolEntry<uint32_t>({0},1));
-//	poolMap->emplace(datapool::TEST_FLOAT_VECTOR,
-//			new PoolEntry<float>({0, 0},2));
-
-}
diff --git a/unittest/config/cdatapool/dataPoolInit.h b/unittest/config/cdatapool/dataPoolInit.h
deleted file mode 100644
index 6fd32371..00000000
--- a/unittest/config/cdatapool/dataPoolInit.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
-#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
-
-#include <fsfw/datapoolglob/GlobalDataPool.h>
-#include <fsfw/datapool/PoolEntryIF.h>
-#include <map>
-#include <cstdint>
-
-
-namespace datapool {
-	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
-
-	enum datapoolvariables {
-		NO_PARAMETER = 0,
-
-		/** [EXPORT] : [GROUP] FSFW */
-		INTERNAL_ERROR_STORE_FULL = 0xEE000001, 	 //!< [EXPORT] : [NAME] Internal Error Store Entry [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		INTERNAL_ERROR_MISSED_LIVE_TM = 0xEE000001,  //!< [EXPORT] : [NAME] Internal Error Missed Live Tm [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		INTERNAL_ERROR_FULL_MSG_QUEUES = 0xEE000001, //!< [EXPORT] : [NAME] Internal Error Full Msg Queue [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-
-		/** [EXPORT] : [GROUP] TEST */
-		TEST_BOOLEAN = 0x01010102, 				//!< [EXPORT] : [NAME] Test Boolean [UNIT] (-) [SIZE] 1 [TYPE] bool
-		TEST_UINT8 = 0x02020204,				//!< [EXPORT] : [NAME] Test Byte [UNIT] (-) [SIZE] 1 [TYPE] uint8_t
-		TEST_UINT16 = 0x03030306,				//!< [EXPORT] : [NAME] Test UINT16 [UNIT] (-) [SIZE] 1 [TYPE] uint16_t
-		TEST_UINT32 = 0x04040408,				//!< [EXPORT] : [NAME] Test UINT32 [UNIT] (-) [SIZE] 1 [TYPE] uint32_t
-		TEST_FLOAT_VECTOR = 0x05050510,			//!< [EXPORT] : [NAME] Test Float [UNIT] (-) [SIZE] 2 [TYPE] float
-	};
-}
-#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/events/translateEvents.cpp b/unittest/config/events/translateEvents.cpp
deleted file mode 100644
index bfcbe2bc..00000000
--- a/unittest/config/events/translateEvents.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * @brief    Auto-generated event translation file. Contains 80 translations.
- * Generated on: 2020-05-02 20:13:41 
- */
-#include <fsfw/unittest/config/events/translateEvents.h>
-
-const char *TEST_EVENT_SERVICE_1_STRING = "TEST_EVENT_SERVICE_1";
-const char *TEST2_STRING = "TEST2";
-
-const char * translateEvents(Event event){
-	switch((event&0xFFFF)){
-		case 8000:
-			return TEST_EVENT_SERVICE_1_STRING;
-		case 9100:
-			return TEST2_STRING;
-		default:
-			return "UNKNOWN_EVENT";
-	}
-	return 0;
-}
diff --git a/unittest/config/events/translateEvents.h b/unittest/config/events/translateEvents.h
deleted file mode 100644
index 0e40ef8b..00000000
--- a/unittest/config/events/translateEvents.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * translateEvent.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
-#ifndef CONFIG_EVENTS_TRANSLATEEVENTS_H_
-#define CONFIG_EVENTS_TRANSLATEEVENTS_H_
-
-#include <fsfw/events/Event.h>
-
-const char * translateEvents(Event event);
-
-
-#endif /* CONFIG_EVENTS_TRANSLATEEVENTS_H_ */
diff --git a/unittest/config/objects/systemObjectList.h b/unittest/config/objects/systemObjectList.h
deleted file mode 100644
index 9793305e..00000000
--- a/unittest/config/objects/systemObjectList.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
-#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
-
-#include <cstdint>
-
-// The objects will be instantiated in the ID order
-namespace objects {
-	enum sourceObjects: uint32_t {
-		/* First Byte 0x50-0x52 reserved for PUS Services **/
-		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-		PUS_PACKET_DISTRIBUTOR = 0x50000200,
-		UDP_BRIDGE = 0x50000300,
-		UDP_POLLING_TASK = 0x50000400,
-
-		PUS_SERVICE_3 = 0x51000300,
-		PUS_SERVICE_6_MEM_MGMT = 0x51000500,
-		PUS_SERVICE_23 = 0x51002300,
-		PUS_SERVICE_201_HEALTH = 0x51020100,
-
-		PUS_TIME = 0x52000001,
-		PUS_FUNNEL = 0x52000002,
-
-		/* Test Task */
-		TEST_TASK = 0x42694269,
-		DUMMY_INTERFACE = 0xCAFECAFE,
-		DUMMY_HANDLER = 0x4400AFFE,
-	};
-}
-
-#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.cpp b/unittest/config/pollingsequence/PollingSequenceFactory.cpp
deleted file mode 100644
index dbe13add..00000000
--- a/unittest/config/pollingsequence/PollingSequenceFactory.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <PollingSequenceFactory.h>
-#include <systemObjectList.h>
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <fsfw/tasks/FixedTimeslotTaskIF.h>
-
-ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence)
-{
-	/* Length of a communication cycle */
-	uint32_t length = thisSequence->getPeriodMs();
-
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0,  DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.25, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.5,  DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::DUMMY_HANDLER,
-            length * 0.75, DeviceHandlerIF::GET_READ);
-
-	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		sif::error << "PollingSequence::initialize has errors!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
diff --git a/unittest/config/returnvalues/classIds.h b/unittest/config/returnvalues/classIds.h
deleted file mode 100644
index a024e3d7..00000000
--- a/unittest/config/returnvalues/classIds.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * classIds.h
- *
- *  Created on: 16.07.2018
- *      Author: mohr
- */
-
-#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
-#define CONFIG_RETURNVALUES_CLASSIDS_H_
-
-/**
- * Source IDs starts at 73 for now
- * Framework IDs for ReturnValues run from 0 to 56
- * and are located inside <fsfw/returnvalues/FwClassIds.h>
- */
-namespace CLASS_ID {
-enum {
-	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
-	RS232_CHANNEL, //!< RS232
-	I2C_CHANNEL, //!< I2C
-	SPI_CHANNEL, //!< SPI
-	GPS_HANDLER,  //!< GPS
-	PUS_SERVICE_3 //!< HKS
-};
-}
-
-
-#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/tmtc/PusIds.hpp b/unittest/config/tmtc/PusIds.hpp
deleted file mode 100644
index fd37c7f4..00000000
--- a/unittest/config/tmtc/PusIds.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * PusIds.hpp
- *
- *  Created on: 27.02.2019
- *      Author: jakob
- */
-
-#ifndef CONFIG_TMTC_PUSIDS_HPP_
-#define CONFIG_TMTC_PUSIDS_HPP_
-
-namespace PUS{
-enum Ids{
-	PUS_SERVICE_1 = 1,
-	PUS_SERVICE_2 = 2,
-	PUS_SERVICE_3 = 3,
-	PUS_SERVICE_5 = 5,
-	PUS_SERVICE_6 = 6,
-	PUS_SERVICE_8 = 8,
-	PUS_SERVICE_9 = 9,
-	PUS_SERVICE_17 = 17,
-	PUS_SERVICE_23 = 23,
-	PUS_SERVICE_200 = 200,
-	PUS_SERVICE_201 = 201,
-};
-};
-
-
-
-#endif /* CONFIG_TMTC_PUSIDS_HPP_ */
diff --git a/unittest/config/tmtc/subsystemIdRanges.h b/unittest/config/tmtc/subsystemIdRanges.h
deleted file mode 100644
index e32de74c..00000000
--- a/unittest/config/tmtc/subsystemIdRanges.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
-#define CONFIG_TMTC_SUBSYSTEMIDRANGES_H_
-
-#include <fsfw/events/fwSubsystemIdRanges.h>
-#include <cstdint>
-
-/**
- * These IDs are part of the ID for an event thrown by a subsystem.
- * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
- */
-namespace SUBSYSTEM_ID {
-enum: uint8_t {
-	SUBSYSTE_ID_START = FW_SUBSYSTEM_ID_RANGE,
-	/**
-	 * 80-105: PUS Services
-	 */
-	PUS_SERVICE_2 = 82,
-	PUS_SERVICE_3 = 83,
-	PUS_SERVICE_5 = 85,
-	PUS_SERVICE_6 = 86,
-	PUS_SERVICE_8 = 88,
-	PUS_SERVICE_23 = 91,
-	DUMMY_DEVICE = 100,
-	/**
-	 * 105-115: AOCS
-	 */
-	GPS_DEVICE = 105,
-
-	SPI_COM_IF = 128,
-	I2C_COM_IF = 138
-};
-}
-
-#endif /* CONFIG_TMTC_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/tmtc/tmTcSize.h b/unittest/config/tmtc/tmTcSize.h
deleted file mode 100644
index de7f4adc..00000000
--- a/unittest/config/tmtc/tmTcSize.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef CONFIG_TMTC_TMTCSIZE_H_
-#define CONFIG_TMTC_TMTCSIZE_H_
-
-#include <cstdint>
-
-namespace tmtcsize {
-static const uint32_t MAX_TM_PACKET = 50;
-}
-
-#endif /* CONFIG_TMTC_TMTCSIZE_H_ */
diff --git a/unittest/config/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
similarity index 100%
rename from unittest/config/FSFWConfig.h
rename to unittest/testcfg/FSFWConfig.h
diff --git a/unittest/config/TestsConfig.h b/unittest/testcfg/TestsConfig.h
similarity index 100%
rename from unittest/config/TestsConfig.h
rename to unittest/testcfg/TestsConfig.h
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.cpp b/unittest/testcfg/cdatapool/dataPoolInit.cpp
new file mode 100644
index 00000000..ad2dc4ef
--- /dev/null
+++ b/unittest/testcfg/cdatapool/dataPoolInit.cpp
@@ -0,0 +1,5 @@
+#include "dataPoolInit.h"
+
+void datapool::dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap) {
+
+}
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/testcfg/cdatapool/dataPoolInit.h
new file mode 100644
index 00000000..23a3d01f
--- /dev/null
+++ b/unittest/testcfg/cdatapool/dataPoolInit.h
@@ -0,0 +1,17 @@
+#ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+#define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
+
+#include <fsfw/datapoolglob/GlobalDataPool.h>
+#include <fsfw/datapool/PoolEntryIF.h>
+#include <map>
+#include <cstdint>
+
+
+namespace datapool {
+	void dataPoolInit(std::map<uint32_t, PoolEntryIF*> * poolMap);
+
+	enum datapoolvariables {
+		NO_PARAMETER = 0,
+	};
+}
+#endif /* CONFIG_CDATAPOOL_DATAPOOLINIT_H_ */
diff --git a/unittest/config/devices/logicalAddresses.cpp b/unittest/testcfg/devices/logicalAddresses.cpp
similarity index 100%
rename from unittest/config/devices/logicalAddresses.cpp
rename to unittest/testcfg/devices/logicalAddresses.cpp
diff --git a/unittest/config/devices/logicalAddresses.h b/unittest/testcfg/devices/logicalAddresses.h
similarity index 100%
rename from unittest/config/devices/logicalAddresses.h
rename to unittest/testcfg/devices/logicalAddresses.h
diff --git a/unittest/config/devices/powerSwitcherList.cpp b/unittest/testcfg/devices/powerSwitcherList.cpp
similarity index 100%
rename from unittest/config/devices/powerSwitcherList.cpp
rename to unittest/testcfg/devices/powerSwitcherList.cpp
diff --git a/unittest/config/devices/powerSwitcherList.h b/unittest/testcfg/devices/powerSwitcherList.h
similarity index 100%
rename from unittest/config/devices/powerSwitcherList.h
rename to unittest/testcfg/devices/powerSwitcherList.h
diff --git a/unittest/testcfg/events/subsystemIdRanges.h b/unittest/testcfg/events/subsystemIdRanges.h
new file mode 100644
index 00000000..24eee819
--- /dev/null
+++ b/unittest/testcfg/events/subsystemIdRanges.h
@@ -0,0 +1,18 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+#include <fsfw/events/fwSubsystemIdRanges.h>
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum: uint8_t {
+	SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
diff --git a/unittest/config/ipc/MissionMessageTypes.cpp b/unittest/testcfg/ipc/MissionMessageTypes.cpp
similarity index 80%
rename from unittest/config/ipc/MissionMessageTypes.cpp
rename to unittest/testcfg/ipc/MissionMessageTypes.cpp
index 304ca439..0ac8debe 100644
--- a/unittest/config/ipc/MissionMessageTypes.cpp
+++ b/unittest/testcfg/ipc/MissionMessageTypes.cpp
@@ -2,7 +2,7 @@
 #include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
-	switch((message->getCommand()>>8) & 0xff) {
+	switch(message->getMessageType()) {
 	default:
 		break;
 	}
diff --git a/unittest/config/ipc/MissionMessageTypes.h b/unittest/testcfg/ipc/MissionMessageTypes.h
similarity index 100%
rename from unittest/config/ipc/MissionMessageTypes.h
rename to unittest/testcfg/ipc/MissionMessageTypes.h
diff --git a/unittest/config/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
similarity index 100%
rename from unittest/config/objects/Factory.cpp
rename to unittest/testcfg/objects/Factory.cpp
diff --git a/unittest/config/objects/Factory.h b/unittest/testcfg/objects/Factory.h
similarity index 100%
rename from unittest/config/objects/Factory.h
rename to unittest/testcfg/objects/Factory.h
diff --git a/unittest/testcfg/objects/systemObjectList.h b/unittest/testcfg/objects/systemObjectList.h
new file mode 100644
index 00000000..0e034aff
--- /dev/null
+++ b/unittest/testcfg/objects/systemObjectList.h
@@ -0,0 +1,16 @@
+#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+#include <fsfw/objectmanager/frameworkObjects.h>
+
+// The objects will be instantiated in the ID order
+namespace objects {
+	enum sourceObjects: uint32_t {
+		/* All addresses between start and end are reserved for the FSFW */
+		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+		FSFW_CONFIG_RESERVED_END = TM_STORE
+	};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
diff --git a/unittest/config/objects/translateObjects.cpp b/unittest/testcfg/objects/translateObjects.cpp
similarity index 100%
rename from unittest/config/objects/translateObjects.cpp
rename to unittest/testcfg/objects/translateObjects.cpp
diff --git a/unittest/config/objects/translateObjects.h b/unittest/testcfg/objects/translateObjects.h
similarity index 100%
rename from unittest/config/objects/translateObjects.h
rename to unittest/testcfg/objects/translateObjects.h
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
new file mode 100644
index 00000000..f836a746
--- /dev/null
+++ b/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -0,0 +1,23 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+ReturnValue_t pst::pollingSequenceInitDefault(
+        FixedTimeslotTaskIF *thisSequence) {
+	/* Length of a communication cycle */
+	uint32_t length = thisSequence->getPeriodMs();
+
+	/* Add polling sequence table here */
+
+	if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
+		        << std::endl;
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+}
+
diff --git a/unittest/config/pollingsequence/PollingSequenceFactory.h b/unittest/testcfg/pollingsequence/PollingSequenceFactory.h
similarity index 74%
rename from unittest/config/pollingsequence/PollingSequenceFactory.h
rename to unittest/testcfg/pollingsequence/PollingSequenceFactory.h
index b6cc2f1e..c5d41b7d 100644
--- a/unittest/config/pollingsequence/PollingSequenceFactory.h
+++ b/unittest/testcfg/pollingsequence/PollingSequenceFactory.h
@@ -1,13 +1,14 @@
 #ifndef POLLINGSEQUENCEFACTORY_H_
 #define POLLINGSEQUENCEFACTORY_H_
+
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 class FixedTimeslotTaskIF;
 
 /**
- * All device handlers are scheduled by adding them into
- * Polling Sequence Tables (PST) to satisfy stricter timing requirements of
- * device communication, a device handler has four different communication steps:
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
  *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
  *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
  *   3. DeviceHandlerIF::SEND_READ -> Send read request
@@ -17,15 +18,15 @@ class FixedTimeslotTaskIF;
  * The task is created using the FixedTimeslotTaskIF,
  * which utilises the underlying Operating System Abstraction Layer (OSAL)
  *
- * @param thisSequence FixedTimeslotTaskIF * object is passed inside the
- * 					   Factory class when creating the PST
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating the PST
  * @return
  */
 namespace pst {
 
-/* 0.4 second period init*/
+/* Default PST */
 ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
 
+
 }
 
 #endif /* POLLINGSEQUENCEINIT_H_ */
diff --git a/unittest/testcfg/returnvalues/classIds.h b/unittest/testcfg/returnvalues/classIds.h
new file mode 100644
index 00000000..606cc60b
--- /dev/null
+++ b/unittest/testcfg/returnvalues/classIds.h
@@ -0,0 +1,16 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include <fsfw/returnvalues/FwClassIds.h>
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
diff --git a/unittest/config/config.mk b/unittest/testcfg/testcfg.mk
similarity index 100%
rename from unittest/config/config.mk
rename to unittest/testcfg/testcfg.mk
diff --git a/unittest/config/tmtc/apid.h b/unittest/testcfg/tmtc/apid.h
similarity index 61%
rename from unittest/config/tmtc/apid.h
rename to unittest/testcfg/tmtc/apid.h
index 77e55952..c0231bca 100644
--- a/unittest/config/tmtc/apid.h
+++ b/unittest/testcfg/tmtc/apid.h
@@ -1,18 +1,17 @@
 #ifndef CONFIG_TMTC_APID_H_
 #define CONFIG_TMTC_APID_H_
 
-#include <stdint.h>
+#include <cstdint>
 
 /**
  * Application Process Definition: entity, uniquely identified by an
  * application process ID (APID), capable of generating telemetry source
- * packets and receiving telecommand packets
+ * packets and receiving telecommand packets.
  *
- * SOURCE APID: 0x73 / 115 / s
- * APID is a 11 bit number
+ * Chose APID(s) for mission and define it here.
  */
 namespace apid {
-	static const uint16_t SOURCE_OBSW = 0x73;
+	static const uint16_t DEFAULT_APID = 0x00;
 }
 
 
diff --git a/unittest/config/tmtc/pusIds.h b/unittest/testcfg/tmtc/pusIds.h
similarity index 86%
rename from unittest/config/tmtc/pusIds.h
rename to unittest/testcfg/tmtc/pusIds.h
index a2dd7575..821a9982 100644
--- a/unittest/config/tmtc/pusIds.h
+++ b/unittest/testcfg/tmtc/pusIds.h
@@ -1,16 +1,18 @@
 #ifndef CONFIG_TMTC_PUSIDS_HPP_
 #define CONFIG_TMTC_PUSIDS_HPP_
 
+#include <cstdint>
+
 namespace pus {
-enum Ids{
+enum Ids: uint8_t {
 	PUS_SERVICE_1 = 1,
 	PUS_SERVICE_2 = 2,
 	PUS_SERVICE_3 = 3,
-	PUS_SERVICE_3_PSB = 3,
 	PUS_SERVICE_5 = 5,
 	PUS_SERVICE_6 = 6,
 	PUS_SERVICE_8 = 8,
 	PUS_SERVICE_9 = 9,
+	PUS_SERVICE_11 = 11,
 	PUS_SERVICE_17 = 17,
 	PUS_SERVICE_19 = 19,
 	PUS_SERVICE_20 = 20,
diff --git a/unittest/config/version.h b/unittest/testcfg/version.h
similarity index 100%
rename from unittest/config/version.h
rename to unittest/testcfg/version.h

From 29187fbc4badd33e7533c53b2aaa8032b73353e0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 11:59:50 +0100
Subject: [PATCH 0944/1292] some config adaptions

---
 defaultcfg/FSFWConfig.h        | 41 ----------------------------------
 defaultcfg/config/FSFWConfig.h |  8 ++++---
 defaultcfg/config/version.h    |  9 --------
 defaultcfg/version.h           | 11 ---------
 events/EventManager.cpp        |  3 ++-
 fsfw.mk                        |  2 ++
 unittest/testcfg/FSFWConfig.h  | 11 ++++++---
 unittest/testcfg/version.h     |  7 ------
 8 files changed, 17 insertions(+), 75 deletions(-)
 delete mode 100644 defaultcfg/FSFWConfig.h
 delete mode 100644 defaultcfg/config/version.h
 delete mode 100644 defaultcfg/version.h
 delete mode 100644 unittest/testcfg/version.h

diff --git a/defaultcfg/FSFWConfig.h b/defaultcfg/FSFWConfig.h
deleted file mode 100644
index 2001f306..00000000
--- a/defaultcfg/FSFWConfig.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef CONFIG_FSFWCONFIG_H_
-#define CONFIG_FSFWCONFIG_H_
-
-#include "version.h"
-
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
-#define FSFW_CPP_OSTREAM_ENABLED 	1
-
-//! Reduced printout to further decrese code size
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
-
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
-
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
-#ifdef DEBUG
-#define FSFW_DEBUG_OUTPUT 			1
-//! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
-#else
-#define FSFW_DEBUG_OUTPUT			0
-#endif
-
-//! When using the newlib nano library, C99 support for stdio facilities
-//! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
-
-
-#endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index cfe89864..f723f9d8 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -20,10 +20,12 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
-//! If -DDEBUG is supplied in the build defines, there will be
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
-#ifdef DEBUG
+//! and translateEvents (and their compiled source files)
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
diff --git a/defaultcfg/config/version.h b/defaultcfg/config/version.h
deleted file mode 100644
index 3c60317c..00000000
--- a/defaultcfg/config/version.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef CONFIG_VERSION_H_
-#define CONFIG_VERSION_H_
-
-/* OBSW versioning can be specified in this file */
-
-#define OBSW_VERSION      0
-#define OBSW_SUBVERSION   0
-
-#endif /* CONFIG_VERSION_H_ */
diff --git a/defaultcfg/version.h b/defaultcfg/version.h
deleted file mode 100644
index b3ef8318..00000000
--- a/defaultcfg/version.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef FSFW_DEFAULTCFG_VERSION_H_
-#define FSFW_DEFAULTCFG_VERSION_H_
-
-static const char* FSFW_VERSION_NAME = "fsfw";
-
-#define FSFW_VERSION 		0
-#define	FSFW_SUBVERSION 	0
-
-
-
-#endif /* FSFW_DEFAULTCFG_VERSION_H_ */
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 57bda13f..16ac289d 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,4 +1,5 @@
 #include "EventManager.h"
+#include <FSFWConfig.h>
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
@@ -38,7 +39,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef DEBUG
+#ifdef FSFW_OBJECTMANAGER_
 			printEvent(&message);
 #endif
 			notifyListeners(&message);
diff --git a/fsfw.mk b/fsfw.mk
index c5847554..1dd4f166 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -73,3 +73,5 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index bb285472..b1177b74 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,7 +1,7 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <fsfw/unittest/config/version.h>
+#include <FSFWVersion.h>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
@@ -11,16 +11,21 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Can be used to enable debugging printouts for developing the FSFW
+#define FSFW_DEBUGGING              0
+
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
 //! If -DDEBUG is supplied in the build defines, there will be
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
-#ifdef DEBUG
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
@@ -32,7 +37,7 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NEWLIB_NANO_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	1
 
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/testcfg/version.h b/unittest/testcfg/version.h
deleted file mode 100644
index f53345c1..00000000
--- a/unittest/testcfg/version.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef CONFIG_VERSION_H_
-#define CONFIG_VERSION_H_
-
-#define SW_VERSION      1
-#define SW_SUBVERSION   6
-
-#endif /* CONFIG_VERSION_H_ */

From 565fd63d0855e10fc29e46a7ab0f31a45e253ba8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 12:07:48 +0100
Subject: [PATCH 0945/1292] makefile moved

---
 defaultcfg/config/FSFWConfig.h             | 4 ++--
 unittest/testcfg/FSFWConfig.h              | 3 +++
 unittest/{ => testcfg}/Makefile-FSFW-Tests | 0
 3 files changed, 5 insertions(+), 2 deletions(-)
 rename unittest/{ => testcfg}/Makefile-FSFW-Tests (100%)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index f723f9d8..d72f2374 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -20,11 +20,11 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
-#define FSFW_OBJ_EVENT_TRANSLATION	0
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION	0
+
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index b1177b74..4fb224c1 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -20,6 +20,9 @@
 //! each CSB service !
 #define FSFW_CSB_FIFO_DEPTH			6
 
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 //! If -DDEBUG is supplied in the build defines, there will be
diff --git a/unittest/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
similarity index 100%
rename from unittest/Makefile-FSFW-Tests
rename to unittest/testcfg/Makefile-FSFW-Tests

From 176ca56e355405d4e9d81e503187e2f87d87f84f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:12:05 +0100
Subject: [PATCH 0946/1292] core changes taken over

---
 unittest/core/CatchDefinitions.cpp | 2 +-
 unittest/core/CatchDefinitions.h   | 4 +++-
 unittest/core/CatchSetup.cpp       | 4 ++--
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/core/CatchDefinitions.cpp
index 3f4614e8..0b66558a 100644
--- a/unittest/core/CatchDefinitions.cpp
+++ b/unittest/core/CatchDefinitions.cpp
@@ -1,5 +1,5 @@
+#include "CatchDefinitions.h"
 #include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
diff --git a/unittest/core/CatchDefinitions.h b/unittest/core/CatchDefinitions.h
index cdc025fa..366cda7e 100644
--- a/unittest/core/CatchDefinitions.h
+++ b/unittest/core/CatchDefinitions.h
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+#define FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
 
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
@@ -17,3 +18,4 @@ namespace tglob {
 	StorageManagerIF* getIpcStoreHandle();
 }
 
+#endif /* FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_ */
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index a623fb77..5749ecd1 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,7 +1,7 @@
 #include "CatchDefinitions.h"
 
-#include "../config/cdatapool/dataPoolInit.h"
-#include "../config/objects/Factory.h"
+#include <testcfg/cdatapool/dataPoolInit.h>
+#include <testcfg/objects/Factory.h>
 
 
 #ifdef GCOV

From 7970043cb5a138afe4259b9442034c501b327380 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:12:36 +0100
Subject: [PATCH 0947/1292] deleted some sutff

---
 unittest/README.md | 72 ----------------------------------------------
 1 file changed, 72 deletions(-)

diff --git a/unittest/README.md b/unittest/README.md
index 091dd3cb..e628d43e 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -7,67 +7,6 @@ The makefile with default settings creates the unit test binary which can be
 run in the terminal or in eclipse.
 
 ### Instructions
-Basic steps:
-
-1. Clone this branch
-   ```sh
-   git clone https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests.git
-   ```
-
-2. Inititate the framework submodule (need to only be done once)
-   ```sh
-   git submodule init
-   git submodule sync
-   git submodule update
-   ```
-   
-2. Run the makefile With
-
-   ```sh
-   make all -j<Number Of Processors>
-   ```
-   This will build the debug version of the unit tests.
-   The release version can be built with the target `release`
-
-4. Run the binary located in the \_bin folder in the terminal or in eclipse.
-
-   ```sh
-   _bin/<binaryName>.elf [--success]
-   ```
-   The success parameter is optional. Leaving it out ommits the success messages.
-
-5. To clear the binary, object and dependency folder, run
-
-   ```sh
-   make clean
-   ```
-
-Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities used by the UNIX pthread module are restricted, which will lead to permission errors when creating these tasks.
-
-To solve this issues, try following steps:
-
-1. Edit the /etc/security/limits.conf 
-   file and add following lines at the end (worked on Ubuntu 19.10):
-   ```sh
-   <username>   hard   rtprio  99
-   <username>   soft   rtprio  99
-   ```
-   Then restart the computer. <br>
-   The soft limit can also be set in the console with `ulimit -Sr` if the hard
-   limit has been increased,
-   but it is recommended to add it to the file as well for convenience.
-   If adding the second line is not desired for security reasons,
-   the soft limit needs to be set for each session. If using an IDE like eclipse 
-   in that case, the IDE needs to be started from the console after setting
-   the soft limit higher there.
-2. Run the shell script inside the linux folder (worked on Ubuntu 18.04)
-   ```sh
-   ./unlockRealtime
-   ```
-   This script executes the `setcap` command on bash and on the binaries.
-   It also increases the soft real time limit of the current shell instance
-   to the maximum. If running the script before executing the binary does
-   not help, try the following step.
    
 ### Eclipse CDT settings
 
@@ -108,14 +47,3 @@ For writing basics tests, the [assertion documentation](https://github.com/catch
 or the existing examples are a good guideliens.
 For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
 
-### Compile without test framework
-Alternatively, the unit tests can also be run internally without
-a framework. This can be used to perform unit tests on the real hardware.
-To do this, run
-```sh
-make -j<Number Of Processors> notestfw
-```
-This will instruct the makefile to exclude the test framework main.cpp
-and include our own. This will also create a binary which can be used
-outside the host machine (a Makefile adaptions might be neccessary
-if another OS than linux is required)

From 172fbd7e4840bcc2001fcf425684a552f2488ad1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:13:03 +0100
Subject: [PATCH 0948/1292] some changes taken over

---
 unittest/testcfg/devices/logicalAddresses.cpp  |  8 +-------
 unittest/testcfg/devices/powerSwitcherList.cpp |  8 +-------
 unittest/testcfg/devices/powerSwitcherList.h   | 10 ----------
 unittest/testcfg/ipc/MissionMessageTypes.cpp   |  3 ++-
 unittest/testcfg/objects/Factory.cpp           |  4 ++--
 5 files changed, 6 insertions(+), 27 deletions(-)

diff --git a/unittest/testcfg/devices/logicalAddresses.cpp b/unittest/testcfg/devices/logicalAddresses.cpp
index 15776275..c7ce314d 100644
--- a/unittest/testcfg/devices/logicalAddresses.cpp
+++ b/unittest/testcfg/devices/logicalAddresses.cpp
@@ -1,10 +1,4 @@
-/**
- * \file logicalAddresses.cpp
- *
- * \date 06.11.2019
- */
-
-#include <fsfw/unittest/config/devices/logicalAddresses.h>
+#include "logicalAddresses.h"
 
 
 
diff --git a/unittest/testcfg/devices/powerSwitcherList.cpp b/unittest/testcfg/devices/powerSwitcherList.cpp
index cb568522..343f78d0 100644
--- a/unittest/testcfg/devices/powerSwitcherList.cpp
+++ b/unittest/testcfg/devices/powerSwitcherList.cpp
@@ -1,10 +1,4 @@
-/**
- * @file switcherList.cpp
- *
- * @date 28.11.2019
- */
-
-#include <fsfw/unittest/config/devices/powerSwitcherList.h>
+#include "powerSwitcherList.h"
 
 
 
diff --git a/unittest/testcfg/devices/powerSwitcherList.h b/unittest/testcfg/devices/powerSwitcherList.h
index f5b0eb11..86ddea57 100644
--- a/unittest/testcfg/devices/powerSwitcherList.h
+++ b/unittest/testcfg/devices/powerSwitcherList.h
@@ -1,19 +1,9 @@
-/**
- * @file switcherList.h
- *
- * @date 28.11.2019
- */
-
 #ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
 #define CONFIG_DEVICES_POWERSWITCHERLIST_H_
 
 namespace switches {
 	/* Switches are uint8_t datatype and go from 0 to 255 */
 	enum switcherList {
-		PCDU,
-		GPS0,
-		GPS1,
-		DUMMY = 129
 	};
 
 }
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.cpp b/unittest/testcfg/ipc/MissionMessageTypes.cpp
index 0ac8debe..d68cb58c 100644
--- a/unittest/testcfg/ipc/MissionMessageTypes.cpp
+++ b/unittest/testcfg/ipc/MissionMessageTypes.cpp
@@ -1,5 +1,6 @@
+#include "MissionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessage.h>
-#include <fsfw/unittest/config/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
 	switch(message->getMessageType()) {
diff --git a/unittest/testcfg/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
index 612527c9..e05b7942 100644
--- a/unittest/testcfg/objects/Factory.cpp
+++ b/unittest/testcfg/objects/Factory.cpp
@@ -1,10 +1,10 @@
+#include "Factory.h"
+
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
 
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
-#include <fsfw/unittest/config/cdatapool/dataPoolInit.h>
-#include <fsfw/unittest/config/objects/Factory.h>
 
 /**
  * @brief Produces system objects.

From 4b2af9eaa6ce2c418cfb280d633772d870f0dc86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:15:08 +0100
Subject: [PATCH 0949/1292] static keyword removed

---
 FSFWVersion.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FSFWVersion.h b/FSFWVersion.h
index b3ef8318..dcb592dc 100644
--- a/FSFWVersion.h
+++ b/FSFWVersion.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DEFAULTCFG_VERSION_H_
 #define FSFW_DEFAULTCFG_VERSION_H_
 
-static const char* FSFW_VERSION_NAME = "fsfw";
+const char* const FSFW_VERSION_NAME = "fsfw";
 
 #define FSFW_VERSION 		0
 #define	FSFW_SUBVERSION 	0

From fb12045f23151e60c30359ee00c09bcef2b0b700 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 15:25:03 +0100
Subject: [PATCH 0950/1292] changes from master taken over

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d67e47d8..38821054 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1262,7 +1262,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (result == BUSY) {
 		    //so we can track misconfigurations
 			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::endl;
+					<< ": DHB::buildInternalCommand: Busy" << std::dec
+					<< std::endl;
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}

From 42e611899befd5992d639ab3a46b08f7c5785069 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:43:03 +0100
Subject: [PATCH 0951/1292] added timestamp size

---
 defaultcfg/config/FSFWConfig.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index d72f2374..b6255a2f 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -11,6 +11,10 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
+//! Default timestamp size. The default timestamp will be a seven byte CDC short
+//! timestamp.
+#define FSFW_MISSION_TIMESTAMP_SIZE 8
+
 //! Can be used to enable debugging printouts for developing the FSFW
 #define FSFW_DEBUGGING              0
 

From 3d2778fdf79eeb315ace8944fd8b555b35d550d3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:45:47 +0100
Subject: [PATCH 0952/1292] doc update

---
 action/HasActionsIF.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index a26ed588..886d0837 100644
--- a/action/HasActionsIF.h
+++ b/action/HasActionsIF.h
@@ -47,9 +47,10 @@ public:
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 	/**
 	 * Execute or initialize the execution of a certain function.
-	 * When used in conjunction with the ActionHelper class, returning
-	 * a return code which is not equal to RETURN_OK will trigger a step reply
-	 * with step 0.
+	 * 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;

From 0919d2c53231934748bcb581915993ed670f2e87 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 16:52:06 +0100
Subject: [PATCH 0953/1292] updates taken over

---
 action/ActionHelper.cpp       | 14 ++++++++++----
 action/ActionHelper.h         |  5 +++--
 action/ActionMessage.h        | 18 +++++++++++-------
 action/CommandsActionsIF.h    | 15 +++++++++------
 action/HasActionsIF.h         | 17 ++++++++++-------
 action/SimpleActionHelper.cpp |  7 ++++---
 action/SimpleActionHelper.h   | 20 +++++++++++++-------
 7 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index 8122885b..28557916 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -1,5 +1,6 @@
 #include "ActionHelper.h"
 #include "HasActionsIF.h"
+
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
@@ -65,6 +66,11 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
 	}
 	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
 	ipcStore->deleteData(dataAddress);
+	if(result == HasActionsIF::EXECUTION_FINISHED) {
+		CommandMessage reply;
+		ActionMessage::setCompletionReply(&reply, actionId, result);
+		queueToUse->sendMessage(commandedBy, &reply);
+	}
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		CommandMessage reply;
 		ActionMessage::setStepReply(&reply, actionId, 0, result);
@@ -101,8 +107,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
 	// another dedicated message.
 	ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-	// TODO: Service Implementation sucks at the moment
-	// TODO: why does it suck and why would someone need to hide the sender?
+    // 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);
 	}
@@ -140,8 +146,8 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
     // another dedicated message.
     ActionMessage::setDataReply(&reply, replyId, storeAddress);
 
-    // TODO: Service Implementation sucks at the moment
-    // TODO: why does it suck and why would someone need to hide the sender?
+    // 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);
     }
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 17ca3ebd..a91722f3 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -57,8 +57,9 @@ public:
 	 * @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);
+	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
 	 *
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 0a718aab..7a859de0 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -1,5 +1,5 @@
-#ifndef ACTIONMESSAGE_H_
-#define ACTIONMESSAGE_H_
+#ifndef FSFW_ACTION_ACTIONMESSAGE_H_
+#define FSFW_ACTION_ACTIONMESSAGE_H_
 
 #include "../ipc/CommandMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -18,15 +18,19 @@ public:
 	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 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 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 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);
 };
 
-#endif /* ACTIONMESSAGE_H_ */
+#endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */
diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h
index 3d04015d..491bfc70 100644
--- a/action/CommandsActionsIF.h
+++ b/action/CommandsActionsIF.h
@@ -1,5 +1,5 @@
-#ifndef COMMANDSACTIONSIF_H_
-#define COMMANDSACTIONSIF_H_
+#ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
+#define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
 #include "CommandActionHelper.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -24,11 +24,14 @@ public:
 	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 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 completionFailedReceived(ActionId_t actionId,
+			ReturnValue_t returnCode) = 0;
 };
 
 
-#endif /* COMMANDSACTIONSIF_H_ */
+#endif /* FSFW_ACTION_COMMANDSACTIONSIF_H_ */
diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h
index 886d0837..690f0369 100644
--- a/action/HasActionsIF.h
+++ b/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"
+
 /**
  * @brief
  * Interface for component which uses actions
@@ -47,14 +48,16 @@ public:
 	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!
+	 * 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_ */
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index d79a3c97..af57736c 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -1,16 +1,17 @@
 #include "HasActionsIF.h"
 #include "SimpleActionHelper.h"
+
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
 		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander(
-				0), lastAction(0), stepCount(0) {
+		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.
+	// 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) {
diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h
index 1329b5fb..1f35d9fd 100644
--- a/action/SimpleActionHelper.h
+++ b/action/SimpleActionHelper.h
@@ -1,8 +1,13 @@
-#ifndef SIMPLEACTIONHELPER_H_
-#define SIMPLEACTIONHELPER_H_
+#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
+#define FSFW_ACTION_SIMPLEACTIONHELPER_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);
@@ -12,13 +17,14 @@ public:
 	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;
+	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
+	ActionId_t lastAction = 0;
+	uint8_t stepCount = 0;
 };
 
 #endif /* SIMPLEACTIONHELPER_H_ */

From 3fc206801153370773adbabd7b9260b8b13d1c23 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:09:16 +0100
Subject: [PATCH 0954/1292] fsfwconfig update

---
 defaultcfg/config/FSFWConfig.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index b6255a2f..ea724a64 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -2,6 +2,7 @@
 #define CONFIG_FSFWCONFIG_H_
 
 #include <FSFWVersion.h>
+#include <cstddef>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
@@ -11,8 +12,8 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
-//! Default timestamp size. The default timestamp will be a seven byte CDC short
-//! timestamp.
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
 #define FSFW_MISSION_TIMESTAMP_SIZE 8
 
 //! Can be used to enable debugging printouts for developing the FSFW
@@ -43,5 +44,11 @@
 //! will not be provided. This define should be set to 1 if this is the case.
 #define FSFW_NO_C99_IO 	1
 
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 777457482b8ea3bb5c78e9b86c5c4e06ed1d08ee Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:21:51 +0100
Subject: [PATCH 0955/1292] fixes for internal unittest

---
 events/EventManager.cpp                             |  9 ++++++---
 unittest/internal/InternalUnitTester.cpp            | 13 +++++++------
 unittest/internal/InternalUnitTester.h              |  4 ++--
 unittest/internal/internal.mk                       |  3 +++
 unittest/internal/osal/IntTestMq.cpp                |  4 ++--
 unittest/internal/osal/IntTestMutex.cpp             |  3 ++-
 unittest/internal/osal/IntTestSemaphore.cpp         |  3 ++-
 .../internal/serialize/IntTestSerialization.cpp     |  2 +-
 8 files changed, 25 insertions(+), 16 deletions(-)
 create mode 100644 unittest/internal/internal.mk

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 16ac289d..acc17b03 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -11,9 +11,12 @@
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
 // This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        {240, sizeof(EventMatchTree::Node)},
-        {120, sizeof(EventIdRangeMatcher)},
-        {120, sizeof(ReporterRangeMatcher)}
+        {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
+        		sizeof(EventMatchTree::Node)},
+        {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS,
+        		sizeof(EventIdRangeMatcher)},
+        {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS,
+        		sizeof(ReporterRangeMatcher)}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 7b72d645..503a71ec 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -1,9 +1,10 @@
-#include <unittest/internal/InternalUnitTester.h>
-#include <unittest/internal/IntTestMq.h>
-#include <unittest/internal/IntTestSemaphore.h>
-#include <unittest/internal/IntTestSerialization.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <unittest/internal/IntTestMutex.h>
+#include "InternalUnitTester.h"
+#include "UnittDefinitions.h"
+
+#include "osal/IntTestMq.h"
+#include "osal/IntTestSemaphore.h"
+#include "osal/IntTestMutex.h"
+#include "serialize/IntTestSerialization.h"
 
 #include <cstdlib>
 
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index b61c8bfe..b301b923 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
-#include <unittest/internal/UnittDefinitions.h>
+#include "UnittDefinitions.h"
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 /**
@@ -22,7 +22,7 @@ public:
 	 * Some function which calls all other tests
 	 * @return
 	 */
-	ReturnValue_t performTests();
+	virtual ReturnValue_t performTests();
 };
 
 
diff --git a/unittest/internal/internal.mk b/unittest/internal/internal.mk
new file mode 100644
index 00000000..799fd796
--- /dev/null
+++ b/unittest/internal/internal.mk
@@ -0,0 +1,3 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/osal/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/serialize/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
\ No newline at end of file
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 265aa62a..63016374 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,7 +1,7 @@
 #include <fsfw/ipc/MessageQueueIF.h>
 #include <fsfw/ipc/QueueFactory.h>
-#include <unittest/internal/IntTestMq.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/unittest/internal/osal/IntTestMq.h>
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index bf0b827d..3fd668df 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,4 +1,5 @@
-#include <unittest/internal/IntTestMutex.h>
+#include "IntTestMutex.h"
+
 #include <fsfw/ipc/MutexFactory.h>
 #include <unittest/internal/UnittDefinitions.h>
 
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 176db4de..534a6a6d 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,8 +1,9 @@
+#include "IntTestSemaphore.h"
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <unittest/internal/UnittDefinitions.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/timemanager/Stopwatch.h>
-#include <unittest/internal/IntTestSemaphore.h>
+
 
 void testsemaph::testBinSemaph() {
 	std::string id = "[BinSemaphore]";
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 2452ac6d..3f231a41 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,4 +1,4 @@
-#include <unittest/internal/IntTestSerialization.h>
+#include "IntTestSerialization.h"
 #include <fsfw/serialize/SerializeElement.h>
 #include <fsfw/serialize/SerialBufferAdapter.h>
 #include <unittest/internal/UnittDefinitions.h>

From 641da2aa2184edeab2b3f282615c8ac27b6eae4b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:33:22 +0100
Subject: [PATCH 0956/1292] config make update

---
 defaultcfg/config.mk        | 17 -----------------
 defaultcfg/config/config.mk | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 17 deletions(-)
 delete mode 100644 defaultcfg/config.mk
 create mode 100644 defaultcfg/config/config.mk

diff --git a/defaultcfg/config.mk b/defaultcfg/config.mk
deleted file mode 100644
index fcf3b799..00000000
--- a/defaultcfg/config.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/config/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/events/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/tmtc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/config/devices/*.cpp)
-
-INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/config/
-INCLUDES += $(CURRENTPATH)/config/objects
-INCLUDES += $(CURRENTPATH)/config/returnvalues
-INCLUDES += $(CURRENTPATH)/config/tmtc
-INCLUDES += $(CURRENTPATH)/config/events
-INCLUDES += $(CURRENTPATH)/config/devices
-INCLUDES += $(CURRENTPATH)/config/pollingsequence
-INCLUDES += $(CURRENTPATH)/config/ipc
-INCLUDES += $(CURRENTPATH)/config/
diff --git a/defaultcfg/config/config.mk b/defaultcfg/config/config.mk
new file mode 100644
index 00000000..51543eba
--- /dev/null
+++ b/defaultcfg/config/config.mk
@@ -0,0 +1,15 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/tmtc/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/devices/*.cpp)
+
+INCLUDES += $(CURRENTPATH)
+INCLUDES += $(CURRENTPATH)/objects
+INCLUDES += $(CURRENTPATH)/returnvalues
+INCLUDES += $(CURRENTPATH)/tmtc
+INCLUDES += $(CURRENTPATH)/events
+INCLUDES += $(CURRENTPATH)/devices
+INCLUDES += $(CURRENTPATH)/pollingsequence
+INCLUDES += $(CURRENTPATH)/ipc

From 6edc2ef1d67f074b57d252ca67650646ae50b202 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:42:05 +0100
Subject: [PATCH 0957/1292] class IDs moved

---
 returnvalues/FwClassIds.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 120d1e2e..916c573a 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -65,9 +65,7 @@ enum {
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
-	SERIAL_ANALYZER, //SERA 62
-	PUS_SERVICE_9, //PUS9 63
-	FILE_SYSTEM, //FLSY 64
+	PUS_SERVICE_9, //PUS9 62
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };

From e0a11f3a6edb5a3493e9bc5214a655caf2eea208 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 29 Oct 2020 17:46:44 +0100
Subject: [PATCH 0958/1292] include guard update

---
 returnvalues/FwClassIds.h        |  7 +++----
 returnvalues/HasReturnvaluesIF.h | 10 +++++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/returnvalues/FwClassIds.h b/returnvalues/FwClassIds.h
index 916c573a..53add6a0 100644
--- a/returnvalues/FwClassIds.h
+++ b/returnvalues/FwClassIds.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
-#define FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
+#ifndef FSFW_RETURNVALUES_FWCLASSIDS_H_
+#define FSFW_RETURNVALUES_FWCLASSIDS_H_
 
 namespace CLASS_ID {
 enum {
@@ -56,7 +56,6 @@ enum {
 	DEVICE_COMMUNICATION_IF, //DC
 	BSP, //BSP
 	TIME_STAMPER_IF, //TSI 53
-	//TODO This will shift all IDs for FLP
 	SGP4PROPAGATOR_CLASS, //SGP4 54
 	MUTEX_IF, //MUX 55
 	MESSAGE_QUEUE_IF,//MQI 56
@@ -71,4 +70,4 @@ enum {
 };
 }
 
-#endif /* FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_ */
+#endif /* FSFW_RETURNVALUES_FWCLASSIDS_H_ */
diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index 9000b23c..a39ac742 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -1,8 +1,8 @@
-#ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
-#define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_
+#ifndef FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
+#define FSFW_RETURNVALUES_HASRETURNVALUESIF_H_
 
-#include "../returnvalues/FwClassIds.h"
-#include <config/returnvalues/classIds.h>
+#include "FwClassIds.h"
+#include <returnvalues/classIds.h>
 #include <cstdint>
 
 #define MAKE_RETURN_CODE( number )	((INTERFACE_ID << 8) + (number))
@@ -28,4 +28,4 @@ public:
 	}
 };
 
-#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */
+#endif /* FSFW_RETURNVALUES_HASRETURNVALUESIF_H_ */

From aed7f31f24cfd2a0b83117de8925a250c16e2917 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:47:09 +0100
Subject: [PATCH 0959/1292] health changes taken over

---
 health/HealthTable.cpp | 19 ++++++++++++-------
 health/HealthTable.h   |  5 +++++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 6d6fe017..2b8b6712 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -10,6 +10,12 @@ HealthTable::HealthTable(object_id_t objectid) :
 	mapIterator = healthMap.begin();
 }
 
+void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->mutexTimeoutMs = timeoutMs;
+}
+
 HealthTable::~HealthTable() {
 	MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -25,7 +31,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -34,7 +40,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -42,9 +48,8 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	return state;
 }
 
-
 bool HealthTable::hasHealth(object_id_t object) {
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		return true;
@@ -53,14 +58,14 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 size_t HealthTable::getPrintSize() {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
     uint32_t size = healthMap.size() * sizeof(object_id_t) +
             sizeof(HasHealthIF::HealthState) + sizeof(uint16_t);
     return size;
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	SerializeAdapter::serialize(&count,
@@ -76,7 +81,7 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 
 ReturnValue_t HealthTable::iterate(HealthEntry *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	MutexHelper(mutex, timeoutType, mutexTimeoutMs);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/health/HealthTable.h b/health/HealthTable.h
index 945fb2e6..cea34f68 100644
--- a/health/HealthTable.h
+++ b/health/HealthTable.h
@@ -12,6 +12,8 @@ public:
 	HealthTable(object_id_t objectid);
 	virtual ~HealthTable();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
     /** HealthTableIF overrides */
     virtual ReturnValue_t registerObject(object_id_t object,
             HasHealthIF::HealthState initilialState =
@@ -30,6 +32,9 @@ protected:
 	using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
 
 	MutexIF* mutex;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t mutexTimeoutMs = 20;
+
 	HealthMap healthMap;
 
 	HealthMap::iterator mapIterator;

From 41bf5622f313c205a931d5bc439b4302ccdc0af9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:50:14 +0100
Subject: [PATCH 0960/1292] master taken over

---
 unittest/README.md                   | 10 ++++++++++
 unittest/testcfg/Makefile-FSFW-Tests |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/unittest/README.md b/unittest/README.md
index e628d43e..8a787c07 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -7,6 +7,16 @@ The makefile with default settings creates the unit test binary which can be
 run in the terminal or in eclipse.
 
 ### Instructions
+
+To run the fsfw unittests in the project, perform following steps:
+
+1. Copy the testcfg folder  the project root (folder containing the FSFW).
+2. There is a makefile inside the testcfg folder which can be used to have 
+   a starting point to compile the unit tests. Copy that Makefile to the project
+   root
+3. Create a folder named catch2 (can have other name which requires Makefile 
+   adaption) and copy the Catch2 header files there (NOTE: CMake support
+   not enabled yet!)
    
 ### Eclipse CDT settings
 
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
index d43a6edc..2017d2bd 100644
--- a/unittest/testcfg/Makefile-FSFW-Tests
+++ b/unittest/testcfg/Makefile-FSFW-Tests
@@ -1,5 +1,5 @@
 #-------------------------------------------------------------------------------
-# Makefile  for FSFW Test
+# Makefile for FSFW Test
 #-------------------------------------------------------------------------------
 #		User-modifiable options
 #-------------------------------------------------------------------------------

From cd71a9cc12fc799905f781a0e2453e28590bffe7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 2 Nov 2020 15:53:08 +0100
Subject: [PATCH 0961/1292] fsfw container taken over

---
 container/IndexedRingMemoryArray.h | 93 ++++++++++++------------------
 container/SharedRingBuffer.cpp     |  2 +-
 container/SharedRingBuffer.h       | 10 +++-
 container/group.h                  |  8 ++-
 4 files changed, 51 insertions(+), 62 deletions(-)

diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 0968abfa..0d85b49b 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -1,34 +1,27 @@
 #ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
 #define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
 
-#include "../container/ArrayList.h"
+#include "ArrayList.h"
 #include "../globalfunctions/CRC.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include <cmath>
 
-/**
- * Index is the Type used for the list of indices.
- *
- * @tparam T Type which destribes the index. Needs to be a child of SerializeIF
- * 			 to be able to make it persistent
- */
 template<typename T>
 class Index: public SerializeIF{
 	/**
-	 *
+	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
 	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,
-			"Wrong Type for Index, Type must implement SerializeIF");
+	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
 public:
 	Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),
-			size(0),storedPackets(0) {
+	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+
 	}
 
-	void setBlockStartAddress(uint32_t newAddress) {
+	void setBlockStartAddress(uint32_t newAddress){
 		this->blockStartAddress = newAddress;
 	}
 
@@ -40,7 +33,7 @@ public:
 		return &indexType;
 	}
 
-	T* modifyIndexType() {
+	T* modifyIndexType(){
 		return &indexType;
 	}
 	/**
@@ -135,35 +128,26 @@ private:
 };
 
 
-/**
- * @brief Indexed Ring Memory Array is a class for a ring memory with indices.
- * @details
- * It assumes that the newest data comes in last
- * It uses the currentWriteBlock as pointer to the current writing position
- * The currentReadBlock must be set manually
- * @tparam T
- */
+
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
 	/**
-	 *
+	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+	 * It uses the currentWriteBlock as pointer to the current writing position
+	 * The currentReadBlock must be set manually
 	 */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
-			SerializeIF* additionalInfo, bool overwriteOld):
-			ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),
-			indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),
-			lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld)
-	{
+	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+
 		//Calculate the maximum number of indices needed for this blocksize
 		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
 		//Calculate the Size needeed for the index itself
-		size_t serializedSize = 0;
-		if(additionalInfo!=NULL) {
+		uint32_t serializedSize = 0;
+		if(additionalInfo!=NULL){
 			serializedSize += additionalInfo->getSerializedSize();
 		}
-
 		//Size of current iterator type
 		Index<T> tempIndex;
 		serializedSize += tempIndex.getSerializedSize();
@@ -178,7 +162,6 @@ public:
 			error << "IndexedRingMemory: Store is too small for index" << std::endl;
 		}
 		uint32_t useableSize = totalSize - serializedSize;
-
 		//Update the totalSize for calculations
 		totalSize = useableSize;
 
@@ -195,10 +178,12 @@ public:
 		this->allocated = true;
 
 		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1) {
+		if(trueNumberOfBlocks<1){
 			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
 		}
 
+
+
 		//Fill address into index
 		uint32_t address = trueStartAddress;
 		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
@@ -208,6 +193,7 @@ public:
 			address += bytesPerBlock;
 		}
 
+
 		//Initialize iterators
 		currentWriteBlock = this->begin();
 		currentReadBlock = this->begin();
@@ -246,10 +232,10 @@ public:
 		(*typeResetFnc)(it->modifyIndexType());
 	}
 
-	/**
+	/*
 	 * Reading
-	 * @param it
 	 */
+
 	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
 		currentReadBlock = it;
 		currentReadBlockSizeCached = it->getSize();
@@ -262,7 +248,6 @@ public:
 		lastBlockToRead = currentWriteBlock;
 		lastBlockToReadSize = currentWriteBlock->getSize();
 	}
-
 	/**
 	 * Sets the last block to read to this iterator.
 	 * Can be used to dump until block x
@@ -307,39 +292,33 @@ public:
 	uint32_t getCurrentReadAddress() const {
 		return getAddressOfCurrentReadBlock() + currentReadSize;
 	}
-
 	/**
-	 * Adds readSize to the current size and checks if the read has no more data
-	 * left and advances the read block.
+	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
 	 * @param readSize The size that was read
 	 * @return Returns true if the read can go on
 	 */
 	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead) {
+		if(currentReadBlock == lastBlockToRead){
 			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize) {
+			if((currentReadSize+readSize)<lastBlockToReadSize){
 				//the block has more data -> return true
 				currentReadSize += readSize;
 				return true;
-			}
-			else {
+			}else{
 				//Reached end of read -> return false
 				currentReadSize = lastBlockToReadSize;
 				return false;
 			}
-		}
-		else {
+		}else{
 			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached) {
+			if((currentReadSize + readSize)<currentReadBlockSizeCached){
 				//The current Block has more data
 				currentReadSize += readSize;
 				return true;
-			}
-			// TODO: Maybe some logic blocks should be extracted
-			else {
+			}else{
 				//The current block is written completely
 				readNext();
-				if(currentReadBlockSizeCached==0) {
+				if(currentReadBlockSizeCached==0){
 					//Next block is empty
 					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
 					//Search if any block between this and the last block is not empty
@@ -442,13 +421,13 @@ public:
 	T* modifyCurrentWriteBlockIndexType(){
 		return currentWriteBlock->modifyIndexType();
 	}
-
 	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
 		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
 		it->addSize(size);
 		it->addStoredPackets(storedPackets);
 	}
 
+
 	/**
 	 * Checks if the block has enough space for sizeToWrite
 	 * @param sizeToWrite The data to be written in the Block
@@ -457,10 +436,7 @@ public:
 	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
 		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
 		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize =
-				( ( addressOfNextBlock + totalSize ) -
-				(getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock()))
-				% totalSize;
+		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
 		return (sizeToWrite < availableSize);
 	}
 
@@ -550,7 +526,7 @@ public:
 	 */
 	size_t getSerializedSize() const {
 
-		size_t size = 0;
+		uint32_t size = 0;
 		if(additionalInfo!=NULL){
 			size += additionalInfo->getSerializedSize();
 		}
@@ -718,4 +694,7 @@ private:
 
 };
 
+
+
+
 #endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 48bdb9df..6ddb3d3e 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -18,7 +18,7 @@ SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
 }
 
 
-void SharedRingBuffer::setToUseReceiveSizeFIFO(uint32_t fifoDepth) {
+void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
 	this->fifoDepth = fifoDepth;
 }
 
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index fdc9d626..64d7ee29 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -27,7 +27,15 @@ public:
 	SharedRingBuffer(object_id_t objectId, const size_t size,
 			bool overwriteOld, size_t maxExcessBytes);
 
-	void setToUseReceiveSizeFIFO(uint32_t fifoDepth);
+	/**
+	 * @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);
 
 	/**
 	 * This constructor takes an external buffer with the specified size.
diff --git a/container/group.h b/container/group.h
index 9c70d523..5a39d34e 100644
--- a/container/group.h
+++ b/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.
  */
 
 

From b71ccf8dd8274b6dc00dcec74e412bad25c812cd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:28:55 +0100
Subject: [PATCH 0962/1292] some refactoring

---
 datapoollocal/LocalDataPoolManager.cpp | 234 +++++++++++++------------
 datapoollocal/LocalDataPoolManager.h   |   7 +
 2 files changed, 133 insertions(+), 108 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d89f597e..65a40298 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -101,120 +101,15 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
             break;
         }
         case(ReportingType::UPDATE_HK): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Update packets shall only be generated from datasets.
-                continue;
-            }
-            LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                    receiver.dataId.sid);
-            if(dataSet->hasChanged()) {
-                // prepare and send update notification
-                ReturnValue_t result = generateHousekeepingPacket(
-                            receiver.dataId.sid, dataSet, true);
-                if(result != HasReturnvaluesIF::RETURN_OK) {
-                    status = result;
-                }
-            }
-            handleChangeResetLogic(receiver.dataType, receiver.dataId,
-                    dataSet);
+            handleHkUpdate(receiver, status);
             break;
         }
         case(ReportingType::UPDATE_NOTIFICATION): {
-            MarkChangedIF* toReset = nullptr;
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                        receiver.dataId.localPoolId);
-                if(poolObj == nullptr) {
-                    continue;
-                }
-                if(poolObj->hasChanged()) {
-                    // prepare and send update notification.
-                    CommandMessage notification;
-                    HousekeepingMessage::setUpdateNotificationVariableCommand(
-                            &notification, receiver.dataId.localPoolId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = poolObj;
-                }
-
-            }
-            else {
-                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                        receiver.dataId.sid);
-                if(dataSet == nullptr) {
-                    continue;
-                }
-                if(dataSet->hasChanged()) {
-                    // prepare and send update notification
-                    CommandMessage notification;
-                    HousekeepingMessage::setUpdateNotificationSetCommand(
-                            &notification, receiver.dataId.sid);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = dataSet;
-                }
-            }
-            if(toReset != nullptr) {
-                handleChangeResetLogic(receiver.dataType,
-                        receiver.dataId, toReset);
-            }
+            handleNotificationUpdate(receiver, status);
             break;
         }
         case(ReportingType::UPDATE_SNAPSHOT): {
-            MarkChangedIF* toReset = nullptr;
-            // check whether data has changed and send messages in case it has.
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                        receiver.dataId.localPoolId);
-                if(poolObj == nullptr) {
-                    continue;
-                }
-                if(poolObj->hasChanged()) {
-                    // prepare and send update snapshot.
-                    CommandMessage notification;
-                    // todo: serialize into store with timestamp.
-                    store_address_t storeId;
-                    HousekeepingMessage::setUpdateSnapshotSetCommand(
-                            &notification, receiver.dataId.sid, storeId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = poolObj;
-                }
-            }
-            else {
-                LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                        receiver.dataId.sid);
-                if(dataSet == nullptr) {
-                    continue;
-                }
-                if(dataSet->hasChanged()) {
-                    // prepare and send update snapshot.
-                    CommandMessage notification;
-                    // todo: serialize into store with timestamp.
-                    store_address_t storeId;
-                    HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                            &notification, receiver.dataId.localPoolId, storeId);
-                    ReturnValue_t result = hkQueue->sendMessage(
-                            receiver.destinationQueue, &notification);
-                    if(result != HasReturnvaluesIF::RETURN_OK) {
-                        status = result;
-                    }
-                    toReset = dataSet;
-                }
-            }
-            if(toReset != nullptr) {
-                handleChangeResetLogic(receiver.dataType,
-                        receiver.dataId, toReset);
-            }
+            handleNotificationSnapshot(receiver, status);
             break;
         }
         default:
@@ -226,6 +121,129 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
     return status;
 }
 
+ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
+            ReturnValue_t& status) {
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        // Update packets shall only be generated from datasets.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+            receiver.dataId.sid);
+    if(dataSet->hasChanged()) {
+        // prepare and send update notification
+        ReturnValue_t result = generateHousekeepingPacket(
+                    receiver.dataId.sid, dataSet, true);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+    }
+    handleChangeResetLogic(receiver.dataType, receiver.dataId,
+            dataSet);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(poolObj->hasChanged()) {
+            // prepare and send update notification.
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationVariableCommand(
+                    &notification, receiver.dataId.localPoolId);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = poolObj;
+        }
+
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        if(dataSet->hasChanged()) {
+            // prepare and send update notification
+            CommandMessage notification;
+            HousekeepingMessage::setUpdateNotificationSetCommand(
+                    &notification, receiver.dataId.sid);
+            ReturnValue_t result = hkQueue->sendMessage(
+                    receiver.destinationQueue, &notification);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            toReset = dataSet;
+        }
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
+        HkReceiver& receiver, ReturnValue_t& status) {
+    MarkChangedIF* toReset = nullptr;
+     // check whether data has changed and send messages in case it has.
+     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                 receiver.dataId.localPoolId);
+         if(poolObj == nullptr) {
+             return HasReturnvaluesIF::RETURN_FAILED;
+         }
+         if(poolObj->hasChanged()) {
+             // prepare and send update snapshot.
+             CommandMessage notification;
+             // todo: serialize into store with timestamp.
+             store_address_t storeId;
+             HousekeepingMessage::setUpdateSnapshotSetCommand(
+                     &notification, receiver.dataId.sid, storeId);
+             ReturnValue_t result = hkQueue->sendMessage(
+                     receiver.destinationQueue, &notification);
+             if(result != HasReturnvaluesIF::RETURN_OK) {
+                 status = result;
+             }
+             toReset = poolObj;
+         }
+     }
+     else {
+         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                 receiver.dataId.sid);
+         if(dataSet == nullptr) {
+             return HasReturnvaluesIF::RETURN_FAILED;
+         }
+         if(dataSet->hasChanged()) {
+             // prepare and send update snapshot.
+             CommandMessage notification;
+             // todo: serialize into store with timestamp.
+             store_address_t storeId;
+             HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                     &notification, receiver.dataId.localPoolId, storeId);
+             ReturnValue_t result = hkQueue->sendMessage(
+                     receiver.destinationQueue, &notification);
+             if(result != HasReturnvaluesIF::RETURN_OK) {
+                 status = result;
+             }
+             toReset = dataSet;
+         }
+     }
+     if(toReset != nullptr) {
+         handleChangeResetLogic(receiver.dataType,
+                 receiver.dataId, toReset);
+     }
+     return HasReturnvaluesIF::RETURN_OK;
+}
+
 void LocalDataPoolManager::handleChangeResetLogic(
         DataType type, DataId dataId, MarkChangedIF* toReset) {
     if(hkUpdateResetList == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index afe82760..a5cd0f98 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -350,6 +350,13 @@ private:
 	void handleChangeResetLogic(DataType type,
 	        DataId dataId, MarkChangedIF* toReset);
 	void resetHkUpdateResetHelper();
+
+	ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
+	ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
+	        ReturnValue_t& status);
+	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
+            ReturnValue_t& status);
 };
 
 

From 38b5695a1008af28ecd783b437770b08775bd2ab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:45:04 +0100
Subject: [PATCH 0963/1292] size check + include guard

---
 datapoollocal/LocalPoolDataSetBase.cpp  | 11 ++++++++++-
 housekeeping/HousekeepingPacketUpdate.h |  6 +++---
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5bb71cb6..5cd4b62b 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -81,6 +81,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
             return result;
         }
     }
+
+    if(*size + validityMaskSize > maxSize) {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
     // copy validity buffer to end
     std::memcpy(*buffer, validityMask, validityMaskSize);
     *size += validityMaskSize;
@@ -98,9 +102,13 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
             return result;
         }
     }
+
+    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
+
     uint8_t validBufferIndex = 0;
     uint8_t validBufferIndexBit = 0;
-    // could be made more efficient but make it work first
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
         bool nextVarValid = this->bitGetter(*buffer +
@@ -117,6 +125,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     }
     return result;
 }
+
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	MutexIF* mutex = hkManager->getMutexHandle();
 	return mutex->unlockMutex();
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index eebdc11c..37d38be7 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
-#define FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
+#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_
 
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialLinkedListAdapter.h"
@@ -70,4 +70,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */
+#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From 633203eb5406adbf3d4f48e1cbcc6397352fe19d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:50:55 +0100
Subject: [PATCH 0964/1292] upstream time stamper taken over

---
 datapoollocal/LocalDataPoolManager.cpp | 3 +++
 timemanager/TimeStamperIF.h            | 8 ++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 65a40298..7706db31 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -2,8 +2,10 @@
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 
+#include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
+
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
@@ -205,6 +207,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
+             HousekeepingPacketUpdate updatePacket()
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(
                      &notification, receiver.dataId.sid, storeId);
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index bdc5e7e3..96011088 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -14,8 +14,12 @@ public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::TIME_STAMPER_IF;
 	static const ReturnValue_t BAD_TIMESTAMP = MAKE_RETURN_CODE(1);
 
-	static const uint8_t MISSION_TIMESTAMP_SIZE = 8; //!< This is a mission-specific constant and determines the total size reserved for timestamps.
-	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize) = 0;
+	//! This is a mission-specific constant and determines the total
+	//! size reserved for timestamps.
+	//! TODO: Default define in FSFWConfig ?
+	static const uint8_t MISSION_TIMESTAMP_SIZE = 8;
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer,
+	        const uint8_t maxSize) = 0;
 	virtual ~TimeStamperIF() {}
 };
 

From 83f0b4bffc25dd4f8619220401a0f5ed2f1c1e15 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:51:56 +0100
Subject: [PATCH 0965/1292] defaultcfg changes taken over

---
 defaultcfg/config/FSFWConfig.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index ea724a64..ea86152c 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -12,10 +12,6 @@
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_REDUCED_PRINTOUT		0
 
-//! Default timestamp size. The default timestamp will be an eight byte CDC
-//! short timestamp.
-#define FSFW_MISSION_TIMESTAMP_SIZE 8
-
 //! Can be used to enable debugging printouts for developing the FSFW
 #define FSFW_DEBUGGING              0
 
@@ -45,6 +41,10 @@
 #define FSFW_NO_C99_IO 	1
 
 namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
 //! Configure the allocated pool sizes for the event manager.
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;

From dcf36d4ceebc8c70f4d17f14fd1cdf78fa4969ea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 15:54:27 +0100
Subject: [PATCH 0966/1292] cstdint include added

---
 defaultcfg/config/FSFWConfig.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/config/FSFWConfig.h
index ea86152c..be3717b4 100644
--- a/defaultcfg/config/FSFWConfig.h
+++ b/defaultcfg/config/FSFWConfig.h
@@ -3,6 +3,7 @@
 
 #include <FSFWVersion.h>
 #include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.

From 81f5783d371bdf3b3521d8c37a59592bf7d45b79 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:06:30 +0100
Subject: [PATCH 0967/1292] clock update, definitions file

---
 datapoollocal/LocalDataPoolManager.cpp      |  4 +-
 pus/Service9TimeManagement.cpp              |  2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp |  2 +-
 timemanager/CCSDSTime.cpp                   | 22 ++++-----
 timemanager/CCSDSTime.h                     | 25 +++++-----
 timemanager/Clock.h                         | 55 ++++++++++++---------
 timemanager/ReceivesTimeInfoIF.h            | 12 ++---
 timemanager/TimeMessage.h                   | 15 ++----
 timemanager/TimeStamperIF.h                 |  6 +--
 timemanager/clockDefinitions.h              | 22 +++++++++
 10 files changed, 92 insertions(+), 73 deletions(-)
 create mode 100644 timemanager/clockDefinitions.h

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 7706db31..5e45dec1 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -207,7 +207,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
-             HousekeepingPacketUpdate updatePacket()
+
+             // HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
+             //        owner->getDataSetHandle(receiver.dataId.sid));
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(
                      &notification, receiver.dataId.sid, storeId);
diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
index 5625bdd8..8c90ae40 100644
--- a/pus/Service9TimeManagement.cpp
+++ b/pus/Service9TimeManagement.cpp
@@ -28,7 +28,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
 }
 
 ReturnValue_t Service9TimeManagement::setTime() {
-	Clock::TimeOfDay_t timeToSet;
+	TimeOfDay_t timeToSet;
 	TimePacket timePacket(currentPacket.getApplicationData(),
 			currentPacket.getApplicationDataSize());
 	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 68fc4dec..cede344c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -93,7 +93,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 }
 
 std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	Clock::TimeOfDay_t loggerTime;
+	TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8878a38a..30f9768b 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -1,4 +1,4 @@
-#include "../timemanager/CCSDSTime.h"
+#include "CCSDSTime.h"
 #include <FSFWConfig.h>
 #include <cstdio>
 #include <cinttypes>
@@ -12,7 +12,7 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
+		const TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -32,7 +32,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
+		const TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -53,7 +53,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 	return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
 		uint32_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
@@ -81,12 +81,12 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to, const uint8_t*
 	}
 }
 
-ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCUC(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	return UNSUPPORTED_TIME_FORMAT;
 }
 
-ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	timeval time;
 	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
@@ -96,7 +96,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
 	return convertTimevalToTimeOfDay(to, &time);
 }
 
-ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
@@ -152,7 +152,7 @@ ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* f
 
 }
 
-ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to, const uint8_t* from,
+ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 		uint8_t length) {
 	if (length < 19) {
 		return RETURN_FAILED;
@@ -427,7 +427,7 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
 	return result;
 }
 
-ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
+ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
 	if ((time->month > 12) || (time->month == 0)) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -482,7 +482,7 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
 
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(TimeOfDay_t* to,
 		timeval* from) {
 //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
 	return UNSUPPORTED_TIME_FORMAT;
@@ -592,7 +592,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
+	TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
 	if (result != RETURN_OK) {
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 89fcff92..ac8bb266 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -1,9 +1,10 @@
-#ifndef CCSDSTIME_H_
-#define CCSDSTIME_H_
+#ifndef FSFW_TIMEMANAGER_CCSDSTIME_H_
+#define FSFW_TIMEMANAGER_CCSDSTIME_H_
 
 // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly
 
 #include "Clock.h"
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
@@ -111,7 +112,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
+			TimeOfDay_t const *from);
 
 	/**
 	 * Converts to CDS format from timeval.
@@ -136,7 +137,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
+			TimeOfDay_t const *from);
 
 	/**
 	 * SHOULDDO: can this be modified to recognize padding?
@@ -154,7 +155,7 @@ public:
 	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCcsds(TimeOfDay_t *to, uint8_t const *from,
 			uint32_t length);
 
 	/**
@@ -167,7 +168,7 @@ public:
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCUC(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
@@ -182,16 +183,16 @@ public:
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
 			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCDS(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromCCS(TimeOfDay_t *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to, uint8_t const *from,
+	static ReturnValue_t convertFromASCII(TimeOfDay_t *to, uint8_t const *from,
 			uint8_t length);
 
 	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
@@ -209,7 +210,7 @@ private:
 	 */
 	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+	static ReturnValue_t checkTimeOfDay(const TimeOfDay_t *time);
 
 	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
 	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
@@ -226,8 +227,8 @@ private:
 			uint8_t *month, uint8_t *day);
 
 	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+	static ReturnValue_t convertTimevalToTimeOfDay(TimeOfDay_t* to,
 			timeval* from);
 };
 
-#endif /* CCSDSTIME_H_ */
+#endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 1ad88305..d97eecbe 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -1,6 +1,7 @@
-#ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_
-#define FRAMEWORK_TIMEMANAGER_CLOCK_H_
+#ifndef FSFW_TIMEMANAGER_CLOCK_H_
+#define FSFW_TIMEMANAGER_CLOCK_H_
 
+#include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MutexFactory.h"
 #include "../globalfunctions/timevalOperations.h"
@@ -8,20 +9,11 @@
 #include <cstdint>
 #include <sys/time.h>
 
-//! Don't use these for time points, type is not large enough for UNIX epoch.
-using dur_millis_t = uint32_t;
-
+// TODO: Maybe a namespace would be better/more fitting for this?
+// After all, right now it is just a collection of static functions.
+// The mutex and leap seconds can be put in an anonymous namespace.
 class Clock {
 public:
-	typedef struct {
-	  uint32_t year; //!< Year, A.D.
-	  uint32_t month; //!< Month, 1 .. 12.
-	  uint32_t day; //!< Day, 1 .. 31.
-	  uint32_t hour; //!< Hour, 0 .. 23.
-	  uint32_t minute; //!< Minute, 0 .. 59.
-	  uint32_t second; //!< Second, 0 .. 59.
-	  uint32_t usecond; //!< Microseconds, 0 .. 999999
-	}   TimeOfDay_t;
 
 	/**
 	 * This method returns the number of clock ticks per second.
@@ -84,13 +76,17 @@ public:
 	 * Returns the time in microseconds since an OS-defined epoch.
 	 * The time is returned in a 64 bit unsigned integer.
 	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getClock_usecs(uint64_t* time);
 	/**
 	 * Returns the time in a TimeOfDay_t struct.
 	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
@@ -98,17 +94,20 @@ public:
 	 * Converts a time of day struct to POSIX seconds.
 	 * @param time The time of day as input
 	 * @param timeval The corresponding seconds since the epoch.
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 			timeval* to);
 
 	/**
-	 * Converts a time represented as seconds and subseconds since unix epoch to days since J2000
+	 * Converts a time represented as seconds and subseconds since unix
+	 * epoch to days since J2000
 	 *
 	 * @param time seconds since unix epoch
 	 * @param[out] JD2000 days since J2000
-	 * @return \c RETURN_OK
+	 * @return @c RETURN_OK
 	 */
 	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
@@ -119,7 +118,9 @@ public:
 	 *
 	 * @param utc timeval, corresponding to UTC time
 	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return \c RETURN_OK on success, \c RETURN_FAILED if leapSeconds are not set
+	 * @return
+	 *  - @c RETURN_OK on success
+	 *  - @c RETURN_FAILED if leapSeconds are not set
 	 */
 	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
@@ -127,7 +128,9 @@ public:
 	 * Set the Leap Seconds since 1972
 	 *
 	 * @param leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
@@ -137,13 +140,17 @@ public:
 	 * Must be set before!
 	 *
 	 * @param[out] leapSeconds_
-	 * @return \c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
 	 */
 	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
 	/**
 	 * Function to check and create the Mutex for the clock
-	 * @return \c RETURN_OK on success. Otherwise \c RETURN_FAILED if not able to create one
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise @c RETURN_FAILED if not able to create one
 	 */
 	static ReturnValue_t checkOrCreateClockMutex();
 
@@ -153,4 +160,4 @@ private:
 };
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_CLOCK_H_ */
+#endif /* FSFW_TIMEMANAGER_CLOCK_H_ */
diff --git a/timemanager/ReceivesTimeInfoIF.h b/timemanager/ReceivesTimeInfoIF.h
index 680e94f2..c1247a42 100644
--- a/timemanager/ReceivesTimeInfoIF.h
+++ b/timemanager/ReceivesTimeInfoIF.h
@@ -1,12 +1,6 @@
-/**
- * @file	ReceivesTimeInfoIF.h
- * @brief	This file defines the ReceivesTimeInfoIF class.
- * @date	26.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
+#define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
 
-#ifndef RECEIVESTIMEINFOIF_H_
-#define RECEIVESTIMEINFOIF_H_
 #include "../ipc/MessageQueueSenderIF.h"
 
 /**
@@ -29,4 +23,4 @@ public:
 };
 
 
-#endif /* RECEIVESTIMEINFOIF_H_ */
+#endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */
diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h
index bb83708c..f5ac3e14 100644
--- a/timemanager/TimeMessage.h
+++ b/timemanager/TimeMessage.h
@@ -1,15 +1,8 @@
-/**
- * @file	TimeMessage.h
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#ifndef TIMEMESSAGE_H_
-#define TIMEMESSAGE_H_
+#ifndef FSFW_TIMEMANAGER_TIMEMESSAGE_H_
+#define FSFW_TIMEMANAGER_TIMEMESSAGE_H_
 
+#include "Clock.h"
 #include "../ipc/MessageQueueMessage.h"
-#include "../timemanager/Clock.h"
 #include <cstring>
 
 class TimeMessage : public MessageQueueMessage {
@@ -53,4 +46,4 @@ public:
 	uint32_t getCounterValue();
 };
 
-#endif /* TIMEMESSAGE_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMEMESSAGE_H_ */
diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h
index 96011088..57b7f014 100644
--- a/timemanager/TimeStamperIF.h
+++ b/timemanager/TimeStamperIF.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
@@ -25,4 +25,4 @@ public:
 
 
 
-#endif /* FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ */
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
new file mode 100644
index 00000000..1cfbe804
--- /dev/null
+++ b/timemanager/clockDefinitions.h
@@ -0,0 +1,22 @@
+#ifndef FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+#define FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_
+
+#include <cstdint>
+
+// It would be better to put this in a clock namespace, but then we
+// have a nameclash with the class Clock (which propably also should be put
+// in a namespace)
+typedef struct {
+    uint32_t year; //!< Year, A.D.
+    uint32_t month; //!< Month, 1 .. 12.
+    uint32_t day; //!< Day, 1 .. 31.
+    uint32_t hour; //!< Hour, 0 .. 23.
+    uint32_t minute; //!< Minute, 0 .. 59.
+    uint32_t second; //!< Second, 0 .. 59.
+    uint32_t usecond; //!< Microseconds, 0 .. 999999
+} TimeOfDay_t;
+
+//! Don't use these for time points, type is not large enough for UNIX epoch.
+using dur_millis_t = uint32_t;
+
+#endif /* FSFW_TIMEMANAGER_CLOCKDEFINITIONS_H_ */

From f69f9bb31e505537a1093ed2c5af26d672e03b19 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:31:25 +0100
Subject: [PATCH 0968/1292] comments removed

---
 timemanager/Clock.h            | 3 ---
 timemanager/clockDefinitions.h | 4 +---
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index d97eecbe..801e9454 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -9,9 +9,6 @@
 #include <cstdint>
 #include <sys/time.h>
 
-// TODO: Maybe a namespace would be better/more fitting for this?
-// After all, right now it is just a collection of static functions.
-// The mutex and leap seconds can be put in an anonymous namespace.
 class Clock {
 public:
 
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
index 1cfbe804..5804d331 100644
--- a/timemanager/clockDefinitions.h
+++ b/timemanager/clockDefinitions.h
@@ -3,9 +3,7 @@
 
 #include <cstdint>
 
-// It would be better to put this in a clock namespace, but then we
-// have a nameclash with the class Clock (which propably also should be put
-// in a namespace)
+
 typedef struct {
     uint32_t year; //!< Year, A.D.
     uint32_t month; //!< Month, 1 .. 12.

From 9e97357b8caa13883e59ed16d5fd60362697a55b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:46:43 +0100
Subject: [PATCH 0969/1292] taken over changes from master

---
 timemanager/CCSDSTime.cpp      | 42 ++++++++++++++++++----------------
 timemanager/CCSDSTime.h        | 28 +++++++++++------------
 timemanager/Clock.h            | 11 +++++++--
 timemanager/Stopwatch.cpp      |  2 +-
 timemanager/TimeMessage.cpp    |  9 +-------
 timemanager/TimeStamper.cpp    | 23 +++++++++++++++++++
 timemanager/TimeStamper.h      | 36 +++++++++++++++++++++++++++++
 timemanager/clockDefinitions.h | 13 +++--------
 8 files changed, 109 insertions(+), 55 deletions(-)
 create mode 100644 timemanager/TimeStamper.cpp
 create mode 100644 timemanager/TimeStamper.h

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 30f9768b..6acd5539 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -12,7 +12,7 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const TimeOfDay_t* from) {
+		const Clock::TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -32,7 +32,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const TimeOfDay_t* from) {
+		const Clock::TimeOfDay_t* from) {
 	ReturnValue_t result = checkTimeOfDay(from);
 	if (result != RETURN_OK) {
 		return result;
@@ -53,8 +53,8 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 	return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
-		uint32_t length) {
+ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint32_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
 		return LENGTH_MISMATCH;
@@ -81,13 +81,13 @@ ReturnValue_t CCSDSTime::convertFromCcsds(TimeOfDay_t* to, const uint8_t* from,
 	}
 }
 
-ReturnValue_t CCSDSTime::convertFromCUC(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	return UNSUPPORTED_TIME_FORMAT;
 }
 
-ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	timeval time;
 	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -96,8 +96,8 @@ ReturnValue_t CCSDSTime::convertFromCDS(TimeOfDay_t* to, const uint8_t* from,
 	return convertTimevalToTimeOfDay(to, &time);
 }
 
-ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
 	if (maxLength < totalLength) {
@@ -152,8 +152,8 @@ ReturnValue_t CCSDSTime::convertFromCCS(TimeOfDay_t* to, const uint8_t* from,
 
 }
 
-ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
-		uint8_t length) {
+ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to,
+        const uint8_t* from, uint8_t length) {
 	if (length < 19) {
 		return RETURN_FAILED;
 	}
@@ -166,8 +166,9 @@ ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 	uint16_t hour;
 	uint16_t minute;
 	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year,
-				&month, &day, &hour, &minute, &second);
+	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
+	        "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
+	        &minute, &second);
 	if (count == 6) {
 		to->year = year;
 		to->month = month;
@@ -180,12 +181,13 @@ ReturnValue_t CCSDSTime::convertFromASCII(TimeOfDay_t* to, const uint8_t* from,
 	}
 
 	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &day,
-			&hour, &minute, &second);
+	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
+	        "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
 	if (count == 5) {
 		uint8_t tempDay;
 		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month), reinterpret_cast<uint8_t *>(&tempDay));
+				reinterpret_cast<uint8_t *>(&month),
+				reinterpret_cast<uint8_t *>(&tempDay));
 		if (result != RETURN_OK) {
 			return RETURN_FAILED;
 		}
@@ -427,7 +429,7 @@ ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
 	return result;
 }
 
-ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
+ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
 	if ((time->month > 12) || (time->month == 0)) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -482,7 +484,7 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const TimeOfDay_t* time) {
 
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(TimeOfDay_t* to,
+ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 		timeval* from) {
 //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
 	return UNSUPPORTED_TIME_FORMAT;
@@ -592,7 +594,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
 		uint32_t* foundLength, uint32_t maxLength) {
-	TimeOfDay_t tempTime;
+	Clock::TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
 	if (result != RETURN_OK) {
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index ac8bb266..29c9f8f5 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -112,7 +112,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			TimeOfDay_t const *from);
+			Clock::TimeOfDay_t const *from);
 
 	/**
 	 * Converts to CDS format from timeval.
@@ -137,7 +137,7 @@ public:
 	 * 		- @c INVALID_TIMECODE if not OK
 	 */
 	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			TimeOfDay_t const *from);
+			Clock::TimeOfDay_t const *from);
 
 	/**
 	 * SHOULDDO: can this be modified to recognize padding?
@@ -155,8 +155,8 @@ public:
 	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
-	static ReturnValue_t convertFromCcsds(TimeOfDay_t *to, uint8_t const *from,
-			uint32_t length);
+	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint32_t length);
 
 	/**
 	 * not implemented yet
@@ -168,8 +168,8 @@ public:
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCUC(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
@@ -183,17 +183,17 @@ public:
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
 			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCDS(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
 			uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromCCS(TimeOfDay_t *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
 
-	static ReturnValue_t convertFromASCII(TimeOfDay_t *to, uint8_t const *from,
-			uint8_t length);
+	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
+	        uint8_t const *from, uint8_t length);
 
 	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 private:
@@ -210,7 +210,7 @@ private:
 	 */
 	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const TimeOfDay_t *time);
+	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
 
 	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
 	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
@@ -227,7 +227,7 @@ private:
 			uint8_t *month, uint8_t *day);
 
 	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(TimeOfDay_t* to,
+	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 			timeval* from);
 };
 
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 801e9454..82007795 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -11,6 +11,15 @@
 
 class Clock {
 public:
+    typedef struct {
+        uint32_t year; //!< Year, A.D.
+        uint32_t month; //!< Month, 1 .. 12.
+        uint32_t day; //!< Day, 1 .. 31.
+        uint32_t hour; //!< Hour, 0 .. 23.
+        uint32_t minute; //!< Minute, 0 .. 59.
+        uint32_t second; //!< Second, 0 .. 59.
+        uint32_t usecond; //!< Microseconds, 0 .. 999999
+    } TimeOfDay_t;
 
 	/**
 	 * This method returns the number of clock ticks per second.
@@ -56,8 +65,6 @@ public:
 
 	static timeval getUptime();
 
-	static uint32_t getUptimeSeconds();
-
 	/**
 	 * Get the time since boot in milliseconds
 	 *
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 2cd31969..302e2ac0 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -1,4 +1,4 @@
-#include "../timemanager/Stopwatch.h"
+#include "Stopwatch.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include <iomanip>
 
diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp
index 6e8dcd60..a1042efe 100644
--- a/timemanager/TimeMessage.cpp
+++ b/timemanager/TimeMessage.cpp
@@ -1,11 +1,4 @@
-/**
- * @file	TimeMessage.cpp
- * @brief	This file defines the TimeMessage class.
- * @date	26.02.2013
- * @author	baetz
- */
-
-#include "../timemanager/TimeMessage.h"
+#include "TimeMessage.h"
 
 TimeMessage::TimeMessage() {
 	this->messageSize += sizeof(timeval) + sizeof(uint32_t);
diff --git a/timemanager/TimeStamper.cpp b/timemanager/TimeStamper.cpp
new file mode 100644
index 00000000..d9f0f2f3
--- /dev/null
+++ b/timemanager/TimeStamper.cpp
@@ -0,0 +1,23 @@
+#include "TimeStamper.h"
+#include "Clock.h"
+#include <cstring>
+
+TimeStamper::TimeStamper(object_id_t objectId): SystemObject(objectId) {}
+
+
+ReturnValue_t TimeStamper::addTimeStamp(uint8_t* buffer,
+		const uint8_t maxSize) {
+	if(maxSize < TimeStamperIF::MISSION_TIMESTAMP_SIZE){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	timeval now;
+	Clock::getClock_timeval(&now);
+	CCSDSTime::CDS_short cds;
+	ReturnValue_t result = CCSDSTime::convertToCcsds(&cds,&now);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	std::memcpy(buffer,&cds,sizeof(cds));
+	return result;
+}
diff --git a/timemanager/TimeStamper.h b/timemanager/TimeStamper.h
new file mode 100644
index 00000000..6895c14b
--- /dev/null
+++ b/timemanager/TimeStamper.h
@@ -0,0 +1,36 @@
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPER_H_
+
+#include "TimeStamperIF.h"
+#include "CCSDSTime.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief   Time stamper which can be used to add any timestamp to a
+ *          given buffer.
+ * @details
+ * This time stamper uses the CCSDS CDC short timestamp as a fault timestamp.
+ * This timestamp has a size of 8 bytes. A custom timestamp can be used by
+ * overriding the #addTimeStamp function.
+ * @ingroup utility
+ */
+class TimeStamper: public TimeStamperIF, public SystemObject {
+public:
+    /**
+     * @brief   Default constructor which also registers the time stamper as a
+     *          system object so it can be found with the #objectManager.
+     * @param objectId
+     */
+	TimeStamper(object_id_t objectId);
+
+	/**
+	 * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
+	 * This function can be overriden to use a custom timestamp.
+	 * @param buffer
+	 * @param maxSize
+	 * @return
+	 */
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize);
+};
+
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */
diff --git a/timemanager/clockDefinitions.h b/timemanager/clockDefinitions.h
index 5804d331..bba6e3ca 100644
--- a/timemanager/clockDefinitions.h
+++ b/timemanager/clockDefinitions.h
@@ -3,16 +3,9 @@
 
 #include <cstdint>
 
-
-typedef struct {
-    uint32_t year; //!< Year, A.D.
-    uint32_t month; //!< Month, 1 .. 12.
-    uint32_t day; //!< Day, 1 .. 31.
-    uint32_t hour; //!< Hour, 0 .. 23.
-    uint32_t minute; //!< Minute, 0 .. 59.
-    uint32_t second; //!< Second, 0 .. 59.
-    uint32_t usecond; //!< Microseconds, 0 .. 999999
-} TimeOfDay_t;
+// I'd also like to include the TimeOfDay_t struct here, but that would
+// break code which uses Clock::TimeOfDay_t. Solution would be to use
+// a Clock namespace instead of class with static functions.
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
 using dur_millis_t = uint32_t;

From 695b161934052c7d18f1db7dbb04c71e66e6f3de Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 16:54:56 +0100
Subject: [PATCH 0970/1292] some bugfixes

---
 osal/FreeRTOS/Clock.cpp                     | 8 ++++----
 pus/Service9TimeManagement.cpp              | 2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 42f060b4..f3d8516a 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -68,10 +68,10 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 }
 
 
-uint32_t Clock::getUptimeSeconds() {
-	timeval uptime = getUptime();
-	return uptime.tv_sec;
-}
+//uint32_t Clock::getUptimeSeconds() {
+//	timeval uptime = getUptime();
+//	return uptime.tv_sec;
+//}
 
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
diff --git a/pus/Service9TimeManagement.cpp b/pus/Service9TimeManagement.cpp
index 8c90ae40..5625bdd8 100644
--- a/pus/Service9TimeManagement.cpp
+++ b/pus/Service9TimeManagement.cpp
@@ -28,7 +28,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
 }
 
 ReturnValue_t Service9TimeManagement::setTime() {
-	TimeOfDay_t timeToSet;
+	Clock::TimeOfDay_t timeToSet;
 	TimePacket timePacket(currentPacket.getApplicationData(),
 			currentPacket.getApplicationDataSize());
 	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index cede344c..68fc4dec 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -93,7 +93,7 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 }
 
 std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
-	TimeOfDay_t loggerTime;
+	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];

From d424d85f6d0699a7f9da63f28e973a2855873243 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:07:48 +0100
Subject: [PATCH 0971/1292] sizet changes and indentation

---
 timemanager/CCSDSTime.cpp |  18 +--
 timemanager/CCSDSTime.h   |  16 +--
 timemanager/Clock.h       | 256 +++++++++++++++++++-------------------
 3 files changed, 145 insertions(+), 145 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 6acd5539..aefcac2e 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -54,7 +54,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
-        const uint8_t* from, uint32_t length) {
+        const uint8_t* from, size_t length) {
 	ReturnValue_t result;
 	if (length > 0xFF) {
 		return LENGTH_MISMATCH;
@@ -72,7 +72,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
 	case CDS:
 		return convertFromCDS(to, from, length);
 	case CCS: {
-		uint32_t temp = 0;
+		size_t temp = 0;
 		return convertFromCCS(to, from, &temp, length);
 	}
 
@@ -97,7 +97,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
-        const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+        const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint8_t subsecondsLength = *from & 0b111;
 	uint32_t totalLength = subsecondsLength + 8;
 	if (maxLength < totalLength) {
@@ -395,7 +395,7 @@ ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	//We don't expect ascii here. SHOULDDO
 	uint8_t codeIdentification = (*from >> 4);
 	switch (codeIdentification) {
@@ -413,7 +413,7 @@ ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	if (maxLength < 1) {
 		return INVALID_TIME_FORMAT;
 	}
@@ -491,7 +491,7 @@ ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	uint8_t pField = *from;
 	from++;
 //Check epoch
@@ -556,12 +556,12 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, uint32_t* foundLength, uint32_t maxLength) {
+		const uint8_t* from, size_t* foundLength, size_t maxLength) {
 	uint32_t secs = 0;
 	uint32_t subSeconds = 0;
 	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
 	uint8_t nFine = (pField & 0b11);
-	uint32_t totalLength = nCoarse + nFine;
+	size_t totalLength = nCoarse + nFine;
 	if (foundLength != NULL) {
 		*foundLength = totalLength;
 	}
@@ -593,7 +593,7 @@ uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		uint32_t* foundLength, uint32_t maxLength) {
+		size_t* foundLength, size_t maxLength) {
 	Clock::TimeOfDay_t tempTime;
 	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
 			maxLength);
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index 29c9f8f5..e9e6957f 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -156,7 +156,7 @@ public:
 	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
 	 */
 	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint32_t length);
+	        uint8_t const *from, size_t length);
 
 	/**
 	 * not implemented yet
@@ -166,31 +166,31 @@ public:
 	 * @return
 	 */
 	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+			uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
 
 	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			uint32_t* foundLength, uint32_t maxLength);
+			size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint32_t* foundLength, uint32_t maxLength);
+	        uint8_t const *from, size_t* foundLength, size_t maxLength);
 
 	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
 	        uint8_t const *from, uint8_t length);
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 82007795..f4ed847a 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -21,146 +21,146 @@ public:
         uint32_t usecond; //!< Microseconds, 0 .. 999999
     } TimeOfDay_t;
 
-	/**
-	 * This method returns the number of clock ticks per second.
-	 * In RTEMS, this is typically 1000.
-	 * @return	The number of ticks.
-	 *
-	 * @deprecated, we should not worry about ticks, but only time
-	 */
-	static uint32_t getTicksPerSecond(void);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a TimeOfDay_t struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-	 * 				is returned.
-	 */
-	static ReturnValue_t setClock(const TimeOfDay_t* time);
-	/**
-	 * This system call sets the system time.
-	 * To set the time, it uses a timeval struct.
-	 * @param time The struct with the time settings to set.
-	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setClock(const timeval* time);
-	/**
-	 * This system call returns the current system clock in timeval format.
-	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-	 * microseconds since an OS-defined epoch.
-	 * @param time	A pointer to a timeval struct where the current time is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_timeval(timeval* time);
+    /**
+     * This method returns the number of clock ticks per second.
+     * In RTEMS, this is typically 1000.
+     * @return	The number of ticks.
+     *
+     * @deprecated, we should not worry about ticks, but only time
+     */
+    static uint32_t getTicksPerSecond(void);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a TimeOfDay_t struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+     * 				is returned.
+     */
+    static ReturnValue_t setClock(const TimeOfDay_t* time);
+    /**
+     * This system call sets the system time.
+     * To set the time, it uses a timeval struct.
+     * @param time The struct with the time settings to set.
+     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setClock(const timeval* time);
+    /**
+     * This system call returns the current system clock in timeval format.
+     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+     * microseconds since an OS-defined epoch.
+     * @param time	A pointer to a timeval struct where the current time is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_timeval(timeval* time);
 
-	/**
-	 * Get the time since boot in a timeval struct
-	 *
-	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
-	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 *
-	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-	 */
-	static ReturnValue_t getUptime(timeval* uptime);
+    /**
+     * Get the time since boot in a timeval struct
+     *
+     * @param[out] time A pointer to a timeval struct where the uptime is stored.
+     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+     *
+     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+     */
+    static ReturnValue_t getUptime(timeval* uptime);
 
-	static timeval getUptime();
+    static timeval getUptime();
 
-	/**
-	 * Get the time since boot in milliseconds
-	 *
-	 * This value can overflow! Still, it can be used to calculate time intervalls
-	 * between two calls up to 49 days by always using uint32_t in the calculation
-	 *
-	 * @param ms uptime in ms
-	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getUptime(uint32_t* uptimeMs);
+    /**
+     * Get the time since boot in milliseconds
+     *
+     * This value can overflow! Still, it can be used to calculate time intervalls
+     * between two calls up to 49 days by always using uint32_t in the calculation
+     *
+     * @param ms uptime in ms
+     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-	/**
-	 * Returns the time in microseconds since an OS-defined epoch.
-	 * The time is returned in a 64 bit unsigned integer.
-	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getClock_usecs(uint64_t* time);
-	/**
-	 * Returns the time in a TimeOfDay_t struct.
-	 * @param time A pointer to a TimeOfDay_t struct.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+    /**
+     * Returns the time in microseconds since an OS-defined epoch.
+     * The time is returned in a 64 bit unsigned integer.
+     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getClock_usecs(uint64_t* time);
+    /**
+     * Returns the time in a TimeOfDay_t struct.
+     * @param time A pointer to a TimeOfDay_t struct.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-	/**
-	 * Converts a time of day struct to POSIX seconds.
-	 * @param time The time of day as input
-	 * @param timeval The corresponding seconds since the epoch.
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-			timeval* to);
+    /**
+     * Converts a time of day struct to POSIX seconds.
+     * @param time The time of day as input
+     * @param timeval The corresponding seconds since the epoch.
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+            timeval* to);
 
-	/**
-	 * Converts a time represented as seconds and subseconds since unix
-	 * epoch to days since J2000
-	 *
-	 * @param time seconds since unix epoch
-	 * @param[out] JD2000 days since J2000
-	 * @return @c RETURN_OK
-	 */
-	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+    /**
+     * Converts a time represented as seconds and subseconds since unix
+     * epoch to days since J2000
+     *
+     * @param time seconds since unix epoch
+     * @param[out] JD2000 days since J2000
+     * @return @c RETURN_OK
+     */
+    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-	/**
-	 * Calculates and adds the offset between UTC and TT
-	 *
-	 * Depends on the leap seconds to be set correctly.
-	 *
-	 * @param utc timeval, corresponding to UTC time
-	 * @param[out] tt timeval, corresponding to Terrestial Time
-	 * @return
-	 *  - @c RETURN_OK on success
-	 *  - @c RETURN_FAILED if leapSeconds are not set
-	 */
-	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+    /**
+     * Calculates and adds the offset between UTC and TT
+     *
+     * Depends on the leap seconds to be set correctly.
+     *
+     * @param utc timeval, corresponding to UTC time
+     * @param[out] tt timeval, corresponding to Terrestial Time
+     * @return
+     *  - @c RETURN_OK on success
+     *  - @c RETURN_FAILED if leapSeconds are not set
+     */
+    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-	/**
-	 * Set the Leap Seconds since 1972
-	 *
-	 * @param leapSeconds_
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+    /**
+     * Set the Leap Seconds since 1972
+     *
+     * @param leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-	/**
-	 * Get the Leap Seconds since 1972
-	 *
-	 * Must be set before!
-	 *
-	 * @param[out] leapSeconds_
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+    /**
+     * Get the Leap Seconds since 1972
+     *
+     * Must be set before!
+     *
+     * @param[out] leapSeconds_
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise, the OS failure code is returned.
+     */
+    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-	/**
-	 * Function to check and create the Mutex for the clock
-	 * @return
-	 *  - @c RETURN_OK on success.
-	 *  - Otherwise @c RETURN_FAILED if not able to create one
-	 */
-	static ReturnValue_t checkOrCreateClockMutex();
+    /**
+     * Function to check and create the Mutex for the clock
+     * @return
+     *  - @c RETURN_OK on success.
+     *  - Otherwise @c RETURN_FAILED if not able to create one
+     */
+    static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-	static MutexIF* timeMutex;
-	static uint16_t leapSeconds;
+    static MutexIF* timeMutex;
+    static uint16_t leapSeconds;
 };
 
 

From 30947d3901ef412f860b4758e66e9c77cd79afdb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:08:40 +0100
Subject: [PATCH 0972/1292] size_t changes

---
 tmstorage/TmStorePackets.h | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 4ce64fe6..0312a998 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -49,7 +49,7 @@ public:
 	}
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
 				buffer, size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -139,8 +139,9 @@ public:
 	static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime <= *cmpTime){
 				return true;
 			}
@@ -151,8 +152,9 @@ public:
 	static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime){
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
-			uint32_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			size_t foundlen = 0;
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime >= *cmpTime){
 				return true;
 			}
@@ -204,8 +206,9 @@ public:
 
 	timeval getTime() const {
 		timeval packetTime = {0,0};
-		uint32_t foundlen = 0;
-		CCSDSTime::convertFromCcsds(&packetTime,&this->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+		size_t foundlen = 0;
+		CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0],
+		        &foundlen, sizeof(rawTimestamp));
 		return packetTime;
 	}
 
@@ -258,7 +261,7 @@ public:
 	};
 
 	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) {
+	Endianness streamEndianness) {
 		ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
 				size, streamEndianness);
 		if (result != HasReturnvaluesIF::RETURN_OK) {

From 5908f99f0b352ef41db992708888c6c2e64bcde8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 17:09:33 +0100
Subject: [PATCH 0973/1292] size t changes

---
 tmtcpacket/pus/TmPacketBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index f3bc3f00..2c8bfd63 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -74,7 +74,7 @@ bool TmPacketBase::checkAndSetStamper() {
 }
 
 ReturnValue_t TmPacketBase::getPacketTime(timeval* timestamp) const {
-	uint32_t tempSize = 0;
+	size_t tempSize = 0;
 	return CCSDSTime::convertFromCcsds(timestamp, tmData->data_field.time,
 			&tempSize, sizeof(tmData->data_field.time));
 }

From c69681b402ea3523cc16cb45799715045d14b13a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:22:26 +0100
Subject: [PATCH 0974/1292] time stamper

---
 datapoollocal/LocalDataPoolManager.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 5e45dec1..b32177dc 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
@@ -207,8 +208,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
              // prepare and send update snapshot.
              CommandMessage notification;
              // todo: serialize into store with timestamp.
-
-             // HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
+             //TimeStamperIF* timeStamper = objectManager->
+             //        get<TimeStamperIF>(objects::TIME_STAMPER)
+             //HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
              //        owner->getDataSetHandle(receiver.dataId.sid));
              store_address_t storeId;
              HousekeepingMessage::setUpdateSnapshotSetCommand(

From d87f78f5c3576d4d3f27f206690047c1783da1b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:25:14 +0100
Subject: [PATCH 0975/1292] timer stamper in fsfw now

---
 objectmanager/frameworkObjects.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/objectmanager/frameworkObjects.h b/objectmanager/frameworkObjects.h
index 57783286..8f8e93af 100644
--- a/objectmanager/frameworkObjects.h
+++ b/objectmanager/frameworkObjects.h
@@ -22,6 +22,7 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+	TIME_STAMPER = 0x53500010,
 
 	NO_OBJECT = 0xFFFFFFFF
 };

From e9aecdac26b83e8548ca03b04ff4d1660e33de78 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 22:58:09 +0100
Subject: [PATCH 0976/1292] sth with eclipse indentiation

---
 datapoollocal/LocalDataPoolManager.cpp | 575 +++++++++++++------------
 datapoollocal/LocalPoolDataSetBase.cpp |  82 ++--
 2 files changed, 341 insertions(+), 316 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b32177dc..440afa23 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/timemanager/CCSDSTime.h>
 #include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
@@ -16,11 +17,11 @@
 #include <cmath>
 
 object_id_t LocalDataPoolManager::defaultHkDestination =
-		objects::PUS_SERVICE_3_HOUSEKEEPING;
+        objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
-        appendValidityBuffer(appendValidityBuffer) {
+                        appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
@@ -63,7 +64,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
         }
         else {
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                   << "Default HK destination object is invalid!" << std::endl;
+                    << "Default HK destination object is invalid!" << std::endl;
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
@@ -78,17 +79,17 @@ ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-		        *this);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-	sif::warning << "HousekeepingManager: The map should only be initialized "
-	        << "once!" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
+    if(not mapInitialized) {
+        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+                *this);
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            mapInitialized = true;
+        }
+        return result;
+    }
+    sif::warning << "HousekeepingManager: The map should only be initialized "
+            << "once!" << std::endl;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
@@ -125,7 +126,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() {
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-            ReturnValue_t& status) {
+        ReturnValue_t& status) {
     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
         // Update packets shall only be generated from datasets.
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -135,7 +136,7 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
     if(dataSet->hasChanged()) {
         // prepare and send update notification
         ReturnValue_t result = generateHousekeepingPacket(
-                    receiver.dataId.sid, dataSet, true);
+                receiver.dataId.sid, dataSet, true);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             status = result;
         }
@@ -197,58 +198,80 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         HkReceiver& receiver, ReturnValue_t& status) {
     MarkChangedIF* toReset = nullptr;
-     // check whether data has changed and send messages in case it has.
-     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                 receiver.dataId.localPoolId);
-         if(poolObj == nullptr) {
-             return HasReturnvaluesIF::RETURN_FAILED;
-         }
-         if(poolObj->hasChanged()) {
-             // prepare and send update snapshot.
-             CommandMessage notification;
-             // todo: serialize into store with timestamp.
-             //TimeStamperIF* timeStamper = objectManager->
-             //        get<TimeStamperIF>(objects::TIME_STAMPER)
-             //HousekeepingPacketUpdate updatePacket(timeStamp, timeStampSize,
-             //        owner->getDataSetHandle(receiver.dataId.sid));
-             store_address_t storeId;
-             HousekeepingMessage::setUpdateSnapshotSetCommand(
-                     &notification, receiver.dataId.sid, storeId);
-             ReturnValue_t result = hkQueue->sendMessage(
-                     receiver.destinationQueue, &notification);
-             if(result != HasReturnvaluesIF::RETURN_OK) {
-                 status = result;
-             }
-             toReset = poolObj;
-         }
-     }
-     else {
-         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                 receiver.dataId.sid);
-         if(dataSet == nullptr) {
-             return HasReturnvaluesIF::RETURN_FAILED;
-         }
-         if(dataSet->hasChanged()) {
-             // prepare and send update snapshot.
-             CommandMessage notification;
-             // todo: serialize into store with timestamp.
-             store_address_t storeId;
-             HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                     &notification, receiver.dataId.localPoolId, storeId);
-             ReturnValue_t result = hkQueue->sendMessage(
-                     receiver.destinationQueue, &notification);
-             if(result != HasReturnvaluesIF::RETURN_OK) {
-                 status = result;
-             }
-             toReset = dataSet;
-         }
-     }
-     if(toReset != nullptr) {
-         handleChangeResetLogic(receiver.dataType,
-                 receiver.dataId, toReset);
-     }
-     return HasReturnvaluesIF::RETURN_OK;
+    // check whether data has changed and send messages in case it has.
+    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId);
+        if(poolObj == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if (not poolObj->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        CommandMessage notification;
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+        size_t updatePacketSize = updatePacket.getSerializedSize();
+
+        store_address_t storeId;
+        uint8_t *storePtr = nullptr;
+        ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+                updatePacket.getSerializedSize(), &storePtr);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        size_t serializedSize = 0;
+        result = updatePacket.serialize(&storePtr, &serializedSize,
+                updatePacketSize, SerializeIF::Endianness::MACHINE);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        HousekeepingMessage::setUpdateSnapshotSetCommand(&notification,
+                receiver.dataId.sid, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue,
+                &notification);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = poolObj;
+    }
+    else {
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+                receiver.dataId.sid);
+        if(dataSet == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+
+        if(not dataSet->hasChanged()) {
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        // prepare and send update snapshot.
+        CommandMessage notification;
+        // todo: serialize into store with timestamp.
+        store_address_t storeId;
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(
+                &notification, receiver.dataId.localPoolId, storeId);
+        ReturnValue_t result = hkQueue->sendMessage(
+                receiver.destinationQueue, &notification);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            status = result;
+        }
+        toReset = dataSet;
+
+    }
+    if(toReset != nullptr) {
+        handleChangeResetLogic(receiver.dataType,
+                receiver.dataId, toReset);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
@@ -295,32 +318,32 @@ void LocalDataPoolManager::resetHkUpdateResetHelper() {
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-		bool enableReporting, float collectionInterval, bool isDiagnostics,
-		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-	if(hkReceiverObject == nullptr) {
-		sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-				<< " Invalid receiver!"<< std::endl;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+        bool enableReporting, float collectionInterval, bool isDiagnostics,
+        object_id_t packetDestination) {
+    AcceptsHkPacketsIF* hkReceiverObject =
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+    if(hkReceiverObject == nullptr) {
+        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
+                << " Invalid receiver!"<< std::endl;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.sid = sid;
-	hkReceiver.reportingType = ReportingType::PERIODIC;
-	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+    struct HkReceiver hkReceiver;
+    hkReceiver.dataId.sid = sid;
+    hkReceiver.reportingType = ReportingType::PERIODIC;
+    hkReceiver.dataType = DataType::DATA_SET;
+    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setDiagnostic(isDiagnostics);
-		dataSet->initializePeriodicHelper(collectionInterval,
-				owner->getPeriodicOperationFrequency(), isDiagnostics);
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet != nullptr) {
+        dataSet->setReportingEnabled(enableReporting);
+        dataSet->setDiagnostic(isDiagnostics);
+        dataSet->initializePeriodicHelper(collectionInterval,
+                owner->getPeriodicOperationFrequency(), isDiagnostics);
+    }
 
-	hkReceiversMap.push_back(hkReceiver);
-	return HasReturnvaluesIF::RETURN_OK;
+    hkReceiversMap.push_back(hkReceiver);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -328,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
         bool isDiagnostics, bool reportingEnabled,
         object_id_t packetDestination) {
     AcceptsHkPacketsIF* hkReceiverObject =
-                objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
@@ -432,64 +455,64 @@ void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
+        CommandMessage* message) {
     Command_t command = message->getCommand();
     sid_t sid = HousekeepingMessage::getSid(message);
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     switch(command) {
     // Houskeeping interface handling.
     case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, true);
-    	break;
+        result = togglePeriodicGeneration(sid, true, true);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, true);
-    	break;
+        result = togglePeriodicGeneration(sid, false, true);
+        break;
     }
 
     case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, true, false);
-    	break;
+        result = togglePeriodicGeneration(sid, true, false);
+        break;
     }
 
     case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-    	result = togglePeriodicGeneration(sid, false, false);
-    	break;
+        result = togglePeriodicGeneration(sid, false, false);
+        break;
     }
 
     case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, true);
+                        return generateSetStructurePacket(sid, true);
     case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-        return generateSetStructurePacket(sid, false);
+                        return generateSetStructurePacket(sid, false);
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-    	float newCollIntvl = 0;
-    	HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-    			&newCollIntvl);
-    	if(command == HousekeepingMessage::
-    			MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-    		result = changeCollectionInterval(sid, newCollIntvl, true);
-    	}
-    	else {
-    		result = changeCollectionInterval(sid, newCollIntvl, false);
-    	}
-    	break;
+        float newCollIntvl = 0;
+        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+                &newCollIntvl);
+        if(command == HousekeepingMessage::
+                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+            result = changeCollectionInterval(sid, newCollIntvl, true);
+        }
+        else {
+            result = changeCollectionInterval(sid, newCollIntvl, false);
+        }
+        break;
     }
 
     case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
     case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-    	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    	if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-    			and dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-    			and not dataSet->isDiagnostics()) {
-    		return WRONG_HK_PACKET_TYPE;
-    	}
-    	return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-    			dataSet, true);
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+                and dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+                and not dataSet->isDiagnostics()) {
+            return WRONG_HK_PACKET_TYPE;
+        }
+        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+                dataSet, true);
     }
 
     // Notification handling.
@@ -522,30 +545,30 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
     }
 
     CommandMessage reply;
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-	}
-	else {
-		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-	}
-	hkQueue->sendMessage(hkDestinationId, &reply);
-	return result;
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+    }
+    else {
+        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+    }
+    hkQueue->sendMessage(hkDestinationId, &reply);
+    return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		sif::debug << "HousekeepingManager::fechPoolEntry:"
-				<< " Pool entry not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
+        lp_id_t localPoolId) {
+    auto poolIter = localPoolMap.find(localPoolId);
+    if (poolIter == localPoolMap.end()) {
+        sif::debug << "HousekeepingManager::fechPoolEntry:"
+                << " Pool entry not found." << std::endl;
+        return POOL_ENTRY_NOT_FOUND;
+    }
+    poolIter->second->print();
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
+    return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
@@ -553,51 +576,51 @@ HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-		LocalPoolDataSetBase* dataSet, bool forDownlink,
-		MessageQueueId_t destination) {
-	if(dataSet == nullptr) {
-		// Configuration error.
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found or dataset not assigned!" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        LocalPoolDataSetBase* dataSet, bool forDownlink,
+        MessageQueueId_t destination) {
+    if(dataSet == nullptr) {
+        // Configuration error.
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found or dataset not assigned!" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSet);
-	size_t serializedSize = 0;
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-			forDownlink, &serializedSize);
-	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-	    return result;
-	}
+    store_address_t storeId;
+    HousekeepingPacketDownlink hkPacket(sid, dataSet);
+    size_t serializedSize = 0;
+    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+            forDownlink, &serializedSize);
+    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+        return result;
+    }
 
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	if(dataSet->isDiagnostics()) {
-		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-	}
-	else {
-		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-	}
+    // and now we set a HK message and send it the HK packet destination.
+    CommandMessage hkMessage;
+    if(dataSet->isDiagnostics()) {
+        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+    }
 
-	if(hkQueue == nullptr) {
-	    return QUEUE_OR_DESTINATION_NOT_SET;
-	}
-	if(destination == MessageQueueIF::NO_QUEUE) {
-	    if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-	        // error, all destinations invalid
-	        return HasReturnvaluesIF::RETURN_FAILED;
-	    }
-	    destination = hkDestinationId;
-	}
+    if(hkQueue == nullptr) {
+        return QUEUE_OR_DESTINATION_NOT_SET;
+    }
+    if(destination == MessageQueueIF::NO_QUEUE) {
+        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+            // error, all destinations invalid
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        destination = hkDestinationId;
+    }
 
-	return hkQueue->sendMessage(destination, &hkMessage);
+    return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
         HousekeepingPacketDownlink& hkPacket,
         store_address_t& storeId, bool forDownlink,
-		size_t* serializedSize) {
+        size_t* serializedSize) {
     uint8_t* dataPtr = nullptr;
     const size_t maxSize = hkPacket.getSerializedSize();
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
@@ -607,8 +630,8 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
     }
 
     if(forDownlink) {
-    	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-    	            SerializeIF::Endianness::BIG);
+        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+                SerializeIF::Endianness::BIG);
     }
     return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
             SerializeIF::Endianness::MACHINE);
@@ -620,124 +643,124 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-	sid_t sid = receiver.dataId.sid;
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(not dataSet->getReportingEnabled()) {
-		return;
-	}
+    sid_t sid = receiver.dataId.sid;
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(not dataSet->getReportingEnabled()) {
+        return;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// Configuration error.
-		return;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // Configuration error.
+        return;
+    }
 
-	if(not dataSet->periodicHelper->checkOpNecessary()) {
-		return;
-	}
+    if(not dataSet->periodicHelper->checkOpNecessary()) {
+        return;
+    }
 
-	ReturnValue_t result = generateHousekeepingPacket(
-			sid, dataSet, true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// configuration error
-		sif::debug << "LocalDataPoolManager::performHkOperation:"
-				<< "0x" << std::hex << std::setfill('0') << std::setw(8)
-				<< owner->getObjectId() << " Error generating "
-				<< "HK packet" << std::setfill(' ') << std::dec << std::endl;
-	}
+    ReturnValue_t result = generateHousekeepingPacket(
+            sid, dataSet, true);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        // configuration error
+        sif::debug << "LocalDataPoolManager::performHkOperation:"
+                << "0x" << std::hex << std::setfill('0') << std::setw(8)
+                << owner->getObjectId() << " Error generating "
+                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+    }
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if((dataSet->isDiagnostics() and not isDiagnostics) or
-			(not dataSet->isDiagnostics() and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        bool enable, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if((dataSet->isDiagnostics() and not isDiagnostics) or
+            (not dataSet->isDiagnostics() and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if((dataSet->getReportingEnabled() and enable) or
-			(not dataSet->getReportingEnabled() and not enable)) {
-		return REPORTING_STATUS_UNCHANGED;
-	}
+    if((dataSet->getReportingEnabled() and enable) or
+            (not dataSet->getReportingEnabled() and not enable)) {
+        return REPORTING_STATUS_UNCHANGED;
+    }
 
-	dataSet->setReportingEnabled(enable);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->setReportingEnabled(enable);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+        float newCollectionInterval, bool isDiagnostics) {
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	if(dataSet->periodicHelper == nullptr) {
-		// config error
-		return PERIODIC_HELPER_INVALID;
-	}
+    if(dataSet->periodicHelper == nullptr) {
+        // config error
+        return PERIODIC_HELPER_INVALID;
+    }
 
-	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-	return HasReturnvaluesIF::RETURN_OK;
+    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		bool isDiagnostics) {
+        bool isDiagnostics) {
     // Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet == nullptr) {
-		sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-				<< " Set ID not found" << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet == nullptr) {
+        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
+                << " Set ID not found" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
 
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
+    bool targetIsDiagnostics = dataSet->isDiagnostics();
+    if((targetIsDiagnostics and not isDiagnostics) or
+            (not targetIsDiagnostics and isDiagnostics)) {
+        return WRONG_HK_PACKET_TYPE;
+    }
 
-	bool valid = dataSet->isValid();
-	bool reportingEnabled = dataSet->getReportingEnabled();
-	float collectionInterval =
-			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+    bool valid = dataSet->isValid();
+    bool reportingEnabled = dataSet->getReportingEnabled();
+    float collectionInterval =
+            dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
-	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket(sid,
-			reportingEnabled, valid, collectionInterval, dataSet);
-	size_t expectedSize = setPacket.getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			expectedSize,&storePtr);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-				<< "Could not get free element from IPC store." << std::endl;
-		return result;
-	}
+    // Generate set packet which can be serialized.
+    HousekeepingSetPacket setPacket(sid,
+            reportingEnabled, valid, collectionInterval, dataSet);
+    size_t expectedSize = setPacket.getSerializedSize();
+    uint8_t* storePtr = nullptr;
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            expectedSize,&storePtr);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
+                << "Could not get free element from IPC store." << std::endl;
+        return result;
+    }
 
-	// Serialize set packet into store.
-	size_t size = 0;
-	result = setPacket.serialize(&storePtr, &size, expectedSize,
-			SerializeIF::Endianness::BIG);
-	if(expectedSize != size) {
-		sif::error << "HousekeepingManager::generateSetStructurePacket: "
-				<< "Expected size is not equal to serialized size" << std::endl;
-	}
+    // Serialize set packet into store.
+    size_t size = 0;
+    result = setPacket.serialize(&storePtr, &size, expectedSize,
+            SerializeIF::Endianness::BIG);
+    if(expectedSize != size) {
+        sif::error << "HousekeepingManager::generateSetStructurePacket: "
+                << "Expected size is not equal to serialized size" << std::endl;
+    }
 
-	// Send structure reporting reply.
-	CommandMessage reply;
-	if(isDiagnostics) {
-	    HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-	            sid, storeId);
-	}
-	else {
-	    HousekeepingMessage::setHkStuctureReportReply(&reply,
-	                    sid, storeId);
-	}
+    // Send structure reporting reply.
+    CommandMessage reply;
+    if(isDiagnostics) {
+        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+                sid, storeId);
+    }
+    else {
+        HousekeepingMessage::setHkStuctureReportReply(&reply,
+                sid, storeId);
+    }
 
-	hkQueue->reply(&reply);
-	return result;
+    hkQueue->reply(&reply);
+    return result;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5cd4b62b..6e237c48 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -7,15 +7,15 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool noPeriodicHandling):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(hkOwner == nullptr) {
-		// Configuration error.
-		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				<< "invalid!" << std::endl;
-		return;
-	}
+        uint32_t setId, PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        // Configuration error.
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                << "invalid!" << std::endl;
+        return;
+    }
     hkManager = hkOwner->getHkManagerHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
@@ -24,20 +24,20 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 
     // Data creators get a periodic helper for periodic HK data generation.
     if(not noPeriodicHandling) {
-    	 periodicHelper = new PeriodicHousekeepingHelper(this);
+        periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
-    	// Configuration error.
+        // Configuration error.
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-        		<< "invalid!" << std::endl;
+                << "invalid!" << std::endl;
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -50,8 +50,8 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -97,7 +97,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
     for (uint16_t count = 0; count < fillCount; count++) {
         result = registeredVariables[count]->deSerialize(buffer, size,
-                        streamEndianness);
+                streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
@@ -127,8 +127,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	MutexIF* mutex = hkManager->getMutexHandle();
-	return mutex->unlockMutex();
+    MutexIF* mutex = hkManager->getMutexHandle();
+    return mutex->unlockMutex();
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
@@ -205,7 +205,7 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -213,47 +213,49 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-	this->diagnostic = isDiagnostics;
+    this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-	return diagnostic;
+    return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-	this->reportingEnabled = reportingEnabled;
+    this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-	return reportingEnabled;
+    return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-		float collectionInterval, dur_millis_t minimumPeriodicInterval,
-		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-			isDiagnostics, nonDiagIntervalFactor);
+        float collectionInterval, dur_millis_t minimumPeriodicInterval,
+        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+            isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	this->changed = changed;
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	return changed;
+    // TODO: Make this configurable?
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+    return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-	return sid;
+    return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-		uint8_t position) const {
+        uint8_t position) const {
     if(position > 7) {
         sif::debug << "Pool Raw Access: Bit setting invalid position"
-        		<< std::endl;
+                << std::endl;
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -267,10 +269,10 @@ bool LocalPoolDataSetBase::isValid() const {
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
-	if(setEntriesRecursively) {
-		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-			registeredVariables[idx] -> setValid(valid);
-		}
-	}
-	this->valid = valid;
+    if(setEntriesRecursively) {
+        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+            registeredVariables[idx] -> setValid(valid);
+        }
+    }
+    this->valid = valid;
 }

From 65aecc356590778da5f66939d8bfe0c10226f8bb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:23:05 +0100
Subject: [PATCH 0977/1292] IT IS DONE

---
 datapoollocal/LocalDataPoolManager.cpp  | 59 ++++++++++++++++---------
 datapoollocal/LocalDataPoolManager.h    |  4 +-
 housekeeping/HousekeepingPacketUpdate.h | 35 ++++++++++-----
 3 files changed, 65 insertions(+), 33 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 440afa23..132dc397 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -211,30 +211,24 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         }
 
         // prepare and send update snapshot.
-        CommandMessage notification;
         timeval now;
         Clock::getClock_timeval(&now);
         CCSDSTime::CDS_short cds;
         CCSDSTime::convertToCcsds(&cds, &now);
         HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+                sizeof(cds), owner->getPoolObjectHandle(
+                receiver.dataId.localPoolId));
         size_t updatePacketSize = updatePacket.getSerializedSize();
 
         store_address_t storeId;
-        uint8_t *storePtr = nullptr;
-        ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-                updatePacket.getSerializedSize(), &storePtr);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
-        size_t serializedSize = 0;
-        result = updatePacket.serialize(&storePtr, &serializedSize,
-                updatePacketSize, SerializeIF::Endianness::MACHINE);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-        HousekeepingMessage::setUpdateSnapshotSetCommand(&notification,
-                receiver.dataId.sid, storeId);
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+                receiver.dataId.localPoolId, storeId);
         result = hkQueue->sendMessage(receiver.destinationQueue,
                 &notification);
         if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -254,13 +248,23 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         }
 
         // prepare and send update snapshot.
-        CommandMessage notification;
-        // todo: serialize into store with timestamp.
+        timeval now;
+        Clock::getClock_timeval(&now);
+        CCSDSTime::CDS_short cds;
+        CCSDSTime::convertToCcsds(&cds, &now);
+        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+
         store_address_t storeId;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(
-                &notification, receiver.dataId.localPoolId, storeId);
-        ReturnValue_t result = hkQueue->sendMessage(
-                receiver.destinationQueue, &notification);
+        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+
+        CommandMessage notification;
+        HousekeepingMessage::setUpdateSnapshotSetCommand(
+                &notification, receiver.dataId.sid, storeId);
+        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
         if(result != HasReturnvaluesIF::RETURN_OK) {
             status = result;
         }
@@ -274,6 +278,21 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t LocalDataPoolManager::addUpdateToStore(
+        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+    size_t updatePacketSize = updatePacket.getSerializedSize();
+    uint8_t *storePtr = nullptr;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+            updatePacket.getSerializedSize(), &storePtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t serializedSize = 0;
+    result = updatePacket.serialize(&storePtr, &serializedSize,
+            updatePacketSize, SerializeIF::Endianness::MACHINE);
+    return result;;
+}
+
 void LocalDataPoolManager::handleChangeResetLogic(
         DataType type, DataId dataId, MarkChangedIF* toReset) {
     if(hkUpdateResetList == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index a5cd0f98..f48b14ce 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -21,7 +21,7 @@ void setStaticFrameworkObjectIds();
 }
 
 class LocalDataSetBase;
-
+class HousekeepingPacketUpdate;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -357,6 +357,8 @@ private:
 	        ReturnValue_t& status);
 	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
             ReturnValue_t& status);
+	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
+	        store_address_t& storeId);
 };
 
 
diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 37d38be7..702db55e 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -12,6 +12,7 @@
 class HousekeepingPacketUpdate: public SerializeIF {
 public:
     /**
+     * Update packet constructor for datasets
      * @param timeStamp
      * @param timeStampSize
      * @param hkData
@@ -19,8 +20,19 @@ public:
      */
     HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
             LocalPoolDataSetBase* dataSetPtr):
-            timeStamp(timeStamp), timeStampSize(timeStampSize),
-            dataSetPtr(dataSetPtr) {};
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
+
+    /**
+     * Update packet constructor for pool variables.
+     * @param timeStamp
+     * @param timeStampSize
+     * @param dataSetPtr
+     */
+    HousekeepingPacketUpdate(uint8_t* timeStamp, size_t timeStampSize,
+            LocalPoolObjectBase* dataSetPtr):
+                timeStamp(timeStamp), timeStampSize(timeStampSize),
+                updateData(dataSetPtr) {};
 
     virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
             size_t maxSize, Endianness streamEndianness) const {
@@ -31,18 +43,18 @@ public:
             *size += timeStampSize;
             *buffer += timeStampSize;
         }
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
 
-        return dataSetPtr->serialize(buffer, size, maxSize, streamEndianness);
+        return updateData->serialize(buffer, size, maxSize, streamEndianness);
     }
 
     virtual size_t getSerializedSize() const {
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return 0;
         }
-        return timeStampSize + dataSetPtr->getSerializedSize();
+        return timeStampSize + updateData->getSerializedSize();
     }
 
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
@@ -55,19 +67,18 @@ public:
             *buffer += timeStampSize;
         }
 
-        if(dataSetPtr == nullptr) {
+        if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
-        return dataSetPtr->deSerialize(buffer, size, streamEndianness);
+        return updateData->deSerialize(buffer, size, streamEndianness);
     }
 
 private:
-   uint8_t* timeStamp;
-   size_t timeStampSize;
+   uint8_t* timeStamp = nullptr;
+   size_t timeStampSize = 0;
 
-   LocalPoolDataSetBase* dataSetPtr = nullptr;
+   SerializeIF* updateData = nullptr;
 };
 
 
-
 #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETUPDATE_H_ */

From f72ee0b7acb70dc0e91f7a50884a491ece57a334 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:26:28 +0100
Subject: [PATCH 0978/1292] small bugfix

---
 housekeeping/HousekeepingPacketUpdate.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 702db55e..48fe1bfd 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -63,7 +63,7 @@ public:
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
             std::memcpy(timeStamp, *buffer, timeStampSize);
-            *size += timeStampSize;
+            *size -= timeStampSize;
             *buffer += timeStampSize;
         }
 

From e99cf32bddf33f7c44c14a355ae2c167f2a8a78e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:29:03 +0100
Subject: [PATCH 0979/1292] amazing size checks

---
 housekeeping/HousekeepingPacketUpdate.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/housekeeping/HousekeepingPacketUpdate.h b/housekeeping/HousekeepingPacketUpdate.h
index 48fe1bfd..43ec0619 100644
--- a/housekeeping/HousekeepingPacketUpdate.h
+++ b/housekeeping/HousekeepingPacketUpdate.h
@@ -59,6 +59,10 @@ public:
 
     virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
             SerializeIF::Endianness streamEndianness) override {
+        if(*size < timeStampSize) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
         if(timeStamp != nullptr) {
             /* Endianness will always be MACHINE, so we can simply use memcpy
             here. */
@@ -70,6 +74,10 @@ public:
         if(updateData == nullptr) {
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+        if(*size < updateData->getSerializedSize()) {
+            return SerializeIF::STREAM_TOO_SHORT;
+        }
+
         return updateData->deSerialize(buffer, size, streamEndianness);
     }
 

From cf7385d64ec3f541d69b7fe23ad38ec8b6b0e9bf Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:32:34 +0100
Subject: [PATCH 0980/1292] include fixes

---
 datapoollocal/LocalDataPoolManager.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 132dc397..f649a362 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,5 +1,3 @@
-#include <fsfw/timemanager/CCSDSTime.h>
-#include <fsfw/timemanager/TimeStamperIF.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
@@ -8,10 +6,10 @@
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 
+#include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
 #include "../ipc/QueueFactory.h"
-#include "../objectmanager/frameworkObjects.h"
 
 #include <array>
 #include <cmath>
@@ -218,7 +216,6 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
                 sizeof(cds), owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId));
-        size_t updatePacketSize = updatePacket.getSerializedSize();
 
         store_address_t storeId;
         ReturnValue_t result = addUpdateToStore(updatePacket, storeId);

From 5efbc7496a57ff5549ca381dad521b277c0798ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 3 Nov 2020 23:39:56 +0100
Subject: [PATCH 0981/1292] doc improved, some functions virtual now

---
 datapoollocal/LocalDataPoolManager.h | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index f48b14ce..187ae5d5 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -27,9 +27,16 @@ class HousekeepingPacketUpdate;
  * @brief 		This class is the managing instance for the local data pool.
  * @details
  * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this class as a member and implement
+ * has a local data pool shall have this manager class as a member and implement
  * the HasLocalDataPoolIF.
  *
+ * The manager offers some adaption points and functions which can be used
+ * by the owning class to simplify data handling significantly.
+ *
+ * Please ensure that both initialize and initializeAfterTaskCreation are
+ * called at some point by the owning class in the respective functions of the
+ * same name!
+ *
  * Users of the data pool use the helper classes LocalDataSet,
  * LocalPoolVariable and LocalPoolVector to access pool entries in
  * a thread-safe and efficient way.
@@ -67,14 +74,16 @@ public:
      * initialize() has to be called in any case before using the object!
      * @param owner
      * @param queueToUse
-     * @param appendValidityBuffer
+     * @param appendValidityBuffer Specify whether a buffer containing the
+     * validity state is generated  when serializing or deserializing packets.
      */
 	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 	        bool appendValidityBuffer = true);
 	virtual~ LocalDataPoolManager();
 
 	/**
-	 * Assigns the queue to use.
+	 * Assigns the queue to use. Make sure to call this in the #initialize
+	 * function of the owner.
 	 * @param queueToUse
 	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
 	 * @return
@@ -84,20 +93,24 @@ public:
 	/**
 	 * Initializes the map by calling the map initialization function and
 	 * setting the periodic factor for non-diagnostic packets.
-	 * Don't forget to call this, otherwise the map will be invalid!
+	 * Don't forget to call this in the #initializeAfterTaskCreation call of
+	 * the owner, otherwise the map will be invalid!
 	 * @param nonDiagInvlFactor
 	 * @return
 	 */
-	ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+	ReturnValue_t initializeAfterTaskCreation(
+	        uint8_t nonDiagInvlFactor = 5);
 
     /**
      * @brief   This should be called in the periodic handler of the owner.
      * @details
+     * This in generally called in the #performOperation function of the owner.
      * It performs all the periodic functionalities of the data pool manager,
      * for example generating periodic HK packets.
+     * Marked virtual as an adaption point for custom data pool managers.
      * @return
      */
-    ReturnValue_t performHkOperation();
+    virtual ReturnValue_t performHkOperation();
 
 	/**
 	 * @brief   Subscribe for the generation of periodic packets.
@@ -185,7 +198,7 @@ public:
      * @param message
      * @return
      */
-    ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+    virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
 
 	/**
 	 * Generate a housekeeping packet with a given SID.

From 8d109b7cd0a4955a1289a54cd7d6e9e148ae6650 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 5 Nov 2020 11:57:05 +0100
Subject: [PATCH 0982/1292] preproc define correction

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index acc17b03..182fb72b 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -42,7 +42,7 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {
 		EventMessage message;
 		result = eventReportQueue->receiveMessage(&message);
 		if (result == HasReturnvaluesIF::RETURN_OK) {
-#ifdef FSFW_OBJECTMANAGER_
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 			printEvent(&message);
 #endif
 			notifyListeners(&message);

From 1b2af5285d6269b482f8717902fc811d5781f99e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 5 Nov 2020 13:12:42 +0100
Subject: [PATCH 0983/1292] message queue depth configurable

---
 pus/Service5EventReporting.cpp | 5 +++--
 pus/Service5EventReporting.h   | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 829d04bd..e0b34a5b 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -8,10 +8,11 @@
 
 
 Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
+            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle,
+            uint32_t messageQueueDepth):
 		PusServiceBase(objectId, apid, serviceId),
 		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
+	eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }
 
 Service5EventReporting::~Service5EventReporting(){}
diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h
index 78c18bf3..69242801 100644
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@@ -42,7 +42,8 @@ class Service5EventReporting: public PusServiceBase {
 public:
 
 	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
+	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10,
+	        uint32_t messageQueueDepth = 10);
 	virtual ~Service5EventReporting();
 
 	/***

From aa45d34b4a682c1240f5c4ad8d86bff99f858bae Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Nov 2020 15:20:51 +0100
Subject: [PATCH 0984/1292] include improvements /factory improvement

---
 defaultcfg/config/objects/Factory.cpp | 14 +++++++-------
 events/Event.h                        |  2 +-
 ipc/MessageQueueIF.h                  |  2 +-
 ipc/MessageQueueMessageIF.h           |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/config/objects/Factory.cpp
index 51dd6130..41333b1c 100644
--- a/defaultcfg/config/objects/Factory.cpp
+++ b/defaultcfg/config/objects/Factory.cpp
@@ -11,6 +11,7 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <internalError/InternalErrorReporter.h>
 
 #include <cstdint>
 
@@ -31,15 +32,15 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 }
 
 void Factory::setStaticFrameworkObjectIds() {
-	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
-	PusServiceBase::packetDestination = objects::TM_FUNNEL;
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
-	CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-	CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
 
 	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
 
@@ -48,7 +49,6 @@ void Factory::setStaticFrameworkObjectIds() {
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-	TmPacketStored::timeStamperId = objects::PUS_TIME;
-	//TmFunnel::downlinkDestination = objects::NO_OBJECT;
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
diff --git a/events/Event.h b/events/Event.h
index f5434826..90ff1a90 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
 //could be move to more suitable location
-#include <subsystemIdRanges.h>
+#include <events/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
 typedef uint8_t EventSeverity_t;
diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h
index 44b6f4c0..1c06521c 100644
--- a/ipc/MessageQueueIF.h
+++ b/ipc/MessageQueueIF.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_IPC_MESSAGEQUEUEIF_H_
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
-#include <fsfw/ipc/messageQueueDefinitions.h>
+#include "messageQueueDefinitions.h"
 #include "MessageQueueMessageIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/ipc/MessageQueueMessageIF.h b/ipc/MessageQueueMessageIF.h
index b5a30c08..33e01e7d 100644
--- a/ipc/MessageQueueMessageIF.h
+++ b/ipc/MessageQueueMessageIF.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 #define FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_
 
-#include <fsfw/ipc/messageQueueDefinitions.h>
+#include "messageQueueDefinitions.h"
 #include <cstddef>
 #include <cstdint>
 

From 319ae724785807329a8bf9304e3228604a64fbe9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 8 Nov 2020 15:29:06 +0100
Subject: [PATCH 0985/1292] folder config renamed to fsfwconfig

---
 defaultcfg/{config => fsfwconfig}/FSFWConfig.h                    | 0
 defaultcfg/{config => fsfwconfig}/OBSWConfig.h                    | 0
 defaultcfg/{config => fsfwconfig}/OBSWVersion.h                   | 0
 defaultcfg/{config => fsfwconfig}/config.mk                       | 0
 defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.cpp    | 0
 defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.h      | 0
 defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.cpp   | 0
 defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.h     | 0
 defaultcfg/{config => fsfwconfig}/events/subsystemIdRanges.h      | 0
 defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.cpp     | 0
 defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.h       | 0
 defaultcfg/{config => fsfwconfig}/objects/Factory.cpp             | 0
 defaultcfg/{config => fsfwconfig}/objects/Factory.h               | 0
 defaultcfg/{config => fsfwconfig}/objects/systemObjectList.h      | 0
 defaultcfg/{config => fsfwconfig}/objects/translateObjects.cpp    | 0
 defaultcfg/{config => fsfwconfig}/objects/translateObjects.h      | 0
 .../pollingsequence/PollingSequenceFactory.cpp                    | 0
 .../pollingsequence/PollingSequenceFactory.h                      | 0
 defaultcfg/{config => fsfwconfig}/returnvalues/classIds.h         | 0
 defaultcfg/{config => fsfwconfig}/tmtc/apid.h                     | 0
 defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h                   | 0
 21 files changed, 0 insertions(+), 0 deletions(-)
 rename defaultcfg/{config => fsfwconfig}/FSFWConfig.h (100%)
 rename defaultcfg/{config => fsfwconfig}/OBSWConfig.h (100%)
 rename defaultcfg/{config => fsfwconfig}/OBSWVersion.h (100%)
 rename defaultcfg/{config => fsfwconfig}/config.mk (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/logicalAddresses.h (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/devices/powerSwitcherList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/events/subsystemIdRanges.h (100%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/ipc/missionMessageTypes.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/Factory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/systemObjectList.h (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/translateObjects.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/objects/translateObjects.h (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.cpp (100%)
 rename defaultcfg/{config => fsfwconfig}/pollingsequence/PollingSequenceFactory.h (100%)
 rename defaultcfg/{config => fsfwconfig}/returnvalues/classIds.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/apid.h (100%)
 rename defaultcfg/{config => fsfwconfig}/tmtc/pusIds.h (100%)

diff --git a/defaultcfg/config/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
similarity index 100%
rename from defaultcfg/config/FSFWConfig.h
rename to defaultcfg/fsfwconfig/FSFWConfig.h
diff --git a/defaultcfg/config/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
similarity index 100%
rename from defaultcfg/config/OBSWConfig.h
rename to defaultcfg/fsfwconfig/OBSWConfig.h
diff --git a/defaultcfg/config/OBSWVersion.h b/defaultcfg/fsfwconfig/OBSWVersion.h
similarity index 100%
rename from defaultcfg/config/OBSWVersion.h
rename to defaultcfg/fsfwconfig/OBSWVersion.h
diff --git a/defaultcfg/config/config.mk b/defaultcfg/fsfwconfig/config.mk
similarity index 100%
rename from defaultcfg/config/config.mk
rename to defaultcfg/fsfwconfig/config.mk
diff --git a/defaultcfg/config/devices/logicalAddresses.cpp b/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
similarity index 100%
rename from defaultcfg/config/devices/logicalAddresses.cpp
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
diff --git a/defaultcfg/config/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
similarity index 100%
rename from defaultcfg/config/devices/logicalAddresses.h
rename to defaultcfg/fsfwconfig/devices/logicalAddresses.h
diff --git a/defaultcfg/config/devices/powerSwitcherList.cpp b/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.cpp
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
diff --git a/defaultcfg/config/devices/powerSwitcherList.h b/defaultcfg/fsfwconfig/devices/powerSwitcherList.h
similarity index 100%
rename from defaultcfg/config/devices/powerSwitcherList.h
rename to defaultcfg/fsfwconfig/devices/powerSwitcherList.h
diff --git a/defaultcfg/config/events/subsystemIdRanges.h b/defaultcfg/fsfwconfig/events/subsystemIdRanges.h
similarity index 100%
rename from defaultcfg/config/events/subsystemIdRanges.h
rename to defaultcfg/fsfwconfig/events/subsystemIdRanges.h
diff --git a/defaultcfg/config/ipc/missionMessageTypes.cpp b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
similarity index 100%
rename from defaultcfg/config/ipc/missionMessageTypes.cpp
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
diff --git a/defaultcfg/config/ipc/missionMessageTypes.h b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
similarity index 100%
rename from defaultcfg/config/ipc/missionMessageTypes.h
rename to defaultcfg/fsfwconfig/ipc/missionMessageTypes.h
diff --git a/defaultcfg/config/objects/Factory.cpp b/defaultcfg/fsfwconfig/objects/Factory.cpp
similarity index 100%
rename from defaultcfg/config/objects/Factory.cpp
rename to defaultcfg/fsfwconfig/objects/Factory.cpp
diff --git a/defaultcfg/config/objects/Factory.h b/defaultcfg/fsfwconfig/objects/Factory.h
similarity index 100%
rename from defaultcfg/config/objects/Factory.h
rename to defaultcfg/fsfwconfig/objects/Factory.h
diff --git a/defaultcfg/config/objects/systemObjectList.h b/defaultcfg/fsfwconfig/objects/systemObjectList.h
similarity index 100%
rename from defaultcfg/config/objects/systemObjectList.h
rename to defaultcfg/fsfwconfig/objects/systemObjectList.h
diff --git a/defaultcfg/config/objects/translateObjects.cpp b/defaultcfg/fsfwconfig/objects/translateObjects.cpp
similarity index 100%
rename from defaultcfg/config/objects/translateObjects.cpp
rename to defaultcfg/fsfwconfig/objects/translateObjects.cpp
diff --git a/defaultcfg/config/objects/translateObjects.h b/defaultcfg/fsfwconfig/objects/translateObjects.h
similarity index 100%
rename from defaultcfg/config/objects/translateObjects.h
rename to defaultcfg/fsfwconfig/objects/translateObjects.h
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.cpp
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
diff --git a/defaultcfg/config/pollingsequence/PollingSequenceFactory.h b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
similarity index 100%
rename from defaultcfg/config/pollingsequence/PollingSequenceFactory.h
rename to defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.h
diff --git a/defaultcfg/config/returnvalues/classIds.h b/defaultcfg/fsfwconfig/returnvalues/classIds.h
similarity index 100%
rename from defaultcfg/config/returnvalues/classIds.h
rename to defaultcfg/fsfwconfig/returnvalues/classIds.h
diff --git a/defaultcfg/config/tmtc/apid.h b/defaultcfg/fsfwconfig/tmtc/apid.h
similarity index 100%
rename from defaultcfg/config/tmtc/apid.h
rename to defaultcfg/fsfwconfig/tmtc/apid.h
diff --git a/defaultcfg/config/tmtc/pusIds.h b/defaultcfg/fsfwconfig/tmtc/pusIds.h
similarity index 100%
rename from defaultcfg/config/tmtc/pusIds.h
rename to defaultcfg/fsfwconfig/tmtc/pusIds.h

From 225e65628db70873cc6267cef55e915f65088ad8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 9 Nov 2020 00:12:39 +0100
Subject: [PATCH 0986/1292] include corrections

---
 defaultcfg/fsfwconfig/devices/logicalAddresses.h   | 2 +-
 defaultcfg/fsfwconfig/{config.mk => fsfwconfig.mk} | 0
 defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp  | 3 ++-
 unittest/tests/storagemanager/TestPool.cpp         | 1 -
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename defaultcfg/fsfwconfig/{config.mk => fsfwconfig.mk} (100%)

diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
index 174fa788..e0827ba3 100644
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.h
+++ b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
@@ -1,8 +1,8 @@
 #ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
 #define CONFIG_DEVICES_LOGICALADDRESSES_H_
 
-#include <config/objects/systemObjectList.h>
 #include <fsfw/devicehandlers/CookieIF.h>
+#include "../objects/systemObjectList.h"
 #include <cstdint>
 
 /**
diff --git a/defaultcfg/fsfwconfig/config.mk b/defaultcfg/fsfwconfig/fsfwconfig.mk
similarity index 100%
rename from defaultcfg/fsfwconfig/config.mk
rename to defaultcfg/fsfwconfig/fsfwconfig.mk
diff --git a/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
index e2edbf9c..b41b87ba 100644
--- a/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
+++ b/defaultcfg/fsfwconfig/ipc/missionMessageTypes.cpp
@@ -1,4 +1,5 @@
-#include <config/ipc/MissionMessageTypes.h>
+#include "missionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessageIF.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index 3f5341e9..daeb6bb5 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,6 +1,5 @@
 #include "CatchDefinitions.h"
 
-#include <config/objects/Factory.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
 

From 72f7a1b1b786d97624632d8291a7fb2eaeb26882 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 9 Nov 2020 21:24:23 +0100
Subject: [PATCH 0987/1292] translation files removed

---
 .../fsfwconfig/objects/translateObjects.cpp   | 271 ------------------
 .../fsfwconfig/objects/translateObjects.h     |   9 -
 2 files changed, 280 deletions(-)
 delete mode 100644 defaultcfg/fsfwconfig/objects/translateObjects.cpp
 delete mode 100644 defaultcfg/fsfwconfig/objects/translateObjects.h

diff --git a/defaultcfg/fsfwconfig/objects/translateObjects.cpp b/defaultcfg/fsfwconfig/objects/translateObjects.cpp
deleted file mode 100644
index 73cd02bf..00000000
--- a/defaultcfg/fsfwconfig/objects/translateObjects.cpp
+++ /dev/null
@@ -1,271 +0,0 @@
-/** 
- * @brief	Auto-generated object translation file. Contains 86 translations. 
- * Generated on: 2020-08-25 00:57:14
- **/ 
-#include "translateObjects.h"
-
-const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
-const char *ARDUINO_0_STRING = "ARDUINO_0";
-const char *ARDUINO_1_STRING = "ARDUINO_1";
-const char *ARDUINO_2_STRING = "ARDUINO_2";
-const char *ARDUINO_3_STRING = "ARDUINO_3";
-const char *ARDUINO_4_STRING = "ARDUINO_4";
-const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
-const char *LED_TASK_STRING = "LED_TASK";
-const char *TEST_TASK_STRING = "TEST_TASK";
-const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
-const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
-const char *SuS_ADC1_DEC2_STRING = "SuS_ADC1_DEC2";
-const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
-const char *DLR_PVCH_STRING = "DLR_PVCH";
-const char *GYRO1_STRING = "GYRO1";
-const char *DLR_IRAS_STRING = "DLR_IRAS";
-const char *SPI_Test_PT1000_STRING = "SPI_Test_PT1000";
-const char *PT1000_Syrlinks_DEC1_O1_STRING = "PT1000_Syrlinks_DEC1_O1";
-const char *PT1000_Camera_DEC1_O2_STRING = "PT1000_Camera_DEC1_O2";
-const char *PT1000_SuS1_DEC1_O3_STRING = "PT1000_SuS1_DEC1_O3";
-const char *PT1000_SuS2_DEC1_O4_STRING = "PT1000_SuS2_DEC1_O4";
-const char *PT1000_SuS3_DEC1_O5_STRING = "PT1000_SuS3_DEC1_O5";
-const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
-const char *SPI_Test_Gyro_STRING = "SPI_Test_Gyro";
-const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
-const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
-const char *PT1000_SuS4_DEC2_STRING = "PT1000_SuS4_DEC2";
-const char *PT1000_SuS5_DEC2_STRING = "PT1000_SuS5_DEC2";
-const char *PT1000_SuS6_DEC2_STRING = "PT1000_SuS6_DEC2";
-const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
-const char *PT1000_Iridium_DEC3_STRING = "PT1000_Iridium_DEC3";
-const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
-const char *PT1000_SuS7_DEC3_STRING = "PT1000_SuS7_DEC3";
-const char *PT1000_SuS8_DEC3_STRING = "PT1000_SuS8_DEC3";
-const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
-const char *GYRO2_STRING = "GYRO2";
-const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
-const char *PT1000_SuS9_DEC4_STRING = "PT1000_SuS9_DEC4";
-const char *PT1000_SuS10_DEC4_STRING = "PT1000_SuS10_DEC4";
-const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
-const char *SuS_ADC_DEC4_STRING = "SuS_ADC_DEC4";
-const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
-const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
-const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
-const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
-const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
-const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
-const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
-const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
-const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
-const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
-const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
-const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
-const char *SERIAL_TMTC_BRIDGE_STRING = "SERIAL_TMTC_BRIDGE";
-const char *SERIAL_RING_BUFFER_STRING = "SERIAL_RING_BUFFER";
-const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
-const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
-const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
-const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
-const char *PUS_SERVICE_3_PSB_STRING = "PUS_SERVICE_3_PSB";
-const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
-const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
-const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
-const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
-const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
-const char *PUS_SERVICE_20_STRING = "PUS_SERVICE_20";
-const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
-const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
-const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
-const char *PUS_TIME_STRING = "PUS_TIME";
-const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
-const char *FREERTOS_TASK_MONITOR_STRING = "FREERTOS_TASK_MONITOR";
-const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
-const char *MODE_STORE_STRING = "MODE_STORE";
-const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
-const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
-const char *TC_STORE_STRING = "TC_STORE";
-const char *TM_STORE_STRING = "TM_STORE";
-const char *IPC_STORE_STRING = "IPC_STORE";
-const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
-const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
-const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
-const char *TC_INJECTOR_STRING = "TC_INJECTOR";
-const char *NO_OBJECT_STRING = "NO_OBJECT";
-
-const char* translateObject(object_id_t object){
-	switch((object&0xFFFFFFFF)){
-		case 0x000123336:
-			return AT91_UART2_TEST_TASK_STRING;
-		case 0x01010100:
-			return ARDUINO_0_STRING;
-		case 0x01010101:
-			return ARDUINO_1_STRING;
-		case 0x01010102:
-			return ARDUINO_2_STRING;
-		case 0x01010103:
-			return ARDUINO_3_STRING;
-		case 0x01010104:
-			return ARDUINO_4_STRING;
-		case 0x12345678:
-			return AT91_I2C_TEST_TASK_STRING;
-		case 0x12345777:
-			return LED_TASK_STRING;
-		case 0x42694269:
-			return TEST_TASK_STRING;
-		case 0x44003200:
-			return PCDU_HANDLER_STRING;
-		case 0x4400AFFE:
-			return DUMMY_HANDLER_STRING;
-		case 0x44020108:
-			return SuS_ADC1_DEC2_STRING;
-		case 0x44101F00:
-			return GPS0_HANDLER_STRING;
-		case 0x44104000:
-			return DLR_PVCH_STRING;
-		case 0x44105000:
-			return GYRO1_STRING;
-		case 0x44106000:
-			return DLR_IRAS_STRING;
-		case 0x44115400:
-			return SPI_Test_PT1000_STRING;
-		case 0x44115401:
-			return PT1000_Syrlinks_DEC1_O1_STRING;
-		case 0x44115402:
-			return PT1000_Camera_DEC1_O2_STRING;
-		case 0x44115404:
-			return PT1000_SuS1_DEC1_O3_STRING;
-		case 0x44115405:
-			return PT1000_SuS2_DEC1_O4_STRING;
-		case 0x44115406:
-			return PT1000_SuS3_DEC1_O5_STRING;
-		case 0x44115407:
-			return PT1000_PVHC_DEC1_O6_STRING;
-		case 0x44115500:
-			return SPI_Test_Gyro_STRING;
-		case 0x44125401:
-			return PT1000_CCSDS1_DEC2_STRING;
-		case 0x44125403:
-			return PT1000_MGT1_DEC2_STRING;
-		case 0x44125404:
-			return PT1000_SuS4_DEC2_STRING;
-		case 0x44125405:
-			return PT1000_SuS5_DEC2_STRING;
-		case 0x44125406:
-			return PT1000_SuS6_DEC2_STRING;
-		case 0x44125407:
-			return PT1000_PVCH_DEC2_STRING;
-		case 0x44130301:
-			return PT1000_Iridium_DEC3_STRING;
-		case 0x44130302:
-			return PT1000_CCSDS2_DEC3_STRING;
-		case 0x44130305:
-			return PT1000_SuS7_DEC3_STRING;
-		case 0x44130306:
-			return PT1000_SuS8_DEC3_STRING;
-		case 0x44130307:
-			return PT1000_PVCH_DEC3_STRING;
-		case 0x44130308:
-			return GYRO2_STRING;
-		case 0x44145401:
-			return PT1000_PLOC_DEC4_STRING;
-		case 0x44145404:
-			return PT1000_SuS9_DEC4_STRING;
-		case 0x44145405:
-			return PT1000_SuS10_DEC4_STRING;
-		case 0x44145406:
-			return PT1000_PVHC_DEC4_STRING;
-		case 0x44145407:
-			return SuS_ADC_DEC4_STRING;
-		case 0x44202000:
-			return GPS1_HANDLER_STRING;
-		case 0x49001F00:
-			return DUMMY_GPS_COM_IF_STRING;
-		case 0x49005200:
-			return RS232_DEVICE_COM_IF_STRING;
-		case 0x49005300:
-			return I2C_DEVICE_COM_IF_STRING;
-		case 0x49005400:
-			return GPIO_DEVICE_COM_IF_STRING;
-		case 0x49005410:
-			return SPI_POLLING_TASK_STRING;
-		case 0x49005600:
-			return SPI_DEVICE_COM_IF_STRING;
-		case 0x4900AFFE:
-			return DUMMY_ECHO_COM_IF_STRING;
-		case 0x4D0073AD:
-			return SD_CARD_HANDLER_STRING;
-		case 0x50000100:
-			return CCSDS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000200:
-			return PUS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000300:
-			return UDP_TMTC_BRIDGE_STRING;
-		case 0x50000400:
-			return EMAC_POLLING_TASK_STRING;
-		case 0x50000500:
-			return SERIAL_TMTC_BRIDGE_STRING;
-		case 0x50000550:
-			return SERIAL_RING_BUFFER_STRING;
-		case 0x50000600:
-			return SERIAL_POLLING_TASK_STRING;
-		case 0x51000100:
-			return PUS_SERVICE_1_STRING;
-		case 0x51000200:
-			return PUS_SERVICE_2_STRING;
-		case 0x51000300:
-			return PUS_SERVICE_3_STRING;
-		case 0x51000310:
-			return PUS_SERVICE_3_PSB_STRING;
-		case 0x51000400:
-			return PUS_SERVICE_5_STRING;
-		case 0x51000500:
-			return PUS_SERVICE_6_STRING;
-		case 0x51000800:
-			return PUS_SERVICE_8_STRING;
-		case 0x51000900:
-			return PUS_SERVICE_9_STRING;
-		case 0x51001700:
-			return PUS_SERVICE_17_STRING;
-		case 0x51002000:
-			return PUS_SERVICE_20_STRING;
-		case 0x51002300:
-			return PUS_SERVICE_23_STRING;
-		case 0x51020000:
-			return PUS_SERVICE_200_STRING;
-		case 0x51020100:
-			return PUS_SERVICE_201_STRING;
-		case 0x52000001:
-			return PUS_TIME_STRING;
-		case 0x52000002:
-			return PUS_FUNNEL_STRING;
-		case 0x53000000:
-			return PUS_SERVICE_1_STRING;
-		case 0x53000003:
-			return FREERTOS_TASK_MONITOR_STRING;
-		case 0x53010000:
-			return HEALTH_TABLE_STRING;
-		case 0x53010100:
-			return MODE_STORE_STRING;
-		case 0x53030000:
-			return EVENT_MANAGER_STRING;
-		case 0x53040000:
-			return INTERNAL_ERROR_REPORTER_STRING;
-		case 0x534f0100:
-			return TC_STORE_STRING;
-		case 0x534f0200:
-			return TM_STORE_STRING;
-		case 0x534f0300:
-			return IPC_STORE_STRING;
-		case 0x66666666:
-			return AT91_SPI_TEST_TASK_STRING;
-		case 0x77777777:
-			return STM32_TEST_TASK_STRING;
-		case 0x87654321:
-			return AT91_UART0_TEST_TASK_STRING;
-		case 0x99000001:
-			return TC_INJECTOR_STRING;
-		case 0xFFFFFFFF:
-			return NO_OBJECT_STRING;
-		default:
-			return "UNKNOWN_OBJECT";
-	}
-	return 0;
-}
diff --git a/defaultcfg/fsfwconfig/objects/translateObjects.h b/defaultcfg/fsfwconfig/objects/translateObjects.h
deleted file mode 100644
index 5b656940..00000000
--- a/defaultcfg/fsfwconfig/objects/translateObjects.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-
-const char* translateObject(object_id_t object);
-
-
-#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

From 434709ca9693a68a27b1595d9a86c9472f52a610 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 10 Nov 2020 11:16:56 +0100
Subject: [PATCH 0988/1292] parameter small stuff

---
 parameters/HasParametersIF.h   |  13 ++-
 parameters/ParameterHelper.cpp | 168 ++++++++++++++++-----------------
 2 files changed, 92 insertions(+), 89 deletions(-)

diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h
index c4fd81b3..19c12d81 100644
--- a/parameters/HasParametersIF.h
+++ b/parameters/HasParametersIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_PARAMETERS_HASPARAMETERSIF_H_
 #define FSFW_PARAMETERS_HASPARAMETERSIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ParameterWrapper.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
 
 /**
@@ -20,11 +20,10 @@ using ParameterId_t = uint32_t;
  * ID is the domain ID which can be used to identify unqiue spacecraft domains
  * (e.g. control and sensor domain in the AOCS controller).
  *
- * The second and third byte represent the matrix ID, which can represent
- * a 8-bit row and column number and the last byte...
+ * The second byte is a unique identfier ID.
  *
- * Yeah, is it matrix ID or parameter ID now and is index a 16 bit number
- * of a 8 bit number now?
+ * The third and  fourth byte can be used as a linear index for matrix or array
+ * parameter entries.
  */
 class HasParametersIF {
 public:
@@ -61,6 +60,10 @@ public:
 	virtual ~HasParametersIF() {}
 
 	/**
+	 * This is the generic function overriden by child classes to set
+	 * parameters. To set a parameter, the parameter wrapper is used with
+	 * a variety of set functions. The provided values can be checked with
+	 * newValues.
 	 * Always set parameter before checking newValues!
 	 *
 	 * @param domainId
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index d2193b28..23d1a1f3 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -2,8 +2,8 @@
 #include "ParameterMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
-ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
-		owner(owner) {}
+ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner):
+        owner(owner) {}
 
 ParameterHelper::~ParameterHelper() {
 }
@@ -14,106 +14,106 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch (message->getCommand()) {
-	case ParameterMessage::CMD_PARAMETER_DUMP: {
-		ParameterWrapper description;
-		uint8_t domain = HasParametersIF::getDomain(
-				ParameterMessage::getParameterId(message));
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(message));
-		result = owner->getParameter(domain, uniqueIdentifier,
-				&description, &description, 0);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-			result = sendParameter(message->getSender(),
-					ParameterMessage::getParameterId(message), &description);
-		}
-	}
-		break;
-	case ParameterMessage::CMD_PARAMETER_LOAD: {
-	    ParameterId_t parameterId = 0;
-	    uint8_t ptc = 0;
-	    uint8_t pfc = 0;
-	    uint8_t rows = 0;
-	    uint8_t columns = 0;
-	    store_address_t storeId = ParameterMessage::getParameterLoadCommand(
-	            message, &parameterId, &ptc, &pfc, &rows, &columns);
-	    Type type(Type::getActualType(ptc, pfc));
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    switch (message->getCommand()) {
+    case ParameterMessage::CMD_PARAMETER_DUMP: {
+        ParameterWrapper description;
+        uint8_t domain = HasParametersIF::getDomain(
+                ParameterMessage::getParameterId(message));
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                ParameterMessage::getParameterId(message));
+        result = owner->getParameter(domain, uniqueIdentifier,
+                &description, &description, 0);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
+            result = sendParameter(message->getSender(),
+                    ParameterMessage::getParameterId(message), &description);
+        }
+    }
+    break;
+    case ParameterMessage::CMD_PARAMETER_LOAD: {
+        ParameterId_t parameterId = 0;
+        uint8_t ptc = 0;
+        uint8_t pfc = 0;
+        uint8_t rows = 0;
+        uint8_t columns = 0;
+        store_address_t storeId = ParameterMessage::getParameterLoadCommand(
+                message, &parameterId, &ptc, &pfc, &rows, &columns);
+        Type type(Type::getActualType(ptc, pfc));
 
-		uint8_t domain = HasParametersIF::getDomain(parameterId);
-		uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
-		        parameterId);
-		uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
+        uint8_t domain = HasParametersIF::getDomain(parameterId);
+        uint8_t uniqueIdentifier = HasParametersIF::getUniqueIdentifierId(
+                parameterId);
+        uint16_t linearIndex = HasParametersIF::getIndex(parameterId);
 
-		ConstStorageAccessor accessor(storeId);
-		result = storage->getData(storeId, accessor);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "ParameterHelper::handleParameterMessage: Getting"
-					<< " store data failed for load command." << std::endl;
-			break;
-		}
+        ConstStorageAccessor accessor(storeId);
+        result = storage->getData(storeId, accessor);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            sif::error << "ParameterHelper::handleParameterMessage: Getting"
+                    << " store data failed for load command." << std::endl;
+            break;
+        }
 
-		ParameterWrapper streamWrapper;
-		result = streamWrapper.set(type, rows, columns, accessor.data(),
-		        accessor.size());
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        ParameterWrapper streamWrapper;
+        result = streamWrapper.set(type, rows, columns, accessor.data(),
+                accessor.size());
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
-		ParameterWrapper ownerWrapper;
-		result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
-				&streamWrapper, linearIndex);
+        ParameterWrapper ownerWrapper;
+        result = owner->getParameter(domain, uniqueIdentifier, &ownerWrapper,
+                &streamWrapper, linearIndex);
 
-		result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-		    return result;
-		}
+        result = ownerWrapper.copyFrom(&streamWrapper, linearIndex);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
 
         result = sendParameter(message->getSender(),
                 ParameterMessage::getParameterId(message), &ownerWrapper);
-		break;
-	}
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        break;
+    }
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		rejectCommand(message->getSender(), result, message->getCommand());
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        rejectCommand(message->getSender(), result, message->getCommand());
+    }
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
-		const ParameterWrapper* description) {
-	size_t serializedSize = description->getSerializedSize();
+        const ParameterWrapper* description) {
+    size_t serializedSize = description->getSerializedSize();
 
-	uint8_t *storeElement;
-	store_address_t address;
+    uint8_t *storeElement;
+    store_address_t address;
 
-	ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
-			&storeElement);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
+            &storeElement);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	size_t storeElementSize = 0;
+    size_t storeElementSize = 0;
 
-	result = description->serialize(&storeElement, &storeElementSize,
-			serializedSize, SerializeIF::Endianness::BIG);
+    result = description->serialize(&storeElement, &storeElementSize,
+            serializedSize, SerializeIF::Endianness::BIG);
 
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		storage->deleteData(address);
-		return result;
-	}
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        storage->deleteData(address);
+        return result;
+    }
 
-	CommandMessage reply;
+    CommandMessage reply;
 
-	ParameterMessage::setParameterDumpReply(&reply, id, address);
+    ParameterMessage::setParameterDumpReply(&reply, id, address);
 
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ParameterHelper::initialize() {
@@ -127,8 +127,8 @@ ReturnValue_t ParameterHelper::initialize() {
 }
 
 void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-		Command_t initialCommand) {
-	CommandMessage reply;
-	reply.setReplyRejected(reason, initialCommand);
-	MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
+        Command_t initialCommand) {
+    CommandMessage reply;
+    reply.setReplyRejected(reason, initialCommand);
+    MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
 }

From cb5fa4a2175bc684e21fb885c94a420b97e680a8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 18 Nov 2020 21:15:14 +0100
Subject: [PATCH 0989/1292] monitoring changes

---
 datapoollocal/LocalDataPoolManager.h | 10 +++-----
 monitoring/AbsLimitMonitor.h         |  5 ++--
 monitoring/LimitMonitor.h            | 19 ++++++++------
 monitoring/MonitorBase.h             | 37 +++++++++++++++++-----------
 monitoring/MonitorReporter.h         |  2 ++
 5 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 187ae5d5..38714cc9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,11 +48,9 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T>
-	friend class LocalPoolVar;
-	template<typename T, uint16_t vecSize>
-	friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+	template<typename T> friend class LocalPoolVar;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+    friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
@@ -319,7 +317,7 @@ private:
 	StorageManagerIF* ipcStore = nullptr;
 	/**
 	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * eternally. Use with care and don't forget to unlock locked mutexes!
+	 * externally. Use with care and don't forget to unlock locked mutexes!
 	 * For now, only friend classes can accss this function.
 	 * @return
 	 */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 5891c36a..d85d5b61 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -8,10 +8,11 @@ template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
 	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        uint32_t parameterId, uint16_t confirmationLimit, T limit,
+	        object_id_t dataCreatorId, lp_id_t localPoolId,
+	        uint16_t confirmationLimit, T limit,
 	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
 	        bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, parameterId,
+			MonitorBase<T>(reporterId, monitorId, dataCreatorId, localPoolId,
 			        confirmationLimit),
 			limit(limit), violationEvent(violationEvent),
 			aboveIsViolation(aboveIsViolation) {
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index abcbe8e8..fdb05018 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -12,13 +12,15 @@
 template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
-	LimitMonitor(object_id_t reporterId, uint8_t monitorId, uint32_t parameterId,
+	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
+	        object_id_t creatorId, lp_id_t localPoolId,
 			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
 			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, parameterId, confirmationLimit), lowerLimit(
-					lowerLimit), upperLimit(upperLimit), belowLowEvent(
-					belowLowEvent), aboveHighEvent(aboveHighEvent) {
+			MonitorBase<T>(reporterId, monitorId, creatorId, localPoolId,
+			        confirmationLimit),
+			lowerLimit(lowerLimit), upperLimit(upperLimit),
+			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
 	}
 	virtual ~LimitMonitor() {
 	}
@@ -57,7 +59,8 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	bool isOutOfLimits() {
-		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT || this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
+		if (this->oldState == MonitoringIF::ABOVE_HIGH_LIMIT or
+		        this->oldState == MonitoringIF::BELOW_LOW_LIMIT) {
 			return true;
 		} else {
 			return false;
@@ -76,10 +79,12 @@ protected:
 	void sendTransitionEvent(T currentValue, ReturnValue_t state) {
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
+			        this->parameterId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
-			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent, this->parameterId);
+			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
+			        this->parameterId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 5f9a2caf..df6f1af8 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -6,8 +6,8 @@
 #include "MonitoringMessageContent.h"
 #include "MonitorReporter.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/PIDReader.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+
 
 /**
  * @brief   Base class for monitoring of parameters.
@@ -23,13 +23,18 @@
 template<typename T>
 class MonitorBase: public MonitorReporter<T> {
 public:
+
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-			uint32_t parameterId, uint16_t confirmationLimit) :
-			MonitorReporter<T>(reporterId, monitorId, parameterId,
-			        confirmationLimit) {
+	        object_id_t dataCreatorId, lp_id_t localPoolId,
+	        uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, dataCreatorId,
+	                confirmationLimit),
+	        poolVariable(dataCreatorId, localPoolId) {
 	}
+
 	virtual ~MonitorBase() {
 	}
+
 	virtual ReturnValue_t check() {
 		// 1. Fetch sample of type T, return validity.
 		T sample = 0;
@@ -39,8 +44,8 @@ public:
 		// Report (if oldState is != invalidity).
 		if (validity != HasReturnvaluesIF::RETURN_OK) {
 			this->monitorStateIs(validity, sample, 0);
-			//3. Otherwise, check sample.
 		} else {
+            //3. Otherwise, check sample.
 			this->oldState = doCheck(sample);
 		}
 		return this->oldState;
@@ -55,16 +60,20 @@ public:
 	virtual ReturnValue_t checkSample(T sample, T* crossedLimit) = 0;
 
 protected:
+
 	virtual ReturnValue_t fetchSample(T* sample) {
-		GlobDataSet mySet;
-		PIDReader<T> parameter(this->parameterId, &mySet);
-		mySet.read();
-		if (!parameter.isValid()) {
-			return MonitoringIF::INVALID;
-		}
-		*sample = parameter.value;
-		return HasReturnvaluesIF::RETURN_OK;
+	    ReturnValue_t result = poolVariable.read();
+	    if(result != HasReturnvaluesIF::RETURN_OK) {
+	        return result;
+	    }
+	    if (not poolVariable.isValid()) {
+	        return MonitoringIF::INVALID;
+	    }
+	    *sample = poolVariable.value;
+	    return HasReturnvaluesIF::RETURN_OK;
 	}
+
+	LocalPoolVar<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 286d82cf..d33f34d5 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -15,6 +15,8 @@ public:
 	static const uint8_t ENABLED = 1;
 	static const uint8_t DISABLED = 0;
 
+	// TODO: Adapt to use SID instead of parameter ID.
+
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
 	        uint32_t parameterId, uint16_t confirmationLimit) :
 			monitorId(monitorId), parameterId(parameterId),

From 0d79d4ab030c3b40cf53203a74ff7d7425b24ade Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 18 Nov 2020 21:15:48 +0100
Subject: [PATCH 0990/1292] replaced spaces with tab

---
 datapoollocal/LocalDataPoolManager.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 38714cc9..aca0d4f6 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -50,7 +50,7 @@ class HousekeepingPacketUpdate;
 class LocalDataPoolManager {
 	template<typename T> friend class LocalPoolVar;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-    friend class LocalPoolDataSetBase;
+	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;

From 03fad1cfcd91fad4456188ff18b2bee0d1e0de03 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 19 Nov 2020 00:10:59 +0100
Subject: [PATCH 0991/1292] better naming.. hopefully..

---
 thermal/CoreComponent.h                       |  96 --------------
 thermal/ThermalComponent.cpp                  |  24 ++--
 thermal/ThermalComponent.h                    |  23 ++--
 ...Component.cpp => ThermalComponentCore.cpp} | 110 +++++++++-------
 thermal/ThermalComponentCore.h                | 118 ++++++++++++++++++
 thermal/ThermalComponentIF.h                  |  12 +-
 thermal/ThermalMonitor.h                      |  26 ----
 ...Monitor.cpp => ThermalMonitorReporter.cpp} |  14 ++-
 thermal/ThermalMonitorReporter.h              |  28 +++++
 9 files changed, 252 insertions(+), 199 deletions(-)
 delete mode 100644 thermal/CoreComponent.h
 rename thermal/{CoreComponent.cpp => ThermalComponentCore.cpp} (64%)
 create mode 100644 thermal/ThermalComponentCore.h
 delete mode 100644 thermal/ThermalMonitor.h
 rename thermal/{ThermalMonitor.cpp => ThermalMonitorReporter.cpp} (84%)
 create mode 100644 thermal/ThermalMonitorReporter.h

diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h
deleted file mode 100644
index 8093711d..00000000
--- a/thermal/CoreComponent.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-#define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../thermal/ThermalComponentIF.h"
-#include "../thermal/AbstractTemperatureSensor.h"
-#include "../thermal/ThermalModule.h"
-#include "../thermal/ThermalMonitor.h"
-
-// TODO: Documentaiton, how to use this? only use Thermal Component, which inherits core component?
-class CoreComponent: public ThermalComponentIF {
-public:
-	struct Parameters {
-		float lowerOpLimit;
-		float upperOpLimit;
-		float heaterOn;
-		float hysteresis;
-		float heaterSwitchoff;
-	};
-
-	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
-
-	CoreComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-			uint32_t requestPoolId, GlobDataSet *dataSet,
-			AbstractTemperatureSensor *sensor,
-			AbstractTemperatureSensor *firstRedundantSensor,
-			AbstractTemperatureSensor *secondRedundantSensor,
-			ThermalModuleIF *thermalModule, Parameters parameters,
-			Priority priority, StateRequest initialTargetState =
-					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
-
-	virtual ~CoreComponent();
-
-	virtual HeaterRequest performOperation(uint8_t opCode);
-
-	void markStateIgnored();
-
-	object_id_t getObjectId();
-
-	uint8_t getDomainId() const;
-
-	virtual float getLowerOpLimit();
-
-	ReturnValue_t setTargetState(int8_t newState);
-
-	virtual void setOutputInvalid();
-
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-protected:
-
-	AbstractTemperatureSensor *sensor;
-	AbstractTemperatureSensor *firstRedundantSensor;
-	AbstractTemperatureSensor *secondRedundantSensor;
-	ThermalModuleIF *thermalModule;
-
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
-
-	bool isHeating;
-
-	bool isSafeComponent;
-
-	float minTemp;
-
-	float maxTemp;
-
-	Parameters parameters;
-
-	ThermalMonitor temperatureMonitor;
-
-	const uint8_t domainId;
-
-	virtual float getTemperature();
-	virtual State getState(float temperature, Parameters parameters,
-			int8_t targetState);
-
-	virtual void checkLimits(State state);
-
-	virtual HeaterRequest getHeaterRequest(int8_t targetState,
-			float temperature, Parameters parameters);
-
-	virtual State getIgnoredState(int8_t state);
-
-	void updateMinMaxTemp();
-
-	virtual Parameters getParameters();
-};
-
-#endif /* MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ */
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 6bc09e55..78b14efd 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -9,12 +9,12 @@ ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
 		AbstractTemperatureSensor* secondRedundantSensor,
 		ThermalModuleIF* thermalModule, Parameters parameters,
 		Priority priority) :
-		CoreComponent(reportingObjectId, domainId, temperaturePoolId,
+		ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId,
 				targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
-				sensor, firstRedundantSensor, secondRedundantSensor,
-				thermalModule,{ parameters.lowerOpLimit, parameters.upperOpLimit,
-				parameters.heaterOn, parameters.hysteresis, parameters.heaterSwitchoff },
-				priority, ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
+				{ parameters.lowerOpLimit, parameters.upperOpLimit,
+				parameters.heaterOn, parameters.hysteresis,
+				parameters.heaterSwitchoff },
+				ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
 		nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
 }
 
@@ -36,7 +36,7 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 		mySet.commit(PoolVariableIF::VALID);
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-		return CoreComponent::setTargetState(newState);
+		return ThermalComponentCore::setTargetState(newState);
 	}
 }
 
@@ -57,11 +57,11 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 }
 
 ThermalComponentIF::State ThermalComponent::getState(float temperature,
-		CoreComponent::Parameters parameters, int8_t targetState) {
+		ThermalComponentCore::Parameters parameters, int8_t targetState) {
 	if (temperature < nopParameters.lowerNopLimit) {
 		return OUT_OF_RANGE_LOW;
 	} else {
-		State state = CoreComponent::getState(temperature, parameters,
+		State state = ThermalComponentCore::getState(temperature, parameters,
 				targetState);
 		if (state != NON_OPERATIONAL_HIGH
 				&& state != NON_OPERATIONAL_HIGH_IGNORED) {
@@ -79,7 +79,7 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
 	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-		CoreComponent::checkLimits(state);
+		ThermalComponentCore::checkLimits(state);
 		return;
 	}
 	//If component is not operational, it checks the NOP limits.
@@ -89,7 +89,7 @@ void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
 		int8_t targetState, float temperature,
-		CoreComponent::Parameters parameters) {
+		ThermalComponentCore::Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
 		return HEATER_DONT_CARE;
@@ -142,14 +142,14 @@ ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
 	case OUT_OF_RANGE_HIGH_IGNORED:
 		return OUT_OF_RANGE_HIGH_IGNORED;
 	default:
-		return CoreComponent::getIgnoredState(state);
+		return ThermalComponentCore::getIgnoredState(state);
 	}
 }
 
 ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = CoreComponent::getParameter(domainId, parameterId,
+	ReturnValue_t result = ThermalComponentCore::getParameter(domainId, parameterId,
 			parameterWrapper, newValues, startAtIndex);
 	if (result != INVALID_IDENTIFIER_ID) {
 		return result;
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index 195f03b1..d61ff01e 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -1,12 +1,14 @@
-#ifndef THERMALCOMPONENT_H_
-#define THERMALCOMPONENT_H_
+#ifndef FSFW_THERMAL_THERMALCOMPONENT_H_
+#define FSFW_THERMAL_THERMALCOMPONENT_H_
 
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
 /**
- * What is it. How to use
+ * @brief
+ * @details
+ * Some more documentation.
  */
-class ThermalComponent: public CoreComponent {
+class ThermalComponent: public ThermalComponentCore {
 public:
 	struct Parameters {
 		float lowerNopLimit;
@@ -42,8 +44,9 @@ public:
 	 * @param parameters
 	 * @param priority
 	 */
-	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, uint32_t temperaturePoolId,
-			uint32_t targetStatePoolId, uint32_t currentStatePoolId, uint32_t requestPoolId,
+	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
+	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
+	        uint32_t currentStatePoolId, uint32_t requestPoolId,
 			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
@@ -63,15 +66,15 @@ protected:
 
 	NopParameters nopParameters;
 
-	State getState(float temperature, CoreComponent::Parameters parameters,
+	State getState(float temperature, ThermalComponentCore::Parameters parameters,
 			int8_t targetState);
 
 	virtual void checkLimits(State state);
 
 	virtual HeaterRequest getHeaterRequest(int8_t targetState, float temperature,
-			CoreComponent::Parameters parameters);
+			ThermalComponentCore::Parameters parameters);
 
 	State getIgnoredState(int8_t state);
 };
 
-#endif /* THERMALCOMPONENT_H_ */
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_H_ */
diff --git a/thermal/CoreComponent.cpp b/thermal/ThermalComponentCore.cpp
similarity index 64%
rename from thermal/CoreComponent.cpp
rename to thermal/ThermalComponentCore.cpp
index 90d10eda..bf28f307 100644
--- a/thermal/CoreComponent.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,28 +1,19 @@
-#include "CoreComponent.h"
+#include "ThermalComponentCore.h"
 
-CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
-		uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId, GlobDataSet* dataSet,
-		AbstractTemperatureSensor* sensor,
-		AbstractTemperatureSensor* firstRedundantSensor,
-		AbstractTemperatureSensor* secondRedundantSensor,
-		ThermalModuleIF* thermalModule, Parameters parameters,
-		Priority priority, StateRequest initialTargetState) :
-		sensor(sensor), firstRedundantSensor(firstRedundantSensor), secondRedundantSensor(
-				secondRedundantSensor), thermalModule(thermalModule), temperature(
-				temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), heaterRequest(
-				requestPoolId, dataSet, PoolVariableIF::VAR_WRITE), isHeating(
-		false), isSafeComponent(priority == SAFE), minTemp(999), maxTemp(
-				AbstractTemperatureSensor::ZERO_KELVIN_C), parameters(
-				parameters), temperatureMonitor(reportingObjectId,
-				domainId + 1,
-				GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
+        uint8_t domainId, uint32_t temperaturePoolId,
+        uint32_t targetStatePoolId,
+		uint32_t currentStatePoolId, uint32_t requestPoolId,
+		GlobDataSet* dataSet, Parameters parameters,
+		StateRequest initialTargetState) :
+		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		parameters(parameters),
+		temperatureMonitor(reportingObjectId, domainId + 1,
+		        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
 				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
-	if (thermalModule != NULL) {
-		thermalModule->registerComponent(this, priority);
-	}
 	//Set thermal state once, then leave to operator.
 	GlobDataSet mySet;
 	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
@@ -31,10 +22,39 @@ CoreComponent::CoreComponent(object_id_t reportingObjectId, uint8_t domainId,
 	mySet.commit(PoolVariableIF::VALID);
 }
 
-CoreComponent::~CoreComponent() {
+void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
+    this->sensor = sensor;
 }
 
-ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode) {
+void ThermalComponentCore::addFirstRedundantSensor(
+        AbstractTemperatureSensor *firstRedundantSensor) {
+    this->firstRedundantSensor = firstRedundantSensor;
+}
+
+void ThermalComponentCore::addSecondRedundantSensor(
+        AbstractTemperatureSensor *secondRedundantSensor) {
+    this->secondRedundantSensor = secondRedundantSensor;
+}
+
+void ThermalComponentCore::addThermalModule(ThermalModule *thermalModule,
+        Priority priority) {
+    this->thermalModule = thermalModule;
+    if(thermalModule != nullptr) {
+        thermalModule->registerComponent(this, priority);
+    }
+}
+
+void ThermalComponentCore::setPriority(Priority priority) {
+    if(priority == SAFE) {
+        this->isSafeComponent = true;
+    }
+}
+
+ThermalComponentCore::~ThermalComponentCore() {
+}
+
+ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
+        uint8_t opCode) {
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
@@ -57,19 +77,21 @@ ThermalComponentIF::HeaterRequest CoreComponent::performOperation(uint8_t opCode
 	return request;
 }
 
-void CoreComponent::markStateIgnored() {
+void ThermalComponentCore::markStateIgnored() {
 	currentState = getIgnoredState(currentState);
 }
 
-object_id_t CoreComponent::getObjectId() {
+object_id_t ThermalComponentCore::getObjectId() {
 	return temperatureMonitor.getReporterId();
 }
 
-float CoreComponent::getLowerOpLimit() {
+float ThermalComponentCore::getLowerOpLimit() {
 	return parameters.lowerOpLimit;
 }
 
-ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
+
+
+ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
 	GlobDataSet mySet;
 	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
 			&mySet, PoolVariableIF::VAR_READ_WRITE);
@@ -92,7 +114,7 @@ ReturnValue_t CoreComponent::setTargetState(int8_t newState) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void CoreComponent::setOutputInvalid() {
+void ThermalComponentCore::setOutputInvalid() {
 	temperature = INVALID_TEMPERATURE;
 	temperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
@@ -101,20 +123,22 @@ void CoreComponent::setOutputInvalid() {
 	temperatureMonitor.setToUnchecked();
 }
 
-float CoreComponent::getTemperature() {
-	if ((sensor != NULL) && (sensor->isValid())) {
+float ThermalComponentCore::getTemperature() {
+	if ((sensor != nullptr) && (sensor->isValid())) {
 		return sensor->getTemperature();
 	}
 
-	if ((firstRedundantSensor != NULL) && (firstRedundantSensor->isValid())) {
+	if ((firstRedundantSensor != nullptr) &&
+	        (firstRedundantSensor->isValid())) {
 		return firstRedundantSensor->getTemperature();
 	}
 
-	if ((secondRedundantSensor != NULL) && (secondRedundantSensor->isValid())) {
+	if ((secondRedundantSensor != nullptr) &&
+	        (secondRedundantSensor->isValid())) {
 		return secondRedundantSensor->getTemperature();
 	}
 
-	if (thermalModule != NULL) {
+	if (thermalModule != nullptr) {
 		float temperature = thermalModule->getTemperature();
 		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
 			return temperature;
@@ -126,7 +150,7 @@ float CoreComponent::getTemperature() {
 	}
 }
 
-ThermalComponentIF::State CoreComponent::getState(float temperature,
+ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 		Parameters parameters, int8_t targetState) {
 	ThermalComponentIF::State state;
 
@@ -144,14 +168,14 @@ ThermalComponentIF::State CoreComponent::getState(float temperature,
 	return state;
 }
 
-void CoreComponent::checkLimits(ThermalComponentIF::State state) {
+void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
 	temperatureMonitor.translateState(state, temperature.value,
 			getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
-ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
+ThermalComponentIF::HeaterRequest ThermalComponentCore::getHeaterRequest(
 		int8_t targetState, float temperature, Parameters parameters) {
 	if (targetState == STATE_REQUEST_IGNORE) {
 		isHeating = false;
@@ -177,7 +201,7 @@ ThermalComponentIF::HeaterRequest CoreComponent::getHeaterRequest(
 	return HEATER_DONT_CARE;
 }
 
-ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
+ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	switch (state) {
 	case NON_OPERATIONAL_LOW:
 		return NON_OPERATIONAL_LOW_IGNORED;
@@ -197,7 +221,7 @@ ThermalComponentIF::State CoreComponent::getIgnoredState(int8_t state) {
 	}
 }
 
-void CoreComponent::updateMinMaxTemp() {
+void ThermalComponentCore::updateMinMaxTemp() {
 	if (temperature == INVALID_TEMPERATURE) {
 		return;
 	}
@@ -209,15 +233,15 @@ void CoreComponent::updateMinMaxTemp() {
 	}
 }
 
-uint8_t CoreComponent::getDomainId() const {
+uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
 }
 
-CoreComponent::Parameters CoreComponent::getParameters() {
+ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 	return parameters;
 }
 
-ReturnValue_t CoreComponent::getParameter(uint8_t domainId,
+ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
 	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
new file mode 100644
index 00000000..2d08ed1d
--- /dev/null
+++ b/thermal/ThermalComponentCore.h
@@ -0,0 +1,118 @@
+#ifndef FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+#define FSFW_THERMAL_THERMALCOMPONENTCORE_H_
+
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+#include "AbstractTemperatureSensor.h"
+#include "ThermalModule.h"
+
+#include "../datapoolglob/GlobalDataSet.h"
+#include "../datapoolglob/GlobalPoolVariable.h"
+
+/**
+ * @brief
+ * @details
+ */
+class ThermalComponentCore: public ThermalComponentIF {
+public:
+	struct Parameters {
+		float lowerOpLimit;
+		float upperOpLimit;
+		float heaterOn;
+		float hysteresis;
+		float heaterSwitchoff;
+	};
+
+	static const uint16_t COMPONENT_TEMP_CONFIRMATION = 5;
+
+	/**
+	 * Some documentation
+	 * @param reportingObjectId
+	 * @param domainId
+	 * @param temperaturePoolId
+	 * @param targetStatePoolId
+	 * @param currentStatePoolId
+	 * @param requestPoolId
+	 * @param dataSet
+	 * @param parameters
+	 * @param initialTargetState
+	 */
+	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
+	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
+	        uint32_t currentStatePoolId, uint32_t requestPoolId,
+	        GlobDataSet *dataSet, Parameters parameters,
+			StateRequest initialTargetState =
+					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
+
+	void addSensor(AbstractTemperatureSensor* firstRedundantSensor);
+	void addFirstRedundantSensor(
+	        AbstractTemperatureSensor* firstRedundantSensor);
+    void addSecondRedundantSensor(
+            AbstractTemperatureSensor* secondRedundantSensor);
+    void addThermalModule(ThermalModule* thermalModule, Priority priority);
+
+    void setPriority(Priority priority);
+
+	virtual ~ThermalComponentCore();
+
+	virtual HeaterRequest performOperation(uint8_t opCode);
+
+	void markStateIgnored();
+
+	object_id_t getObjectId();
+
+	uint8_t getDomainId() const;
+
+	virtual float getLowerOpLimit();
+
+	ReturnValue_t setTargetState(int8_t newState);
+
+	virtual void setOutputInvalid();
+
+	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+			ParameterWrapper *parameterWrapper,
+			const ParameterWrapper *newValues, uint16_t startAtIndex);
+
+protected:
+
+	AbstractTemperatureSensor *sensor = nullptr;
+	AbstractTemperatureSensor *firstRedundantSensor = nullptr;
+	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
+	ThermalModuleIF *thermalModule = nullptr;
+
+	gp_float_t temperature;
+	gp_int8_t targetState;
+	gp_int8_t currentState;
+	gp_uint8_t heaterRequest;
+
+	bool isHeating = false;
+
+	bool isSafeComponent = false;
+
+	float minTemp = 999;
+
+	float maxTemp = AbstractTemperatureSensor::ZERO_KELVIN_C;
+
+	Parameters parameters;
+
+	ThermalMonitorReporter temperatureMonitor;
+
+	const uint8_t domainId;
+
+	virtual float getTemperature();
+	virtual State getState(float temperature, Parameters parameters,
+			int8_t targetState);
+
+	virtual void checkLimits(State state);
+
+	virtual HeaterRequest getHeaterRequest(int8_t targetState,
+			float temperature, Parameters parameters);
+
+	virtual State getIgnoredState(int8_t state);
+
+	void updateMinMaxTemp();
+
+	virtual Parameters getParameters();
+};
+
+#endif /* FSFW_THERMAL_THERMALCOMPONENT_CORE_H_ */
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 522d4e44..16739e36 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -49,18 +49,18 @@ public:
 		SAFE = 0,             //!< SAFE
 		IDLE,                 //!< IDLE
 		PAYLOAD,              //!< PAYLOAD
-		NUMBER_OF_PRIORITIES          //!< MAX_PRIORITY
+		NUMBER_OF_PRIORITIES  //!< MAX_PRIORITY
 	};
 
 	/**
 	 * The elements are ordered by priority, lowest have highest priority
 	 */
 	enum HeaterRequest {
-		HEATER_REQUEST_EMERGENCY_OFF = 0,          //!< REQUEST_EMERGENCY_OFF
-		HEATER_REQUEST_EMERGENCY_ON, //!< REQUEST_EMERGENCY_ON
-		HEATER_REQUEST_OFF,          //!< REQUEST_OFF
-		HEATER_REQUEST_ON,           //!< REQUEST_ON
-		HEATER_DONT_CARE             //!< DONT_CARE
+		HEATER_REQUEST_EMERGENCY_OFF = 0,   //!< REQUEST_EMERGENCY_OFF
+		HEATER_REQUEST_EMERGENCY_ON,        //!< REQUEST_EMERGENCY_ON
+		HEATER_REQUEST_OFF,                 //!< REQUEST_OFF
+		HEATER_REQUEST_ON,                  //!< REQUEST_ON
+		HEATER_DONT_CARE                    //!< DONT_CARE
 	};
 
 	virtual ~ThermalComponentIF() {
diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h
deleted file mode 100644
index 680c0cb0..00000000
--- a/thermal/ThermalMonitor.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_
-#define FRAMEWORK_THERMAL_THERMALMONITOR_H_
-
-#include "../monitoring/MonitorReporter.h"
-#include "../thermal/ThermalComponentIF.h"
-
-/**
- * What does it do. How to use it.
- */
-class ThermalMonitor: public MonitorReporter<float> {
-public:
-	template<typename ... Args>
-	ThermalMonitor(Args ... args) :
-			MonitorReporter<float>(std::forward<Args>(args)...) {
-	}
-	~ThermalMonitor();
-	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
-			float lowerLimit, float upperLimit, bool componentIsOperational = true);
-
-	bool isAboveHighLimit();
-protected:
-	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
-
-};
-
-#endif /* FRAMEWORK_THERMAL_THERMALMONITOR_H_ */
diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitorReporter.cpp
similarity index 84%
rename from thermal/ThermalMonitor.cpp
rename to thermal/ThermalMonitorReporter.cpp
index fc0823c3..766ea1cb 100644
--- a/thermal/ThermalMonitor.cpp
+++ b/thermal/ThermalMonitorReporter.cpp
@@ -1,10 +1,12 @@
-#include "../thermal/ThermalMonitor.h"
-#include "../thermal/ThermalComponentIF.h"
+#include "ThermalMonitorReporter.h"
+#include "ThermalComponentIF.h"
+
 #include "../monitoring/MonitoringIF.h"
-ThermalMonitor::~ThermalMonitor() {
+
+ThermalMonitorReporter::~ThermalMonitorReporter() {
 }
 
-void ThermalMonitor::sendTransitionEvent(float currentValue,
+void ThermalMonitorReporter::sendTransitionEvent(float currentValue,
 		ReturnValue_t state) {
 	switch (state) {
 	case MonitoringIF::BELOW_LOW_LIMIT:
@@ -28,7 +30,7 @@ void ThermalMonitor::sendTransitionEvent(float currentValue,
 	}
 }
 
-bool ThermalMonitor::isAboveHighLimit() {
+bool ThermalMonitorReporter::isAboveHighLimit() {
 	if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
 		return true;
 	} else {
@@ -36,7 +38,7 @@ bool ThermalMonitor::isAboveHighLimit() {
 	}
 }
 
-ReturnValue_t ThermalMonitor::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
 		float upperLimit, bool componentIsOperational) {
 	if (ThermalComponentIF::isIgnoredState(state)) {
 		setToUnchecked();
diff --git a/thermal/ThermalMonitorReporter.h b/thermal/ThermalMonitorReporter.h
new file mode 100644
index 00000000..4fb68a99
--- /dev/null
+++ b/thermal/ThermalMonitorReporter.h
@@ -0,0 +1,28 @@
+#ifndef FSFW_THERMAL_THERMALMONITORREPORTER_H_
+#define FSFW_THERMAL_THERMALMONITORREPORTER_H_
+
+#include "ThermalComponentIF.h"
+#include "../monitoring/MonitorReporter.h"
+
+
+/**
+ * @brief   Monitor Reporter implementation for thermal components.
+ */
+class ThermalMonitorReporter: public MonitorReporter<float> {
+public:
+	template<typename ... Args>
+	ThermalMonitorReporter(Args ... args) :
+			MonitorReporter<float>(std::forward<Args>(args)...) {
+	}
+	~ThermalMonitorReporter();
+	ReturnValue_t translateState(ThermalComponentIF::State state, float sample,
+			float lowerLimit, float upperLimit,
+			bool componentIsOperational = true);
+
+	bool isAboveHighLimit();
+protected:
+	virtual void sendTransitionEvent(float currentValue, ReturnValue_t state);
+
+};
+
+#endif /* FSFW_THERMAL_THERMALMONITORREPORTERREPORTER_H_ */

From b7fb1b42e660795325c66f7fcf5e1a9d2388bb12 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 12:43:19 +0100
Subject: [PATCH 0992/1292] added new cfg option

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index be3717b4..fa769bad 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -39,7 +39,10 @@
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
 
 namespace fsfwconfig {
 //! Default timestamp size. The default timestamp will be an eight byte CDC

From 279df93cdf84eb99b3d1609b97c422be6e07d512 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 13:01:37 +0100
Subject: [PATCH 0993/1292] form and doc comments

---
 subsystem/Subsystem.h | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 9a3fcdfe..09d7850a 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -10,6 +10,10 @@
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 
+/**
+ * @brief   TODO: documentation missing
+ * @details
+ */
 class Subsystem: public SubsystemBase, public HasModeSequenceIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SUBSYSTEM;
@@ -31,8 +35,13 @@ public:
 	static const ReturnValue_t TARGET_TABLE_NOT_REACHED = MAKE_RETURN_CODE(0xA1);
 	static const ReturnValue_t TABLE_CHECK_FAILED = MAKE_RETURN_CODE(0xA2);
 
-
-
+	/**
+	 * TODO: Doc for constructor
+	 * @param setObjectId
+	 * @param parent
+	 * @param maxNumberOfSequences
+	 * @param maxNumberOfTables
+	 */
 	Subsystem(object_id_t setObjectId, object_id_t parent,
 			uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
 	virtual ~Subsystem();
@@ -52,24 +61,20 @@ public:
 	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief    Checks whether a sequence, identified by a mode.
 	 * @param sequence
 	 * @return
 	 */
 	ReturnValue_t checkSequence(Mode_t sequence);
 
 	/**
-	 *
-	 *
-	 * IMPORTANT: Do not call on non existing sequence! Use existsSequence() first
-	 *
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence.
 	 * @param iter
 	 * @return
 	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter, Mode_t fallbackSequence);
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -125,8 +130,6 @@ protected:
 
 	HybridIterator<ModeListEntry> getCurrentTable();
 
-//	void startSequence(Mode_t sequence);
-
 	/**
 	 * DO NOT USE ON NON EXISTING SEQUENCE
 	 *

From 952978f999936c515de731e796f95076373c5528 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 29 Nov 2020 13:04:38 +0100
Subject: [PATCH 0994/1292] moved perform hk op call

---
 devicehandlers/DeviceHandlerBase.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 38821054..ccd5bebb 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -86,7 +86,6 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		decrementDeviceReplyMap();
 		fdirInstance->checkForFailures();
 		hkSwitcher.performOperation();
-		hkManager.performHkOperation();
 		performOperationHook();
 		return RETURN_OK;
 	}
@@ -111,6 +110,9 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		break;
 	case CommunicationAction::GET_READ:
 		doGetRead();
+		// This will be performed after datasets have been updated by the
+		// custom device implementation.
+        hkManager.performHkOperation();
 		break;
 	default:
 		break;

From f0ca4be71eec5e3883d270e98b5b53ceab4fe1e2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:09:03 +0100
Subject: [PATCH 0995/1292] fsfw version include removed

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index fa769bad..f475e3fa 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -1,7 +1,6 @@
 #ifndef CONFIG_FSFWCONFIG_H_
 #define CONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
 #include <cstddef>
 #include <cstdint>
 

From fa4597782ec20090f45d390c9cee6542561de7f6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:09:56 +0100
Subject: [PATCH 0996/1292] some improvements taken over from master

---
 osal/linux/TcUnixUdpPollingTask.cpp |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp    | 16 ++++++++++++----
 osal/linux/TmTcUnixUdpBridge.h      |  5 ++++-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 670ba804..af99ec91 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -33,7 +33,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 	while(1) {
 		//! Sender Address is cached here.
 		struct sockaddr_in senderAddress;
-		socklen_t senderSockLen = 0;
+		socklen_t senderSockLen = sizeof(senderAddress);
 		ssize_t bytesReceived = recvfrom(serverUdpSocket,
 				receptionBuffer.data(), frameSize, receptionFlags,
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index b55291b3..ab28623e 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -65,9 +65,13 @@ TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
 ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	int flags = 0;
 
-	clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
-	//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
-	clientAddressLen = sizeof(serverAddress);
+	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
+
+	if(ipAddrAnySet){
+		clientAddress.sin_addr.s_addr = htons(INADDR_ANY);
+		//clientAddress.sin_addr.s_addr = inet_addr("127.73.73.1");
+		clientAddressLen = sizeof(serverAddress);
+	}
 
 //	char ipAddress [15];
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
@@ -85,7 +89,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
+void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
@@ -168,3 +172,7 @@ void TmTcUnixUdpBridge::handleSendError() {
 	}
 }
 
+void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
+	this->ipAddrAnySet = ipAddrAnySet;
+}
+
diff --git a/osal/linux/TmTcUnixUdpBridge.h b/osal/linux/TmTcUnixUdpBridge.h
index 5245c44c..ae6f6adc 100644
--- a/osal/linux/TmTcUnixUdpBridge.h
+++ b/osal/linux/TmTcUnixUdpBridge.h
@@ -20,8 +20,9 @@ public:
 			uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
 	virtual~ TmTcUnixUdpBridge();
 
-	void checkAndSetClientAddress(sockaddr_in clientAddress);
+	void checkAndSetClientAddress(sockaddr_in& clientAddress);
 
+	void setClientAddressToAny(bool ipAddrAnySet);
 protected:
 	virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
 
@@ -36,6 +37,8 @@ private:
 	struct sockaddr_in serverAddress;
 	socklen_t serverAddressLen = 0;
 
+	bool ipAddrAnySet = false;
+
 	//! Access to the client address is mutex protected as it is set
 	//! by another task.
 	MutexIF* mutex;

From b7945dfe606e2b2edd1a618aa089f893876ed75c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:45:08 +0100
Subject: [PATCH 0997/1292] added gp_id_t

---
 datapoollocal/HasLocalDataPoolIF.h |  3 +-
 datapoollocal/locPoolDefinitions.h | 44 +++++++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 9d4f2605..7f1f202e 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -43,7 +43,8 @@ public:
 	virtual~ HasLocalDataPoolIF() {};
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-	static constexpr lp_id_t NO_POOL_ID = 0xffffffff;
+
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
index d1493059..1115a336 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/locPoolDefinitions.h
@@ -10,11 +10,19 @@
  */
 using lp_id_t = uint32_t;
 
+namespace localpool {
+static constexpr uint32_t INVALID_LPID = -1;
+}
 
+/**
+ * Used as a unique identifier for data sets.
+ */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
-    static constexpr uint32_t INVALID_SET_ID = -1;
     static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+    static constexpr uint32_t INVALID_SET_ID = -1;
+
+
     sid_t(): raw(INVALID_SID) {}
 
     sid_t(object_id_t objectId, uint32_t setId):
@@ -48,4 +56,38 @@ union sid_t {
     }
 };
 
+/**
+ * Used as a global unique identifier for local pool variables.
+ */
+union gp_id_t {
+	static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
+	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+
+	gp_id_t(): raw(INVALID_GPID) {}
+
+	gp_id_t(object_id_t objectID, lp_id_t localPoolId):
+			objectId(objectId),
+			localPoolId(localPoolId) {}
+
+	struct {
+		object_id_t objectId;
+		lp_id_t localPoolId;
+	};
+
+	uint64_t raw;
+
+	bool notSet() const {
+		return raw == INVALID_GPID;
+	}
+
+    bool operator==(const sid_t& other) const {
+        return raw == other.raw;
+    }
+
+    bool operator!=(const sid_t& other) const {
+        return not (raw == other.raw);
+    }
+};
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */

From 25f08b8c1f8143bbcabfab7f40541351eb2adc50 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 13:59:54 +0100
Subject: [PATCH 0998/1292] started replacing local pool vars

---
 datapoollocal/LocalPoolObjectBase.cpp |  2 +-
 datapoollocal/LocalPoolObjectBase.h   |  2 +-
 datapoollocal/LocalPoolVariable.h     | 11 +++++++++--
 datapoollocal/LocalPoolVariable.tpp   | 12 ++++++++++--
 datapoollocal/LocalPoolVector.h       | 18 ++++++++++++++----
 datapoollocal/LocalPoolVector.tpp     | 21 ++++++++++++++-------
 thermal/ThermalComponentCore.cpp      |  7 +++----
 thermal/ThermalComponentCore.h        | 19 ++++++++++---------
 8 files changed, 62 insertions(+), 30 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 88027169..c25df25a 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -19,7 +19,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
     }
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 4d25b88a..8d1ab45e 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -14,7 +14,7 @@ public:
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
             pool_rwm_t setReadWriteMode);
 
-    LocalPoolObjectBase(lp_id_t poolId, object_id_t poolOwner,
+    LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
             DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index e9d94178..85d86420 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -64,9 +64,17 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the global unique identifier of a pool variable.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
 	virtual~ LocalPoolVar() {};
 
@@ -156,5 +164,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 3320aa5a..7025e462 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -12,9 +12,17 @@ inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId, object_id_t poolOwner,
+inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-        LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T>
+inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode){}
+
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a7ebd3fe..4644b748 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
 #include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
@@ -65,7 +65,17 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, object_id_t poolOwner,
+	LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+			DataSetIF* dataSet = nullptr,
+			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+	/**
+	 * Variation which takes the unique global identifier of a local pool
+	 * vector.
+	 * @param globalPoolId
+	 * @param dataSet
+	 * @param setReadWriteMode
+	 */
+	LocalPoolVector(gp_id_t globalPoolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -161,4 +171,4 @@ private:
 template<typename T, uint16_t vectorSize>
 using lp_vec_t = LocalPoolVector<T, vectorSize>;
 
-#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 34720b97..fc3c0a2e 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -1,7 +1,7 @@
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
-#define FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
 
-#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
@@ -12,9 +12,16 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		object_id_t poolOwner, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, poolOwner, dataSet, setReadWriteMode) {}
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+
+template<typename T, uint16_t vectorSize>
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
@@ -148,4 +155,4 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index bf28f307..07649bf3 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,10 +1,9 @@
 #include "ThermalComponentCore.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
-        uint8_t domainId, uint32_t temperaturePoolId,
-        uint32_t targetStatePoolId,
-		uint32_t currentStatePoolId, uint32_t requestPoolId,
-		GlobDataSet* dataSet, Parameters parameters,
+        uint8_t domainId, gp_id_t temperaturePoolId,
+        gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalDataSetBase* dataSet, Parameters parameters,
 		StateRequest initialTargetState) :
 		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 2d08ed1d..49ca098e 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -6,8 +6,9 @@
 #include "AbstractTemperatureSensor.h"
 #include "ThermalModule.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
+//#include "../datapoolglob/GlobalDataSet.h"
+//#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 
 /**
  * @brief
@@ -38,9 +39,9 @@ public:
 	 * @param initialTargetState
 	 */
 	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
-	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-	        uint32_t currentStatePoolId, uint32_t requestPoolId,
-	        GlobDataSet *dataSet, Parameters parameters,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalDataSetBase* dataSet, Parameters parameters,
 			StateRequest initialTargetState =
 					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
 
@@ -80,10 +81,10 @@ protected:
 	AbstractTemperatureSensor *secondRedundantSensor = nullptr;
 	ThermalModuleIF *thermalModule = nullptr;
 
-	gp_float_t temperature;
-	gp_int8_t targetState;
-	gp_int8_t currentState;
-	gp_uint8_t heaterRequest;
+	lp_var_t<float> temperature;
+	lp_var_t<int8_t> targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<uint8_t> heaterRequest;
 
 	bool isHeating = false;
 

From e7a96d5ad8dd7169818e624943bcf15b651c0af1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 14:13:52 +0100
Subject: [PATCH 0999/1292] it doesnt work? comment it !

---
 datapoollocal/LocalDataPoolManager.h |   2 +-
 datapoollocal/LocalPoolVariable.h    |   2 +-
 datapoollocal/LocalPoolVariable.tpp  |   5 +-
 internalError/InternalErrorDataset.h |  12 +--
 thermal/ThermalComponent.cpp         |  18 ++--
 thermal/ThermalComponent.h           |   6 +-
 thermal/ThermalComponentCore.cpp     | 147 ++++++++++++++-------------
 thermal/ThermalComponentCore.h       |   6 +-
 8 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index aca0d4f6..95d48303 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -20,7 +20,7 @@ namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
-class LocalDataSetBase;
+class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
 
 /**
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 85d86420..75cf570e 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7025e462..26500e3b 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,9 +6,8 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index 52a4b632..fa91116d 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,12 +21,12 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(TM_HITS,
-            hkManager->getOwner(), this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(QUEUE_HITS,
-            hkManager->getOwner(), this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(STORE_HITS,
-            hkManager->getOwner(), this);
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		TM_HITS, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		QUEUE_HITS, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    		STORE_HITS, this);
 };
 
 
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 78b14efd..54bd67bd 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -1,9 +1,9 @@
 #include "ThermalComponent.h"
 
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
-		uint8_t domainId, uint32_t temperaturePoolId,
-		uint32_t targetStatePoolId, uint32_t currentStatePoolId,
-		uint32_t requestPoolId, GlobDataSet* dataSet,
+		uint8_t domainId, gp_id_t temperaturePoolId,
+		gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
 		AbstractTemperatureSensor* sensor,
 		AbstractTemperatureSensor* firstRedundantSensor,
 		AbstractTemperatureSensor* secondRedundantSensor,
@@ -78,13 +78,13 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-		ThermalComponentCore::checkLimits(state);
-		return;
-	}
+	//if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
+	//	ThermalComponentCore::checkLimits(state);
+	//	return;
+	//}
 	//If component is not operational, it checks the NOP limits.
-	temperatureMonitor.translateState(state, temperature.value,
-			nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
+	//temperatureMonitor.translateState(state, temperature.value,
+	//		nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
 }
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
diff --git a/thermal/ThermalComponent.h b/thermal/ThermalComponent.h
index d61ff01e..0785a914 100644
--- a/thermal/ThermalComponent.h
+++ b/thermal/ThermalComponent.h
@@ -45,9 +45,9 @@ public:
 	 * @param priority
 	 */
 	ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
-	        uint32_t temperaturePoolId, uint32_t targetStatePoolId,
-	        uint32_t currentStatePoolId, uint32_t requestPoolId,
-			GlobDataSet *dataSet, AbstractTemperatureSensor *sensor,
+	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
+	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
+			LocalPoolDataSetBase *dataSet, AbstractTemperatureSensor *sensor,
 			AbstractTemperatureSensor *firstRedundantSensor,
 			AbstractTemperatureSensor *secondRedundantSensor,
 			ThermalModuleIF *thermalModule, Parameters parameters,
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 07649bf3..53eeb58f 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -3,22 +3,22 @@
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
         uint8_t domainId, gp_id_t temperaturePoolId,
         gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
-		gp_id_t requestPoolId, LocalDataSetBase* dataSet, Parameters parameters,
-		StateRequest initialTargetState) :
+		gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
+		Parameters parameters, StateRequest initialTargetState) :
 		temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
 		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
-		parameters(parameters),
-		temperatureMonitor(reportingObjectId, domainId + 1,
-		        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
-				COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
+		parameters(parameters), domainId(domainId) {
+		//temperatureMonitor(reportingObjectId, domainId + 1,
+		//        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
+		//		COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
 	//Set thermal state once, then leave to operator.
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	writableTargetState = initialTargetState;
-	mySet.commit(PoolVariableIF::VALID);
+	//GlobDataSet mySet;
+	//gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
+	//		PoolVariableIF::VAR_WRITE);
+	//writableTargetState = initialTargetState;
+	//mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
@@ -57,19 +57,19 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
-	updateMinMaxTemp();
-	if ((temperature != INVALID_TEMPERATURE)) {
-		temperature.setValid(PoolVariableIF::VALID);
-		State state = getState(temperature, getParameters(), targetState);
-		currentState = state;
-		checkLimits(state);
-		request = getHeaterRequest(targetState, temperature, getParameters());
-	} else {
-		temperatureMonitor.setToInvalid();
-		temperature.setValid(PoolVariableIF::INVALID);
-		currentState = UNKNOWN;
-		request = HEATER_DONT_CARE;
-	}
+	//updateMinMaxTemp();
+	//if ((temperature != INVALID_TEMPERATURE)) {
+		//temperature.setValid(PoolVariableIF::VALID);
+		//State state = getState(temperature, getParameters(), targetState);
+		//currentState = state;
+		//checkLimits(state);
+		//request = getHeaterRequest(targetState, temperature, getParameters());
+	//} else {
+	//	temperatureMonitor.setToInvalid();
+	//	temperature.setValid(PoolVariableIF::INVALID);
+	//	currentState = UNKNOWN;
+	//	request = HEATER_DONT_CARE;
+	//}
 	currentState.setValid(PoolVariableIF::VALID);
 	heaterRequest = request;
 	heaterRequest.setValid(PoolVariableIF::VALID);
@@ -77,11 +77,12 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 }
 
 void ThermalComponentCore::markStateIgnored() {
-	currentState = getIgnoredState(currentState);
+	//currentState = getIgnoredState(currentState);
 }
 
 object_id_t ThermalComponentCore::getObjectId() {
-	return temperatureMonitor.getReporterId();
+	//return temperatureMonitor.getReporterId();
+	return 0;
 }
 
 float ThermalComponentCore::getLowerOpLimit() {
@@ -119,7 +120,7 @@ void ThermalComponentCore::setOutputInvalid() {
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
 	heaterRequest.setValid(PoolVariableIF::INVALID);
-	temperatureMonitor.setToUnchecked();
+	//temperatureMonitor.setToUnchecked();
 }
 
 float ThermalComponentCore::getTemperature() {
@@ -169,8 +170,8 @@ ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 
 void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
-	temperatureMonitor.translateState(state, temperature.value,
-			getParameters().lowerOpLimit, getParameters().upperOpLimit);
+	//temperatureMonitor.translateState(state, temperature.value,
+	//		getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
@@ -220,17 +221,17 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	}
 }
 
-void ThermalComponentCore::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
-		return;
-	}
-	if (temperature < minTemp) {
-		minTemp = temperature;
-	}
-	if (temperature > maxTemp) {
-		maxTemp = temperature;
-	}
-}
+//void ThermalComponentCore::updateMinMaxTemp() {
+//	if (temperature == INVALID_TEMPERATURE) {
+//		return;
+//	}
+//	if (temperature < minTemp) {
+//		minTemp = temperature;
+//	}
+//	if (temperature > maxTemp) {
+//		maxTemp = temperature;
+//	}
+//}
 
 uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
@@ -243,38 +244,38 @@ ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-			parameterId, parameterWrapper, newValues, startAtIndex);
-	if (result != INVALID_DOMAIN_ID) {
-		return result;
-	}
-	if (domainId != this->domainId) {
-		return INVALID_DOMAIN_ID;
-	}
-	switch (parameterId) {
-	case 0:
-		parameterWrapper->set(parameters.heaterOn);
-		break;
-	case 1:
-		parameterWrapper->set(parameters.hysteresis);
-		break;
-	case 2:
-		parameterWrapper->set(parameters.heaterSwitchoff);
-		break;
-	case 3:
-		parameterWrapper->set(minTemp);
-		break;
-	case 4:
-		parameterWrapper->set(maxTemp);
-		break;
-	case 10:
-		parameterWrapper->set(parameters.lowerOpLimit);
-		break;
-	case 11:
-		parameterWrapper->set(parameters.upperOpLimit);
-		break;
-	default:
-		return INVALID_IDENTIFIER_ID;
-	}
+	//ReturnValue_t result = temperatureMonitor.getParameter(domainId,
+	//		parameterId, parameterWrapper, newValues, startAtIndex);
+//	if (result != INVALID_DOMAIN_ID) {
+//		return result;
+//	}
+//	if (domainId != this->domainId) {
+//		return INVALID_DOMAIN_ID;
+//	}
+//	switch (parameterId) {
+//	case 0:
+//		parameterWrapper->set(parameters.heaterOn);
+//		break;
+//	case 1:
+//		parameterWrapper->set(parameters.hysteresis);
+//		break;
+//	case 2:
+//		parameterWrapper->set(parameters.heaterSwitchoff);
+//		break;
+//	case 3:
+//		parameterWrapper->set(minTemp);
+//		break;
+//	case 4:
+//		parameterWrapper->set(maxTemp);
+//		break;
+//	case 10:
+//		parameterWrapper->set(parameters.lowerOpLimit);
+//		break;
+//	case 11:
+//		parameterWrapper->set(parameters.upperOpLimit);
+//		break;
+//	default:
+//		return INVALID_IDENTIFIER_ID;
+//	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 49ca098e..6ef59058 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -41,7 +41,7 @@ public:
 	ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
 	        gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
 	        gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-			LocalDataSetBase* dataSet, Parameters parameters,
+			LocalPoolDataSetBase* dataSet, Parameters parameters,
 			StateRequest initialTargetState =
 					ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
 
@@ -96,7 +96,7 @@ protected:
 
 	Parameters parameters;
 
-	ThermalMonitorReporter temperatureMonitor;
+	//ThermalMonitorReporter temperatureMonitor;
 
 	const uint8_t domainId;
 
@@ -111,7 +111,7 @@ protected:
 
 	virtual State getIgnoredState(int8_t state);
 
-	void updateMinMaxTemp();
+	//void updateMinMaxTemp();
 
 	virtual Parameters getParameters();
 };

From f70ee7696a82f96268d5cc06b6182a6c30780515 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 15:30:56 +0100
Subject: [PATCH 1000/1292] it compiles again

---
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolVariable.h      |  2 +
 datapoollocal/LocalPoolVariable.tpp    |  9 +++-
 datapoollocal/LocalPoolVector.h        |  2 +-
 datapoollocal/LocalPoolVector.tpp      |  4 +-
 datapoollocal/locPoolDefinitions.h     |  2 +-
 monitoring/AbsLimitMonitor.h           | 10 ++--
 monitoring/LimitMonitor.h              | 12 ++---
 monitoring/MonitorBase.h               |  7 ++-
 monitoring/MonitorReporter.h           |  5 +-
 monitoring/MonitoringMessageContent.h  | 37 +++++++++------
 power/Fuse.cpp                         | 63 +++++++++++++-------------
 power/Fuse.h                           | 32 +++++++------
 power/PowerSensor.cpp                  | 56 ++++++++++++-----------
 power/PowerSensor.h                    | 27 +++++++----
 thermal/ThermalMonitorReporter.cpp     | 15 ++++--
 16 files changed, 162 insertions(+), 123 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 6e237c48..640956db 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -31,7 +31,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
-                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner == nullptr) {
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 75cf570e..173c2035 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -119,6 +119,7 @@ public:
 
 
 	LocalPoolVar<T> &operator=(T newValue);
+	LocalPoolVar<T> &operator=(LocalPoolVar<T> newPoolVariable);
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -164,4 +165,5 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 26500e3b..8aa164d1 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -81,11 +81,18 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator =(T newValue) {
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(T newValue) {
     value = newValue;
     return *this;
 }
 
+template<typename T>
+inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
+		LocalPoolVar<T> newPoolVariable) {
+	value = newPoolVariable.value;
+	return *this;
+}
+
 
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 4644b748..58face3c 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -47,7 +47,7 @@ public:
 	 * @param dataSet The data set in which the variable shall register itself.
 	 * If nullptr, the variable is not registered.
 	 */
-	LocalPoolVector(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+	LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index fc3c0a2e..46123ccc 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -6,8 +6,8 @@
 #endif
 
 template<typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(lp_id_t poolId,
-		HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+		HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/locPoolDefinitions.h
index 1115a336..6e74d349 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/locPoolDefinitions.h
@@ -66,7 +66,7 @@ union gp_id_t {
 
 	gp_id_t(): raw(INVALID_GPID) {}
 
-	gp_id_t(object_id_t objectID, lp_id_t localPoolId):
+	gp_id_t(object_id_t objectId, lp_id_t localPoolId):
 			objectId(objectId),
 			localPoolId(localPoolId) {}
 
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index d85d5b61..1206dbf6 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -8,12 +8,11 @@ template<typename T>
 class AbsLimitMonitor: public MonitorBase<T> {
 public:
 	AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit, T limit,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T limit,
 	        Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
 	        bool aboveIsViolation = true) :
-			MonitorBase<T>(reporterId, monitorId, dataCreatorId, localPoolId,
-			        confirmationLimit),
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
+					confirmationLimit),
 			limit(limit), violationEvent(violationEvent),
 			aboveIsViolation(aboveIsViolation) {
 	}
@@ -67,7 +66,8 @@ protected:
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
 			EventManagerIF::triggerEvent(this->reportingId,
-			        violationEvent, this->parameterId);
+			        violationEvent, this->parameterId.objectId,
+					this->parameterId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index fdb05018..27e35aa7 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -13,11 +13,11 @@ template<typename T>
 class LimitMonitor: public MonitorBase<T> {
 public:
 	LimitMonitor(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t creatorId, lp_id_t localPoolId,
-			uint16_t confirmationLimit, T lowerLimit, T upperLimit,
-			Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit, T lowerLimit,
+			T upperLimit, Event belowLowEvent =
+					MonitoringIF::VALUE_BELOW_LOW_LIMIT,
 			Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT) :
-			MonitorBase<T>(reporterId, monitorId, creatorId, localPoolId,
+			MonitorBase<T>(reporterId, monitorId, globalPoolId,
 			        confirmationLimit),
 			lowerLimit(lowerLimit), upperLimit(upperLimit),
 			belowLowEvent(belowLowEvent), aboveHighEvent(aboveHighEvent) {
@@ -80,11 +80,11 @@ protected:
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
-			        this->parameterId);
+			        this->parameterId.objectId, this->parameterId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index df6f1af8..530a3840 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -25,11 +25,10 @@ class MonitorBase: public MonitorReporter<T> {
 public:
 
 	MonitorBase(object_id_t reporterId, uint8_t monitorId,
-	        object_id_t dataCreatorId, lp_id_t localPoolId,
-	        uint16_t confirmationLimit):
-	        MonitorReporter<T>(reporterId, monitorId, dataCreatorId,
+	        gp_id_t globalPoolId, uint16_t confirmationLimit):
+	        MonitorReporter<T>(reporterId, monitorId, globalPoolId,
 	                confirmationLimit),
-	        poolVariable(dataCreatorId, localPoolId) {
+	        poolVariable(globalPoolId) {
 	}
 
 	virtual ~MonitorBase() {
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index d33f34d5..d6d8c8ed 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -5,6 +5,7 @@
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
@@ -18,7 +19,7 @@ public:
 	// TODO: Adapt to use SID instead of parameter ID.
 
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
-	        uint32_t parameterId, uint16_t confirmationLimit) :
+	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
 			monitorId(monitorId), parameterId(parameterId),
 			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
 			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
@@ -95,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const uint32_t parameterId;
+	const gp_id_t parameterId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index c82506f3..44d32656 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -3,6 +3,7 @@
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -16,12 +17,17 @@ void setStaticFrameworkObjectIds();
 }
 
 //PID(uint32_t), TYPE, LIMIT_ID, value,limitValue, previous, later, timestamp
+/**
+ * @brief	Does magic.
+ * @tparam T
+ */
 template<typename T>
 class MonitoringReportContent: public SerialLinkedListAdapter<SerializeIF> {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	SerializeElement<uint8_t> monitorId;
-	SerializeElement<uint32_t> parameterId;
+	SerializeElement<uint32_t> parameterObjectId;
+	SerializeElement<lp_id_t> localPoolId;
 	SerializeElement<T> parameterValue;
 	SerializeElement<T> limitValue;
 	SerializeElement<ReturnValue_t> oldState;
@@ -30,20 +36,23 @@ public:
 	SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
 	TimeStamperIF* timeStamper;
 	MonitoringReportContent() :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					0), parameterValue(0), limitValue(0), oldState(0), newState(
-					0), rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(0),
+					localPoolId(0), parameterValue(0),
+					limitValue(0), oldState(0), newState(0),
+					rawTimestamp( { 0 }), timestampSerializer(rawTimestamp,
 					sizeof(rawTimestamp)), timeStamper(NULL) {
 		setAllNext();
 	}
-	MonitoringReportContent(uint32_t setPID, T value, T limitValue,
+	MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue,
 			ReturnValue_t oldState, ReturnValue_t newState) :
-			SerialLinkedListAdapter<SerializeIF>(
-					LinkedElement<SerializeIF>::Iterator(&parameterId)), monitorId(0), parameterId(
-					setPID), parameterValue(value), limitValue(limitValue), oldState(
-					oldState), newState(newState), timestampSerializer(rawTimestamp,
-							sizeof(rawTimestamp)), timeStamper(NULL) {
+			SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
+					monitorId(0), parameterObjectId(globalPoolId.objectId),
+					localPoolId(globalPoolId.localPoolId),
+					parameterValue(value), limitValue(limitValue),
+					oldState(oldState), newState(newState),
+					timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
+					timeStamper(NULL) {
 		setAllNext();
 		if (checkAndSetStamper()) {
 			timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
@@ -53,16 +62,16 @@ private:
 
 	static object_id_t timeStamperId;
 	void setAllNext() {
-		parameterId.setNext(&parameterValue);
+		parameterObjectId.setNext(&parameterValue);
 		parameterValue.setNext(&limitValue);
 		limitValue.setNext(&oldState);
 		oldState.setNext(&newState);
 		newState.setNext(&timestampSerializer);
 	}
 	bool checkAndSetStamper() {
-		if (timeStamper == NULL) {
+		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
-			if ( timeStamper == NULL ) {
+			if ( timeStamper == nullptr ) {
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 				return false;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index ace625bf..ff9c7b3c 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -8,17 +8,16 @@
 
 object_id_t Fuse::powerSwitchId = 0;
 
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
+Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId,
+		sid_t variableSet, VariableIds ids,
 		float maxCurrent, uint16_t confirmationCount) :
-		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
-		NULL),
+		SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId),
 		currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
 				maxCurrent, FUSE_CURRENT_HIGH),
-		powerMonitor(fuseObjectId, 2,
-		        GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
+		powerMonitor(fuseObjectId, 2, ids.poolIdPower,
 				confirmationCount),
-		set(), voltage(ids.pidVoltage, &set), current(ids.pidCurrent, &set),
-		state(ids.pidState, &set),
+		set(variableSet), voltage(ids.pidVoltage, &set),
+		current(ids.pidCurrent, &set), state(ids.pidState, &set),
 		power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
 		parameterHelper(this), healthHelper(this, fuseObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -73,19 +72,19 @@ ReturnValue_t Fuse::check() {
 	checkFuseState();
 	calculateFusePower();
 	//Check if power is valid and if fuse state is off or invalid.
-	if (!power.isValid() || (state == 0) || !state.isValid()) {
-		result = powerMonitor.setToInvalid();
-	} else {
-		float lowLimit = 0.0;
-		float highLimit = RESIDUAL_POWER;
-		calculatePowerLimits(&lowLimit, &highLimit);
-		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-			reportEvents(POWER_BELOW_LOW_LIMIT);
-		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-		}
-	}
+//	if (!power.isValid() || (state == 0) || !state.isValid()) {
+//		result = powerMonitor.setToInvalid();
+//	} else {
+//		float lowLimit = 0.0;
+//		float highLimit = RESIDUAL_POWER;
+//		calculatePowerLimits(&lowLimit, &highLimit);
+//		result = powerMonitor.checkPower(power, lowLimit, highLimit);
+//		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+//			reportEvents(POWER_BELOW_LOW_LIMIT);
+//		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+//			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+//		}
+//	}
 	set.commit();
 	return result;
 }
@@ -136,7 +135,7 @@ void Fuse::calculateFusePower() {
 		return;
 	}
 	//Calculate fuse power.
-	power = current * voltage;
+	//power = current * voltage;
 	power.setValid(PoolVariableIF::VALID);
 }
 
@@ -189,20 +188,20 @@ void Fuse::checkFuseState() {
 		oldFuseState = 0;
 		return;
 	}
-	if (state == 0) {
-		if (oldFuseState != 0) {
-			reportEvents(FUSE_WENT_OFF);
-		}
-	}
-	oldFuseState = state;
+//	if (state == 0) {
+//		if (oldFuseState != 0) {
+//			reportEvents(FUSE_WENT_OFF);
+//		}
+//	}
+//	oldFuseState = state;
 }
 
 float Fuse::getPower() {
-	if (power.isValid()) {
-		return power;
-	} else {
-		return 0.0;
-	}
+//	if (power.isValid()) {
+//		return power;
+//	} else {
+//		return 0.0;
+//	}
 }
 
 void Fuse::setDataPoolEntriesInvalid() {
diff --git a/power/Fuse.h b/power/Fuse.h
index 13a0eb7c..5e54d294 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -13,6 +13,7 @@
 #include "../parameters/ParameterHelper.h"
 #include <list>
 
+#include "../datapoollocal/StaticLocalDataSet.h"
 namespace Factory {
 void setStaticFrameworkObjectIds();
 }
@@ -27,10 +28,10 @@ private:
 	static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
 public:
 	struct VariableIds {
-		uint32_t pidVoltage;
-		uint32_t pidCurrent;
-		uint32_t pidState;
-		uint32_t poolIdPower;
+		gp_id_t pidVoltage;
+		gp_id_t pidCurrent;
+		gp_id_t pidState;
+		gp_id_t poolIdPower;
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
@@ -40,8 +41,8 @@ public:
 	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
-	Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
-			float maxCurrent, uint16_t confirmationCount = 2);
+	Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet,
+			VariableIds ids, float maxCurrent, uint16_t confirmationCount = 2);
 	virtual ~Fuse();
 	void addDevice(PowerComponentIF *set);
 	float getPower();
@@ -71,12 +72,12 @@ public:
 private:
 	uint8_t oldFuseState;
 	uint8_t fuseId;
-	PowerSwitchIF *powerIF; //could be static in our case.
+	PowerSwitchIF *powerIF = nullptr; //could be static in our case.
 	AbsLimitMonitor<float> currentLimit;
 	class PowerMonitor: public MonitorReporter<float> {
 	public:
 		template<typename ... Args>
-		PowerMonitor(Args ... args) :
+		PowerMonitor(Args ... args):
 				MonitorReporter<float>(std::forward<Args>(args)...) {
 		}
 		ReturnValue_t checkPower(float sample, float lowerLimit,
@@ -86,11 +87,16 @@ private:
 
 	};
 	PowerMonitor powerMonitor;
-	GlobDataSet set;
-	PIDReader<float> voltage;
-	PIDReader<float> current;
-	PIDReader<uint8_t> state;
-	gp_float_t power;
+	StaticLocalDataSet<3> set;
+	//LocalPoolDataSetBase* set = nullptr;
+	//PIDReader<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<uint8_t> state;
+	lp_var_t<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<uint8_t> state;
+
+	lp_var_t<float> power;
 	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 739d02f2..8fe3cf3a 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -2,15 +2,17 @@
 
 #include "../ipc/QueueFactory.h"
 
-PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
+PowerSensor::PowerSensor(object_id_t objectId, sid_t setId,  VariableIds ids,
 		DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
-		SystemObject(setId), parameterHelper(this), healthHelper(this, setId),
-		set(), current(ids.pidCurrent, &set), voltage(ids.pidVoltage, &set),
-		power(ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE),
-		currentLimit(setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
+		SystemObject(objectId), parameterHelper(this),
+		healthHelper(this, objectId),
+		powerSensorSet(setId), current(ids.pidCurrent, &powerSensorSet),
+		voltage(ids.pidVoltage, &powerSensorSet),
+		power(ids.poolIdPower, &powerSensorSet, PoolVariableIF::VAR_WRITE),
+		currentLimit(objectId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
 				limits.currentMin, limits.currentMax, events.currentLow,
 				events.currentHigh),
-		voltageLimit(setId, MODULE_ID_VOLTAGE,
+		voltageLimit(objectId, MODULE_ID_VOLTAGE,
 				ids.pidVoltage, confirmationCount, limits.voltageMin,
 				limits.voltageMax, events.voltageLow, events.voltageHigh) {
 		commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -21,27 +23,27 @@ PowerSensor::~PowerSensor() {
 }
 
 ReturnValue_t PowerSensor::calculatePower() {
-	set.read();
+	powerSensorSet.read();
 	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
 	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-			&& current.isValid()) {
-		result1 = voltageLimit.doCheck(voltage);
-		result2 = currentLimit.doCheck(current);
-	} else {
-		voltageLimit.setToInvalid();
-		currentLimit.setToInvalid();
-		result1 = OBJECT_NOT_HEALTHY;
-	}
-	if (result1 != HasReturnvaluesIF::RETURN_OK
-			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-		result1 = MonitoringIF::INVALID;
-		power.setValid(PoolVariableIF::INVALID);
-	} else {
-		power.setValid(PoolVariableIF::VALID);
-		power = current * voltage;
-	}
-	set.commit();
+//	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+//			&& current.isValid()) {
+//		result1 = voltageLimit.doCheck(voltage);
+//		result2 = currentLimit.doCheck(current);
+//	} else {
+//		voltageLimit.setToInvalid();
+//		currentLimit.setToInvalid();
+//		result1 = OBJECT_NOT_HEALTHY;
+//	}
+//	if (result1 != HasReturnvaluesIF::RETURN_OK
+//			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+//		result1 = MonitoringIF::INVALID;
+//		power.setValid(PoolVariableIF::INVALID);
+//	} else {
+//		power.setValid(PoolVariableIF::VALID);
+//		power = current * voltage;
+//	}
+//	powerSensorSet.commit();
 	return result1;
 }
 
@@ -94,8 +96,8 @@ void PowerSensor::checkCommandQueue() {
 }
 
 void PowerSensor::setDataPoolEntriesInvalid() {
-	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	powerSensorSet.read();
+	powerSensorSet.commit(PoolVariableIF::INVALID);
 }
 
 float PowerSensor::getPower() {
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index 20ebff39..bb409f3e 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -4,6 +4,7 @@
 #include "../datapoolglob/GlobalDataSet.h"
 #include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoolglob/PIDReader.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
 #include "../parameters/ParameterHelper.h"
@@ -12,15 +13,18 @@
 
 class PowerController;
 
+/**
+ * @brief	Does magic.
+ */
 class PowerSensor: public SystemObject,
 		public ReceivesParameterMessagesIF,
 		public HasHealthIF {
 	friend class PowerController;
 public:
 	struct VariableIds {
-		uint32_t pidCurrent;
-		uint32_t pidVoltage;
-		uint32_t poolIdPower;
+		gp_id_t pidCurrent;
+		gp_id_t pidVoltage;
+		gp_id_t poolIdPower;
 	};
 	struct DefaultLimits {
 		float currentMin;
@@ -34,8 +38,9 @@ public:
 		Event voltageLow;
 		Event voltageHigh;
 	};
-	PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
-			SensorEvents events, uint16_t confirmationCount = 0);
+	PowerSensor(object_id_t objectId, sid_t sid, VariableIds setIds,
+			DefaultLimits limits, SensorEvents events,
+			uint16_t confirmationCount = 0);
 	virtual ~PowerSensor();
 	ReturnValue_t calculatePower();
 	ReturnValue_t performOperation(uint8_t opCode);
@@ -53,12 +58,16 @@ private:
 	MessageQueueIF* commandQueue = nullptr;
 	ParameterHelper parameterHelper;
 	HealthHelper healthHelper;
-	GlobDataSet set;
+	//GlobDataSet set;
+	StaticLocalDataSet<3> powerSensorSet;
 	//Variables in
-	PIDReader<float> current;
-	PIDReader<float> voltage;
+	lp_var_t<float> current;
+	lp_var_t<float> voltage;
+	//PIDReader<float> current;
+	//PIDReader<float> voltage;
 	//Variables out
-	gp_float_t power;
+	lp_var_t<float> power;
+	//gp_float_t power;
 
 	static const uint8_t MODULE_ID_CURRENT = 1;
 	static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/thermal/ThermalMonitorReporter.cpp b/thermal/ThermalMonitorReporter.cpp
index 766ea1cb..cefc6110 100644
--- a/thermal/ThermalMonitorReporter.cpp
+++ b/thermal/ThermalMonitorReporter.cpp
@@ -38,7 +38,8 @@ bool ThermalMonitorReporter::isAboveHighLimit() {
 	}
 }
 
-ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State state, float sample, float lowerLimit,
+ReturnValue_t ThermalMonitorReporter::translateState(
+		ThermalComponentIF::State state, float sample, float lowerLimit,
 		float upperLimit, bool componentIsOperational) {
 	if (ThermalComponentIF::isIgnoredState(state)) {
 		setToUnchecked();
@@ -46,10 +47,12 @@ ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State s
 	}
 	switch (state) {
 	case ThermalComponentIF::OUT_OF_RANGE_LOW:
-		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample, lowerLimit);
+		return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
+				lowerLimit);
 	case ThermalComponentIF::NON_OPERATIONAL_LOW:
 		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT, sample, lowerLimit);
+			return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT,
+					sample, lowerLimit);
 		} else {
 			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 		}
@@ -57,12 +60,14 @@ ReturnValue_t ThermalMonitorReporter::translateState(ThermalComponentIF::State s
 		return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 	case ThermalComponentIF::NON_OPERATIONAL_HIGH:
 		if (componentIsOperational) {
-			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT, sample, upperLimit);
+			return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT,
+					sample, upperLimit);
 		} else {
 			return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
 		}
 	case ThermalComponentIF::OUT_OF_RANGE_HIGH:
-		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample, upperLimit);
+		return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
+				upperLimit);
 	default:
 		//Never reached, all states covered.
 		return HasReturnvaluesIF::RETURN_FAILED;

From 4bb9dd816ec910870cd8183951efbdae9cb74d0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:06:59 +0100
Subject: [PATCH 1001/1292] compiling again

---
 datapoollocal/LocalPoolObjectBase.cpp |   4 +
 datapoollocal/LocalPoolObjectBase.h   |   1 +
 datapoollocal/LocalPoolVariable.h     |  18 +++-
 datapoollocal/LocalPoolVariable.tpp   |  49 ++++++++-
 monitoring/AbsLimitMonitor.h          |   4 +-
 monitoring/LimitMonitor.h             |   4 +-
 monitoring/MonitorReporter.h          |   8 +-
 power/Fuse.cpp                        |  50 ++++-----
 power/PowerSensor.cpp                 |  36 +++----
 thermal/ThermalComponentCore.cpp      | 146 +++++++++++++-------------
 thermal/ThermalComponentCore.h        |   6 +-
 thermal/tcsDefinitions.h              |   2 +-
 12 files changed, 196 insertions(+), 132 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index c25df25a..b4d0e306 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -67,3 +67,7 @@ void LocalPoolObjectBase::setChanged(bool changed) {
 bool LocalPoolObjectBase::hasChanged() const {
     return changed;
 }
+
+void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
+	this->readWriteMode = newReadWriteMode;
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 8d1ab45e..7165fc24 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -18,6 +18,7 @@ public:
             DataSetIF* dataSet = nullptr,
             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
+    void setReadWriteMode(pool_rwm_t newReadWriteMode);
     pool_rwm_t getReadWriteMode() const;
 
     bool isValid() const override;
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 173c2035..bb36089d 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -118,8 +118,21 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(T newValue);
-	LocalPoolVar<T> &operator=(LocalPoolVar<T> newPoolVariable);
+	LocalPoolVar<T> &operator=(const T& newValue);
+	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+
+	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const T& other) const;
+
+	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const T& other) const;
+
+	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const T& other) const;
+
+	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const T& other) const;
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
@@ -165,5 +178,4 @@ using lp_int64_t = LocalPoolVar<int64_t>;
 using lp_float_t = LocalPoolVar<float>;
 using lp_double_t = LocalPoolVar<double>;
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 8aa164d1..a63e550d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -81,14 +81,14 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(T newValue) {
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
 inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		LocalPoolVar<T> newPoolVariable) {
+		const LocalPoolVar<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
@@ -119,4 +119,47 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
-#endif
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+	return this->value == other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+	return this->value == other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+	return not (*this == other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+	return not (*this == other);
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+	return this->value < other.value;
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator <(const T &other) const {
+	return this->value < other;
+}
+
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+	return not (*this < other);
+}
+
+template<typename T>
+inline bool LocalPoolVar<T>::operator >(const T &other) const {
+	return not (*this < other);
+}
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h
index 1206dbf6..5feb369c 100644
--- a/monitoring/AbsLimitMonitor.h
+++ b/monitoring/AbsLimitMonitor.h
@@ -66,8 +66,8 @@ protected:
 		switch (state) {
 		case MonitoringIF::OUT_OF_RANGE:
 			EventManagerIF::triggerEvent(this->reportingId,
-			        violationEvent, this->parameterId.objectId,
-					this->parameterId.localPoolId);
+			        violationEvent, this->globalPoolId.objectId,
+					this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h
index 27e35aa7..c4448ced 100644
--- a/monitoring/LimitMonitor.h
+++ b/monitoring/LimitMonitor.h
@@ -80,11 +80,11 @@ protected:
 		switch (state) {
 		case MonitoringIF::BELOW_LOW_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, belowLowEvent,
-			        this->parameterId.objectId, this->parameterId.localPoolId);
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		case MonitoringIF::ABOVE_HIGH_LIMIT:
 			EventManagerIF::triggerEvent(this->reportingId, aboveHighEvent,
-			        this->parameterId.objectId, this->parameterId.localPoolId);
+			        this->globalPoolId.objectId, this->globalPoolId.localPoolId);
 			break;
 		default:
 			break;
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index d6d8c8ed..9028e7e4 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -20,7 +20,7 @@ public:
 
 	MonitorReporter(object_id_t reportingId, uint8_t monitorId,
 	        gp_id_t globalPoolId, uint16_t confirmationLimit) :
-			monitorId(monitorId), parameterId(parameterId),
+			monitorId(monitorId), globalPoolId(globalPoolId),
 			reportingId(reportingId), oldState(MonitoringIF::UNCHECKED),
 			reportingEnabled(ENABLED), eventEnabled(ENABLED), currentCounter(0),
 			confirmationLimit(confirmationLimit) {
@@ -96,7 +96,7 @@ public:
 
 protected:
 	const uint8_t monitorId;
-	const gp_id_t parameterId;
+	const gp_id_t globalPoolId;
 	object_id_t reportingId;
 	ReturnValue_t oldState;
 
@@ -167,13 +167,13 @@ protected:
 	 */
 	virtual void sendTransitionReport(T parameterValue, T crossedLimit,
 	        ReturnValue_t state) {
-		MonitoringReportContent<T> report(parameterId,
+		MonitoringReportContent<T> report(globalPoolId,
 				parameterValue, crossedLimit, oldState, state);
 		LimitViolationReporter::sendLimitViolationReport(&report);
 	}
 	ReturnValue_t setToState(ReturnValue_t state) {
 		if (oldState != state && reportingEnabled) {
-			MonitoringReportContent<T> report(parameterId, 0, 0, oldState,
+			MonitoringReportContent<T> report(globalPoolId, 0, 0, oldState,
 					state);
 			LimitViolationReporter::sendLimitViolationReport(&report);
 			oldState = state;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index ff9c7b3c..1c30d83f 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -72,19 +72,19 @@ ReturnValue_t Fuse::check() {
 	checkFuseState();
 	calculateFusePower();
 	//Check if power is valid and if fuse state is off or invalid.
-//	if (!power.isValid() || (state == 0) || !state.isValid()) {
-//		result = powerMonitor.setToInvalid();
-//	} else {
-//		float lowLimit = 0.0;
-//		float highLimit = RESIDUAL_POWER;
-//		calculatePowerLimits(&lowLimit, &highLimit);
-//		result = powerMonitor.checkPower(power, lowLimit, highLimit);
-//		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
-//			reportEvents(POWER_BELOW_LOW_LIMIT);
-//		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
-//			reportEvents(POWER_ABOVE_HIGH_LIMIT);
-//		}
-//	}
+	if (!power.isValid() || (state == 0) || !state.isValid()) {
+		result = powerMonitor.setToInvalid();
+	} else {
+		float lowLimit = 0.0;
+		float highLimit = RESIDUAL_POWER;
+		calculatePowerLimits(&lowLimit, &highLimit);
+		result = powerMonitor.checkPower(power.value, lowLimit, highLimit);
+		if (result == MonitoringIF::BELOW_LOW_LIMIT) {
+			reportEvents(POWER_BELOW_LOW_LIMIT);
+		} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
+			reportEvents(POWER_ABOVE_HIGH_LIMIT);
+		}
+	}
 	set.commit();
 	return result;
 }
@@ -135,7 +135,7 @@ void Fuse::calculateFusePower() {
 		return;
 	}
 	//Calculate fuse power.
-	//power = current * voltage;
+	power.value = current.value * voltage.value;
 	power.setValid(PoolVariableIF::VALID);
 }
 
@@ -188,20 +188,20 @@ void Fuse::checkFuseState() {
 		oldFuseState = 0;
 		return;
 	}
-//	if (state == 0) {
-//		if (oldFuseState != 0) {
-//			reportEvents(FUSE_WENT_OFF);
-//		}
-//	}
-//	oldFuseState = state;
+	if (state == 0) {
+		if (oldFuseState != 0) {
+			reportEvents(FUSE_WENT_OFF);
+		}
+	}
+	oldFuseState = state.value;
 }
 
 float Fuse::getPower() {
-//	if (power.isValid()) {
-//		return power;
-//	} else {
-//		return 0.0;
-//	}
+	if (power.isValid()) {
+		return power.value;
+	} else {
+		return 0.0;
+	}
 }
 
 void Fuse::setDataPoolEntriesInvalid() {
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 8fe3cf3a..1ef041e3 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -26,24 +26,24 @@ ReturnValue_t PowerSensor::calculatePower() {
 	powerSensorSet.read();
 	ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
 	ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
-//	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
-//			&& current.isValid()) {
-//		result1 = voltageLimit.doCheck(voltage);
-//		result2 = currentLimit.doCheck(current);
-//	} else {
-//		voltageLimit.setToInvalid();
-//		currentLimit.setToInvalid();
-//		result1 = OBJECT_NOT_HEALTHY;
-//	}
-//	if (result1 != HasReturnvaluesIF::RETURN_OK
-//			|| result2 != HasReturnvaluesIF::RETURN_OK) {
-//		result1 = MonitoringIF::INVALID;
-//		power.setValid(PoolVariableIF::INVALID);
-//	} else {
-//		power.setValid(PoolVariableIF::VALID);
-//		power = current * voltage;
-//	}
-//	powerSensorSet.commit();
+	if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
+			&& current.isValid()) {
+		result1 = voltageLimit.doCheck(voltage.value);
+		result2 = currentLimit.doCheck(current.value);
+	} else {
+		voltageLimit.setToInvalid();
+		currentLimit.setToInvalid();
+		result1 = OBJECT_NOT_HEALTHY;
+	}
+	if (result1 != HasReturnvaluesIF::RETURN_OK
+			|| result2 != HasReturnvaluesIF::RETURN_OK) {
+		result1 = MonitoringIF::INVALID;
+		power.setValid(PoolVariableIF::INVALID);
+	} else {
+		power.setValid(PoolVariableIF::VALID);
+		power.value = current.value * voltage.value;
+	}
+	powerSensorSet.commit();
 	return result1;
 }
 
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 53eeb58f..a64491c0 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -9,16 +9,18 @@ ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
 		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
 		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
 		heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
-		parameters(parameters), domainId(domainId) {
-		//temperatureMonitor(reportingObjectId, domainId + 1,
-		//        GlobalDataPool::poolIdAndPositionToPid(temperaturePoolId, 0),
-		//		COMPONENT_TEMP_CONFIRMATION), domainId(domainId) {
+		parameters(parameters), domainId(domainId),
+		temperatureMonitor(reportingObjectId, domainId + 1,temperaturePoolId,
+				COMPONENT_TEMP_CONFIRMATION) {
 	//Set thermal state once, then leave to operator.
-	//GlobDataSet mySet;
-	//gp_uint8_t writableTargetState(targetStatePoolId, &mySet,
-	//		PoolVariableIF::VAR_WRITE);
-	//writableTargetState = initialTargetState;
-	//mySet.commit(PoolVariableIF::VALID);
+	targetState.setReadWriteMode(PoolVariableIF::VAR_WRITE);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		targetState = initialTargetState;
+		targetState.setValid(true);
+		targetState.commit();
+	}
+	targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
 }
 
 void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
@@ -57,19 +59,21 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	HeaterRequest request = HEATER_DONT_CARE;
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
-	//updateMinMaxTemp();
-	//if ((temperature != INVALID_TEMPERATURE)) {
-		//temperature.setValid(PoolVariableIF::VALID);
-		//State state = getState(temperature, getParameters(), targetState);
-		//currentState = state;
-		//checkLimits(state);
-		//request = getHeaterRequest(targetState, temperature, getParameters());
-	//} else {
-	//	temperatureMonitor.setToInvalid();
-	//	temperature.setValid(PoolVariableIF::INVALID);
-	//	currentState = UNKNOWN;
-	//	request = HEATER_DONT_CARE;
-	//}
+	updateMinMaxTemp();
+	if ((temperature != INVALID_TEMPERATURE)) {
+		temperature.setValid(PoolVariableIF::VALID);
+		State state = getState(temperature.value, getParameters(),
+				targetState.value);
+		currentState = state;
+		checkLimits(state);
+		request = getHeaterRequest(targetState.value, temperature.value,
+				getParameters());
+	} else {
+		temperatureMonitor.setToInvalid();
+		temperature.setValid(PoolVariableIF::INVALID);
+		currentState = UNKNOWN;
+		request = HEATER_DONT_CARE;
+	}
 	currentState.setValid(PoolVariableIF::VALID);
 	heaterRequest = request;
 	heaterRequest.setValid(PoolVariableIF::VALID);
@@ -77,11 +81,11 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 }
 
 void ThermalComponentCore::markStateIgnored() {
-	//currentState = getIgnoredState(currentState);
+	currentState = getIgnoredState(currentState.value);
 }
 
 object_id_t ThermalComponentCore::getObjectId() {
-	//return temperatureMonitor.getReporterId();
+	return temperatureMonitor.getReporterId();
 	return 0;
 }
 
@@ -120,7 +124,7 @@ void ThermalComponentCore::setOutputInvalid() {
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
 	heaterRequest.setValid(PoolVariableIF::INVALID);
-	//temperatureMonitor.setToUnchecked();
+	temperatureMonitor.setToUnchecked();
 }
 
 float ThermalComponentCore::getTemperature() {
@@ -170,8 +174,8 @@ ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
 
 void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
 	//Checks operational limits only.
-	//temperatureMonitor.translateState(state, temperature.value,
-	//		getParameters().lowerOpLimit, getParameters().upperOpLimit);
+	temperatureMonitor.translateState(state, temperature.value,
+			getParameters().lowerOpLimit, getParameters().upperOpLimit);
 
 }
 
@@ -221,17 +225,17 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 	}
 }
 
-//void ThermalComponentCore::updateMinMaxTemp() {
-//	if (temperature == INVALID_TEMPERATURE) {
-//		return;
-//	}
-//	if (temperature < minTemp) {
-//		minTemp = temperature;
-//	}
-//	if (temperature > maxTemp) {
-//		maxTemp = temperature;
-//	}
-//}
+void ThermalComponentCore::updateMinMaxTemp() {
+	if (temperature == INVALID_TEMPERATURE) {
+		return;
+	}
+	if (temperature < minTemp) {
+		minTemp = temperature.value;
+	}
+	if (temperature > maxTemp) {
+		maxTemp = temperature.value;
+	}
+}
 
 uint8_t ThermalComponentCore::getDomainId() const {
 	return domainId;
@@ -244,38 +248,38 @@ ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
 ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
 		uint16_t parameterId, ParameterWrapper* parameterWrapper,
 		const ParameterWrapper* newValues, uint16_t startAtIndex) {
-	//ReturnValue_t result = temperatureMonitor.getParameter(domainId,
-	//		parameterId, parameterWrapper, newValues, startAtIndex);
-//	if (result != INVALID_DOMAIN_ID) {
-//		return result;
-//	}
-//	if (domainId != this->domainId) {
-//		return INVALID_DOMAIN_ID;
-//	}
-//	switch (parameterId) {
-//	case 0:
-//		parameterWrapper->set(parameters.heaterOn);
-//		break;
-//	case 1:
-//		parameterWrapper->set(parameters.hysteresis);
-//		break;
-//	case 2:
-//		parameterWrapper->set(parameters.heaterSwitchoff);
-//		break;
-//	case 3:
-//		parameterWrapper->set(minTemp);
-//		break;
-//	case 4:
-//		parameterWrapper->set(maxTemp);
-//		break;
-//	case 10:
-//		parameterWrapper->set(parameters.lowerOpLimit);
-//		break;
-//	case 11:
-//		parameterWrapper->set(parameters.upperOpLimit);
-//		break;
-//	default:
-//		return INVALID_IDENTIFIER_ID;
-//	}
+	ReturnValue_t result = temperatureMonitor.getParameter(domainId,
+			parameterId, parameterWrapper, newValues, startAtIndex);
+	if (result != INVALID_DOMAIN_ID) {
+		return result;
+	}
+	if (domainId != this->domainId) {
+		return INVALID_DOMAIN_ID;
+	}
+	switch (parameterId) {
+	case 0:
+		parameterWrapper->set(parameters.heaterOn);
+		break;
+	case 1:
+		parameterWrapper->set(parameters.hysteresis);
+		break;
+	case 2:
+		parameterWrapper->set(parameters.heaterSwitchoff);
+		break;
+	case 3:
+		parameterWrapper->set(minTemp);
+		break;
+	case 4:
+		parameterWrapper->set(maxTemp);
+		break;
+	case 10:
+		parameterWrapper->set(parameters.lowerOpLimit);
+		break;
+	case 11:
+		parameterWrapper->set(parameters.upperOpLimit);
+		break;
+	default:
+		return INVALID_IDENTIFIER_ID;
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 6ef59058..19d72359 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -96,10 +96,10 @@ protected:
 
 	Parameters parameters;
 
-	//ThermalMonitorReporter temperatureMonitor;
-
 	const uint8_t domainId;
 
+	ThermalMonitorReporter temperatureMonitor;
+
 	virtual float getTemperature();
 	virtual State getState(float temperature, Parameters parameters,
 			int8_t targetState);
@@ -111,7 +111,7 @@ protected:
 
 	virtual State getIgnoredState(int8_t state);
 
-	//void updateMinMaxTemp();
+	void updateMinMaxTemp();
 
 	virtual Parameters getParameters();
 };
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index ad258ced..37e5b849 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -2,7 +2,7 @@
 #define TCSDEFINITIONS_H_
 
 
-static const uint32_t INVALID_TEMPERATURE = 999;
+static const float INVALID_TEMPERATURE = 999;
 
 
 #endif /* TCSDEFINITIONS_H_ */

From f581b37fcf51415fe9f24ff22bb61aaf367739f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:25:09 +0100
Subject: [PATCH 1002/1292] thermal module replacements

---
 power/Fuse.h                     |  3 --
 power/PowerSensor.h              |  3 --
 thermal/ThermalComponent.cpp     | 33 +++++++------
 thermal/ThermalComponentCore.cpp | 39 +++++++--------
 thermal/ThermalComponentCore.h   |  2 -
 thermal/ThermalModule.cpp        | 84 +++++++++++++++++---------------
 thermal/ThermalModule.h          | 46 +++++++++--------
 7 files changed, 109 insertions(+), 101 deletions(-)

diff --git a/power/Fuse.h b/power/Fuse.h
index 5e54d294..e9e9290b 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -4,9 +4,6 @@
 #include "PowerComponentIF.h"
 #include "PowerSwitchIF.h"
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/AbsLimitMonitor.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/power/PowerSensor.h b/power/PowerSensor.h
index bb409f3e..a0ccb1ca 100644
--- a/power/PowerSensor.h
+++ b/power/PowerSensor.h
@@ -1,9 +1,6 @@
 #ifndef FSFW_POWER_POWERSENSOR_H_
 #define FSFW_POWER_POWERSENSOR_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../datapoolglob/PIDReader.h"
 #include "../datapoollocal/StaticLocalDataSet.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../monitoring/LimitMonitor.h"
diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 54bd67bd..4805fc9d 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -22,22 +22,23 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (newState) {
-	case STATE_REQUEST_NON_OPERATIONAL:
-		writableTargetState = newState;
-		mySet.commit(PoolVariableIF::VALID);
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return ThermalComponentCore::setTargetState(newState);
-	}
+//	GlobDataSet mySet;
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_READ_WRITE);
+//	mySet.read();
+//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
+//			&& (newState != STATE_REQUEST_IGNORE)) {
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	switch (newState) {
+//	case STATE_REQUEST_NON_OPERATIONAL:
+//		writableTargetState = newState;
+//		mySet.commit(PoolVariableIF::VALID);
+//		return HasReturnvaluesIF::RETURN_OK;
+//	default:
+//		return ThermalComponentCore::setTargetState(newState);
+//	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index a64491c0..81d9326f 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -96,25 +96,26 @@ float ThermalComponentCore::getLowerOpLimit() {
 
 
 ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
-	GlobDataSet mySet;
-	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_READ_WRITE);
-	mySet.read();
-	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-			&& (newState != STATE_REQUEST_IGNORE)) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (newState) {
-	case STATE_REQUEST_HEATING:
-	case STATE_REQUEST_IGNORE:
-	case STATE_REQUEST_OPERATIONAL:
-		writableTargetState = newState;
-		break;
-	case STATE_REQUEST_NON_OPERATIONAL:
-	default:
-		return INVALID_TARGET_STATE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
+//	GlobDataSet mySet;
+//	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_READ_WRITE);
+//	mySet.read();
+//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
+//			&& (newState != STATE_REQUEST_IGNORE)) {
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	switch (newState) {
+//	case STATE_REQUEST_HEATING:
+//	case STATE_REQUEST_IGNORE:
+//	case STATE_REQUEST_OPERATIONAL:
+//		writableTargetState = newState;
+//		break;
+//	case STATE_REQUEST_NON_OPERATIONAL:
+//	default:
+//		return INVALID_TARGET_STATE;
+//	}
+//	mySet.commit(PoolVariableIF::VALID);
+//	return HasReturnvaluesIF::RETURN_OK;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/thermal/ThermalComponentCore.h b/thermal/ThermalComponentCore.h
index 19d72359..da9424e6 100644
--- a/thermal/ThermalComponentCore.h
+++ b/thermal/ThermalComponentCore.h
@@ -6,8 +6,6 @@
 #include "AbstractTemperatureSensor.h"
 #include "ThermalModule.h"
 
-//#include "../datapoolglob/GlobalDataSet.h"
-//#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
 /**
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index fbd6939e..2bc1741f 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -1,28 +1,31 @@
-#include "../monitoring/LimitViolationReporter.h"
-#include "../monitoring/MonitoringMessageContent.h"
 #include "ThermalModule.h"
-
 #include "AbstractTemperatureSensor.h"
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId,
-		uint32_t currentStatePoolId, uint32_t targetStatePoolId,
-		GlobDataSet *dataSet, Parameters parameters,
+#include "../monitoring/LimitViolationReporter.h"
+#include "../monitoring/MonitoringMessageContent.h"
+
+
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
+		LocalPoolDataSetBase *dataSet, Parameters parameters,
 		RedundantHeater::Parameters heaterParameters) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters(parameters), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), currentState(
-				currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE), targetState(
-				targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
+		oldStrategy(ACTIVE_SINGLE), parameters(parameters),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
+		targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
 	heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet* dataSet) :
-		oldStrategy(ACTIVE_SINGLE), survivalTargetTemp(0), targetTemp(0), heating(
-				false), parameters( { 0, 0 }), moduleTemperature(
-				moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE), heater(
-				NULL), currentState(PoolVariableIF::INVALID, dataSet,
-				PoolVariableIF::VAR_WRITE), targetState(PoolVariableIF::INVALID,
-				dataSet, PoolVariableIF::VAR_READ) {
+ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
+		LocalPoolDataSetBase* dataSet) :
+		oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
+		moduleTemperature(moduleTemperaturePoolId, dataSet,
+				PoolVariableIF::VAR_WRITE),
+		currentState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_WRITE),
+		targetState(gp_id_t(), dataSet,
+				PoolVariableIF::VAR_READ) {
 }
 
 ThermalModule::~ThermalModule() {
@@ -30,7 +33,7 @@ ThermalModule::~ThermalModule() {
 }
 
 void ThermalModule::performOperation(uint8_t opCode) {
-	if (heater != NULL) {
+	if (heater != nullptr) {
 		heater->performOperation(0);
 	}
 }
@@ -42,7 +45,7 @@ void ThermalModule::performMode(Strategy strategy) {
 	ThermalComponentIF::HeaterRequest componentHeaterRequest =
 			letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
 
-	if (heater == NULL) {
+	if (heater == nullptr) {
 		informComponentsAboutHeaterState(false, NONE);
 		return;
 	}
@@ -53,8 +56,8 @@ void ThermalModule::performMode(Strategy strategy) {
 		//Components overwrite the module request.
 		heating = ((componentHeaterRequest
 				== ThermalComponentIF::HEATER_REQUEST_ON)
-				|| (componentHeaterRequest
-						== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
+				or (componentHeaterRequest
+				== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
 	}
 
 	bool dual = (strategy == ACTIVE_DUAL);
@@ -76,7 +79,7 @@ void ThermalModule::performMode(Strategy strategy) {
 }
 
 float ThermalModule::getTemperature() {
-	return moduleTemperature;
+	return moduleTemperature.value;
 }
 
 void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
@@ -85,7 +88,8 @@ void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
 
 void ThermalModule::registerComponent(ThermalComponentIF* component,
 		ThermalComponentIF::Priority priority) {
-	components.push_back(ComponentData( { component, priority, ThermalComponentIF::HEATER_DONT_CARE }));
+	components.push_back(ComponentData( { component, priority,
+		ThermalComponentIF::HEATER_DONT_CARE }));
 }
 
 void ThermalModule::calculateTemperature() {
@@ -94,12 +98,13 @@ void ThermalModule::calculateTemperature() {
 	std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
 	for (; iter != sensors.end(); iter++) {
 		if ((*iter)->isValid()) {
-			moduleTemperature = moduleTemperature + (*iter)->getTemperature();
+			moduleTemperature = moduleTemperature.value +
+					(*iter)->getTemperature();
 			numberOfValidSensors++;
 		}
 	}
 	if (numberOfValidSensors != 0) {
-		moduleTemperature = moduleTemperature / numberOfValidSensors;
+		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
 		moduleTemperature = INVALID_TEMPERATURE;
@@ -117,9 +122,10 @@ ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
 	return NULL;
 }
 
-ThermalComponentIF::HeaterRequest ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(
-		bool safeOnly) {
-	ThermalComponentIF::HeaterRequest heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
+ThermalComponentIF::HeaterRequest
+ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
+	ThermalComponentIF::HeaterRequest
+	heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
 
 	survivalTargetTemp = -999;
 	targetTemp = -999;
@@ -224,7 +230,7 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		limit = survivalTargetTemp;
 	}
 
-	if (moduleTemperature >= limit) {
+	if (moduleTemperature.value >= limit) {
 		currentState = OPERATIONAL;
 	} else {
 		currentState = NON_OPERATIONAL;
@@ -250,15 +256,15 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-	GlobDataSet mySet;
-	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-			&mySet, PoolVariableIF::VAR_WRITE);
-	if (on) {
-		writableTargetState = STATE_REQUEST_HEATING;
-	} else {
-		writableTargetState = STATE_REQUEST_PASSIVE;
-	}
-	mySet.commit(PoolVariableIF::VALID);
+//	GlobDataSet mySet;
+//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
+//			&mySet, PoolVariableIF::VAR_WRITE);
+//	if (on) {
+//		writableTargetState = STATE_REQUEST_HEATING;
+//	} else {
+//		writableTargetState = STATE_REQUEST_PASSIVE;
+//	}
+//	mySet.commit(PoolVariableIF::VALID);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index 41be6baa..d1e4fccb 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -1,14 +1,20 @@
-#ifndef THERMALMODULE_H_
-#define THERMALMODULE_H_
+#ifndef FSFW_THERMAL_THERMALMODULE_H_
+#define FSFW_THERMAL_THERMALMODULE_H_
 
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../events/EventReportingProxyIF.h"
 #include "ThermalModuleIF.h"
-#include <list>
 #include "tcsDefinitions.h"
 #include "RedundantHeater.h"
+
+//#include "../datapoolglob/GlobalDataSet.h"
+//#include "../datapoolglob/GlobalPoolVariable.h"
+#include "../datapoollocal/LocalPoolDataSetBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+#include "../devicehandlers/HealthDevice.h"
+#include "../events/EventReportingProxyIF.h"
+
+#include <list>
+
+
 class PowerSwitchIF;
 
 /**
@@ -22,11 +28,12 @@ public:
 		float hysteresis;
 	};
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, uint32_t currentStatePoolId,
-			uint32_t targetStatePoolId, GlobDataSet *dataSet, Parameters parameters,
-			RedundantHeater::Parameters heaterParameters);
+	ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
+			gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet,
+			Parameters parameters, RedundantHeater::Parameters heaterParameters);
 
-	ThermalModule(uint32_t moduleTemperaturePoolId, GlobDataSet *dataSet);
+	ThermalModule(gp_id_t moduleTemperaturePoolId,
+			LocalPoolDataSetBase *dataSet);
 
 	virtual ~ThermalModule();
 
@@ -62,20 +69,21 @@ protected:
 
 	Strategy oldStrategy;
 
-	float survivalTargetTemp;
+	float survivalTargetTemp = 0.0;
 
-	float targetTemp;
+	float targetTemp = 0.0;
 
-	bool heating;
+	bool heating = false;
 
 	Parameters parameters;
 
-	gp_float_t moduleTemperature;
+	lp_var_t<float> moduleTemperature;
+	//gp_float_t moduleTemperature;
 
-	RedundantHeater *heater;
+	RedundantHeater *heater = nullptr;
 
-	gp_int8_t currentState;
-	gp_int8_t targetState;
+	lp_var_t<int8_t> currentState;
+	lp_var_t<int8_t> targetState;
 
 	std::list<AbstractTemperatureSensor *> sensors;
 	std::list<ComponentData> components;
@@ -92,4 +100,4 @@ protected:
 	void updateTargetTemperatures(ThermalComponentIF *component, bool isSafe);
 };
 
-#endif /* THERMALMODULE_H_ */
+#endif /* FSFW_THERMAL_THERMALMODULE_H_ */

From f108ae883c1a19eaa74f1c67cd4278815c98538a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:28:16 +0100
Subject: [PATCH 1003/1292] local pool replacement

---
 thermal/ThermalComponentCore.cpp | 39 ++++++++++++++++----------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 81d9326f..29f9e25d 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -96,26 +96,25 @@ float ThermalComponentCore::getLowerOpLimit() {
 
 
 ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
-//	GlobDataSet mySet;
-//	gp_uint8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_READ_WRITE);
-//	mySet.read();
-//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-//			&& (newState != STATE_REQUEST_IGNORE)) {
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	switch (newState) {
-//	case STATE_REQUEST_HEATING:
-//	case STATE_REQUEST_IGNORE:
-//	case STATE_REQUEST_OPERATIONAL:
-//		writableTargetState = newState;
-//		break;
-//	case STATE_REQUEST_NON_OPERATIONAL:
-//	default:
-//		return INVALID_TARGET_STATE;
-//	}
-//	mySet.commit(PoolVariableIF::VALID);
-//	return HasReturnvaluesIF::RETURN_OK;
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if((targetState == STATE_REQUEST_OPERATIONAL) and
+			(newState != STATE_REQUEST_IGNORE)) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	switch (newState) {
+	case STATE_REQUEST_HEATING:
+	case STATE_REQUEST_IGNORE:
+	case STATE_REQUEST_OPERATIONAL:
+		targetState = newState;
+		break;
+	case STATE_REQUEST_NON_OPERATIONAL:
+	default:
+		return INVALID_TARGET_STATE;
+	}
+	targetState.setValid(true);
+	targetState.commit();
 	return HasReturnvaluesIF::RETURN_OK;
 }
 

From d1beb96c6030c82bf20d65eea0196cb4d904c8a2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 16:30:20 +0100
Subject: [PATCH 1004/1292] some more replacements

---
 thermal/ThermalComponent.cpp | 46 ++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/thermal/ThermalComponent.cpp b/thermal/ThermalComponent.cpp
index 4805fc9d..084201dd 100644
--- a/thermal/ThermalComponent.cpp
+++ b/thermal/ThermalComponent.cpp
@@ -22,22 +22,21 @@ ThermalComponent::~ThermalComponent() {
 }
 
 ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
-//	GlobDataSet mySet;
-//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_READ_WRITE);
-//	mySet.read();
-//	if ((writableTargetState == STATE_REQUEST_OPERATIONAL)
-//			&& (newState != STATE_REQUEST_IGNORE)) {
-//		return HasReturnvaluesIF::RETURN_FAILED;
-//	}
-//	switch (newState) {
-//	case STATE_REQUEST_NON_OPERATIONAL:
-//		writableTargetState = newState;
-//		mySet.commit(PoolVariableIF::VALID);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	default:
-//		return ThermalComponentCore::setTargetState(newState);
-//	}
+	targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+	targetState.read();
+	if ((targetState == STATE_REQUEST_OPERATIONAL)
+			and (newState != STATE_REQUEST_IGNORE)) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	switch (newState) {
+	case STATE_REQUEST_NON_OPERATIONAL:
+		targetState = newState;
+		targetState.setValid(true);
+		targetState.commit(PoolVariableIF::VALID);
+		return HasReturnvaluesIF::RETURN_OK;
+	default:
+		return ThermalComponentCore::setTargetState(newState);
+	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -79,13 +78,14 @@ ThermalComponentIF::State ThermalComponent::getState(float temperature,
 }
 
 void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
-	//if (targetState == STATE_REQUEST_OPERATIONAL || targetState == STATE_REQUEST_IGNORE) {
-	//	ThermalComponentCore::checkLimits(state);
-	//	return;
-	//}
-	//If component is not operational, it checks the NOP limits.
-	//temperatureMonitor.translateState(state, temperature.value,
-	//		nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
+	if ((targetState == STATE_REQUEST_OPERATIONAL) or
+			(targetState == STATE_REQUEST_IGNORE)) {
+		ThermalComponentCore::checkLimits(state);
+		return;
+	}
+	// If component is not operational, it checks the NOP limits.
+	temperatureMonitor.translateState(state, temperature.value,
+			nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
 }
 
 ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(

From ef2e07b3891a3c2a2429d973d5db68208db7e526 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 30 Nov 2020 17:03:14 +0100
Subject: [PATCH 1005/1292] added explicit type conversion operator

---
 datapoollocal/LocalPoolVariable.h   |  4 ++++
 datapoollocal/LocalPoolVariable.tpp | 32 ++++++++++++++++-------------
 thermal/ThermalComponentCore.cpp    |  6 +++---
 3 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index bb36089d..c18d5443 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -121,6 +121,10 @@ public:
 	LocalPoolVar<T> &operator=(const T& newValue);
 	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
 
+	//! Explicit type conversion operator. Allows casting the class to
+	//! its template type to perform operations on value.
+	explicit operator T() const;
+
 	bool operator==(const LocalPoolVar<T>& other) const;
 	bool operator==(const T& other) const;
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a63e550d..b9f7b906 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -80,20 +80,6 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 	return RETURN_OK;
 }
 
-template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
-    value = newValue;
-    return *this;
-}
-
-template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
-	value = newPoolVariable.value;
-	return *this;
-}
-
-
 template<typename T>
 inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
@@ -119,6 +105,24 @@ inline std::ostream& operator<< (std::ostream &out,
     return out;
 }
 
+template<typename T>
+inline LocalPoolVar<T>::operator T() const {
+	return value;
+}
+
+template<typename T>
+inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+    value = newValue;
+    return *this;
+}
+
+template<typename T>
+inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
+		const LocalPoolVar<T>& newPoolVariable) {
+	value = newPoolVariable.value;
+	return *this;
+}
+
 template<typename T>
 inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
 	return this->value == other.value;
diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 29f9e25d..7b594d0c 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -60,7 +60,7 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
 	updateMinMaxTemp();
-	if ((temperature != INVALID_TEMPERATURE)) {
+	if (temperature != INVALID_TEMPERATURE) {
 		temperature.setValid(PoolVariableIF::VALID);
 		State state = getState(temperature.value, getParameters(),
 				targetState.value);
@@ -230,10 +230,10 @@ void ThermalComponentCore::updateMinMaxTemp() {
 		return;
 	}
 	if (temperature < minTemp) {
-		minTemp = temperature.value;
+		minTemp = static_cast<float>(temperature);
 	}
 	if (temperature > maxTemp) {
-		maxTemp = temperature.value;
+		maxTemp = static_cast<float>(temperature);
 	}
 }
 

From f357de21c9b37a5ca384590be0d511c0c503aa16 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:23:51 +0100
Subject: [PATCH 1006/1292] updated testcfg

---
 unittest/testcfg/objects/translateObjects.cpp | 242 ------------------
 unittest/testcfg/objects/translateObjects.h   |  16 --
 2 files changed, 258 deletions(-)
 delete mode 100644 unittest/testcfg/objects/translateObjects.cpp
 delete mode 100644 unittest/testcfg/objects/translateObjects.h

diff --git a/unittest/testcfg/objects/translateObjects.cpp b/unittest/testcfg/objects/translateObjects.cpp
deleted file mode 100644
index abcb1b40..00000000
--- a/unittest/testcfg/objects/translateObjects.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/* Auto-generated event translation file. Contains 77 translations. */
-#include <fsfw/unittest/config/objects/translateObjects.h>
-
-const char *AT91_UART2_TEST_TASK_STRING = "AT91_UART2_TEST_TASK";
-const char *ARDUINO_0_STRING = "ARDUINO_0";
-const char *ARDUINO_1_STRING = "ARDUINO_1";
-const char *ARDUINO_2_STRING = "ARDUINO_2";
-const char *ARDUINO_3_STRING = "ARDUINO_3";
-const char *ARDUINO_4_STRING = "ARDUINO_4";
-const char *AT91_I2C_TEST_TASK_STRING = "AT91_I2C_TEST_TASK";
-const char *TEST_TASK_STRING = "TEST_TASK";
-const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
-const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
-const char *S_ADC1_DEC2_STRING = "S_ADC1_DEC2";
-const char *GPS0_HANDLER_STRING = "GPS0_HANDLER";
-const char *DLR_PVCH_STRING = "DLR_PVCH";
-const char *GYRO1_STRING = "GYRO1";
-const char *DLR_IRAS_STRING = "DLR_IRAS";
-const char *_DEC1_O1_STRING = "_DEC1_O1";
-const char *_DEC1_O2_STRING = "_DEC1_O2";
-const char *S1_DEC1_O3_STRING = "S1_DEC1_O3";
-const char *S2_DEC1_O4_STRING = "S2_DEC1_O4";
-const char *S3_DEC1_O5_STRING = "S3_DEC1_O5";
-const char *PT1000_PVHC_DEC1_O6_STRING = "PT1000_PVHC_DEC1_O6";
-const char *PT1000_CCSDS1_DEC2_STRING = "PT1000_CCSDS1_DEC2";
-const char *PT1000_MGT1_DEC2_STRING = "PT1000_MGT1_DEC2";
-const char *S4_DEC2_STRING = "S4_DEC2";
-const char *S5_DEC2_STRING = "S5_DEC2";
-const char *S6_DEC2_STRING = "S6_DEC2";
-const char *PT1000_PVCH_DEC2_STRING = "PT1000_PVCH_DEC2";
-const char *_DEC3_STRING = "_DEC3";
-const char *PT1000_CCSDS2_DEC3_STRING = "PT1000_CCSDS2_DEC3";
-const char *S7_DEC3_STRING = "S7_DEC3";
-const char *S8_DEC3_STRING = "S8_DEC3";
-const char *PT1000_PVCH_DEC3_STRING = "PT1000_PVCH_DEC3";
-const char *GYRO2_STRING = "GYRO2";
-const char *PT1000_PLOC_DEC4_STRING = "PT1000_PLOC_DEC4";
-const char *S9_DEC4_STRING = "S9_DEC4";
-const char *S10_DEC4_STRING = "S10_DEC4";
-const char *PT1000_PVHC_DEC4_STRING = "PT1000_PVHC_DEC4";
-const char *S_ADC_DEC4_STRING = "S_ADC_DEC4";
-const char *GPS1_HANDLER_STRING = "GPS1_HANDLER";
-const char *DUMMY_GPS_COM_IF_STRING = "DUMMY_GPS_COM_IF";
-const char *RS232_DEVICE_COM_IF_STRING = "RS232_DEVICE_COM_IF";
-const char *I2C_DEVICE_COM_IF_STRING = "I2C_DEVICE_COM_IF";
-const char *GPIO_DEVICE_COM_IF_STRING = "GPIO_DEVICE_COM_IF";
-const char *SPI_POLLING_TASK_STRING = "SPI_POLLING_TASK";
-const char *SPI_DEVICE_COM_IF_STRING = "SPI_DEVICE_COM_IF";
-const char *DUMMY_ECHO_COM_IF_STRING = "DUMMY_ECHO_COM_IF";
-const char *SD_CARD_HANDLER_STRING = "SD_CARD_HANDLER";
-const char *CCSDS_PACKET_DISTRIBUTOR_STRING = "CCSDS_PACKET_DISTRIBUTOR";
-const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
-const char *UDP_TMTC_BRIDGE_STRING = "UDP_TMTC_BRIDGE";
-const char *EMAC_POLLING_TASK_STRING = "EMAC_POLLING_TASK";
-const char *SERIAL_POLLING_TASK_STRING = "SERIAL_POLLING_TASK";
-const char *UART_TMTC_BRIDGE_STRING = "UART_TMTC_BRIDGE";
-const char *PUS_SERVICE_1_STRING = "PUS_SERVICE_1";
-const char *PUS_SERVICE_2_STRING = "PUS_SERVICE_2";
-const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
-const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
-const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
-const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
-const char *PUS_SERVICE_9_STRING = "PUS_SERVICE_9";
-const char *PUS_SERVICE_17_STRING = "PUS_SERVICE_17";
-const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
-const char *PUS_SERVICE_200_STRING = "PUS_SERVICE_200";
-const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
-const char *PUS_TIME_STRING = "PUS_TIME";
-const char *PUS_FUNNEL_STRING = "PUS_FUNNEL";
-const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
-const char *MODE_STORE_STRING = "MODE_STORE";
-const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
-const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
-const char *TC_STORE_STRING = "TC_STORE";
-const char *TM_STORE_STRING = "TM_STORE";
-const char *IPC_STORE_STRING = "IPC_STORE";
-const char *AT91_SPI_TEST_TASK_STRING = "AT91_SPI_TEST_TASK";
-const char *STM32_TEST_TASK_STRING = "STM32_TEST_TASK";
-const char *AT91_UART0_TEST_TASK_STRING = "AT91_UART0_TEST_TASK";
-const char *NO_OBJECT_STRING = "NO_OBJECT";
-
-const char* translateObject(object_id_t object){
-	switch((object&0xFFFFFFFF)){
-		case 0x000123336:
-			return AT91_UART2_TEST_TASK_STRING;
-		case 0x01010100:
-			return ARDUINO_0_STRING;
-		case 0x01010101:
-			return ARDUINO_1_STRING;
-		case 0x01010102:
-			return ARDUINO_2_STRING;
-		case 0x01010103:
-			return ARDUINO_3_STRING;
-		case 0x01010104:
-			return ARDUINO_4_STRING;
-		case 0x12345678:
-			return AT91_I2C_TEST_TASK_STRING;
-		case 0x42694269:
-			return TEST_TASK_STRING;
-		case 0x44003200:
-			return PCDU_HANDLER_STRING;
-		case 0x4400AFFE:
-			return DUMMY_HANDLER_STRING;
-		case 0x44020108:
-			return S_ADC1_DEC2_STRING;
-		case 0x44101F00:
-			return GPS0_HANDLER_STRING;
-		case 0x44104000:
-			return DLR_PVCH_STRING;
-		case 0x44105000:
-			return GYRO1_STRING;
-		case 0x44106000:
-			return DLR_IRAS_STRING;
-		case 0x44115401:
-			return _DEC1_O1_STRING;
-		case 0x44115402:
-			return _DEC1_O2_STRING;
-		case 0x44115404:
-			return S1_DEC1_O3_STRING;
-		case 0x44115405:
-			return S2_DEC1_O4_STRING;
-		case 0x44115406:
-			return S3_DEC1_O5_STRING;
-		case 0x44115407:
-			return PT1000_PVHC_DEC1_O6_STRING;
-		case 0x44125401:
-			return PT1000_CCSDS1_DEC2_STRING;
-		case 0x44125403:
-			return PT1000_MGT1_DEC2_STRING;
-		case 0x44125404:
-			return S4_DEC2_STRING;
-		case 0x44125405:
-			return S5_DEC2_STRING;
-		case 0x44125406:
-			return S6_DEC2_STRING;
-		case 0x44125407:
-			return PT1000_PVCH_DEC2_STRING;
-		case 0x44130301:
-			return _DEC3_STRING;
-		case 0x44130302:
-			return PT1000_CCSDS2_DEC3_STRING;
-		case 0x44130305:
-			return S7_DEC3_STRING;
-		case 0x44130306:
-			return S8_DEC3_STRING;
-		case 0x44130307:
-			return PT1000_PVCH_DEC3_STRING;
-		case 0x44130308:
-			return GYRO2_STRING;
-		case 0x44145401:
-			return PT1000_PLOC_DEC4_STRING;
-		case 0x44145404:
-			return S9_DEC4_STRING;
-		case 0x44145405:
-			return S10_DEC4_STRING;
-		case 0x44145406:
-			return PT1000_PVHC_DEC4_STRING;
-		case 0x44145407:
-			return S_ADC_DEC4_STRING;
-		case 0x44202000:
-			return GPS1_HANDLER_STRING;
-		case 0x49001F00:
-			return DUMMY_GPS_COM_IF_STRING;
-		case 0x49005200:
-			return RS232_DEVICE_COM_IF_STRING;
-		case 0x49005300:
-			return I2C_DEVICE_COM_IF_STRING;
-		case 0x49005400:
-			return GPIO_DEVICE_COM_IF_STRING;
-		case 0x49005410:
-			return SPI_POLLING_TASK_STRING;
-		case 0x49005600:
-			return SPI_DEVICE_COM_IF_STRING;
-		case 0x4900AFFE:
-			return DUMMY_ECHO_COM_IF_STRING;
-		case 0x4D0073AD:
-			return SD_CARD_HANDLER_STRING;
-		case 0x50000100:
-			return CCSDS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000200:
-			return PUS_PACKET_DISTRIBUTOR_STRING;
-		case 0x50000300:
-			return UDP_TMTC_BRIDGE_STRING;
-		case 0x50000400:
-			return EMAC_POLLING_TASK_STRING;
-		case 0x50000600:
-			return SERIAL_POLLING_TASK_STRING;
-		case 0x5000500:
-			return UART_TMTC_BRIDGE_STRING;
-		case 0x51000100:
-			return PUS_SERVICE_1_STRING;
-		case 0x51000200:
-			return PUS_SERVICE_2_STRING;
-		case 0x51000300:
-			return PUS_SERVICE_3_STRING;
-		case 0x51000400:
-			return PUS_SERVICE_5_STRING;
-		case 0x51000500:
-			return PUS_SERVICE_6_STRING;
-		case 0x51000800:
-			return PUS_SERVICE_8_STRING;
-		case 0x51000900:
-			return PUS_SERVICE_9_STRING;
-		case 0x51001700:
-			return PUS_SERVICE_17_STRING;
-		case 0x51002300:
-			return PUS_SERVICE_23_STRING;
-		case 0x51020000:
-			return PUS_SERVICE_200_STRING;
-		case 0x51020100:
-			return PUS_SERVICE_201_STRING;
-		case 0x52000001:
-			return PUS_TIME_STRING;
-		case 0x52000002:
-			return PUS_FUNNEL_STRING;
-		case 0x53010000:
-			return HEALTH_TABLE_STRING;
-		case 0x53010100:
-			return MODE_STORE_STRING;
-		case 0x53030000:
-			return EVENT_MANAGER_STRING;
-		case 0x53040000:
-			return INTERNAL_ERROR_REPORTER_STRING;
-		case 0x534f0100:
-			return TC_STORE_STRING;
-		case 0x534f0200:
-			return TM_STORE_STRING;
-		case 0x534f0300:
-			return IPC_STORE_STRING;
-		case 0x66666666:
-			return AT91_SPI_TEST_TASK_STRING;
-		case 0x77777777:
-			return STM32_TEST_TASK_STRING;
-		case 0x87654321:
-			return AT91_UART0_TEST_TASK_STRING;
-		case 0xFFFFFFFF:
-			return NO_OBJECT_STRING;
-		default:
-			return "UNKNOWN_OBJECT";
-	}
-	return 0;
-}
diff --git a/unittest/testcfg/objects/translateObjects.h b/unittest/testcfg/objects/translateObjects.h
deleted file mode 100644
index 18c237eb..00000000
--- a/unittest/testcfg/objects/translateObjects.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * translateObjects.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
-#ifndef CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-#define CONFIG_OBJECTS_TRANSLATEOBJECTS_H_
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-
-const char* translateObject(object_id_t object);
-
-
-#endif /* CONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

From e323c69f20da5b2321fbecd5ef2ab84dc1b2060d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 13:36:30 +0100
Subject: [PATCH 1007/1292] better name for preproc define

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 8 ++++----
 storagemanager/LocalPool.cpp       | 9 +++++----
 storagemanager/PoolManager.cpp     | 3 ++-
 unittest/testcfg/FSFWConfig.h      | 2 +-
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index f475e3fa..1386bf66 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -8,12 +8,12 @@
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 8e5f4d48..74e362d4 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -1,4 +1,5 @@
 #include "LocalPool.h"
+#include <FSFWConfig.h>
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
@@ -116,7 +117,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 }
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
 
@@ -155,7 +156,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             // element of an object.
             localId.packetIndex = deltaAddress / elementSizes[n];
             result = deleteData(localId);
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
@@ -222,7 +223,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
     }
     if (status == RETURN_OK) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
@@ -264,7 +265,7 @@ void LocalPool::setToSpillToHigherPools(bool enable) {
 ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
 #endif
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 9c801a3d..3b7b549b 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -1,4 +1,5 @@
 #include "PoolManager.h"
+#include <FSFWConfig.h>
 
 PoolManager::PoolManager(object_id_t setObjectId,
         const LocalPoolConfig& localPoolConfig):
@@ -24,7 +25,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
-#if FSFW_DEBUGGING == 1
+#if FSFW_VERBOSE_PRINTOUT == 2
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c1..d3451985 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -12,7 +12,7 @@
 #define FSFW_REDUCED_PRINTOUT		0
 
 //! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
+#define FSFW_VERBOSE_PRINTOUT       0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle

From e0f063f232f92931f17d874de122d9c30c795d73 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:14:44 +0100
Subject: [PATCH 1008/1292] comment added

---
 memory/HasFileSystemIF.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/memory/HasFileSystemIF.h b/memory/HasFileSystemIF.h
index 20ef727e..dcec6346 100644
--- a/memory/HasFileSystemIF.h
+++ b/memory/HasFileSystemIF.h
@@ -8,7 +8,9 @@
 #include <cstddef>
 
 /**
- * @author  Jakob Meier
+ * @brief	Generic interface for objects which expose a file system to enable
+ * 			message based file handling.
+ * @author  J. Meier, R. Mueller
  */
 class HasFileSystemIF {
 public:

From 314dc577b547f734ef32b0552d109a9b5f88e7b4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:19:00 +0100
Subject: [PATCH 1009/1292] added changelog from upstream

---
 CHANGELOG | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 CHANGELOG

diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 00000000..a6686478
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,13 @@
+## Changes from ASTP 0.0.1 to 1.0.0
+
+
+### 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

From 84ab5f83189481909f23dc7016082f51010fdfa0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 17:19:26 +0100
Subject: [PATCH 1010/1292] readme and logo update

---
 README.md                | 161 ++++++++-
 logo/FSFW_Logo_V3.png    | Bin 0 -> 137423 bytes
 logo/FSFW_Logo_V3.svg    | 711 +++++++++++++++++++++++++++++++++++++++
 logo/FSFW_Logo_V3_bw.png | Bin 0 -> 13369 bytes
 4 files changed, 869 insertions(+), 3 deletions(-)
 create mode 100644 logo/FSFW_Logo_V3.png
 create mode 100644 logo/FSFW_Logo_V3.svg
 create mode 100644 logo/FSFW_Logo_V3_bw.png

diff --git a/README.md b/README.md
index fc86fca7..4aabe36a 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,159 @@
-Flight Software Framework (FSFW)
-======
+![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+# Flight Software Framework (FSFW)
 
-I want to be written!
+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.
+
+## Intended Use
+
+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 recommended hardware is a microprocessor with more than 2 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.
+
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses Run-time type information.
+Exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something is gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. A independent OSAL called "host" is currently not finished. This aims to be running on windows as well. 
+The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
+
+### Core Components 
+
+Clock:
+ * This is a class of static functions that can be used at anytime
+ * Leap Seconds must be set if any time conversions from UTC to other times is used
+
+ObjectManager (must be created): 
+
+* The component which handles all references. All SystemObjects register at this component. 
+* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
+* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
+A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
+
+``` c++
+	template <typename T> T* ObjectManagerIF::get( object_id_t id )
+
+```
+* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
+By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+
+Event Manager:
+
+* Component which allows routing of events
+* Other objects can subscribe to specific events, ranges of events or all events of an object.
+* Subscriptions can be done during runtime but should be done during initialization
+* Amounts of allowed subscriptions must be configured by setting this parameters:
+
+``` c++
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+```
+
+
+Health Table:
+
+* A component which holds every health state 
+* Provides a thread safe way to access all health states without the need of message exchanges
+
+Stores
+
+* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can be exchanged with Stores. With this, only the store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* All of them should use the Thread Safe Class storagemanager/PoolManager
+
+Tasks
+
+There are two different types of tasks:
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+
+
+### Static Ids in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### DeviceHandling
+
+DeviceHandlers are a core component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Example config
+
+A example config can be found in defaultcfg/fsfwconfig.
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
+See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/logo/FSFW_Logo_V3.png b/logo/FSFW_Logo_V3.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ac710dd2069446e8f10108716f4c0e97bc961b9
GIT binary patch
literal 137423
zcmYIv1yI!A_ckHYDcy}UOCzN;E1^qwcY}1N^s+Qk(t;pe(%mJ}-AKa%OY>j-&hLGh
zVRqSJKlj`d&wWnZs1GXg*cjv(2nYz+iV89y1cVn+2nZ;gXfNTPcqtGP!e3svNhzwM
z!GHYF%p>7{qdP0;xFH}Y&HVjE{BhAW0{@WgldSe9H7CnYo+hpq2%esvTsDq&Ze}LV
z7F<rQR+%Sa<Om3~2#PZA)V;EfRy?yP-5+nx=d7+z5))oXDTLzD1|uk9(Y}z0#`|bb
z%jWZo5T6c-Jo*zFN1oy<Iw`bwAHF!F8KI=)=F23je4s^QEyTxuAti-w<0*Q&M&sGo
zXkqCwY<1eunhPFaY81`&KE1arY2V}Hds&nWD$^X(ZbvU|_}GNSvV$WvO3M@a_9cTQ
zn%ql7_#3)$?5wJ>9r0{eMZUDyUYGtPQ?bn>1YWG3Su{O_wqRx+|6r^$lL76+cbcKK
z1m;X<I8|7Hm@Weu=`GWC(W7kYyO`uMN?2tUjvuxcNsnk#`TmVRlj-V9Z<0}r<$fVy
z+vybXtO^j2)xtnpmE~(P2*~8R6=Ha4M;<>Stlyt#O2}2f6B{ynjDU)YHw_4>d$wX^
ziA2;d5uL_y*v-!?ByY#sg?7H{#6!>@eB#Uw1n%X|KgnUtx3VWJ)O<JD)B7a>D#i}D
zS`$Evc}Gk)etP?KCOUk+_gZ60KdF0=2digaTdbz$5Gz=neffFy-k8|b9G^ahXPmwl
zzKb4u9Ga?cs5M$Z)*^ywdI$(udH`@6QV3fC_z~PNR#8+DWsG;@QuV#sBFTF*n!chi
zozR01rCK-ccC3tvmJLTnE{>VRCB?NAlbc1>WdvQZJL?P!k|G=hSD}(7#9NeeBEvdh
z#Bzo*qcO&YjMHba*J5yOXkgbV6vC~;TdxoeOFNDqI*I|@(;Xq(ll^#NK*_dLa{nEt
zYv{095Fl?nN*G2ZMOo_e3Jg<PM<_~8>y|CHb~!gFZjc$J>!hO+2Z!CS=^<Po^|uDu
zJ@w-wKdVK=roeY1^WPe-%MI3g%fGv5QK3)2LV4_010p1B*2nWdqL9Qm>iN8;$)E^6
zjuw6F<sc@CI6F2;=4k+3(f{7uTo^<U4Ozh7u#W9~Jgs;;YV?*mFAYj+wD$1GYhDgF
zrEI<|J>18{53h>~tle-?Zi#;^pf3Ml_&(mP@<XORwwqdx3emSlg4gVp7Ua-qBFu5>
zKY@e6)FSW#^GHG63(Q=UT=^mU0w_ox4LL<vGbvaae*B*E;)#YC>iY$CqBiLpTvtSK
z#8L3Y+&lh^L~PYj#cj0IHE%7hU9u}h4vb_qL>-bDh8H;Uy8WRRcECkokgn$*Rug-}
zE>o!Wl{KY@(~HW)1Wlvo%HcN}FMfKYu$IenSzz$P%d~qD*BFb9qz`b@Cr<q{{mB$P
z>#EV6hJHqv%{^s=`h&4Znwz>EYWmWe7*-yNHIR_ybeQ=4tAdhfOQ1&9ixKsQ_tOXq
zRP$7yzc)R%4d6TOga&t*CECQLhW&rRQ|89r3$g6vbRP7vgf0mBawMM(vrf>OLVwlq
zerevOXmX{QMEkUz!LyM6$HoGQT_ezsBs+aXz2^Ni<+>ZG#6XaSlgsmP<`Dl%zA8`+
z?mS#@M}xmm^X+1XM9{q3RbQkbQeM~bW{0VAMH)rH%yXLUNn(9*vr*{x2WuI0C{PNr
zoDBfq>qk;R;-jA8iN+|eD$}M?jk%a+e5hfSt*@q?1;&tx<)5A5<{Zxbr|$*#tq|ou
zGtSh5;NbQrZ2$3Ly%za+!UtW%wpd4>5*kYb%*mxjWydbGx-<wVrP~9yV6uQ%VDZH$
zE@bq4x$!{4nQJ2w5wj=ouMu}9{``3Xx8h7>o$zwaehYumE`uvqFbX|)B6N%IH6(;q
z(^T%a-SJGP3Zx(ZEmE;ErEH#$sp)Ht9Y2zh7bAAxKGw#O11_kPb_GrXPknSHNJ$@&
z|9ZLKKV_sWSHyUl&2R1n86istKZIrv4ge(>Sfc;DDum8;e<oiLG&>(RR*4i35VWY)
z;%EDkvmyXUE(5e57QbMx_)vgBt4v!$R{?Ey+5u-U`4k1gpFICBe%RW{Muav}!{@es
z*1ls7JHRG9^cu3-mH}Xzr8V<x3QNis=Cuu)(HWXdDVVATZKmrofUbbcA@ug67Q>z^
z$;L$*KEFA6mIp<@Te__ci*GUgfCv7n4Mc&pNL{RvgEXexmsl9PmD-AC6XCTBn05&;
zV!oRQq5bU9Hl;IP{UG9<R?J#t3gtMOk0rBxJDOg@9#PVK+V=f+I>hiCiM=SfOzWQx
zh*mDcS?I=N(6-(S;kfKB!!05M7}-Sia&&X^L9__u@Y6NHW#FV_B~o4W=>^X9o&4ml
zKxDA0wuF*2d(Lp36KKG_3Viv+0`3JHMOFelpL(x4!8NDu)FU!JZ#APJrhOa$*Zg$!
z!oJ|5HB8Bnpihisl3IwXFEmYW5C9Z-I>^5a%Uu7&0F<ee?@dRG(K3-T5i|Rr)QfBl
z9FP0A+abn%Ai`Sbx3TkykAak|Fr5=$Cti7b7rpX_zs^C#Nx)i^jIq~Xfo!vKMw^Z-
z{@FMChRfStO*m22gaxFu2H`U%My#acK)K~MeTorw+N|T;st`*197j16Y0<J(qfrN8
zJniscUUy3K#D~6?dx~{2Dhk~4`yyW+lVkr`bS?hI{7sRqOiuz$bwFPV{~NunFAh8>
z&OCZ%qk@q~SVwR7cIw01f}&F=Ui4+R;zenO(Ox2E4EdibcajNbSk?l3OyPiWAnTc{
z`d3?V#T|ebURY;M_H^CFj2D_Ly=be-tH@8-mN=W^h`Ut{e>BDwJ_twI^(SKT=)crn
zJs=M%aUNB_1K&`LF`M!I1Px1%)JT~7fO}F5f(>|LQ9Y0axozzVtO?)9%+FsCD!1Wm
zQDnBKiIKsLQm+sr17AHvIai1>t0QDVq{*aLIeH~z$`ngA#GAk+$NZOIrJ0h&a+uZb
zCJP=kqZO9u<iFPEOer~k0*+#UBVCJC-)m<H)T7T3<Y4>-lNDVK45DZEUcX?5M(tEF
z{J)FH{afT=EL|v4>42s)y%i?yAU>?i?}M5pi4<5YaHSg1s_e~0^q!3qN00LsZJseO
z2;EPon~l<wCZ0xsTgMexS_2OxQbsofQyjS)q+(+#V?U!_l8Uq`P*y|~Kd!d@UJpEW
zXE6TR`$Ev{mf3t(;^ooS67!{I?=X{1B_eqJOe?kH*7Mh^rEb(?x<(GlxUErKN5X1j
zM!%$2jlMh|4S}U6ZUdXEmj^KKSYI?#9OMYg&sX-`1>wRc0sOe$qPL&f;ITpUA6Rm5
z;)Ie&glvpJ2I`katOW-R_y?u4c<wqNZhveVxkM<p8>i$jILO8O(3g(Wc-V{7RWq2d
zTiZ4f6sY0{A)P__f-8$7gWgesIP2-05_Qmba6^=3OROlt!??Q3N#9VP7Q?#=v>9x%
z8s|ze?CKm4V|TKi4B-yHp9Jp2M+GFXP;=J;idj??S!djszX+~7b*?p;os;oji4&Ts
zyby^TM`>Hi`SNo8L=M?ADYX(J=y=%)U&Qvm^KYlc=1GVrOHJ%6^fkjKBCu(Smy{Zb
zFR4-fvBCpKbJY0-W;WuBuS71-3BpW8>K4L|+dk`v>xd@?&3yfj)ZOQuUt2w74=2+P
zO`p?0*FanL5Yq;5zx}0%`#YBKb$%-43T4GYF(QIxdlJQ!2b}8SIv<5g+0*%59b0LM
z?ECZALT}6Vs`ja3pT-IyEi9^V|F1srYvGP7eT9FE&eLk{>zh_=frqpCtxJ^=Js<w)
zI}!2hzfg(+A^sfeR$>*5wm2bnFQG2s{51`X=NLBnT4iygML>rZi3basEeK)B@SahD
z|9|w=iV2O|_WB{&S=Tjf2?9IP(q4r;eWki<5zq2?wi7Il;w@b74wL`RZ4YVUoRE!L
zrX|HL)tg`hiXc0M4E(H`p3<zk>F2~k{c}cG4SueT+D$_souh@0t2$64ha0@w`BB=b
zIG75r`Gq#gyo3`Kflm?0nlNr$quNaqzO`5X;2*=XwSkE~t)E=T9+zQ5bv=G(n`+$h
z*ELP=UHQTEQs9TqFeq1NMNLv7sLYlhSEpx6dRmy5dV@P}fW7QhI45~VQj^t=Av*8h
zNACRh$VKu>)CG?Ij6JR=mdZ7G;Z!w`8w{4yra@r)48vE2->mE9flqqhE38VA%W&ke
z3<js9+k*fs^yP6xJ#f~L@7@;5ASo?#s#lf_atHp6R*h3f!zv;Au|D@`?KE~mpA11}
z=V2VrMTPnUH05*Vyn#9)l~!cwBK2co*E1z0OKxMsBhsR|t9#eymNlg>WpI@r6#gZ1
zWu9Dfn^)Rd`I~aRwx2g}%TFI|n8AkD3}b9F$uKsLHszq$@K4Dgjni+OMnxt)5~SY4
zz}Eb$#2{xf&cqr5Be+#G{;{c<S{uxEj2fpQk11cW$M|;?xO=hqT|#;l-V$l{+J6e+
zYw3+KXhIfmyu)-Nx0l^s2R~f>im&_epm`w!2L}y`zu=%Q&ZiV5kTaLD_d{rJauR0!
zWxzq{i=hMBN9<oA5D;70F8-ml{mmO5)Ynb#>QUsz=X_tmzxDW^2;YrHMbVbgqf80c
z+-@248#5I3{ye&gh3`uhw#6ocOayQr5JopTza05y_vJ6=diA@VwiwkU6v5TO_K(|^
zY0+DeP$@BfS3-+8J>SaS)g7tcMG;#luZmhtRAAlN*{8$garH6I%+LS0?>q9y;~nxB
z7NY(#s50tDzY`T>38Tw^De=$w2`wTP1D_LFw4_aEmh0{lKy3L15i1c2@At2pS<piK
z!`E8t4MIlY$Djt;e>(?eD0+!cm8&(Fz27&KqoH&Cam;Tg7l|W{F8={IBRU|CqD|%9
zx^5_k<9Oipp6oB!A^iorQlG!D*jWu3z&x;E)b9s-8s>;KzsawsDN0tBcc>@Wxaf6>
zb`0WNo1xH#1Ks1lD4NLx3;7X|lKMVu8p=7H86HkJ6lv*6sfW}}CxC`ii&LiYR;viu
z^*Br^PIS&$*#UoTB=%3zHhdBK=ZlcA^VsHyI*AjBbS<XW#@%)s3amu((5ARZ-*;0?
z=8AK$c&Nj7@4sSd|0kyF%<@y@t?5&y2rBLrF72v?S#HY_qgJTYnlGFjafn#XBX<V2
zqW0^r#rUali>Luh@4o(XQkKlYytg!`!Bq0tknuN}dctPCZ(0;*(?5uZ)E&a5B`|wo
zR*WLVroX0UTVE>xE58Y=r~E4~$A6l28Pm#-!_($i44U?-4KF`<zfYb(9Fq(J2spN4
zdT~FXHOn&OGOL(ytN*`4SA$!ZF?<8_T<*H55oLEGi}%FgyU1+PWcKGe?ZV{fZ{EFc
zcsgQ*YE;3XcmE<1mE7kIBK+$s=6$Vg_zi>YDn6d*5Y$(4-;lHAwdhzHv^W(`kqB1f
zFny-L%6X-d2xNj2I7tm)YisM!S<ThcdJuP#y1+z=9#0lZy7?i*KF?ZGH}%Sf8;*R*
zWg7pfkk0kP9OkR$fRA5OBCx@Xs%3`Tnt}8xXXa~a#~JPR!YYTtu~2m9fsk6x!PL&w
z&bNyQ`e1yuN#?i6mm{5{Om;z@!9=8~v>cu3C<z(z!>!#e40E1qG)3xUexCEDCqDPG
z#vw&l3a=cneGyd|m6hSawe#yQ>ds)AJTH^nb`VpFB)>`E5$hjnDQ`&DIld6%VL#$3
zoXLGF#Jw1mEP|JgMv3Mi4T!k@Gk+UM3c9JGNe}2$2y0uCMqhtRQ8B82fpI1l!7{}E
z7_O*SQ3pk3or%N3rRSx)Upz##_^A2r#{%v@vnfxDtHF1U%4aE5(|&6E)#*=vKXlIT
zLYf(zVM13s3~+cV6{aLuetl5!uubb)V!E!`xXpYkVC>!cv4=k~O~mFiUylr13mN8s
znG#=jWAIdPv))1ys}7@k*XT>wNBtACUxUqp5*np7Er;1uw6$No-Y%O$ypzo$0z_<d
z;epMTcKt8Ds(w5>k_yQLqapc{xj%hTeCz>Pru3Ltg-xI|0K(G%eXXBH`DBKu<;+9_
zfCE=b-(?ugKsnVdBNM4tc}`27Zv(LW=p|Qz(5;HhG)=e*^7A3cH6-b6&Q0kVF-8b`
zj=Ie;NsTkq?q#n2R)ZAF^$!+2ExWj9+Qrd(zTCbHraW?|#g)k*0bs6UaWd$t)BHMG
z(sg{gelgHs$fn@1mPK|dw4X!FdsIkfXdtIA(uTENxsj7%FjiLW&(cpq^Ot8)&J1_k
zjytMs>4LIJ!$;_@$Z;3Ud?ag~mwii2k1|EW0}ma}#~8%a6B=Rm<Ni)gcANrmZzhue
z=iIoxx8@gL-VO{#upB;dxK0%uN{f$3n2t^&oAqDX&i|`jq=s8f&fdN3CJgI3|8;iD
zfVrmfX3g_yyW<Gek{8<&kuU8jI^%ie%}L2?4Z(gfGKUx7a2A+FW^LvU*56pg`)70m
zXHQ(Qpm?cmR$uR#$b2(4Orq#cJiwM7dluuT5eg%7jnlcH!?%Lm<T<Y=f*=(SkKw2j
zNK(l31N08ijOuOI0FlPPtU+K(_`(@sh+U=jf$iVS%QpQVM9;#r9E7b!qvR$TmfwhB
z(DI7kY|)3N^|qUO^VMY2QV%B_#E<qmG{xLM5l3@_jv1Itb`a*QKA0}t`153`7Q-kV
z4aofh*^7RTOfCI*X*kxdqR%MU!U(5EMe0TW#mUd79yvtiTPL}FhmWs!+6`01*xy-k
ze;udE49~XzhH-46?xpIu<fv1}-X_!@1{u0pHGCs;va@etUh!E&u(M(PDO@jYxtA)&
zcOb4fS^Oe-Z<NZeJuTbb5^nmkn*HgqvaX_uxZZTtAU-@3HRGf~fKMGI=|&HGjs1eM
zV#<!$aI&wepK5>kz!`q`ebWiSY{NK{xQPR<ImjQ2&U0TBjHfiY^!;Wk9ag@rfn5{W
zGEt{USi7A$wRIQo2zVBD)cwRmk83>7@54qXr*OF!{^fLwhn8h}_++_#{kvb_WlJ>!
zYfADUCMmQho<s!MbPTpMP0#v8xnDN`=xw7ji+UG3knVtAD?*<sHIO81b{cctsbW7N
zA<8dSLXX=U?Om)B+$;~TSeZd^J8#igpwue1Tt-K2by+af8TyY*KR25>t#|B5+Yv2|
zjBBssJWgy@BYi6%xr>x$mGhp-Xf!A8%%ZMv=^_dF%%2p&ZM_T%n_D8_Wd}+I;vb1h
zQ`|#D;RH3{J$K6exsjbkk@tXIGJS8#<pB}9xxQ<HZ*=`Dtc#vo^<#i+r#VONd|J@u
z`-|IEH{N@tdl^6|`6uZq>$~oxx5XcuGAVCWu>n%~LwkG<1OZH)t9618Nq=HG1{E37
zWXRQ6^(c3JV1yT}q$m@xwws${{7wS)X4aJNJ1gP|zc)xl2uYC(YwiP?FU81dH{X5S
z94m}+p(F;hSEM_3$p|zck@R2s;pgmKDz#U~OV~!qLE2%U+stdhAJb3bk0vVvVl~$q
z>!-pe9OQRTN!;mRX-2AO;wU!7yNqLJP|0+E6zR{OC0ZlFGW*H&yVN2nq^JatS-N1<
zNr2g1FBb<Tlc8#id=9a%+@~i~Gvsv<ap>x&&R7|9#)yK>V7tB6h%<z4gDmj?lUCdx
z@A~a?{gyJs+r%Wjr3AVgos+ACKIG+J`S;!gulX;iNY%G^Z@AD3x%-<&Ex)Qf6_<+?
zzeSRZC7-T(#riaSj44qe9<2_xUb-PKHDn@Bng6golVmOrr@{7$F+J%sMqPu1#uJ;z
zhJz`N<yZb;w-TR53C@dX74i*ShVCb9rxY%bJbRT%oAxif5^02P0>aVTTR+^7;cu}>
zh@{RnaaWO4k^FEIq?mJ9htz|Ey%Bt#Q>B&jzjLxx8EI1e+}&wc^51xq^&82U_ru*2
zO3qw7%TI_@)Rb92j<{~vO*M!W0P0rUYeTHU7ZOSsOK;vN+8VGN&7#pm_kB8+b&BnC
z2H;>e?WV{#dyMZT1v+En)uzDidv#KGnUqV4(Y0IBJ{pd83UTyug#N+A9T-%KzHS(4
zZpQ^k9d(G)!kht(B^4X*9Q8jOC>XHb$5Y%&aIxou_xapJV}V&oAcPKYPb9OoOzaDu
z?wk!djAnY(*7im+KHA6`2UmHXrTgoJGmH7)K}?(5rY`7M`uY2Kat4pWk4O|SBpk$B
zf%1E9aCuvz{45SQRf&X?;Hs{4!vBl=;WM)9OBWvxbZU5>mx*q6haKBgVB}hdc5YS#
zGA&FGG#rAw3Si24_eSe!c6KHk;1<9UK1MC<xfU0M-S3BggE=?uopJc&=2e4R?s1Zu
zhvVGiC*IG&E*+B6wc9i1W8U6~Kb@FKatt1HO86=YkhwYQJ@lafNXP2?=q%>0ma^vu
zd;w{u$G;yp9lMuh=##klfDuHj=(0A<?viDN4;?zXhwM%y@YU7dO8mN$@bO~@U~cXm
zFD*qXK0PVx#FM#hvM4Wleqm0ZWa=m(t!D6tF;O_;WMOh_LcoE2G;<CVTv1#;%{r=I
z?j8V<%h7qNb0qfFm_}1OFNnGB(OdmEcA4<<xLG2dhxE2btjkU!zV!u{_l;t&;s5Su
zvRO!{dj7jx&v)C6`l5T@`Y@&O)vMeg$*KeUjA!27I+)$&uxP4l*#|1oj}0elDX)lM
zPx$3xYq?sih+B?QgdMKNOrpssu=oFLZ}Vp7!A%d{Akv3QI?pBW(rjEv{J2G14&X1m
zqjQw({e#N;!klCCC<Jo;_Srm%n--Q2FWNd9c+s#pK1=;p{m6#jBNm1ny$Y_?B`A=k
zCt6!Mb%<{D6zZqct#R0PcN-*obG<7(d?(>}ltrrvI~5JFI6XIKu(aAAH+wk}T>IIE
z80HcJrr_x3pd<wZY@6-m_bVI6_oXm+n;&!5IW(nLIz0uXgJ<bKs%G3RFGT92z}s7H
zBvq|O`Rp7V%xz$Z)#%q?x-HcHSTe~^qiEF(16cTyAC+=%7K|JWla3(PzncDsh*oRM
zm;+*6^_8QH)1R34jvhX?;+FE#N91-0_F5Tt9pb^<TvpyR=SCAg9H*wTtlh5e3Oq4(
zfIl9I_44>{R0dVFeI{weabJ4_mW$BB4~W?k8{V~hR)%K^5Vx^_EK*A@^0-4k^zF>f
zfb+RA#HGX^?^vB33uHa!N~B9qn4S;s#5W#WV!gPxfGNK&W{qW@UdDo387ND=2m5Dd
zVTdq5G~pbJ!iIk=yj~e;;5C}?+R|}9WVvE>;M-Q*N%OPK<vf!-7+><%Z|#Lrao!xh
zSnIWU`_G}!A_-88jQB?4UI{I)K$Y@Fu#7l2T5v(%GC~-zNam=Q0s(xZDaeL$K2nW%
z_9m#oBeXTk=!oP!wljSxw$b{Rw2ld#771!e=als8e%i3&qeBG>VlX~siH9$N$c1Px
z$2qljlbCzF8hvs42<z3^Qa2Ub^X*fkv1Qs#Z&tcUx4u5th2^*TcaGj$dYxKQ+_ibL
z-rnpHYbM*|0m63~>0~~BIrzo_0~6TGKaD9fBA@`*7ujlDQ$H8nwhgrFFL~DU_R-mi
z(psklw)%w?6V{Y`2}<`*{Cv?Id$u}-X>VPm^UYr7_E*ornB<iFPMCXLr0cWn8v<O*
zMPuafx8x->aquOd{3KuWINkOvu66dS37dD?c2xURN%~~}++Nt~T+VqN5r=HGmd>=M
zM9OFKFj*iINp(2E0RZJI?(x;sS1wsr53>7ZXtFo7R5ob+EOy=HO8Z2~I9r_CCPBTd
z1^03>R?&v!%<|*DLi7q^-tV~6yAEOTBR}%lbmua+Zm0Imm%y$+&0L&jEeuf?ejJXy
z7_oo)_S~JW_~3l+EXzw#%)N-&QyH9%ywvyjD%|RJ<D2RLrC#ZNK-<G1EgeP@ouzFL
zu)SqweOs~gr_0|G;mNab#O9SDn3_+<n$kCkn8$R}Ku_H9b-d1HOyB=@a#q063#o*r
z1h}=nJc#?=qITCj5t0EBj{o$8w$nmacKR1c1*(YnTzk?3Eu$b9sPbR@{%bOHobApD
z0-3^vYHBqChO+mLM`15V`}FT~eQy`0{mZwtqx8vkZv(bZ4G?bMV#=(1b2d2Dyh%~C
z(_>+%F_>CtYhus1-sS4HDA&F&b>zfD%;G=rRyq|AT1&I=cbd=q6LVdYR1TsuH<t~&
z5)bC9s}ix9+Cn3WkIYkj78S>o!8=c<+m03lK@-j^{(|TqlFq#*x`ytpm(_TDLVjH?
zp(*LvlHmhb=$pO~ieApMwa~}wrd=CqoqPAn;GeFiTxpV`gxl0I<Q1F<*)@E@eGL8+
zJgLM#I)ecuKPIsmIP@D{De~U}DYF<iYd=;qTZNj6*gyHvh)&|0--!<^S6<g9Y85G3
zw8qGUcXQIyu&90;pU*jE*YMFqP9IvB%bSHUImm1;WwrJY!fUz&d!z$}6|=m~+Z&yy
zKUeFT+J$!Q&Xd&G^5q&IT{i|>^mF3WVguax^h!&~J)g^_gPp=1X>6(Enx3t!+Eq#U
zWbD6(XFJo7iMC&vy*wh0sR5k7{;xq2l8(NKDs+l^fe@(eX1{^JN#OoDHI=Yp8TAuY
zxyF?lGJ__+bRU+jF@t674a8KAlyzzwN+zQDgK1Om)IyzSVu_8CXdHUJdylL=cg-``
zx;!T(mm;h5JjfRrIE}rdP~DJX(_YCR+W16n2z!m5bp^yCgo>+>JuY1^QogGlGQOk4
zZv7%j+sms_76p+$Vk%Qdw-X|k^rC%l-3|TUEWj_1_OIu1RtY;;8l1K|%_L1){i}H#
zBH;dcbQRt;y{JDzi7#;DM;Y3W{qI{JDJcM=(j-Ts3usxeMiOei-q_Q7qW*MlhPW@z
zIj7`I;pt1>USlxVOgqRo(bo23vd-XO2Y3^(#zi#1o~u4s^sd2FH<HFD8LisvF@sKs
zt@?!$MJ9XTclfER1>|M`yux=A+Pu1nWMeLFoIs$TfJNM>CV)hStA3oiSc3M8;r83L
zR9Scu8iLlC|I)O>hx&J3IT4y>uo+r_t?qc?4C;XS`&_C$fsLqBgF<3l8FHZRWK8S>
zhAZ_~L~W7R+zW#qqmglDG}I`u=0#0gwN6eJjfJ(==6rB)cBN(~X{#dS`yKQG@T&KO
zyss<W=wfid=!CLRHsAHVWFrGToLiUZRgTr+zXFG|Tlzh-Sv}k^naMelmX<y%2%1Jj
z=AN;iV}a&JURQ^Bx0met_RKXojuVQ~7}E6~Q#lq8nBFxlCJmP9{xSIk?`(F7(_VNz
z)vmS_Hg#(H%>IqHu+QC8Sz+46Z%{MhS{C1fN)eKn>q46HGzCp8w_Z-K*#?wd`|+&v
z8pl3ABpdGuT>wIhZY5N<v;$3}ZlYkP;z-&emaoy&E81f1m0~BMZE@*&6gPdJ@J@Ci
zR|W8@&<+bPm4b)b@^G8X0E?yLYfQ|HW0XAeQEhCqLVS9dOwu?@z=9xxpy_VJY2K}&
zg4<XYGN+$zI8R$pWK6V^G$%ny%7B=Yoi|%avL8;~)F#f%n9|}CvM;*swllJ^iGS`$
zY<=2S5R>~QTAV*EWP17cD%0X{&b{UlM%Ibwvgh^tDo$3Bvbft-sjc}y)6Pf$ZWIzS
zWBecd4riKy#V7wRiR6^@X313MFst;iYK93|yWqfB9nX96It6tV5^-PQGo5?UI}yyZ
zovLF1C-V{6@UL#7j^O9ld0J0`W^$3aUMuRR1&NUpa(!PMGf%Mxu^ja$M=n^dutJ~L
z@b5$qtiPpYy4NmKmF0{x1vxtpJfnE`>!S-hbO3YIGqQvaSl7q$VXrC<>lF%r&iFjP
z!?)VTf>*kpdT&J%FxGMiP@7y_(fDk8Zy;YjFVn?8vP1|wDlo1$(E-3)FEj10d58N)
zv8`A=)~j8+Z&y7pgI-3gXxBQ{5JwH~3<Ms8yHt)FA=uN1Va|RprZQOybS2?>AD-R%
zA;*b1mh3mJ<+2w|4o?c+`73_`2?o8ppLWLWYmh6N``pJe=Kj+h8IkVsae8rRSgEb0
zyH%O#aVm^$;b#CBOPmfUg7TP0u5<K)irTxDIY_iu(+8NsX#ZLq9FYYHR~}9*C<}o7
z5T@Mj)ZV%q4?vHnkb*a~J>Xf-kOkXrE-8;`$j~lLubdM2Mq^>*8=qx&nDhh;eJjF-
z))ih)9=3oYS_P45h;^E6)Ra=f8qSs%8c7>3;b#(aES1mym_6Kwtd32N4^N73SJ~X&
z{OK#g<VaCjUfsz))!+eVmoC=2t$&#4Sg|rC^&T?RwV=-+q4$Rrb-<L9m<rVy`^2N@
zsn&OS93|h2l<HoTptSMqmK<|)INSiK*B4`T<~tAITz#uIoGKH5iL7w0r@7r*nYtB`
zZ?@w)2HO$S92eZ5!+U;}TnWvkiiWs_QbY|@ir{JhAN-iWQjqGiNoLj?CT{c58(HtW
z_6(llwa$cd=@LS^fO5&&UIoB&Yv)arnNKg*fS*xaw~(SKj!6=3X0Yh1o!?tZ+^3vU
zgXl@3x(?#73JM}(BTQy<0oA!b(1;|H+R5V>%bxu1%kFK(luVu9Pl3He1%YmDx0MGf
zWNUPJg0GsFTuS3cYEleNojjPUq@OZ30g`?5H@D*je@#&_%+L?6^F|{Ry>9n<>&Jc%
zW4d-R?YoRL@>(`FTPr<l>N==)9f)xh)r=?Y=(R6_!;<wT0poZ^S2wctTIim@Tf57%
zl`7h|Dn9_CWjgE%GErn^TOa^M5MK4GnPopY73~3N?5WTiCacn@MVa*%x!06r@%f7}
zGMm>IhH1%W@6<L3iR7w$6Tec_52Z#mFooCVotfnO{S0MicYc^<0N^lQCQ{8*glV&&
zzuAemjir|V<_F`Vd6BgxGWuO!<`Q`yYuld1Z*S^?`mLUb<G1vrF%$-3oOnNBt&_(Q
zc)36ajnb=}^34--f*W|sbrgnDa4@{mfSF4Xbx57&?@-`s>xDa7v0m3X;FOTl#QZTH
zs8NtBzVaFSv7xu=-gtY&7$;O1RqL1g2SeLiLa2?dE{I>~KG(a#i#ZUw+Ki7T)>%=^
zCR;I>aXoV>&~!O~FDeQ`=<i>M;dKMigi>7iVoVLH_X$<l0z<g+n``SL;afn8vkDG7
zrOIfGzBDkBK(TyD#uu}Jyk?m{b<a?C2Oazz>a4azml2BJ9s%&(#fBO9(Pxnk=COM&
zQF>x1B(<#)UkFoV#&1NUJLwFnlpeVEOB@EtQb~Hcjg3e<uS|Dl;q*3nelX!?sLY4h
z4<}A-1rK+q0@Zh#7}a#}oE0sZ0#H;2ia?2vCE2WZOyylsZfq?Lv#o01tGP7J><iUz
ziKw`HIY`lsm2OzHN*6s(qw{D>ddcVR39>b@tj><Rgz6>v-<H1d*e_-ePU*B?$DqF3
zM*!)EIKMR%omh$6zo*q@tohSzB_Dd9eN7@kv7%rVIVO4Y0cYb5{qTtKn>seU2IUz9
zZMGcuH|Oo>N;m`j5)qGeeL_~FQKe?{&iZ<9RoyEZyoLXQBKU~!@;XbPhE;xaWl)f~
zhOJT%DoLJ>H_!ZgGx3<SmCi*4D7(?p4%X*^7atGkvqJMKi?l-^TOy|W29zdD`Jnn8
zipSiy=JXxUH!QSi$ja^TV3G}mP1Grvs{y&BT8m2uSnm_(yrEnaHoJHJb#DvR6KeZA
zx>c=CL;1xJk1({`-{q*^K1%7+8+~v*4p77RcC5m<d0trfuo2$z0>(>#lP?S6&m3;+
zb-UQd?u-%7jsR&gHse<rIu^fKxjIQ*f12DBH*nk@%=2VYRVpQ)UF|v14S3%0>lKsv
zupzMtPuo^?w27L}G60d3WIw9C9tc}U&lrBp`^u8R8P#=`=mzp4=yOQ9%_%;kY>bv)
ze5P1e&Te&k6rT^aQq;*F-!Z(jLDZ8DW&kHWwuq+AJVfy%5IG$=aY`1c^GmdRLqtwS
z8fZh<SGx>2`DrLME)>znZ!bLI5e=Lv?-BGTZ4$olYXANT-a{0S`-N6|voyNwG$__n
z<SS{+DO7aO6~2{bvR(W`$ThW;QI?_cSinx?Iyq7FzU=-+30C$9RJuTAB_xiE6=iZ!
zDoPgDXbAwVY>w|NAxNUlG*nq{YX}pJ7kP&nD(0yZe!n;PJm|{K63%qZH>{DvstQJJ
z&+yOwWX9&Oce88)AAeH_pyDY%WbvD_rds0Gw+D3P?0NHQgAsh>Ix}u<Z-GjOzaFRp
zFahBc7ct&Ojd+Tz8VVfc`fUDfg+H~}+!33>d+}@?&X?Trl;teLDbWYQwbY~1xA)+4
z-ymDaAO?&8Z@{x#{$Ay&zv%vPTE!4JL)LhHd=}?MtkhxgJH2CaS-%-3SKU{TSxSv~
zNtg@oKrxL+v49N_xAk2uE3_}|irXY4TnLNQ0TVezz&_`R=#OXv3z^~OWfDV5rRiat
zTVK=fZ*&=fY>%TS#_h9La&POolmHVhzbuB-N`J09lK5wRrIvHe?AvBDf_F`Rt`X}T
z4QVk=uab6E!J9B$J1;(B%1Z@0KhaF@zLb<zVkOEg;u|lEM^}4G4xPL0&Gvul`zTG*
zkogtl-aDwUW+MCjX8o#-I4W_tDGkqS>50H@_@OJ1p$(SQ08%SEAr)b}4RG)Xzhzz;
z3*`3(X()k-j^6W&vsbg@(~7-nFqukn3UNRY>xzSRd{(Fs!&NCAE@}g65OxH3$|smb
zqY`F$VUDD{uOoqg0QCwq>vl{_I~PY9i%${oHPbJC=b#y(HzIMkc*r5Ra93yKfZTT$
z7eeuv5j|8QqV;uNrG05Owvaah6PaS@?j`w2RG<+Y6Z}ySj~!(uZ4NaWeP$7AZI{pI
zPXTQti*4!8uya_vXLAEg;w=xF`Jam1r;`X<?lW8`sh6qn2YlkKk}Y?MnY;b|o@1UZ
zVUWmpal(=K#~CmO%AqU$^zl@-P#vjayqWef29@-bD)Fm@y7q8{VdE08VnDHrd!fTX
z)ap|%9!1pP5(HzTK|FqXUT!E9MKU~`e(S37G-hkma`B;q;Y9gT7wXHbY#j&l29^#+
z&#LNjl-a@B1#r?B^1-jYpX>RI&7-gBL2SjTo_BPv9@q6lPp`lmy2pxyb114OsJm|M
zJp~S;D3gXVz&`ieBhKKYR@Bt}p$$%DpJh3UQjNm=+McreaA5``PNNB%Ev@y7^fvua
zAF`ofQYZq&eMe87Hw@r#0#FJxi>y%9EW6gx{SY3XQ&z^+tR!o10HIfPxtx?-iYij4
zvORJqpRDIjwx<bXvh3l9i;xCL+fnt(wKZs>#=>>^)6T6u^uE-`97GaiPp~{_Wx{dN
zRvm<Wy5_)MAI-85xM;)8&=N)}{$BZP9caER+T|D3t%u5#6X)kkhK<mUy}MLr5oQB5
zM18`!@FXYCSudnoRlFMl&M;26xBocRc;U&pMzwKxd}xJv=m){9*oKcX*y_}ib^pof
z!I*<3w4n{BIWv96eu9s5x#(YBk~ps*U#uNHAW4-|K{J0Ag48N@iq+e0{~S3u@1Vll
z&bp2}^zg(vu~?(NCW*28jWSA%80&ZEMVR3|?cqHa64}gEF}gb!)0gpl$WWY3Q1!9o
zuK6M_kHaecdL^1F1UR;tOqIHD^Qp*IW$#@Wag4h4E~tj@eb+VH-R@zfpVdf*9#E<D
zE(w^8j)k?-4n?G2?aObp)_23~Z4Z2#ZRf^)erim%vCDEyv3sv@`WT(knp`GNW`z-9
zICQd?NOh|*8(7l^G@SWyCL#CX?kE%^^<mXL#qL*_renG<nZkHmE5=15e1__@op^zy
zAm|k!EAqQ6LlN+oVG&zw%i7|rjrV=XaNT_1KlK^|#y1awEP*q*pCy)&%w5Y}Fmna%
z5L~$SCM#w`h@<jb)=PWdN)R2(HMPsXB;y?~`WM*xx0^VTluJ+ay-aV4aED701nb??
zQ2sQn4)q5F5Y2FuNtJuog;WF_a=pY7CF^-{`jQEUe%QrEcP=nowqP!(!)zOU@k`En
z-ADGsfS(|NKB&yQYZ{HpFm`nDSIJ@@&rsvZ?_&RM{QZeY<N{$;wQWGs>Z9YKU!Ks9
zco{5(#Xuf9-26A>7#+LA{=17q%B4R)0Ve04>>^QknucPsTJBHnnKX4=9bc6H)aj)_
z)f^csYb#`FfVj3Jmt#tT#%b&yolci$eO3@Mt2>7xn{(9<my|La6KtTC&ReaguG16@
z_Lh0-W0R=VzZ+XpPjM*;CEu>LGSK?8U>9xL>hNK0Bxn7U>ei^u7)~3D7}r`%dL50K
zWBbyBeSvG438jMnXBvERtMrZgA52j?N*ys;85mZj#qSR^U?Wa8LY)JPLSW>)!|SP?
zB=P+L(XpL~Ip)v|G6xyfoBAckpp~JHl8<E@r#=k!8hlbKN|G|M`4+$#3Ac=F>MEo&
zyaD@C+~bdIKhzIzja{i1)x5|844n>)yD98fpXZvLY#^`8o$3qUa-H}vbdyirGdngy
zRs%m?^d^_7vAU5ZV9YgbXA|b`F0ari=co$|H{(0k6Vltt^`cU%kHFjx=9g}64;gqE
zo91M?s46SgMq0N0)&dyp0W8z0_>NgZs5k7a-myxy#7Xi_XO!<tqtl==Wwtsc-*P<X
zF1YD0$R;wF@9q}*-2WoC%j45Zg*6`&^<t79KU+1}Nr7)_Tf7e5;Wmj|y|6Y`nxg;!
z{}>dMmsD?HuzSNtV~fYB!RbzfZ8Y~Ew|M)cG&RPz%Bxnty=jIIp4cAm%5>V8aqaH8
z`37et!QdIq_pG+qRv&4?V<j@I7KE1dFMK>Fs7jgl^1a@8qcru#g=MNk6dmj-stTS@
zi4)rm=Tz!E>q3;G>NJZ5>iQ0GB*^~VU_7sh{yFQV%l2--WsZzVmT(Jx(`(-fqZ8Gf
z&fw;;;-uC4jvWP!(w_;uX<PMA7|m$Jv1h8|OIt3Pe`aFG?@8Ss_xn&3Q<mdz1j?mK
zj{Uft=_kMVPYma3;Pu`WvSppdklVl9eH|+n>5>MGX%=#ZE*seU)quoHw*4v(W(-C;
zUiuCD8h6T#`F?oGdpAj4w0YMtvqa~|t&_0qD>&T8pQ&Vm$w?3n@LF-{yw2&7I^N#9
zB_;n+lkx@RzE=~dj3C0OzQltXAKyGFr+f8I@cPqB0akSv=^!@0vsD{2%gvwn!5n7~
z3>AbP7{s3r-RrYLcQ>1m@%b`hy)$f}IotgxpXtNFXCKSRZMqZ?>5IRUeB6heW!uOE
z^m#^1y#JC4avyQ$Li|#mMfqx%$Ex;o>q{HRx8%$3%8??K<}GL9vBfTZt9RcFiZ*#q
zh|HZp1bLXjT53H7@OYFQPPLPDhT=LW*(<?I4bdFkFDiq_rE|tfVPbJLqV$dM3edRl
zK<ZM@pa*wBE1#1g>cqY2^5@&W2dj+hyI@60<<jB2w%CK&?2$}-kGMu^&P7!_6#0KP
z#Px4t*reX^b>%qVJrLeY63nrptyfSV?uRi4+mm>UopK*YFBjYWI~{)7Uk7yVJyOVM
zi((|WOb;cM5lc`cDbUHBwh_D^MK^rkm#@}ev2p2=gjY*rYIs7v4wYZzI!eB2k~xpT
z{Q^U>BA(tA@4l*ZvVu-0mtj#s+sYg`6Or6prtV$lCgdzHR!m|X3X9bZT$hSLpHywY
z;ech{H<^{N=YqAjoCGL}69?F?Dw}E$g95{elw6+)+j!ti+WQ{P=sX{?M;elo+t%Y3
z>_%OmqJE7G3d3=wtTU$w-xN*5yIuz}Js{R|mJNHm?X^Dk0}*kgJZ1GQ`tE(zdCbX1
zA05B2Te{%$fDihYGSU#cMzrs?vp=7yka?M%Ezvsy48ag~POER~k6zX@ES-KM9l;X;
z$!ol}!Zc=nX}WO97SitkrV%8n^V+`Ur_;Z$-3~?AG`P94{dt^?SAFwr-{r&^fOZpI
z3w5%QaB|#AO0OBC2Ry0c_>t%0EtB9XYpm7D&F0}H)81U+*~S6KbwjS+Pw&Sr;kr0&
z_ut~WJ#Hcj=Ch^5+K=YKN=IfA*i8D5<eV{b9>`7Q&LwHvGRzugKVQEl((2cj+g^+t
zz%WD@P4YAAG<#<Tr_icCnv!9BF{?0r?uhxC=;r9lUf40yH}z~l82drk0e;UT+|Nds
zbY}p$Ig~!C^rA?6Q*Yh?Md1^=DpW#oFs<1B^nze3Ab6Y4zx*ot?6us2@irca!V(%Y
z=UGSiv9xJ+uj4X(s%QLu^EtsyW5);gULq1E?OP)?`ubQ|f;r{qqNXiyCOZ`dLuj{k
zFk;zC^|J;OM?Kg(s~|_*;K0P8o430_-evV-rIa%NwDvQNgf<4M`rBNpF$A@WJ?&Ec
zqszLtoip?hjbN*@!~M$uA5)5w_~x|f{*zD>v2==H0$i`N48fF@5o=%lJ(^`<r@49j
zWZ<}!_=#J;h;_SXVYL`*88!UQh+$+i?ZcbO-dNKnNI}Gbv~P0sSR17)m!4`}B|~7I
zH<Sff56?~0+^CnZM*lztpr;m}P_#~AknqvuGD-U4CX$b%4E5JjCz}uGZVrW-8s)#q
zmT@`E^Fw}niGM3p8+iIW-JdnAX%=C&?bfMuabmE|Vyrr3%Uw_iuy{SVwS2b7l4x0|
z&H?cWOHDsDC}}JzS7%zNJ7qMMS@ng?dW#&I^`P31?*EnSuuJ3K^hWAFCI|&^#A~~~
z$wRaB;in>%>zDBtWD3iMb+<;7dgV?{aI6Q;l#CcXFn2pH%z4A_4J}q}^DY5_T=hxX
z0)Mhp`hAfJJT$CgSG^=_vTSIq>h!NZnaI};Ap{=Y1Rol%;mhN6556;IMnZm+zt-WF
zF*FE+cP1qdoB^n&S(0v#hxe{`=}ay)AJ_!x`rCHIxa50+;1%QgVhbIb+2I8^adym<
z`LTz}pvg22r>!X)zcwv6j6XA5lMzwxX6lJi?3&fHe9X%oB@c79y~kuPq2b=S^PgqH
z&Q~|EwNczi9QWmRuI5-cy-3Sy+@pWLppn-r&beCuMa7^L#wCURXg=zvLL-_z-S3|S
z8^G#!zkcDyoc=jDrHjE+9+%<VkIa}Iw2SzwQjlrvZK;BOZP#M!=}%q8G6B16nouk-
zf9TDG>US5RRbv)F(ZOUWyX0pR(?1bR9ukYF=u+PdWxk3>MGFY;Av{7$Tn1w7AzYV#
z28u2hH`7vi)ykemX}k&L`h9TNy#>F28*Zmwh9^9l%3>-ndyi~3e*T4;d>h?UgD?&S
z3X=4db2lpb2%E~dE{i}O_^mmx$<iji^f*i;G(T#2#2N`Xn>{$U_m;nC(?zmswnfF4
zU?vrwkyLw_jo-cA!~!ipu*FmSM^j>_-En6o53M?OG^xLOufI1bu!g*z)2WRx5nk|Y
zB77v!7v{BO`{UwMpjEVKZKDVPW75aHs*^NJ??UnAe4nK?15pM#>G;Jb#;nce$S8WN
z*s{;Po8dNl;Z?C^^%7yOqk&288re!R!9Q3Pq|Sr=4JT#iS6#^4mz`O|anKX<3zfS%
z*%|Rzukryi5~X`aRRxV$uuzW5iL@`!5Pk*k+jL8vz=}N+chSMek+MpJ-0}AKHY0ij
zGG50w!vl7Z*ILpCelmhl{3_QTuTWswc*K+6k5%lNSv8z?9epX~JZu9YH&4d!y!q+3
zl;(`Q(waGHlL&*AQq+i#I)`l1n_d4{^|a}Mb`-J6b7Y~88W9S$d$Z9lG*sk*Hu=kp
z>t<1_sP@$S`_Ll1TQcVliQj<XR$|dIh=*BUXCOTDAW&J!O0^e4!t-R#hfMko_u}S|
zE!4xmu_fJm)>#&VOw#`Po+-jt#B}oTBWRNTV~JbN^2?zt_?&S!d~(_5UoQ}z8v#2O
zU(n<l>4%LG{ZTk3DTMimdYfvLI@K8Bi!d}^{Tdk?F5ND&(dCam-Zs!g#`S#objiO7
zHHHttP*!<Ap{>l144&yY`Z+i;gR$ND6pILa1_D3y-mX@q6lJNaCiU|H!VkN~O;9Su
z=e)h+Qm5y#P5!#-hmkTT<9WVI9C_zjEXUo8Z>;-q-)k4SUid6TF;)J$%(y@51(o55
z*r~pdvo!Kujp4k^7Me={8d$N{moZ#Iy|~AfeYKLP8~as2Y{_10Nf=v~)lM#p^P(aS
zN_={8WU+vIdRO!_tb}vw(paI+)DXTKU`h-+8-X`^)+s8VnMXlfojUH9YCpV)p}eKE
zMM3nmUt&^!*#o7G3y=P`IQ+npf8zBK9Shx)RhIT8K+F=g6Ad%N2S+)YX3_KS=Eqam
zu@&V5|DN7I_IM_M-a~Bn?pYnakE`zo1}#yXwmYzv*rl|M;ZutAzr0T~!dwtm%98(r
zld9)KVe``(GLQ0SV{5rllAsWlgz)yyT49wdl>M>cnE;!6+-{a1>R1lDRFsvzcBz}q
z)y~!wJXqg)?jL6o<Y4*<Pq$7HSpW<x%+E#k7hT7i7x20F<JLQcFoU3=KAuaQ0lD60
zUKR4iBs2uRl>F>Y9Qs?yBDCkt;faUbm51aq29-4$#2)E-B5>}5&}xZ^|D!~JfcSSI
z9**a+d~{;5ro%)@PJ%urLVNi--w(2)k4dL)i%l&e?#o&(Y6W<F*xEE=i4(3GrY<8>
zF;^5FiHr_KQh;qEpX0`H?$QDmX&|@AcT2uhdvw>tK&Ru#rSGxLVV3^ZU{H0P0tSOx
zO(g?oL{6Mjk$2~&aH%z9zcuhA(%F3fnkhzhmp+%`+v_4=GklD!Qzy!Fn@Dg}Agl5D
zpwLF6qIgX1qpLWL>B#hI%ntT@oznb};xcWkqf1E@8a^`lYXm9DH-hT;4fAPc=HJx$
z_3RsCL9!FCzcVu|F)J%xeeM5!`}SVi7ims4&oUaNwRy&XxK^#KeXz_dIQ!xAtD=Ms
z>P^YN$%x}FXj9)qYrf}OoAV`-*6}mT5-XdA(CiOMYzUn}8z%vt=C3A`FDb2MDeOz1
z*S;o;WtYp+FV!UJ`jTn14s99s*ep|QfT!AXf-K6KNVZo6K^klyYKMY2u-v2HjOrYX
zkI<`MHM`vkcB1F>_;uWWb^p?wUN`lZ?+jqs$TZRZmM~7I{u*I4DYhTzGF^H~KP93X
zi`s6(nUg7^>Wj}xG_7jo^fC+LpFKBCKW@sT<vJd4^?0MfP*Bq`@FiJ<A(A-iXZSU5
znLa!%qn+^*K9hN<WHEk6$QNz5hYd{32j!9O5_gc*XxW&&GSPzT@?<tOLu&r>b@Gu3
zW97xJCQNTcxzwk2!I$OJapS<e&4g2Xg!-X?;xD)`kU@(`;i!1&7O|n3+{es+RSAm4
z03@tYU+zjEb!kbTUQ?;waDqks!U}YS$Lcdw9uE`;$&LL=aCT&|4V~ni@n;6FzKt*o
zzDD}AZNaKFH5gGmiqinn7*1nHJcQzve1oDMTZ&6+1T=CkAqop#cm>pc?jii^M1Ym*
zCZPyuE2`Y`l(o~fTRVVbGl>H_;{@4X9)KZ;)IG|MhfSO$ymBa+aOdWDp97o;WzShc
z8ZA9em%shrEI{63M2pNG@2^+0x)Zf`e$2lXOrE*EJ2|g%UHLkdFurMIDf7q@@nDtv
z!RdWQS+bW?l^u?if?=6XaxR02$agh6I!Wz3Gtfo~=?_ae@t}X+Y|(ojH+6;6_tngt
zuqyW^|HwpaiB5j~T>hdvPJ-rLSESt2bk7XgGat2^Kz--}%MnwFdbZ6DrSbIq)}B#5
zlo?s@xhT80Y+hr+5xW^R3*Q4FCR4(S_4}I?y-9Te6NW}43I-yR9_Kg-R-ijFRCjem
z7-ei3f4NwkgAqOsUGcnvZx)Xr)_zagM{ibaeCa^}>~q~)@&~xapPnVgn12jCv|hE>
z_*HjMtMF-d>mJDnZBAH*yC6A}OF9)e^Z63mgD27l1jk(OxU#|hrV65~Vdo%5yG#}t
zRH3@}HI_K4{M=_hm>66(v9PuJGUwQbq1Sb1j<GQ#&uGC_vn)yHk@v&$lHjP=fk220
zF4y~<GBNUPUJRN=waaW0#{xgAh!PRUFo`<((k34PrI%#n&2xcMrmR7&^6WzM3hZ}k
zZMGrJ91AxhM)~P$E<09N2=F_>%g}wl2e#~R`d9N4+?^DIi$+Vs<z-Qnv3Yjx8m>OO
zG^M*P+bDM4tWJqg*}hCz%bdHL+<Nr0neLWzX3kbt_V+zYXhaFV#H;1k#{WmtRfe_I
zb<0wULvgp_4#6Eti$jqVcXxMpcXuhlDefum?(R_B-R<V>_uSw4bI!_=Su?Zu0bf~B
zdt;guDw#u^25hg<xPH*f8}K#L2pP%IUI-82**i+=Yc*B^l|&@&t*zeStLa_o24oC{
zM?Xi(#_ZTlUE0t+irdsY^A6}^@Ne>hM~|u{o$fY-V+Z}k`u@1_?*>f$$F-*TI4}s1
zb{tLp9t={K{E=}Z>iu#wk#p9g@p;5^;`meWIpvsTtG`cXn-LAGvc^`cZk`xLJPQ>2
z)%x`)`?ss;ba|)=n!z$p@aTjmaVgp{cR=X`$$A-$fLNm>mVI%vnWsU&-SvxNR_iu7
ze`#qgIyj3`H9>Oy{Cx*bQ#gl*rtnCa+K~^8dOB3;VTet?USxaxL*)uY!orQ|YN5w{
zVW!c1RL7zTVPyZz+Oba3D9x;n2)4C_oIDcBgex~WM~6aXCR^cJw3+J6j@)|yhaTID
zy|iv(_Fu5{x9OD^BB|dq-WTtkhwz6K1O-c#oZ0v2-u=-{O`v4ycdUt&Vjp)iG3|Ea
zn&AXVZt?^n^z*<G6y6o-@^*_^O6wi&CgSI{;pOk1N53JtSpMCwt!4e9xu5ICdC{m7
zTp*iHulzhcVFl;K@)Ra??}!doBkfog**P$S+b0p$hJM%MZFw@V)@}V;CfX+kl6zYi
z#%)*USqB`erzE$GU!Pt)qxVsSxAd#HNW(Y~=7`vRUvs3L9cA2rC>FJqZMgB5t>+3i
z)}#3^dYQh9a*CyYrheZN1wrNX1l*6b!7>i0yJn8v9F<5?!Zw$P62_9AH~F=IpZpd^
z;z}TQHAGJuQ6&r#J<NVrF;H$9$svWJ-jA}`$)9_fVuRq>`0>E^EE17<L<zy62i)-1
zAUYy^d}HnbHuf8&*WeIs<Y+T_@;O1dbr;UTlau4g+b<m<dmn7n0gYORWkEh*C*jU_
z*loo~af9i9BdWfY6K|9*z8`^^K>OP@{5hs7>zsW2!AS?{=UUSnbU~G*Zw!BREdF8E
zConO33@jrtAoIEbR}pSYAgF(u{~?cY7lhzgzEjBOmgQF>j{la)Bfho4QmgqlZA~gG
zU|??GpiOm<a|8oY8gBiM9i3b8p52Ai>X2g`foWy~Oxa=-=jofSFM6W4tHN@n(%VJj
z1CsBethJHF>H+Krs$A2<%A{f-r{%6>I(zw&rV+x&&y~Dpd25u(Wi)3>zsPLC5o<Hw
zbT<FCy{Q$6{vO$_Yx?A<b?01gR+fYLa&J7Wggy35xhQn&=lqI8@mE8t`S^T&;hV{t
z1l}q4mm6G-MaIMoQ*Nokk9Z`=bIdo4rz9iUEUGJQeHI%m8v=O$nLJE7u1|b2zG^NT
zxIp^wMr#W;b7BNi4eNa|GVY8Om&RDU2OWmDQ)hf9v)K8-Gc#8Ln=18x%xtpH5hnb`
zl`R^$xbG3~CraqtE{%iGB!4ps88gL!-i?pwTCpBn-gKncVf?Xw)79rM2{f%#3vV>y
zu^Tz$&k|?m=vIO&XE!F(<w=OAp(`vO+&Sl)*XwRf%1@tPgVgC(v>4aFE1&H@DE?#f
z9MZo*)(tQDzaeb7d77)13=LWhx|B~UGKkx92<4Mvbes4#Tg8~EYU99CJ_BZo**`Q&
z@{u%BzE4%gQgzE(mnUjLnBSUEwayVb-_5kyM^rrM5p&&zXX@15(=zYr->uluU7h$0
zjACk%wbWlv3b#5dA%;MCSXeHPY?Ghv8?|ND1|$))&lP4b0i>$atBqEA7m{TwtBp4b
zcK74Hn-V8x_(7%ra&NWHOEc<NTarZsB~+bdL`;^$dRMaHE>d*m^9xD!&$mn}>gIRX
z+87n^AAxXsWw;`N7P!hsi`IA~9BK5y=BEc`zj_{{EKL!QzOw*etNowoo8DS0w<GCp
zo!&<g`lz(xz);sWQ96S3?dHF?Oed6T;x<QW(x>0Wm<hnKD>4eDaX<&s0JmJmu(~TY
z=%wZ@0nNkGPol`=ByC|1NaFE`60Y{$F8|`nhJqW20NIN`b9U>5@A~VTaKmv_3ddp~
zOjGUvN0Gx2GOmErK;N!gxYr3FBuB`=QL6)0)cT{jV5eLfMoQ&ZV4b|!;zCP{ML9xt
zSHW3zd<MNj-ffOr)U#2+oftoF&eP1ShYP56__Rp%SwD@)y%o68W=Im5od_Yf?QSf;
zoWcxuj)@mo4;$Hd7{bZmmo@u5?s5CehgfRWs?A0O{u_R0?xq|U*`llts$KnU)mf;g
zrKjYI@2K)$jg0EE9X8l$EPvf<v>?zcOB4yzv52>)HCa&|Y{`i;H)b0sOaJH1)8@Cy
znPLAciu2YR+``h3WuASNey8GrcMCXtMMi6DQrAb#hirS@_*(bCLFi19Y7yoSA^mR{
zZ3~{qhjnkcDeTJhM65Fr8x(qX%)IB^`pwZd<*>iq%Pyw>emP4zpzyc>SiDEr?mw?E
z*Jc&~oke#rL<yGf-4pu%inR;gZ0-2J%-O`#LiPqpAJ+vn{_Ums%Kc@QRzoU?ULQ{<
z0KHrHHAGX6bZ=T-*p#ZuBIWJ=1JSi-=es!@mFtCI!6-7rBONN$-m?WgUUuEJgx-l3
zdGf|c2^6=puxfiPIC+sv`!(0wewPtRkO@)3J4_05o?1q(G)?8~0v=841N__w?F1Au
zalBkkR)q0Gri4F!u0Y&}TBzdNtDPE%xbdG%+S625buAay=b#UUV2~Cu5Gp$jw5I3h
z$aT*xZvuj<rnGF}?JlSo^<(;h;H0VljixwCfIXyb%E%xVpW5i{E1Y^Sc#7G!emf?K
zU6xgLM_5EtR%W394|I<yICeX~HRnrRqAe&*Zr4}&8e_!>d@ArO5M;W-zgO`Lr^i-Y
zZq_RbwK?ba#6?Eq&CSH^ZAHzCs1O4-p9RlDXbPLHXMV=I#4Mn*WLBx$oVI|ca;lzN
zM1IJN@CqGH*%<j$y6;)!)`{fYuT7JMtC?5TR0`$7Bhg-voZi#{)bw+^5oe19hihi8
z|8ue^YXo)Ohb+}`%Pi$M46%G^%C<Mug9E6<x_rYzGfFse0S$D)h)Pd$2`zRcyuT~d
zcBvG0n_6<D@2D*h1H0mRBmS53-V=m<ZcoBZ7n=;>ez^qtq`Ao0p6Z|WQ=fB{6@EFV
zCH*gbJzQNkkMovsaH3lgB`U-1@y(qY)F~5YOFI>E{ev{vT`ELX|K9wW(t+UN^vIki
z#O}AD&rWp|rh{>i1FN?XS9@t#de&OnV%Zn?ccbAP-&#yrC<G({<;m=WtZd<r;04cL
z$p%wz1v^xgZ};utAWHjF2Hox-g5lLacI=@$+D|$eM%JvgN)uu>9w~YYR&>?W&Ygl6
zKN^y3?>*)xz$oR_w=M^<?t7x%2tMw~8xaiH)~)_Wu4B?T(w)LwyItMgj_LAxTrkR{
z!<4l_)~i_Skc-6Wm8Q71sG#4?9v!iarlm^RXn|=jI-=o!gh$%6?hc>4U&_MBUSDn%
z>~Om3S}dZ7y+R>`X{mtd!Qv6=uW$Tr;8F&JR)1$m@eKy&TX#OfEwnoEFHEensn?=w
zT~>8zT@P1ulCrY#C{B%cgidulnys!4B`OaGknyiZTv+&=PY3lK-6@7r?9tg|bYvFF
zCg-9)<$Q=@TmvYv<Z~LaEhJO?C_L(3vpo$@V^I&M`fw(uVi2t0DF#xJgM&5El~}IC
z=1OT=bUGcIclcSh4$--}zuqBh!S}G_<7+kf*k&zGCm0+#vI876h8mZM+awt};lOrP
z#oII`t?KFb3@h#}j2|84>*L9BBZ+#6BrLZLDm@;#Dt+AV!_-6WXH=WEGI&*I7OOw-
zKy_j5r(cX56RrKoE=_eUi<q)v!<)ICO#KTo*&<X#hQ4<7VSSHVd@R*-Wju@S6<qpx
zvDSG0{Us{VW%9pWHxpd@8U&`?*vEXNkU;V7S1~D^ozJI}e>}$NgoyU7?N}Qzy2R1Z
z;DDRFr+W0lzmk#PSAOE^^WoNa2UqJsF@mEqR=`#r?(<i_sSlR|(=x$uJUmy;OLbku
zkOPPx7^J|(y+7oW6P(toK2~P-vu;oxNO|T6Ac|36#GVIlxox^Z-U~{c<Xe{Sq~~d(
z?D}($S?*e1Ayr={|2eD|?ACGI5^e{fEDrr2X~t<>SANszx@#w%LMvY58;Tc$w_HCK
z(~WET1e~#>yuH^kz~24pO}|)H>npZLdZ97l7~Pjg)YI@*rXe4y^O?Pu)qkA!KM8sE
zHe}~@VLV7%9A*bYvou&yQw*e&1ygH&z-chqo_#@0$UR#BpPEN=J&KN37wH>_Ceg3`
zgNuAT*#+Y_+u=U-*A-j)u|^d{IN(JjR8&?kjAvCfnszXT`T9MPmi_qi4u;Ru70ef5
z`K;e=FPH1A5)^wxagJ&m63tJ$h458|M(F*mkr$u4HKNRgmkhN6d7vR4R6vj4R_8b)
zCqHy%???k+u39%MU7pm@qI^QBY*lvqQu3Ig^WF5kb-RML67DVA8wRbHMCK#{qy{qh
zPIXl$S|dhLkS3ZRu8qZk6QNZ`toXIhOcqompcw^Y2>|s5h#Pi(w3uD2`AKr#*0O&;
zVA*tXw#Ihfra69p4Zb)#8wH!Xnwpr7XQkKW*k&vmlfpq#p6T)PLYpI7G34qHeXEPm
zSdTh~zQ=61<ul(^*Kk(VgF3~ePiYxL!P=n?G{auc{I1tCD7j6A8hG>rkliBi*uQ=(
z$aMV_zHRQ#3f9hujXk8Ywjdj%gxf=4@wLC<tOke5(1dEVbI^+V^s$k6cQ|NvRYT1h
zYmoAn(6JcCi8(sTmJ0Lwv7G0}WVeT;*U_0mq5bvd8Dx*w=g_bd6g3X3hSb+id~Rr~
z7=1?oZ&RK3-FW@bu%#{=CXEWG48{4IBt^6ER#bKh)w_ro-A7ZaOLTS}VG=`<FWmyJ
zaO%bz+|M<VGd`mlUeu;HGp-6il}et_@`FgBd*NBMA;v!QEd3wcVx?R*&ld`DT~q8P
zH?Dl|j;ylvMVgZIrt+ZWCsugxmwS}3$sU|HnOqhhTV-LfQtBsLFM)5qUpf#&%0krf
z38XSdBJ$0`*)G%9^cwcRGD9C-kJGGt;z?|ZdqPLxP)3X|Kf#r+GKgbi<~$^wAra?y
zL}^c!8DhE*ANEOEj1g>o`8H0Su)-|&K`QW>eSGCGct`jbt=LYv^}b#jF@vqj66(pP
za@5tX@;($<-w_)68erU#Z6#FHl@R`g+$BGi*09tor&%nhx6e8j3qQ3{dTE*FkzH8*
zeS>Q@;+rvE__(hTMO-3(JKWv*w;Q!+aN6tzwI?FIG`9U!0G}2<W*YT0o~#L*@#M4A
z96b_n;)d$>M7dc2saED8Dm`#z(#wCANZcZoCBLkc@=NV&-e{EA{^`?aJC4b{@XS14
zMdm(G4XuO~NYa0u4Q5Aad_}#DI_c_H;{>>~E_`=KIlmRUr$mOuWIiF>8Wxobv744H
z@D5AzWTmo!<PGhps;M{&q=et(^Wu%{sdgk(V81FglpG-kdGd@go?oi#mjRfyISA`|
z&inFx3O^Og0&FXusKgtQjpLY3jO(Ka9K{rG7^%iR!Q8mQj$GAvMpz1%nkqc<ktTp1
zNfa-pyK~y1uw8v6YOUsxm&UQenQS<AX0AFboUxI?5Lqh^d~g_V=Cw=vP=ZMW&`WN~
z45k3}`wk~V^4v;G<!c>Z^R}7GhQa(_Ebfj*k6O~-7$$GF#DM)?PXQeka`wVoFhc|e
zK05TFl1nb!c^OX3#&u%!pTa7gH*t_7=>{?ntI~1+s`v+2#!@n-A?%+?^pu=UG|l<f
z@}g$gb%}B`4f4Aox`OAs>sl`p@i#h`I3b7d8}u2)V$}UvqYr{4O|LQ$xacF^_)7sF
z!Fs7H=#E5_C%GkQI^tpgJmat!Ge!*<2crG+5>GGM-GTHK?+_k1vR2&u6S(cUGkkSI
zBY|knb5_eCPOba?6c?ZJZ>5^fLX%C~o*>uo){!z3P9p|sEt}VeP(7D%p#w#_p1CQL
zsC0v$ZL~=p@wC};{yXPO=s_J~=h#o<9U~x@2%vWTY<5Um^ed()pb$w{(Xg_yMEfw#
z!^E@y-4WJXr8QQc;GzQLsZl@dBr?A9SJ1~)1cZ?hHY0gynk5|>*?x^n<cOTszZnEJ
zCLLMOm1W7-LZuk`am^a@DD2aAoy+uE267UlczQ+Mf(KMgRdy%6mh5=qS3sS?2lYYT
z!h6)qkroAGW26xy{q_zP-t=kx`M~;+Qv7D-mtX`&C~RrhU|(0b1HG{xF=xkC^X*1$
zl^M@4|DUBWi6<yw>({??PhwG4CPs{<NtPn)Vx>akp3U6dFkgd?@ZuDj6J~!+FqtpB
zYVp`I9UXrj7z__PK@B>n-yP*MTJJsZPs{Mz#_ve|tkQx(X0(Lr_G{OQmhYYa-tkZd
z8vQLyzt}GQ3Ym$L@%i!U+NNV{(ByPoaS!S!)2DCHpOhN6l6Gx0%v#rEp742-4Q`R~
zSj%Q9w9zBumyUCU1KQ`%n=P-}2ggd!SEyca;Bpno-z0yioCsw<3S6k)4L%5$atLRc
zO#T!9YTkHPLby-A#Vj4tqNCIHWKL*tVz0O`cx69W)U7G8V}>n=2;%@we?2pr7tzj1
zc%P%!i_>3HJ2_+dO_cm@n~%_0ld|agQ;-=FfFH7@Co5VtAi!n=vTfNPa)?4Ud|7u)
zcx}gsR4^7^hGt@5ei{E(G`100q@xN|+=q$LauSM_OC}8A(^wt2_RqaE4WuG~(pfcQ
zzqQ)TY%MHFJ_H0ZNUjJ=MT;$!M_c-Y#OF>;yVBLIKM-EvjWzi0XE6yk-clHMMY(c!
zbG#1=iww%CntJm2|NOmrP(*8=&g7gH+b_m0_(0|d&dIfT>DY<rEB1;Or648nyXa}%
z&I!2zus5>7%JNPu&`aOPdla#ZG3^IS6OQ};WdnM8XDj@!q`6&%ZDxAb$BP2sHJQU9
z%Z2hweG46sBX`$mh1m;@+OQPK(giYNEW6VNq$+{|7L(GOPDSl6o>BZLc(X9Z!Z|Mw
zI^sXzxi>Sga8F;vfIqMbDe=Ltp;~v#uIgi8=p9d(8JPj$inLZ?&<wqew#GfBVEi8(
z{dqzp{|<`1bIB+7@uPQ<7gAbii%b^r<$$}O96vJ}mY(DCwqV#(#iZt&mkUw7-%)dD
zOQM!%DL)OF>p-d>hZiJw_!2eXbYU*)4|aci7aE&`6E^ravNSRryQ{>tj?%MtDJ(q4
zYeA|tc=HN9eq)W@)=TKD(14Q<UT{r?q?>gDgQgx`!{y&&e#Honoqj1!T&{aTwwe3N
zasCH@Ad@@AFDxT{m%rcP6Oo3{xz|VcEM;sGVT*ZW%cv1<M+k^Vaygq%7Zy9jU_N+9
zL2<w%?YOkm`-rwK!{un6!Nfw*^@0Bbzn;;jet-2U-%oomb~?Qm<jwCUYd+_I)dHk&
z2KP!|Pe(i7sY^kJmef>zE3s8vvBS@m+N;n#Y4a>FPfsMpR{#elVfBs`L5h(XNshl;
zYXC1{Ac^kxKYnR7T(iKWGD=R@9~nF=8)!&*9?aPx(WM2jDdG=vvyOyuHoO=QT-_#k
z?I>2rRw8_B6qfy89QGM8M|8wPZ0*MIWf!mKc`%Zgsc-74;)J}0n>$G*hpca2?)Ag?
zKk`&>d!4Wvc9Q6X?=+5#-Wsr-8#ae$?4@UM+nIkmi~#D?6JRs%F884tuC73CO&Phk
zVUt!<<nK*K@#_Jc=@SnKsjv2y_t`>4qT_528fc7?;!jnLQUfW2Q}vl0gui{z*~(`+
zZ_G;uDN$M83SsLfo&-W||Jo#*R-G-bf&h(=!!wdbX`c+1J9>+5$pnXQ0&^rQlR!#z
zV-2_;EMd7l@;sT(FXvRbHKrMPZDyGDOrS}QU`H|BiXeifBT;()DwKl|=KYf`7D|!<
zS#08MB?`V0$Ndt&A8T@h7idn+iPVntC(cR4_RFWy8p-jZW<7KDBJBJrIK4N-)gRk(
zjw_WSie;(juWx<z_prbg2YT^w%ArM&o6O8|sYHQr$Xi;Y<L7I?;7i|Mk>IT{pD<6Y
zyDoTt)T?JU!+PSMNogFd3z5ltFWvm}K^z45l_n3=ROt1^FHxctBqX1RmJgld?BHYu
zu;7)8X(L#01;HfU_&NKCDnD3KWz$Ea@{BQj8vJ}+LB=dX+$?H)k$A3@rQSJF*OAik
zcrDL)YZc$r0VbP~osnTL86&#u+4V%h`haTw$)0tSxYHn=j7DTPoGtUH^q%4DoEfNO
z&<?;NF}YK+sKW(1h8=;Tr+kp9f4W{4yxSb0YDDh7-2{)Dw1&*QnZ$IquO#z_PP$?0
z0J0(|)?>qLu1#?3PS;)$SpK0ZfV@D6l=?>Bw#;HWoZ*@2vdDzmw5(!T{8Z-=%+KH}
zHn#Udo6`;TsWKTlz>icn{PfV5lkYNqLp+{qWr3=NC#>Rr`^!Rc87ql7mM8u^o`E+5
z#-7M4A1$5s!mq!(%glUogL8x4;v~}P+f{G$*xo>f9PvDU!73cgnt6BD<6+lbBV5oz
zK(57Nt!8MAlFmI&J@Eq&(E=Xl<+{e?#hV(y5g^gRtwf=6D_+PjKf#7M#ouM~sp(6_
z;i&uOjvp>AR8PwMt_sl3NsX76u~1+k7YiRbpyB@HC|%x~BPYt1GwWB>>#<Z2JU%CK
z$sH7xOewloEK<2O_r5kp%onCipEMgMzB$w=PxBMUD$J0pn}_gAd1yQepgcS+2hW47
z2$sSd3N1z7Ox&!0kPX1#FK<5<iYL^UCSR)gW~2FuOH47rVbA4V)JWH)%>~b#{o~G8
zK>u0DmGwK^{VfBMKE`QVf<h{B+JU*;+LfYa8J+ap)S>|5Xp`53gk^?MA-J+2;4UdO
zevmVfqA)c}xRxXV9BB^sIuf7~0nCQq223+N>-EZM6wke)9BICpiTwVH?jG_b2ublq
zJ=9q5tkb@Viu0f_pcK0hh|hlUeY59G<+~ylsfM7^8Qj@^hS)1$JRP0}s%-_s=oL3}
zwcRIl6p@`kyUB=qv!r!9?+IP!6@BVINRg_!u7kOirGO1sjR=5T$hgj};#4R42m#k#
z4+?sA<oMaBL%}x%en}CaPpo@~V|Ft%yG_yd3o7aM1tIlnljX-@&ZRXeMHQlMM9qO2
z%C3n7wT$Hv5g^)#>C>#XSA$Kf%4gRIr&m_^fdHZpv&J3w(r)G&_w4BaT(lxvgHejC
zKew1TPQaw2-qL5zYL&O}xWK>@BhqOG!IcOd96C~pc#6^}v?Zy+*Lcg%udYC{2w+3=
z;pL}b-P?7?LHT9hl8t>i&9Wt${*bt#)S|Y}Y^a7LJA@>EEwo|tX(K>Myv64?Fm~*A
z><h1+Od3ZqA7fw~KTKj4c*g=-?y?N5{nnI6HQ3;H;>Mv_+ZtEuz-MlR7If0eR|BZ?
zg;L|SjVQrsQpg(xJ5P_h`jiB$`(}EvG3N<}g^?y4(t(85OBo>A?5I}>;prDfKy)$L
z+CXIg;NsPy9dGw?wb{sEh6s*-dgzu^*0OuS-2-jPzu*8r*Aqnfz`evkw#WHpJyW7O
zmTsXhaOB{+o4zYHdbq&&ohVI%v$z!tzn0jUrul#W6*coGmDqMrCwmWn`Q77~%1y28
zAz?U>E_C8Yb)P0V=UvBk#&=!$@>Gx#gE<WhM%(EidjS%jj^413Z(V^pE@n@U<O9p+
z2@1wu)<`s0bkcjTKteb!Tp1ZLMJzEobB)x@j>$W42yE$AqN;1Zb9<mZe-QE4#_x-x
ze^M1o*{{c-JBk0|v$h0IzM^-P;KqY`_vYViBsJu&1xcO7{0BdUq^eEka7k}S-Yn$^
z_f|U|+<<k&<IH(1sK>AvJm{o39lCx(e|gP^gxbSmN!clCLR`G?dlv$~@U7rkw7%n~
zz)4(H6}YF`w_%}zJ?7cA5G=@}!Qk0UcS2g_sK#RG-tsBn><+JvW^f9g(9N{`D|AA<
zSAL9bl@y{@ha*j~b%ls078Ubh2J4sK#-zw#b!VTeKC8y53Ky(8d2_<>5YAaW*(<<p
zc1S*9y8GZt_%5V46LP|wJ_XAYc-)y6efC)lQPGwTLg3F0%G6&(ejvdcb#QC>e=h(U
zG}Enl|F|y#g}mYDPmYC`Y?-^4QPBK<84p|@)lraeJoj%l0T|r%4aO8KAxpq7Owdl}
zh_CgHa)$=A=oSdPd1Iw=5Y$U3{=EuC<?3_xP4^|A9Alw<bPGvKKw18|EDl0ZdB^|e
z+bM3i5!ReaodTkr8$O_M?Mu$Di`j*^VK78`o3|Ow=LLgwB8lkrQ3h?`Tgcb~GH_CB
z<X<689nO&^5%zF2_rFI{55qHQt>JGD{bB-$K7qM`#o)u28UMXt^s0&j`H5-#f;<8e
zB-6VUUd!LA7{`UQa}f;NXdX^psB`=G6-`Kw=i<IK`D*sG+7wemNJnw<1J13Kd}r?c
zV=?nOIs;L8?{%O|kP=0uEJ&eZgp<HOck6()=uCJa#iEa@fBpOEg9%;QBvc({x7?R}
z{O22fytBS!{<PYO8LAFZc}U(VzN9tUec&7in6$bOb<bD8IqFy@T<gdhZ4MF3)FUt&
z=TA9DY6jjpIf)q9sH{m7O#fL60rl<{-8YKwJd_*e?fH3QgoB%B1MiY5<4b%FrSKX@
zh2vTEkc3?{V@lgrGi)M&)>;p}XPtR9S9{KO$eYx<;>)|eY8tri<{7qs$I!&}M&bL%
ze4*2QiK91Gdy_XbNp$f4tBFJEN)Ka9i=**Q$TjOf{5QS%9dv(%t28|iqP9d-{FVw2
zWE?-Eaff*y6xxj4!jU_#`j>qTCIa8IyPWdM3R?#e2-kX8tY}pPq-Xvkm;}Fy!_i>G
z3VW|g1zR@Xb;dH87t_v#rpW*hT7cO);;43qZ|}0@KUL!w!lPI-ap`1DpdP!qzRVmh
znSR{Pc@t!wfy9nKI9UM_xg_Sj3{}@2PE*4j2|PN1!C{Jp9{8*E$Z!uDDm*o_wmxA|
zuYkLqTN(%M-{Z&Z99u=j8nbeWWsw{2wuD-b_Q$Dl(LWSab&QCLZd5<<1SdK{|II?Q
z!l0laW`{l{?NOa|NLGHuD$IDe#eDWB+QjDt@O@<K3i-uc*d~Y|fPeWGH2yc!E?VWB
zJOyC#b{pkm@@j?%X}Yx1@y#An`m(;ax$sDUEB0T^XUA;0L}V&PDex%3K(w(HzT+oH
zo7ye$@uUBRtWp-%LIZMg+lue^?sZo6C6VVacI@;uCBf2UqzSKZI+9s`kE1cc0`lu>
z0EEuS=8-*nSQ$|;B3GVm0Xx0#V;;|HV>yx27p2DALTJjY2z%fD#bVQG%Ad_%8@7n=
z)sSKUsqG!9HulUy&<BcF7uB*sarQ?Y@xtb$ax_wwH{K#9GkK+}vr>+~VgI(5)vNUw
zc;SPGoTgRwL<JdP7J4`qa#}G8#h<z8cuTaF6L~Hm?z>#5nTi8Q)eHtZqKe=VrBN@~
z?bvcS*pG@bcqAjjY@oC1lGku`rmT0u%x31Yos}xeE;r>}pwdahs<y6X7Ae1WK606J
z^;VNf+V;+FO6q<H+O4me0C>fW0Fh-_Ym+i=;L0stNK4762&a`5lgL@G=bX*94C2@i
z(wy(R_hE3ao$+Zmo~G-`**!&wf3R_Rf&~1#4NUBpxz05wA<zypo=%TXRR`v70?B#Z
zn1sgas#$P1LdG0FTrPJ7uI_4eo`r;8SZuvsu2Qdmvg(u;a^qtdPwBx($+C9VHT_X;
z8sEbPPW=%d(KW2OD|P=3bR#TRzCw$7b+&XhluL=#m32@D;O>y3)S54GHjbs|Jq~hY
z)63>V3@^O>Jyacg^zX)xS*?Q1vNk-2Tx@V`2EPh%ES@;nA0J))oBW$PTchnazU?se
zpMif3sus{nyV~9U9++h8=&E+P8HHluVaQZA9nuZH5V{ZwaYbJ*u4#0-W3)cImN7$G
zP6T_6evQhk&LYVFS9;tX{Ai<F{^lQ__jys$;%ibkjxnT1B#l&JKF*H_9Za#0p+q9+
zSnn4Xc#hTPr-78n_9tG226JkzO+E1n<CmqvosTT2&#$TNR0i%7ac67BhnWD=sQRW+
zODLn2Uo!W1qfd;D^x0caf(E95O{9kV#1lKOIq)=ErEWkZmp*%6SY$Y^?pw8$Y{pp!
z;%=2rl?vU$+iZy2RDo39Tuf0qVF^jaP^{{=h#V}V8?^d0n+9wxe3mMjE7|8Ny)3b;
zx%WWYWhc6(*0n_AAL}BX1>3nQ-ER2!MUKn!xoXpp@<rX2z2)M2*j#bO@C)V9pP@OW
zo##x7i9g8loG%D=?56s>WlU*;xPYQ=BE>IO%GTQ{48-Z_dCM8OXL`T*&HdR5cHQh*
zVA5WI)7Ls<bq#F^a}+HK`J>0)E@~EbG_Ns1mi13SEc;z4R^mOAFh#aOXh;Zw&dNzB
z-u}nlwNgEg4TTYPxO_z%h6`*lgs~e{7X$D$4e|<Hk<1PX*7ArMUB5u^v5-_Wd+cq~
zD{jvZzHt^8!V%SMM3Zd=bN<S;`#qn&vOV(@j-N?K+k38eF!#TVMg&*hxc%a4e<`N|
z`NTncBptBx(gNF)9tY4z?d?<lk(l0E7ow&Qb3240T!t1!i;Cr<QYcSEZuO_^>G9W|
zQ!VbcTKn%`Kf|)ejq>A~|8Ug#X!}yf+bP;F)PUbGR(#~cs@z|&AG^zWj{(q>h*3CD
zFDgIb`b{g%>p0d8Z3l+yIjVsB*4lIexe^<0i@EoeVc+WA0c-_(JcP}1FFqO^e=W66
zT5&%+s2oM`>tDY0%UWd9Hcjr^KQho*UzMXY{7INTSj+a>_%l1#3UkVmiTrm=Agh10
z$40U&1+p$fWQ0Y7HdVjV0L%~$$ocv0>DP(sJdGu`J<`lC<E)(kJv4od#!f8OOq(9V
z+4(oWS)D(snuUoTJ~BkEINfB#16Ec+8Ii@b6M<t<E83}<bkbnQIbR<?)+WOPbSA@+
zL1CD<1;F^Z`IgQ2+F7(&hi><%+v~R=8Ai^rT(a?$sDt8jcd_uEv2zk+ffG-msvKAq
zEs;^?toqB5A?#xf>7K-raWFg!G<vW7Pw!CY)ORj0FalU;RkJQnXZ9taeE3jTp3r_5
zL$fTI>1X>hi5-d^ieb(=GPgHTf7VB<qfDCFX^xFgK5VE3;N5er>dg<#gb&IOQPS%1
zPy6wB_xJFYCd4eQqGWtIAjV-;tU{+|i!B5^ALv<eUzA`o+*acve_r?nyYai&)P{jL
z+&Y{)GNyb#xrtLFLTBAdSaLBbKmBi;815TXk0jWtqq@UWUq4lhp#4crBwa@1X}E>m
z_hF;8`vYwVEC}JomeCd~HIvg(fQyPuq00wKKZoA&c?hPWKIR%Tjbze2xAss476UuZ
zad?P=wtNCytmqc+g3a;j7Nh?t-zQ{bc9<pr*Te9D6IucGZ-~6GpmL|v+$g?Gr<pGk
z4g_E;`Uqf|tmXp}a?>Vf7g1?h=*c9~2wKr3C86W^odm$)d4PWW>!;2692u2Kk|CSS
zm1m``hp?x1_EUyZTIKE^=S2S1swMUAKh)R#Ic!FH$;~yK{%lAprIJ9G?|IjDu28?<
z7|b8KXEM!U6&@WtkA+*uhhvcYF%}o?*6!5OCnedZw{959E}g@Rx_mgJv{D6Bn<G!j
z;65_{XlP1EIP-<0bwOj5b#vkC*OJU~KWP0NgOYs`4#X-XOm8;>4BqC=NK`(n<E!|u
zO4i*N?%Wyj`gTevQYK@ocC=ALE?Aetn^vRT!+;0~!Psk9h0AEHc&6Xj@QvnYRvzZ|
zs;FnnRu0yox`*zq5npQUx<9giCN3WB`$P8|)Vos-=c$JWt>*9{&NAI&bHF9(w;eNn
zYgp+s3N$|aC_*-i-M7Y0s|wbE>6aT$saX~2FoX&15LOC|k)d0*TKz*s!+1~<%Z%<i
zj{Q604gC51hIoB@klqfC9+LQHo<dOc_tROfY}9gWp}^2k#eMHrzZ9L0n#z2T5)yZZ
zC*$8UgVK$esPF0$*k?KviWQEm-(nxwKdYzX)UMZ|;50zm4@hF-=T|NSj^2=chK$V0
z`g}EPR_BXI*)?0*w0CHnfdurikpo%riD&on4MpkDS@!QD<B`pbWJK;Zvk@RAlo_1L
zAAk0IC<o)v^Q<qp@tFFPp?OR@!=qN;dU(oGh*jI$naNG5F{fSF#lDV;id)xCNBjp!
z3wlMC8&?K3*+`*#Y<cx(xFO6ulT&W|!A)o*Y|I27&WLB8puGnXgvnR@E>=n+J`NF~
zU&f(@>Vmgu(5v>2zH_`-Xce9Dr#_`*cV>T>COW3Ve#l~z!!u#MBYnlND0jkz&>QeC
z{xMW0VD>Q_6p3^a@kYqUY9fFh&1^`Ee5;<qDXEGC`t-ULjhOpqfQ5wlU6E{l0)1zh
zu>;@7*2k0`X*%iT+RK&!{YBPewMtXxhoM?!1@^x71Z^2^4-CjjVGC$mmqpj;Ef^Ex
zH`U)qkPT09#SQ1;bW@ZJMdE_$#{pYWK|u%y+ieS-Rvq_+xGaMQ&D+xRm+^DSF{Ws<
zRB4WkOd6=;Pc&BmqNOiQ(1qd@Vx>ftFB7q>FN4=wW}XUqpu*-o1#uL-?-r5bg!HK>
zsw~5(|BZb{3wHVha?Y=TceK((1O>2=Xwr((=EtXxg>U#wfI`;3-Q$JJx!ZXTdR+!t
zp?fE$+vBr(V~d4%A38pN*zX@XQKSnVNfX)`DX^fk*7~!7G+TV%o6Nh^#JA-q(8A6a
zwwEz=8BDj<UEpg2xA)MEAXshAcoZiU6WQ3Ff?dc6K52*sh(;!0mkqnRRk!=uyX?1~
zl17*6yKnOt`s+N>cu{W#xCgQb{aO1bE_uC<v-nvX?v7>B8d5cA*~o*>@;#$OInO@*
zqJ9@0OusrYx=!cicoDCP02$55h?99Sq~}XZ^vkn4*D+d_6ohyU6$YaA41W4F<Rgc!
z{nCc^bri2($eOG+d)l}FKT?(Fh!)GxTtme^Y6nz7D@~`c@<JHbVA!UL*d8-l;nnv=
z+~$5`CnAN69oHJx0cZ!x%Ea3-HsbhCWG&Ly7sTUFEU56#!6)h%dREzSX4kf*<h%BV
zI7AWd+Yv4u9L9L~Bj}{D9mZEVS+lm?nR7<2m6$i~GkZPgNbvNJTz}%ped6N}%9)^>
z|J6#ekewy^y$}g}u;h&9808&GJR&pA)(dHuu(FzN@Bof?(FCcm7+dbE+dCSi+vySx
zTxda%>CFXO!287#m+K<%hhkYwm1l0$AWjPPP|DP*S29e6bU-CHM&Vj1aR;IK$5r+%
z0UNxhdvfzK+GP0(Pm)0m|71XG;xHTp+%;AeB=pU8b@c42{o*}tHuWS}8aW7!a(6&&
zL1YlilXx=yBKUobW1vutP>&%3m=T88n~m{u6n5A~KWeb!_fsnU2!+jY4CE8`=w9o>
zx7}X6X0Plmj7^0AL1vg+-Q&>V&jK?%*2nUU7K;^5r{aah0syp~>P`-Kn<OZNXnf1>
zOk$<d<Jm3D%@kMiZVeGd7v>a+%^q<fx~GWDgkCK9xi7rkr=Rej1#^}4C@j$&sQ^4R
zG1B(v?4#Ry<GH*n3LE$4Uy%Iw{kQ?Oc-yU!th$Ld>SD1eReZpTGFF8qlVjW_oCBos
zjI<kq3g1kj8Xs-Nq)NkO-w=wEBX{PDImKVsHlv(T1a@+(Yp4vc@mLC(_)%<;X4W@I
zS#@h|QT2KM0br&*<d1=OZuk*Vx`M9>)I}@63akSS3dLwyvEKVLkAz3NT3t!UH0OuJ
ze|W9Oo<&qmQ0wnq#KBM3VAq4!C0ob>6l8d`Da`&fbczmQ0%Lpe-4nyz8{YhcV|Cs*
zT2-hgYPMU~_zE9em4$2OZ;{nC(iuHlM5=cpbS^r1at&{eEk;KLbhJbV=FL3cO|Z)o
z_=PUH={IDC>MeIe=|QBW2af)&6|>H$KC?*@vG6`pp`)>~{_A|xq;aX{Q4jh(X}OIX
zB$?&pPuixGe6Q`^=)5JjGEnj`!j#A7NiY>yg?zmGLnu<*xhblrh$`PZ{xD!lqExL5
z!v2YTdIgqySg@GcYJLY!_6!OlDNrbuPS>4%5G8N#`0kG1=C99zd+y%!SqQ6eSj~Hl
zlx$i!WhAdkB8m}Ixo;PODo-<8`C^~;HD|wSBAP)!He+Jxm9(}n1EfUEKseF0rFjWs
z<c`nOr|w<>$>4~}mBc|~hi1XhZ+gw4gfVX8|5)GI`lzmIjrB{l;~isG?<`I0l0s2R
zW37zr+>fM`Dap4dWBL%?cBGdr`R|u2ZKQ95>F(}X*i6v)9ShnPUw}y#y@Cz5zDR_b
z4G|9!91?7xjRh%A2G2^JdWJMZL>lB8VagBxh!c~$OiMjHV|&yA$R%>VeK4no1Qb)H
z_r9oRr?WV#$CY{?Q|o1ELoy<O*jg6{MVoJIfFDVMbitPdJ`IFmhg^9(UP1m@w}2)c
zOBXnvwU~ei=iU=6*K;*geLqGh$0%`Xr6l^@;oz0+3~vlrp+WJ{Dqi0K?o)b=Mp;q7
zluh158}2oa>3y!HGGsZS&dP8UnLjJh9C`wh{+-vgRqsjoWf>((-C6SUf;h<$_<&Rw
z>jvhDfcQEl4f>%3$(=vECLkiId#~$8lvZK{jKFRn?IC>G#;1bFG`#V%0baK3g`ezP
zZ_4BB`T4rxfu4s}9Uvv9!xt&2iF=;|@jZlbLc2t3rjdlh_a$Py<x9akzj~&?%=vH!
zh>kG&UJ*FBv;=o;g`#+Lfb}2faTb*E`%4%u*YYkIBuKG)=}T*_m2M`&AXX|TKE6i4
zvo0(GA>uxyMM@PyMl#)IfyBqh3GymO(u@W(4WDL|IjqQnoFzOphWDU>Ym|kdM^w!F
z97D)vrZ^lu8!(6FgF$bt<N0^06HjH6r(@dqw{=*$^rX1_l+G9`n?+~qzbOpd@DiHj
z=27hYq{Ve!TMIUb-V)=&2sdwV8^{_O&+G#<Ic%d>sVgfgmLVjP#44yZONRjRkysq&
z;ykT>m-HGP#ijbKcunkk;00f@B>+5WX|+f9x{6;@Xx&KrFKAkhAh<x~rc{_fzQ^%{
z`|I_nx?6gG36zZ0Z}k+dIy>FXPKBJ6;1=zG-z(O%(pDyIZBTY5^|DYp;>?M7Q?|**
zOfn&V3Bu*tZ1MWNim$&06rxT>=_e5PVHG0c-!5`>#@59ISH|SzkJ$5))g+zu?*c&_
z)xm91pD8$-iXlPLEZ`1HS>JD4@u5Anz=EWPNe~6o5R^VIhqj@Z4%H^x(z{WfR7NZ1
zJ;1{6A3-zgfZlC!If{1bq%=%beRHpJL$4TNN=Y!U5GXUe;YMPwSh;0VDg06aIw+%^
z>oWS)e=Qp(RhiX0!D=1GtVqYn{C@WPtCQ-D7EAv4w@C=M9B5TmLRrwa1bFk3(V?=<
zD>}sf{R9b&5QNwb9qgL_NQ!4-x87OUILlyJ#3b;^9BCO-l6Jy6wf<jJv}}A_DK=G!
zHz+d5t^jAB<nR}*B*4=JZsH(kkGD@fE;;)Ga0UMPv*NNI7E?~jNz$e}`TPMdUx1c)
zN>tHc$+j?QY%m!(>@N0eBvH0njsfbni6;it(ZL`P_?_UCwun}G>C$=4r!#|i<CO-v
zyE>~V#k^6O(Gd8xSBfVWS^RAj%>S=L%E*kk#p$#svuX%>2XZ!+JQP0lv0|WDmWbeC
z(#7sWAM)^I9=E^e{D<fX>_@R`k33~(+$|g3wcI;5n9Pe7i}pQS$*!c>T$hofhzz6>
z44}WCE68AVUy3;dL&O42tr&QLTyqZk)#}xu18w1ke6@6T>n%kzw0as1{_G;EivQ9?
z>pzuz^V4~vKZ%#nfH5P438>MblCzHzJ-*>VU*u9*_hML=wpbgnE-j)}9vGB>{X4wX
z6|x8~h-28ltR!C}Yw;Cxkob#{HINCz6}u}W>U97or9sJn!rD_5yQF2yq;FQTfOalw
zt9sI$T`;P(H7W|c*63jz9tI^9e54wD7=ZuQ>CSKd-_VGpp!+4n6E9y(_kO|P)!e7u
z2W&{Hw*4<(V(k=P#C#xIC);%iY6224iC%2*a|eMMC(^8@{%2L<ivq#jB+%wn+<kaj
zKggs`-XI%`KkRVJF<=rpL9V?Pln8=Yl(1QRkq&VAeN$4=Nox;(AL%0lPKA4*Vt)ye
z4RYggQXKk?RYCZYoqp~n5guk8lh{8DY#~YZn8(Vni`*C$bK6EiOc<4xHm3ML8dR55
zAf+7QNV<k=*vd`v`G(_y-yA45tyB}vF$VMTF5~io4Y50nAY2-zYd~@~{R_n7(bpow
z5b^i>^4iLBtx>8lt5<U)4GIdUUOxmx9e~#|cBsYA3jVPcmFe)a;*f88g~rGt@fb%w
zR~)N>7CAAp0ZlY^dHdiPIE<}BJaB|&$kCGtByckI&L{qJKi`Ju;LIN895#o~nP@DM
z>Nbtd10nt!%7O6psqi&+$VLgYAJuupgta#wf>v>6P+ebn<I!uegM5Wl(UO9b>7VG~
z@R~sUH6%C<fV3h=5LlY?OVA}+)OjNd!HXa8W4>qbmTmaYxvqglWldQwNC}gIlo!wF
zeG$6nq>L_3Zb?a=jxB`ul6~Ku;PmTJdi!0{&+>#pGYDy@Os+%7;OUl*V?&+cZ+gn0
zW&){MIIR<R<{Lc@3jcUQyqfFx6NWNc<p9>i3*==?1%%fGyqvuxCQ`Z>P+_<r#nd5+
zH{j}6&Akm-q8nSwx7ntwl-AxpJ#KA~>aroJ18|Cl(xD+2CSW`Dd9xZ++JP-4{q388
zk~0wyiz+OM2fig(=0u-ocn=2R^>SFDPa)ozegA0md-5=F<!~1dJo`T(;-3f$*^m0g
zPD5wraO($h;!D5-yq!&qQkv3{qt%o$ie<6!sHFb-RWax7r@AGIMg**w)@8*`P;G7q
zcAESTl-ziDiWG`c=v#SZHIj-+vL5ZN#32vsdFlP+nD*w5R0$etvG&XsuLfP7geG?5
zF{CR%c?fN2$`%l=LoCQH&~2_Mpf6QZ+XdkacS1P7ii<D9bHevfz1)@9mO~6m%At5#
z>|O61B-<ljWd5x7-vsJ3R22i2fZtR6>#g0=FRfNmQAK_2Z7em#`f$j!Llbx~A;6v&
zuP!_JiRI&8AzKlk`wZj@Xz^op=jJD{uJ{c<W=`l!Xq9`*sR98GlJhl`BUjoTV+Ra`
z{Nm(I1K`eO_knHvNFmWILaUNOTIHdoSdvKn)X76Z!m*gZvDtail@|><DxE8#EOQR>
z9i*9(_!6wJSujMSx$HiLTQsMiHjy%L9!{TK5%fpmYlmB(0dQ+o8uV8FOFEz-HLfgX
z`{{pLsvC8lxUrN2#T344RbYG_^vsTR0Pc;F5h6E94S9`D1TeY)_&LPB=6YY=>otYp
zv)fF9i?k|5(4qwWOb_kgh-7MJGIAbG$(*yKA{MG>W8=0yVp_`4=c#qiC3QELQv@py
z@0C3ka}1Q_d|G>mw*(pu-(aXm1Fea^Evz#nzGMmf!Jypoj*Fm8CiW>4;~3JvhW9;*
zLkDA^6ruC05haS$W_}!c5QR^<PZ0AsA(J#xQ@KzW(BHvp@6PEJ&_*ory{q|64R(Ol
zhJ&Fy=wo7xJIjM1A3VaPw-(84`{2Nfd-}gJCl?ZjxCubxl&%gM9lq+bmF1H2Tf(pY
zC}`u=pm6x+Gf@*{ZDX+<kP;z;mjsx|4&0Z!0Oo&Pz!rI*3o`tnTl>E3r6&>hVLDLx
zdcKB2o{rA~4v5v4i>BD@0IRfaE$!@y&RHZ8&<okfz2#G<f!s6yz^vB&o<96@@bNpA
z?2bXn(J5B~et1TPI7MwnVfYZ0RqNh4rj$aG#omhL+sDBTZt4-Y^)s+)b$4Y!@JQsZ
z!s+DZL)7w09tTY;v1%oQZHz;aBMWvhMK&oWHIzkK4QgQ)ipSAEKD*t8Nb{Y>MwTrZ
z)p^)oN0pcl{;5fy$zdH@!@eoY<cfv}I}EE-VTsJtlC{Sl^m=lC^jUf;+?4$eFB>r%
zm$LXoE6tf`Q6gdFbZ|p_JKNMfuD92f(yEYTlW#i)movd_!_O20>9P@cs6Z6)2;kZc
zTP9hW(YIwn^q*~>VSKmyP?k_6))qS<ci*$B{&^R7|1`zGx}eHpuJ_PJ6B=9}Bhs|T
z584kvx7DIPof#{JiFtvKCTg4&lPvZl+aYI+M8{K)^=FSDo?i{{aBYaRYaBr>^24$#
zdr(PYZohUFtq1*<xhv%`c~MImK?GLe6WYvjjOHa<(ymJqJ$t2AHFL<zFTtE2_GyIH
z)a(|M!~fx(WI1V~C{O!?o8aF&Oj+%_$0|+?h8Bjqe78Ac=37B_;Z(=MY&0yg5($^9
ztOCR`xMHO)a%n4==6}#W$#xHkd|;hvzS@+B3`6OUTbNO*cK)l}`IkQGCOCAgM^Z}k
zSRN`m6RL_>eaX((nb5I!!di)n+2Z7-EgvAu;d0hF^?4`%?0xf6h(-i3*~{`Ww)2Dt
zWVrLgrIC7?>E|h}%6jiLrA0i#SMS!`(ab)d;Aq`H{5gzbifV>)_+KivRO|9#`nO~<
zGKw^(Wav<k$x@*oWPclxu!#$XOQ$OwpJ9uY+7QKl_ylF`t5-)hxBu#J3qtA2BH{Nv
z6XcXN5*7Yee`aw6y-{`Z_vkh|<!`o{ljSGjXHqx6TbjB!g@^cXECXs!{qgaC(C_xg
z|Dsi%a7Vo_QXik-&#|OMJk>X<+<fZce6gU~nhql~;6L3qrfk^p*ZY4jz?sJU4KPAt
z(<lQ=vV>Mz%y8BAu>;L(HT(qvLrU9~KQR5s?<${vqVf+d`jFPgsQCo<&skFIbUD#=
z14n-2eI?g86PDNxnGD8qPV(dnvXl$WSiS)cP#wHa{%X9~V*b?QBDAfaAYvoghN#S8
zjY9|oh$M7Q!c(rff=;(@s`HbkcS|VZL9~8NH1VWl0<youWpHgG(sYea_tOr<|EFaB
zhhEca{LMjbYDjfF)+_f+=Bjt1*OYvRXOLO!o*Pw{qb}~rIIfIEg-j#-2ev>$Y<wSb
z@e^GtY2lVCLu`M!tyE(fx@xqjBHrubQ?nqfW}+%|m{mf}8_S=lll=~K!@bAW879T1
zyS4&Y4redY*PG9Ht}WxAIJb-+sgtRx&m3(TU!~*iuU&g5h0g;hR?8G_O5B5x;CzhL
zEf(0#yY5+M)f4x5<N+QF@)bi2oTBrm5B#N}<_#6l0478KlY6~^z1dUqtGA2zzHcd~
zCI4W|nB@ybPfFf2?437^9&ZeIHO3%WWOmmi@$y#a>Y(1F3Ox4X4U3!f+N^g2A~a;@
z96I_pV2+q`5_n4*Uf+fr(@}-BB>cKHQ9MD3DT${=v{@U+Ys$Ng435rUfiucEo2l73
zkC;Sb_LO}k6xJm)8|JCS@8@vx8Ec{S4M-^3yQknZlVT*6i6(GF>5gkfin06sZ7NNO
zg!a6U`DgB0NWCX&!bOpjiLS_41PX?Q@=^KJrRqmd$2l;j_EpswE0Hchdq9xM&QTj*
zepo3p{fFX--N=fd`ji0Q9TIDk2SNI{`74K+JnU9#=Id3?njZxc%}qE%s^?<7-aP<f
zo#5TBaYp0icYj#^Tx7S6PR7lnGK@6SNM_=nmYb93={R%XP&a7AEQ2P4J%6o^?cru`
zBrc5>Qz%FRC2%Jg`DKN{94WN#XGw4Ke>C0Qh)|ki7kN18_srGri95^)8d-*#?+{bg
zdq2#xO0z^oXw3%jw$jWZJ6sfDIdSFAwCVlbq)+Z1>-!I}Qbd*dtdQ!O!p3)oqm1Gu
z<?0s%TS|xY06ox#?*#V*#mioruV^v^su6Pj*oXFphWosAeAE)=`BU*m=@03p<}{&!
zQk>_q<Y-BXG+Y-n9FoI|m^$7q_9)5sw`k~0|7S$g$X~w4uL9&*AF1TBiKJ**&Q}|S
zQ??E~3--iO^?=f0M8xA}1W!dTL+uGv65b`A`QrI<MeX${-LaS>hs~*nQ%7P2w5;I2
zyX#?EAA-!Dd%mb%jzHzEsMfb4KzO6WO7E}j3zve2NIlKlm^&&-M|(GLTwh1i*J&IH
z`t5F=FxW#Z9+ZOvqFW+8Ft7t#$D@Cw!=O?p;eT%*%)XpOlr+PWwK&VrFG%`7-oE)Q
z5;yEOZf&+U+it7Pn2gP~YqPD*c5T{h+xBGJ*v)oxX20)w&!2Gmajvd;=6P;^ZgIvE
z5(zmgtQ$P#RENwvPe1i6PyRyz2JCW<_fkMCnkJKBRVV6mc&H}+;ZQ1*!}$c%WXfL%
z-zXT5Jf~i#f^lHLgFEWitSul<y>liSP_a4jd?nU&O*Hz(NwX59(hod?_vIJfVlw@%
z<Y0)f0b_;3ZSa~^4*h5iz<vyZ<#%83v&w{xo;TX>>u>496)B9I+f_7tExtbY(t;Vi
zlilfC-sXoouumt{W||gv<y`iiW|7na7k0v>K_{UOb6m)ip{gv?ZBtorO`*~@l7$>M
zy>7*SlDMk~`kX`>H-nZkBif*<uKRLH6llWNZQ&Kzyj(+zCt>m*o@~6-FBtw4aZRQ6
z5}GuP1B^yJU^Dq6fMJx*Q(;4?<3K3;(4F}pli{!>1*PO4Q$D8P!1<cp8_3Sbo@e_U
zrYt}BcgH5TdE)wPLo-?D$xt*y5Qx`~FyQ-e&`iai{FunmGLk0@c9EBeJrzoLbS}Ps
z>6u}IpY5vVM<yit)MTw`{fYU0c3h21>nA_!pMc*2@n+FXv{5Bb_X=^V|G;IGmIr>r
zE=|wdHUCEn>sKH+^>c_moMf5*xC_sL3@(2mdOJEvGX{gp2=T;mGYnd}RRzl3Q*hg=
zk|nL>pI078134lvFc>B<M?Dm5p)tOoGXF{gKxOFv+2ErXL#1)I%($#`ZafYNb+~|6
z42@rMx+79nv`rQ_Zi&~fWgZobFg4wte{^)uwGeAc9BH)eCTx?_VhTU(Gh;!4!JK=_
z`lCm=)gl%BAK0P${_qQLs(J1Kp7dWXPAd4}3GK%}mK{KQXui9Vf-V~+ppTpz=XL%H
z$4lmLh4vYLf@om=0ZUaTEgrTAVFW@?^x_7Fft^FBEtKL5`#J!-?7L6b8QIS1%1u{8
zB|!GP+YRf?_+P5jgYo^QO{keTDjf1SKE162HAxU5@2fxb(+ZS*O@7SJuCz?6*W5TB
z6)7wezKV1I^jr72|0)#MiV@M4fPWtcFJFCxRcf|1m+OMyopL!_qc7iNvP3K;sBb0h
zz8x)=VqgKR3INKct{43DW>3vG*h`)lcHZN3hk&1H<tR93Ci9xfRB40*vH#>t!en?x
z4gOK`Y1Z&tl#3@b@A~g&VbX))b-_oP3lnsfebup~o`p)^9kgSKR<-&CBnY;In7YN$
z1^;ts!XM`^t{upLi0QNC<spaA<2D{&l7auyaEWf%5j|j^up<`IZJLkRrdVWdhMy`m
zG%~*zAN2<`;j!;riRh;#6?`#zHKvB*MfpCrZ>GWelffaz2`<p825slLgB-TR>>L0p
z7Xj7{t>4*^WZQ(;@(~z)hbK>%j!J8OEWke79JxagYdex1i0#|9!=9ZO)|$k%0)!UP
z@bBL-RB!8tjGRVbUtvM;QEZPlr`fqp6~FUU(dDBhGzD1YpSq|0pBtZ3^G~!yJpPq>
z!nLk!$pycqZlm}M<l9B&H<|#&MI}>jtg!e{nGA>X1i|CWhA_5DNxtS8X9Htnd}pbS
z%~Y4!;YMTWG1f}|OsMN}_W1L_%KS{`!Lzy#kh$~lVaFxjcrbe}7IE}%nsD?YLb*fA
z-kLAX2z0b>Db~@#%)3&1vDvHlCxSW4^<~}9FTjt6*+}O4mkI_Kd4=|t)!leK_)-F_
zg_E#1>GA9-W;>w$qH9%7)8IKgx5j=sY{*txR)8y{${sHRSQ+)hfCb9!Q<gJV6>734
z)B<^F;fc}JH|+J-KLnzr;oHi{VtRw~OkW5J_!Yi6nMzH{2H(xULVPhLl2v_&Vt*a0
zWIJp)0CLS1{1TaJvPcHGys+RjG5G#yeoy%u$2d%5iF&Y^37%(woYf<X?Nv?}No8$4
zl7Rorfs$<t`oj1wO!G-J{y*3!*k%~kBFdDrJs~r+CtFzZpGRqdaqh}>-Kv*kzVt}k
zRF<O*`IA{C<r_IIh85%5vQvyiYNbS5u=%>|Jc7}|l%~_|fd#S4gpC3DzK1y1ZL8<l
zn%^ams3kg2iOLOeS#SmV04?eelw0_Tsg9x&>9byOxn=*(O&SW^DuXt)L4gv%9Ol`7
zl>k6MW}vsS;X<#auAH@06wx7l=G!4dSN49OZ3D4zpYQuR<}uX|%It2=YNtr$`z$x`
zl4GlNlYtWQ7j+>PF!Fp)CXO<NQ6@*%jrVA?1M9%JrLu~lS#dv&ly`mL2YY}T&o`+3
zz1>330cNOu@o1*eiFbxC)yE$Dk($e04;<SMC$28SZ$I+QM#eO6vp9zZ5aHi$P|L0E
zck#@%N3$&Pq7|~tsDG?83;Ll~<s(;!p@ET_JeJSs14S(IjWY@@AV)sjv*Q0jn4H->
zMZDKQQEQKEpxp*Pcg^{#{;{tZ+58=`)WZiw<4r5ig7N(GTXG+)Z|~{tbdh`MV=fD=
zP}s8*^*PxG=;p*PKdB~@>+>CU;Zv&mhoJ$-H)PWg&{gC7{ujAyM`5dQL;G4Go|^1&
zvX7VgHJJ;&*wHzU5TjR9!E6ZH5BJM6s(e^aV(f?Q0bsWia+RD%X|K5l!WJqkRV?sJ
z!NHl6c<dN&{JjA~9vlkOf=n=W7k$F_bN>*}H2s?z5<?*K*eMpoB+s7!GaGRAyAwDS
z*gO4>dGO$i(Dcq8n_N~aQQ=|A!fm7ds?nPY>m1^IuPqVf43O)>0`T7U`38u+Vg4))
z&yYsi2Lrds*xfY)c!C`-)=VUkO^|ME4(s_@u7+k>vYw2*n2#qXX#{&8gB`v_T`Wps
zV#w)e(_AK6qG+Kbcn!-V;Lwf1c&SRpz%~^FZlE=2LSVqSHRKjN<LzI4muMDNUhspk
z#rh?$;{%k1opTM~kUmF&V)k>(op>v)G6P=c&kq7Sfg?;=FM65#-SI*PHMRwPoJTg3
z6OONoD&yh3d+7OZw1=|bI>lz`X?;|PiLNN)vwBZ>3xSn^>ii*66U-ycH0|1RRF-9j
z@6y{18r(!k_4-dpZDvBpdw>s1jXoy|k@fAI&O~Yyug*IYOVl;!?nmkkTbq8szx=$e
zIWu9vuH-fBLF2oXJEKJKgLodeLr7f+d0;rZ#25unyTK=9U!frntox`efV>cRP=kam
z7G@ZP_vFg#v@4wzb)`<%_^j?UWq}L<ygA1=k;W(Wt6__;XSv@S_7Z>faMcE1K8xG>
zGqMzHRW==UEBV(=#HTAw)|<NE$$mjEcURY1|M)>bVBH&o);Myk3TOTm_x#2{2VAnS
zm{6S&@FZ>&H{~;R0g9*6QWHC!1g(;I?T^ELT!xl%AUk1mqk=Y46C;&f!!zv{BDnt0
zK)AD;ob)hSm#AVSbVes9{>C5)N!XdBMD)V*+)QSbO=?fTc|7@kUvX9R(s;=R4hWMi
zlR4PJy_36&r7ozNmY2U$rZ6R}eaQT9Vb`p`|7_TdoJ%%3G0HjDZ>D~)l5D;A7tj$z
zIL})Ks5h6I`7OX^$%Vn&r2xHj$)kO>iI&{!6R0B8rHQ~GGvqw%D<<-QxJZt3F;L_v
zwW{{L%o3sbUFLCr){*{EQf2$q&(QPaE@v~o6IwDL`Nr*(IFmKZ=Xds4s?i$tGXjQa
zw~dUmLB8WH98{*;NlxpV#;Y<1D*59(!%uMKpW%=Go8;%VoVxA*dPZ<Z<VbB0|3<%1
z5uf|B`X8TtI7by&n(a5b{RWo7s^Ivb5q&0jI#=4(oCOyvqOgT0jq^&J=*#LWKXY(|
zGS`>>R!*fnnbBDB_+39*c6InxsSK?V;K`E^-FccO-?meh?W63@QdaU+bcKRPsTA%7
zLg7|-XX0dfn`6MO@CX~laBgv7!Gn=2O7Ek`@SG(vrOBG?Dks&(BxxYA3I+Bn*qARH
zngS=sQoum|;o9;e1PV(QtLZw6vLSxiUf96&7Ziw9dY9NB4&*-?RsZU*hs#ijKh<~m
z2T5^EGBu9EM6J;sMz*8@knm;xB=XHm<d1AJwK|1ihj7%aJIXqbX*KweIP?pY1jMF|
z3V<77AmW~>S)>#~8!^$;8Zy!7YDts|Z~WmXz{3M-Oxw^J-dRSzQXz#VA?oWU+t_bt
zjfg~I;Bse!OEGHC{lgntGVOJSto!=XO)y%Xv{omz#}>f}U2!A{<?C;c#CUdQ59m=<
zWhKen&-ys}a4C^w%jv>@g#POPc|})0`ofj;z5Es9`A0ut)wuyc&-OHQd)UMNEt`(x
zt%|XV%A(Ao8SX`L0_*z+kw)6DRrcXjzOps}^qL#}oe!ABvhJv*#)5yH>dVY)h>6Ue
z7p3Vz=}}CUYE3-w(BHna{ZxUi(u&P%e1!O(Ja=&S>JM?2>dNSn0+co_jA-Pjvuvk7
zjMB)!m=4}7%EJ&p7)iX9;}Gjl)qeWB5N{UV$P7Ksl&fU~q)3_G#ODC54}ItUTGnP0
zgoGluuR+DZvVNsGax}qJK@7~5h#}?9gvR6T(fG+g&s<GN)T1@d03zAB5SXqHJq(fc
z+bmyt=&_spfN%QvEUG%VF%Tm!M4Q?ksXW`t-qesQ+HXGg{^j_`s}Fi(B>|zKH|dUu
zxSuHB%`IQ(x`vt(eR>1&S)hYeX`@kjVfwbyKpv>6I9K`kr!^=gv3JdcZpgwqs31!u
z5Ynz&cq4T#a%EA~oANtJ2i!)+TTZM=85s#A%PSQltq`9Ui#p9p_+ruMY+&#W?a)g4
zx^#vzN1U5b&SN71lH?yKli#Fo?4y>&De(zvO5=fl5aVDt3U31xi;y%FVO2P~HOtiz
zQFgZDp9KS;m`d4tc5&U$f5~wH%E-0nk^-uX-G}QNDua&7z(s21=+pU{5y3y51`2#j
z3$HU5HsClVCX%kNJB5_3Wv8GXmOsC<&M*9Wb&7pv;f<o-PMOnm`U>vW3TXZ??R{l?
zvz;$8H@faDNm*Ed;1Tdu1avRN-n8+?bP-5RB42$6CvJjew{@X`!2ZwBFG3k%$nNaM
z>siv6RP-oDqEj#0E54JS75nX|j-q0JZ2iD9SBL5R`4Eg$KO)jOfTQ3JuMh8~JC*UQ
z#>`d~gE7o8Gud$bW+xy0w98lIE2*<LqGe_ma0N38Ws@P7ECF?aT3j%KPz4m~TzZMr
z`K|O)9j9}@5D4mX$Q)}W?~!G_C|S#Xf&Z0RmxOh0T4bI%U|&mp9YpJ1Qh65{gltyn
zwkVKA?0aecx8am>@w*cJFK`!?7w0?V3Z+l6FiQbvE8T>)Iu**5XJuB11>TYvFqqJP
z<et!ddDszKH97KVp$B;+T?m?Mm+wBX65<#`c8xA2Al=2Sq??clPR1zFOEVb_!+1=~
zQY&C4>c|XEGb!VzT1*&3m%ucvV8uq#g@C7Yst;@KhM?ZbaqhezUbE>L$9w+)BR%!#
zDSZ;!;kH8uRaLUn4~<R-IUU~!HZl#`G6$H2ZeTL5U%5UYa<9*<rfQ1d%iHIJ(F47O
zSm`_=4&z>On{VoDD8s(gO0pz81Eil0RITS_d3IyB9s7w!95!rylPaoc52NuEJPlb(
zww57|ScIE9oDcAiDq)r#H;qWJCGCqC*$M-*$W<;bs3U~}Ier{ouMD-}CJZaslOi_q
z6z$?;4xgZxzq^A{(=KCotyts267kJNMdvm<4j7vZ^?r)Xj#~>q+q3!CRT_C>*h72R
zk8dVes!f9T7XyBV);n~)d=1qpyL=^3F(90vVmS-7bRa1jZ@Zi1O7FhH`a91ONSNs^
z=x0y_YZ`=2gl&z^fx7$i>#5GC&ug_CaMmY*qu0IH3rhpn$g+WPy_Jz5il5(SBbYfP
zQun^^>|yj6`@m@Wx@M4%{urRkfKy99^J=2rXknY7n2Wi#rj*wYGFw>ECDs!u%177s
zi9PoJL#whD#-ydIO`=#Rc`zT4T%LDw<J+?vL_-|XOr_`<N{-nTPQaU(oV8Y!iIdy;
z8%3RPsrdVo&-3&jK(WuG?R4XCc5u28+o5@d*}?anweR(jBJIzwGdP~(1@J#5AwI?q
zx^Q)7E0p82g!ZB#qgBeQq<EA&e8vu7YasZb1=I9up>eW0x&Ek=CZSO~jz!6XH`<%*
zBz1Ng9fa`^$q9qnXy5P2M;X;gitv1Y^DE()rd>X@d>Z&9wg1WUToH#C7mRBB(&6>y
zvpr@~idxu2ova8T)<W$w^_6~L$gb`_uUvmgFs;8mJlesLF{F}xO0&YsfW7eF8`*ch
zMcA6h>q+3XGOpNk<#>56hG#+4`J^)1R+8x4Z~Tnw%*zq#M_}+<IRS4jF9wpxY}{Jx
zH&*aqT<OAQ1TcH2Ww+5(*Z<^8tsuh@GE9zawT|49z90-xyUGBAzZY0)-nP&T%xn9)
ze~6*v_h4h?uZ*Zp!Q}vOp|af}KCkdUShx5v70DYPc1HSs@=3N){zx{7&x#u(gjoX}
z!O(BcOZ(B_^Ga}0z?=BFe{ptax=FxSk-A~EkkRi8#T&+Vfj8n>cm}vw35IW9=yYJ7
ziA+*hBg8g9Z<GvDEzzho@yhUFI&sf1yVIT)k#(GX^Gx$Ws6KsXYzLC#80?N`vP|)G
zv*));<NYSrZ^-Df>>NX~4<nI4pkl{HA~Wc6cU<i{MTI{7ggCR!tf%2EEdkLW#jq-y
znN7XTpF(bR(iRkaAtKK$$?FW9eV(SDf==%6RV)hifiV?#m0ke-k)AIn3rWNcxy{uk
zdg>W{C%KfBn>QwiEVMGiXa^-Z0EFpwcpAoHO7Ys)#7_oX0U)7kyxvq@RFMqZ#->L#
zyH|T}B*QXLE)|DLR!AlxE%{M!wB82=C32BWI1*9G<Y87v!Kd>&DVwmKCApHBapP%G
z+rVB?TNQKB=Q>2!(ZagqIy#P@5ScMvBeDajK)Gui11v2ky4@R=W5<2;P0sa-WKQF=
z<ftX%)qzMxDl#%S@<ZSqnL&^zqt|eBpww2G9VbT7pa>8BY5H*k{SySP^VrUgJTKtr
z$s$ghr_lR>>hB*yg$qAl;Zmp^{}*uY-hCb5yc~5}gegGhBS*Zz{T-{7iB-OmO?cEa
zVePNx;dZP~g$cwu__1+~kal!FY{%{e&<u*3+=cNn5-^8VhcrICE1TaUX%mzC8wn!(
zxZkLvfhgG(`}j>7;)p5K8glw(a+;;kaQkeCt_KL1^(G|GfP*Bu-Sb;)!#@cYpC_`7
zYDKn?8V)4{wkP_7fO1NCBs)HKJpKBdq(${;?rlRiH4^!WWa6)eO;s14qP;ENfcob>
zs~L#Lc6PE|Qk+6<xV3qgp3@eGo-^A~r4*SQBOKo9`0&quY)DK`-b2Ea;;IcZhoCrc
zm4d&u@iDOd5GwtK8w0Y@0lk(}b#3O{`sXJebseI*cSZhBQu#KJt9o_gy`dW$HwNGc
z;{bJ9((WXQ&1^WC<kX2{0`=Hg#+@muTK8KT3XgyU^mRVDt5(sqK>By{LYR;S@p4Yc
zh>pD?bbM6E)U|p>BY>mq(0-ATw8LYHKW<us(^qtrWF%A1<J^de9&oPlSNOSqnIyIK
zK@GgT`nrGG0F!i7sEuf-ll{PL7d=`di4vczU^=P~v5eg=$!1U;XoETNLYnuqj~G6T
zl7Q32+`6#rV+-6!kQ08__|>u+Mv**Vp|>cU@0)rFhYJah2uR598C3z}Gs*MPFa$o7
z(<?}Q+*;!iggN?X14`OT7Di_?!!3A|R5`Yiuq#Pmh!QSIIB}Qsk7ykTq-IDIKx|^l
z(1$Y_N7XAe8As0M2?9#}#TqqjP<s59g%^jLU^_m<wI~}s+O**@7&R8cfE`uK|KwBn
zk7)J%)~Fq)8G;A0@gq8Xk1K6hChaz3s|gWQ;hob|uQ*#CuVA~hbM3%R=b#8%SY(ry
zb+7ksXz0qKX3P)jaa`@KNn}t{YHZs7`e_1tPa1~R?J+YTy018-ueIwZn;KpG*cu+`
z+O$NH-XL3mJWBye20lrq3|wp=<~Z_OA6O~KhdUEU(2PfkJWv<5yn7H=XK5@T2iV@-
z`NSlAK7=!We4kBkrv?*N8PQbc&4V9iu+uiMzGHl16s%X`?r%U}xnlMc8Ol^SW1p#2
z+Z_%KV#JGt+15bHfI{0btqZ<@*0g$|GK&}Og<95v+>Or(wu#;u-~5r!x#)orl;588
zHk%~K#cG$;lKn!^^{i7B{rHI8tzvaVB*;yEF8=Zlyb|4I6P7ZLgZwcXolZB)&`;CQ
zw5%ZfYJcdO3YNAw$Tc%<B52ca8QKoR>sr;1eTJQ+1v%pdx0;_CQW2tlg}>JQIib@(
ztyIyTKjB!*Iw6wC(as0GjmETZ7CvYAuxr~a*iPJ|naZ0NdrYt()@ps|pxruGf9VG1
zILQFW1t$~`j&2!2#9zkfHx<qvdXP%XI^d$i!kmwO2hu+N&cS9tZ7wx3+K7I4y;%dn
z<I#04RA#59@`@9jd(V{Z?KE4O3|VM`Q49)WREhfMAeL^g(O-5cV!peS7}ZaBbf6RS
zjA(*J3<^mT4~ABFZM=9IMJztgQn`qiMZw1rFHp~l3B-hxzz77+p%*wJ&%goedv(@b
z=R18zEl${ET8}V}?sLgw<Mg@fu9Mf+#`n-k(Q`gLMa@!yhLL2FZ?Z7Ybu1jDCjINj
z45W3ssLzXgW~NeLeW|#rBwl72?USl0VX<lu1@;>ewdv|UuSkt*XKIUrn*eZ0or5tC
zyP@H`KbQ@ij_N);o3E4Dv2;wADS{~O6!qB-D8%)rp6f`TKj7~dTH(Z}@q%r8-t`PO
zfh2K-{%&)88ElR9(Rk8UwmlR-bkAo&(>^eJpI9uIC5JDriAO*1QX$xeA;><bFeyE^
z6olWi1t4b#-c&t;oJVksrJ3=)Lajj*<3Oym*7wWdo6F2AhB+=F@TjE8UH|V9ku3@E
zJ4+-nux)rflFMfL5;%uAf?zEp`ke4rbM$A#mwQto60Lyq(9LqNr2sI3o(<~RfJVW%
zEOoE@GDCX{zUFmrd_D>KBfmJQsL=_Uj2r#+V$j&ewfY`FSIiu4`aJH=tbAcIUp7E(
zap3w0sUBM(q0KvqNxS)&R$-}mh=XgH7IW8MFDl$bHqGkY{ev5s_&V=SxXD*&&<#I{
zCJZLZ@Htg9?<e>Kx>@fbNk2BQa@h_{jRD{r-^P6VdiX+IOA6-2nKUNm;jG@8*B+vG
z$z<B6FA)%Suh*3E6c8YJ5IwWDD%602p#@|9+l&_ZXsl}nEIU=FZ#NXi*j+;IshMdo
zGin_jqT?5TIeN9fjuFYqMr}UkEpOa4_R<_wZ0H0#gSM{R%9-78;pU`}P-~zjExU*2
zib9epRC0@JYtSZ|(&WuSYxXOKryxiw#F#cbqEd`<5JECUgMoDyuJdEJGrvr`+Q+2Z
ztmXr8VbRx6Oj(-UZRWKw4LJxr)3AHLu)GG8ggqPlzqJ5yJyY3wkwHXtUog3biDl(}
zgd2;Y_X)Qr;CV+;E!hL9dsc#&erbLuL&wAvW(^`m*BY`rqpouYzz#B-SzJ87*D?Oc
zShdPs&B*o?B8gLSJKA!d?s6{K;K<$cA8VB>DKY$g2@1&ut>UuKX6z}C()ra+m%E9`
z%#N2bc;P3X5%BZ|Ubx(o@3}Ysde+KnKRkb?VR-)ADFx#&fqF6cgcARXB%`OqiEy1i
z=JAnw15h!1Q}(gMx_g;4D$3v9aDJMhl{rO?W`3H1M{nWnS(c(gH3UjcE|9l<;W$xQ
z18Qp>Jd>=i^*JYRnE6%*b!(}IMt$-PpT{$ANrkO#t!U3WoMER%JeKvUadF=|?P9+q
zJ2923ZzMU!pUy>oTFk1togyPS7U<-tHCh{S60Fk6F#xUCYi$)awTt&e=R!W~46dpP
zI_nPf4!!-=ku-EesHH7&y=ixtQtCeTXTA>Bg~mz~osx!q)wIDb#DX?V+j|vi9Cy^(
zK$AYc`^dF;tE|BF{4nv~S+HfEWTB%|eIQ5geYzBy=6iRC6#6pS<L^$_ekA-W>6<Cg
z#T}<LCTn{^Y=nu_Ps#qT7BTY^oeU=FL8ezbYX0vaAI(k?tjmFzur5qmx-$GDVVa(Y
zBkzw)Z49-bpzZ~ClOx-XEbI>1E!cgGY`zMii*1xEBFj(6e7+fv+L)5XtQTW8*(f7T
zi$r6}?z~aXETv|?9~7=!vJ>-I&pOP%#vWbo^-C-1w?OAE*mTXGE+)M<72>QCaQAsx
zG|O!Q2-V@$SEQXaW=U+$p<qF!Kh#(e2%FEj9Clh)FB#d*U*Vj??RERgbaJ#k$P;Te
zBE=ydQRJK^P?`G*hywn=+Ez_;6vOhAarhb0@5u}7|JA}B<ya=)!%db!VZeUBEBuUh
zLT8UzSfP!7c%+ngHtagE1)mVIP)HaV#hU{fZl@aij*ztcYEa8PQJq#lwlh|F32M7Y
zt%E%Vu64p>RL7SKB`*cT;C{T*fU3<WTC6zgS(5F#+**!6$*occ1Cbve`vKQbAp7Mz
zld*;Nl~*&r+II_x)ttyRIt)n8vp0gW?1#Sng5KNh$Ico^(LqL5zpcv(SRc^zD+TSq
zI910dc<dG`pI4gz2sR@vzbYXOD9S9i?I?cIkX#Vk#j)esQi;*hWOu8JeH(6s_M7Vg
zsP*s_&gfb&T}a*K)2123StX5Yf+M2A?@={`Csu?Exmxb~cs33gL;~>lrrvJ1MdaK=
z<MB0my}rx-@ni<%-!ZuHgZ3x;DXFLumfc(J?tD+{0}%t<8obTg@W!Z9XkBgcr*wu7
z)LE^AN^41uAQH#$e|qF+Qk*G>?OOvzWR5jZf57^5?Mom^2|V<KN|nhR&g!+^133QV
zL_Ug9E!uKw0-rlJq-t_9A(3~6Tw6}>uvo5w_`ys5_>GUV!KA^u@A@`y{rN$!OYd!G
z86q$WP}R@OLKuRO^Y9&xR?18Wgp2V?1|CHh5@Iiokm8?EI`l*`W&VchMuvS3DF+jI
z`nq|pgO82h@%|S-O3CvFMUC2xX6tXgNsOL=&52*CvuqrLEC7ar*kh1xc&OvROs)-r
z!RMW9LxW-Cb#hI0<pBPiQNv4r?0#G0P`J5`x$Q-TKat`Vn_cuzy;*6~Z|@}uQIAih
zJNy!;J|vGN(C_2ABZ-5*gPi}!&4t0fewbVf_0wolku%g%S^l~dYSN^%zMeSm-qGL#
zg)WSL*&z&mmDTe`Mk6=hLc~dzLAj3lsQmlaCIF31XNY;|{<3~%vo&Rwld*}ZXX9vU
z4<l6+Tc6U}@pKdpOkRpQOO7niz_WcVOMxDnwNJQ)*IE)^Z->g#BD9a?PtDdHy~$fK
ziW;$Wqr-8~j0fDKiq?j=^Dxrv$vZ~qbLIp{@9f$BBSu(DS_!HX1oy_gMwPWb>Y3V*
zwFPoN&eF08Rm8d?hJzMBFz7k-R@C*-XuvVIGUsKu%J1vq)SIf*tEi|vwjPEf*>#83
zXO@m#Bt0}heR!u~{ym}AWVQ0wd1~7eNvE@ps*WUJeUc~llV`!?=^Lsqa=heQkTTuj
zBS>K{?d-J&E`0S{XG=#&<hqj$cE`$&Rc-}2O5>~E;B`(`_avIa`p4#8Vv_L!Y!s*8
z!D%mSFYKFTf9hbFNcwpU8wC73e_PRaQ%DOVTi*-j%fEP}erw+W!}duwB8XURGQ`ig
zjTO9=2hYPmGQZlAu6wwIL(E%DLxQ8Er&6nLn3Bws?V(bF8~RgE#?zp;%aP9wO9zU<
zf=G#(2Q<_J(|nLZJ@kua(6|m>`|skOjWb%z=g+yMDLfGH+X7>F>Kn({5Nt|&xqxGg
z5_7}ZHY*YxzqNxWv);4bBh=Oa6S1tvoneo+$;t^=ugDf3p@o3OZ1%Ng7^Wjzih7Nx
zsS@pI!VD;LD2}$bye%K~9^4~ulQZNWaNWi~>Wyn4*{k(?zbFjpLLbCSDUmp8b%SsT
zx#d~yv1wOE94kbXMs0S?^7?cRwIgkIDiyatz0~NdFbeB`dxmI8$$m0mG(9XQfS^C%
zbYXiR?Kk6p`a(Z_L$}#o!u2@}+ApzD!`kE8C;FI`35=<p3q?Td@eSWw|A}4aIQmkY
zGmxKMll(fcYR2;+5?9vpY>;VqL=xx=bzQNe*znO%Gc$vR+rX8eP^8R~Wa%r~BDBhM
zu7|%m#}oh;d_ettde=sOBH!{Fz8BHj#DsC!<!$SyMJ#$kK3j%*Kb%HbYpeomz{%eq
z;*GPdz2EeV+F%6=;juB*9iD$n_{cZXo62brz{RvPv{Xc%J{_mIrOP2#kb_TFyXU>n
z+v@$q+XZ6j=x{E>4LVS>RakdLXEj+xuJ&r9Az|5oYGGpC#%ti})#%gy)P(x{p*x6s
zkktcyaBbH1+ogUG)gvNx+8hxTtG#r7ak&>jxPg*K_{%~X1mgoa>|fhn!ed+UPp!xl
zaRTxmK0boM!#M)|UB@28#Z5zC4Z5X4g0f>P?^KgD{MqmQICaqU7;3RuenuBAffpua
zip5*i#gmmrRm9W&xTu9jqNoH=%{ymx9zq-1?`TVZpN{WUJ+Ad8A*f^J93Qg0dnFH=
z^oP|YW)0yrDf>gQSLIr%mbG-B&QbdhR72G7YcO?wF?2&|YkffxFhEGxyZ`3dK-J4J
zVMk8BDVo+SgpQuTp3VcF%sazHDkgM;;yY#gcqJ_}I~R)_zYLXfi5e^j;ZJJv@qD>O
z@3Un;9e^LC6RI_-O_e$U1Fy76)aO+1A@LBxZs{yX6h06m>oOc{v)^s=;>dWzFSKcg
zoT|YklVCO%h%_SfzG**OJD)~1t|~4*E(ah-Pte}sPXf7W3`d35;w~zG+w7!HPW7zN
znyNoDWOfZ39hh`ln$d(KOnyZ;N0giZ`J_fYz%MIP{NZqT6h7{42}XX>%O#MJt*C9B
zR+*x?GTsCHI?GdOmi?Ia58Wquo$s5&Ku?G)AWsOFVsg-#UFa$e3WV-P8Igar4yY_7
z1;p~ro+C;`tOuyRj5w{dJw)+{4IIGw{DBT=LO=x<-XY8{Rt}v6UP3Fj&`Dr3i)@%|
zlX|vUSh@m2ow@cu`@n%!kaT=j`LdmG_@lo=4pMSbc(^Jlc7(XNwdlrm+P1NF#sc84
zlR7h5`w?T@JTez9Kk;9mJi^%N$gr<R(Zf~22S;BSrB0a;bt$cv$|tl=neAb*Vu4YY
zPHsz^6~@hq3KQlwW(U>P=Gj&rK2(OUUmvlZbEs7*G0@A*=`kY07eY%K^pOvo`_LK;
z(i;m&vzzNnA*TlWJEjVK8HLk0xUa-+)_!=|JB)2n;T<eBM9U^?)SU<ubhci`M-am$
zII_Mot`X12J-yxbkLZ@eUhnDko(6Y;Fe{`e$(4uxI|z1}@J{f`{FcPCseaUD)&X9U
z^MPKZII*U3zg5*}mo}0b%F(FfmmL*Dx0H*-eoFu{2Qg^FxvT0#ch1xHV?Y>11-Zn^
zY(Yr~XS>Bj>A4k^;pOdzzAuIbs=l%+^CGj|=1s%NBWT%b#n+B*4hubD{P#baou8Pl
zy%6f)H?h9Vxl7yW0SZq|J8LWIjc36$2`;*HQlF_F?zoy5c8!!RPr7!k*NbjxtD)4J
z)HdhsEcxv^?<U>Q2YWm>vx3<2u5sp%eq1v2*E&@`xj01Ui)R;T`g7txdNKY-uMlq<
zK>i_OQJa|uPb?~8R^HEKTf#IumYihg$BeU%FM+uFcMz<6oUfwziQ10KaGiBK3HdiC
zKDPk33G2=N@ct1h?c^1bll5;uZmWt8m8XtRboFye@&OhE#2*N3d^k(v%##BS{;db%
z;)NJx|6Z4Y|616nE1tdD1zu7}pM)JSM$PQAXnh)pvrb7m<vCLSP)}#9o8Mq=A98#D
z7H1n)XlJmrSHihrvEz~M-0OZ64Y$l}sdieqh)onFk%1`b&+zBE{FD5LUT;8_*RQ4&
z^AOra&2m+Mcp*D@trGaa7oiuDonSBzxzx4#6mgYhf@8Qc>Db8gUn=s|E5~}I@)eo<
zv5KdF?03ubc4d(^%5`i31m8$<ng1&Z!9rd9ZF>qu;e&H;aJBZ9mCz{T-d!$w^GL2-
z6T?2@C2_~@D4kLR#5LF%3E;Qo`R{E3Vq(#^HH~qH?})ecDfv$ahR@P=PWEO>&_2pE
zaYb#e?I$um?Kk?cMMg*yD*`l+CC8XvEVRB1$PH$CQ`%HZUckIg1*(ajiPgD52*aw*
zWt+OaH~&Dy#|1{6?B|}>uh84PB{W<m&RpwAp5)}p$p7&z)o^r>ww9^>(Rvo=z0OcE
z6+mWrJRgVhFZI!~FFklnq;Oip{N*a%lR0=&dJlY0QfPwg?Uvuxw~iV66kWTKI|vCm
zse`6x)$-eFbKZuYkO-AYjFOqTMI_qR6g@-}uk=nZEffEvrEDstIaFEaFCJ4J&aX|>
z<yc_%@o<~7(EItl*F8Wo4U~P$Y@vIF<{;Z4Lp{v8rW;-ol`F<T(J<%6Wplmu7S@O3
z*8TleUBYxNg$uk(f<JQ5&QNT<F-XU+`iSn(f7-u@!0F+=V*icvJ=n9Q9@+x(^0A%U
zAr*Yv!2h`|H&JbTx;LL-{6#+5NR&>?r6cf;NjA9-t6=hW;Um8@T%?vEBB^acYYM!u
z1#W5oZkXt1<D+)tuR}I<J>Fl7qoz$!F4Q}IhMttQ!;KeynM1aT)r`jrs2}lum{tgq
z8HiGG>|VVS&*x$>(kpDjxw_j+4c(d>)NJM@#mXg2<m87X|HQT`;*I2)i+QZwf#`Ej
z?Mh=|l$vx5ysW(D>;@HThJuak;nv~V-EdQYUc)djHT=2f>HQ-2u*1CXmjy54LN5^R
zxU*EtNN;itHww78SjmALR|Au^@`v4%i`}JmK`2sDPF%bl`ai~sS*QH%d6vZQMP#bw
zKuZH$p>Zgl)8A+h0kkERp`~4dzCQJ2f<~WB_4D58>kiqNm3(Nwr*WA-sJ0hZtRlEG
z)wCbv+IaIhTx7XA>$+KP&Fa_)KB`dqiYhsl>&@>q^e(eJam`#`bC<6BDzw6YCFy_2
zZBs4qL~(W3kR{^R!`$*G7R^9TELc#ZT@F0oz*^RMmtzwe>-+r^wZ+%sON_;wp+6Q}
z6D%oMj+{&*8~u0!SH8g9sdQDput`gq^IX?54uY29XRixsa~ISCxNZ_s1=nw<fib<)
znvRl?HG#1e8^XbAvg=~#=wqS=M*wl_1UBkZcF!hehhBH%kEs&e?979j0UqW<h0-X`
z`g2B$j1fYaM?-H3_KYsB*$mXXA=}HlYra*95y0g>I2Nn7W8rL3Z^$wu2%~=ABuY0U
zNgMU?$m}=IV@lI)_~lB!>))$Ywhs;4QZK7Kof~{eLr#vZ_@BjYe86-M>d{hd$!grh
zc!P@VF**KjC6l*?8&lqC?Q$4s524uDRx|I+H8FO^>%wcJ?SnSMa0|t&pRAMS&Sits
z#EemtWU^cOJoV1|a{Zz(;EESlsusTyB@tCu)Z(7wj?8x%cnKK>#oK9ctO?0UJzx8}
zp<Kv7PM#wD-w#-rK{N3ih~z_f)9Tr$zejryDJUs^rqUTNU(><Qu*f+?a^e}%5wJX)
z1mF9dQ{Qyp#(T9;ZzUoL1T;I}(a!|2*0T1b%waD;Sg5JLzpdkI@O4}>^t!bTJxs;^
zQDt6zOv;+CqB`E_;l0RiL7VidF4pROdjyzMgI%WRNO5xVrt!q(U7xM%z@QGQ#*J<f
z@^+jJ(IR>>HLKJ7QJVPE&zW5z0L5S3gvpNYNyU$Y?*SVo=5jmRlhF2QeS-;fSz003
z$n#CCksR*4&Lk)Y*M2kYAxfv}62BH1t2oT7k>oz9k6Ar$=-_Wog4XvV9^xXyrCe1K
zq{Iu=->sg)dhcQ1+p|(grX1&4XgRt5h?6NwGPSyZmIF%=w7EBjoED_h8eWKB6VHSA
zOM(*8N-DGvb(Rh*dqaOR@bvBgQClvp)untu>42zumxKxt<QUhxlXnYX3;o|1vdvq2
zT}?S_a`HKW{}kIq{)w_7I+`6)6!t{!z_kkKH~zHf#LT!T1U1eAMs-u_qA`m3;7{?;
z5U1S5N>?BX-OwSi!7=mNrBq(n^h&DArB=_t`|;G@xZCVKL?yYszkRX@`W*z>oLw}s
z1)q7g^&EAfvq28HJ?r~hXjb5xKIXGrfFJqnSMb)znIb+3OLI!X`WSHik9utGOi3>i
zRfXGr>w-()D77iG-BA_Em+CgzFz-x6NwKxzDGt9|`f2CY4;HLMO;)fhp?<g=*BCi%
z0t%S_t{ncb+WUUhJk%V7l4;Imv)>uERHB$W{I#m_8+hO|6*YFQj;bH{=C=Rc{4}-D
z57B4l5BpFfyOYEogFs*1d=EaonRLlw9gBJ7^~G7FNDZW7i4ZoTrO~eA2(!g$O*foE
z4=3U={x;2Vs`!|^{f7Yx6KunIzV|Q32p`Q7hGUnNAIvq=ne)$f3-QiJgfdw^7*7go
zBlChOo{cbEAN@nn2&e6IU{1^VkJIeVW~NC$<hM@Ey0$DEdXF^UXh-Bb(kTe|GQR5e
zTN!YcC-f(<)eZQ9!y)ex@&qOZFDw-v*jjPV5en;Bc4j4QPu!S?A|uhb!?;}6$8tPq
z=cx1Sjq?_EM^pM`y>e|ZVWxSV?O=-`Y>u1krb1Le@h=A%WOLZ)2^aqa4m}VxExOO6
zu@pgc3F_x^a4z6-I(Ij{ECa4B1*7}{0X<$ug;Iv5q?)%GyJV}$s$vBBZ05}vEHa*9
z6Q2Y#RC0<QhJz#nLfV+JT;X1C4hcG{G&?U0e@h+>IY(bQ+JcpW<=K$dV|L7P56s6q
zDcgLv0iU789IJy!ylr^6R7)Y)ri61UhS`2auyDL3f_0g+s=8g|rrA@7&0HJ(?CwT*
z3t(rsv9kI?i;|#p*k;|6)|Wf!`TV0Qn$hv<#!RuxThg$g-?-WM+O&4ObV;5tqdy~M
z+jDUYWw>gXD$-Ze=-4`Qg@x5CcbvA=wJCI1FpJ|DmoZkqzZKph<w$I<+|@9=-(EI+
z#lm6tVn1?92W)@1{@I_xRW3N8xaXP%_iQ@h7qv(7Sd!h=G7jF0SjZ6AYOZqxKCT(o
zQqmj~n|$DD%U|F5;t8!?m9~~xd@VB<E}LDT<)iy<2vJE}$__ZL{e(ixObyY3)2Qz5
zHkIX<<!b;PRlx1g1GU1sUr&UP3CoUywwi#g(g}8u>y^OTKwMq(xC}gja`dZ-Y&iL^
zhC=&*T9TD6LhgH|*vxN{U`?VsNW2iBJK|Vo6fyWSfQj*8r`4*0<<(nr7H<7HUeFa4
zD^1fd;)HqbT#Bs2x*NM>yMb*s?KQY&!>Gu|q<F9AxOVZc!;<g1!&H`ygFogISFQQf
zDYH<{xengp3McSgih1L<>n#ZfJptSlsUR#aP7idPSEqUK5B6s|t+x^aM1EL4W8L=b
z`w=Z8FCy_(W%ImW_CD6Lq#yBG`lmf}RugPE8Xj3Yjsq<MZBs#;=Ac`C$w~hJsvOE#
zgR>{iHSBK@Lz>|ENTY8UCr~AmUQi}sM?yC|f`4#aV+Y>&48xAQmDj>Z%<i_frvx(W
zPR?F6!aQKu!c4aKbCOa{PTO3cBqwq~afpxnJ)B?uv2}6v#%C~Ng|t2F#PM9@4n!32
z?o_z7|CoqdNWGu(sSH}5HI#JTSderik({$X9?m1dBB*^R^hD9-rY()g4fnxVi6mFb
ze4oB0jKL2o`YPSwvsDv_aB96oeuLl2#DH<==rhM;O$fC#=3%0xFnq{X^{wMq_RDvB
zFJ|Is@J0?5IEZ^&l;D<cf@Fvi6LB_~`$93q-kd+z!^6W}-2X*&Qj*IkzNsd~#PA!)
zrk5Wn)nMJ0$8^)V<LCyt9`dat)TBfZFvywsmdz%nKg#kwC48)*z#|MjNn=CrTyJjA
z14C(#+lu7Y4K%tmPFoM{xSl^Boci$Hz4g{vT^cw}SQrho*m2We=ezYlZqd7g=ymdL
zv*3{=gMFh&gWv4ON3E78_k?)rtG$EZ|C>4QwRQ3Ila`>0_Dn#5{)G%#y{KR%DqM=p
zdap$s9i485O(l%8Wpvbn;M7fKp6XnS{3Bw0a{&<Nc)vq6^yv&IHuuB*hn9Q8o={)O
z^$7ii-6w}}AP7R|ut}kqnRiGN-5N^cEKSV4j~$PVtS{6CIG{<<f*pC5nChB+Vkd#R
zQ4_$$AU5FdU2EB=&>Oe|2f2+z(DP(GE1P~k1@N9iO^5{t8>mg-us8u&O~RgHa>;}C
zxZdaVdf3r5*T}w>nr_?Y4^W{Wt5eDC^T9DkO_bUgSqv6pqFuhAG=WCano9q9tVKD#
zGF}=E-I<@MXy(QR4aP-={yYNveN8i8IWF9Y!P~r#t>0R7Q_Jya<PAbn)Yp(7H+vs;
zCOr9|yVjXatw37w4@}XdkNpX&72@)*j(vjkXkcQ({YTQ{YChAiBMSK9g!0fYuw9mR
znB_a=l0>x>c6@unS=!@uDkN|@kp7{xUa>=E$9Q~q4gHwaSlQ8s7{A>O7TI#c*K498
zXS*$7LU3YJ<K^U8=+l&)%^@h(H<y*xHkn&(wA%r=m_sQ#-}x*QggULhD9?Vy(}CuL
z*4fXo)F)MG5x0Mw4ggS$HaXl0DbIH6HcoFq=zw(z{eK$P)P1vdgy&`|Tbhz)f5Ke2
zUI78;`LD~>cIW;hgqv+Q{ve6~#c^v{4fJ$SPxv}tdKci}GTz!N>@;+mfgV&py8DDB
z5bDA0J_HFmJm|<7Ir}2A?}i7#Qv#WDS@wiu2Uau6bTsQIhn?%Nr~v{ovJdZ+uQEk@
z!x`>1vbrr~3AR#%_5lEcytdQ5uaqk9WC&O7)=l$8URBLlvA?1KsPkAP{btZOFk6ve
zTBHBdzm(kEM0eCB3M<*u-uhvV9_u6%U9EJ(Iw604x2j7pIU+w<-%h4(OCxCt5OTY+
zO=;<JAC$jAX+$!Plr-z$%lE%)*k0BPGjXrI7c?vfD77(}Xh#!236^ZWW7Uf3hh#5_
zHnOviFE5@&ul9@(DE6It8FJ!k0i|9E5FgsDxBE-=ev{Uykxb(n5UX+Qw}5Hgck_z^
z0ET}yuqkl=r3L0Ts16Ih#(7rgjQ(l(4<@w@*Eg)d!L3a^aPTSjb!)(Jv^E~$>w4Z3
z(tFG@HuXauTv%2_?5Io3n0@PkGBDw-Np<W~{DV0;>OT-DUMZmfeQz-;w4!5BAv`qn
zqyG#EyeG{8I~@EPxc~9l$1qa1)DJ%6jogRpL)-}_+&$as9K?CSXp7E<+SW|~*!S9b
za&h<PKjGbZj*e@|DwwbjY+iriLVFDcU*7NcXc4w|2b6r^@%O2UMx7a7a%5=S<1`mx
zPsLBUyH7CQf0}r|GEB|t8WY$DoevE`Gc&lHf}>FHe^F>c|AxotsjmMh1kfL$xpv+R
zyoNWW)*<<M>aXfd_0nja)#O?82Ckg}CxSy(yBIhvaOw93Kh-~_m;?bRkgEWwe`rlc
zGGCc$@~-Hpy!I=FrN=r`ba~lMP(c&Zo6G*cbI8-3-}AVW?rd2<WCYU$tq}PDGTxBt
zVt@pKwZ+as!Lri(C|k4Sy@&kf?G!Lpy1TJ?)LnV37D%HvvbeQBiF!F9^c@#|k$_ec
zh;*I3EcNX7=2uf-`Q&DXn#>Ficm8vJ=(bk!oZI|P;`(}^KOFQ=-PXoS;nmj1X-9lZ
zL-mjk|3c?L>eCATi`#jtZn69~K=*qsn;}5<xX%lJJk<;_v#_JK#|IP2eCClEWIq5s
z)pIbk?S~i;xx0SE@&e6AbAb&Ak)-70LI1oxjJb3%5;I_4$6hzfl}DdrssSx*rITq_
z>3Oviu!q2{32*A)>UF!^FxfGo^cCztD5a%KS4+~LvQ6&))=~YaHYYkzie{qs>#K_X
z<xpM1+=O57*d5Q{rl)EN4qnLrfokE&{m5Zc#z3;|eqSEDIBdcaUxos-l-TH=wX`-!
zF=nTByy@L19$2KA_06Fqb(gX0D?mduw4wJS0|pmr{ky9Esi`e;()rt+M(dADnj871
z(}S6f5(aI2CJWiVk^NcqXkrgWT$GpJ@l0SjZTyD_geQmdaua?F`GT?vn=g=xyrrW{
zRXjPQ+{^HGp~^Yt*<#c6=R2PUsvm+7JWSR9)&h8#4G~qvDoUfIh@I6qEPjAK<2Oxs
z@Kb1tG|$87M3Q~&zCuosjjf6n9d;M&Z%YO*0KR+_%$fz~lgtspw>|&o#FH0sn~y^4
z3c2t|f9-$&u@jST(rjmhWldOcL0O}Y7^rRJ>MjuqS*e2?4TTdEJqD1VrO2Eu=fVOI
zCF^SA<NLF)&ej?utSs__9UfnJqN|eYCrkAYA7}~GH>xyL558?$@KJ504DL{1))X5?
z$wt)e5C5E2ul??)c_+3JX1vsLva+>HVo3C%)HSE)VZL#$&4dF;A{FF&b;>!)twJ%c
zE=d~Mtf|n7au@RZd9U$`W-*Bpr=?G$<7F%QWTIPlDf<k2LJoUwjlyt<<4(pJk<ON~
ziLEFuULK+S&sSK^1luX(0drRK6UCE;Mj>K<)W;sE+hDsAEWP=0`e{MO#rpL;-6jxb
zZ$(H|mU&kC)TG(u2m(o5#Rgb10*i8~D(2b35R?O<)!p;2mW10F*>R5vz}<{yr_(20
zaY}(;SF=6wzq35`*qqQ=A=8D$#0L4+eK8wEdPxl-%<lpA1?AfKO+7O}GJotyb%!40
zGhl!2g97-o2&<O)nHfEacA4ot{8nF<{e3H)frHIE>f)RTPjhu+-tOW4Ms}GXflv-i
z6Y4Y+AI1R@EOhig82@RrL(A?`KjYPN42ASgYFW(Jpv#!msotfZFK5<mNT(0WCKK+3
zm0B)e>g37yfVE+^&pQ)Um#5ue40z!_U0Nk6X<A9fTbGY_<>K+`_5BDZ)lg$>-*l||
zM0w|PbeKa&uJ~X5e<8my2l&j-fPWEBnXW&<2ieu588^?%i<i&l<n@AG`g!bXY%dPh
zyl;EQVz~Bk=7VUK93p%#7u-iCW=YQ{A8f`eBOQIRr*tl%Y!%DoNH(vX*SEckl3w>w
z@6E;-$2r0u4LXR@Rs1)WL(83(7#_rD(&4#K{z2WYar3MWj$_K;^XU@*sew7)Xx`$_
zPnY%Uco4Da^#rcX$hCBz*O4q#H2oO-gwJGB?|(G~R9iI}u{%f%BPd;moud#)Ff&os
zMPiO{gj=dn(q9qE_?P1DyQVDf(I5BciQNht*#~z8Ju?h~Bet5vNCUFfyZ_MlaWFV6
zF8U8z5N~f0LVd++^<S;3+P~BdE0WJdU)2cw;CW}egj+(@gwy<@iFh)bLYF27PB;C*
zDK)xCV&$V42%Z4%JG``ZcRzaC^iXejAP0{a@SFfO2fW{9S?Tg#?e9US3@RH!PC=0$
z?S4h|fvkmSc*eU-j5Z)!y!(Y90u~$jyQKW^@X_$kpAA=|6|jE{{)DOU=K=x?PkoO#
z!C*+lA`#KM$2D}m1-to(DK?T@lW1A&q8DGWW$ie@hBx@%bz-g}CuGI{fBY4mYPDga
z{o_xuYJ(_ZfhF?T<)C&hwigj6+l{4uA0|e&nDyB7?-!iT;6Z2RY&yn2f*OdYyznX@
zD`wwTx8RNukwzle1R=X2a14PIeNewVGKo8<h#!=+9sz}kNIlmcwb_nGnAd{DlQfYy
z@pqo$@+7q~n@}J8){brS|F|Tj-H8TlGcX3pxbKU$xQ9-ALTR{%R<Po_KXud1kVv8N
zO>!k;@i2m_29c$@Rf~ZQuW2=sLB6b?Ao=QkP6mkI3dVoXkW5^qLyws~azi$}Q$#OE
zcoKOaAG=2TH^d2O1qq;+IW!a5g+Zf1^Asvi*5E4k(x40s`~6(6(0rpGW<cwT9;x|m
zQNwy|aXXRG1rDd`{xkm<hw+&&iH3aS>%<m(SvA472wS-xT9EKM>M%D`CTjJ(TXEFg
zl7n#$-HS(cwH;00rvBpbK};}*W<b1=o~VnLkNi!)glV3Se8jh5?k4_rfeAF|d(*n|
z7rV1xvi6E)8{tghHUlRuH~u9w$gzPjM%;FRi<b!3c0Aj|t4QI${0|Mfbu(@l0=2q%
z(Jd0dD?RQP8*RwdrhU{5B{$q)zQFc&z6>FeymBfy&(fxNW%0%O)OALHZB^lawn{ZM
z&xD(@-j{6~6?7{sRT<J!4zG4<>DACFgq~*j22Vrp{*4?Xd=~L|y|;xd^k-kKBZ;sN
zw>ozUPtMSJfgrQ{um5Liv%iGJY@%D>*@Z#q1i6DQjQ<Z$R~Zmh7j5Yd0qGvP8$nXK
zq@|IP?vh4Iy1PL-q@=q+TDm(%y1U*TzxUoxW|(u&*}3-Gd(JdFy)$!08-VY!s;?da
zZ9RAUMi%=<#u+ax6mxVY@Bx<d?SVRV4H=*onE%Q1g6}BUHVj9kd(bCkffsnR>ABx+
zVH`0>hwh2GM1c)<or_BCoi_&QEgtVp&PGD2(+=#eq9Oo5BmRXFSE-dI1O|c31q?bf
zfn3kl7*np3_NwZ$%aOm+;6F~qfC&2*kob^~sDq<?FfKE+rVjB=o+hPt6+Z&`B?q#G
zs%J>la==0i&CrBjl63?7%vP22J6bcm9PbWf16Ciu`uRKF2L-&i=!WiNxq}qF(X$M@
zz`s_sF%NFd2>>EIC}b-DR(aoRzk(C<60>m2;Kqo%&35`z)+VZJ0E(MsHS2ay<ijgZ
zr_|dDjkO(#0uW)l!z0#R3<0klhM8vdG4Zs8MQCjmGYAwfFqREScN3jhz|Ux#=)43=
z*}vp_tI=ds-P=%|zEaYA!?j{&ThBtlurQh1O|Px<x7lldErVkok<rl~gxNr#?!V$d
z#OvX=SusOv-6!v|ITISmQtWTueKz3`pguO?Ag<Zyb-mjfk#6N<!rG6HtZ;bcny|UD
z$7uC<bt<L;fo4BIk_5wA?4c&0x5<Jhe)h4Mr17SCO<3RQeNIJk;g>62<~s|F;1-}6
z!rDNmsA#^h@QuS|g?Cp`3W&4s{!vGKy#pAzl`qH}+>sAX#cDMNo>{0r(|Y3v;%U4t
z*4pU0MOa*QK&m`9lv|F$G3`N=^Hu66UjW1KQiVio6fR>i``}d<7Ixx=wv~PLI$dEs
zcs|}LSJiXH(X7VUqM~{Egv3yF@~U3`z?O&N`;#0VvdqxXosW>+53N@dcYK%zWBQZo
zpQyKdpNS`jVgk2kKWe7FZt8e9%cy;hkP+^XV$2>otC=tT1Yo!w@qZtjFxo~C-=d7P
z9m$ew#FCW8Ypa}2i4k7(|DH1n-L}CuK-VQrAdeDF30e)?B$3Q}`4GH%7Ue_-2yRte
z9}+p^PI{t@w#R91)}b^`Y*6-?5!MFW8}DCV@XSs{jTL1Z-T@ZscdGRz5iSDnc<51{
z+$gKQ0se4-v+E8DY`4)#z_!_@Aml7tovLrEGVnX9g9ytfOgky{Q%Nx!gD?Z9L7d%i
z<=~ci*WBPDR4uxrF8M7wyJwO>YXHHr*p?9nu^U`tR7?BHJ`lA`4?7GlfUXW|Gl%yP
zxr4xum9!no@0YY#6WcEa%n#&dO25X4Cjk87$`ulo<HfyD-@PSygKb?^&l%SDKwz*H
z*?o_Ad&!4hL^vrS*Avw{U@MlnfMC6Z5Yy1Vh<8UcXREU(-~g>A#p8#&#;5`~Rr){2
zY;Gqy&@$<*X?iYMDRmi6Q`*7Y{3>FGS&O1{308?1$->)S&wxWiC7RaiO1F+G>^PA_
zSVa6_5+QREtk;R{>beZw8hE_;^i6}oStE<<rKhJcdT%ZGOS2jf9ETwz520V?{=7LK
z4SpB+oC`eS%c;@%s=JE_7N+BJ3I1@FicVwOt*~OJ;dvy%Q}L5~dnbGZ1IQ>cH8yvD
z<Ty;#Yoh_*&da#Ns(D(@gfT+om5fVqj=&UvC&7>d#4lFYq`(#@3PfqVAPS>5B^<B$
zmdLk8;To^Bxt7Sc6LS|`3Sb!A&VMiom$3v^rMO>o>*_!yLHMb8lBkn5EN$<j$r29O
z^FJn)y4}cR0@hb|k6D$#P23n|XvgJ*&&e+Ba%f^*cp*jITeB<F{$dimzOgfQb=WE6
zHVvHZNV6lbI9QCE#5=*MIEW*8C_j3RKoZ!Y7{pZf|5iJS%iQm9V*Gv(8Kv`oO&b#V
zR;$4O_H?hg*!ZhuwL6FT<+Q6bVgwz?bZemc9QMaPeYLnhnd#`RU=fLj<9!1VFOno6
zYgryvJL<l9>~*=`C?EG8eGQl1ZuXg()^9mhZT2|9P0b=<&R#Ae=@>uk-U^esCw*_n
z6N%LowxR2Gf0LCevD&@z^=_1Py#XLDNFd(-<vVQEf$W4Zrisn`cU@qx3U;W7IL&i3
zMZalvs`b9Tldbg*b(6>U*NK_GahOcM_FBtd=IRgnt+u*;G;UumR8C!vzXE1EHIpO&
z4IoyEcFhi`(>$2COXfKJ@t$|~6-)kVV{`t7;y!{njIp8WAm<`>;?yytcgI1?_k4)1
zV+}qmf<&;su>*9#B#Et+ERamcf>#Bhl*SqF`6R}<s1L?V!z$4M8xb7e^Uu@oRhkoG
zP-e#3#|U0;q9fBsJDTDluFFs5w6dAE0gxA?N;3jAz^=+UZF~|s-{GNQeKQ6t5PrPA
zR7#5?0W~fMZNh?vCoj<wG9;4Io2b(I;p&pr1Ji-kw6Doku7eafgcbzwBV8RhBMjgb
zF8e9vMcbxvS}~)eJMK5AIeLCa-6j7XK?7P1;a7_$2${A0exHbKZ}lnu++Mx~9r(P(
zfgLSK75LtEHMHXveB>HU=nK5rAg9O7y4;)Ai>RDOEUi@St<mVM!NU?_piM1cbL3di
z^cGb+$c_rWgG()XhR*^7;*nti6lC>zMmZi3Ctl65MlC!Dsy4gZShBMFizJ-g<6^zU
zq%X~pZ!#1stBMWqU<b&?XMO>`?=LNaOg4Y~5&NiDL|O=6@T=Qa<%BjCvi$`XW_-0!
z*Ba9pf{jRU%yKh#4WyU6KT-~iCPi$o`_02g?cX3fT8RMbTYuON5B-hO80G1o3hN&u
zU+aIjGSvqWZV}+uG8OM_jx@W2;iC^ECgWDlFEwEXf%k4+_z(C&0(sOmtHBNnIgO06
zkgffb=?o)SA$>3#iO_{R;hWCVq8r2jm!&@TH+8_pMe(`nA#VX~H~4=IM!cvdM|9(!
zXvv)$KJxbG@>~u{3F_9OA})u|NaPE?qX6VYC)Wh@odk&j_4I_#+-Fxq(f!5F_Trp|
z3P5V<pE2nO`s+Y}%jaZpaE$10^8ah|J~LZzU!E)QU-<u9)~%8J9BywrV9-@S&>i^b
z|L!&&uu=>gLiVlV*coO%V5(s6x)Vkim3X>y?8kNoHg^%=MgPt0Oxy-aadid{4YuJ!
zUfr=D-n{f1ftBU~krVPk{*4~uY*s@+Wf2;T7y;(~;B8y&4uFwNwgcAQG;(gU(a_v;
zAO;!#H^UJhf#`ROiN|(<tRQ@lWe9nP@Adr?D##9rX!?#eWTo!&pH$%EasLJ`7>2|H
zg1I_D7J>jA_&il*Yqw7rse*ru&z}ANj}CJd?b3SPYseA7Wd>diavY3v=E%Y3EeUyi
z0#adk;Xj2E+@y?g@S@^PJT(~B07PD$2z=BYTHcQj^B5q|r^^5O6`HaqsCcZIbhII;
zwDBSN<W<GswlRttn(UP~Ca|hMqiTdDeApjgT$^qOe&ScZz0313eI+?ES;2pEk4S*(
z;1#v-nf5}n$<tv0`kUmi>F@;E&L2m6Bb&GMTL*%TFLPbB{#yW>01tr|1z(Q{nd2|1
z0R>qB0?Xpx9FLNf@QS<ePqmGiczv&kDFcn5Sl%$%VJu{Q`>rCHqsz9xcW>-f*yurQ
z1DV-3QsUW!S?2-CB$%0gEIKSPo}c$Cii2EJYS^kWWc{*#0_VzGoibp@$7a0J!pAjC
z#-ujR$mKBj23A?Y`C!cQ;4Q%FeX&DPGj-v{=QcQOK?)=^4*L{+**+=<0i=bX1<kiU
zFub9MU0SdU_<26Eg}KuDqhZtJh@Gfl))(%(n!WIN8Mlpu?jGDQ<8|~VUM)aVrF{Rq
zH30BdsiQ-Lh?HMmf&FD~vDRUuk%^pN0;o@Z2wS@`SvtbC;?vs$7h9!e7!GY~8B&FL
zi?<aBWKzZW+57vTZhHe)u<_&xyrP^NG+X^1*&SCbP+M+)elub7L<Z;idTTLH;RvxT
z%QJpp(DBW3V?e(X-ems7Hjp7Q*|!BU*?nO8*tWjDuQqB{8y@YHv*`pWwsnQMt&N3o
z-4t_{X@f|4xcjuc&8yw_h`El~tPy}j1;UjE@=;uR>=LC`N$6lIpA(SBR9h9Z8+hmx
zbE5BI2|_;PR(j|U+#uwPhq(#$54lCD*T^u&&#sd5k}V@dL6(599C12^H)DR2WM~BP
zR+F;RkB&W8hhaEMFpnt$SzGtKediUK?(=~pA||&^=2TMyQ-wzBwL<kie<0qY^3VJ|
z?fURe<l7f}yNzX!`Azq_n}h<-FHh#3=!w_A|32Nm6Bu+p(6>$$AjX0!BD;QXcM2ET
zq~E0lEMW9+fv;3{pD`~#1@=c^zarzwTMZI&Y3}vyo5&QtAg^_<>?f*!5&2^I#9TZo
z*tAj_3T1dM-fhgU3kT!?Kn%4RuK3gKbUs?&X*IgFDgZR+(hQe_eMu;PANhP7;Z!_b
zQLrGW#cYnH+kS(A6DXOea~9D$XR7j~6iEtz*A$L9nxqFhx-}1;ZzSG~sVM?9rKUIR
z?3~I!9dZ~z%}vXig^1;`#<;nf&C^)>#<Ir3`E=xQJ6s4lzh;Ql<4RO{9uWFS!fOPo
zg{lc<^QIKPF{^f~j=UIPj^1Fhzl2;0j#G8n+|;;@r0Sbq?#v@!?-{kph>MfZrp^T6
zoUR1ZcEVmp4QI)DEXZcEoA5k*<V#0DzhgDUrg@Rh9PZF#9n~~l7_;WuJ@YVv39p;l
z!1AgVU?(t<jy!gpqxiGWG{qt*iUaj=^hVPk?3hipCA@)!u(TDMp%zyX&+XoqO@fjc
zT+37xA1j0K?Dzl+%Mp!e*wBfz0{xWKew^k+tLYEKoFR99E#^{Rx|Mp^zS@AVZb#9P
zIn}vJY(zx9C7|*|NzQBIKObnB*U$jJ?Md6WR-0fT$WQhev@YUJ1y#(#>O$!nqUqi|
zXpIWJP+-00Mh_hUcPO-CMail&oSZ)|B!K;v{Z^4~YCC1d?%totZ&;c=ezUw%bMJZt
zZcss~`Ou{NBG#m(I;)u7Lbx~Wx5WCUf<557fPwM}b%E5g^Nc{3dG{8-0V-f2%jyPU
zUQfoJXN(SCGhpIEck=KDg!xQlE?8@Qu${d{IiLaVt5M1zYSEW#K*4YXsMl0!8v2^!
z3){wQUWKAM6q|7vnQHwEn)2TD^v9REZgtL4DUOysK$l(OE~jNWfiXw2f@eU^E1%Ku
zS#i$>5lgjiA4E0wv?C3+eyX3iNVEtQ)3HZV*IHf;T3nq@Zg|Xl&#eB;G`rvHTZul8
z0t#x?LJfG|FlWKrJM#S@_#?YbU)f{U%<F)DPFJ>AW?-OjW9VG#H=a#%b&Nyy_dB5t
zF3=-Egh-$TG6z;%RkSX-@hNNr?LcxDt$qeo>@Oz%uY1gu%LY|6`#LI5AUgs0@CM&p
zKGpJ*^Zd|zsunU_26S`j4STc=!ISISg%Puzma@-@yG}8uVH~(xg@E78_$6_S8#9Rf
zm{c;%UHyC#)S}gttUmr^SX1!6Vj3)%*)G?L712#TnCdSXvw8ll>7mQ*0>gRg>XXc3
z1GTqTW_Q<T(TP8c4YjncLrl>1^zp1__6TT2$r7rmd;X=s+}SV4Q{c>*GA&1MN~!s?
zpKa_KKB-ePhG=&n4seTZ7lyi2Tssu~`HSPfO=y8SoTWTO>OR6)?Xn9LMzhNg-S?-z
zDmyosb?V-8gi+KS910g#vi?27wUvNI@D|yxJa%~PoQmSMLS^rahTCp(IwO`0Y4toS
z?t&e$`?eFLZH>($1k<S2CBLBB(=mwbrazp6;r`2I`HkfS7@qiov%!Hyz3{8T8Jx8f
z?10ipR=5m0k(iK|Q%p|3@K<qj)H0cw*^_fpb~7kwwj~K_ws9mw&6D%ZBa@gUfvot0
zBoqNMHMKHNUF>5MO;}CDD37fxS}~tFB59}VjhYX}Npd6x(eRAn^+pk)s`znw_n3NI
zXP0N^DfiR4nEoSto(J_;k&0B&<GpRtmb`d52v1D_`kSimLv+s_x@I;+{ZvY7?No>&
z0W#hB8SY40>%-QuK_9%3vX3|2HLJgG&_OnETp~)Xiaa-%DxR<D;S8Q>fe!TPo-vv7
zO$~Lp&=;@4cHwgN3R-9Ymj$xXTl$yObBK5B90dAG@3d~+Xvj7gMQ+@s5hqhO$h_a9
z)D5V_Wlx?7SoGx_INwzimw>tx_Hp-n6g*ytWW;t&8f?#gPYe4XMz6~6xwRsbpQCvq
zAvb^x{q4A3sTXh?oIx;L%>IguT4#IHo}XsG;CTORU=Ap0h19(sZt^fRzE}Q@CUtvJ
zu4Eor<egfM-+4j$*bOv6O0obtmSz89^jl1a9Jf>ndC9!W3kH1H)<ocS+1`87+q?c<
z#eD8`4OIM*l%NQjPrC)J9q>ma+-656chmlZoWP)IuH&WaYOI^12*Dk-yG<iyw@LUH
z?04Tu)mUep$8ygL-jAL85^SHVx=7;1fhxpDZB8z2b=FHkDw?Ugk1)lME$jz5;?+La
zITd4NPBIyC<AzbU10Z-K6f^ed8>d#ORM+@K4u)sgZzW8!`Gu^6BI{(eeWD?nobTua
z0Bl*LX~rrJ!hsHzQOT?iOB-74P#Mu@#7<gLFh~nMMB>c~3QhcDVfMJ;M2D3qO<8>T
znTS1EJtBDE{b(>kWGZ#I61^8{-c2RZlX>+ZEN~mJMQay_<Wz>^lxl#YP^uP>9&@Q&
z)C<+dhEp*mNSp7ubo;B>127S<vOnvLbv6rml|Rf+S4VTIRS0t-{`W_gu!4Nd6mLW%
zx0=5%nw9VGM7p=&O)w^RH@Ax#(8$%ONu4PS&u2AJ@a4-C^Q++XR8F`hsHMlh&N!o&
z$fyIi#>rE-;CN#(RLsgc*fu914G8MVgQim@;)4et5u@FGHrzL7zBwVj`3mLMSP?LQ
zv%j)s7^hHsEk~ERzEvWhCv$sYa&ip|1mD6?5hz!PNnP-!E|UFvRN#ka#*PCDzp~Jf
z%tRxy=a=VGzw@3J;~h{Yzkj~foZ9|-G6$PxElJSOhVVMVHW>0@l#Qnkl6k6@SK|I3
z{{4L;u+sXfWlY(c@ttH?tSr<Pi#hR<0H_SB-3#BGEB|qiMyO0?eOtZk@D}*q!hT_s
zdTm;mi`w`+5QV-YuLY*ArvQ3q7@p()W!{`Xud}c?Cb9I;pE&CW1m=jRe#08M{)5jb
zB-Qo{0NOowz<I+*lpynd3Ul}0AYNfL9-Xm`1|YQpna}Va3j-Udu`SIlfw|-;Ff$ra
z)muT|cMe^`M%!U7xbv|nQ*+y&W1MB1r{BbF{T&mklR6D_{)!9|iMqs$oUgV!qtT&m
z6YjI|J0~?1F|3HUpIj*4S*91_xlNvurGD6gzrk?UmD{<LnPDlAeg<D1P4+SRh@fQ{
zGW6wyM43NyE4I+R)0dXf&2i+bw%jO*@Mqw=RT*s6>T;}?XbDUWrG5@ufFlSx&r)>*
z&t!O6jLV94`eA`#rE40WxeOKJPL5)LVE9ZRHQG$D&b-;c3rIc)`o<Hvk#fqX*>wtK
zU@tCoFCkR;hxtVR)rsZR=hEmkA<ya7`K6g#EpiiB!$1vaa#oM=ez}1N*^)}C0N<e4
zIa+tjjka8ltbINa^H`rZ+?6u7*RQF&&tZJ<+fAxb)+HbnnQ0%~jY!B=ys8^Ny%3;-
z^eqbt{bZZgrKqH#HDTK2e^pRtKmh=~pjPUXj5&-v*L>nF(`{L?TU8QZ{XCvG2TEV8
zVXeWq6Z;0~60ir0b+KP2oFO{Q2P&r)^`D@)pVhR|TQ(%@TP#OoSgDqCXmNAt5k+9m
z>8gTk$1dm}?|uLqX}^Q7mddq|H4Fv9ZkEN%7JIPNH$1Ri?pqTtiyOQ+g@%P0nZ*-;
z>}$}i)+%(`t&aJSpcZPV;?t}ai!%AQ-OoATV}R8tbhNs^Oaad0vLKN+lGhnx<hFRQ
zhS$FG$?dGaT3|mHkSe{nwFKj=c>j<=cgQpBS-kUvi(ydZ!8U+H2iuGrfGxKW0ZO!w
zpUC`~q9&3p^o|ggg^)U1hR3=(^^qUGN$86fZkU+%@P3z-e_s0tSnn-;vW)G*vKdT5
z;NZtIowHQXEGSLqt)N*Z%57i-&}^R*UnAa50WecO4_<)`84)vWH=7v7K_y59DXIf+
zU<jHjd*aO_r=einlA#_UpK-Y7XCxA}0#9me=U&9?9FCXOs*o69;JVvq=$!8mKFrix
z6ek5Sj7C)+VPTn1P3*f`96cO3MRZ+s@^gO^zcO>&(yyRb_$YJ1p-Q}t!XTM?E&Jof
zu8bapde2Z=E~CvdBY@A4QI1**p|@bllV4o#`D%h!iaUP!L#$Lr{ipUCIUl8#AQ<Ml
z8<#;@znV2?%y<AH%9em&>i=c|=u~YHbg;K8uqD<4Xd>vGMnY)PmOe>Hz&I$vJV18X
zg|CNC4af!MW*gvF`@{Jn9BRqi<@)YKYb2~<IQR_f*ut85fFmEgUB)Rywt3w6czX%P
z?9fQR1L~3LR-aFi(*ga?tg{ZpAb6*Dk+9;xDN6{Pz4bR1{II^2Ye<0LJy#BE{J7BG
z&;P3O!Dh~usdqYIGdin~?VDhKX*b|Hx&B<Z42+@e&}`xJS;K|jWb0ssz1<YXK<L1t
zPL5LrmXq~`zruJ6T<p*ZA5Np{CA@9kr3owf7(m^L`BuK5g{G;oPxmi+rjkz;nDBK?
z`^ol1hh`0+4P1&QHBsMNDve57Nm8p)xKR~RYPF^60>N!YsDtCI7T|C%XTxO*M1g{6
z+yk2G#sAs%bC)}4_Hgj<1+&&%zJt`9YC}x*h87@|f3uuECuXc0wC*eev{6GQ7v&$m
z*a2PU-2n<fR+Bazs5a#EIymE}2QcvELId}r6QYwZy*>(Pz!q<=_Ovq5fh`9W>fu4`
z@XTFs;V<iw4x1t0xC1DL@byKl&zD@NDMexek)S!a1?a0K4wIZp$8Q5=UbA0!12y0b
zI-K1&1f3WJj?95a0Q-yLm}4&$-U}=BBtpcDL7-IdRdA<Wdo&H2>hm~s13N@%DH~?0
zPegyG3zuC%XQW{Zan!|edhy0jk4ohh!1tO!vg6PX2;nyf<WA1HTA+IKkG?V`HKB$a
z$gD8RaV2jUh>+ZlvJENR;2>g8cHpf3oNGb;E0qbhAG?%PM9&_28~lQGbi`>M|5uCK
z^Hj1Lkt0VkX2(X#t^`yK%sIa79zp{|G5)2s)Y25d3t7qL&qIT^x<Q{OpuC9HsfX8X
z)=}<!yF$T6cqgT}r8H4MpZ5wdoC(86Ziu5za=8-9A4d1>Yo4g<$O7F!`!MIX@(1a<
zM9mYFzr6M*w|(omv9X3!NMEH(WW6F&WX^6O>QEWQBFI1l4E#g5yv~by9R0UWXfgD=
zX9}<7(SN4xOa#|Tkrm_k@!z?3f>8k#Om3(FWhEW3IHACnFQfd-l#B#5-R<1~L4H8J
zPAGql54UBE%m*M~M><qAn!NN;Jm&5y;f7r}#+*W-0sPmVX18(JOuCc-IvBruix8jv
zk1!^lQUTucmn?xMj}yL8sU(3U64$k<63a>0$fccaCprd@>eqpLJ|P%Mujt2S7D!O2
zrIm)w0Q`XeT5s(E16bbZ39njo(v0Ib5k&4n<81!3u#y?_N&^tJEPML62+C`$BiZCQ
z6|4F+utXhr7B*cpTY4{Efx`Nj4?5jLr-4bP6KY8y&R-S?iD2NdZE2?0Nf(Glt)cR9
zX_X6uoo?#xD^5{nZOb0UF0%Z)ySMr?$(fU7DlD(+{SpHDxqL?|i%>=4-bmTiCl+3Z
z7~MEDt1+Y-G0S4~@FnnFvn5~YbV(|$b@wZg^#3)VV|DWcf%HK;1wsQjXofnmfNjz5
zNn~CF9*|0=H~XT98|H-Th_$JMwK|l`cz409%1Y+)F#9fTq6yFr+{SO;oSL&*ABWER
zmD0B~H;rLFyBfDwFc>|@@8gHwHUE9Bbz49GGz*3u6q#s#M~Q@jGF%<4BYn75KP(rD
zDhd5vLxm9Irx&IKlK9GO3uFBo&2n_k71-bK>Pw6|()F$rWw<JFxba>Smyc8nWg_tL
zg5b)_HUl;TpZYE^NonxP>3#O;<rA#l{ZpKJp|^R1b0y#G0R~dws3&y3w?&NeSmIOz
zT(G!TV);I+f%omV8_7J^xG6io*#-}qFF#dAn(xx8^!*aXJjIe?4D_Yt#4GK)abvj}
zwEJuHqv6}%*0H}X%7)}Tongu`I3Q7eEBf^Ku6gU;x#ZyxLA&)GICCVrrexAwYSYql
z7>AYxyhXpG@U}c_G-onAqw^HeJI+F%9tX{Ox-`)o-D|vGK3(4LT0v)+xNDWRLhG!b
zdtL%GT%%8iErS^}@9ZP+aqf?Dqn(J#JMrf9UsG<WcTZZC-osYK`Of3Jiras(ea+f~
zFpnK87tJgMV0wQDIl!-e*}r}EW5cfaD2EB-Ni-`aHb7XP8Ihyi!tW5E&1T5GE9~o<
z6;?TX&C&$J(=@`xeA;$-peZ@;xJiTgv&??AAg8KMnn1E??NG1z?5&j*Hr8sI^SI=M
zr-c$`n)!?qt1otD#IHD&W0PdA{Se<j_+fKWrJO%k<qO-sEI6}%#*ReLA)NheM8+dk
z;jZjW7iZmpHPz*)Um4KHO0U*!!z%5fG3#c#SG5wv-W1o^@Isu@S)H*j#6OR%3iZ0y
z{Pc&f4op#-%|7sRS8ru>4x@|EOlX($VK|)p!N`DGCqYMu<gQtTC6IlsWLNL0z{T1y
zR9ngC$tnT4BLTQOtR|yv$Wh-{GFL>}Bj`z=Sx2s=qi|aMYv3qMrTd9`f`C(H;gb!2
zV<il&aeai0N2=3(x$H<YA4(Hc`46F<$DhW->1^PRoHD<C);t0Fly8JLnGq?m99mHZ
z-@zq@MJh~+z@cinnhu>w<_p<Ct&{G&TE5ShxCgBi2;{K^Z<B~q?^agT3x{>qoGT^0
zYt}1PZH_V231;73Bkqp#=*kIDWg5?^4NObV-I@EdVL!(<qrrUTDdTzLl=ja6E0(E9
zOy|^Cug}ZJw#ZpC+fCkgj@IZ0|LNMJ$A_xgeMp9qDemMx4kMA&ew6lxNgrX*zC;Wx
zQW0@3*P=n2Q2s=|w5=CGkDo6k?zQnTNMQaZ!8`8n<BWyzbtODgqY8sPF>oe)BWA<v
zvA-~$Bl%Jlsc}io9k7~x!EV}pfUb5ISeL1eVD%!-e8*4BO|xc=Dqi!K5;Q8vuJ_GZ
z&HEe%v$q7c!&T%k#rBP+u*J3+Cdd0nm{&<QC3?3OTnU%9BP7;~sRFTl&D6`qn^qv2
z8lBF1gOGYHCY4sdCDkk0+yRe|Gw9-xY|^UN#i8%3@Wv+aV5rNd3tzi6<l!oKGRT#@
zXO8Q6mMew$$0{i94x|$I%S)N;;SU*Dhq{}lWbzN$=BGX9)0QXo@=KxcK{1w1CMjaP
zZ_>@)77#<6QjmzmtNTt@nwTid6it1u4Y+dupAAKOSbNyUxGCz_mx*i(Eq~SM-xL14
zd-HF_h%{_1*PhqmJtxanqYNKh{xsLC_09+T(5alKRfQy&*(W5&La$5i=+zdw$OHE`
zo|7S$&AD2{oKinjRuLdP^_4Va#xh0ejQ1<a-AeHF{lp*CmoRobJDF#}%c#$^j&_oD
zRseT8+02KL%)5Tmab1f=6L@tijx(%XW<e97P=D+%wkIC{G_jmjzqit&ZI=>1_mw5Z
zxlC-p1%HxMUB)+)1FT1>TBa-)WyPj866yLp)RFKv!>aCW(?Yd7Y|;gJZ??0e$va<M
zvLB73@2qe!M(Em&{tATY`4UnSZY0fqTSe$1f33y+azll71G|d3&@r^?a)(^~eKX6q
zGji=W530H2TK3Cn@(3Pq@Yy|Fq!jW!P9)$~KOI<ES|UgsS!`h;z&Mt58frNKSv~Ea
ze0%T2SzV}d%yiH^@XsIXh=*UKcq9p}XBe6DY?bp}8z{~&f3dzkpI+CsLN%GIXmYPc
zp$UCp`q1#%nrbz+P}cVs<uxY)pOC=3a}6Ccr<d!8fEy{A6l<Pz(dL=zJ4DZ6fnXu<
z7L6f^hBZ%5tqVA=NPmq-&XUl<Ut6g;I&jCi7IJKUbn#SKdyj#in#z4vUueHD=ZFfV
z&`8@pVM)7{ZZ5DE1A;%E+ow2c2|miI2W9r*qQ0A0y4Gt8^R}8p*|(Z=YMzbjHhf<P
zM#)chK2Mkee!`snkfsSPj#h~5Ofs*Ep%^xUXtslT!xQp8moz365MO&1PCziq`QkoF
zNuwk!eFeLEtmr3Kyo0XoQ6{ZV@fukISbx{(@dL-9ZJ}~2g)_)~6D%C$@T$PZEY-Ty
zVy&v5c5`S@R>fF8piS7Q|8v}+Na?XT%j~?6QOg6i3$`OD23yoj^EtK30=*9ILw@{s
z#w{h6=8QX%y`TN#8l-+S{;*V{%pCCwr0(6QoN&}jDd%fAgsvNQq4^PrM7#&`PHHEP
z+f*-nLW05<`nY_Ige&K6dWm5sltOI4fyP6$M8z!Kyaeo=WcGjz$p<}REPd%DLIP@d
zv5Qu!Ub1e>402wz@(}1pf>}<a?MR*P=7t|(X3Rpq<l3jZWR92z@;+wfw<>Put%fK!
z7NF*d`!OqkCo$@lN~Evm9c$>2d$S}&b)J)I#co0yV5HKo#UKYo{n%w^F@dB0yKV1D
z%z#?X(rd$}Hk&if?$^vuuwG^fO6m!yCBf-F#i**9n|U4Wr<D0HF)t|?MdFhODgLqJ
zI}s0Ox_~nmL(@8Z1#&#wb$&yiHA!tS@;hr>I1Oo@COvu+xau@nc`Y&6P7X_ceChfY
zatA-7nzH6jAZ>|_!}4;M`6yV^{!5T=Vg2=^tk8pkLk#divNoo3s^?h}tl0?Y!w#F-
zjk!nY7rrj|C^u1+$17HinC0Ttk6<lV>DuIxO86zBP4C)lr*=pthEF^Xu1745?c}+|
zAM}c&FC@hpXFp`vUepBnPW{!3vm)u#F`dJqRb#NvxJFSO*o%aQLiUdP-M{>M)qp0h
z6z+v|4Bo}uw>H<6+ZNm*%VO|jrN4UjS84RLaz3(akMY4j7{hDeMP(-L_11FHyv&^q
zyZd|BgH*+>*60_As;2$(v3k$Tp>d*g;1%51<xM#|WOi2Iy*eb{pg~7%y}89c7-@*g
zJzQxF+vL|B9yeo25n`~7aEJ!nDOfnZzxO4JiIZ@8oA)GN@3Vz0MMs3hWj$*6>ThjR
z=D>nAh;n8uU^cO9vmKa(c42Ej|4`jGn>NC_#k^ft0z<K`@W5XT$}IKZ#kpiX(((vJ
z`UpHI>P%FFe|_L5<{??4S}}&;h`mEf`c8IBWI}8f1BdWakV<fz-x#^oFfrVU>68;|
z^m}%ag>fLJqG=M;qs(`^+544@;jH<YE4&}ajiSh#XLPx=Xc_kjq-Mbn!=}deWmTcH
zBw2DUGI9j%{u-?Y>v@-;5VF=Ep3`{_i|D3@fkBf%hT4^=%~qCdE*SG1@0X2A2I<+%
zso7nemy2eM`ik}x6mmaq2!O+<`deQ}??OD@^&;$j1b0}QZt+u?%;A)>TQ~pJ#yG|j
z&Wl`D03!XQ_e1`X=@d3+5bvOEpK~02H+^oB$}#Sqa}^|)?{~>|#Y9<+&~NJGYZ#$&
zwI3O834~=nvhMC9rN1miN37)!dVjwN*H+r0s7;R003hA;s3#%q9gyVGOXXn2ru8Le
z)rSx9N(&?latmDK6DfoHC)H&k2~Jp5C)g<tP+2nBuirm4tJVJ;P*oVuq_A>Z^-oB@
zT8j1;;RdUaB(DfMUwsM6h${C|qnsdomyh!|!t8b3_v0v;A%CM;o>JgKTl~)p)Q3-v
z=6ls_A3a&$Q{saF<PdawmuZ!d?CdxbXplzw!Zw4mK-!4anI$pImpfB(Be*-tZpDu;
zLRkzAiHZe@>qPY^%YH+v{wyDLhOGq!?@$voNJ^7MQ@QV%-fZKB;c44_Mnkp1kNRzV
zStND#c(8Jdj2$en$t^49xqPihy=RRNqsYq)$?xgqjusR2wb>V5K<w9Oc4xsJo3r)L
zM~g@S#fvC?&0?aC+SZ(S$NX8+?YtiiDj<JMwP)LmMN=>yi`gvkSDXizDvkVTLRc5(
zH`m1<`|w5W>__HH&NoB^mUnW8#G>44WLXh`(P$sWf^TMi=$X#IY&FOv8p3E)Eg(;*
zj_3ae+?m;lJ0A!OSH8?J+W62_gcx6!5ypD|uG|fm`i*jFmR>QM5ocv#yN;H!^e*d>
zY+A`3(|!JDF<R~`De0)^_#E?Urr-9M=Z}8?9nT7xeX81>t9^GpxSaqv&~%nEkX{(@
zA6Y@*bj#!halYkhcmCBr5j|*Xc_~AldI?ix;wtZ{g57X=zh}4)yXJdi^xv&IFJ;fT
zX7%v)6>1ZerD7WdFQ>Ip2)+|#dC<1?sLiC-Wk%%FWcuy?$wsK;uzJ??#tY+A=sGyn
zbdN_#Gl94jb|$J>RkHV}lO2y0Zo`jR(=L89A!PFHTPmVa&r0{1%LWg%h50r@8dKs+
zv-g&qNqx<(*a%;NgzzI%;nOE?VcoakiFQ#AnMRW#H+=JY3@qYkAvaz2{K~>SN6?Pi
z)N=dTq6W2}E!=-6Iy-Xd3P70?;nDrkJTmZMkdWu1@~bp!r#R2m9>Gm{HboA&?j92{
zO}4XJiHtomU7n5&o>;H5ecy;sXp85kb%OGQ%x354XEdRWM2Mc4S{DS~?|+7<N9LaA
zj4C0yI>@u~ou!YoAYNGF2vm6~d(5Qn9x(){_@VlvM_Qe#41NJT?@)6!TfxEK$Pu3K
z+IfB@z0Gt52m5Kbi7=|%z{aHWlEFQs?Be}$k+U_st1`kQqC!R)4xv^8yKT!}`Rp+g
zT4yCn{&N#LIDOyI*5rL1-Hr}M{KS~&y7E(m1dvn=@742%t9SL<3hKBV%8VRIe7+<Z
zRXNDI<BFO08l!WC_*gDD_e*)qwJ~JM$k`$&NH8Su!&D13>GT#Wc#T(}%C49%o8V6|
zF&o%AvHXaXuF<Z;!TTfsv>E3-mbBxNs7T9V#8J`IU2rWF{w)rPHZ>_RP5t*eU}gPL
zoY<oSRUKgt#VY01*PXR=za6H{exH8ys=TAW2}x(t#d3=Dn2#^>%d}hjILv$roRRCe
ziNDLbL8U#im$u4&+2tdzk{c+uQ(K9^cFu{_4pK{w^BjKH!v(Bp>oawF#UpHcq*eGG
z#8Quuk5MuW=Wxh7QM#br8vL(p7ur=(ha*-*R`B~))8Vn0v7wPPISt-L7uaqN<423R
zx-FM5qSMqjd<4&Zr_bxGwY8$dei3pWH%;{;!Z_ZiVSvP#w+?t#ymeq44TlJoLoeK0
zkV+R{uMRryMV`?_v%4%OLhC#iP*dIlnIIL#mdFm)*Ek)$N47{vGjn(sCnyC(?^fV1
z8zu1dV)WC5i&XQtFo|G4jes^8#nDQOytBYrlCApqPUwMe!^g&PqL3RB<2h6xd_cN4
z1$Lnh!9WxhJoq8h-zt+hCGPJNX+?+~$peXQ46E1#R$3(6+nWBsOl#oNR9z`Eh~*on
zZ3}QQH_IGKNCKy~{)*VAvPgwr2zB`$x=+`NDdLzUoo^>wBg@4~68MdWH3sw>Ss_{b
zK0h1P??$Q~Q>))rs)AfSGeV+F%%UaYuN{z}Aap<kCmubIRr{#7S!x~1qMyJ+zEi2k
zJFL&+u!GV!(X~vR$R{5{t-5bOdw+Ma>NAQMKS^1(ioiZD4w`bf8YniNzMqG)Y=<uF
zZd%HY^&&Qi_^O>SWhYvwt@Qk%*?ElD;GNW6J#bcLVsWo<=Qs;iX^JB=b!$;Vdq_Su
zJ8bBhG;8;Zt67(H>B~aIHaqFLAOS(``e^)YnyuRp*Hyari~T!Z`i3=E<8_qT7Jrdv
zZtqu$fXdtpR**Q=ez{^^SsQD7gY)5mKh7F;wQvTKpOD2edjb$-u<BNCYkZW26V@&w
z|EbiO!_YPMwUv1fBY%zvcO9gXgg~FHG++Ejca8IiAD=DCJa93x4llb9A2Xv4Wfp7J
z=XXId)xdV+k8}1j>50&%{U9bzXdJ4Jo;Yd`fByIETZd2IG+B?NV|~eHv$6Cy)ea7;
zqDzkTrhhULhg>v!Xch+0Y>Eq?Go$Vuydd!!R1vv_>9F!a9wqLj$a%={2`%2Uc8%yQ
zuoorZr<i%mW~uayAc9eCp)$Phwxb4FEif@Zmm|hc?jzkOeM!=kX=q<=I}A5y9)-^i
zzakpmL%NNhf*+lyDw&ihm~XxK?nEmrlEI#eu*CoC5NW$)Y4EPg5C|fh-3An!Nt1nr
znWAQn3p<sQSENusHr1PBONHwOoAG2gQ6N;rA>1PIlA2zG1W*VOnrgKrIeE+jsHTk`
zr~2{z<=b7(<&sZ^>VIEDP(QqeDjTn-a1VzmkS5mHw`$375{3FgYu@u)S}mlyrRC3a
z8F<C3W=Kvm<vbGN<PZ<-PISr;j7!nK+kbhJ^nHdU?CDGvoL->6MN5%Rde!rpI>7v|
z$UT1C)%LiPMNBN^{-7=2yp6L9YLJmxd+cPQ{L;@xJl-n5oroyH@LyRfwlu?^q=2wo
ztO5LN5*M=$D-?co;OUy*+-$<6q3D<S*fY5kkr(^8YyI;>%FB}3<?b`$JRX%6P^Mz~
zG?s=+`2<W=Zkt?JD}4l#wggiL)W&S1xUd1)o4FL=`|(`^)K}64_k=wdp-1AsX$OkE
zEB5UT31#_%<94+lgD09@ogS;-W8`oqimK*fc`N>5eKY#w+qLB=0dIc?xmuanFi=3R
zCO$%-#YciDBJ^YbZ)eogkvfM3?s#E9YBq2TGdh>@9O;C3Vbt#3>|klEhg3xmhvD#v
zMXwOOuJl**q|OAJ41@dueWPIqR#^<uMeg$XPdd=6es)N&%M)+AzM1o|Xx}h?X`s6s
z7#L7?YR-93U|l$l%G6(N=4t+R2ZNxH9XkBif;G3oZ<&C-ko=3H(L)%ylyeqA+6Wd<
zcMf*4IaD_9?el)&8~B;BF=c~!%#b}lmh6OmW|F_eNz^n4DX?b_e7pRE`#FLup61=A
zJke5}Xc)giM>+V1zE3m))So1NrWdztko?90M(m}%fxzrnt3y5QFpFN>;Bj*YI(Y8y
zB_^x*4qM!3asD9od+g_OCAhIA;f}m%zPdrX#(LF{g>ANT&a8Hv>PGMC!2F(Pxw7TR
z;U+*SV@i)th*z~OdOrg(!_a-Nqgyq~a}V6I*TigU`D}51w)BdZ*Frca&@HAHe~)!j
z(>{aJ8>bJI_S?Ed2O^S|DTm8YqSs^xZUS8MjhibvV-<2#o+Q<LQ-`4qu<c3Ev(8UH
z^UMwgCc7XB4|nJ{oyL33HY-=epbtP?QfVewQX`3w7-r~-iL^3M?Qw-z99>~j$)bN%
zI6;R=&cws3k@SPo3l}@$0`CLr0eunXqZ*_Foz|^Hya0>tnKFrtU$gwYp&)h9YG{lU
zn75e@?u-f!ff=FdOrFBoVR%sT2!K}m8uR4YpC^SwO<*~PnkJ!i-v!h>Pm$tLb6P>g
zz?o9((o4?p!^q}&4ew@Dn}Sa+zH3i3-w~QGq{}t887_>7geWa$za*TB26hILgst)`
zT004FMR$Tw=N%od35)X-#;<Lms%`G4^wweIc!<Bl64sdaE`9su?D1s}d4i%_CAPlw
zeY;BbkJm&?w5I$O194r{!yiI~mAsIo<m}?M;m~U=0q&{L-z3-5?@1G-%U?22bO?mh
z9Hq13%0C+-%w^sJ1ZG*8UrHlisPeZcr#CXdqH=kde>i-ck}LPNtYW_?lYU?^pv=sg
z_R{VEg$TH*`=3XynAn`0bT{Lr3tt&MtP7J|Vf?zJ5cl)7C?bC@H;^t;uPvLk6%<?`
z-||(9O3wRNKJ7r={{|$qg0x-zKvX*VLu@a-F8xO}ei#5HHuQip5q_2WR*58wNusPr
zZ@}<&?udL}`^&Z_qJ|r77GY0B7|sV`%%zDFuBqkwr$8))s*9RsR?n!@KRJUWJ~4hw
zno5)-9Z9Z-yE`qv>8Jy+^r{cVo0~hFgU!&Msh;iG;M;k&E-yN)brVMz^m*c;)ySm2
zFn-7wOnYx(ig!vWV%ry{g>lTV`3_<*=FumpBsO!?E5Iv9l6i1oC}P4{VKc%`u73$1
z0m_STb}C5EY-YH^-_1_({VFD3BDWBwjB!)^9NfEKBadL^PrKkBO-BbT?^Mg{k=*i+
zGOrJdxroi5)5~r@^fKt3U0Ps1yRv4Op;hdK3W$IbN<Y-uCRcR`4_7Ha<EHJ70HM{0
znxB-WKa%qN@s_#JwClUsx+4Ajq&OboY-R*GhoGIfN9u5Bv3#ZECM!_<V03Al37LX?
zOd)p0S2_i?d}~%-nmCW{wK!eXBIJJ*60|z>C&T4|7|~(R*imLG7oWrA&UN&6_ih$!
zNvx(;?&Gg``8VS*I_BUW9VG(0^ek)W9#okjNxi1&pFj1dn{Cp+u56QhUPa%bl&A<E
z;EuA;jWx(iGl2PHKfDY#>fdLB?OL1q-dI-ggee06P+C5=kMXL$*8hNmwHrIhQht$I
zUPhq<ept}uKjdA@7(-jbr)lBol(>oE?}@EvHxoYBm9aea$I6SkhAODl&qdtTTpc#i
zrc>@lXoob&BvtsSs<{IPyr8K8lP|MhL7xI081}FpkLyYfB@%W;1l1!zkzcxe{W<6J
zUijK`@8`WUhSfKAh@QK5cA^U?rcA#xWm>pDb~039pScBrWiJJp64);K94D15Mv@2X
z(R=QLC$b<wj3v%6bF;F8P<^;os@{xgR5I_rg~L*j=MZ^&pQ;>!s%4{Sm05Y174wSQ
zOcty=5@?goBoA4?^o)u61{J)MTtr(4S8kvii@^%AuSDAQHu`JriRoHceD;^aVD~{W
z^D)`!{tbaxg`&hg5A<NZgtOhB3)6_OuW^4ZVeAZd<I~iW9<>cvg-^&|pg(<jyqq#K
z&+m5svy#bw^J;-@WKOshl=*+N0Et;D!Ec~!rwD=AgnGpiJCE!Ri*2uL@QP=8yk>ro
zt5A8`A}hy-V~PWb0Zs{!7$Cd<fnG>KM@%O5QC~v2BtimRFTn7c^-A~W1nIvtO(ouC
z^JGOjoFr9|tgF66Jcaps+xg8I+kTB1!6(H#(gAup<dtFGZEJ<-({Jl8ZNW+$hE2Gj
zeC39B?E}DNStNE$_Tqejepak2`Arz}Zj}r~6HTqjRCXDXsZBTw4D*dwu-IJ<6w5G(
zI51x*()=9y$Ge#L+gpoL3y<H7^R7tlh<jyP6Sl$@iJugze&#%^7u{sR7W$!&1%YBF
zi)uhII^I77A@x}~nAc?N?;DNS6c7AmXObdsR>eK27r(+DbX04rGA~#2xwVne=fL3j
zhmFo1BlBVN*<9QCNklA-95Q!I$Ob-Tv3sKhr0M-yMn(7t4j-(;G1w}Q^{Odxp=Zad
zQ>(NuwV>fc1bC_1Oxgc3%CqtfFThI~2FQ*;c11%Nwd$Wzh2szdk?nmrj(<g@)riFg
zQNBhdy#@MEd_=0}%42f};Vr3fQL`oE?k7VM_Gs;;XzUxB0)aE<pyQ0E@cy!guOHh2
zxqk~-+$mAJBh13jgiNT`7h^U!*nRXB$%Af+@_)B3UUZ}<#!o&p2Yt=Kp({X<Y19<)
z`(K$2L{6Z=H=I@OrUm}qqeGpZuM5>X>N!l$*f;UUp^_iM2GwXQHThmg!!#;>!3|PF
z#@6Jpwb-;ta<kJvW|Q}m)_k4)%dr}&>KptE{fsIo%3l#FOL<P(Lhr3AFBEoA8gCbv
z!hjdS1^zdux(F;DG<kv{R?ul++raRz#*(EU!WrK(#&MHMi&<d@IM2qdIQK7+cbf(*
zzf|@UVU{-#E>X2j$kAp%7>H&xvBmz9Inmz|`N?6xW&;>=X9^11MiUgcAUy1F6?FM|
zqr6tXt5n5Sk+)cGr!>wx4wHo~z4d5kZP!?D48isXHn3iY)yksh`;d=hvY<QMGIPo&
z?)k<~)v8N`e6tP#@ep36`6%S($zRT6xq9CCd#wz&QX^$AhnbL3Voa%PWg3v6fygSf
zn?6havT~~;EPaI~qiCAYGN@^P=r+y|zF3AGWP`WMFSFugduhTfh=JdS#rnw2tU-xS
zY1V0O{|nmfA2%GukFaYlRsTMSDN@G_#XOFFjIZy=7hiQe@SigUaY2;_GKl2kb^?qF
zW)ddyl}dmi<FB=q0OHBROy_Z*3P<cE@h)++3RV+YW#oN-iV*)vCiVU@faO94Hk%1K
zNg4n{<q3hlpRe?HZ;LrDRRRdL0L%XSXR%&D=xU8U;0?^Si2oV^SLfwW7aT!K;_Mls
zcz68bz)`}dj(ZR8Ji9FnKU%v;y7ef$izN#>`mUUOs5{D(46u3gT7B)bK>GX36l}y(
zC#|LUdzO~P<a><_b)+<Mq?OXNZuUPu4;rYu?q-#=x>=+u#LjWgl!7!xUnOJR(;Q|;
z6v)pVEA2=5fi`#90CKF-&ll8Sjg)hEued*UU93Sim^Km0@x861S&4SYXdD6&^xcJM
z*z0LWdd`A*6@GDmCZrg5Ma+c6?>lAG%e`{1xDLZMZ`i?Gw1vki<J^aqM*x$7`T*Bc
z4i~10tl2*7Gx)d_>paenXmHBu>2z%nrI@bXlQ;JWLJveLBo_l`t{OCakNglBeA6{D
z!`TbL$B7&;3!?=z%tpBL>2;vk*9eKI*3iBZo(QKjYk>aBW`$cKu3t09?F9N`;Vd5%
z#rzeJ5=CDb44~LR@5$pYElVDWF{4ALdw{Mt|9nXq<HqhsH;F=GMu87!YIyq?u_t~g
zQaMN{y*8_On-;a%5Z&G5Sy*d0c5DW9A6|M`DEYEsk4^fhVDK_W^V$IQ<)y31R3<R`
zNqcwq35pla^T!k_XDq#?q3E?3w>P$Xs=lyR^+T5uIMcbZ3GJuspR-vqxGB=V-4VaY
zqrS0L;%!q&e6LyX(a@D)Bl`ycT{AIUc*=bI0l>$Eecvwgmc9FE0%7yR@NSh94*-dK
zWek1tm;Tk(8je_U%Fpn>+5Ax59U~?H<iR1MxEtX{W@7j0{e0tJz&v@DyVBwI3p=6s
z<AY6M<8qxd=L0%4<=o(+xt~b>h3U$~21)+GYIoe-i$bFby%z{1IicT`;-N8&goH#7
zvDUmucIIfK*csxR@YJtx{0N+b)th*)MqP=m6m8%4>Dp2b1ps-1=d@o1yg=yE37^+6
z3#i^y%@3x7zK|FL)DOe3X#->}m2m`K-ZGZF#C5`YP(o*f1T@a5&M>#<@H&LC|A?HD
zC$+7)=^7+LSZ^#P@FOz>0nBbVoDbJ+-)t|#ayR_}5Tgg+1q^9PAwM>oW7mjrjh|5#
zTS{hy{Cd$Md{=^<$4rF)3eTx!NVWE}#D#NQiN+(8P^1;*u={_Fy+%<&JFT`vr*q9B
z9Wf+j3`!g_vDX89q_Xl<-lJ~4^<;=eimuC&$|h%udEO7@W;yu?z)KRwq#oC#OMV~y
z2P7%Ml<R_Y74ShZT2<`9H#=YuR&Z4?!?!$0vIClUJp>SX8FSA$M`eU(DM{I!({R{e
z$U*oP(;)Vc*lC;}Uybe~qmjzKvZ2`a;Z%opiR|9r4kX0%>mbHjfH6y$il#44yXI6d
zG|;x3i%@<6IOWNgt~IH8G~>Iabbxt<#KM|jN%Br2TvKwGz3Fck?Lkf)x0tUK^Nl+w
z>Yo^g=tkbh(eF#V`56-{;VQ)aHlWW5s>g+tP&>Q`UoHMFlKAniKn%Q9`AQn{i@pud
z<xp>3t{Z#0k^CQs!g8WC=B|@=kC`atwKV<U%YyyMvf6V#0KG7M?IIljs!c<w(FQ)z
zPGsy>rXgoEjP@|P0ekcFBd2r}(v(vn(6hxHKB+m+J99^MgWpilA1Qxv{WuE!t#tp>
z4ktbgO6<?sGBI?IeH%l%GR5TGcCm2F+bgOKQkXTVE7G1X+uyJ|dZT<ghELX0oms6h
za()paX9busI{7ettR}ca`p7nN9rZLXSV1AqmY@Crke51!9bYMXhs-i4#RqVw{$xL;
zGq6j?a0>ou@P}KTR9oXX0Gt(wxo6m^ALsc(Q9M>klJo&3Y$o*KQDf`k{GFp;h8Fm7
zgd(Lx0Q$i*lakfb8`$~#I;%;Lqnh?Z@ih~2uRokBvQ2Up>ImJ6%URK4b26~C=#mp@
zDSPn+`uWBSAz?9h_+3+^&on<yW08eHix03x7{i^K!m97_3tLr=g&B8JAW6kMdM(r;
zT;&)&h!k~SVeUzrx@;1T^d9j{Eq`lFJ#<wd2yli9MOXxa+3X^*7Q*@q=}(`!Ms#gZ
ze-WoI!UnV>U4xNmnmg)WRqx**BXVuu6$64{4N>&UV~Q6Jj5T@Fva^9f)KsdZjZt}+
z8PU^~KKCVAKY|l9-w5M3%t`&kl&6$es1*P6TUsfdclP13j`?LBCZP?2G7=%@kz8S$
z)f7MynC<UT-{Z?MC4ByE$hiACK_hu*0;D1rl4o|hKTByN4$NZA0J9i-e@~E5YaWOw
z6V+IqKkD39o)%nN%pTx>;Y^}<{Be}^C`qLak7hnl9q<4<OvrZ}R%zk+wnv%$!K~N=
zXpS};b5yr*p$i86wc~F?h4;YY<U$T?X7+gH-_yYTAKu>jt*S5D9+qwpknZkoDUpyy
zknTKmmo%t!he#Yy8l)Sf4j>H&q&uX$Tj0A7pL^fu{sk|;@jS5iUTe)Y=a^%TwdU}L
zJ7;x*tuvyOwwNgI4>Zy-`p}+H@-{4<j05)8E-^2TIzGK~i$t58)Dway_y*oxmYHz_
z=ra(hzvCY3D;CT|pIa%``go_hCtp)1x$`C=TSRn09u1e%wD)A+%`M=YkyZ(Pv<~>w
zpswj>!xe0xoNDMQ3^2Q2#E}2d@6Twzh0m5rSLlz)B^l$^xyL6}2_)cU7FA!fu6aGf
z&ay<hNo9HwEVL@`JAj$2O}N=d`-fbdWX)Tyev`k70A;X94$wCgxc=Ll0LZm~l9Z0L
zOLRTJzp$|EqoiA4j#AkCT;a8tZKjs^)})(tySinWbp7d33@|4w*r()({=K5;{}NAY
zdGBA%71Dy*6k^-G0zIqG(<*=y*Ndo$R!~b<b`}|c)%ZvLh~gq=J{MA!<<|m6fw|93
zNzG}ETUtxUFG)~>&7N906wZM$g&F6M!CgjO)QDMfBOOhLoE34dW3Aumi5m#a&Dt{K
zq33#M@wNC7x6Y!%c@yXl*Wdhhy3$uiX8Xlq?Z>I@m(AH<m5NSxNJ?uyE*-#1vyBQ$
z#Z0Dtu;M@8)SeeAS025xFI@Pz5~YBxmEI9i<kpTJs&=I$dro$_usr(qkJsC00}h9(
z5dXXkyfb&!O}#v0S5n~;iru6&>g~^7gUg|pm>}{X_p6F+TJK)`0Mv==#D&`Mzz8lp
z5uIXW<-Jd-|3b@Dq&Kwac~W=#RM_^6Dgn0FxXa6Cl;po{Hcd?qD3}P}b2j_h|L7@`
zGY}eGpGRJ!?f&cRAJX4Uh?-`qn|XvGvv0Z=!7xl5NHK)JKy8R=X>Hgxc!}Ax-d|=o
zBzs)<4u?)zjY*Oy0_+~T7c9E)GF9x2AYnvGqZD%O(0vPcK!1R2+Z)8O5Q}O9>Yvih
z<1nlONTN`8oTu^SGV9%_8>3|kz{tAdA|}cdGtVU~5nt}H?qWhbUT84^jv9F*c(=PU
zw|z<w(GUyoFolrjO}D7XUz}#J>N-34Y<BvGx2b1;t~(S?Qwyoiv5Cy=+J=kX7QO<w
zQXGRXY)MH=OG*XKE;UsDZSdwPvCst26cVPB;#GbVJ1zHx308^Gj@xhoh(1Skr~pu0
zrMex25q+pyVfB8+Dc>;tPESu(xzYsx(SEuxE@qFpGM|s)b|nI8qeO?EhL);9`2<oQ
zac+4!hed#9t@HoHG_j*^Sh-$)x#w}bkrfj*m;F66NTno9DUh+p&R!H^538W7D_$dF
z^X!L)wnd}5wIuHtnp)&d(|$2{wnN2xI6tx}UdYEhZGRQfQ-*ebXGzp|pJYCo7CpvT
zp8edp<1{alnpC^Za<6v3NjXF#!CxbI)sz@Zc4anyiYxhYfRBa4;K8>!HeuyX(|TL~
zO*3XoZ3b0dqi)u5246E!thDt@;T!SovPv1^g~^C=S&ISMY@sA!1{khDBkM>EeuYdO
z*@=_~QBv}5P+!iUOC$Qghq16Ph1+)`+vH&Wk}tsvxVf(#0$HR^lt7r0(JS#b5j&)}
zY#WxV?*JMT4GV-23=||&ybxGNd<S)FwXruriSo@aX2*)JaLaGnV5ld3h%3Y>#tw_V
zX}EZ^T`=J0+|t8j)fv}FiW<09q^VX#CV(i^(uJ~14#wdcCf>5^Asyf<7~B%kUxDVw
zY!ffem)7UQf-#2wt2c)pK;LT}6*Y=kOb_K8aN!ly(Zw#TJEE=w+)BnJI69eBg}6h=
zk4$`%qC5M39-%KtMzrKjlTa?3M}f-x8CaO8Aek`r2QQFtt%2Ei-)TBaGpj%7ov=zt
zGw_AAQmRWnF^FJ2YllDtLeEv_=3kPEYIzy7J=MTMR?FubVwO2;`o+s?KHGAv2;tgu
z3N;j~e{{bnQ5KiAB1!ls6Q~-2hk_N1Xl+Fe$|XfH>)b1xyG3*?HT&oil@<N5@!HZP
z{;s3Whtd={;z9-YL!T=oXjt(J@9l~ch(>%xQiu1Z0PVmy*kKy~Co%mc2=JwrFkk<T
zl+ZcHP=f!U`S^nt!KZA6Cl&^3rt}8cg|{{6#AfrJSG;RHb1iBAP(ET^V14n%Etj@p
z3E^Z?7JMXO-@Pj4r@UiMk!pftJw%-g?wuJ5_>}E_>jX(zQjg<5j`|n+l_B8cMcPL$
zn=jz#G_1qhF9fh}17(&5pw0E=Gg!*Mni<PJ0Pg=M37ry(8YDyYe$I^xFj4YOORK;y
zzbAYZ$UV^TWaV;dK<W=EwEb#EE_f>>=F&<fkzM)IPEn73GeT}crvxQS_AMnXh1ehm
zirhz=U+$do%D<hu)abrmQ}a+?VaNa;4W=>D8Pm~D1J)K_i^i%cnt8)%aPvE;O)Q~J
zHW#M;ZGBe%CJ6%IlPTVYEky}4TIfB?6VE|&eaTOBlACY~8&pEtU!i6qQb`{=Pcrqa
z?OpFpsBKGU8ahhgZummt)_WzKWyidso28G*Ejb6y^O|~cv`g`}-Tq>JfO6%Ekz<W+
z@a8j2O`9=<3#pK+M@~VLD{oC~<BR-1vS0w+6bUdPWRgs!z8@8k<CuB%LG1<{oCmis
z<D?a5v6}BysABzY-|yY~hY0G$_{=-ZQzY7L^W9ey8F+a8)yjY$m~f)8BcHdpz9)N@
zi<HaZLx^j$|0`V#;m^S|2-A?4fF_GY3-8(7k>-6b@j1x4JS74J!hxy)Tbg92?sw%g
z;q}7W+?q^RR}vd4C*cc`^$Pcjmls)+xSs+GM}iH~B`)A5KshxO^XHt=&CmIz!*6xw
z1t5NE(Wl#t5Ap%;()d~BSAQtNnq~_lL-&L!cI-6o;cv<TT(47eI2C+&goCA;_mlM=
zpL^*wsu%wVnnlxY!Z(#nXmgjk1~2)fU85xPaq@H`sO_zwNsFl{rg_;jBVflb1>aJs
zLX*71BJ1O1aY6M0D21#7x)?VWyeZo(C_!^d0}@cFN7K>ZG|9L$JXfaB#NnM6{AqCh
zcWcQpv!Vx@@rP2qR7Vz$u)6ND98ggjN~zOWHrZ<66`ey)l~giA0S-dVJ~{Q|b=UW2
zZ;TR_<6y06pb%CXtM9`^rWV;pYHSVHwy6$Fjq<<<4(6H$h>H%BZX5y@JKsZ!R5EiL
zDyf=MmA*N}?q1NeeOnmXKk$V%f8t$*8lx`EB3(*=Fn#(fbRb(hgb{1-VBTIBouw?G
zALRlQFGV73(A64e1JtNZ_7UQR(0*tPuRV|+u{h#@0WyS9gL4Q_rG&~TAU0Uzmt3IK
zQ-mMrGbSE5Ec(sXZG+jkZCj2fq|joY$XPAB3YZJz>Vvqy-@}5(s2mve-)wP141WiY
z-DZIeQRKKXe@oa2{nsSkXA<fb5++w4Z!<!lms;z#lAy=zOiU=0x3bZO=~q#}U-w!K
z^9|Z0PN^3slz+!UHxv5M{m-8-*yk6POPL<mfXy?CDX5D<B+9r<*%t=XFZ-K0JA{#-
zePh({v`c@Ox?n~)@X`a&G%oj5Zqcd37p5^HtVaq}SZQ*2;{`xHQEn}P^lI;9FY8Tt
zb{X4_6;N{gW`?N^&^6mTacWWS70tZhsG1V>LnX!NAR9FgST<ZODzt{{JLC^r5PUaW
zuXUXji|W(2Uuu(okXnA#<Jx#%o67g&@Id1)h77bv@8!JsaHu|r{3#buq`=NXbnx#p
zJZlJ3#~bK{N2@+!Ep1|S8yiP~fXKfTteBUP`=9m!(EN2({&x~$#NtCZ7ks@azvgUq
zNYE@$?9rEF;j@n<d=L_WHVY&`PH5h^G#Ztz#>$SwEqu(NJZpk^0S)LIKw;%C$07ve
zC;I%+GEqx8o?XhmLwqnN%{amU@ntOUJ$L#?*6Gi57GV|3T^(;WS}!Bd);+Hi#sP?(
zMOLAL%!1ZX7B+>7Un}`qJ3uB8ylFq5hh+d0oI8fQG?<+#0-1cb@p6p`{m&_ckZig7
zF>hRv8TeWc_f^F1+;|fXL^Mi-gN8!;rtf+~^(lau-27TU*S(^u&P?rnCZ9X}ku`wr
z7|Xka2wT<#?O47w!=NEkrwFrl%bFxeq>;4#%=ndPBs-DkqjKoY{RmV*=hL6rfMWkp
zrrTQeAz9nKDzz6am06?*_S0@0bmr$dK>F^E<+o6e$9JHQR0i;TodB|T1p$u*HF&)d
z?yeF}Y_I96`ZnW06lr(Ky}Avg?SD<kv+NsEoUq6Nu`f*hA4=~($zJe_2*F-)#1|k>
z+>|j*=qmi?E3_c&;aAM@?^)C`U~FqJ#(P0PM|u3A&oWs%1dtVL5U_jWvUsa=K0Q+n
zG#0^ldGqI*+!Mu{HMFNGdWtqGP3B|(+<`V5*3K(jkWRewcbH@~1Of>wAoRKW?6#f3
zQILhJ%EPYuBYtgT72dQ_KE<56s#Luk&Z-p#SW2c2U&isW-`z~TrMqmX+zb1aWjiXe
zZRkWUVa4~OR7LraQvQ|TkZe{uP-Fod&tHZO+DRK5oYsN6McYYMV!>xwLkX`f9BOh&
zN+U479+mYkonO=);Rp&RY77Mdu92rdXxR5}v<y^4=anL!XhuD~uIV(Z=K19t;7Rc>
zKS?rsSIlLPRYa_fQJRtaDSp<gd^5|A=V{5^HL9%tzVR;0c-zqZf6g7GD2?cI4!!N}
zE<Kf{1sn%*dd%8>_gR=x=^HCzi)oE#=`}qGRvp0nS5`;(spumWZo)qD1*h$8c^TuP
z;(uk}#V>|oQ}9(M^lb&x`I~NQNZr#7fT@DrMe-zhlo&2JYPD%Hio$bX3QEi_M3}fK
zWt;;yEbS7{aFBWc$n4~YB;~zKg}taKQ<K;JM{6#wjtwZT0N2+{F5l{us&QMQHw4V)
zQG|n|rheySj#s4s5vdl>@_%KM$OIl{?TL>jg{dTR<)0>MWOGS5WSeGpjNddzDt7bn
z10}?k)6%ZIi_}|2j&EdACy9DWbrc9p^?ds<?iNeHfZi9wTx_xnIMlPQ>H?djX-C{R
z!F{y6;-s-M9aH@V`N<GmNW7y{s8xy!5Xpd&lC4n61E6MHGrQn?r#%<PfUP9Na|nA}
zg|U``W@A;Ptv}U)AY~)ZeAN!Dwu5HIp1}W;BcBL|tR7wCoG22gP`KpGWiii;OB1F8
zIE75WKi()!3MSd#cFU8fTTnnun2uHP11!D9{y{}ZnwiHIZAj&HXffUAP8XYam*(g1
z*o{LZx1Gl4lrnEsN=jwN3k4%P*m+QyXbd{X!rVT&_=}j{%1<yS)@<l|lHbGZ2?!3?
zp3SIVF)3?UpY_y`UcZ<jVmCduQG=6;^!b3#Y4O}xb`i_BImUAM>DHBDfbtYxIgzNy
zZSgmQrAfbC)cg7>331h{#I`vuW<~(AHo<o6PZ_~XmW&c{lsO-bD!{30F#=n>So`|T
zj{UTfONm}-uz+(S^9DO)ue<Aii*qGY-N7)4SyBw2U32S?Axr}xi3htQsR-35Rd<zX
zF$3jQL(A#&9C2uU3@;@h1>%mT<Q*;68p~*x=T};w0Xu%g`8J`F3j1&zEjU0U?EUA%
zqwTc2&l_#h-q*wp0I6$bH1AYxV#94u5Y?L_Za_Mfnz->A7BW7R-qVoV00O@G^ZG(A
zJO&Y*Dqr+do}uQcXLX4ied@Xnna;Wq4;tnuJ>KB3KFsmF@vrV^21suB?sdVG6_`3%
z|M%HpI10<R4$>=h{fXY+K#iK&n$$Q5K7b+6Kr5>j5UZ~f9J5FS)}xkG)Y$(SEF(bC
zB6SHqJ)RSfpMo>VsQdDD(tm6||56&+@#-)Orm%fCJAHL+*=9xa;T=1V<CX@Xs?(;(
zeRx7Lol;dQPU1e>mvKyO$Q#~)XarBQTd1)tQ}EJKL|zVO6Y36>0A3&)0>c&#=XIYj
z+hXkYS|ZxZZGn(U1iw#abRV#n2EZ21z}GJPRc-2y1ZbSV^!w9J&IM4vH=(zSI?~kW
zTQ3}WM47ACuK36Eoh$N6YJ_TKA)?dZpEI{?&4o_Yp5TOizS0EwSszqPtVtNzG^HUE
ze%D0KH};LOWoA4V@_LX&tz&~1^(q}{#?8Y4&WCXatXBKUAxXO{!8d?9l*6TB?t9Uo
zmS)7rrw%~%$U9#p80+TKS*3F_{V<@UD2h;&VWda=j;h+P>(CI)4;+B_T~_ozuIDWL
z=Tf>1EnqDA%uQ7Ejti6Y1(#mdcpKwb&ULh_t2SJ;(L0mX7$kQxep&3O!r(%Q6GQwp
zg~3guT4RZ`nXpWz4faVF8#Oj39+=btpz{>Hfiq1s{9-Hh@@4n5iM)8aqdUKx;k}9L
zfrJ$s6QzOgXE{9}evD4r+^2`V7}T54^Aaj>95o-?F;YOl#`az?;s~B}y!s)WJ}Hyh
zP2OW>0I#6K^_X(P*mxX}w@7s=*!q2`9roRW`2;~No+a7*MQMONoMyw@Zvf0$2t}2*
z<tL!Xzf6|dHqQk}upXdJgp8dK58%GE+i;8-w<NILGUlc!Q2Q}o9%-oR^!l^jqW?`?
zL2u5f^l2f!dA-|_uFW__W1cXlt7`U5KYzDzc2d{VHT}X{DANBu<8gcOZf*$3%z`5s
z%V}$!qGizJ%&rk{wYGZJ6k^?R|F2p<mCg4Nah}AcIMeoVFx^H}f@^8CF5OX!lv>K8
z#qZN9!)u4xL(wOL-<1ur^1BFym8#;Z1?++cn@pEIkBkbo@4id`$v)y0LCXvzD>|7K
z3$=N&jL1!t0AR)|Bgz5*tYrW%JzT*Y!xCjn3f+9GIP{Ve7EiUd4ZXyL|MHFbY%MA4
z&Q^j45}OkLR}1j<p^eODJ7UjdtVH@<!tcgMov&|=>1&oe8U78_eXG>;Pb_9h!Kea`
z^tAS|{!{_np}KcqWKAuMcN^FQ23>b0OKZihT}jN$#TUN|b5_h7{M^8ql&(uTAcz@w
z!(FEfX<_p@gOU|HBDw~{4p-<C5AL1<nSY=Nd~b-|`i1K&V}NTaw5O)4DvpzWd6s^Y
zGUy4UE!6+!%ZPZFpTRwVBjnOAQx<kuj?*rqhBE*m5KLPdrbD*d5&^a^>^&!f0_uGg
zZ<e^kKR_0wvBJId_?55W?+MF7reLiCe}-&Djkel&;pO%Bl^=Dv5(fkWo_Uk0iW3O!
z(jd1V>_YpSd_AM|`Z~6pasa|?m4X-npZ~WAp$|?{;OA71ApkKH?TzWtiQ}hi)YtTU
zPpbet`tdbBW?yBhTb?=)TQjygalcF5<ogJ9=4_2PG&!st70>CpKj9-*j^}hs*#8sx
z8G1daH-Dp5OU+oBA)r|HP$Ue{-Kb1ymnqfHnLZFh5M%h+mz81Sgvy<NCjj#etD3b=
z%gewda{j~PUd-FXgaQA4x^vFZe%vg3LllX6U?PB@TBQ(<l~7Mf@^Z;+PQCaKV%p<V
zYs6)`1t1frHhpCWE33e;B@9ICcbzgDq}P4f<adcxD2;eH0rsg`tmHDknmT7KEaIts
zau11(v7@R58vwtG%!sACASduRvUaRiExb+_tfhejCKfLtS0*Yy+E4^;ffgTJ*IEl_
z(w!i^fT)NShMPtS+EbhqAk~1%j#bjByBP#z*Y4FoF40KN{5|6`YVw*39ylBpyxDT<
z6|M}VXSMYRv6UHfFFErn%eVnh0aSQh{sz4a7_4JKq{s6@A+_$-3R*#)?W~*o=^^2`
zaL@*ol+1TA7P064Zs%2LJ4zs7#r{0ZY|3G7SUN_-gs^`Gu{iv~!0(c!P}=`6rkXSK
zg6CK7x@N>fvBCCV+SRw*qCd_9w9in0I0mgxnD207oCgjn6mat!U!X4kSeM&xe}hPk
zR3o3yib(D>jlY}+MgocJ+yL?P-(VRLcW?ZH%d;o|(a>}n;}#2LU>np%d-ViBa8JqA
zH{JFzJg{;t%ONIEt;O%Xh3&;<dHO<&he18!gVC`)-U(33<e3<)k!lgPf=tHEb>&j=
zZEMz2fQ%)!U#^1_@X+L-VDA-k@wy_E_-AZRUz9i7`j(UZnI$t{y>CZV<vx&n6Z&ri
zMy&z|1A$_@P>3jyur}B0^@z<A2mV01IhjEF@~cCEty7e~n@(9@aziIGXkb;~-_4}i
z_py#U+c8Se%qz#CaZ9yT*IJM!V`~+Q<(1$<>r%x-G=1{D-~*8&+U_qm)54KhncsH@
zg%A?~_Z4nH<Zt;xdnhafMlQ@z{=q^Oo;g_QODNr;Ga;FZT5g0vw8-(H;_`@NTDNCp
z4T%JapPrUNt+duF+HjOJy#ox9J$P)bY`Uv6=a*N!DeAE$nZ|6t%yQtteZdM~`68Q}
zbg}j&WCUGZVc<hqhjAn5>CVH2`?g*F%NlLs3Et)zPHi@uKS{5JNL^9U<nxhIZE$SH
zGkpde3yTUp4x}Nsp3Q#NQ39|lDF#lTY|7XI7m)q~utt^oI%ih(QC$Rca?hb>2Y8c@
z46XB@lI|l8`!C`DsQkPsnXL5+0{(et|Afj3*1XZRe1~L-|I!LWVfGp^^7Us2w6JvC
z%PBYyO$SdI*>@BkG7Vn>2B3^D(cmzt`&r?TXb${l5oi>y-IpbQ!lUIUA61-Bei*uZ
z@V86y_*r@1PoGus;kwzmHS8&K>94_y@0dgG51GtE>Fc8KC`gRiq-hM}hFdppVk$#7
zMI<K*#Es6Sl5OIszMMDzSoA`#L$-?K|1Q#w>!PfieJb9of6z=tON(1beoq_OLrLjS
z)@QcuOqM}Xe%T%ZIU?8=KCYR531KByY4B`1*(_(PU}8JWY0MDm-GGRdcteBm1+I60
z0arrMLI)s_1om|w-~I9I3RZzg#ba_=uU0OrrU!9uwftsb$uB?lb+S;JLw9NPXleCa
zz7uAr=hp`e={ZXh+mr|wIUgI?usG@aNWDp#KH{(@d~GNA4fo1YH+!;iyg;1Cx=qTq
z)kNl(bsP@dqc}U)=DP#)=&rL2nGyy5@IS($NLCGIITrS`BUW)ic-lUb_BsLIw4*6D
zU*bk;vMXayi6|xa|4ICKD8Wb@+8$7dxREj!=&Bd8b#o{DHFkod(kKs9L%!Y@Vym-1
zPML_F!g;t$lw>t*{bD=ZQXt)G9b|%|<WXVvMVv5|Y1{$)A>{4*d83$`($6(AGBrG#
zJKOR%N;ZYJ*fAp34`aj3<=)qw4wX^vi`(OQ$C#!Ho3e2EE!?}2X&jG<^CI9XwpCrl
zkee)fjqgrpj;>+hn+*S)byMYQo2O>r7{34u2YP2fnmQwsbXE~MX#MvakNGIUOIt>v
zyHp5K*BSUY+$u7{lGT4>_{7{XPVKVcAsBu1B|KhcXX59TuI9Y6+!tl?N|l3|I)BhZ
z@<32_x!F%uz<Rkh_QSgd5y@tZX{gfdjZ?1U61phJYvU`*izGF9TLXQv(TebV9`=|s
z2~rqnld3&fS921#>U}uXNnKHEMe}u10|!07ZhtM9)V6Sp!|9x3U>|MfXII)YC}o0t
zJL8m=37%`GB%G~t+<y0~uIL^w=I}G$dV@n0e==DB*=j_U*aRmnZVBB)d=Mes6?=S2
z;(_}bX-@jr*ZW6=s5ZYpy5X!WpW41a_X_Co8KMX78z0NpCP#lIofPBE?4lx{I@z)2
z@OBbQaY%R7BTSx;=MiIvAVn~~`B!HR9$J-_%NE@5DaB_#SyGcOu80L${!Cmi_xGtl
zGgsjc(&sVD7b@>ULE3vGe^ILh*q}V1_NQ~YaPf#!kDl}wP;SmZnmerDN9PenI#w(?
zyj_H0n+gF+v%F#-EFNi%bY4G#40Vm)mU14JD8rW#fNh1hdHU>+SEUp61^PNr5AaiU
zUjNgV$#2j99S=^Np6;I;=P%q%%;(d&@!ShSA3!=GB@xNoe+b4k^FfNu7;w`F3$uRR
z;+7o5C#I9H{<T*k2&WE_VY$x*RPktA!-{s|gxtKaYS<my?u9%@8@nmDg1GH%=F{sL
z!%IQUHH6r)N;oj~wND)3YGzD%n_Ax>&&yW3a0(wU+D2b|kVW)gKxjOD$TnX3AyKMU
z<h5`@)9GiVi_P92?6!!ujFllTRIMAnr>Qr{Tg+u8OFI+u>+?)pw-YD^mo+RMDRv<Y
zpEi-P$dHaWtR#HVgRK6LK{=#N+T0zJDB(-(jRSY;FE)0ncBU^)tUr#1RDN)cyT6F{
zcW@nwg(OAQDtT>vvd()n+H0qGnZzvIVYSqgqN$yE6Lv}ly7vIx`;wH?XgoQcRhs_u
z*3EV$qEp_6BFP7%@D7`hStASGE)8FCoib4+tm)HUTEtzOH&8{pN><sLo@vEYwIH15
zKb9!aUoxl^;<h1FK%{bfmQs6LT|ooy8pq?w?z~nn7m%WQ+CJC(+KykwpB3Uht$_fe
zKK#cq;lKVK?{Pro(QoS}ZnK&cH+`MVHQD3^SYd->zffo}?-h?zj|ly`rx&Ct1>SLS
z!+UMG?<2{(;~jZ-1>oM}m)1ftgE*W<>gfNdg+J_N`H%^Cswei_4U1hVU}t*Z5Pn1p
zbLXCfgw&*xla4+4#yLBC3$5r491G8wNiAG`SfOeXqc0Wptrb%30Q{xxm5jw~O|JUY
zEBAl4U@TsP?p-uxNIJyD*t}sS_EZeIpI*+Qk%?(R+zWz0e;ZBL4jW$8HPzl`7~(d;
z-B=OKEFf7BQP(&#Yf#l>CA57?Ox=XODN&mTW~Xnw#57T;z-gp&+hKUBPZBq6PC&B7
z+hCDxMPzSy=cG0ClTrNrD64UvrKG<2z+qTgzrhGt$x}|2(BE~LKy$bmPPkpszC6~I
z`p3+h@z$C<Metc$Oj4#s7iuQTBG{V-xS3n_MsY<a6-4yQ;={_6;@7%@(?;+mGdXd_
zj25MbTwXo!p6fXBE9%|}ntjMi!62R*^%<Y!wih9EpF+vKWdwK|@0{^SI;4rjA|{2b
zdHv?TpL6CVrZo77SZ^4HM`(75WT{_iE?dc~ptrX5`2MzvEPHF)H`<nyUh-~{bvhsw
zkw5Z4i;yd=Ww0n;u=LC`)v7v3S6ip7hZ2$iOt3R%BZ_p5rR>)6rqSCTxmhu=!8zck
zemUZv9JWT=@E0)tkq4O%4>S|v?q*xtt`qqX(FhEFWMXH#%r?`bE&ZyB5$jF{HA_Yg
z19?ryQ_T`zJF?=OmD*DLX&5YeHL=fXVokEZ#aW6m4pFbwY>Ch|CHyGwfN($$&#l_U
zpTVI~^!Uy>rH@S@a+rKu=5K{6L86_jD##?-9#P)HHU3|14r8LGT9Pu_2%kRpS#x#i
ztOO%{QG$n<UBhs0>YPk~q;)&pxAr<Od2Q=vvM)x(f9VZzQ>K`GLm7N(nAzFX=ng5t
zk{d>05gv)B<Vqsq$GoI}P>Q1B>%u)8!SYMZ>50DIG_`3I{$|L4?C=yWl|`K-oUTJb
z`WX}b=}0jdw{N44p~i<3y;uQc+i`<4d6VV}3#ALXEs<Hl@u8L^?j&YvVU_~uIE%RR
z%%YJmme>6tk}zNYi+a<*H&2X=%~-sVsR-fQ=7*>Vk3TKMefzzHdJK)BA!fkqJQ*lO
z-BRZt59ahSM+~#Ri!}-6e=is7cUsMC@o?G>!xwVXK6H<aNkeFt$^)@kgowV)x|2+{
zNk=#+KTBID^Z7<go8=~u$L`fv-Rj)Kn3#T!y&lrB@gXk4Bf}k??x4DLD1mf)U_Znb
z_O^7D*b$4DpQl$C_}x9xm9P<%w4Z)YZC2f>*Is|OpV4Vu<^|pJ_La`)MgzClGSFO&
zs!5{)1Cv*w4Q@M7NB2j|bM=ys<S*2bPfzg1jXlU)sUvqdPPM*rE(sK&9aos)O?nz?
zK`lYBy|)jsMd)0|7AMflvh91s-wqj5Zfq)@5~bUExmD0=pS42au~CJ>lZ~xQWU7+w
z7r6bSOsi#}vFlbwK9w&Tw}G0zRK2c&@#X9Z+eZtqLS5^cU^IMQPA91;ZEQDBZ|%3X
z6mObXhs|S$*s9QrRntjkyb@Wp>MwcxAjYh}k9MZ|IM}WH-xqT7eMqY5tm(shx60q{
z2O#i-q0leM>|Ys?eO7SPhWy$rd+X^Wat=}FqxgQJj^jwuLRQCdvGQ%cI(+H9(<`Jn
z`)GO8ZK9Ye`!mkGKc1}*K0smKf(!gzr<xL1uf9=U<jVuQn|B0%O?GFHwl7D?k;*&T
zSD!}7Pez0{TGN(TOD9CdUzWY=5!uS35-=!C>&;TK)GSg+K@^CL@s@9TO<$VGt|v^-
zKZ-sYzBQG!CWv8S9rNytQ&wgWEP2MdGSm_Ss@fyD#hvbDz8CC0g|tkuD9F67B3^g7
zs_ED?ikM8)$quAo!Wufis_&|id2P}ACmtRr3`AH0?bow|%L8SP9~lMBc&HCK09b1u
z;pWQlYVa429!1(A*<S~$q_1uabhJ2!&M%R|dPDWd7NE`tuI;#2IE1xiFTH!eMR>%!
zG98~G_3HaA7w~_EQsfJFK?@*7+*_80@eyT<c&6-h2feKriLc$=?a2s58kcf`J^LML
z#cfOBN+s81X_?Ib`{3uKh1;VzE|1&)ZzrKZ<QL!{8_ULRsJDh|bLB>~2cuk7Xs^H7
zIL7)R<Z2&USMrQw|Gt3_^Ky;e=xhq_A^+W3sKTZ-e!CzTwt&CbWh~4DA1m^iT_bb(
zw@6x|m)3Hqe3n~w^pM>|Q@W-JS+WH}fDX0<o7crwck0D5ibL$+=kfHVM@=TD4R))i
zs<N+<WCDJ%-^R#T*)|hJBY!P7m08m{u%dnMO~>9*mQUPEmnQSuFOJ>YoBvu?p2|BI
z7+#GF#rZSvL_6p9s4&PGgDw`VnW2`{D-da#3}H`%Hrp-I3F9C!67KwATX6T%h;N$0
zl&?IvD$*x%k}=>|39oHs;B*!dy3vPl(&#}gd-ccCjPh)w7tk_3o-eWUFJ_yiP=wTC
z^a76lT|OFEI_S#U*^lq|ZHCHqMJM}+PorDj_sCOcViP3faBar%MRMWr?0-xxa|=F1
zbe_j^RrIxLVO9z=<>D8PxsOk_lQTj_k!szJrB$tUho-B4t6Defp)BSNK|N&HG55Du
zs^={ax9_kr`+B&<Vr!+WLSN_x`F1p6=q>siY`g@&l~1*uEVCe-p?3@7VJ}^dsc8uo
zPhW3IbmQ%XlZjP~LWN+^gZs0mFO|sXWoEqa0%nb`@bb#O7C1z>zHKh8;7FtW+6=c{
z8&ij7_fi3MI~~F<5P7D_evzlEE4iW0jM;x5r20+Q%+4m8>Aw1jq*~__*M#4g%gJEh
z9QY_cgCkk)NaoVP%Y=ldr6Q(iE*VgVkg5-End!-`FFQ=@(K&GD9lVS=41Pk&ut!v*
z&p2g-s`<ooOi>T&SgGV%UDbONn_2U8UH!<44R$s&MA-qMB|?2jgfXm9<mLl6y-Q@w
z=?5gcYrt5-H)RrLKD1c^hiT!#;oWD$_v6-(BQu{NduI$gUriUvKfFEsfZ-_o&6II(
zqw0-FVBh8)z5rSENl>P43{05mT{?XkvB(cdMsko3X>*1C@Sw|kWREJ#wpc{^$K>cR
z%zRIYGHc*NG<EPx$f<$VZ(#yb8EoR(*mxo+nouLq%M_yaLOSGe^WE{urL5gT=8!lg
z$`Q(u8C=kxuW?D~br03W*NEJBQ9UCeDCY38zaajkP6lC{U*(|YI3iv`fnF<}1lz=F
zCx;YNWy03LcK5C0fb-P^Z?<C*Np!%yD<_+w)*Y52<`MmcPAafJhMSC0*H&w*yV7-#
znDzr%<4)qJ@GQ?`S{p~=b1f2-5F$r^fq)E;a8ewUCc770{VM25V2lkSEqsm8$Tyxn
z*eHBkb;J1Q%&V>dVls#WbX$?Gep+WYN;8*QNnq?LS5KBd8_QOvJ3S8H^l{@pxvUZk
zo;Y42ad?Pw*Z5BO9xI0IPLQbGMYK1Y#;1zQMfE-5OF_FU?(XulLj63&l{rK)r&hOJ
zbAd>0YZE_`rb3`eNeS7WX><htFBS_TT%V7g^9}YuW~gK6bMV<T2xo|IB|)0Wks=i(
zL4R25NOv<2bo>ri$PF~`Xr|}h3S7@mqh~7@o*;zY*rd+)@oOm)JL)h#ZXzk*u_EO8
zxZ_(S7FASe2jYP%>CVw@H}lNcUei;rGo(5MS-(+@T(~sTyJ3djSP#d&vT*)k@+K+S
zMfQy<g8h?+X_}WqWCTCA0MOwj<I@Tip_RkH4hC}gW~4_bK3~{nU^d08)XQWP3EAC$
zJ%hr0w)J&qp9bSd1##&1$aC5;_4o?a7b*GekQ;frvM~qk-sg-w_#xB+EjxOPfo@3S
zuh0{%QArejDVb)=Z;udPzko^tnQoS_`FK?VyL~)~09)N}lZVXtvZ}HIB{nLN%mbtt
z1caX~OLmMDqULTPlM?u;)?OyMsSy#A<j)@|^>$H}Hkf~jk6$gHjXl;rml(~F{AG%k
zPjdgq&$0s?a8qT)uvnE+Wzs`p&qq$I;loq+NA3XCJWuZqI-Q1tI&>}wdlG3{2GDzF
z#B{%i5@k68qplmm!Ks#yk+hn~havoJr|8-dvE8Ug1d#Rqno5dtmv8_KlbY3AiPOh6
zISOz7liUbcZ_^+@pDtA{E~5?FFuDuk!%ajkd|nb8N0rWFROQ8pZq5iXRIU8;!q^U+
zgX*f*$*Zl^+B?mZ#Qg9Otz}_>cq#z|VxbF1@Iv?5xW|f9P(_QG3<YtZ?R!;(+ClHY
z08^*k6?~v~mZlxh9*G~LcH!-L(iKmR53P|IWn*Ulj*8MKE`e3P!fzj$XlBB7DE1vU
zozuqf?qjoz`wiwvb(B5#GQ-+llsoC%Bhhsq2}!E;<8~E0(85LG`H9i}Mu;y;C@3?S
z#sxlDtg{k}-1i{ZhoF#e9n}ikE_kz!?lLb|;0*D~@!qB{FO|}*9u#Uozs6LB(&)wh
z)LG~xZtFVJc%IO#=LyZ7z2*eV0vYWV`D^t?u!2M(l{e6cSvPw@YDvPnltUbmS<_J3
zd@d$~!+o;Khgc1z;1Z-@cI^}Z>dK)Zc*Sqm;Jb_Ks@D*FnB6AI33TYSOMHH?`QWT9
z{qN<Bl$%J{@DpX0?KbyaZhlkzx-Ow~MRg|&g^=~XPSRf#Hkgl1tQC1=0jp`YHk^`j
zxmxsy#2!>BAh=#(57k~EXT1YV^JWt0v~A0nXr1&TA;xT2WWNs-<&oMK2Npr`ymb$h
zXr$`RhAUke3_5C}rna7n3W;UjmrG{GA`{3Q){X8!sz}tmzZp~KW3ycO4fKCs1X5Sp
zal=PqvTfN#)rgT-yZN^3N4@D(soT?+?vbsdAumtfiYe4m2pE81mQ>tqp6UK)DAV)s
z!>0@xmT%!3{6EDFqCcKdg+waJ&pZ9M!3&<PDcx()9~^Ejom}biTMxmUPxdv-)!@yc
zu*0~V(OnF``Q$K#e#K9*B76Yti(b6E=Rf@Clnc;-RYpDbq-uQMW*11wMt;QN^vzPU
zkN)#5j0xgkhs|s1^Sm-DFrhGE7na`~t|})&PgfIbKY6$By7o%?nI9P3<_;KvYYuC_
zZhL5K%-W8JJ{d!8e)xrdu1s?$DKD&b)$W;a{=LPZ^JNQYdo-ev474Sh%kLTL;#+F(
zO>-B*90h=M`ubzk!Ur>-67Rr`gEsFg<b9pfj8tfua30%Y1&%TqRB!Zpcf(!4P8%!y
zyCmU1zK}@gbJevy2&~f(kZ%BnpPAk#7U%A4Q}_o%?NOBfL;i<hg>i@hG)Y`!qZKL;
zI6o0#Fan9v3ES|PR`1?26Qf9(j&5(*w)^gxR~dWS9HqlY3F5jp01ROd*nne4k{BcW
zoL1B7$6r9ewc7uEI0->on$+Gm;()b&OgC9=Iy7>T^XykiQzm2*K5lRakYFULzbTGX
zX#KmSjZM-K6RL}DAo5QiP<8i{qWDPll!m;y<Cmv=oLqq0rYHaNsed#&h(C%7Pn|TJ
zlLU0Gt{Nt4Wd;ss<<MEDRsfT6%Hf4VrGKi=G6mQLqiuXEw3TlgPxj!KThxvNIF3B<
zQ9IwCPxw-`kcz0~ToYKcjOR7m`RVFxK?2@4D?>T74&RO{OA;ac7}~lJLeAqe)ne>#
zJ6uenB@u6vo|-yG9Q}D*aBF;9a&GPTaR4QOJNK_v%mRs%nkIN6BJQT6J%4wTxXt|Y
z;kRlZ;2Q7!=Y64_{fK>nnS`@`5@|9(t&?w2qJp7JrhMP>{qV$l39D9`)wt(?<<UO;
zo)x+qS8dNhzZqB6+Msp7$m&9^8Xq+yA1Ue4p<Z`+CuusgI@!lkp}uqu(5m#_&&yd#
zvc7E=sKq$P(qS=t`?Vv2aJP&tz6}9KG=`-0;RklmvGw&aYP-~?JvV+WJ86BE#qU_~
z9BYOQC9mDI99bgJ^OVQ;?+hdkbF_YATbX2mG8?#ST>uDzxQQSTI91&ZPK|5p1mk*y
z*<?d{SV7FigKhW5kXFs2!mY92x25y&u8Dgg>)iNur`)B{&l!)l9s6Hoz~N>vxR-Zp
z5l#3hS?VkgQ_tTFxfz&~_2)SOP4q6s-U^TuR7&|Re2q!>P?o!;WjpK7Vr)kWSDW`Q
z=&(|FliW{uvYgqdll>tiFKh%M7yI9lRQy$ZwrE{So9i@ce+NHxo+~*|GbAmtXl>xh
zjKp8^JN?S~0h&^`JJ8H->)DMQ%nOq+WfCFCVH|Dq+_hrNZg)ixMbT0$T%|9#W@8MU
zU*zd5e)oFn>lBs9Z$6*X8GoHy{udlIS60P*9Ulj-2N(d7V{=PBQiJ$ja6R^+vq`)=
zy6M_&uSuHM#l?vsu&*$l7ow%KSNzjyxC2o&onGF9YA?9MzF}YfgT12)Pkig<K^~p;
zR(QB26Njs(Hmz;E*teZvf<W=UXsTOXZ($vtE<$ba1ZuD0iBIb$+@c()?yYEQAc310
z8_>(p4d%Nd-tau&&MM7u{xwJ_6ym#U<rDe4C^c8XpfV)pvN7zn4pEvmT$5IX6sL1-
zwCQYXX5;@TuoCS3`=jo%`J_j!?Wq*LJA{Uyh)}?;H!bozX!v*L$rW30XL`9sAo4`-
zw);A4uK_u!j0_^+*J8h*rB_<eo0^!}uA%jUuMy(X7Ddkm3Ys0x4-8jt)3~|D?RNu@
zpU$>%%Hj(|H7V_b@;!h15p2s4w@km)I6@sV2;5)?O&$msZ>SM$PnLF%u0;LWHhMFd
zCEU$tG?cDJCOPZ@>yzjMn?Cu0I*Ur=j$Bsz^y{8O%~VeRFWsXLzo2YM+~wsga*O3=
zw)ZG>*2@y4WoLY*Nsz=QRJo0Qy%L2Dr#F2<zdcj=LaQ6{|AKwpXKzJQGNg9{Oy7ar
zgfGv)DfAS5TI<VD4_Hsf=Xdp^L_KO%G5u`FuBNm-W1F`5KALtO2uX9FuAHAAZ)z15
z;AESNr(?W+L47&s-Mbp?<7~S+bq=@qcaLY~>p&&eD##0&_30k$rnf0O6*)cqrJIRj
zcqg*a{5|;E@PD-cyGEw(;6s0wIf8pHP8+qYIDpp!986?HKMHJm^BplyoIHuHXqvJV
z^*?_4gKy2V^=Y)$+P?aifPD9?*W>q2W7Gj&syFw!Mk0sM&NQvSlV5z9)1&PK@Abg2
z4Urv%R!gh2LMBV<>V-eb{cQo>&2E8aJKz(~_Cqj=pnuAwHT;ysY7lV8j^xiXpbNA{
z9&Ga^5~zqiI@5;+A^Z$#QL)W8f3+NlgdpVKTGz6(h*fGFKG`@u{Yt446JQfQv%JEA
zV|6ynn3^u0yLZsm)f{}JC)an410q%`vZkgVb|!zqpX4~}i{Az;v(imj=<Tl9U&Ry_
z#)HfTXRpYo2?1!G?`<n9vyoRw5x|o-YJ`(C;a1w||1gfhB>MFaK2@(jtL+*oh|*on
zNdP!er5bvL|27v4Ff+Bm`Cd_>_V8|h84hO>8T<My85UOkTmO=;p9S05^#Kv_cM^j9
zgQ=<7Nw$d2#cKsOR2?<l1a}HxpwiC+{hG=1xE+%%jCccDE_h+^*NZhZdvGT*KFNil
z#6+Qb#mE=MQ2XcDz4km|J7$@dYpR}_*b+vm2SUSAufjsRp{ux_jcxi!(p8V}S3yp&
zl)c=d{*AZXJOZ4^t*xU<Q&8Ta!aPpb;Ty2pIx(@2!=zzIE$Vr9n%A)OEg{erx?T=&
zqPV-WF&1jTZVN4-5Eocq&j%xV;VG@?_3uP_n+K99m~kGr3VhpdZxB9)FF*$TFLdV|
z^eLd=ZyDCKAF|SPsc_M>lYqhUY(1gdAB;u>I@UoJLgymu_y|5vPPG2wiigo1g-QW0
z_!WYrrH{czRUXvFx1k@a9e8>+Pzx!=g^m@09O4R=L(rC*LOlY37dyjs{J0?ec*uQ>
z5!2=P>X7B)pfQ05|2Wu#bJ<NY8)~stt+r)UxKUt*UZ*up&q}ymeYKh;J*cMvkX1}<
zP)}VX6<P}#Kp94<p^(%2ZX_<v@Q34{!h}HdbBa!{p1BhKx7r3KjFKA^NtT!&;@f$S
z-vS>Y2=mCar9$gXCVal*AB2+!W7Fp?mx-*M<*&l7#_j978QT>826YEe(&Ge6Mlp@n
z+>~3_?-zFx_$_Iy^{3a)g`t7qD(?;{+dB^NziwMHZ~CHxmk&peC+>~W2Pg?<%od?8
zrLj-iDBq{T&1+~vQ{(?+J0ba_&t?>0H2!9eow~h$Dw=M?4kVta`wVogehtepB0Qim
z7DetixA9{~6Wp|37@Fa?FThKkUO`Wx;DWJIE^@(B*(z&=@$Kpj@<NLHKL6;i??3c5
z@NKo0x{$4ukDBDoP+S~0D#>$XLoo*i#(DO|e#>%+A$e@ebruoNN`m^nZZ}2S4Cixw
zrji=GgY*H7@5df<lz;~EwPT9n=%Lc-t`~VeL@<*nAIB#Kf>*k-=oSs(^$ljPh|f2?
zF5<A;xF(8EjX|%E-RKdt!Q<tl?u6BIg=9#C8uu!+FC4TRB^*zJkxX$LJ?j&BIjD;=
z$Cq5Nf6rb$Agj0WJ^oJ0ZYh=mCO->c(}4kxc)n}zxmZ_)91JzJrF)CemR{`P3$3?~
zZ;q0QopAa#l#zY-@{s&=chSwGN1`-exqr6(Dyd_<^cq`=;9q3hLBWqQMr+5krwGSv
ziD3Ju%gfeMpwIK&kLRb4URZE3=+zKx+*Wk-+bu56%e^JSiD@93v-zCWWhWottE)Y&
zuMe{D*et7Hz|?cMnZ4_^GSeFwzGW&o?!0i7%&!+PdSHqGddEDQ?UGPH7sjx#6Z<SK
zgwN+2U5$pqczt3m)^xfW&n|vLAWuoMI-lu*K8CB)@x{5{RqJQ-Avqd*vSWB1fSBj7
zM+h8h>7i&kYZ5)L02-d}#lwJ~Ml(sDYSFAWM$GXG=WV07espAxY=qYNl5N5$oa(Ew
zQKX7Tawg~d8A$7aNEVq0pI;&kf;Xn&HLKigS5+&>;vb2%HHiEg3q*0Ly1WVW?hb%K
zb{TVJl9q_wzAV)iXS6`ZD*EFjnHR!-T^hrcd%yXzMg-+8Dq4diPZfvv{svxL7Z|RT
zY+oK<BhHeV?b}V3`GJGXL%FygW^sXn*<<SvY*L?X^!G2j#q(j}YptjrwG=0*+6u5U
zZ4#DRVa1h5o8Mz7+(RR_(F{7@+w-4mX`Ynu+4`IANtToW_x^$oD(eEqIetQ=0+oH8
zan|Jp27C`YCGV|A<bi<noVm&i7Ls4`PsEGDp_7?C(p4e(e4|%!*h!ibuJpXQhtf(^
z?;>}Ww)g&>al(R@;q5n>S>$7q>b{`$HdHYyv%NMeniU(4Te~c3wCt_M7xC*FZ)F4G
zOz*R;S=#ribMXZ%;@BG0@XVeDV}JO%Ckp(D*0P(R4aDeTr`q@+HxR3wZr+@)l-~CE
z#xU1BeqndcB6{o+JS2Ti8k=lxs6;atPSWSl2N>4ht?9dewLr^Ff$}tOIH0*UeMR;O
zCpT_d|Jt^Lw7xL*HfoHS&o@SuE(g}5ca<AL#%9U!hcDZW%`b)Q8kGIk<nT;lCfq~g
z$(*@AnmT+&&0ZTF#)3M$yz(CA%GYiB!tzd1=Wdp#SsU0cu`n2nTheaZ_k?wW{7(6i
za5on>|InmM<fVnpa)AN@S?h*c>-gF0sx5RXlc213EU&z=j1P?n3xtrZwMW&vm)CNM
zoKWP-PEIB4#pG$`#638+-Sj!IM#`+A{xRtvUx%iz9}l*W1GEI^GYkqWjB!M9VwYS!
zIdANm0MhKPIfOihnY;XIu(%mZ9+NSG|LsG(-Wu*S1)k4lK%~2PxoA6Cwt))NbJk6T
zwziLCjO(as@7g`{QM=YFrsER;R|)v~#1p)wfVpaYj*Ig=&je@i1dvCW#<cx#lw6d1
zK{eF;+7>mmWb6^p!_;CCO5+8|S%|~<S2uAa)u5-D&&aLmQtMa8F?CyZQNk=B9E(6Q
zC!xQKzhf*``da`R1ou76{_Un>@=TB_m?c*MmVjj*JO8jH<S@7vze+osL6O4uctr9~
z?Mh}E&JVTtj;gKTn=GEHS6m+cC+=;+psetwozS9SES6VC`8t(Ze7c)Sn7sBeZC`E!
zR<9FY9sl5HlUAVt7DVfLt^(404#*$}XL%bZk(sNZStkVs76YJshp1|jG095af?lKR
z`kok(W75Sq(}|Jk5lbv<?5FyX{d7y6Om~FdZzR0TH(QNvzBy7(0`3}B*7D<hu9V#$
zG0~rXls`yRygs^Z9RdiWU4XC#qF0~_P#EO?Zq*W-DzX8tXK8Q<E6Ox;2)pkk-cOoO
zI9r>Qh8xN;FF^|}DVy^S@VzF^R`CC`A2jJeQoFx1b)NhR!|%7XJ4*Lq<jJB#D|Ra;
zJLI1hc$=HDJ378IsZX!fMq(zw(REoi3TW4?2s1oeF&&C0yc0Z^1;wDJhykRJ*36EF
z(p9NBX*k_J`9B4`!rdj%8d0pKhN90uJ_Hbwm3N?R%~&U`OuyL1<(S}Wj)Z#<LipRa
zJ>N_xR%;%JM(<v=!7x98^eUCz6cqz-OTbPAM)?23PYLf(%L~Ap*|}dELlVv`%Fp7T
zxNH5~Im)6J+qkMEssy=T?Vw%Uj!i7X&xg!}AVEqY@O*xiQ3X+xNZu<5x+otL$5+1T
zFh2w+xN|52>!BFsLqttWi#M=z50?p-$$7obZOUB`HunC<v7*E!%9|0v$i)B-(^pma
zRRUF51zXzQ=f=oe2x_T8{^rdlk`|!DuUhOH-yR8wpK{_0jvmnq3je^biYNw|Jfevq
zi-ACun)Qmn7souuAkV&~SdDXQ(be^o45=YX`)yr)X73g7c=WV1vp^`V_lrucKz}cW
z4k3~oja5LC!Jc#BS<qd{arDTz8K!=F`r<@~&+iv20kF1+04omclkApClmm@G2c5u+
z(fZ<;CO`NXxOO;y&TTiDe0Ss*qA66z?$<)We!&ZalFL>gE}ag5!%2kx_s?-Hl^6#q
zwykzTrrrK*Ke4@^;0vl7)i#WxBfb#J@9xhQTT!`O-$GO%mk<X&KenQI85tRgw=km`
zF!H$`u1M+qc?Bo&)me5*i<0f0qo6k}g1<p!F#hySOUnw5A%-EsqCF_v+7)mbi_cEO
zFa@}j7T$tIAe?lIJ*UFunhT+0JFhV*QhuH7q%&>41mb=aNZ^9xlIf%c5bAaxV1xWQ
zxYYO}j$Lwkv>CkE<cG701Nq}K1Nd$W@zs^Vc<aRnH`Cm7@eF4`^ES?&)QSQ0An)Bi
zifp0UII0as331Lt{<8@KE)@5~E_f$ZEh`&GCagh+FM(miz@m5(iML7j(i7E*unR*$
zw*g(HYo+KWPfH0T2lg7z&fqmj4<z~M5y6`Z?5+a5<j3=1T#lAUm(+45$?q7dq@WB_
zNyqRgTSi|ZCJX9WvW)mwmejnjb9{(k5kM9;XJ{XQN#Z@hS>=DjWtzHv)Pk@w+JcQ+
z;ujF&3>V*gZ+j%ceEbP8N}gw9p;-)|cae0F;AUU3vs3dKKA1^y;={v@93v7&`Z&3y
zHk~dD01%dEw?cc=UfA*kmxct~112tTKx}&78vQactd8;I!>WY$3g5Oq@YuL#<h-<X
z6b>JR5?3^UlW$Dm&Gmza4|iahDP-;_Fti0{poJLljFQiu@msSWm-iDEH&&MDB*}eF
zcZ+PkuLO?R>e2m{5df<uiJo7rv=|`0>a{9U=T}@CHwtV|+t=N}_Dc^qN6Spd=D=$u
zUY&Ek0RU5Y%Q3n#()3_UDm53}DEuhgHK;nc1qbnJl-7^I7?~28l0(uMkr2Td{umDX
z!uaSGfu+ri|0VH@3$7>ON<~1QoY9<;!L|>#|KUlLAyy;V*U$T@HC;Rz7L+s=F0iWr
zOd8b^MA`ImC*7OF=z_4Iuup8&IR*OOm+)inFrjr@Q%gKtp=HzWZiwY-Jfsb@MN+{q
zuDRGoQ~>&Omjb<?BfNQ4B{0U-H~wqgYBd_<rL-IhV6ww!Or|}w6b}zAxT<tELH&o+
zgw=%dv41#wxR%;m5`*}=)I~QWKG+tN3QFLjrEu{^5G<TzpU0j>m`x|}-kZv00Cd-0
zKF^PH{O@rCOMP%bKLkgs{Sq~#ZJciVP=?DmR+6+gj^bZrBJ~-gDs$H|bT-qDs~j2U
z*G<^Gsv@gmD^Q2(uR|0-SNp9Pz($_Wd&bJe{yh(`?5t7L(HBvMkt>j#N;gkgy^m2^
zRS!BEXW+s!^!!W<BM{kyV!e>C5wMX2hZ}R_Z^F_a1dnNf6>504H@3|qIu-$Q-wngT
zx2D?7sgfCULn1R1wnvX5iY?$=cEkq$+HH6~*?jcH05(OP2`bcs1b315^XmM|!_d(d
zU^kUeJTnvTn(pNwMvzsoqI`&GaCGp{u!EVZr{?da4tOvL@vR@9C=a)qjN9tb_ZM*p
zaf~Zuld141X>%$f(|{)ykb!L#y^xmc0+065A~)SfsuZWaUt`1B{bmpEj~@9}^CA7C
z8UK%|HxGpBecyo1j9q9f*{Pw7UB+6L%2-;EJ=u#<+4p^`)L2U>gOnk{gp9H?AE~5+
zC}d5tWf@zt^FE{B_kG_#KcB`q&v~Bvx$o<`?(3Xqz!9+uPJ5+}A^<UGReTiDq!!J-
zaY;O)104U?-aCG*0Bq}WOtIIUwpjO=pSZUfgx!i*2ht%n=<1o@A5@Vy598jpLWNla
z+7!uHN4U3TZPHnaD|M9IJ_qz?_JbuFou=ML?3=xqd<^G93}p@E;f{m`nY_B9pg5;(
zAE?k%1I?eroM!mWug)9tCgJlUeU+837MKQ8+B7iJQJY{sLA;Nz9?F4vc;O7P2Xrm3
zU=-XLa4PLoX`~GUCj1=~1^0kQFoo1#xVT?bzj*b<8?YSu2mADM4(t#VlI$M)s$+hi
zFn|##w`AL5!ZjYrJdRT7gpOnl{H9n@!1+4_I=76j^8hNJI8gY;!1iWxt7%=OIOBrw
z1g+ekr{0`cNqV3LCu0kYGY9-}e;F<~=99h3ykQY4zf`~t?;VJo6T^*aOWB8>)bM|A
zhsrvAlCRRPcUO_D10Q;{TSi>0+kTkT4|1#E!F_U=JszH=nvIoC`rj{!v^9A(!<*Sl
z8(d%;G)mvZ9PzBD<Dm`zl}<h|vI1}=LvH_dmDn^TyaPO<8|s9P*5~r9fXpD6NT?+|
zWfZ;`)bVSX+T^7_0JifxT86#pB?-H88zZvuh|qDU6D+I}rk+_n#UqGk4c<gJTLyBF
zIxPofrPr@B8MhtXn!a@ySa!Q0d05nA(;e#oRdCl;TCFPxeM)zTxwAoF<E&31NE0O9
z8u2^BDlxtS6SUQ)m6-yT+HkfPh*I%J`kh3=?-*BPs<c#e$F9=D_Y5%ZVSBey(Dpzc
z-0thKGk@|5eyEV2+{Wl(T~wfXma#bjtT*%g(}O{w|NZLjSVMRW8|^0rY0&(+u`U7Z
zgRZ0IplYYns*cfz5j6&VeSNrOmW^Ph6gZMESZTTX>B1tld%7QJnIOY~QEf&bD<}<8
zxF9zt+L@Vm2qO%3Na3Nx9(*MpuM9i5Qy1Uu)hO;9Nfc^i-QMZE5AIL15SYUQq3$M%
zx_92Gl+tDk&OyT#1Z57SQPRi0n^H&B)M-O`c+kI?TpH6{Kye|9wf2Q_`Vsu1Ibb|0
zz^{c&ovL(n>ibGji3QCFE(%12?QsbUZ7$vilmG8I@78m|gE*3MZs8UVels2X-+@4?
z9D8k)0c6kKc?1u96-SSY4<OX9BUI_`!RFGVg)jX!s&KUqT4x%S-rv!3LN1+JQmS~q
zlj#jWO1WQZNv84duBiRz4MxMe*KvO@U8d>EM-Lv?U?P;O3l>a26;FCp&zb+nEhK!*
zoC0hHv76rT2e1e5;3s11Sp)T^?s$tdf?Ux09KMm@VLi5T(7!rK+nmY|MiAse0)c62
zvUBAA;q{blr6ZXt-$v9}pzR7h+~0HeHtol$auf$jEG0KR>zs`s-TdXKh~k~ss=>{C
zHLx1djZ%Ht7oC@MY1!)c?KW=*u*&)wLPr(2)&uvCV(R75r6+2(7h_pM`&09?J3K6M
z8EWcHZ!t%*@UtIkC+B8_Wc2ioKcNd&zM5|#_@KW0>~HtzXV2T1p!u(70gy4f6X5d(
zZ|J`v>&s3|->~&Bh^Lif9gYyX8YI8Lf(rh5z-TuM<ymZW&35&$R@gehkRKDyl*!9q
zn^C{cao|UwRR=@=@5dC~a|w;2nUY5BBjGjM{jriU{xPro<cnog5ynipe(PUHB1an7
zxPDVQVr}#;xZMWPcjqAbG_Wa5!(dZ`Kjegq(nm3nGW<0%W;i3*LRv?nOP=bP-61yP
zyoG47caXVLrz-57`W9ksdR&GhMS`1;)I93(%F*v;QWw~$uNNZ(pG18Qr3=9*n$TkF
zUw8hF|9UKCD>ikV0e7C;cl{(~ml6dIv&eI%Fi@jj)t5g3e>5qyNj;QADtdhxOgD-a
z27*5%;pD;C&DhW$`r*bgYI9)#=KI5jx#CB=G26qDA)wSAKJE85)QRR*$ONHi_;EPW
z--++Sb(AgK{ju0??75T|@fO(#Z#r+7xA`rz9YhF!&1cA=^Yz=XrDY0967ukM%2lpe
z;T?WL$24t!k%JM@U%wrKsh3#1R#4mlDoOvyHep~WmVg2vTa;3kE<f^}<NL#&xo3N4
znuRZNe|m?yP#!(X=l~Oi?Qv+*4}0P+=JQ#kz5GzKeb@=U6zY_n^BGxu{Ilcz#%({H
z;NWLWP+q`?Pp@!~t=?1)@(oCYDJxzSv<v;V%;@y7!Tpmd=Y?NxyB+gTLt<*-+Jmu%
zjxRH>>HXKWVtgrQDHPhpc-^CB`nMI<SL3MKd^O0-TevQ)>`Py=;7{tE;oWHT!ov+D
z$dUn%VYUcI1P)<Rx2-U|o3{Db(p;4lN{Grk#@;@%O^3NjW$adB%=t;Z55S)CtB<j5
z!P!E;zl44w)Gz*~R$mT#w`ln7DA#XNQ~HOYXcj1VJ$pFPZZo{X%RKERW6k!olqcUd
zV}*X_B>r3dT8uY*bvW`d4Us<%Hr22_tvI&~yyBOsqwq^^@9m>I<YDrD!6S!`TUv`6
z;CHqf&pJI;mI@Y|p+-NiV!Kw|Fo!JmXHgVZ7YgYciT*_$sjJa9A_~`rn*{4{*1)gG
zEQVnPlVJJi<mVlM>-PR-k|uNXxJLfW<H>W%PK&~Qfn$MV=P$Tb44=Ju|K}@8V|vhB
z6MQ1DtWS_q;KyxLFeu6b^>jp<A%lOU^z={ul8Wp)f%0XflZ5ZfswFZ8Or`~%Ff|^I
zMEmeA5gOc)H{s71ynNR`QL3T&xCXY8%C-~TG9c<>hIi@4_AQ-@gT~4y0s1^Ub_`=%
zQ)d#e4u2t(^_KB1!`q@iRNF<UWS8=m5)IdR)p8Z}IdS+rsE`5K^<uC~#8Zy`dRaD{
z7dnUvb=#aV<POMs{ruqhbVRTt+XgpSJBu`!Bb}(<`ma^_!mGoLlCR0Tb?1#wSu{mB
za}6}f>{yS{JK1A~dZ8v~+;rB!)2BBN!!m8^3A^v0!pwnnX#UKF(_tUsYNms!=`TQ4
zuK-njv*HPy+{X?*Ix$Xlq?6ZYN2T5pWZlW_$)3tCr+&J{Wl5+nKYx=NG)H@QGenF|
z&9-vz;<MnBmWoN=`R3W{)7qfD5r{RF^BQM@h?xD4`=a^qTOJJe=qE^!ol^lJvJdJ!
zNoGj>iThhdFv5@<rR*Cu)s*&i!w`-gijFR>-y|N{Wdt9#zguX7U8$7usje5REs-of
zZ=pAdVJ@S4+g^VJ`BQOBKKO^y;yI-w8n@o^(DH~NzTR8!w@3U9aNcpOR>%C~Ln}Hh
z5S3n^P7>xRAcy&HWE+<*SE-b0L?mVX*YkWh(!dFIxvl<4>WO~78p_E2mu`W0@O=H=
zXpsUL)Ej623-_-srUoAqNN5<CU+aWUUi^CN_}<9RX4vVhfr4B60~qo*D2hRtRkqzJ
z{w(DffDi!^ev&sFgBN)-CE1~oenc6gblqcH>^Tumy9KJ)W_a-l(~R`;TAgEyr?3;^
zjCB2V+ieYOpA0AJ8y7*+Lr6Kk793fs$?gfUnQ*SR$Km=B2C$oq%S^5hrFv4^o?<WG
z3ILvhdPxey%n7&Dt5s@C2EmKfJ50S2CGg-M{OXe6!UejKF)|~O)!@QsCjNUEYA+=J
zW>Kb<iV71|had+|XkHbQ&9URi*u5Q8)oUw(=#GBI$TWTa`j+;KWqV|?QN4MX$T$B1
zrf(AMne{?GC%znFnn?IY)}{mm|BzTbcUvz7A<F_i`cT=9I1E0S0s?;wx)AwfV`!I=
zm?&EiMikn0XPiEN$9LT`c5%Y~KAzO)Ge&Z4zMO^*|AqGa#g#g!#-BM)O%9NAcS$om
z9X}yH9LeVN4q%gx`4URQVccJirP4#h>b9fi6XKBU@xModo+^lo_^qRSM4yj5LaqJ$
zOx+WEe!{e{y?<n1g7(Z8-xj?dU7M}lDhdEjj7p_##_6ZX9KPSE=UVFKYPlCw^m65@
z^+7Vp<wi%E97nDFnx-}tXJH3!=~>@R_?DkG9QnB+k(p~i;wpHlFZp_iQy*$<i_&lz
z_ZQ`3;4_c=FBDbEH85|TW@yzu!UWT41C0H5<tW9wSEAi;lVR#^!`$Iiuis~X&BK#~
z)k<f1C(P7PA74<F$g*YG50ur^z0dgMwv_;e)%zvEtC_pldb{L&`cp@ufL&@>(8GG~
ztY9Pzm5oKopnu#&hJN3E7i(h^U-tUP>@yS>X#IV%*vzRbr_E--vn;HD&pHCHlYbUl
zB9nKr=~KM08uw;}QOr4~(M0fPq0;K0tQHrxiR6W0EUc!iXS(hg+RIGYpUIbU4Bh{A
zh&UwW=^K4}LncIT_P;Dj9mOps&+@9j<5;@%tBed$Ace8ZZL!V=-(Ia;!ujMnTsq&F
z;BojO!e{*_MOy&djQy=y<A#1}FWGY`fijprnmH6N{m18<M1mUQcX`FGSaR$$Krmu!
zQGuUExGy*!{fIDl<jL(K6D;O}D|fBAXQ-7Zs`gtf=Sf^J&;$zf!K{e&3FfS$me`#N
z3BOkk-3+5@A6BQ^IPzNSKJUx(JTG^~RaPYSgT@Ro*}|DpX8n*X1C^c{ur3CRru+N(
zMlJmYkB>XBeXPlcS(IF@r<Yk4^)Yc8CCA#JdJFoID?t2U`!24y;!V-U{k`B+XlRci
ztHoR#*;R5<_BkOiTv(<+ef<G$%P<vb4{}}#AX?O@!#+wrSM@*7I2os=*!YaT{V()q
zdwrNrTCfO8<xIJ_OX#aun=bfv=~;<NKim}99{X&HPkYk!_(kkQT1VI@#j&aVnF9oX
zhS@(s!%!5*PO$#PKcCRn1xV}zhlP3S9q{&?gix5sF}j-VJ<2q3JZ2eZ#mOgtpJ<12
znK<C0@lY?{y81qAgxr^o`TuzVQ0O_WF?RqCJBYkBI(O_ucoceG&zvxYsY}zKd?oLu
z{w6Q(ZxKZ^^&Sq#hJM;B2#O>fsId_WiYtdOiA~q63-U6m?e~=L%-qMc@!aGo$2|;9
zsGqwUf=oRHh$ENU?RxqRugi}OzbcZ4Vr_{lU~PSQDsEox8=@$H*D$j>hQ}I;AlXE|
z|4_--v|n_`80yBZ4r^^Shy#5q{l6Dlfa!b!1Hf_pJ!NP_WUUS7ymorD`D>zCYL@SL
zzz4o5VZxvE@V@WnU}}0sV@s_9y2EjZi!sj_z)Q3F6>1CLBua+Wo!&hsRmV6o(f(f-
zBkl#I09;gGMInD!tY%xRU3>%}WL>52ddl5UF2K4sRqL?~pj5zu7a1ZX6<4YU^(4$v
zxe?^O8@N@V6bSad62OUZ?hK6RmInbMnGlKmu7q|!34Ye&Np0e-aI?tG!e(f|t|*}A
zjH(h13x<Xx>3zYsn!X2r#0uK{v2hZ6%k5KN|7?+JdYv6efIyUy_^VI$hvo^i$NhT2
z&U+g8SnEEG^wSx0B<+Y{!fEg14q&6mN*xfD6O7TNI<2D?`}tyw0%E;xTaFr)Q(vC8
z3@jCueg?2?CRaJQF=sp1%~RC9n@#~v6UDc<0)NC)2G82C#b9oOxlgHI<eW$H^mFVe
zqAwQwB-jY~gz`QaW>;ql`7p8w_C)<QI(X6iy&z!3W}7)R`>aVjPYGIlnc!vGC}!*k
zb9fqIgml7Gt!A5U%r-W)C>vncP?S-Agi+9hJn=I$|C9D8it!X%l~bQ$M5G$85EvR}
zsnsPnB~Xuwf5j%>sXPL2W~GgB5+k(EnY4qPxkRLHF)E_bb9!UYbJ<i}0RIx<IVotY
z3j9Z*Gj28Jx5krh#P<x&EdBEOZF}mTd9cpQ9mWTM%bIWY<eJ09qp#x>n5N>Dv%i9u
zNduk|b_JgE^L$qxjy$^bhSK&75V?PY+?`!Vh<B-x4dAQTtWTV=y2Vcy<q{|ylS~w|
z;AXa(7dtiYpwUmI>L8Z?cvH5{+IZ77vm8ullaQj4bjpf6>WeXvsxH9KpT4I2!k-sg
z5dHyfS}h_6ixNyf-V*@L9~+wv?SIWG7g6zbhH*?~L75BrJ7?vEmL!8dc#}7^edorS
z$?qxxE~vlK@mqU+WZ-`z_u>1Z{F~euTVXKI%EOIk=H-bXD&lEV`RDot^76CJ`iI6}
zjKzWMzAgCr$=@ASuzJ61wwoyXZi`L77SN?CDf?Ch!7mKcMhoImM~%`?7-cp3@M15Y
zJ(Kl~C(IPfgVa0or-zqbO1iOF`RtifJq5wcauRcUC%L_oq^9Rrp<J!-+{I~s?e289
zQ3;ntE%(vjSAkgHUuf;--Rxj4_Rb~>iAcI1`xR@0^Q>a8NCH6~7S43nMjYG9KW2W0
zTeA03!`B-v`rqeVrv9wScR?i4N#oBWaj6DjHy#W;OgfBv%8RTv*$|QEV!w>*WST#k
z1iFphY^%`KeBtK0X2lgr(dJu)NaO=}Hrz-@U(vaHhIOnKYEZ`nw_WP}8h|06*x;zk
z(=vhU@VXM-7~{M+NGB46*o2jqgX;{HeVFJl36)etClC0??jXuFBB`6wO_aqTP~#k9
z`Db)Qe&(=j(7(s_e8jA_L&NeI%hO36P?#~UlVx5y>CYEYGKVYf`H0@1Qhbfu_+min
z4LT)%=Y(vtjGxHm6vZx*O8au@Hmi8_%yKD0^(~d*ia)kh2OTtSXTE+_S}}>p{MSF>
zcK3NgZA6E=5~j2zm*PPr8N{a1X6%oE({a;2{;@CTcViN<2#j#1ae5%rl91_R8=(c}
z29xwPr6q)^l~7H06Z-|MCOgT*S2N&J$LHd9Spf1q38BuoGKcls5X2+RKj@FY|2H$R
zP<Rky$G@3~54mBcGluH6aG82Uc@me(q~EIUoNMEr{>!>qCQ0)I%Hi<T+Ua#u^4UcE
zYossz`^`<A{>EHZh6)xRd)(d$jAim#2Q*tLrgzNlCrq>IqX)W)zQHkl?S#+9MAR2O
zVzJQqlP9cy9vNFF%92$F1x7Y{r(=I%Z9IP#Mfbh-^ZQ^R6@<{XT=gq?d;EPT(KI&!
zhcikitRfuw^hGU<Daz!t(%>Y;qe+@4QKHX=Il*Ev5Nd^&Y@8=x$kY~1a$g%{gD!M`
zDJ+64XI>qooR0S}L|wDP=FrPB2s1ZWtUfAH-b0LZ5NfZDB%YM1l`LdW54+K2LmSSP
zbVUu?UD;<MJ?eHM77);pXWeVaWrKr><$&bc!&ucF(tA(Ha}luEq!j$S7(J<!hkK<{
z$1QK#jBP<XW+QAT-<>|^N!OmIHN+~;NehHdm#F}Xc1xSs6D@Jc&w9j9Z4jra2cNaZ
z<xJN;X@Uk*MWW&g^8?2Pytn)%X_P}eei3$&&XK;1e#`gc!X?U0Lh-P)S0BsdT+O2R
zRzGu<Zg`YTyOMjpNUR>#ru<|~o>r9avxYn9tjp4NqDbq+N@(zg!q^CrB)PQFYg}vS
zl7Yupi;t7=SH!N|8)uv>%X(rNXG#bS7)h+KGH*($|6wHt<`f;QEjpH`g?su55|E<a
zu}F!>yA}OSvy;fW3)wMzH{{ni_iw;_6={kq&+#F;nf)ia`WxxyqLIsIu)<tO8MusD
zgnC{2_@PLh?^>AMTFNZZLs;{U;^(lB=m6btFGhJT+I}*oz=@<MF=8AOk|hpwTOH0b
zK}dTZ<gVsQKk3#soSaZ8$`~cpek*@^)*<H2MeMNN>-?F_l}mfKC}993mhg1sW#0(F
zX&*sK_BS4O7nw9h@x^al(x{rov>0+OoSeI?QRT+zJkgCj`8@X6=y~N-$S!;QU6BNb
z`jvFozEcDZv5Gs2eiqo8O}}Y7iORurgPyWvd@6F;bWDqKiYIO&@y2LDm6+=k)2zeY
zH=Wrnvb_^Bb0SQ6;FGM92f@GyiMNNPoISL#Y)sq_dZ;*8jr2_e+uHMQ(T$A~A2FXg
zbm{r@({d5RP?-Ke#9rOX+)F5japPzO<5KsEZSVb3X^1W-i%=Re`yep2^7~>gHc|p(
z&G`1PKFDx3_d)#Bvxsv(z*{qIr8TDAfD>ww@0l*f`BIL7K<$(ISneg6B;4I2^xEdG
zjk#xlo7EG1h$PA@0WYTCT7<f$?W8d_N4ZJSnX~^X@yhVEHrXpwKl4RI^y@7t@S(RU
zu+F-bOa}>2l4FXm#_-Rx^kj*yBz!Z-p@UOr0!*Y9={tE{Rg!N>9@(fNs9eGhb0Z}U
zTHhjH)4!jn@<#B%5m7{|*Qtc!o#0!l$J?*%N3_V6n&Qf0K|Wc#>vyB8IxhA8p`aTN
zz$eC`;oC%(!j>xyiEX6ogj)KFWJSM_#E<2jvh4zF4M*FRO7*bAVo05Myj-k?)ad#;
zgFMsh;7xVDB^?#}p+SS%v>Q>*k9#i;c>P*OF7ttmG&G+K&T$u~NZr}hljnjF1a8QT
zHYef3<3e$s7`S~`m2C_g*2btnnoDc2=T}%Cm=h1|Fc;E5uk{{}T7%>B4aFA?siOF&
zbrD+b3cr2HP>xZin+p2=-v~QirX*V4HwFQf-O_eP{Mr|DIeQ7|h$EMc_yrKcC&1==
z>bEmH4btP=h@II6Vh$4)9A_+r%6)(*i(d<OI_rcOJCtA_U}^g{VgXZ{we`Ism|NwU
zA78gOYTO$nskZ}s_NDmkSjWH>Hd{xDb|^S+p()x7`{$bfC2}Eue9+FU7}h2^jj*U!
zZNC;}nqt!>6D(klL^?8B(MA1;`|Q;l=bou0-RbX0Wc&;zFM~Xj`;fo}8)6eT2n=I=
zzNUv7yGYsAv+;%-;47i4k{E0Hw><hBd^nZvYb~;i5|vg7_;B%SY-6@O^>L+@#&H8U
zI&5p=jcjWLIjE9q9%Xz=97R1mMR?Nzo4NOQm?5Y4w}Mw-DjHMtV&n5=jbkWLKH5L#
z%{V*(sJRr(^&~2lV2I5z^yPV5a;{r?l8PgjNNwXv234*+ah-a61Eg(f+SEaI^b22d
zQ*{Lfzs{nN6>|S_ZWa17DNxCu*Xg=*!Aer3x!iFmjFuq{k-pj$j(W>v;`XI$s>jz^
z$aWI9o<qX-g7~_NMF+2|O614<#@bZFr`eA`f1^i)azq!H8h@e2Z_=VfnDs7tZX91@
zmEP;(j`wr;csd^XuzhT)KcSMZ4BhW>u04B`7ko`3HC;D+l#zq)01L>+fiLyr^Eei6
zdZsdeM}|B@&$*8AgMAOs$W=;Mi8}a(z>e==FV?p@U~r?8^aI;^rDRTL29+9kr_xYa
zyrMv{OPaRDw5FY$1Wo&lD93f#Z@PlHbEE&ur7tRkRA2_XOyB04h7QV$Yf7cJodOX_
zLV6mwUGT-JPpp2^q@!Owu2sjc_VG;HylFZl3$hKjy4gYUs)bj)QS@uhqoQs<J`x}E
zG<H+ZrVH^g;b4{3uxh<-!g?yBPM*$>6TNWU=wNP3--5tGR;7+TT`aJGNGDnR<*s72
zRIHkoJeWSF{L)W$d`N5bZHu8SL2-;5EQn7(N&)47q^+-^bDs^;w_dUQ(_1c_WpDI*
z!4g?&l#y_~H&#=klhl*U6RDLBa;R4=?22Lf8wZ>*AJRK<g>-5tFFOL9Zj94?NDyOG
z<<@V{>aH#`q>o_AG)P~QUE=;Xol`SgQ%MXQNLQ7sIQbMW(t<fMFJjzd*BLhUbsQ3d
z8-e|6d3MT{*CorSeQieYMJFSP!%nW9%<3|Ah|<*31{PZ2V4-h=bRdR0_g8SZ<QI-s
zRZA6Dmhd59Q}+oH1SrhT6XmFJQD=v=NP&^;6qlirwWrdf+qhRp$rmjDp#HeA&OH`t
z4Q(&_X_YLp^lv-4!-bf|4Oqy7mJ;y4bfcjB!#4;ZOp~<{B#CxG1PJF_Rh1im8Js5;
z<81nL9LkT9Z>BYt@Ne(lVj$qs{FvS+H?{L&{7*UOvbat`l;F5j9on^znf|@pcobFe
z>ey9tu=#6ayxGJ#<MC>DLvgQ6Qyep%W-~-}S2&!o96U6lK7Nt{azUS?L&;J9VpgS6
z<!}aq<xXwZ?vu*Rt%n~aOq?8?*qn23E?}2~3zjtBFFRr8&fv-(c-=5Tjq1_MNpqQ6
zbXnRCh{24JwCc+jyPjA%N)KXv?apqTO~3wK@2j3>dp2haOLT0iUuHEM&%}agIWev2
zJF3<idgAhbUvl%c0FpCI*L&)Z8dr4|{qhK9itD`pH`zU1Qk@1Ko5P+ft`vzjUu}bo
zVlD5c^0AUh&6@FhZ3FFufr2KijK#xHN7|J5OFbXvZ8pZ0h|&={sgz+N$t{)}VA@w{
zglw1?@_jM`2bb&aeJh^$nB6bQ8I58aj<k9k$$P~vT}4p+LVE8Fg2o}wWjWu}wiDtg
zu3azU@0)GD87n`AKDNF#F=$O3zeN5deZPF?yZ}oQ&(y%-4BhY`q`oL^J3f`#zL&zI
zpDT(CW?S8RwU~${)E-_^ah_<yhZxY}#MS(B<lR)A6ns%!sL@}!s(L&~ZPF<`Hv2V=
zx1j~;Hd4#SFIoh#MVxQ$z?mJZob_VJPB-V~(;;q<(ViV3FZZ!KMAFF{*^c}7n-sWU
zOqVsETGX(q+k(BTf0`~4U+DmAQlP~Re-vK*FV;7A?b)1ko1G-4zvQU(tAtURb`cRA
zVom6b#tZ3~#V01vD}8Vx`cqJA!T~UFYZqx_Viq?^#xuo*?&p=$9)W&Ir={&D@}%)W
zsB0i9sufqh<3k)W`(1SO`ZLAGq{iURxobtz3E0cSPF5!!98ee??6UIZg-Wo_g=mxm
zQ<PMSJ?}=P`d3D8v4CgnqKw8gR@BWG!wV`10#uL_#o$&v;%|$1T}N1Vj1L|L!3G|t
z<(D<A4YH3l!Cwc1Iyru6PG_I4M4h_n>{QO`cc0|Zuy39)!gYbus@Iz0K^JwYo6a(e
zK=_Quc*X#bbDC8ggceD6@{YpfpP$^~<Ic{b(Z7d4c*!$FIPhyUcznBw16b5?M3+A_
z-GHo%^I{g3OA)yf&hecteKCI8f+zYi&dUyLC}9?o-C61<kSW*=L&?7J>On`wAjpC}
z<@J99Vqkf`>d~kZuhUJ_zU&#D?foZBa$Kg$erBH5&BsvRymN7$l|qUS&~qANl0?#n
zcIZVc=1XH|a<Eyii6p7qLS<pqo?=6&b<o?q^O#VNsJA+-#V7{Oo)xh@JH;B(@7<pf
z$(o@{2M$a4w@lkC;?cs$eXc1ZGsh$GO8yL0yYPE#Wa#Q~j9U@-s)w*BvYd5QP!hxU
zd`3X|zWP?+*k#|swb%F>WKB77gAmK6v|7qL$!Unw$E7^4lMJ5LYc=O}&1N^m+Oh1s
zzCE*`WIjOZEu@|S(3)CMCz6lzTncnDHSKc`xOu|_+!I~6^D@f2|FL%tu8*MgCD}3Z
z(PNVl>1T%>V6vuXcYKk{E)2DOKT38eN{FRINK*?lUA}ZG4X`aZpV`Pe;z<fVp|XQ<
zu6`z*8<x}#Em}Qv=cYl8QB#fu)26>7LdY)W)f1(Q30MMHZ*%8@U?d^%B_QB{(L7Xr
z;Mf7_6_=g)!(|_K$~kgcd8|93d|6|R3JIqY{H-J8l>DclVMLA4%SyGLc%*5su`Ky)
zJigg{C%ml1nK1A*jcvP?nN~pMLVAh^E=RCkxtzYn)ho=FThJuKWh$I;*+`^T8C7<W
z)<$POlxv?$%&x~xl~7b>-ja+x7V#l@M31@aldaho3|>FR<%RgHc0roQF>2CXTc2H~
z?klaL6Z*6BV+PVUxkFQk(L@^s0gj|HbhuiAc)@Ib52MReC2cuP+8{!=@vYq`Yy%p~
zMy)aTUv&jYptq&1_j42*PStR7qj&p@QU7;s6v(kE7jRyP96IPq_whY?k9p2JVT8>S
z&!t`d%s0pS1q1J*w0+Z`QVRRzo5knfH&@%v=&QI*<xnao`)4VG6ja8m0ODtatzK)K
zeO>NAjO&zI%rBXSRs^LF>1!R=f8!~nDYTJ}rryI}p(T}5gjxkXHsQGGnB#Q=X>Wcc
zV6Exq@Z+5in0wh?(GZI-#h6&L9XmOsYM-z9c}Kj;{KAR9noF>CREfTA0(NOJ52*(K
z+S_;}VZZDd<0##zRP)n}asRI2$^JucUU3-X@lV|wng(24adgv&Y|9XWH9AP>*#r}h
zu65JiXaY68Eez?K0m`B!*w37Fi%31H2-4n@rCSYvv0=Iz3tlFYFtR#v1-kmeqb!26
z?zf<03LXRCEkFh@zH3!odjDkW95%;(S><Y}ksc}r8s-$s%gSmt8;*JNwmEC9sdByF
zlhVNJID5+JKE9@UeD2R1sDaMjq)$ftTI4?*VVEFwht&jrQLlB5*Z})ol#3OQvvI3G
z<Dx3DoiB5Egdyj6`)nvd!wr{vsrz}|EWCSJ{xISD&#IXp?o4~Ih#m&iTp)5;c1h*=
z>?bRCn3~&^Hlg@b?x-}OmbD^YapkD<W1G@+gMnaPebLbcIP%YV0O!;Y+NcDf#Amm&
z0%b9LXHQ23Vue1G<E8=#n{s2uV=@-aUstb<o#u6XcePMcwNmT7h48k?gUf&R!kVaY
zne14sT|&^g-xCn_WXMz=G+eKF%M(!qK7tw#C=~lAhnag0nyfhhX{3MPi*NV;Djt{G
zoPw`Epg64dCXZ~TwordwK{;<dE=5Y}?dOHo`3#(vN?A%?Xn8|&ZI^V&Hs1-x#hs1`
zM2#=k@m*8pNBY8j0-ngLslE4Vjdq#pZzSKC1*<k!Jia84BBx}03}}{0(o{x`a!s*c
z`2{k*{f-X0UGPpBTP-b=%x-)vPnqez_n4qDM1T6eF~gC?o)=;;)p-1q`T#BWJbVc2
z2LIBNtS3EeWd-QNT2|}lpi@-}@3$?gWe@G}Y*^#=s)QH3(h6l~a~6v`0R<IPOhnH)
zk13n>Jy)qSOeegHLEKF(!nW$tNRkF~rha-Lw@*B})Xil|i4ZEg#Q(lC?|5CvX1$b`
z)qd}L_p4yV6Dc2N?p;vsP#*&z;mti6vA&2q)ODe3_Kj0M;W&p!gdvwHVS5MNu6BsM
z+bB@<{*Y%TSg+}#kVZ3s1J#gGFA!t>L;)^?uN;MQa365Ls5SGJw%sjPK2VAf9+pwB
z?7k}Po$FRykIO3amg7N|r$-{HnNsp*w0amH&<%y&ty)XO^QVEst3{dq&a6z{hY3A)
z^md(crPNa5Tu;`$(q|>p^spNo^f(^Z5vCle_F2Q;WK$VH@`&ocnyb(&HFzIxYakp>
zZBiuleEaq8&i=mA?>d!4DWNb@9#gjG?2*xQ+T6%|cLxKo8rhU8V$Fj1IFG3n_!U#k
zGniOexEybokb3Mm%UEfk!Uqy7VN+#H^4oqzsH~5WkA{zckFM<rCft-{_nL<=8;Kve
zjtATFIEIgrdbU4p%^&GohAtI1lIMy{9)DNZB1ADmF5g9Wkt~%~-|?Kbv?!OF({Jr1
zlG-zDFX@~)*&gia#2etvqr1%U9!U`&E~pcg=h`ju``%g<laJm?`IAT=rTZGO@?Ra_
zb>JW|^i^8Qt?O5cRf}zY>{tztMu^TovH$cdqdZ>?Arp@R0HQqpfX0{<W?mxsFfHZP
zNuE}#1aa{dwoiA2S5H&~x&4pMD!llvlD~8x{~eotJdHqxEh3K4AIVdnt@GIQRERVb
zU35-h!9|yaAM>0-br%5e&7)-;#CW76R6}?9l+UT9U-+7Q>if(<bDaDcQ}oql>YGdd
zedc*jJdIBA8Rpbv*6jIqUy`sX5MW^Xf$npiWT}mtlK=UHW6C8@Gi>!+<A|gbl{bb}
z+&(#Is*2Mme29L!8&LCVPxt_7BN@L@s#p$$4nZF-J>MIBSx+#R&-;Ge@>Ki$>KPCg
z9}~V_7XGxOT5+Od)6S3YeaCV!a@h>Xk);=FOI`UAnsPDU8gl*%5ei}cu8a~b3zb7y
zy&b9%89DhEKqOn50`v*`8ru~=?!~Cx!&Wbrz2ZFoL&={pK@!G>M}d=MQ~&)&1{9?Y
zd#s0CyI>_W%v|%58hEHhj*^SalN}s5>@w9ib0U6}3%SqZx|Rdk;m6T~MX|jzue#9Z
zPx>xvCY<bE?`;6e!Xv^WQ%YgxjqegN`mMledhNNAztEV4>2Nkh3Avnk5Fq}c2~QJB
zx<ZBYTAyKUbbBs}Q5YpK!9^k5W+5zBh?8kZ=+tAvoVl{z<5rl=dQU(yBX4}}^BJuG
zKlAFYY$G&g`o+w$N>f)qE2X}!=B^q#cV^^r)b4Rq?%eoVhoBTj$9P#|_fBBBYmA_|
zgmf@+ghlpv!j3a`Uj9H;*paJ<LsPf#8!yrBZL_%-6w$7ncN*`e{_u}&^DxwBA$R_M
z0XNmvWZvQ5h?9I`1H`5xw7%Ulwuc0a=_QPP7Lo6J52b;kN!g*u-f3tZqL3+HDHzIi
zN+V^2r#?eysJxYAjP!NIm9a($d>6YyoI1Xi=Go1Q*GCxqW8c<{sz9YiLxPq1yzw#i
zQrd^5H4S|IU2!5bUi1Jz{=sbi?(5jvT%y9zCUV)Bw&GW@4aTouY<s6|EkilT%(QDI
zV*wOsXW#30!FPc_xXorqpJsXTY`S@<@n^^pAy%}p)5OBA`QH~Akht5Ao&IRh`t@J3
z9C06XZB*^8JxLQmL^e_sR{*cEJm59?7bfM2`^mK0u{&d$fE)sKWN6kQ$wmRN&X|vL
z4)+PW&6QUIG<-q_$T!>)7|R#S0-Zam5Ou|!<*<+cwp>4*DwlrBVcdD;LPPrb6ffvc
z8pVVLs;gA$q7c_(bg?$OQzyqF62#T|*ITL(7!3J8X)*eRbV5B{sk!pYec7eat9*TQ
zfX+0=rGCV=k`KmxB{R?zyQ7yW*^Q^M%JU~3%qJ`S=IRLSW;kFDKdhfCh~#8l&6+<y
zHn=h;I3~|`4}wUJ>5WZgh_cU+R_p^)VLe-+4Z0D}%RhKd=Vj0CaJ}~pJRreF%XP=&
z^O=H?XLS>>JRK!&+^$-zJLhQh#gWd6$F-4N_*na`EJ<|M#2%t1`C8GJ-8K17;PR*2
zbHkowIJ!)EPy~4x^53Af-Ct_&tC`_C;q#zE4(f(O_pk%HYt_h;pBxec=QdHM8jQh`
z&J+J3mmmMHy~8GMl7zn>7ura59;>EkP~>uRU2r%nJl;Cy;%5cW5IW{0;1uelk)VBa
zwXc#A_7W&$3J0+~%zrt#Sj>R4dT3@7h18SWCtz(j>6#DJb8ED|iA)1bSg!q6f*yLS
zbb+HGgRoAwPFHPqNw!`C_2FB!CYbsy*QsmZ_@KvmXbw3<gIMP4&cHx(po^<HPauKr
z(?<Xbt&j7B0CG9lIoHC34=|J{r*P+qvrRC}+$Eeb+q`6wrZ#HtIOLx7TWU)oBIep4
z8)XLCk<l|Dmc|P0WIa(~ll-3-z!itvEt6$^W#9{Wcsl(Iv;M~Y_sr?4X)KMsd%{T4
z?SgDTE-Ar+8^s{HwNBRXshb}xgTd*jwQV9PN(ocpwaKt#hTF>>4;g$GVbKRcTW4{d
z%n`S*wGS{-?AFR&Rs)r;NiIqA8<_r6=757xQCqIqVHqfGZh%G^;SrYnq0hIY4<v~#
zd*_MQ$mJx(a>ou>MD0$P21cPE<a#Y})RjOWup8U(58{c6RZ@!XjWV-0!}Hw-cbR=E
z59FPTuU8$N5BX%GOO>>2C5Ze?YERK~9AlaXQUvz_3-KYLOO0?vviz=7krWn+0_s{o
z<7XudCcD9pxg&+=&W$NjsD@Vg&g#}<#U9#lEjSi5F7t1$;x~#E%emgoI#3D#prY^r
zVvqgTV{-utkwZ({V))MNLpg>Wx)5~?XBSjE=kSm~7`Usns!Q0snD8n0op0=o=YQXW
zYlgj7<w;)U9i>m<akVUwOvF;q0rffm>$1pG!htXd)8TTp>Hgy9Jr)ZIn|e*EVK89a
zWe*9_bY8^ou+yF$7jGp&5n_6rh8d>+Yfa{9ZG+gw<3GlQX8f+D&8&&9m5u8@-VjJ_
zv|eB^NOP0Rr5TxV<5CM+gv~WScM{>!Kvg&7QK{tL328nahb?RcmKWvyEy|24@!_K>
zjXXoJ#P~{(EE6lG`xCX|InG%()M=ySX?UwU_)ChT*4cE|w6{l>%oCdQ96ehIZl#Vm
zc{&pKto7>`VS6icjg&(?dWK5-yA7^~-rsFei<$mh?uOn=-scX%kB5BHMK0?<i4wwD
zrB&j0M8@a>Iv(2sG`-5}JYiTpq&No}L~f4G6M*(sDVCd=uES5H6J!w4devot;^Vi#
z+LnSR6FajW>-_{zYxD6=s(y`&J>Fh^Tyo<_V)vc;lafoU6}H%&N^0B{Z>jAh&r2tR
z!nB;aSrycpeEyuldf5I9gh-68shi4U*Hsi;{XWpGo6nbo(uXwcguz1&h16LWin&b{
z^X!`NQ0cTMP^mOfVGX3^;m;H<<nnEFxnHA|L>>ReT{P7M`8xGL5?}R6h*D#H0RQ~w
zYd|uT!@J?M`NnT^q32Aw$l8|NQZhaSkclgeO8z2FwoWqbBWLZEPoQu!D=HnNbA(zA
zAFjr)54SuMv<=nhssW0k#^bBq?R)9KR-&E>Zoj^Y_c5^|bEI>Ar5g071-f8`W!q;H
za;3Ojrvxc)TG~{^#}z=H?n4*3YQ<3X{qEy8;s73Zosy;8;%VgXLug~Y8#=X_J&qvP
zdm9hWl|hG`FbQ&BOM7d0_~M~0Y-q!LIHe3shpdl?&v74ipX=riYH(8oiW}Bf4OUwJ
z4_bMT`Iru`^3>xUkduLW3d0R_4+&55hf2bnu^v+Y>O1Vc1tyLub`o_h30;0tX|)l+
zH4~VS>7U@@&lnz)Bi<#x?0tHZX}`tHchs(^(QbYQXUvqt8c|kwJc(fsp2L<Sf;8!^
z;-KZeA74bAe<-5lX_EhiP0BjV$;))23F(`TE_Dwh0?0WBk2ZS`69a`33uM_xpas1S
zEAgFmjK@1BRtlDC=DwABpVm^xs-GXL5W*G~EmJha&eU{qF)24FwT<+%J-f(XYKss!
z^h1gflOups==a%ecbN*MOc875P}fBM@m3!vu+%mQ_So|HmAXP}K;B{QiQ}Eg__|!L
zOce)QF5UdmgnG^^$55ll$+b8r=jpZEpX4oultauuz@Mey+3F(f=WegOoGJg^xcn9L
zrB$wMHU&ym+~QN%KB8wj+lsGgO6*?{q;*9_fGYl8o*0~nYUW0MjIXRK`3ttT7u*gF
zj1MFp<o@AFFcmoYL&Jzmk_kJYWiHb`d)n3UezH`8-bh2S7&}P}sTQ=HW%U}e<Ec4x
zrC{pCrG!K*jy;3$m5#5walQB?#fGQDVSnI-dmjp;08{08zk3p;dW1%(aH6d9;tApK
zD<#E|J-0-D*r|RKmQT`r$ABUq6NoK46TtM|MJ_uD&(DYC(`%KCc@tAw7w{XXU>JXb
zynUDSV?rXr`b#zg3giCv*Kgz48?ruv6&~1#7YqzU6#&BM0KcM9nQ3?sXt4}`gCoD$
zNx<LITOnP6sC>ZbaPlk>=lMgOuu0rgYj5xy{#X)|$GL7w<t=|$a~I?wVDBL!ZSW?S
zQ`TbrDnx2_naZX7wXgZMK)H&1?TOX=7B{zc`_5e(K5VNajf9gq6-&``$OOjyWJ}xB
zmzp?Vpn`wH*H{D0rJ5ge6KkV}Xy$W$a{;>(OPqeE7E>ZLBFDNz8h5|47DX>>yN)`z
z$=1w=GbWukoD`gTRYhVup|vkYfyN14KDfSED2MaADZhp^YV^odpuMM7ywWNgPlpQc
zXyNy)!Tuq$j*>@&&#>w|8DVc8WJ!G7s|-RSOcFk46;TX`VR}NjGw<Q`wbDo7ATSIE
zC~HAZ|FJ6gi!Z%bjf(1m=3;vFe5bLk(*VQ)0bYl(Nh+aU>`K#b-SArj=PgpEwa$Qo
zrP}mgCX2{j>e^TsA6~g#Ze7T%!NDptVDUR-M{J2GJ+tW$h8>wxBscvLFOfUEn{|!L
zdQQ99ZK`mF6?=X8Kv&QWf6J|(aw9C3dG@r|TlVL-GPh3n6wuNeu))|ei)VZ^v{gVU
zp*V^*PKVV3>lZx7j)S{mYJ;`HZX{8Wy!VLk4Bm9bbVrEt*7f@A2i3p@i%sp)ot%I$
z?64e!anDA?{?@YzhE3xuZ}qN$um<==A!+A4cIP5(F_`jBhlSZ-LF1^B1>5=_V7j3z
zr4=WZ2nm(11ly&AaX5hVc)mg<OVSnRu{l<zQQRJJ|N7W`yQ)B4-&LwAN_mQPL>%FE
zO=e8_7tv)f4~Zn<V^C#0wpEMgeNMAQK>Rx;^EKu7(&>a!m`raY2WIYcIGw-s!)>k#
zU#y+^*&uNX(0EJ7*O<_TCH{qdp_XCeDY`VML?;~vj2AJHphc8~ce@M1%fCW#ZXIcA
zx!iIAxg0S-+AyKCk8kKn1r-U4cd9gcy4Oryr{wc|Y;c5+5<{+FgqF%yrY~Lejqoj8
z+5Q;a@onLK*1(v{lqSWC7prse<d^Zctd-dltCR#HsoK}%6wrHg!_(P++&93ouHNeH
z-Qy<I3N1zczr~0~`~5w~q%DOjKm;45yP2CtWj4nWEAs!KDqMgR+NqKUMetmC-f}UC
zQ63==_hO(X;=6erx}aN+2|DyaM?N;OfRqt^WLout#*Hx!AiYmK5Wi;qFZF3q`iM0`
zsB504R`me-5H_*66y8XwqI_DiaFE(r4+$D+ex}+E0r4U5=Z{|-<yy0QjRO;|Q!BhX
zPao`uDPpSSg7>m)F1k#$5H|H0%B393w%7aE+WRegpZ%VJNGr!;Z5%&Cyh{E_OFt$)
z&hBXy2a+YbI}d;n0%Sm1UtEn*TRK6ANf^~$c@~e)j%k#^k4hyL<@RN(zC7wLTOn3)
z37f-(^tSS0$IRLPfERMRi3%W_kGQECAJGl}%dIcENb7R?q3ceyy`c%ArS?kxkD-VQ
zS6&U3Qh%h`n7e}DdKR}YI;8ocK+<JOgI9BR*JY$xA-f9FwBHHdHO5I7g=gB_0amy1
zuHV-&t0l66D%B3SDD#c!Ex#ilJ32@RoB5V#gAH%9wJ(iD0dwzdHKcw@l?Zj*>|?a0
zD@~~UU}o{_l|#MRpNFPfZ`Hd3tPW2<6+||3xn<e-dn5-D2W%;7+pau+F1z>!1dBNr
z(DX&ny5CZA>?!9Kl2HJ~UYH`^(k6}?4?KW)CTsWD#G?g}>#VCJ1ag^vE8b-eH)S?{
zNr={9zr5GjkQ^jICa83Aj5nkreXG^U#Z53-bbFY9y462X`bb4CO*OSL`TfC|*chXM
zwK1WS1XDgZL#8lcZLY_>!`i3<btMUH%`#@*qWSd-SEhdEdObeGEYl6g4)PjZd$DG9
zUi6J_LxKiouqpP(x`i8PogNA7e1I2<3)Onj1NM0*!@NY2CK@$LvnuExNycZKW{eUA
ziUw%?rJt7N<ooC))k)6FHpvNYQtyJYCcn<4IM5~G@xgaNi_a4%awM=O_b8``HNJm9
zvU(XM+5La+L`OjC2X6>D34n$X1qdo%H+h$cii__EwJ#OB?s-M|j<SzyV%#5h+_kBO
z@v*E5%7Dhs%%>7yENYOZ<)qXW5?Opa$l0N*m;?aDDhzbHfd6EO2B+Gt?ac1Av^~SN
z{%X;rb?KkVr;OO;xanfb73bdILoEJH!Xks!5q(i%q!i>{ITEvuugrx<q5e@s;VVWw
zYDa*hsh3<bd_I6qF&{mr{YOn3^sz)LGHEt8V5#_H%rotI3`_vQJaer<@iUa=W)9x{
zS*L5}1}%36-EfX|(9h{~!O@A|rHRYocSE&`Y297<Lmo0oe>QPsj*MT{>p=9LUM_8v
zK~dplz#LGJ^U}5P?Aj6oh5d5J;6hpp$uX3#yLo|T$+=GHqG<wuZvOKq9yYZyDZM4x
z9UC)SIBq;<N25>+|2&GhS9|FBn8}4q+OiNi&-BQ=0~d}!+Xl*%x)SxVL#9^wu2aL5
z>bt4;^;>NZFeuHXhI}fF<YZY5d)xr#^rD$^o27s#@)t;$wAT4<nc@nQX!9WRlY~_(
zzG<83bUl=qqoRBHWULL=rXSlXP9zns(pp%{dSkmpl3KS3l4@f)FChrKB;H=fu)ysL
z%sDIz8@*x)m85e>U&-elh7E;^pYP%7>iC>+k<Pr%eFH7D{@`Y;$lcU~?j>f@>(lPt
zR7w5T>n#nrC*;6x@}o@OO=a4OAkz^35vO398ErX1v8!awz!~(Jf9YT_bDZrWL~9mu
z)+NvZHQ0boty?-tnfBcnGc>gle;Le`%!3;}jEp`^V@LmAr@T+(2^)C|e&om$fnd{U
z#XG6VHZ0SAi^O{G@1cK7`Oj_mOB@(r9J<nY0c6mnSe0ldO!Wgm!TO<G^a!$?Wt9|G
zow#aYavf+L`UH*B6;){J)x|9)C-u5tlwf%CK}(H;LL`#<Z-9etCyj}wF|+C|y#G2q
z$$#MoZioktp2Tgb(eD<IkvK4%NUL+foIX#{MX!N0<p|<-hSqeaRki==Jq`K~8_v2+
zNmD)~kb2Ix$dau-LA7W>t5RWMq&M>_iLIS8GniT2(&T9eL~^*uN~Ut*RC*1obi?Hj
zoVcC;oP)qGnoJB!@Zqns$MPApz5!yV>L3%ak{ZOA>)G^0wu`#~C`?$p|31!!lZ7lu
zV}Ue-sCJXvf$kyN(v~kiuIKD<{ZK6kB6rvvYaje!2w$qrM<su4Cj;jRG<Y=SNp1%~
zBA~5zT*RE<n7*XDxk;uoqIHg9$o5YK0RGARYZr%@TKz&hd;{)?Rq^o?Abk$ab3zjB
zbqC&s-e11XeG!CW!3B35Zq0N-B1{7H0bfZQ68VLqUyUNIZ+347nEikS-8wEbS*ZZ*
zz9{$=gQ~~Al>cZl?*EznelC|LuNNrF#MA=piR*JE2+Sm4J%8v09IguzdIHP=0}tn6
z4ZvI@;X_21rrxVdyK&crH;#-tr&T#XGUA{w<Z~Ti$q{d_+|oSOY3}(`1w#&l*dSE9
znei8objS{|02W#+1JK}qmI*;*IoqmW(JwF_nmhXH$17up|CMeo3Jnv1ZN`^N42iT{
zHb!B{xNOHvm8+S(%I!fy0Kh*x0LW^<VfX+pN#jfTDAQU?OPl3AOYE>XEjuDXGs)p-
zd!?XW>y<G9&^rbzrZSY%Lb9TD%RR?_m8cJUy#sbZ4TUA6{}a~AQ%{YYr`eyo1wYW;
zr-`mb!p&Qu&J#YsKP#g^^M)w_eo%YY##1XLZ&)uN_n?#31RQLdbU7!0?cyvDx>oIP
z)GzL%P@-H14yS-$*4}vhMG!bbqla-)-tu5iY^R@&zq($fg;9e8ctA@S$J(H{m~vpR
z3%y~ImnQUC0k+6zzi$L+>wzzf6+8`4ek(_x?;O@4gG39}nGD#LCD*59EU0$=pRW=Z
z9ROH29JtC=MxTSGxrUri%+eOf8=wY&b{EfxJW)m~>WxC96lB(j%qG}qHHcT~5^5PL
zO3<A&$?+(L54LB(uK^ULy&q0OBT>K?6R^-tt4_3*fMtx)-PCr>-@em!5+&zxWl2%h
z^D8Z+UZvFsEe+=fPNDX+PMpS6pBr-GN*KKd+8F%4UZ4xFR#m=`Mt1ued=fwqO6Uxu
z8eN1IN)$P@COGL!?tAHUqw6Npx145g)rWtLucXp-0`pKDthpGpI)Sy>eP11w3lb7=
z1D?TG%E#l~fnUiM452GLW^LA?l?T#Wo68O&?nhhe_1g*65N{8knm;5v7&qquQ?4_l
zCvirc%UnPDe&bhE;jN`X)n^RaM``w|1EVEm$GUM_(Jy)twPkWgqp(uE0zXq%4%4CK
zMPpo9993UtS)LeGIBXBj`eQ$j9X3#ji#M@)I1o5VC42GU=~QQX0!ykg)EA>|6-Uh1
zCK^>}!g+48WGHRR2;cQ$`fWscPb4*+d``m?%=5<^s3(!jB--Qt+td2MJ)`i$F0;j3
zx^1}OHgpQjguK*ILeMbbE0?q!t?@pQ;;H+!Cq8(6;9H~su$qWt0igo=<Yu~}-~JIz
zVg9OEs>C46l`{by!1nyFSD;4UhkPHpQ^I}^1b&MKuZui@JeCiKJV#`?*z?uPdM(`Z
zo_-7TzZllK5g2h8IQ3V}0gD%Ubf+7T26>urv6fN12Xg~LjA)BH=!_|_08=5ZKyhv!
zUt^!?wrkXj_<WVrfNUn;p3xW6_zWG7b*+yWNUo32I=*H~R-H$|7nwy!p0V$-Hu<sn
z2V)lfWJNtHA`i{VAc|WS7+<~>*J1jfCjAd^ETWXiVHUm<mm>eX9C};!GfODr<6FTO
zIm&P16#ayK-YS+qsWntSGx?_hlti5s+Ro9SA3=Q9IcOX<Vcydw`K+mgnT96HftLo_
z7=Bqt^CH)QB@$vRNf27;Rq`KY^{ao8ZP4){oU`Hrd%s8tCxVS-wJZf64GKR2yz@{k
zzNBs1_nET(kGcY<9)MP?<gLzcL0k*42HSvFlCj+Xe;jhz^f6)Jc{;;vH2(Vi?l1B7
zgj%{aUiYjGw?g@sPvtx3Tub85M83M6r}a_4m5sI?O>?7a6j6K9(A?=XT1mH~RLAw7
zlK4NQ87h3HHgU$~fujmJ%hGp(R2&)qwxB83(P;i+fh<=edyWD`-mAbUHlyc`kE#F5
z5n&(=NsQ_#Tbd7^uToPiojLV@t_bv224@m!*#oq(FmvB(d0o6fN6O-%tx6#G)PGkr
zFh6X6tuY<PJYjf@)OVN{5mn6t@)Z@7Fj_nLps|&VAG#YFdGisi@x!@MxO9ri;Qs&<
zEh!zmD!~o#0{d0$Fw3x9%2R=j8g;T6K|``4DET7u7`KW;bVbBBsN}B*$WOTp|3jEO
zSL^}8^!%^b+sKQCiZ2n}hdFmH9LV+zNBC$&7*u5fd&YwtUh{!jD)-j{akq9<w+!Wd
zi>7-G7-iZ2>&G|Pe7^Gse_1DI_Ts)J@I1!FEX4Km^CB0)vR@U)6e0csliuQTDXvdf
zT8b+}Og5X?nUDMB`H&FES5hdA;iK0EIKOLG$rBY$1U7sO4M=*%dA)phWlYi3>PPlB
zrrWzf1K13PxzSk04JIcfa6(Z|f|qu(>*`~@@tEo&{{2@zOg;^0cRz<`J)HWjKQOD>
zPEtQrrkS*vhovDB7T0-*<hXtc?Ui87RQ4+TnE7koLB=0$%w(YF0kaz0KeHNeATG!g
z%~9jp&JK>-4?sZ6!*~84*51RZ$>#e5B?(QC4uW(cNHGXV?-p9<gswDEKoF#N!9+#r
zy;p?@h9XT6sZl9Ped!${AV>$1-tNZl{mtAz;LbS1nB>_#d-jyiIeX5tapKP&5)(^6
zpvRy3y5C>;pAG3Q<mKb02>sCA-R;}Y62ToqxqPJHbG;%@ZYN3Vjh323XlQ#qtI-i@
zlP!GWZu;&;k9XpInVSuuS~?p6fPO(A>{?{i40$ZQL(SLLjvfsNFu?9)z5kNtL^y;X
zilB{YTS9dYs875t#wpEF4lZF#X;2ygM`z1^lrlE*A2mPk?0}Aqd&I-QjKk{$lKTsN
zd~<nU8=LnxiR7yrRT_g*2w~utV?bs5|KX$Dj0`pT$UPg+HHxk?Y2}h^tItN$tLb<O
zkmRt-r@HsXZEL;2QReOGf56t&5RXopp$JeW%S0^HWM|rdE3i#xZG!UWe*lez*z5DY
zc{4m?-0;0WH$??b&Uk(P5&J^1-#1b~zs<XBmpzg;C)4U}aLjWxnseFO1=MWvyb+3f
z!^1<Yq^tQVj_$UCtjlknHi1q8Ng{B~`qw-oUCnL&Be|ODMv6&ZLnxvX!>#O<no$j1
zrQ+|~S~AJPLx>C&B{Fm!qpogQ4w+?gsOdb&Q48LgJ&jQC^;WYY9wQe_V~9Z(NhqjP
zmn>0Jo6@dqxZ^xsRrjBFCr&i78R-vGrC*5t6zW(UWGv!F)y><zqt^(D&)5M%>75MF
z2C<c@x?CI-a|CFlkFtNe;jItqNUwv?2IN+oDaO><0_!@;GcE6c@=;mkid;Ek2O2w-
zTfK+Bn420%ElH{&B~ew$$u!OG5#i4OBpz>u>R#*K35mB{s?`K1YHUVks~2I-;d{&7
zI$sghwTHBAuYJNaF}A>vbQg~l@;eouDJ-SU+K6<%Al|~3F<7vk;sYX>OoQ<#N`ixD
zuI06dpr!=WB6kEmGFW;Ac^oO3#=4YIb6b99fAZ`1JN$E^_j5BW9r)%P3Aa4guKp65
zwy6%|o%bZ9{&{xob=Y4MP!&&N$i>0=Ixf=^2kxw^lk<}Y<K9~%=@#n@;y!pQRFd)v
z(iJJGnwL?G({*&a!8uLw^MCz*j??+MUNUqQ#d6+SH@pSxByJ4_GD+Ds(*~%=U#NKM
zcpcG+GUS$Ss8`B$B0mb|{jc_-_+yaxhOMhrZ-SB-<;s*-Z&$fhX1ekFHzZp>JBD17
zG{?SwQxY8+{)vc;rw!W@B-LL$5*RkBe#Sb)XAe|Li1lMfgM!%x)cEW)2PEtk?_r;J
zyWKDj(f(FC8v|WrbWnx?H|J7z|0auUqAfJm<L!6XmCjJ=qBoDT1H`skfEB6!5E0IS
zdEHvsG?J!e1P|h_3(enL?cjIfQTLzUk~zw88F4k8g6UD8T$fZeyj5#C`=dJ!HVcx`
zml+De0?VW>1~lcbDPwdbjU}4Cm5QYpAPrz<jP0?J;g!H#%A9|))AK$Xde->{k(Qwo
zE~$w6@PO>r5E;XEui9)8g0ak81^+(l&-?K<a8d+pM0xRY`6l@jP<(rWpK|>J3QQwa
zJin<WfR;ue+7se`_4ouos(6??awmgo%K)zGcHv+ZEAppz*@6W<Knr4~`y2<d+Q$D0
zSw@yg{P=}Kqw4KW8%6(!KThN$j1Ioo#?LcWY|B8uD@8UjjwGQZC-RcAeY(SX6_&Q&
zyTwS%VVex?AeuCFLp!H93uSVBu>L9SNU=xJoRu*OOEZ=l4q^W;e4<btDh1n8iG;2c
z;(g{$5<sDHwsX&7j@pQnEHsX!bMZ$WX)M#CuQuRm%v|*l)++Kz{Xn~MoxW`8?d?$9
z7L^A$2s`TFV&-3UD&Jx+F=Y15`_ZjRA`6LwsL(!elVYuaZ^{3Sndc!3z0&Ji<}Ad{
zwK4hbahY*wM#hZj?>J|R9nb|A!^n`4u>@(j@L;sJTb^%D;Qr#9<oQ~2CN*o2-qYXc
zKr54uqVu&r773Lw6<eDd>OL=7d1RCogA0b-VPF7xIrjR&Pp;f{S%12^|I&hEv=tk*
z7B+G#$doy#b94Q^mu<&cH6Eby#8D5c;w2+m@m9{eqE>Ct|GsulT6w|P<+l~Oj@Peu
zuDq<$S}1TF{{5PxDhYJBWzdYT<8i)X`FR(wxr-Q-248WMfrGTXw6ECLpu|7Rhf+Y#
zg%7FQMm*ou7i9})inp{evzuswR#}lRzU{{^#UJBuc*}$A>XamN!=hd}Pox^_&)2^k
z_4c{w*8ADd)mGtzZ3R|)N3LMl!4uH+m-}ul_&@5w*iy1i3X7Hb>a2&0ALqJ3{#jnA
z{WINg3d44%NocHB=Xm?q(l3S^d<x!-NrVYqdAG-29o!rRPs`*#Zuq8Kc7$>;n2$Dv
zhe}=~A@vUazghrZJ{yo2o$an)I%e3`B2EW7gQQcAzK?U_+2^`36Bm2lJQwDY<}k2?
z9|bt}!n-+yoD;Othv|}GlI*r{Xn45o{4{9${CjD7xok?|T!n*&VM(Hbj>mCCk((^G
zIGAB%5VV{W)?@6c;!)O`z03e9LR#`B3?jojFb$-muylqV+V_yI?l25p<Qz9PJ=N*l
z;80<PRXu+|pE(KEQ!3xg%0M>+NSE@2wYgywS1rObd>1$veo7R}2wZ2h<Tv$MaP{__
zF-cMMl%ZF%=3y|P*;<l0{622>J60`c14Db>rk;-s4-dwizZGiFwA^f<kSpB){l4cy
zjOwi=_#!mxie+pD%~xTD?br3J_mvIg|J)1I{o=|S%HMlWNivPWNx$b6zWaIh7v}C{
z^?bdTmaw-<E`GJ*CAM{1QlKnDkwB;)z3*teOIu;B_ILQPq1a)$QR%PLG8*(!eG8`~
z#~TXt^s3EE>E~6yRZGOdok1Tca_OD?j=yKjy}yhndvWl26ebq+p~1rOx<F?pfQA&-
zv+wWm&+&j*Cq4rrl=W$U8bCtMm;Qq3yY(;l=E{jOcxs+N$;<boAmGogtAE-9N7&Y-
ztwV@zodnD+;ZbV0$y&HLM|?Qj>t@?I$GOHIB1Jf1zqu1pK5q8k2C?B1c+=;rv7=@D
zPFb)`Mu(g$oy&rQZ*!g$im2@+hs)8+RRO^nhg)CZwAtr7nubTIkuZ2FR$TSa+)sVr
zXq<qjW!U}%N>yXF8|B=&L6^nQ`?&0~+zjssNkJzrg7Wih{UAx{O0fi&(P6o#L#`-C
z)+L<(;cj&J7~KK+mf!SaiRx#^f?I8WAc>}rsz5bycmTZx^?{o|ad?Sh&S4iB!xe7t
zO_rq$y`CC;($_}+{>FUGY4!X#$3?`~#`8pg8hBXStc~>ptIx5BKZ0AJS^#KcpRm5!
z-`&l@(knJ3GBM#!D>hmjx|Ld_^bF<dtxo8^pRYz7eUEOb)xFK9(H<Y#RKLG41@smt
zlE+qDlx;eb_I~X=Uv6UWrrO1zKdzQ=BfZib?gNmg^^&<WYI5jfq~BuH9IDF05Yp0h
zmG1+Y+3l8s{%-OOfk<e7ldl+7wD2yRU5u}nOoi0SYTB#Y^+s%TxH577M_OK5&LAK9
z%9&^HM|7L$2WBS6kx)~4y&6bbMt#}sC<)q60qmOmeQdEy?U11LxuLvBy;YK7+mb*X
zV4h(4NtxP}o<Vk`DPHEX2XXVcqrwePu1$?)nF1N(q%+W3vA*^!Uu{eHU9EHn8N<;x
zO~N^0`L>2BCIwTktD>|67j*m4!HLBB!@g9iG_{xh%?6o&>MU0y1sFVKD&Q4jTP{6a
z5|3ZBz)Cb*%fMpX$W4ihxlUmQsr}N%2NKv9N|_jnhCny3l7oA!!%Is?7>Zk-qnq*o
z^Bx$E#plsQ=(kGBP2AI@#bGzREsaK6Wk?)Z91h=)F9>tgstR<wfTLqB22Ds8qyw5O
z^|(-$Rt{nz$#-VCZ$I(AfRBNhXN+&|Z@5LqT+b;~34+)C$zmr54z{LD_U%i>grd}R
zKyL>5osb3B>MHkmE5{Ec2!U_~cOhddB7#V<<C-`1UC{L%S~Df^8JVfx)lDA;@6RCT
z<2z$v2quXl35M+tHSkq8dtTex4j+@}vndaja2xhacm$Hj>T0fJ2$D5QE80ffcbUft
znrIkCoqz5>8L5{aKLi@4*O)l!gPa)0`x3}6lcX>-OIRQiic8w~?}!n%eA2&+6}~XP
zZijD<2271&zTWZJH{nrZcz`@#GY><TQFfIad0qLULxyyZMdZ<!LWW9hH7oP|=M(xz
zw_227p^P4=z~&Qv=0WjPiWxctt!_zUq2&u@vMJiBi&m6VoD7zmiKPb0yxp0xb3br5
z23?Cmx2)qC?LocxUJ`TpH<w7hejR+x^K2cV_LOUWdf=G3TJz-!B?oiUTa%7AKo2{U
z6>l|pJMuZqCf~z=T9jLadFK7wT_j!k>lYkG9&Q>ozM9hCR@qmKtKAe$QKq@xaox6!
zbTV7gn@wC%oI?Cw%BbwBQMvKo*I-Q=qfKm&V~)XX@N;|#!}C@j)$@DMcU}fQT;yZs
zuYSF<AIbHOVLQNaMtvLq<bC10x@|6P$@K_aY^E~I3Y1kVX2`3yIk~fJre-`358ym7
zJtVv7*bCa@#5wA@tsM3K@SQ*7`3tHqD}SuIBor!{pW7dT0yb-U2C;{WJNWGU?{RP3
z`CMh_&5feJna2D%^KiUQ&(L`RU7Y{gEBg4|BhX02DWAj~(V1&lOg`sySok0^S+mE6
zf}3fv=JvSlFW<Wpe<!;$?+k#KkaY*mOn)tv4g(Txb_tS9)_HT*Nz-#^&6i;CJbODi
zBtnK!=ER1D*kpPU*Z>sE1<1x_?K{5UfWVEI#IE_~_7$Xvo4p-<<utR4CVt#@Y-Y8v
zrr*`vPFPqKu06Phpe*I>L`ffn($^U!50@vmo!$epIgUK|mkgzF@Sa)5(1EsY@_B87
z{Qa3AhjRL`9*qA5FF<p6xP<P1{HU8X$1c=Hy_dO9#7!SlR-aw%z9Cu7Jr5dsEfwDj
z%9V-sN^->i`92=@_4{Sau9{_JsM-T`6q!6z5>Qf?n~vAxo=l94=Vv#Y$QauivMm!I
z<nd1U-d)PI0ez(;><q2qS8(L|{h8kh#B6N~<!|d1z^fz{bk`Vf)=WBrvZe>&mx~J=
zKY{XMPz(4@4k|x$?>CP^dWIz(==AF@CF7gZBV4+_P@M5OUcAp$`~yjHSaQz|@Ar8T
zGLS;1QuUxA*G4b+r{eS*G!<v`k|yf;lIrrOuGaTQ^nM*jfU^K$Vk&=Pp8USqn}#2f
z9LZH3v0y>LmxJ;|+l;D7L&d&lWb1@ka_tL<#Hp6SExySS5V!PaJG-6#+c;@7O9uj?
z{9PR+y7%gAvOm?x0V0Mpdu3MtvZfB6$uO7x6#EsMSFCl+=-}vc@c2`{kQCi;4a<4p
z?h9XH#{S=Vg#7<#2#OTk6nT8~J!AOy4TAdp8AHE&t|Z+e7T*q^M+<-E4zNs?7Tfwl
z`>f1`b#6I7J9O{z{Sm+o8NiLWf7}q@o0BJ)-CqzVWPMdSR^8iBoQf?DIymqj_}%pS
zQn86qrWOn2)=hOa`nJfe>ilvlp@CaQ%p4;2cj()0r`eD}$e3?M{*Ap!dHXgxUS^Z$
zSnW<Dazoik4<wuVcDk9gEUOo@C6{_j$AjHy?mBf^E)129E(SJhr=82#7hlF7-tr_L
z3henndr^Kt*eNhq?2az~uOG}qEjVEX<DMA?wm+GOuB+tjN$}x#bv~p^+V@;I$?>ni
z=9?b6&K3DZ+3QL}&*GO3J?zrZA+re%<4q9H#j8G@maONC>-a5nh;5?7cs0Z`(^b}P
z86S|4$Av`cS;7;sei7FhMadgw<qD-N(u_}&tIIF~us!RM_vt!XG*$eKSNe7YULCmS
zYgo$<yKbm3ah88CTuH=cR%pSI>t0OaGIEPWuvEIVSBS2vANVlLl}|r*p8mXYmi0bg
zv;Q=l<hN8%v!u|J2THZ@7Wjt2ZW4Xkd~@x1MlLYd9qP)>_NNfh#eFea5LqlNwjzL2
zuR>&zXLE7-SrbmbNWA-^ASpf~^vdk-cdfyqpj~l~dpEPcL~<I*B{!=z#M{i<<YYOF
z>wtBw?R?n|<=`|(G%>yu0mp@en&0exu%?HNw9=T0v<5|~PFW<^$k%qJ5MB9&Xc~=2
zw)t10;XcKd7yc+c<EjX@`|jL&>45-J+A%>Zabn2;&-6tijY5Tk(>SvP(PeYRZ>9fw
zj_F%+eiz|=RAFY%LeL!5V;v|*-@4eZKoy>f2l%sG$Oo$M!H2Vah4Kd%)BFmBwG;2+
z`4ZqYx~UF>m_cgF5WC!^Yb^BUnOWbBXrm+#1Sa@XS$U|Z=;@vQ1Ivb5aj|)c8~6H=
z@M&<I$#hlWAfD{PeLGDUx98u^<m7VUxON015~X-bn$FGXeT9&gBk<+j4Qnc0%IHt4
zQ)jnxmsUw0ldY|u=$BVih3U(4w9ZCky7*}rX16a(S)T`ajCDkumTD!s^b)BuOm(13
zNTrLb74Wcwc)lC&ta4@aFtYpp`BFr9mW!XhVfNd4((siRA3bxIbow^v6bJYHXvg|q
z;9~&0SBkK>mIQsDg;aP=6j30{d6=2^zxV#>LS^t3WtXKa9cFqTDl(|&v!YeWTQ67X
z$7LwK_(}ttx$#<c_SI0sdvmAcDMEw$Lg1Mt!TQU6!FY`vz^_&!WuxkNQL<L93)wkK
zhv`szooa6h+;2vQ+JcBbO16+OaXTJXKaE?a0$%L>*+-1(deYvP_aI;(4Z>rxmny<t
zRo_!!0?3emyf;~jIN2r(<Dszv+VT7OoKE?GaIM-U<wdDquKv8#W16PMJ&xf|oBTK*
znbs-wNfO*3+vm9smP6l*+Q09d>|%$vHOOCwLJssjbde~Ye`4=<X{+zKeL0O)+S1_!
zSzDSTi~KLwE~UP-^qxF*UFqPkA&&-aSrQ|D^-C}rF2epSNhv-3?5p8wFrXfurB(M=
z*6_AvYK$oF2RLq#xTR4JmNHy&b$IL2i&l9{fj;FIoq1VdV&rY?v}<y!?!ZvME7WhE
zbX6mwvbkj+TBhnjh^FE{5hn(+nq|4+HPt^#eSehBp}6mLk01>Jj0aC3p8v-Jt5gS8
zsQIP3D0TGgufR}L?h-Xi9ZwDTSd2k2%;k+U%AMlO>8>ejajuKZo&J!B83y`&gB*>?
zGO#`o?A(8&5r>?#3wWS8k!6Wkl?OmWNWrUZwZ9yX@znA6?SyA(IQxNJUr$~-d~X>l
zmVaSKitrUJ$8a5zZ+0>Gv^(TG*f^f_NfFN%{YN;*z}&v9rNb|HH@qL&#!4rm>+X4w
z4k`<nBRH^J>sY}-^?R6)f5sgGb2Uq81$tI)&lP5iUUZe7e+I^(5AeP@wOWM;zRIiL
zr@-&C5l%(X=umhbm+m5SSx%8x-?nq-X+Z8$Fw7rnOLj@f!(R-NhY)Xu<LE5F3_V*c
z1RjC)$BKk@r9Okcou@g8d$>!#b>*X6DV2AUt8*}cF#8dQ;_-`Vr0to3otA0|zY`H%
zxisN}=6{s(1p9WtrPi<_*aPjc^;?#y)8=18;s3K5q&HI?k}!0zB<+b`;&$$YTBW`|
zKuUGuUdiHdh+XNYzQ3~!#ywtyMzmZ4-!Ws8K;KS6U~U}5hLyhD)Hn~UO|EYTh6XP&
zAt@Jj9!-O&ia6UQV%e*Ktv!lEbUhK+r4<<z9|(W3x}($r82<u1(zw7mgkX&?>{YXn
z@7vi0B)-O&Z?YG+I9TpIx|t1Xl;>aAi(YJG7*pmQp~mi4^(&O5xB>k%KzE?sVFgQn
z`uLQoo{D!>y`M1wyGyixe?=@)PpJ+()f;R%<Y)uneLH#b^;*+_Neu|`g-I=AI4f<q
z?~|L+hX1c5erA#|?&)1`Op5^`5E+=uLpnus!f-%YVfVvX7rNJ7<?8z5I0ZfoYDbU*
zH)(nOs5%XM=$?Y>xqt5|^~C|lP@vRTP34Vx7Ln~$drd-}?)|Ju_2uhS(YxFOkMeD#
zpA=i>E|n|>p5c`G&MB4DL?X*=Ocn5&)rf}A`KLOGF5jcvkOOG2`ZyDz3703&KB>he
zWUkqeSWR4p^s@)%=0VmjGjDuFbj_&jw~P>ZO&JiGt}!@>9IU*wD$%QKnL1o$6buYB
z37v7?<8PJtNU*jtg#??0K$YyFEN62&R=WZh$)J=MRS3nmD{we+_eTB-DfpA@Fy0lI
zyGecm8Eag5s$fRCx9Zxr7#K<eDzimBG=cFi(beAtl1&|$YujGJVc`Fmt%)`KO=wBx
zDfl*SDKM0xB6Rq(&&dZKYPFpF|AO$TSm^Oy>r=n{kZ;fgxHB(sX~^mnhw&XSk5*<q
zQ~yWV0Y>a%oh19hnPT70s+M}eDrT}8aqaOtnc>0B2w_HboV9AcrPb|_NVOK60_Mx_
zXp6~s6XuD=YW2S#L<UBy5sKJ<i!e#M(gtL#Yv(C^3uZT4?0xyUGd={rj(5wkb?>WM
zOVF-f!3_4ix*E`FS)NN`_F;z#1zb1G%G8$|&yRQU4J!Mi!~-cMExnU@qgLPPUewvj
zcHq-g2iszW3rJLme4<vOlzGmK>hV(GnJhsO|31=~J^Ck>qpk++-*?cX)F+sb`t*zy
z*U?{qpU2k#m9oB-E28DpInII&6*pBZ(pQfgufq%lJ10c$$Tby@iuCQ!AoV_(^Xj?h
zRK}2Nm?ap;o1^0#EdA~dM`$Ik^Z*~?3>>N=(1%I%AjY(~w@7CP`q-~FgA2lWFH}Kf
zY!in}c)vorc(toa7;FkzWA&U#=)IrK=X3{;!j8qh$_?DuA2rDdhvUwUoC8YXIPxmQ
zF*S~&!=SiVo&Dtwra0JGncB+SllFzLXWMa$bXS$)wcfYL4-lD;H{nQjM3h=0_DWZk
z>+Mtr9@rk=?$ZPp;Fm7oQ&@_&U#r~3t)kv^I(s^q)NNkPpyDK7i+31jG8N=UuJ91I
z+PbT1O?SYnPqk=*L&sUaw>03qCJ)$VAS^I{laI&QQp$!+pJ~Q!bXAo*TFR8IJcJ`p
z+rYAMf|jYuX%6F|ct?C*ajzyj{t&+qxu=}4qIrX6Sb$}He<IW-q=Nh^lme3FXzAxY
z{6j18C<$mKDjd;uM&(M~nD+5+qX{(_#=ti$Q>Pjc{5e0wzofWXO<#Jo*Jr>U`WP_!
zHjkcL^8cVHDjm`F2LYP)OYf|hKdjX9H5yK?Zq9I#N#a0n3v7B*dHDS}Uh^MBmXEJi
zBaZD-9SqEJ;^DY+qPY(PED9>J?LWe+;AchjkqT*lin8_I9u0pb;z?n=sletQ(fEo6
z=AF8*Z{0(A{+_l>H66aAoj7!p$f>X&Rj%5p4o(j(YlXKQ35bE1YLnvL<mwWgnRU~g
z)4hVKsCzBf1D~BfQu5%da7=aBtdWBwMV=E^EL??X00N+lNx_Ig_RX>rCyLgDolfP3
zU0>-4ySII1#Zc=^n78}@*NeoFbU9h>jRU0mK}G<HN+QypBGOe=1k^~StEvVw3e|+s
znP#U>{N(J+@{-}IdxH%Di(B)2Q<@;M^w4t89(laN>JQO`JO=++M0Dw|e<S}5%&pWv
z8?p{`I|rYGHww%J7dAm%>0D`|OK-?Z8>Bk)0hdivapyuq!&^wqOR+1vEY~uPdr*0A
zTM~nu0Q$|~7ZpIJ5OGOySO%3w$5LRk9PV}h9{wJNrMO!!#_Q@Y=7?U=`#kCmY;qNZ
z5G9zE<(A6I3Il<P;DtID;qcc<6mbGZ-$W4@{VX5JXO6i`mn&o{Br1?gqoa_5;x5Aw
zaFs6w^D`PBn=jj49?Ce&KYU~x^Zvj<ii(F?>ykgAIJ-DSVl|sFAc#bj5xwm2-Bbs8
zoN9+P-kAirIH(MvC9Gf<JuJNEXhs8sy$<ZrI@MH984xrJyA#wyOBw0Dof5SFrMfIh
zs%Y!5Wnc?n_-VW-z6{T0nVK?8r;~{NK;-*wPA|BmEoU8jxg~GuZ~$xHAMHkCCv9hH
zSNTWMR4)fvsh)pTS32vbedIMpW$4MfH)HBSWCyG`dY^N|<O|ExCe-~WU>G9Q#7R^k
zIH;oq^p*lrl=_w+snAqNDtYSK$+=gK?WVBU;D>2i1OxNx$Q!xS-&S^U(D^)5yR|Co
z+n&lVdY7Y_OOqzG_%C%NH0$IppX}H5K8x$AS_@klNP;61|Nr`j9e8Le$cseLARxLF
zxg`n-+z9AJ*d_8;{-N%STQ`=++Rc;Gh73}nHjt}ClZ7-T3WG~=7<w2pjCQ~XC{7MY
zp6*Ax$$5}^xC&&@&LrYjF*N91j48Sw?}cylKKx{i@x)i>*z%BZlX9=P(m@TNfeaBk
zA#)E21=!pDlK8P+nGZYX1~7w!-n3(dXIGJ^2hr~pAjrg^3h|1oIQoxAx-B1Q5ytmz
z5@aZ5$X)3gW2NrC=it|Bt8!S{^1qrurO`s(Jn<_Odo`WH;%#-$4^qMzq;}F%DiOf4
zf4dr`j*%tdNQ@LHr!ae$QDC12*`wII!qV7zL##r^IXMyg`Cj_poR2?Ap6$UsLYx}N
z4mg~Tir~l^kbg}yG4F!7lh^)sUH$J=C^NJY>cLwfCT`pIS!<=o3(uWHV@CzL^(8%6
zJOuWrKnxvC)PL(}(prcgT(9hIo?|Q{`*%>bf$zuKXeVYm!7DtSj^)H@>R9UN>(EjY
z-*fE}u^?TW2sd?BK^gtd!GFLCJGfQLc#!LFCr&uZRTw!bavrdH2z%Hpjs6&ZcNOV!
zjpzeJTuB>w0(dF{+CG~&ixE2T&rJpSa9#x%I{(@wv^UxoGD@K2N1~9KGn2OxO?Y%j
zC=$%hK3_PHTE9*olIjC{gwYx(y#!Oay>jm_y$5H7{kzM^#JgXJvioQiqDsasF#Wp}
z<)%=xB~Kuo81zP>_RZidW1BF2{<1Y8B<czXFA^iGR6Im*msejSyGp42pt0q^Glw|A
zog+7FG1s(8RJ9YCJHd#;6YO|P{46F!tH&}0VIYz%|6B_tRtw%7c=oalFpQVDBB3bQ
zEc6Vr_9`qM^OVk_3V;ad_C=tD4t2Nl;lgMlXJ1-l?qT{!3PgI}eUO3882K_LvO6md
zNPT2N>Xi#1S0af&5=*5xBgq~;bnlrN_4G->&P9``K&CD<w#-?<ks(BSaQ75RWMPWt
zIa)jcq7@FqNG+Ez2ed885>&@LD-w>IC0ZJqVM^5I+bE<ge`dpJvHnfeYGce0|C6+0
zrUdwI90O5xR<1=sS_F1m9wj322hZ)}NcXM_?cMYu7!g7VmkDG9b-O=^XYN-9eDPX#
z_w5+$`g@<LnwwRjdXx+l%rgh>xd{*W5ZocQ&_dI!SU7HDEru7#UOJ4XMoX9IV|D0~
zf_zVyKr<p~05pJ;?H(cY6Zwbh;%7dDtAyJFRGR)!G1fX&-13b9p&u+j<+O9oZ8$9G
z*o-Y5n?5I+RD{;9r~w%HOABCQyHc2ycK!Y024VcHR!P|@tgfJ%MH=<!i625}!-wEX
z=)xM^Nwi<U8|S$3M#UdRmr=O>H!g!c1E&!XS*SbNMu{9NNbUSXU9ueURBAe=Ip1A%
zNzN`>(OGG_6rQ5qU2d9)!MA^r*o5xEV<Hnxn#j<juq@al>>kOES!Vy5vd)UR&x3zZ
zssrqTv;GLlhj%vD7Ia}}U!N73pT0QS8)rj`*sJf!2FCmFAL-iZA}beRGdJ0hbsW1{
zg^G}|3)JdF`$z69wMBv>G2WGd$mM<19;;I4_Nmy72;nM(P9_JDCi0b1ao!ZEH+Xln
zIpmCGQ0HI{{Ezrt=6w}Hxk)fgl0h!#FFf>N<?DOt`;5n#+2&7<5~(T}w=NT8ip7|f
zp`{jUKefRVEB>lQ^;xM|S_V_BVkbgT{_x83o)7OF#c+=}AgX*ZsiiB5`{h^)7;*H!
zs<dxTvXVXV5`Q-b2CBVpc$W98H6|owx)>3du%?$wgqU+oPOkhLS9UcqlEGm*T?xW@
ztNxZtK6Q9-*@tWL{>Wcl;5~t=Mxk#X^)bd8fMHR2>1lt09!^1?#*dk{to(MIv#HKY
z%WlBBxM{BWf1j!?!Z>Kl-yr&h8h=FF>`Nuc8udl7<@91dRnPKiS?ykH)b0%sHcE5~
zGv`?L-Y5RDxVi?DCcM%9fND$B?n@Qz`>Wi78`3AJAD?xK<H*qS=pW3sLK8Ub1LC?&
zjLnUvXgZYfi@&(E%cA)=d`|+1Kg@GOYYNwD`3Q<vl>!C~cU2TK#luaX$PUD4GF*qs
zz@7*Rg--V{u{}oFA&{rb>~{QwII@igqINCNc^x7ZxS#lS<{hb{25cz1n@mLA=*~BR
zrR%t64M+>Nu3yc7WGBT>DiJ&30SDQeNeZ+tRrs+oLGq@}O;@B#!w>A{<{))s3*u6t
z05TD4cA0ic?}X|1HRrw+2k&_x_3G>wtTZGFBDh;;)DnjjV&RF{y$LQ0e!0aY{IQlS
zTO!t853&czz0SMWiEp3|zlJQ90H$cj#+EWxmTZhEKt%2X+<C7Z%9EeI+;q%JZ=7iI
zfS3i$nIUoI<lIr4Xo$>!n=aoVye4a%rm`qU*MSUX74VYl%%?sF&V(^SdLs6VB3nQy
zy6%{T`1t>lh?fNPsH1!+#Z}}A;m%t&<g}u^8#efG=$tkPIDu-^^ljizFxzKT+3aiv
zi9<QI3C&6TqGXN2;P<#fVq)jGQBZD1R;ciPG2Ho)7vT+bZo~8@NF>n!UxM|sq#C;_
zKEsdyjM;`Gn?94*U6)%_MF0FE0rHR!fm@q!khKric}n-bsMhrVY5~&!P1UeT(Qywt
z1}9GRia1fj8YkN-8DWVyl0@&7(0A2bFXoZ|FPR-m_$=7`DI}d9kjeZ&#KX%&m&icq
zbthrudZl!Qon2!!>;barF1rP}MdDw2SBTw^?z3E2pMPk`r2uj^3f=3ndN?UnSS;U%
zwEx=ieE5Sm0U&Dp$HPiDJMivd9oRhbMJ3yog57j)Ev@(~6HfMVhwdfxYxJ?=BoW6c
z<NwYKq=-mgI$-kb8l|I<`L-E~bde&`!F`Xcy&i2Mlo<JucbVLOvbVfkAhh_zKF95w
zW#}`dE!hDPqco^2Z1DNMD9buxE>ex;o*m#1yJ!gjAt>QRe!a>JL7^E6%-{?A;kJJK
z%ohpsD;rMhl32%|>Yo|Litq<7q<OZ??8Hz7yN4xuORBlRtM&3u!wqmUT+W860@4++
zA|Gt-xVkG6^^RpMQ;Leug~Qlo@7KYV%5tL?H}kzS#=VCQ1P<)7t!c|8@5x;9W{Oht
z@7J!h)u-0=osn7{Xe6@thy@~DUdKQmC__MzvcY;St+P*W6MhLDR-)%*m`bX0VT#J?
zCI2-OcXQJAyCfF;;vlQ*NZdfh?g{sItk0;T-|gKcm%DJFSRr^iE-1k-N*yY{+!*kn
zW?2hXe_d{d{0rD&X?vn{{M^M<exL&n{6HHdn9)t<ogrvx9(tqR{`QyhRwz6gjcMKc
zkGMrN#H3E9yNz8BK0ubD9o2xK&Zc|HYVm%~Dl#6j34KCA`*jsD{4EO05Nt#w=0)H(
zAF}6@g1D0Sj54Njh+7fn?-S})e~6h!M`7NH^r}Pau85DUU@8GEgUMHB^lC3INA%R=
z8L_W&3q*Rfirb@2O>_CB^_nT_I0D{%%|23J5Xu)sZoZIWK8DN|g^Y4dCOzr(Z<{MF
z_SLZ~HAN@1>fcXtl!jVF`S3`+@}c{vm2v^e5_BN|!lqe&{+T17^nFgvx_z0g>qXF%
z!IU?m<$WVY>gCx=uOE##ZXkMPSsGK>*gtIe5HE}AGt1EmGZPTK)l3auOzUkFtRCtg
z$IBAAK@%-}>#p+VI(`GMk2T6jB;Vu2vCf&|Q}EVC7*WRIE?WE*{0P8kyAeOJ`77<<
zcDMinCt(zu-~V?7Rgz)~eGq8;=B-?;A8WXy1!Eok7_<%mmLYwAm^{vd<37zv;2XIp
zk~~scym0-1ov4OLadXqoxj%`MPpxLq1y_UoAU2xp3s%p`_;9RIBs|dT{L0eG=)We#
z>#5Yy00PjAT*1zjB?@46v{-#n<5!_^6zv>LY&z?;*Kp(K5*ECPL6zKFECb)(?_k#J
zX&xrL4+@5z!}Uayn4L@slh`wLThhf6sVo=uOA+ACVx6AdCj(?HHg2MX*5V|?$Lg03
z(}2YI-3|X6f1-4vgiLsqP*`V6Zbj!hs7GS@fNe{f;A8hC(mNs3)e~iU`h);$rK#Bz
zOi<6S1ahET0ufC6SiTGrMB{iP?A(wew#fNf(xs<t`t_GD>$%J|3s>+1B+81P75bDm
zKJ)QGnCx(zI^S^H3byb}1)dgJa~bE<|M}uuO`LK>vBbp#;jJ$Ksoi}@Mqnls;G3}=
zT{3L?Yg_A{U^XRwE#)tfRv1Sr4~DJa0pltsifwnB6<344zrp6+e`j|{-1%5C_OJ)e
z#j3n9B3`~4Da$y##WhkO;f=5Uo+{R_s9`S!a^NnXe8POo=vqm3dzx=k6YW!QbVi)i
zm2ZoTAZRLxdhUP`gwBg<dTTP3sh<pPM}-IT?ueo`>+_Wi*i8qc44|{r-yL|FkZmcO
z48hfkCF;o2ZWT>-j7jn-CXa>9HgmWcANRt38dl20tg~Ku$=T%F4Io4{V|v(emg*3@
zCkgMLcEo1}Y8TIxBV}F00Hnp(7)(`74q^f^&bPKF>=?yw2#shW=`OFhNDRcxGm^Ec
zBz@GLNFr;^&H05?&*q|vJU6fl8HhASU7pd%^rHVMkCOCru1Mw8lepIe0OU3lXXtZw
z^VuVVe6RHvK)m#4blCqi`V2=f3;l7P_O{?1SPMxwfc8gWapS>8PcW1Nl#Mx<O=jk2
zZg!K;?R8)goMiPvwPpViVxYZWpa~|d)DWixN3#>UD79afta3Pj^iSh@&?U|rQwQJq
zjFL31aI!lvo(r*uN?Vr(pme4gv`=&A3jb?rdQ&%WGdK6x_VUMQVARRyALB2X3SL<@
zeFd?lh~@ZAXVQ3xne_=xF;RUCNlQA~m(qI(v&mX>@!Pvv24{1iavsiVA#Go4Tf#i1
z3U7D}k$5+LSvP6_tw((Z`Meue#XWIlnHQy#eO{qu68oUybDoL+<Ahh%y~e(LUlwVi
zK}1-+(@zM{gpHDSthM>rsoHsYOqqHdg>^D1vrAQpmpa~s%3VGtX#4t8N?LbW!bN5r
z@kJ&2w+G(1YSgDYCxYeurK!ri?`$`Z51@kxlD0?vA=!$8&V9IdQ`ec-IAZ-8t31lI
z=dZQZ58V~kS&CZnC^dBs{gpdXjbJZmCXO-6CHj1Z3*Ut_8J&6Euj~cQ1rP04?-fAp
z6$UIEB9%TN7@hTN1@zQYhj=ugMNsOyaFLNv{9_^!@gZ4@QVY=tMu6gB<0|4KJ}A1D
z`g)o=MY+X^FWXr8N-gY-i-OiV$Q7|`kk^3x-h6xl;4to57xcARj#~WpWye9-1DyN_
zb+j)>WtR`@m3quB<NrOnMp0@DLbCclmQiYL@|+gMU}t^T3-ElVf(*RCU-Y=JZDryE
z{7KtIIz_*1U!sZ??D>JkTTqj?qr4I1oTkKwWxnzmNsK^Mh{0V@75x^bIEnJVkHZrt
zfTSIY_Fy@2Gb3)QSddwAh~#8Y5D`z!ocFN%QJfS%)C8ik{|r0g*;UoEXq9M`!Uk1_
zRJ!8Lj6`<wef$ZnjQi%KQEDOs17EgnC}YiEI=z_hVdXRsiK4E4WcC0Z$HIK<K#(|^
zUwX;xY=gQMJy2M54<5O%K*;$baejf5E}N{8jq~1$;5T#(`V*7~ZXM0+Y>Y~H_u-l-
zjfR;o)aB#v<*TRSH-5eYK-lH$F=fw+p?yn-_kfFzAWW95J>{rBAKP|&2GW>iPyUXi
zQfEX&K5;Co${4MO9;~<t*Q0ns9(z@9^+ep+$J%I-Oh!n&d1y1gNPG8=SPKqBoWn2q
zBc!T_G5ZwlSvP}(>clRE!_i9^N#xRaCcX~|&IeT>;WZa39@{laqE9_tGNj^#v2)As
za%}n2e&&wnleMK}@&+yRxqR7<+!C)ml{vXw9{MZfrK2C4XI_LkdOF-z59Jc6i7cT!
z!<ZoMB5u^#ZdAtdJz?&LVda}_l(fC~q;PV_6n3wnbDA>0QZlawtqj)=J&RoOA$$f~
z;DS$3%e=2gP{wS>;-LvrY)ddjm^lfx8kujsWp)pS3pO9ZoX*B(-~y7cHuy29z2<dR
zgtQ*Gbp>KqL`2K>T<TMV7x&QaWNnEPAkeK&fQT}-$%}}O1mbHj+gKSkx~J9Xx^o0?
z;Se(uRd^t&O`aC2#e!#yUwj6G|A-Gjab%NEv9feWRj^HxxYI^T=SUTq5B!(I#OV%o
z?k&e+l&x-d)1VEQ>CF?F#i}Zv32b$|u|Q?%3e?O{-cJzH0Dz(ztq5SJ+n=W%jo!kK
zhDmT&as|#BVRD$d*J6Oi#@r!01?>gplp&e<0;nZ?WqJ>9cB`@w)<FuWezZ;qP^FF)
zl<rq1YvsHpGSFO&9!tcsB}DC6L9BR~bzBN6jzP|&DXKIeFQOnEYx7h{e1t2Yl8>gH
zhOEt+<Uo1L)XKpyamCTtE)5@`Nzo2cK^F*aMqdz&yN;}O)o&~Yx4Mj0+Su&!z}NF8
zlFs6hR*$a0Xs;^Y45afcS<*@jVhWt~x}cJt6to>U@U4b24p3>M;re3P_NRz8N-UN{
zgRHGS=iurX%GesFD-ytSEg@82g@hAYYPfX<4uw7mRNS#s3T8k~--{e0Q*E|ScpuyV
z%OY*dgmQ8ammrPVCvQK#fzwRKe&(RdwjF3T<K5i|W;?jHjNH4_$`USs^k$Wh{B1=j
z1bZ_1^n!(u(8xDD?ovd(<V86t@fl%kQ9)w8H?!xUA$SoMRir>o8%|(TjK8dS$6>(d
zlM|*(s~{S|jzoF-k<?y@l;)ar(`sU)S>s{b)UvDcK5p3ICe+-jyb80W1JCvc;khx}
z&CyNa*thk`CU!CG_Z3ZcV3WQw=rnXoQjis3Jw+o*&n0n4NRzz%NZI3_of6KCmTZwa
z(pSube5|gX<68umy3Y+~i!|&8r{0wRxGz5CRwY*E2X6G^@*$Exl9n$<oL!UM(}xom
zFJ<71L!xFUQpVJSV=oX1=)}K<&2vF?$)ePz4|umS-&lyjW+{o^Xy7NoH{5JGE?Ly*
zs1kj98FCSJYYle!IstuyB<$xO;b2~c>l6IDa~^XaY(djz_O`0NEJtPnHk87snNEoT
zC`{G^Eml#6>-=Q{a9l9Y6+JEsfI=3(E;}bmNp14&K93^gE2G>;NcJv7`?E=kPRwiN
zza6Ku5D*$sBith{V*)xRAwH9Usl?W@Q$G#&f&FK&C^hhi`sw?txaoY>^+WkBJ0eSB
z;TsbR?sy)@Ga9iVa(5d70Ut1X#adTqMSsDC?HS1vP*hVh{tlZW6RJO@)l$`?Fz}lU
zWl+$iHOm@jlAH!Nz3*;!`o^L>{^%QWrMDiRi`k}iNL3H!L`ntlP?%9h?keH5;5bEh
z@)>64YaK>vsE>nM1@6agYW-^n(lzMQw7-9kuM(p0k)~G#kOFM_?53B0JtR~T#fVeg
zifbuo09IjMsU;;xO+rE5t_TUZE}lCilR#70NBV>&di3Gp)OqAzo+1*(!R|bN4v6g)
zmgwu`d-(qG#LVS8b&ujqSUI2#WbGVVxu6A(z)6B&Vt&l&VQ+}Q#rToeQbkI~n8b_{
z#=e{1@nu<lUWn8C`5NL538kK*d73C?s+X8)$Gr6p9{_H6r2?$z>2KBh)xvl%fAg7L
z!lR8#5EWLo%~k9SdE%?<{C>>+<(`MbZ_}-Op({FZ&`Fprujs^oCM6`Zunhsd8t;c-
zkC(vCg}Bl-N{i1hR3F2l)V%l4(QPm6l`otK38fBcG(d=YNB&e=$n2h6qSkaK?NgBF
zlWPD`RxRhU(`gw#m1T(!IUQ;9acL4S39Mvogw@9-K0;sh@f|Q)E$LPUKA;04M%JD*
z@sQ2K!miO+%iu&hAQp})=Z4MDxYC^9h=a*^NIM6G8UJU(ItVhJA@fZ5KesA#1*Ol@
zhH}c#ZZGVAb-yD#OnB7WOoHHKUNs^V{Sz$eF<zmOhv0(2%8AwlwMZ{z=diCiS|L%H
zE^Nyht3h_V0QTeUTgU~2`g7d}y45dYtJGro6e#Kf^`Cv=>t7R9udj&mLd@79r`c&a
z+1WNb@OLoV6JN8a)f+g+AY;sODT}eSA)+4q&ZH?O?~s_v{LG@_P!$-03vApLkTn#?
zy4uw4Hy=X!=Tm_wwQ7G*Az)ZafgXHrk97MBu`7FHk%R{I3N<n6d@R4*@tSBBv;jmm
z{?#4XANg2r5|9fHzbpDD_^F8<Vz`43n_Fts{3>cst0~>>#q#x&O9vfOXP{>j6LZyf
zC(cVsTmT5%Req%Uq>w5}E@kxSRazGF{&tvP!s1N1cIJi$*_Kxdk}Q)>j%n<}irUa!
z5at8|+@u23OkSS2rJKAlwXxzcQVq@@Kojwr;Xs(x%V5mxKlfof&}08H0vou!(py)|
zWLTo4efN5xrXA8QcmPT-J22bhzjUQ+tJY{Z;(ZDc?GbfXq$fuM!6HhOH)s6xi^C{>
zsQ(1>H5d;qum<ANL~?hawp7vJmUmaX###XMigo$QnEia0&RGRS#adV@<SQgjrFR`}
z4a9H8AWP1)93s}@F7Mtn-Sy<HjM_Uv5UCDk{Pd`g8P)G+h+sS|=MQiAuQBKEM?;jq
zipGi&<9(&AoHrJy4+HE<orp=F0Peas)wk*`r;|;jCZGZQ6^7C{nh6m+9cJGQuv@@u
zVoM2AY0~6?F#uXj&bppZFP$wl2JbY$P*5DFi83~UbAw~(JeS4_?{(+jmq=)-qWz&;
zoA`iJdko$J2(NY1MXSMaUTdo|b#{l30?wxKDaA;)*ga^d{z?Np<!1)o0zgL8ZnM@@
zaFFU&7g11}=qwb4M&Kw|pzpFdR)vCLGNw-I{ZQ142t}R_M%kzJvsQXjt8CK6C3;sG
z_K!66!=4n3#+&IY<^h1e60+>uKvvFbk_(GCUYoh=wIR~`2sPXOzE5M}jz7*#Bk_n`
zGbc_kIV-ffR4229b=Pst@W~OX0HG_grj`?DD<pe*H=}<+*1r0@^*>8^aS;Qyy`KUy
z%6PoflI2!pPiKA<N5{DTxu(O`J6mmPY3{mxQN4~^wW{aRJgHrV*Pwf9b$GDk2T^%{
zoO3Mi#?z<I{pccElF~=FZ5;$>=r2VaeM8}cwTxT1`8Sj~*8Gs$uZ18LlAd{!xVo>F
zOwm{L#$%4G8cT-O-Z^Ga1f<vPY+rllI4jPP0PcKix;&Yj)jT8=mB<bU%g7UvJ)H<l
zOdsu^^Y;hPqeu@ukLidAK41K(_eC&7q~mI9sGqs8YzPa1c}|7y6ZBiBo~=tVEL@T2
zoCYzY$C%stqrY_*R`>i|rZ-v2ha!PWoq-z^xigpWh*AROT|Ijvhf=M}_-p-9Vfpzw
z?)kp##em>1$ML+OCcl3Z0z^jHTR&6;2m#mV`&b1vTPHO8wo5%2!T2u4fG-%r$v||e
z0vH3*_G7Abn^50fyv3!6A&n$74+%#+yA7*z$Mboe_((M-*nG@|=y!hrwsaYNMt1!o
z(JL2)Uu#sQds;sE%r!wMhA+|!vIW4_{|Bkusys4XkU}3rA0SU1IV%*mzCri5UqK(}
zNG`O7=DE|e>HNA&7vOK#D3+vRoA~O<ErK_Iy@D)}^#gl+{bu;uTa{jf??jmsr8u#*
zYvjlLz-%A&yI?B0DWe5;3$mql*Zj%acw&tGO=5##4*){5)nxJ)3*f^2dWGFMQJuT1
zrgSHcu4cjp9?7ZhBeS*t&jo5vF|O`Iok-hOoU+K<GBnoo!iLJd2=iD|rYL&Lu@uLp
zTp}Ni1~ppuZYe5>rw++PLGu7C;M}?`2AQw|?>87z5E}6zj1g%oyZ96?KJydHLOuCp
z=Z%~{<K(y7D^7i|Ss|f4Z4fXxUIN`DRGRqRf(POEJ}!A#ebiiOV@0<;C%UJ)QC?8`
zt}c_V0z1(Bho>lrxDqCJO~_0&n8umP_GQ+KIW0X;_APseXF;!}v;M}#*iT3gC6>qD
z_8h->F8|v>Buz;HCw1f0<M`T35q|uB?Cs`6!~K!G!oaTao5!IkS`_wRnhpH+`8Ix+
ztkwDrI(?vY1N-__AuQZVz@km@s`v<xM?W`?m4XSFD1Lk&KU7^baLnKpgQEMMiT&$!
zZ8vXH&sp_n{MHqeeze4lSdWYKT%lyI2dy(pW$3mOLG+8n5?!ny%|iv;0grU%LfI`(
zlSWyXJ5}T_BC<+_sa#^)eDwU%y7PmC-_xzq<5^JPk%3iQg$9$gD>A3qhDnvnujHSq
z6F$7LaEX<Ls#3)UDxR9cgX+-fq0exLQ6_Wv-Gsk8N<r*dbLuKWs?>Ev%PjMne&6G_
z3gPb?i?XaIGTBlr0-Xlv*H93E0CYTi2XttXwXOJXLKiPY?mD?bKb)JY@$ZCksPAk-
z?e{*iM@W(O4+?PUnLKkR`-fh9XasSJ*C5Bhsz%~hcWYT9_8=o55V~*>M8r5U@Lh_i
zxj!Z6yUlnD{n^2rHX^)>f5=)9sPFL`mUWSDI=v*F)t)9d!5#?PXsr1TT$by!SZRCP
zs{CIQ(}9~I;*GU>egamOzmpErK@5`sm0jgF7fvLE%v$cn)d_}?uo5GBW{Ek68mRpx
z;o|;<?yJo7#_Zpt@V=OB8w%G;YzCFUZB<Uc8fqHG(2=$)J}0OLPnf`uC@WkHOIb1Q
z|2!d+{p&&=2DXw}E^Vvrb-!#>2}b$u&F&bga7!Ss;fEf?430cF2{|Y0Fpj?8T040_
z_CFXsK$1%NiDZeq%_S#Li`8cEdF=z89vhe3E@0(zXm@QNCl%5iSex@Cg$JvuSb1%D
z-(U;~t9y{8;c{2GvHQjE{<v`EGv~jv$%?z5ej$|+`6?|;m^K|{C{25CcyJuJ+zpsL
zoY4qe&pb{+kb0S7G&Mo(Tyu)4WgGwLpX{<YUl^g3cmAv?@S5?sX~RUar<a*fNl1@^
zOp<mWP(B~TNY1HZg?oN5;bSn{i!fTs=%Sg=0Gx_-(C^<|b0j1JaggL$zAaOHm-SHn
zT223OYffB?nEbxN<f}2kul@|OZe=~03W<~i=v=H@`(D%yx;GS$8J?{@6WOK2F5I+N
z?O;Nd?7in!QJV@r=8N@94yshC<UcFmu0M~HiH09Zi32N8jrV^+R5ktzU&GR6tV`oS
z@&ph4y`e)1XKbpJVuGH#(^%A5-Io(Bh(tLEx}{`Wu6T?;9QbCLrcwSn0iOoWf6!7#
zx+woxfe&YY1PR4}>}uXEX3ybzSQl^y*&M(fJhSxL@ZIyZ&m(OiMVPKINSP;TGP)tx
zmY%fxX=hOMhrL4@_Z7qicio`7o%v%k{1jmTkwNTIO2x-9?C0w9hU|k#qP;ctATH?l
zjP`4WeGMgb5e4v>A{bl{RxS)2)x`4y@~=fHL8Lt+3w-@bSe!sYUXwF6>OGgXQtVrW
zu!9F@vYyv+wC>bMZ|5yHpu;+qD4RMP@%*h#d9hQeLEgf^$Eph~%>egjrX3L^>Dnsj
zE5<L{&*rOg_HpX(<HruDg2~@e$D*A|;jbQhB~Z?3@^+8qLfe!5*<RFAv~h0Ifgznq
z5>yMETwA~<NLBaI@2i|~n3p95F)05zqWM)gi|Akk#A{?e5XC75Gy1FOL(N11Cdj0#
zi#Ui1T9WN>2}%(1dPyjq<idOX;_9?=)3}Q%4Sz8Grgc7^{0~Fqq3h<o#aonUvhWbJ
z&!f-FIx*fXfbel5;X2ShrhUgXTO#7PC^)^Qo)b4K21aLxWZyYyJ29~vWQ;4I$+UrI
zz8*7bsD9!Pdz|VgRsBhNi?fY$epi6|wUlB3Iyn6NX$xf|uJIeahq&kFtcBfAufa5S
z2MYW0!I1YuFWedT9hJ0>z6j$Kd3g8iy~Df)%X5sFW!ska1-LcuNi}JadT_Qq<#uwN
z$Ivl01kKtxU`<iB?6;fmO#30$A7SMubL>^-`(RmV0i14&z_>P98B84>tR{N9C;tlP
zqCNZaZ$7w(7+BbaUxl`c1zO*9qw2!*E|wb4y#1)b5vit=WY#P^=PkeEC+gg3ZfT>l
zM!$`z)zML8ciy-$5NOuw6auX<4tzau_chagt}>+iA5+$}*L;sAh}$3t7BQulIdTQ3
zc+3=x`K<eSd9?Fu>xXFZRX=<1n24JY<E=Hyna^&cB*6(sPt-Wb8!yYHeT?=`=#aSl
zI;JF4M!+v)(NcAXBE?^*jH&5SUlCE<lP?}z15^tW=eWk82!C4sZ!OGQB;Zr?PQ4bh
z5$Kbmx~$=2tvf?3<)Z5O0z!`On&jQYNSqSPc&5WYE_lnDk?)b~L%GEy&iNa<%|#~S
zg!ihSfh%syGn>lk_ql<U7|QxSY$ymRNy&K1vU42umuX<-BEtr$4TUaUBnU~1Fq@=p
z>~y92cVE@Gfw2nHjhNz_=WF@(Bn%soSm!hb744=xcoWBgUf6LSxza@?sL}<cJM5pu
zbN|Zc#rZs_XLB~0^TI;cZnG=|!74<ZTVI*TQYYr3%Z&&sPp<AF8b9GfKK@9=pSFhN
zg+%+<3ON6M1^Gm>O3`*Kv9(RK0Sa4Go-7U1{~+NZS`!#vI-)FEfU}vlI7hh;r7#y<
zZ8SXdCnEB^d+%8065HUf)oUpZ{Pry^<P$cevAiGRXB-9T_nVc_#87PPHNdI@c5Orq
zY)jldwH*yhq=P~{_}Fql=~!kwX-K^4ch)e6mQH$!oZB@<(To32QQsX;_4~%nvG*pj
zvNv@IAsNTW%64p(W6x~iC@PdPl08mFwj6t&uae@JS&^Ncy;q+5_`ROz@gH8F`*V-$
zzOMIm-S_AHK7T&1+<ej0iY!$uj$l`nU+&byyx`|BW)LUQ<=ebCzK7dCx7Zuv8uo6w
znrVoZtFakz9v~V{pAEMXX&Wn{`nsO?=(QWUK_YT9<911$19`WrYs$3<t3<Y?7oWzT
zxnxB3OqI4%7PSmU8Y7{|v1H%Jy}M!a(=Q|DfniG?@^3!PBozb3*So7QKmA(yeP;8p
z^h>bu@4{p*RJ-fww|O5HVf$P{;~Rp9($Tk>WAN&3lxtahTW;j4Bg052wW5q<mWV0}
zTb?X34VkRp<Y%{HDAWCmQVLDMLG_PXt^a{uR=&q&90q@H)lOdhd9bGv5N+-2)DyeF
z3Q%Wvu`PN$G9_m66PA3C@u=a5qO$$~oBGdkow^qu4n_>4xB5$t)X)F#U4RT>j3cH3
zRA=>hLRqFYTpL7-6>|7CpR&`4*?^Jw-u3bN#?_-|;|e|oRN&$&O6#el=4Eo}6D)T(
zS%Mu=VEQ__P>7)=9=d!})t;3~)3J@M{MA6Cb}P<?m#%#un~?-aM+)WcfAnD6C|p@c
zaEwjO@+aKdzKLo5G12sUzd!>{ACwIi_Yv>_4OH5&8qH5jJfZAWusO|QcrEZURg8-V
z6D2*j(`tNk-^`8h>EMkSO$Eyopf3rKgG5|z$~Z)L_pT=JEn+V3ANj8uffb+t7h+t~
zy=cJ-XkALS-+_$B)`)Eom;@RsQ3X+k(wYL=tHgxDw;B}~<FO4c%=JgMw~GUoNcsv+
z_uMu9TOl3lp9pV9Tr2U9@u+t&4l53&plx>Uzk%EER`h3I5I?Ury!?<!;itVFwE_g!
zBikY8uWH&ve|JnG=#<__zX|A^r?z_HkgzghhNoX}UYz3S{uXjJ*L}~mZ4Ptv>0f3>
za0Z?=Av<XcnMMAm=an%t3`Y}Jn_dk}cTOQk+#%zV2p9|cYAoO5I-84+^hUkynT(*l
zl8~Y#wvaa61C}39uS&d^{=26BxDvw~43kMjwz@mbyBBG)pI@d+3pOWsI+xrfA(<#l
z3=z5@mU|^_gpgSa3%hAi$q(uX8TSETN`WDrz&n+}1*zU@0w1rhjP}p3#>fBggI$<G
z<7)q4N&f1?_8Uqrp;5aj#aoV{c;?0>6u7Dr{x<LF6Sj$345#!$q4C<NZ$6!(Y0lf{
zQv&#xe6?xE%*8nm+hhLj1O$WIM0x;3E-x(P3%9;sA0u`I7srS?PpP)sa4E{gwQ*UY
z(X9NDcZDRK>m&M@Xj8$Pgpve;iEK;ypX6BhmAO5o$0W6tFVmg1XR|QPkshC%<{a4o
zi#@eBr%Om$zMt}EWfz|p{33mhpKNuS4p&$*@FD~@IXCs>rgYav=`k0W4wW5hZX4MW
z3NPLYOIcQn(klymGoC=dB_?~(I1#g!6G9yTssL2_Yk@itF1&D!^l-}&d6~4DsEZ?Q
znxqtw-P{6Vi{$-x^RSZ3G`Vq)DOKB;dGMX!=gYi5zY7Xa*uV(Y8hBjCZq0gqZDm!K
z1Q60kA9#qCw9_}9WuXbqA}*=zqQb>LQi!Hi*6;(^ym>#rnJaoH(I>%wV16c7CGKND
zTu{eKa31^5`N50<4D}rrT9~K-u0Hlvf0dYEkP+oopYr^^v^15!>OfbBxBf0=B1PKI
z4N}h_EB@Ggc0Sj_aP7|2U#6jMfv%r+U;Y$mQ6!$`iRrP0)%YzRv8<mr;jP|rdboTk
z_)g-h0K_1HO|Nf!?N+C$YvPEu?A@~@4b~AuWj)#ESZNN~4*C3S*Tkkhj@h3opEpTH
zc}E1L)xSh4yeb{Nr~=dX?L-`m*zS|lV3Q|r47dzJ%q+Q^%dbsdLtDl5d2Gkfs{J)z
z2!&4<@McC{8Vt>|FD?>7t7w3kf#UCCp`=Xr=~s#N(<R@ZTs3zXK@0JCw?&RE__alb
zq=x#dd6A*T|CZOKPm8qt2z<JphFsYZJ$R>b@$y5CFb6qr7T~GsuVCmNFyl)L&own8
zSb{VA>cNGg%l$GwZM~#~)77vfSIuh&Y6&YFUpXpqv4&O6QcrFz({I9w=I;I9*KbA+
zJKr}7ye&}2x;VO6sLTgriLt$*q#{Rf%vdbjQDqdbo0xxUkv^QUEjMfV&|H6G865PY
zl$1rUR`>>3VW!Hn=G(EuSmCu^xeDCeG)6V-eU8`5b7HpP3&E4aACDWR!4ydFYoFRt
z5M(5AGDc+7?4K>vRBF`-`gGkPv#7l?$fSLw>{{k;@C!*L*HZfiNf|w(8_zZ<a2j3r
zAp1*uZR-=p;=-QN8*f|6g>cX&Yr|~FJJj4Fkx%%|`K3Z})ee1e&I$zvQRAe6@t)nr
z1Sx+p%_^`3h4qU+mBW_~!5+O7iubK+H(%lQ`Lf7-Ul&@Zul2g)Azw)Le*QkGy#l)<
zxCj2h6iI`p%&(*sW6k}MOOw7er(xkKokbq5mua8X!-nNqPX=23?;8BRz9Uv;feW<N
zN?>VBP9L3&h?vV};GM@y4?q16MFYMLOB7eNY(4&f;WgPq*HwV*@@oa&vMzbCtP?}v
zU0W;P%{SHD+k9XxKj4Bz<~jfq5jMV?QzbyedGB_@{+HEO3?!Np+#2eHCrhg?Jspy+
zE{SLx1-f5cK3#xb0>r`sjbE?8VND&#6%g`K4YKnt_IX#X%p45y2L^`<YnvEj5YyQN
zZEDt)x54%1I;vF%%|AnfbXFX3>L0ZzY}7dx%&)8|4p@_<xcrd@oG|D`gY3fPdt5MP
zEpD_NJ_)+txO$Wy4@0p|KAshO%63D$q{tA%iJ>yNggyztHI>7&dHjt)=jxdZhO;a*
zym3{w$M9<_-CKga54e^>L3{$KfvD_7_Anr6+zTM8a!{#^<kMEW8M}`>BrCZ*k*hEF
zgz<o?>DuCbFoM1NeXWMz)<)5*5a?aos|<iwyr0wmZnlZ%snYrfo<Zp$>(!ZgX=!aE
zfAD=|-f2$E^Qkp6zEg-#*P&Q3Npk*XOWOGQ{@90%@FNYAEDRnsgqb?_KxlgpXIvXV
zQ-X1wDU-!6|F!g*8_TTR?0P<z){y;co&$0#hHF$}G-4E3HA}6Be{>^`g1H4{Ot?s1
z^H04#rwD35>q!WDXv^$`%o1iors9aSMHMtph*!@njRL7@Ui&lSDqGRrCHnTvJ&+?h
zStWO6a9a!<2K=UO5fGY=!8kpC_}&qG&x>KhtYvvnR<=1*lqwT&@yWC&BWka03)qL+
zQ`n2o-yQp@ZQRP0?h=Y8$1Bv9e|k+L1QW`4@b8yg<o@>Y%^~Rq!8?}`0n7bsvptwW
zmCxT2D&V%HIK*rfN%8EVo?vZsgOZT#`qP&UH*Ag`^d}e@wU2*j*z@6Wd92Ftn)|?X
zg5#Ln`=$#~XUR(}P0bs@*0=Qewk*wwh5Y)c-~IFX;L@&9V~XIx*V0p`DeNTU(9cuj
zNCIuy5K)!`2q8G3DVpKz*7i?K;H=ZgdRv5pZLbBUv@}{-x5RN31r7WoVDjPRzxPEy
z)4Mc{(IA^Y{ZkDd<<kEctKc{CyCYxlB0-j04RDWY_f|s>g6`cSYl!#D`b=>#`Fz=V
z-ZrT#^5hCp1>&+x0Z)KxFJ1u)4Hz<E)t)*b1Y0o3eifu_(TkBsN#xR(g{Ks&J=z8$
zBb*<RYFf+oBRR@(>PAmma)zC%O16?>Feh1x>Dx~{w2iiMKaF+4Li0DN2t0vLJNLm^
z?X_7)fJ6e{r?(D^?LpoGyXAzt9v(=uk0(kO9152-SN$V#`I?mO<+dh+0-w+gQ<5Yx
z!-UQh9^dkoSS5=v*&1q+%WfE3RT+9lkl2Kl1s&{ZSo1arSNWacBU%g*0@#xm6uMJ}
zxy>(SXo_<N-<v$iyO3gzO&22oH?FhQo=k$txDY33(>|HuFnCw^Q08EHv^sxj$gpzk
z<yBHPhsgrP6TuW5NY?)QZp7wlhKP`YxU2*?gf_H*OXI0ea_C@~>_#SJ-0ve2Dtsy6
zDU|`^DQ@S0HO{aeB@`x&1b5bu&hQ^PHG?2Abw&%i8iygrmCv1MK|-PxG6d4empEui
zB?fj~nA;7bM{~<UTafeqd{l0_1EY(GMw+aT+Amyx-3+>~pPWj$NI$+_s9R3hqW;^h
zKJY3ZNi@lfzr)pTh{If*F2&uSWFMX3JQaV)$w)u27+x`|ry1jM-{d`(9g;2!kEs@)
zBARdpapB_DeUc`fFue7NsxyyOUtsg#jHGVzUC7Q&;33H59<~cEgN|Ao`)(TjWY-3`
zSgzMi3|?reU7GOTXYXHUV!U?eiQM8-vyiJUI#Eic%(rt%5SWQBzjJ*=2@Zn(+PWSZ
zq17cPo`8&5wnyVDwawI(bA>+}FV@ci=NsQ9p3h4T*x^q<7{wR<?WVOi9oH7K?higT
zKKS5(F=ae!-Dcm$pZFy*Z!&M&mEp4NCIma71XI}_*$HwjxCGB;Z$rcX2TV0?4MBq%
zNoJ~|yQ&vC<2j$~MjB}bu~#djUg39VAb_RH(?!!*auD>+`s%O+?;Ip_J5{)BLj2W*
z%7U?Xai|Xd0$A)LP;4=~rt+6uh`>V`)FK!i-C{3v)jgSG^8bClU99=QaE8Q*fZ{`d
z^Z~;!wM|L6Sgp0r|A6g0aybgL>aXD2?3Js(>Kirav66H|<Ag}qt9iCp`uMiy6A3~c
zM2vw9EUn-c_URX?A=m$4VJz%s(|N-~0LV<BZLXpqt~j>55Q$3|CP5`jw=;vSnB`+k
znB{RB=y8FE)?QXzLr{Ck*M$dOW_SX|zu#EzgNwFnG-nU6ffy6(1IC9%q|LY*052{b
z;9<%dE?5VLLg81-3Qmnqjt#8!Tg9#$Tj#BmgQ8AT;I+<{%jZ+Jgx?Zgn7v(he{!m8
z$(Ok11u85%Gc3lD2A~k*kE?QriIFSn{61L;w5ACV*nE?!n+^qasz<ME!u{VGp~q4f
z(Iq3wRpVnco;Uur=J<zl$}t@CxCAdAXtS6;|4drNQ^g4m64hwBM2gvSa#OeHy|NSI
zVnX$7z@b5}Ip{4H!4imROW(D6M^MwRjjv*<G5EU||G~`%jfV@D^?@@E0p^PnUG30S
z!bCiL$^`n5tps{-Z~;+KjQwOGXQU|kC->7U^1N6iHxCcDw@@MvnKr2^H?10(>3!!R
zO73@rr1|eS1@``ZM%cYxNVeIuYgZntl~nD%u!4pjVyF9U`$JH{s$0+Onhw;?JpJ}2
z@7q)6$+WmxbG=LBuMph6d%7ho`|U&}KNXOK7HHaaTz4qxTF~B+P_~O#3DhjZt9u=I
zf@rLkpV%o?Td--9c>+BZJox$0y4`d$X#XgfK#FMm#<#a$utN(b`!mLc^A61X#)DzD
zU0p2!=$1zIsfC@KW4+pv5rY1_W@tqmt}!S*_^Y;JxQw<^B+H<3<BUunO^1jt$LZOb
z#&3kP*<<KHxWNfaRX`b+N=Psex(?Y_0~Di^SDjJ|)D$Bk{@VN$ZT*XS<JdGuCb30n
zpq^`rc3so{eQNw+TR40Bq?g&_=Y!z}E_g3GPwDbA0O#+g)G^N#S@Vyfif!b6@qs5N
zgJeOhQ&~QyEj_Y5Sqg(noLuq28>4lD&N;J^kkQx!-YVZ=0*Zm@F@i@Iq*yTzPqj0p
z#lxTvIj)+yXDuP1TOPL|DY>D#oY%K@_ZCA}HeYq#yA1l^l_JX7o^D4l@Nd=)PyZFJ
z9rtI4cLVaq%Em`E6omH(?6WMCpY0pbY&6P`j$|zMQ>}2mg>DaIm-ypP-wSlIX4~5B
z^<C!ld)xKnX64kK0M-deM?PrSahzo%?C;<(qBDSgVoSKFtNGmIjJ&CT{g(aDtM{(u
zDR~x`|0fK(LWF7Bk(d!PKU6(a_kMfzFtUon#-B?PKLkvPg=ReLOm6z_^kN3QTUYhy
z;xTiTWlN8N_`yK78(3!e<~b`^Bw@vxBG;+Nz=0`N7TlEo4yK)2@Og-JtKZeTXQh4|
z($Z5;of*H`W)n+eEiGEji78rXD>|2(UM!lB9SE<SmctFOrw*{(QpSKeM?K{^BfEQV
zq>Py)H&ij4_%Hj`ZaGA4fH~$HXnq~jxw1JK_{g?7t)S<D-;BXsLbJDlC&eRVK}1u_
zhk>{O1#aFu3VO=7RJ(lNpd-b2Bx|P!H*|%c-h;V9Ymu^pQ!`w1;<YZm{7q*88dx`3
zv|l49%Po{Qq^Z9YnD_{S1;{oW#`zzR#jL4s{zL-WD6WOiM~GTE%4=fXmPFP<-PO)z
zkZ)vrqaD0~Kl7WV+_C|0ezoSWTQ~2gzIU`i=1}Za5Kpr#r7`seuT1~VydSinbc7P3
zKY;YnF4>TaF@pbSa{w+=FGe8D(vR|~l=G7G$u_ObkaA1FHRXuc#3AAZF^H|M-aL!y
zFYn-)^##1qbX0sT@Cx5HDbW$o+6C>@iOLfs;H*c${G_+}4b2E}grg{#EGar8$9Gaa
zt{(yUDo&cDj*=1ahL9~f7(T*roF=su7=_Npmfc~=n}qpE65V;LWy7~dK*_RnkuLS@
z7gofaCQ}^S%o?PZ>NE(C2~hZ(-62-`rvK$FXtYuk{D=Zw{g(v80)tbKIt`@3{SS$$
zfi8eiu8n%GB>hG510kbSqTk%zw?t8oA~|4iQBvdgVhWoK2oK_YK%1ThuQq9Z{Q=Vd
zs=B&NaGSwldNFFX4`IgPXy^plPL`590Hl)s$V<AVEQ90!9wFYZM+Jz?<{;~%f|->T
zlMe6Livp70H2xxrswAOx?T+i(Fj@Agf$T<{-n}?A(IJy#IYffi(eXvKmLGG~3!!z7
zS!UeaalGAxUEG?bH%#eVhN(`bb*FTQL7_T*)c0r%%^dnxoHe~>H9J~#A`Ji;FAS=h
zdcb1;LQ0YWFmi=sv{7QnCp*pbh><nOxoT=471+SAp2)HP@nbE1VeTk%iiX4e?@Z(=
zMF4Jbra?o@CaR2>ydjR%4~DWsg=)_GccgkiOZy@SGG0|P6MTrN77OnVyo=*H>v`E5
z4Tpl~Yi{Rh<@??QqLXIjcL4jcCjnrZcYFc3UFp1^aTh%XH<tjrzg822rLrmTj+3~D
z(J8l?7NzI+$RjBC=^ZcPyovMEOqWYn`mC(TtogdT*<lGQ?75}fB(wbXWkNk=uk<y5
za%nwEOy`?IM;ZP-r>p5yGv!NH8~3p`0Um;d&a$(&%r}eFpX_~x(6;^$%Q*E6f*B*R
z{2#xf7`}pkDMdn~gWEe7%+a3lQl-!VARLE4{213wHr}^Ucft`tPZN7G;if?rSq_8u
zke25}o4O@96E+2=<lqYcp7Yoh6ChuqEKrjUuj{2>E*I?s(yu`W0)LT)7Tn!GPzO7J
zfWKx%b=)20%duS{CHcfvnBIeez0{I)F5UyTfqtxEXrhBZ;8R2gr%?JQXdQHPV6lmx
zBc)2emm|Oorf|-{#x$C*HK-@Qhu4CS^GkPTWMw%T43Ztq)Rk3_AmP;8B!(&cZo(5O
zDqFZ!xa~OUZ5XG19Z+m9WjzP3z_e6!8|pAUf+6W>(JiU_j;8Rg@#g4OE5ybY(nwjS
z9=U-<Fjyi-w*bC8u}NUKsJrIZB7vAt90o_7PnSjL4m?KG%R{^omY6<*HFdXCa$UfH
z&NOI%l!3v~$m{Cx6l%cU252x5DIRVV=wxNP>W5Eo^k_gcq0}~Twy2{;6!|tPIL%Zq
z!I|4T)thP=@IA&BN^W091+zTB3Wf#O0ZK<59M9X1G4olR#cw$lAmz{uL<C@dA_I2G
zGF%P!livrAFvf&Od$J5FVR!+nInNym3$^5f+umrQo*^}G*W!vf?^rmHo~gGEGZq!x
z{uStUl+@nwej&AW%RXC5@~2376b&&otxYo>kWwgxDbGH3m<|p)cjW|9G@1Aq^UgFY
zGW2a&vtF}|`OcQz^HBWIxXRCv2BXZh{0p+?x{m>(4i8jPM(6}WO9BG$&RH)Wf0s7Q
z);5t|{s=h8+pla>vmWXz!8u`^)Q(Sun&be{P0Xu812}Z1jU;!Sw+e${SwZSvj?@}Q
zjs0uoi@`2u8h%+DlkK9n7Rlxtz4T+&31SEC)#M~K{%OB<mu_mgRO=Bc@P;n8aoFbJ
z8yvP6%GkcJJP1-$0wKtbe`H%NGE9BU1}1m*6<dM^+f2%f5NvMq?kR`hh@HoSp@gX%
zDw_kOw~_|9#>ETWg!@0}#`+FPL<t-Bbf&p1Y%Pq)b4~eNr-9I1nKdO)B0vy~#Z~)$
zOyn6Po%8R)lLS%$u}kiL2K%-h3TL~z!PAj;))wVv_zXPXdvy|4dRA;-1w4-Ec$_L`
z%o3v!yEmjI)6}YUsA^?m+E#c=G`$Vu?Jy0)&^y>lBwO*Z5&xBFLJ)Z8;U?@hNj%F^
zmfB6hWQ#@M4Wfl&hwLD2v?`vz+t?RsL+Ja`u_fh$*@H3^K$+`<nN6bYJ!0Yh2N$B-
z4ZxE)hsOeARlw+>%B+Qpv`k*s&4-E3oihM8MOw394v28!|B9*q);x?uEtYZ0S!c4=
z*A8;6O(lrcXBJbqekApJyp$D4Z;Fs|7|T-Sy$fV-m@klAq<a$Fm*U?{g_p@L%|Q$p
zvm(Q(FPN!MLb}NJ`o1lg_lnt;zABUpdrX+-b0_hbg!FNvR=%f<X!n2T67;4Tjd9M3
zfW8)Vun%I!;Mhv`TcEo;D?U~|i?m!wL>2<P4+8c?qG^i#E&dUhcB}{;tml`?O17fF
zjXpDUqBydbzQMD+O)K?w!LG=5rj%r_HJ``~EfAg%6TeN^CW%#`q1kXT)|9;6uDx<%
zW<hKXGz&ygHUn+1<gCC}GK+Z`Nz)0m5YJ+u3)OeL?N!G(69@d=d?+Uf+TyC?NS_KA
z@+WtBy#5AuiR%u9pVOl@-5_1d>l32%{`ld-Eu*!V&<;g3N}gsaX}%aE4OBef1#HL|
zx<828MR(Ex-aI#_&x^WKuD3NZKOlVc`g@u_l99}d;-Z+xZQ?d@tO5(@p?N3_wS}J%
zTY<jTV1k=Lg2B59=7-}MX{NlfDQMmwOL4P&mc926d96G`!Xi~VS_F}@QNbx;2hMLN
z8;Ecr+)R2o&+UB}ekyl&cX?f`x()E%V~uRb_i+DW$qSu(BI(fdE)AYoh|d)RJ;QH~
zg?=23er(m&L~te$ba9_bEfiC4MP0@Z9FopkaUdnM7akc%=l`jkXYfaqhYdMJWDm~Q
z)W|lWMc9B69aQHfF)GdXw)8Ws5C`eLb`TZZRo-~B$(1{u!z0BeYashq5WzN1Y}~m|
z^XMDqXOwJDIYBv7ObDJboh{({d<3MZ28H78Fd&Pf055*+t9hc3(O7luy7c$#+53=g
za1p9qYD>i)aKTq^SpnpDZh2)~1a@>w7tgj|H2UY(mi#Wh7h(AC>1^PYvtzWmjs)Tb
zo$CblWpYmf?FkG=-R+x%O2tL*9PhbA$tI36+ddKOSYEMlK$xs)cR5TFAj?TV&i?!>
zr5c)fKcO%k-Zc!gi(cUX;ymO|_BY!KO)@V^3nnu`MHhG4spMrg;ME@ioL&#|8l9Jh
zD{U_dzqJIM8FZgPW6dgE&&j5`OqwpZN8jd#JRgksJ2I{R_V|(MwKtm!HkA7y-6-BB
zZt9=ozgel|DwucnTa0k@Dix|0-DYj-dYsZXtz+HO{d*PDg!<cvk+~XGY?a%+Jbaw6
zji1q0-7~+xeZnt8l0(IZ!X*r4Ye=3NK$uDQ#3q~Yl>xTn#08YjXdvbCn?{kZTO?`;
zhPvxK0|TnfK(o(`&mTkTFzu1w{sx1MbrIQ)k$a-taU$aqXfj0MjNs~s->tcGZ6j>W
z4C=P|*sr{WVjBc#OG*ee0BWMxtJa_(rZu7?*KvS!-?XEVja)P`4*Y^}6&<W^^CzID
zcPiPSbWhypNnedUeBdmzh(EIz`J+Rzr%vd_;U|h21Pt{zynzA;DVmcO@EF?7N;_;u
zV~l_~B=|x4=$58Pu^{rN6*GNabWasp#y6zS5A22u))=pU!|wqwz@rF%J+68Q-~7rG
zbNelm$Uv53s>usX`0j8_F;5>wX5jkf#|~0emN?)xP`h}ifzvdCj4VU<KSL1`-gVqX
zeC5mZR01t|#kY)79e<5x4d~_h@;elz15jn{FlsRy>|pCK%<xSqn;YBmJYI7;9ln0&
zBS(9P5@)+BVzr*W!78(ny6Pp6$AH=^sPw7Nx~OKfcMxOhP-6U!rN6{x=^U~hCvQ4a
zyvycuGi$wp$p$#FCGL~!LDa^0H{BaATzFr)4&;{0`2Tn*mZvS6Gm1NPGxPJC4n9(J
zP`F?;<jnVyHRNa-RYVR(vCts!1Y`H6nU~X;Vn7z_Jj>P5qFSsu6ESU&>14*ZW}`la
z_XM|(4AWKR`qhNXVW^KptZ~S8nTu0f6<h6zSm0FjvLFUB=>BpQXGfFMXL9{zLewN}
zeBGy%8*^jP#x(A{eTwl?H@;v+p72x^3%SwZ#`>!oa$G9+<hoxo)O1vHPyLv)qwxtX
zxqA-TtsAd7H^qS*2IKI3TcT{HC3u~O-gt50z6TK7pd0?^LDkF@q?T$fcYraQ$5KUd
zy@K}cdg|3M^j1Lb;#Rox25@dQdVkrzEk9Rtz1jAwayjq%&LolCz2t&icbPp29yiY(
z(pwRPW!F_I;MrMte|fqs@d4TuDGQM{FtKc++)z+P1P3xT2{KV2XMk`OcHU2UE;My0
zVZOyuxR2M8TGw+YRQ$4?*~LYEl6WH{?NJmwCCpG)`L9lpSfPt-Haz`+BpjqcWI0q8
z`ejmhcr35A)m2Q)&>{9dgpFCGMQ1rL!mk&>rzr*5Ey{PT_CMx}H=FUd;-SgKG-rHo
zr&d`(sZMj{2^LlC9pYvH(*d<0NB>N+ac}n54U)qxR1g(m74KY2RXK0BY)_mmCTk^J
zLy|y(*^$XoX|OimkEDWc|Hl@`pbWOUjA1T!O*ATvi=drh34U1ICwwz5u4%Ch>itO$
zZK;WpulIQ>+J3|?W%Z8Af%FG8s?1U-u%LMaYZ+TD9-%oa+#xUOrU{fZ$|h2`m%e#+
zVAms$qJpDMX%v}vWDZF<A%z6WyiaeGG3?0n4wZ;X;T_-ICY<~6e0OSMW;<s~!s>JI
zFxs&<Y^D8eLBXQ#XJ{dQL-YF?FTR@fV!kQgI=U*fP$_<cTC(HGj`ZAl;-@l=AgH&%
z9QRZu199^HtL=1z%jip~&%3@Iw2@QMzjTl~;Ps=dL4<PrFWfc;{X{wVYBRl^(wVfm
zP?H^(_}edERf{(Rt%NeTM(Xbae}^T9D1tO|a;Ru6oA*2JWy6VSd>_eej{juvUgRnX
zqKq^@o(0P@r2>(_e#h3VV6tt>DyOewaE@cd&+^AN{++mY4l%8;I{cG4K5Nl+>S#8k
zcy)=a_0*Gv{=BB*cX5zn<0*?4YXVvUpJW|s&ZHd>1=O%T!eCW}h(o-&n=^3ltX5>L
z*5+#ku!prAQo=mpLlm^vVEZuC=>GlLbVTq0nYYVO-1npqdphqY9Y9ukqJ{F@ZYZwG
z#8Ltq`;e^=?j}Hx6AMl9lsD$+P%O?;&d`+0h37GN=L(e?t<%SbkoO>CP-16+-8qul
zjYJpfFlgM^uc#+*z5M;C%cDOFQ+Q|;TYTVai}mE@o|dzp^VP2h?iBbX%T?0bkTQI6
zJ)qn+BZ<(IUlc2T5)-c~o840LXnKEld%}Uv+hYi*QJ1um{(iU5vs-8a&Y8LPAE%fG
zCc0BZ7i7e#r<krie<6!sN9UB{rYy}HKItYSYRD3kIIi+(!k@@f#;rI`N|Xl35>Tu*
z90NbM&v35MXuZdE{sFI2pq3U|+I?#lo6q7<yu_2>IP!RZxr~Zw`Mr+mzEF|YKD(5T
zU#owljXHeM^7#W3<J7lx&M73_TMNO$^y2vX1|f6^v(GV@<b0L{&E7cmp2*5s@kRvP
zSHhvD1P=80s>>{&wJnOp@E9tko7KxA&AX37-#F(;)6gN_FOcRo3%RkM$jNH{0BbQt
zWu34O<jLJBA}{qq=z>RlDRxRRfj|Cf>7aRns2gsr!YtOr84*BN#mBflbAzl*u<!48
z&U?x#eOXNBHjX~xn>-2CBksvkqLS8pu9Imi6h9HnZ=lG)BwKac+EJ%)7H_t>EFq{)
zQ75Jz`CeP{tC4|xThmLRhsl1FJ4Iz~a1Nsx5jye(sEqSopvITYs5-Qq9|1L!V=si0
z*>O?Z+`()*R=pGn>N|X`v{1J(KE)AvBM%OZAaQT{X~V}UW<~SRuVsqeJce8~l2X_^
z)r1WOnZfyTlJV=UG>SI=&E$|M3O7hZEyt3?R^Ra@ozvxs9=!KlNK~>ZSLu~?7{Y>0
zjQc6a-Q;~$Y?<j6{!G_(OP-Nwn%E3d1*Vj5HOx@a{v4!Ll5LdZx2}$|JN6tP!paYe
zJCS@;*em2!z_TLt6)-wsczBSEmJ_n-)u2G{qKf3a;^id8nHl=%nnhQmQ-8I?$=NBe
zdLcK0#|D8m4N@gYEFW(9+h82_*i2$kpXXKO#@Dhxo;3>0W+aD9OSPIn!J;iT;-jL~
z;)C2IsY;nF(wAnUE%=JO-Q5faM_a$<TcqKH>;#$73ZmGdTsk?r`sd$Jnc_uI(w7qP
zaY5pU(Y7wKktZYa3}%!$s42QNo`g;hvb=j0jOIOQD6M_6k*xAP#W`!v=r+tfLo=&G
zm!|lR4OC`};U*y{OKJT;Ys?yT9K{_m*v7#VWFTL5q@Il@PkvBjIcA$9TGJd9@4`-O
zU-Oom&^9$=-y%cLXHz;7OPOT`GUkQdx__NOf!uequt}DLEmHW|`Umx}*?M3oucbr{
zK;o~s#pCL7t4b+vYGye%wX-xqYVBWoK8q3Gdrn(f=JE6gru~!Z1n8Qk=i7gN6Y-R$
zxXR*VPJzyb@6?+BP3s7IK?hs6c)CTCpRQ&oclo$#EfY<l-@=MSEfU?`*BA8%TCz2V
zQ;0Cam}$&@)YwBa#yGMJlYj5_Rbva&$w>A{FB&Hq>h?ki>*3NV1Wu5ygnlv}W-hP}
zoi|z#?=7R+7TrI|Rr141f6;fyow+I@D`3Iqs7dW(egKA3Cg~;$e`}l6@EHDJh=TUE
z;kRUNTVi+raz&xa-nMAp6MrP-1eqbeO%hIk{ZRHDi^s{Yc;k|4dcwUHM7BCmWHeQs
z@?~~Ra8~LFj;~GE6=F1X<7`s9yG}-8p{e4JITG2o6AT`*OEn$lp^I8}d_=mDuZc%9
zzwC+-5k*pvRX(@X3KEYt)k*mD$EL&c<w2waCZ~9V><v6YPf#)bkk@3Omob?^q@EGH
z>LLAv*^y18B>7(Y^%n>>3-NLUe-aTZ|4SfBd|jYBEw--pwpTLjA5WI{aEeC9!aA)z
z-nQE8FLm?BDK<T1%i$jQubodLbY7vfOsX@z5tu-vByF~qHL+rhl_Pcn;2MRwjJd<8
zRf)ibz<k|xDhD&J+#HawSm&UWUNy!`(Q=c=0{nuKH`am!t+*92EWtRn%}#K>kYHsp
zEPS#5y<!kcL#z~$_mf#Z)%6A44r*EGnZXk>uNUkFpSUtrgT&w+!^$f<U^`I@WpO<q
zao0MYt6?69+gANj=4?hwt!#ZSXny<F-LW3jQK6id&bdT2|0A)9odZqC7{wl52t&a0
zQCGG+n=-S0hJZ04>MXmY0ga<i+@<Oxu62~ST<@c86pMpMB^i1bf%v)ct?+V7WxTWY
z=3My7$bKjSwg=<`2NY*vHC;DSADF;UDQuB}>7ED#bLA0P=UFzYB{GVo3gOcn_keOm
zqI)uDyWzoR&|S!i$alk<bd@0L+tF1&tsF>K!KZKUx97iD7P-r~;r$cF_B0n@o`A55
z9yYGa0M*_*GAIwKagbA+#Y9J`Jv0r$BO%|r_tUj5_5rQ2VNLmaN;-rG<zK#T-%|J)
z*hp!|EwoVdZ(p2v!nI@u9^$zit`zozeG$hqOB!hgO!mFWp%c9AG$A)ZKjZ2)UAe?u
zGm63N)@034P>19Fh862N=bHh~B1qArgmpmO)pTB><HS=$ZBU8p&NV%&qEq**;HZuy
zRgQGkYb%z$-%wdkKWK*jPlC7SCQj)fb}rZ_+p14YcyF*Svs_2cNk?VSl~_tU`DdnY
zQLn?Z*9QX|o<5+zr+Aa3dx}d_;H9`ytmq5YD0GYoqa=NANr9*Qb&>BYl<X4UgYkoG
z-u+Aj^=R6Gf^V-sBK4ouVu?AK|NQxty^_5rJD;VFKs18DnFha!Ra2-wrtP?9hvw70
zH|bj__raMfw~|}1<mP5S0a_j2`l&TcyLR1G+F>H4)}u;loe7sNr==CVjsuN!-n2;_
zq1qCt{(~g}S{Rd@*B(52QL;j3n(&D(l?Pk8xHEHo+^#0x5S6KTT>u-Rj;k69|G~Z4
z2Pnzl+0iY7>7w?Trjt3Jyd&M5Fs%{#{i)6oIT}=7Iq?0M%I5TDSylA2J!stdu{fO!
zvE{3Q$9H`VRzr?-rXd#Z8~6PBfTSXHYcPH{m@SNPLX~YG-;|u!18K7QIN#mB*Bs1v
zr9ffg|Gl{dAEb2$grJZGwl?SXJ1H-_4#rQepEMdl%rLvf6$A?I&P<nun(r?wWIn>=
zgAeUMxjj<8LlM;PZ(J=HELeaH<9&|)n)uOOejUPYz1VJ=d9sT?0nxWgHts8Nkyl84
zU|%s}tPUlTFbE*11IeTyPAepNmmw62ehA8tkSZbv_BuGdK(1TPvo*`UI-)v8>rkE@
z-Blxi-TBxb+L0}qK;33m=UYO*f^;fH6(^0s)MH|wCikQPq)gUaA3fw1C|9iK+6`;d
z->@wD{Ry^D5h@j|3M7hXhk7^6HkBejKg(2He_J>5*Jl3LDguEZyAm6*VE*XE3XYff
z`lLlaR4=-V+gFlbz5!)_<S{j&C*dZ`lIf6do#cSIcW*J~3^bweW<a(0R{D1BBLqTz
z8Ml5ruVc9Pj5@A)qZ{66PWs-idDh+xVEJtNQEt}oD4pY^3qOp<wDgydp}y?_kv^l7
zNZe;Ih=*5$=;!N*=P6Jch_}2gI%YlV;9$%D@&VVILOC|`Quq%>`vM_1QTv~_{@HSj
zWStBT-9qI+KKQddxX5oCZ6Q?z3P4aa<JCZdQfR4vn4U2WC_S@A#|!lr{d&DigEFg0
z7gwA7XBtn0)2;H=nAoCzYUo|w4%s7;53Yr7&&*@jJ8@I`zup)#8l1}VGR9)(0|a;K
zGY<-O_u?#}M8_uYjD;7I(Y}^_CL~XrN6I|>F--Ra9hQvF<z=Cwj8}%RN;g|T>ig38
z7b`!4oD2Ug`Chj$kR{&Lb}o+rkEp}>Cb(7x|C=e!e^V(=F<7DC6;Ak<x37gMRj^O`
z|Bj-eB90qPeauj$PxuS5VOW<*g<24{1|I)9>4vd(5N9fX_nOLCXUs;VIN=zp&iJo~
zmo5ggJU$2l2d6|}6R)oJqCeDu<b|cOYN+ZMX?5>}uizZ4TvgCsOCh3-*x^XGoKt|k
zB`Zp!#_2|F{quox#GvH|sahlXT~2%U?LxVqSgcVWPPS#<5@OA2c=!)<nWuF9OPLZ^
zu7|vv7ya0rGqsCB$w=8BTZd7)jdOs2q^}2Qy-Sj9CGE`oH~-rd(>bpTh4$cG&C3QG
zO2KP>9mC=G)GQ{gTh3vWHrMKUM4_{c8{sDXpW%n(RYu8xD<xR8z5QlY5_be;Q`W=a
z!4Fl}b$yT_I=qoAJl}!tdh*pOk26Es<E0|5ZR1rrM2$&_vc9Z%S9M3K;r+~(MlkP;
z!mjjo1$PlM1yT^mN7iO?@OB53{%W5j3W8j_rgBI=+d}HwixnfdI=z}9xO^=YK{LxL
z{qqfW0!k93n>uC*YPnI&IhJ~~kA;MaqHE3gjB3(b$<A%wC6Q!B=FnP-lBoN=5k;oa
zIRdTmZh++xh@MC&Z`(J^sOQm|5W82$mS*nVDd>-uCrYqVR*br#etGgT{f5qXq-iy0
zo|bj#BoS+H6@^q*)fu|n?7L-abol-BG~AElfVyg_{&4-<$V>hv7Wv@Y<Wm>#_JidN
zS2g9FG!KF&^56l29i9c2P`lXKg$gr{ybZmB6W4I$fi?;&&U4&=ejGL{P-8ddF*T84
z1e_evEY7`~`I2vIQ;w~wIXeZh9t&h65tiu4uIOO3jEfL2dkz)Eka2Ii8y|ak*-*>(
z+;RT{>Fp+N!8l@Cfd_5GPhYO&)X%&MaKiQP9nQGSZe>(`5tJZ6T1A>8w-&Nsg~0E*
z+433HrWY(KqUaqRa%+-4$yViXSH2=K+aml8X(7)fE@S>8;{<W~>dgVg{q&@|#k3XV
z)lQ1dKD7V2qWl%>+YAqGBYpZ}X|E>HJKl_At|i5CZ`!5%e$q7NmY<!K6+-}-$laq0
z-t&f^`Pa9Z?8$c`wrn7OIWJy1BM|Vbk&X_zM13(_sN>u=R(0#V!0g;RA{=%2b;RkQ
z*r2N95Qwe7ym;2K6UAI94M%S75#@n;!upyQ&aFvLz8^3;q~2zkMG}rmu?O9XTu)Df
zlV7c`csXG_Z;P|GDu*|>H`HPIn-@~$*eS&nQ6{ynWuGb}>VX4+(eN(3m!!VC6Rvgg
z-pqL;hr+53wmze#GXFs4J5bvT)QquWYPWf7keySf1EU)R9r7G%!kZ^BPg&8K7b}*1
zclk4EJ|44evM-X@JkQelcXRr@F4g;c7^fc(dr0`rZJr+yo*5A|TI*vU!6Ecl<!e}M
znYb5yzyn?4(fdK-cwv!VGE>a-)RSR&L8(<{=%s(K@q#=#H%FO{&9|0%Jd71X&ct~_
zE#X5HF1|EU%B!$pd#I|ziqx!qN27tuE~&TJ>O~0fL{SYmtKJAE9)J1Z-7oIBTIsR4
zZOHO?;bjhi;(a+Cmpj{Hs|rV*^Rg*^9N!i0t`gOJOz>tN4`i^_{P8`X<w2x=RF=ha
z(&#*us4sm#UGL<D`ML~I+=Qa{wI}_kK;$fXg9M)jB-(1FEzt*PwA^#v3Ze^QwaEU1
zBGkaQV{p7+0&2+b&92k-)!zTImj#RZ^6LYC>$`w+7Ab*M7;OM~g~6S;YpszRNRLR4
z^ncCJDviXr5)45U^dqw%NNk}xg1BQ<v~LT+UznWk>B{2|Mk#GkUn*(b4?}bCD+#=4
zEfc2sb^i;gTpdGuufwKWD9$;qrS7YeHt!5sb3c;`591%;pYwms+Xyj~%~j6BjGu#2
zlmE{Mw5zl?<d<X$0GI$`-XEqb+!Yf%Q8OQ@w<A|JFx>fX<o(&r9}ylh+re&+C-itv
z`c3!dJ%3lYIoZHl!!+ci6{r-}fF&#{>W_oNqd~2p&o{4eF?;-yO8L`YWT`){olKO(
z(Du(=HLqLxE^(W#(5B#poD>vI=?yRswq%DfFM3(vyyMHzhDV3Wl6LxiIVVAiL<#yg
zH~xlyo&Z<j8^VmPCj0OI9;l_2qZ{W6l9{Vbt#xwm7&F*2L8l;S`<Cx_uMk#dvFIRk
z=mm`1-h-qID|V%ShPG6K{3U*kVR#~zwaMMc;Z;hS^rsp{*Pxu|)~+q*{JZ2xYVK@j
zF-S8dEzR^l5GkO>7Ub5X?nJ*;gB;vbn7#1(`TaIlF_}>nHs$$!25d2t=A{Rcv&|TM
zjN1>1PAs+>d-YU0?AqrRf^DaB{knp#hNudK8+q%a^WpZ6kTL&K_~Ko{KD;_Y&o8js
zP-tla&iOD$N8rui2i#zcGvjM!hyDWxV}b&HQ<h?U>>=z$?F$@I?~iHaavrcZ(MP<M
zfkNqU5lHO5BwZ{l1M-3P+szDq2Z8OU*s-Vae>vINkCM@bH|-=#ZSnMpiSd>bvWjs~
zfDQ*t;Oq!|Ws=)?@kE?oJ?NO*8?5@O$6d|nof4dx=DdB}rfzlUHxK}d;Opt({aCCn
zE?`3Ae)@LE?W&P_&@bav@-^{@CVmFZ_kauNQS+Ych4@=te&uD(gq$S*NLFarNfeV;
zV!<Y+y^2Qp=L`*`<JsN;gQOjCJX`@DhQV0_6$~$B$u?5pBc#7se%5My^UJESf~CF)
zWUi8_lJ(}0QvLx0UH$B*AA%1MU6c(46iE?TOX|Tyg8!0X8YXMZs+roxQoD20n%DIR
zG81>q*7Kulxx{h{-#Fcq2J$4yCLVx>EZo$l+|Hq$c=iqA9|e^=Bp`+Wt{c9(TRqPe
zNJ;)_i1z>&XN-J*?*nP24^8KU@E);4*PoA=M^W1Ez>ACL01iwmfb(v<|18g!&8h!H
z#Z&Y6>5YE{aE(?CXM#zI4mT_$J61|rf+A87`5&DvZ)G{66j@Kku$k>~IP;d?Ith&9
z<<&%#!S4mJ{4<;_DV(uNs`}!5?`H(44&Gpdga}q?=+yhDTk)l93DN)g?=cE|S;$vY
z<M_+HW9|%^F*OabC1MtAkN}vl<jRKyOVI=su8t1f!65W5ZCEV8ZePc{K(^`Cx3qk!
zkH3iaeh^}^>-VkiaR>gMVFQB&n_)mL8&W<B9eJ1du6t9jM^o7F{w11BA=-?u`aWp)
b)p>++bN-t<(c<QK;71##uU?^Q|Lp$&DmvP#

literal 0
HcmV?d00001

diff --git a/logo/FSFW_Logo_V3.svg b/logo/FSFW_Logo_V3.svg
new file mode 100644
index 00000000..da561d1e
--- /dev/null
+++ b/logo/FSFW_Logo_V3.svg
@@ -0,0 +1,711 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="59.111mm"
+   height="67.383003mm"
+   viewBox="0 0 59.111 67.383003"
+   version="1.1"
+   id="svg22814"
+   inkscape:version="0.92.0 r15299"
+   sodipodi:docname="FSFW_Logo_V3.svg"
+   style="enable-background:new">
+  <defs
+     id="defs22808">
+    <inkscape:path-effect
+       effect="bspline"
+       id="path-effect23502"
+       is_visible="true"
+       weight="33.333333"
+       steps="2"
+       helper_size="0"
+       apply_no_weight="true"
+       apply_with_weight="true"
+       only_selected="false" />
+    <filter
+       inkscape:collect="always"
+       style="color-interpolation-filters:sRGB"
+       id="filter23683">
+      <feBlend
+         inkscape:collect="always"
+         mode="darken"
+         in2="BackgroundImage"
+         id="feBlend23685" />
+    </filter>
+    <meshgradient
+       inkscape:collect="always"
+       id="meshgradient23819"
+       gradientUnits="userSpaceOnUse"
+       x="-9.447978"
+       y="-28.967659"
+       gradientTransform="matrix(1.6672918,0,0,1.5637161,15.752536,45.300004)">
+      <meshrow
+         id="meshrow23821">
+        <meshpatch
+           id="meshpatch23823">
+          <stop
+             path="c 11.8178,0  23.6355,0  35.4533,0"
+             style="stop-color:#0087ce;stop-opacity:1"
+             id="stop23825" />
+          <stop
+             path="c 0,3.49232  0,6.98464  0,10.477"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop23827" />
+          <stop
+             path="c -11.8178,0  -23.6355,0  -35.4533,0"
+             style="stop-color:#0087ce;stop-opacity:1"
+             id="stop23829" />
+          <stop
+             path="c 0,-3.49232  0,-6.98464  0,-10.477"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop23831" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath24955">
+      <g
+         style="display:inline;fill:url(#meshgradient24977);fill-opacity:1;enable-background:new"
+         id="g24975"
+         transform="translate(-42.742183,-140.61702)"
+         clip-path="none">
+        <path
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+           d="m 48.300305,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 h -9.625181 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+           id="path24957"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ssssssssssssssssss" />
+        <path
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           sodipodi:nodetypes="ssssssssssssssssss"
+           inkscape:connector-curvature="0"
+           id="path24959"
+           d="m 90.668816,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+           style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+        <text
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           xml:space="preserve"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+           x="69.980721"
+           y="150.38542"
+           id="text24965"><tspan
+             dy="-2"
+             dx="0"
+             sodipodi:role="line"
+             id="tspan24961"
+             x="69.980721"
+             y="150.38542"
+             style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill-opacity:1;stroke-width:0.26458332">fs</tspan><tspan
+             dx="0 0 -0.27000001"
+             id="tspan24963"
+             sodipodi:role="line"
+             x="69.980721"
+             y="157"
+             style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill-opacity:1;stroke-width:0.26458332">  fw</tspan></text>
+        <g
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           transform="translate(-1.937002)"
+           id="g24969"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+           aria-label="{">
+          <path
+             sodipodi:nodetypes="ccssccsssccccssccccssscc"
+             inkscape:connector-curvature="0"
+             id="path24967"
+             style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+             d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+        </g>
+        <g
+           inkscape:export-ydpi="499.60001"
+           inkscape:export-xdpi="499.60001"
+           aria-label="{"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+           id="g24973"
+           transform="rotate(180,73.264036,148.80851)">
+          <path
+             d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+             style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+             id="path24971"
+             inkscape:connector-curvature="0"
+             sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+        </g>
+      </g>
+    </clipPath>
+    <meshgradient
+       inkscape:collect="always"
+       id="meshgradient24977"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.6672918,0,0,1.5637161,15.752536,45.300004)"
+       x="42.742184"
+       y="140.617">
+      <meshrow
+         id="meshrow24989">
+        <meshpatch
+           id="meshpatch24987">
+          <stop
+             path="c 19.7036,0  39.4071,0  59.1107,0"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop24979" />
+          <stop
+             path="c 0,5.46099  0,10.922  0,16.383"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop24981" />
+          <stop
+             path="c -19.7036,0  -39.4071,0  -59.1107,0"
+             style="stop-color:#00beff;stop-opacity:1"
+             id="stop24983" />
+          <stop
+             path="c 0,-5.46099  0,-10.922  0,-16.383"
+             style="stop-color:#00519e;stop-opacity:1"
+             id="stop24985" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="2"
+     inkscape:cx="110.06798"
+     inkscape:cy="138.03068"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer16"
+     showgrid="false"
+     inkscape:window-width="1536"
+     inkscape:window-height="801"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     showguides="true"
+     inkscape:guide-bbox="true"
+     inkscape:pagecheckerboard="true" />
+  <metadata
+     id="metadata22811">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:groupmode="layer"
+     id="layer13"
+     inkscape:label="Corporate_Uni_Stuttgart"
+     transform="translate(0,16.383002)"
+     style="display:none;filter:url(#filter23683)">
+    <rect
+       style="opacity:1;fill:#3e444c;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23621"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="42.5" />
+    <rect
+       y="34"
+       x="-8.499999"
+       height="8.499999"
+       width="8.499999"
+       id="rect23623"
+       style="opacity:1;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23625"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="25.5" />
+    <rect
+       style="opacity:1;fill:#009e51;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23629"
+       width="8.499999"
+       height="8.499999"
+       x="-50.999996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-50.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23631"
+       style="opacity:1;fill:#00ffbe;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       y="34"
+       x="-16.999998"
+       height="8.499999"
+       width="8.499999"
+       id="rect23635"
+       style="opacity:1;fill:#51009e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#be00ff;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23637"
+       width="8.499999"
+       height="8.499999"
+       x="-16.999998"
+       y="25.5" />
+    <rect
+       y="42.5"
+       x="-50.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23639"
+       style="opacity:1;fill:#3e4c44;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#443e4c;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23641"
+       width="8.499999"
+       height="8.499999"
+       x="-16.999998"
+       y="42.5" />
+    <rect
+       y="42.5"
+       x="-33.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23655"
+       style="opacity:1;fill:#4c443e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#9e5100;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23657"
+       width="8.499999"
+       height="8.499999"
+       x="-33.999996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-33.999996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23659"
+       style="opacity:1;fill:#ffbe00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#4c3e44;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23661"
+       width="8.499999"
+       height="8.499999"
+       x="-25.499998"
+       y="42.5" />
+    <rect
+       y="34"
+       x="-25.499998"
+       height="8.499999"
+       width="8.499999"
+       id="rect23663"
+       style="opacity:1;fill:#9e0051;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#ff00be;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23665"
+       width="8.499999"
+       height="8.499999"
+       x="-25.499998"
+       y="25.5" />
+    <rect
+       y="42.5"
+       x="-42.499996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23667"
+       style="opacity:1;fill:#444c3e;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#519e00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23669"
+       width="8.499999"
+       height="8.499999"
+       x="-42.499996"
+       y="34" />
+    <rect
+       y="25.5"
+       x="-42.499996"
+       height="8.499999"
+       width="8.499999"
+       id="rect23671"
+       style="opacity:1;fill:#beff00;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23673"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="17" />
+    <rect
+       y="8.500001"
+       x="-8.499999"
+       height="8.499999"
+       width="8.499999"
+       id="rect23713"
+       style="opacity:1;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke" />
+    <rect
+       style="opacity:1;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke"
+       id="rect23715"
+       width="8.499999"
+       height="8.499999"
+       x="-8.499999"
+       y="1.9073486e-006" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer10"
+     inkscape:label="Logo_mono_black"
+     transform="translate(0,-229.617)"
+     style="display:inline">
+    <g
+       style="display:inline"
+       id="g23526"
+       transform="translate(-42.742184,139.99998)">
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 48.300305,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 h -9.625181 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         id="path23506"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss" />
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23508"
+         d="m 90.668816,143.44076 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+      <text
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         x="69.980721"
+         y="150.38542"
+         id="text23365-1"><tspan
+           dy="-2"
+           dx="0"
+           sodipodi:role="line"
+           id="tspan23363-7"
+           x="69.980721"
+           y="150.38542"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;stroke-width:0.26458332">fs</tspan><tspan
+           dx="0 0 -0.27000001"
+           id="tspan23367-0"
+           sodipodi:role="line"
+           x="69.980721"
+           y="157"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;stroke-width:0.26458332">  fw</tspan></text>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         transform="translate(-1.937002)"
+         id="text23461"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         aria-label="{">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23467"
+           style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         id="g23472"
+         transform="rotate(180,73.264036,148.80851)">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#000000;fill-opacity:1;stroke-width:0.23404284"
+           id="path23470"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer12"
+     inkscape:label="Logo_mono_white"
+     style="display:inline"
+     transform="translate(0,16.383002)">
+    <g
+       id="g23618">
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 5.558122,20.44074 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 H 1.557983 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         id="path23560"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss" />
+      <path
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23562"
+         d="m 47.926633,20.44074 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+      <text
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         x="27.238537"
+         y="27.385403"
+         id="text23568"><tspan
+           dy="-2"
+           dx="0"
+           sodipodi:role="line"
+           id="tspan23564"
+           x="27.238537"
+           y="27.385403"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill:#ffffff;stroke-width:0.26458332">fs</tspan><tspan
+           dx="0 0 -0.27000001"
+           id="tspan23566"
+           sodipodi:role="line"
+           x="27.238537"
+           y="33.999985"
+           style="text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;fill:#ffffff;stroke-width:0.26458332">  fw</tspan></text>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         transform="translate(-44.679185,-123.00002)"
+         id="g23572"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         aria-label="{">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23570"
+           style="font-size:18.72342873px;fill:#ffffff;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <g
+         inkscape:export-ydpi="499.60001"
+         inkscape:export-xdpi="499.60001"
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;opacity:0.98999999;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.23404284"
+         id="g23576"
+         transform="rotate(180,51.892944,87.3085)">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#ffffff;fill-opacity:1;stroke-width:0.23404284"
+           id="path23574"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer14"
+     inkscape:label="Logo_colored"
+     style="display:inline"
+     transform="translate(0,17.000002)">
+    <g
+       id="g24826">
+      <path
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:connector-curvature="0"
+         id="path23538"
+         d="m 5.558122,19.823743 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668807,1.48047 1.480468,1.48047 h 9.625183 c 0.811661,0 1.109108,-0.75875 1.480469,-1.48047 l 4.00036,-7.77454 c 0.371361,-0.72172 -0.668808,-1.48047 -1.480469,-1.48047 z m 0,0.98828 h 9.625402 c 0.281935,0 0.621179,0.2415 0.492187,0.49219 l -4.00036,7.77454 c -0.128993,0.25069 -0.210251,0.49218 -0.492187,0.49218 H 1.557983 c -0.281935,0 -0.621175,-0.24149 -0.492189,-0.49218 l 4.000141,-7.77454 c 0.128986,-0.25069 0.210253,-0.49219 0.492187,-0.49219 z"
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#00beff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001"
+         transform="translate(0,-17.000002)" />
+      <path
+         style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:0.98999999;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;vector-effect:none;fill:#00beff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.98699999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 47.926633,19.823743 c -0.811661,0 -1.109125,0.75874 -1.480469,1.48047 l -4.00014,7.77454 c -0.371344,0.72173 0.668808,1.48047 1.480469,1.48047 h 9.625909 c 0.81166,0 1.109109,-0.75875 1.48047,-1.48047 l 4.000355,-7.77454 c 0.37136,-0.72172 -0.66881,-1.48047 -1.48046,-1.48047 z m 0,0.98828 h 9.626134 c 0.28193,0 0.62117,0.24151 0.49218,0.49219 l -4.000365,7.77454 c -0.128993,0.25069 -0.21025,0.49218 -0.49218,0.49218 h -9.625909 c -0.281935,0 -0.621174,-0.24149 -0.492188,-0.49218 l 4.00014,-7.77454 c 0.128986,-0.25069 0.210254,-0.49219 0.492188,-0.49219 z"
+         id="path23540"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ssssssssssssssssss"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001"
+         transform="translate(0,-17.000002)" />
+      <g
+         aria-label="{"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.23404284;enable-background:new"
+         id="g23550"
+         transform="translate(-44.679185,-140.61702)"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001">
+        <path
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z"
+           style="font-size:18.72342873px;fill:#00519e;fill-opacity:1;stroke-width:0.23404284"
+           id="path23548"
+           inkscape:connector-curvature="0"
+           sodipodi:nodetypes="ccssccsssccccssccccssscc" />
+      </g>
+      <g
+         transform="rotate(180,51.892943,78.500001)"
+         id="g23554"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.36171436px;line-height:5.85107136px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';letter-spacing:0px;word-spacing:0px;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.23404284;enable-background:new"
+         aria-label="{"
+         inkscape:export-xdpi="499.60001"
+         inkscape:export-ydpi="499.60001">
+        <path
+           sodipodi:nodetypes="ccssccsssccccssccccssscc"
+           inkscape:connector-curvature="0"
+           id="path23552"
+           style="font-size:18.72342873px;fill:#00519e;fill-opacity:1;stroke-width:0.23404284"
+           d="m 67.678074,141.482 c -0.798867,0.0624 -1.915603,0.38946 -2.290072,0.80139 -0.361986,0.41191 -0.543,1.06141 -0.543,1.94766 v 1.29191 c 0,1.04851 -0.199567,1.82824 -0.599,2.34001 -0.386951,0.51177 -1.010722,0.82383 -1.872,0.93617 0.848795,0.11234 1.472567,0.41816 1.872,0.91745 0.399433,0.49929 0.599,1.22951 0.599,2.19064 v 1.38554 c 0,0.88624 0.193496,1.5478 0.543,1.98468 0.349504,0.44936 1.453759,0.79514 2.290072,0.85755 v 0.86501 c -1.260711,-0.0749 -2.215606,-0.38696 -2.864685,-0.93618 -0.636597,-0.53673 -0.954895,-1.55404 -0.954895,-3.05192 v -1.23574 c 0,-0.84879 -0.205958,-1.44794 -0.617873,-1.79745 -0.399433,-0.36199 -1.017306,-0.59291 -1.853619,-0.69277 v -0.95489 c 0.761419,-0.0624 1.360569,-0.28084 1.797449,-0.65532 0.449362,-0.38695 0.674043,-0.91745 0.674043,-1.59149 v -1.66639 c 0,-1.26071 0.293334,-2.19064 0.880001,-2.78979 0.586667,-0.59915 1.566527,-0.93617 2.939579,-1.01107 z" />
+      </g>
+      <path
+         sodipodi:nodetypes="ccccc"
+         inkscape:connector-curvature="0"
+         id="path23705"
+         d="m 24.042453,7.7684013 h 0.98425 V 6.1909995 h -0.98425 z"
+         style="display:inline;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.15297562px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23707"
+         d="m 26.264953,3.0725683 -2.2225,3e-7 v 0.7196666 l 2.2225,-3e-7 z"
+         style="display:inline;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         transform="translate(0,-0.617)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23709"
+         d="m 22.994703,3.0725686 v 0.7196666 h 1.04775 V 3.0725686 Z"
+         style="display:inline;fill:none;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         transform="translate(0,-0.617)" />
+      <path
+         id="path23719"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 26.41312,1.4850686 c -0.1905,-0.014111 -0.373945,-0.021167 -0.550334,-0.021167 -0.282222,0 -0.493889,0.045861 -0.635,0.1375834 -0.772583,-0.62441639 0,0 -0.772583,-0.62441639 0.282222,-0.23988888 0.663222,-0.35983332 1.143,-0.35983332 0.141111,0 0.278695,0.007056 0.41275,0.0211667 0.141111,0.0141111 0.275167,0.03175 0.402167,0.0529167 z"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="csccsccc"
+         transform="translate(0,-0.617)" />
+      <path
+         sodipodi:nodetypes="csccscc"
+         inkscape:connector-curvature="0"
+         d="m 25.227786,1.601485 c -0.134055,0.091722 -0.201083,0.2751666 -0.201083,0.5503333 v 0.92075 l -0.98425,3e-7 v -0.85725 c 0,-0.5926667 0.137583,-1.0054167 0.41275,-1.23824999 0.772583,0.62441639 0,0 0.772583,0.62441639 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23717"
+         transform="translate(0,-0.617)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23727"
+         d="m 22.994703,2.4555686 v 0.7196666 h 1.04775 V 2.4555686 h -1.04775"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23729"
+         d="m 24.042453,6.1909994 h 0.98425 V 3.1752349 l -0.98425,3e-7 v 3.0157642"
+         style="fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23731"
+         d="m 24.02759,11.070149 v 0.719667 h 2.032 v -0.719667 z"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23733"
+         d="m 27.29784,11.070149 v 0.719667 h -1.23825 v -0.719667"
+         style="fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23735"
+         d="m 25.07534,13.366982 h 0.98425 v 3.016 h -0.98425 z"
+         style="fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.21439861px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path23737"
+         d="m 25.07534,11.789816 h 0.98425 v 1.577166 h -0.98425 v -1.577166"
+         style="fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         sodipodi:nodetypes="cscsccscsccc"
+         d="m 27.446007,10.099652 c -0.1905,-0.01411 -0.373945,-0.02117 -0.550334,-0.02117 -0.282222,0 -0.493889,0.04586 -0.635,0.137584 -0.134055,0.09172 -0.201083,0.275166 -0.201083,0.550333 v 0.92075 h -0.98425 v -0.85725 c 0,-0.592667 0.137583,-1.0054166 0.41275,-1.2382499 0.282222,-0.2398889 0.663222,-0.3598333 1.143,-0.3598333 0.141111,0 0.278695,0.00706 0.41275,0.021167 0.141111,0.014111 0.275167,0.03175 0.402167,0.052917 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23739"
+         inkscape:connector-curvature="0"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 28.921204,8.5335684 c -0.677333,0 -1.199444,-0.1481667 -1.566333,-0.4445 -0.359833,-0.3033889 -0.53975,-0.7307356 -0.53975,-1.2810689 l 1.04775,4.856e-4 c 0,0.3033889 0.09878,0.53975 0.296333,0.7090833 0.204611,0.1693333 0.497417,0.254 0.878417,0.254 0,0 0,0 -0.116417,0.762 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23748"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccccccc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 29.799621,5.3903185 c 0.465667,0.1128889 0.811389,0.28575 1.037166,0.5185833 0.232833,0.2257778 0.34925,0.5326945 0.34925,0.92075 0,0.5221111 -0.197555,0.9383888 -0.592666,1.2488333 -0.395111,0.3033889 -0.9525,0.4550833 -1.672167,0.4550833 0.116417,-0.762 0,0 0.116417,-0.762 0.359833,0 0.631472,-0.077611 0.814917,-0.2328333 0.183444,-0.1552222 0.275166,-0.3563055 0.275166,-0.60325 0,-0.3175 -0.165805,-0.5221111 -0.497416,-0.6138333 0.169333,-0.9313333 0,0 0.169333,-0.9313333 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23752"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccsccccscc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 27.926371,4.4378185 c 0,0.3245555 0.215194,0.53975 0.645583,0.6455833 l 1.227667,0.3069167 c -0.169333,0.9313333 0,0 -0.169333,0.9313333 C 29.298677,6.222874 28.910621,6.1240962 28.466121,6.0253185 28.014566,5.9265407 27.644149,5.7677907 27.354871,5.5490685 27.065593,5.3303463 26.920954,4.9987352 26.920954,4.5542352 c 1.005417,-0.1164167 0,0 1.005417,-0.1164167 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23755"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cccccscc"
+         transform="translate(0,-0.617)" />
+      <path
+         d="m 31.048454,4.5436518 h -1.016 v -0.0635 c 0,-0.5362222 -0.342194,-0.8043333 -1.026583,-0.8043333 -0.338667,0 -0.60325,0.067028 -0.79375,0.2010834 -0.1905,0.127 -0.28575,0.3139722 -0.28575,0.5609166 -1.005417,0.1164167 0,0 -1.005417,0.1164167 0,-0.4797778 0.1905,-0.8678334 0.5715,-1.1641667 0.388056,-0.2963333 0.889001,-0.4444999 1.502834,-0.4444999 0.578555,0 1.065388,0.1199444 1.460499,0.3598333 0.395111,0.2328333 0.592667,0.5961944 0.592667,1.0900833 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#006cb6;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23758"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="ccssccccscsc"
+         transform="translate(0,-0.617)" />
+      <path
+         sodipodi:nodetypes="cccccc"
+         transform="translate(0,-0.617)"
+         inkscape:connector-curvature="0"
+         id="path23764"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00beff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 33.742924,15.878152 1.3335,-4.191 h 1.026583 l -1.87325,5.312833 h -1.142999 c 0.656166,-1.121833 0,0 0.656166,-1.121833 z" />
+      <path
+         sodipodi:nodetypes="ccccc"
+         d="m 32.536424,11.070152 1.2065,4.191 c -0.656166,1.121833 0,0 -0.656166,1.121833 l -1.248834,-4.370916 c 0.6985,-0.941917 0,0 0.6985,-0.941917 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00a3e7;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23766"
+         inkscape:connector-curvature="0" />
+      <path
+         sodipodi:nodetypes="ccccccc"
+         transform="translate(0,-0.617)"
+         inkscape:connector-curvature="0"
+         id="path23768"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#0087ce;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         d="m 29.890591,15.920485 1.344083,-4.233333 h 1.30175 c -0.6985,0.941917 0,0 -0.6985,0.941917 l -1.386416,4.370916 h -1.17475 c 0.613833,-1.0795 0,0 0.613833,-1.0795 z" />
+      <path
+         sodipodi:nodetypes="ccccc"
+         d="m 28.610008,11.687152 1.280583,4.233333 c -0.613833,1.0795 0,0 -0.613833,1.0795 l -1.756834,-5.312833 z"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:10.58333302px;line-height:6.61458349px;font-family:'Univers for UniS 55 Roman';-inkscape-font-specification:'Univers for UniS 55 Roman, ';text-align:center;letter-spacing:0px;word-spacing:0px;text-anchor:middle;display:inline;opacity:0.98999999;fill:#00519e;fill-opacity:1;stroke:none;stroke-width:0.26458332"
+         id="path23770"
+         inkscape:connector-curvature="0"
+         transform="translate(0,-0.617)" />
+    </g>
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer16"
+     inkscape:label="Logo_gradient"
+     style="display:inline">
+    <rect
+       style="display:inline;opacity:1;fill:url(#meshgradient23819);fill-opacity:1;stroke:none;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;paint-order:fill markers stroke;enable-background:new"
+       id="rect23817"
+       width="59.111"
+       height="16.382999"
+       x="-1.110223e-016"
+       y="3.8147118e-006"
+       clip-path="url(#clipPath24955)" />
+  </g>
+</svg>
diff --git a/logo/FSFW_Logo_V3_bw.png b/logo/FSFW_Logo_V3_bw.png
new file mode 100644
index 0000000000000000000000000000000000000000..99b9b4f9608f4e53b86ff83747a114477004c9f1
GIT binary patch
literal 13369
zcmXwA1ymF6*WMW2&1h-qP6sF{ASxv&T>{cDx}{qrCS4**4;3aLj2s~;>gbW1NP~2I
z^Y=gB;cRDTZ0~#D``&o&bMKNLKh&inXCnsy091PSwTuA(f;Rl?K2l=*vycAE7ytkm
z=ccLoSWi>)mXDwJb2krX0N{33M3(CP-n$(Aww6^DxzvHQbVHAe#gdqOr$rdcHQqBl
z3y}J9L{T8eFD#Mq(!IMov%e-b^<x8d!^>Nzz?C)JTO6;zwWRQ;q<sv6dv`~5XAyX<
z6aV4)FT%1Hd07ty<2<~~NINTN_(=Iu5Pc6K9x|HjaoC>h?f;b+_}DRirF@>-F$5^R
z3mJj-@-E&gS^NYYyXd2P@|tnQf5kUe;{N4ez|6Yhn0De7MApG+>adT_p&Z@qNAmG?
zIsGF#T_&^2@Ti~8@rTSVpN$>s!wy&y4rYgCez{TeC2Nb_ivzIA=NQGrgX`IZ1*blh
z?(NYiM`l^cd>OV|v$)G7!jGc4Ch2OIr`Xq16wU#(*?L?!GLr5PjJA13anA)F5|Tnd
z=FjGAJpr<%Z-31_J0d0Z2C@9|G+YEp1VwiXS<CS2l2075kRvZxBTT5l2%^wm^NY_e
zlp+8!(`K8*N=k$SDLG$v_IFCg7Oz#mZ|;(ezx4a2`jA@@e=Wog2D(~+n}2_0U#qk6
z?~wW2f9ekaNbvo80E4U41MzQ?K=ll@N!BR1XavM>xd;ma0Ji{oTK7zYXSa((F1f$|
zKrMCI9-EPlz9hZ(-r7UEAnCQ7!-<8Zfu)0+k#-?(GCJkGxOn{&)x3)PTZBCDU4F)7
zfjm+Nsu{kaLsT*3rS0pmjXQ@|i}@EJT{ed)eZ^;sVLSQxve=R^YEqs!T8;mIx=kEF
zA4BV)Jf370Gj=!3Zhg&y2uw47n=V<zhqOsyPkN6`N?dsn_|5>LkyJHl!Aq+F7>zc}
zcHCaW<#CL{{KjnkWT1auM;;L>5dS1n5g-oqFXMUx4FBA>FTD4Y9>s50@$R$S5izyR
z@J%6cM;1q;5Vzep0k@uq1}STsMxUOposgZVU20#G$Fo(n01{$?3xO+3=Iz&xZXNmH
z!HUbvTgok0V_jW^;EqQGGysNZZF(533^bm0-3esJVh7mcD{_$|Yy)6{VI<Q+M&WJz
zD4U_BYJ$p`u-ED?_qFgx)q?*fElRVTvVOJit4DlwK_qc>>rbcQ)HEz5%DIkP*4JJU
z6s<$wh*yh|SRkPefxo{L??)M^<Ttpt4AdES&gBgh0($a4=NV4SBa6SyGKX2A+XV#*
z&F{Va80{!;%?tPmxF+l%vFbZm?T!CWI<x227;22PT_W<LjbSg$FrPF{0qN~Cqw<ir
z;6A^`-~^M#be;;vXMX44nh59Zh;hj2wTv@x$8cZ->|ByH|0ySFc7llIosaTF&8>(<
z8ko+5q=}~_u<~WUyb^<Fq;yL9l7d>&GmHoZ^ZVrm;mN7a;WWW2{bwNAtq~17t_E~G
zq;Gvg+G=a-1#;6gXcfJT%tKxywgfbi2+CoxwEd2{nCE4l8C`JNR_KMt0d{1lwA9pR
zGy|EFGhWO>-+S$AMN~%<J!1etJ>%CMS$j`nlUtLMcZ{eBVHb!x1}N|^nGH+ElmdhF
zF8`@n?dTC@N1ch-C`k!m3~&w<U7I+GH92zUozVR*0kI%MGa&%MS>eW6qlRhL|E$pI
z+XfQaY*-LQ;RBv1C%@{NMt3RJPD>g+Yy%1rWb$+SJzY>dj8+w}!GD_fjtXek>8K)-
z4c6Ndk&BZ0i5`!T-{$4}*|Y8ysotB}$3<WJ?+TUEee8*HJKneeqk7lp>X~-g&M$~W
zMn#&d$(j`RATy?>mPWixc!5P$`9%&P#Rh*r%7(*2J=T*xFYB)9aY_MNXPW69Pi*O{
z@XKYD>>$%}B$uU;=P_xO#qeF2+om>?Yh3DT@zWUioPh%)ex)ht1gJeZ35h~R#(;ED
z)dv<cC(u+_5O?nBKVQ3Z=WX!sNR2mK?<59%DJPFoMZVJ`_^ROTseMBD|D(a~;WJ~z
zEo4wJYiC>v!33l~q7~5krQT+RffoXGB&QR+15i!J77;>(C&{u3l#%z4)dPnLz)*wm
z{|xEWw+?=#i6l)nOiBsiRubtCNz{kprRqCy%dG#lYh|~JL`^frOC&k?HX6COyn6K8
zgGY;Kuu@bjm;)du|EY`Z%`G@tmavczah;^NPyg+>|4euUgH32jjiwNg;gNA6@TuJ|
zy5d*hal(=F<UMpLODw;-LW<HC(th#z0KaOvE1PWipUo!B(3zJ^!`$)T@>`{|>nM*f
z=rP<E(#ny`BaI^+oA~R@<<qLg%;@Rk3^NC*07X|F6bqMo9&D^AutgGtQ+9wlfZ>9Z
zL?h{lBm2%H;sJc5h`U#;bxZ4U2SwfH%&{7#T7DDTg3P4cHYX%zomGF8CP@|5yB*y~
zT%4_p=E*{_376J#ujo&xWu;xj_en8-cHzXxYhLI+e)!MoR>JC%#fvA)*p358f9qF0
zS+x+y!WD_A2i7G@O22~_K?w|zvj~e|GRp$#cp`E-(l*w3(nPBCZSL&B8hsN?u$|1F
zBnG9drg;a{)gKaw0^HHNlwY^koMT3GO#T<ul5!Gu2r#V4buTUngIN&(oW=UmPP(X#
zk9t$gy9z-Ib&;ssS!8s?aBrPIMI1HHO}O5HxR>)HM?7#32RvWUpG`3;aVsUv?z-W!
z!{>|g!1EQMkgT4GuO<$)BA(G+Ll;);+auj#7=MhR)tfhz){jC75-|#|pgCN*d5u1W
zVO)edz((e>ac0ShKLsoEPstFhIHt#?1wgC-x3;e7!5)j?BJp#AdOrkAJG2du2x?z#
zE_TgrEBc07Pvs_=kDudSw*D+7SY<)enjI$Q^CoTncIQqIU<@g)tX>?Bk)uM4TT^)o
zxuy6!Yg>7EG~T@klG>v&H2GoS)Pen(HRu=BX-oKk@H&a&cUG3AO##OEl9M8BpvswJ
z!yVOM0ahm|F`(q86H<*9&4&Hx25v@*merSET@*~syCzr$Qmd|Zk4G=Lwbcx0X<8~9
zA2{}|MO?G@1X?9s;s}dgQn)FxVBg^5qbfOq+*M+M7P*PwJj}#&T=Fa+nBTdH_^%R7
znYW%3nAh(FTfK|>97ByLJ{8Ztu_3`x6cNsAIKzMTzB*}o_CWg6_ATG_9vy_)j2C_U
z{jD|zUwf)Blt>(CNOHU?V};umNJ3aqtC}9MYuOYAuk{Vrd@((4BOLHM#7=RZzA#q-
zIf>ABbBnxq@pZSRhio9kjW5f2covZ>_O%@<wv8wv?znV5#(8C0);yWduwWBs*qw6&
z9<7rM9DkRO$TuOea)r16eK?wkeD3^KNQ@x5WNOXdC}+g(CPrxAMV}3#ZEO~{TvJ7Z
z8eY-D#i&tL4jv4#<#Ws|4HH_25)d#sWrHtwo$$_v>#U56(0l?(YF7IlDFTZ(-Mdi)
zTjY=zkVap>l0n#`^lj%HXO#ABt9z%D6tMhq?HQ_tRNr;e_&sN-G1(`g1*~)9KXRPM
z=mw6lfD@<r#2I8`bjZNr`HOQu6q`Z)<<?9Si-cnaZKnr`mC<v}Rz)xKue8jYKKrV*
zKXE7Zg#uW&VVNr77Mb=^pv(F+>=zuh;Pqbk8|NR@Uk`X|-zXpj=wt791CiIxa!_{r
zOgMvsw5M-Kkh`<%Q;V|S!#UzHKNF5y*Dm3{?eME-uId_#7Uo7dzpMR-%TN8YN|x^)
zHmic8v`@cCYM<K1d`_zWZUArbu=BX_7`qDjhVJCrJ{T`NYpbpueuj{X(0E(L&}5sh
z4`}V{42u-;;oD;tsd`FWuyU|=+|879KP){GF`D*6i(Saw;1}a~2IPzYd+(E2RIA2}
zl7>b(MXvPp?cN#WeJknYr}VbVA9|hnW>rF}tFL_KD<356WTEqvyn6c&#$KuAzOMI$
zTU)+W3L0Spw^g)QC{q70D}PkVTIxn_{i@uO`KM5F<I$R@9ScT2xgiItuNEGeyE4z^
zEDg0>t)V<SAoogscIVf~hzWw1QgMa;4C{83bei`1bIn9GCp_d_eOhjKLYyqtH_R*i
z4b2u0U+Z)@fU=Ki<E(anJ`lf3X1DtCb;aASY4ZoNG}zBk46fcvyA;V1Ds>+!13?m_
zUmh{Yi^sov$a}wE2dS2D%mS3u^Dx>|v;xO!t9Rb+H8!`z1SK3-MkiKDPVO=JbnO@I
z(_2C<Qh`U^^<Yw-W@plCd!^FXwgu{Rf~^)ySZ66{X8)39Ytn30CjIB$*9tGZ4y5^4
zRz?}Im+Tgr6%4$x3cc|>rw1-YvYNPvPPqojw(>dZQ@oGgw|jZSFQS6!@a~+C7VQ^V
zS?OoQLWxTNk-Yn4S!C6#+z0z)do0OfD%3KcipkT&+RDQ;9JbDzXq8M<=sCMkRV9b^
zolyQ~HV@BYz5~JOqI(mT4vf6=mVhg&?Qz}3c{I)~e5?fYO}M$dT}HyA8}=tlQBgq!
zqzj(4O&<9mw&F;)S4uv%L<9zPfUJnOsOos(<jbQ^Ps9Ax`#LXd7)$LFT6PI;;vBHn
z5Y`+0yA+R+p=m|rpY}ZN2%ViX?EA5Ltyj}OF;Hu`&hALFCD6eHk_Ej=ig$gr4UY#D
z$EIlX>8N8+3CAvv_qLvK`Wi4(Kr%(&@=d~tC7g2_GpsCDuS?u;e+ag6J6;%?ubw7M
zzb`dsyKqyr83?I3u2QIaryZ&wGxnF8U&fnDZt$;XPNkAgi4<;73v=@w%PgO{bIZdQ
z=3<~*;V9Km)JXHuci%?ilDaj-_is@{SEL{1gKIT9*p3e#)R`K_B&8Kc+u(&Mhn&LU
zcbam`ucR=4cxez6UPC><n!8N#TK&UMqhZTQ#^ZF4Ye5Rq24G(u-j#UYy)WV=bmn!M
zxRA7YE7MC2^8D5BLSmAH+av*q6xU9b1M;O0HRgTb1(QA7mN%dxQPt#(^3%pA-;nDL
zVr&%hqhF+fXkc(7ao1M~AASkgp`2A)dnaR<dOWRxBcLgLe@5+*Lu$$mP(k{Wy0~;O
zg*z^=KNtFUUB)g2ZzBrGe)V%do;_b6>O*2gXBtT;CPia9C2vUc+N-EK=+=am37@`(
zwFBZ@h76{v*Qd#61+I{koV?pzUBTL>xsR7Ac}2o;4H|0`1+=o7@D<S!k5VIwq~1y~
zV1HupbHLLfOyGCsd$m;lmk(yx&B;b#JdBVX<2TBrt<~Ky6F0lhAMYpZv>|~B$1ni5
z-lGZ!e~)#(L{KRUwC(`+B(ptc2l49Vko?ZbGh{t7;I!JDaYo9PcQEa|@Am$>Gv;}+
zxJUswVC^ZUp-R}&2%Hc#zYa}d4H6dlMQ3m}NJqp~OS!Pgu51qYBVdz2^4_!P=o$gN
zV=X6d*4vgcb)VN#gao5-a^}Z23!`OEBv_!_eq=9PE1@k7RqPY@KlP*Y`t>O(QQViT
zDnc2yl9yQ&(_!#=#l3UpRts^1&#2N12L0y9gSpxl&t6_4OdEbxMFEN&TyHph68o5$
z4B^h=A!5F2j0Hxg)p>7-KjoHap{|HI^It}BZM?A8lYG)A({C;OFcdEL327Fnaz|Rt
z#rSKE)A-Q)8gfxq>^da5?p~x@j-xH!S0f##vuw1veKPw}SMFf4tN11-zXzLeaALq?
zibprXtZngo_b*A6fCwts4BsP1^Yz-pYA);#GwPG!om53inQ#l<)C^{1J2B^%R?65;
zloW<0=I2y4E_kqvFPrT9ML@niWzf)sI7a}2w$2vB=PSMPl&$TfZ#g5c?K`%OHR9wy
zVH}>*e-`PVLW^9dvpiGOFxzP$wTF1)j!0KI7`cn`{cKMe1uM4<-t?_Ci;X5>(8LoA
zK?p9AFNYQOY6E&!OBKozhNX>{JFvluO8LE*d%9kty=5pc@g<i?J}X})JJgAHS#Ulo
z+Ak41IAN`@9c>G^sYgx}r--~?AB{*j3$|W4XBGng{Zg&P%vsHLwCe5=@+S6e=KeeI
zZO-J3g)|kv$4JMJ5vdGSXIx%h=)BkJnQ;07SE$(9uq~CpGz+$$ae}<Cdgmctqfd~`
zQvr^w#H!455=ZZ*vfsb&-BvjHk!4P%*y!x<QD~)*S8f>^nKd<``YbcSN_k9)yHL+5
znqm?jyxH=4u)^`pJ>3n*kzNk|t8|)dP5h0(8;x|2$%4hcQm($ymNwBFn)vK*K(2YB
zkt}Y0&Wc^7O-^HKa^^H5`gCf+dfHRQXKpFM<p43~ltNEj2VkE4)-#op*&H-L6z`Nb
ze=Xmpn0}`e^IpwO0rnwStMh?W%hD6x)m8*YpPCrq*sH;cRi{gX0!hGFvsH(0G-wfI
zzCH{qM^sVM(U7dvXq@?p*uygCXC{tW4Wl+Z(#7)*I5FEIM}LGd1|CE{&)ih}onOeD
zSgX#R^eTHZYl}1<qnmlINWhZvsVNyqql9DgWraMJyiiQY<-#w935iv-E5U=FCsySW
zn0;vf6I$o4mt&UZJyh1g@jksE8@Xe{!r%k!i`60z4tU*|^q?D8Q^~Zbii84gki%|N
zF2VW!7Kw+0t9o3MY5;E-HBlSuY$+Q;as5^-&$axpcs|L;wCy{laPPykZ5LM+e{2@x
zNpM=-OHcnbd8E5><9i$dhnH&<Q3KAz-Yrf%aZNUE`vb$wcgEoCgPhDy@8(%eFkk-Y
zBe)jA(j#i0lWhd0N3fTpw05A#yz6bgl?SqcJPMB%o*CEUP7CkpJ}0QHI?H+mX;VkF
zcu2<uua-EhlU_Qm0v=L?Lv#t$r9S;?hN^YAc`Sig%<~jIO)kf@3|)4@2_g2bT{1p*
zon$uCMooeQBn;mtB{m?t@gWRok^;d9BDTmn^RBW73)$I6;UTR$EEw%Q;g+?-Vv6g>
z6hA7%D39fAP^RU!B=2zMlByy#J^KS8AtbJ>S>a;w@_4BXsw!4RVl%?^0yGEwmhZ1>
zR%Sx^RUXQ14l2ZCy1ey;+z5C73VWZh^Zc!7>zp7;?Z>i)w^+n^io=G51h1&T!4ogs
z?nh#&xmz%GgW?Lug}#v0T0R%%2;^vXqxBLnGdn{|*WCkN*Gi;T;%EYXa%XsAG(8m4
z%joa-G$TSqPCH6x)5ypSp94z2+#M%f^ApGl*^J9)r&Kv$y~g`n|1)DF1OI(r@|J@v
z9@xVC%&9;-AovrZKe)M^qJ>e>fU6oi0kgsD;b-U3_sWVIk0ei%*%jJ^F@d}xl>zLW
zvN7L+;)wD?(er4_<vc(HNq8&%gmvqDnl>vp(k(KHshNv1P=6OkkFzuwq=DecxA)u^
zpzkI}_munHd(}<8{cwLfuWAEmkR7yFks!)XN;Seq)r5Mxhp&n}!tZ*B<70t6@ztA0
zh@qK_tTBV2Fue_FsOGP8!1aza(J9q$7`kO3e*W#%RcEN_betI+wJCx0>|88!YDNPJ
ztG(V&3#o*HImv}sB9Qg){{HmWc#VZ&{9`k$@bPx@bzy)_3T(ML$3@YPj&flK!HJ;|
zQF;z+1qcD}VDdg#M(A?S61aoHKrX8t@Z8G{dHgOptHxt<EXWdp*S(_yE^{fy#W=)V
z86US`phG!pn)r^N$?yBnqSX3urxWCP7qQPHBI0i`0tF+y;5I;4?F7y$FY=*KL~!3!
zhWVi4MeN?io39^VDtFMq+*=1dyr#GB85iQvW5Ko@mPf!=keW2*X()a{XkQC|u=d>u
z?}FfvslI0tY7!DN;mrLL^#&!16y!b~+2Ie8XTOsLx4-;y34j%Tal41|mOfISLOsn%
zlg15(-A%2aITfoEa*Dt&W)avu4*W@3HlFV5Rxak80?Xs7&!Su?m@FEG?Eg>_TnR*^
z`k;|Gq#G`nLaD|s0h5RB_|lbIqovEe8X?t$1KF_7jUCqFaoQy7+(11Y@F+;CW!Q6M
zSj>2UTwhxT+HL0EA^4ath*BcbIt~?x=qSw{+s7gW5Iu_J=D@GqbMHp;jI(iI_e-?<
zvm+o4YU9HnLHuQpP^rjd&%WLKoigWqbL+Q4fjrd8Jb}G~KVioq<Cb+x8YF{N$@|T4
zY2v63I^~x5?whn)uAiCS-X4@OB?E8{@xMtK*E*capKzd^IPskWzkjOhf1>6W%yj;V
zpvlwW$Vz*?oNP(;`D)<rU$AhS)MpX_hM0G3Y=}eOAMc)gUoDraOZXc1vGLHw>R|p3
zEz3{y5vl6LG~#xBQ<OI69)AnR_w-aX9Nhpc%KWz;)XI4xt7BM~D@N4llyoMJPwdaB
zWRo^Ox0JR#l;xwcM3Mc&T*`SjWJnxcl*E=C!L<cZM1C<u*Ncey!^-J7+r=5h2QBE9
z+jQ1dsv1TD!I2H$QDGTzvBtxv@!=2Lxo^o2RMooIf8{1t2G@~tB#3V8KTS~Cm*11|
z5pHs1g|HL&6i(OdKll)sP=SJbmU!@*C8gjaeQZWfMcXP9dPTw<k5&=|>c6|ZZPYL`
z&<qk8v-~iswI1@uJLT~06`8r%iZmvD&2dB2it;4fDs8(OAuwMZ(;nT0IndrIs#Hsr
z!o{ZkmW(ZLZ-?8GxSdz70xB~YJA;R3(U1VF9v)e1;)Nx_qG5GZ3n54lvU@OARBOwF
z@{-f?2kI5&f{I5;o4K%Un-<)IZMnxSJYbDgziH_BMQ?O9Nc|NaO5OJux!xvFgjO#*
zY!K_0#?w+waG>Qw)FUl!X$ILkmL5-<>Y~bZIM3WBN#;2%&#UaGvT(Q<@#WJY<rCBk
z+{6A556Ny%r#afHXnKuP6OzkU-ZJeF&9+a0A?$7GKE7+6S0Pz`F4=TT)nt2Z_jF6X
zT|_)hAEkD|ba_Z~BJPLMbGm>TuN*Nl$qz`4c$tBX{KP$nh)?$HD-dgT!s+qYCNmLL
zCX4sK(^G5-+*xODq$h8Bn(0~)BPRcfmHJ6XUn{2b95Y<cZH$i{li^3&3gBjReav?s
zrh!iW`H6TzB)_I@iH4{pe3HWwo&$FVA9?EZmen8es|<jlYpP}1_b3;3y>!@P6)MSi
zI0^}{tHZ_2&a$)11D#uM-7+#((^L*tD`<i#@a2q<zHUY3KdfX?6}g^ovjxIHb8H?Y
zq2Hs{bvqYMy(qgUJX7j<*Ln+faIW!ljVrZ$K`{G?N-9t!x2rI|^nep{hKPosnHMIk
zW!eX6=Z!OIE9SQV5M5sioy%EtrcJ>CPHE;npCvwS&asnRvg6(8a{4`A;uE+x%d&=B
zjnNS9?^-0?Oepiu0p~+BHJZ4!yqcn+CSOD@`NbqF?77q~c5thY)klZg(KVx<@!Zug
z4EkvxkJsCYmDuycwQ)VdfQ~u<$$%FmeKtqanhs5GUKv5yu=3*@hmG-Jw5-w4FS%)u
zYD_sY;#9KOu(#^-SrBhnNSW5pEsel4Uziw!D$v|#MG>*r_;9WL_a7}s?$*g^U6frV
zwYTvRaM!6rm>QO$g(|^EgIi^tiYRf-l9)NOqIH9<owX4Qu~IW1_}K1q{tHol<18M{
zK?&*;M~uE5jorFPW~IEBZH%|A_xEXC-8)uv)f2;}*kQ*6V3*$C6$x$dw4*4ua!eCL
zMvx(dOVa7cIE>BA*pk^W<{r|VHOdL!v3RPwr1NT2Wc+>^_h;+h%0&27B>Ukmw8(k-
z&tJTo0|yGv?C>hx@}AC8rI2gc_BB{Od_Rx&<TE?tau;YG;u|nZXc&B{pFW?Dj7Poz
zra2Q8DbBR+-b^0pqK1(y#GGg5lO$Fo5O?ri?QKD61vcP~JZ?~yQFi(Cd`PqFb=64N
z<hu_7GXTp?HrBR^Sq@!ic<T*iAJY1pl;#Z<#BM-T;fTP)Ucdq#{(ntZJnqE1lv3Y&
zzAFl~#qG3&tDsETw=y@o@`EDG=6G3RIq!G9K4e?=Oz_CWgQaxSTPiB{6g=%6I8XzM
zxl*a5X;nh|SgyNj>flF~kg)FAATv_nZRYns!awZ!&#GNsmy1p{6G$mnEnXE$DVCME
zhd&H}v1y^I&{InR;^)ycGK=%=|ElydBi-{HkIO`YkH#IOLUbnyql>0OrEp5?ti0O$
zEHyqFWvjoFMop^2gw)!=OD-%-5y<pt^Cr(vAF@ldwEZ!ju^DNiA2<RDp1%zi=HiC$
z%!_N96F#8Xf}bAxeEFie?tph7cYUggRdNq@F?0OZQT81}7kH0awJ=rllfEM;N#f2m
z8c4S}x`{B9$OSj~`>@+`_cP@nNX$de-7wBp@*ik?mjyH|z9_~&<YGQmb=jXze?_i^
znnha0W)$Jmwjyv*it>~Wf5Z54u<IkE;q5!9>R{z-35^A1nJV84;yn_pzr{LjMA{EM
zN;MS6X~G}C91o}K1?7`6YVjGcn0_r@eKt7zBoA-ELpq!@Dg^n{z}9N1MF-hgFFpJF
zMF~^PDVsj^Mv5q+NSdI2PqqWjaUZ;eK~Z_uP8Rqm$q|e%3@`o_mu!~xCq{Hb?+W*;
zngQmo1OyjlhOuG`eiiz4X@{=on;T+1jidp&_7GbF&bP#q``mcMN?d1p1iblqN^e~7
z_Ed>#PGZfFFMFJ5Anf)#t6a~t=6szuZUtJ(aOOlX+iCF6e&(PLnZu`O(z%jk6TCe=
zLDw)Y2;<XvAW{flrmAVM)+czf;$&C!<c~Egd3@`=l#R5x<Zv5UWJ*jXHk9{pnoPEp
z6}rZ!|9Bvh7LV<p{If;|%eLabe7WCm=X`$4a}Hkj%fWxIKQq{1BWL1kDZ9hrG*up6
z?ab&Y98=`s5jg^?+X?E_#@Df;cn=LR>ua7Jb)6_?NVYnb8+P_y2&~ZGN*$g27?`Zq
zqAoCInh2MjE#un-iQ`?8CjmH)sye0f^;K(uR4?%6nTdLYh@!N4VW6b;*CnJdI^wV4
za(i$K3Y$xt@7$a}<wCn8&ZFm6SJJ~t!i({!SH&K`=NGMk2y~#gV(MK%l1g4a-UlTz
zxOHv<?$oLSOk&P0JYxdyt9(Sge`V_J5yd<4^W!!FhVox<rMq!X4MCRj%M7s1D)40l
zKhGs&;h7>pqbJmyGIs*e4%g#)MPOd8Kp7Rfu^#8$+hVnt8mrT1$L9ZX0Y!`RX{vw>
zAh3Jm>%1aCKF3Q)8!x0q2Dj$XV-vyZ2p-Al8)Wg_#}~Sb{1bI|nenvP<)P^qYP*fa
z*SBW5Ta85N5iiKD10E5S{2-~oZpK0(-{-4k#J{vBD?P6bp#-!@f8tKDtP-y)pJP?(
z@mUb{HA~mBl8la}+SbJcx{zbV;bLUN6HL6}nu=>dWdhphJFf8x3Y$$#%K2KzFMAPG
z3nu@FCIg7@tG-t5B16dB7}AW0VM*%8M9arM0j<4+ov@gU<!ZD@E;ZldN5zBbU!zCU
zc5fO}J#Y;`j^~JtC4$awZM8azEtg4*lpg><FY<2|z%@#`!KwB%frir4JPQ%`p3Iuk
zQ*$0+mN;5?p;Ds)X8)^%eJ3f&5d4*pTQf-N8aVLLSJ_nCst71|>~RO5{dq6AxY=f}
z@2=3}J5FjcF2v{?)qe*sj>ea_EY!%nr)zR{_E}U50nw$b4MD;!0v1N$3O)a5C1Aso
zw);26R%Br>?(%4@e^UHJ<;nLf!XfAMz!sxp7-A|%@KE|w6g7hH=$`nlvod4UqXkOL
zIG(Oi`fdk}C<v!a-jziKFDYaX#=UQ&Ych_x=#p&FuhJx)HxZJ-(s~pYKLRnwtG#z-
zg|pj@{0iaOgX8(W7UX*L-*pJaAi3T_6V^8&ZroP-(RVS*_KBhIm7FM%NleU$o4@Kr
zx6fz@VjA+<;$VRTY}0+#+r%U_l)~N=zs5n;@nl`C#V~E5g6%i6_s$`*K2%Iso58AE
z$d(JF!xAx}xLSJq)Wl934|3<-C$diV8{aVVx!8-ont<D_hD|7SzTnJ;oL|Eje{Eay
zDVJK7LnLbNl`2Xd?_0lMX!|~d9)C4_!}Ve-EK2ot<tpwaWcAy$WUpvb;<8F_%y^ZM
z5uCFDQYMMT)VxbhfJ@xS<qp;i7z&TgeAbCrsO&ksU@99|d|W8-w_?%Xu&Li#4K!al
zrzTPW>QYpZ7{EgpRnD7dhozX;H>n7v-ibhwy+_G)A}0-lCAv-3y|wY>?Q|`WMyg37
zbkp$F;&*iCljPs2FL2ic79$hajO4UI!ZPc(?eN`Bd+n&FUdaZxw@1Fj<x4(ZLp_SN
z87S0P=hHTN3P_VF`A&6ek0D;2I(1{Zm}jzdI5&@BdGVISko<l7Xw1EY<4gia=!mYi
zD28A2qCGqFMuWZ0Wp#J-3V^V}<H~CG*-om<MlC_|hjcwG$AdVPA9B#tmC<+yFD-V`
zIxkmsi`GymN9xV<Ic>&og>$dU+f^q}KG!q1cVrX-f&Y2kux`rAq15qSJkV@w=^5Hs
zS3Gq)n#l>rT=E2u?{`7?&aV-iz~^Q8RXqZ{gWsRo;L4gYh?PA6U$$i*InWE(1COBw
zbC19JjfOb|*AF1}-gf*3Tn<iL>tVz{R4AhC3{n+M@x0>d{y5cF+PTFdI}4diFWZ0A
zIlav~OO|AqeQGuP%VAw|RIuYk2AUq0Nz!?LQqn*GRT#~emJw$iU0ZW&NmaJfChDNk
zw(CxdVeZXO&ox7LJocZ9spfBa?^+6O>zseHqRhpSxmv33$=gr)jpg?TlqbRdkF5RM
zveEIf@O7!JXMQ0Z4mrAwB1a$S_R8V5e6<se8OZSFQAr5V%~v)z_}X$wYJHg&mxq?`
z0ghVX=+NEHMD=CmDo1R_H_%Vf=6!-D_NLFv9ri=9W_`Wa$bkWpdb|Q<vIN7Ig%HKN
zAr61j&L_y`Hq&zh(ez`P-CTT}qT4>~Y2ja3gN^VcyO|FWZ}^vlO>^FF(-ZZ*;?fr~
zWY`|&{RvW~9~0Ng^TuyzoqG!+%9)xp$081>EKk9fB7=~Rl9b36k>Fy}@j{0EM$<OH
zTqlJQHSuzfW%!%S+WDszn=!?3aZ9TNJkP$0MXv}v(j-G^E3>AGzIL>4<+yO%Pg{%;
z*L_iv&>-+GnAxY$bUc+AnU!$7>hmR88v^ZV`GwIZ?<D)grSvU$%;`6tVFX^gy51;B
zJ#%0X5HLLLkyvBdeX*aG(f4FFz<oX;x6Uouzv<MEL`t&;+i!z!+1z_7=CDRHM3P10
z@8jk~VW`?bUl4DD=S!6c%-4rtJoNdum4EKVo5hU!Z>Bc79En;*gr=5TdduC9_+1EY
z@4P+tQr(hu&O1|q3e~5AT*mW?7=?Gtixb-(5bS+B%iji!(4IU+Z>s|triyQAL~8OS
z*}A!MsV+xeRvRx*VqlbAlj@0)yUwl`tj~Cw?IKDWNs4&k+P$P@`7U!$k)^{@xKO)y
z`$fz{nuk&mWO)TGNGh}l|A%m=P{tFRx-ZQMl56(3owP0&=rsLJMCQI?bNHB|G~2jh
zC8av^^LI)vxA%Un<x39hS<8&)X-L7Ar-YeH29ShX%cP#sQJBD>Yj&9Hx&LotVb=@;
zQ7EM8-Ezl8jIKcE^!rnNID+i7s{HC5auXTGdTcKl>m}|szerKE6|ysoSl<(p-8`g5
zP(eFydvp&N2#>RqZovjGfL1(ARf%G1e-TB0bO8~R*ipckWGXG&>ZWCNdb>4^<&2%t
zLuLm9bwRwl7AN{FQ{;_41Nqpz7IS?$x3<v>3J;V0<%on{n!869l$X1cSq8UaxW_;5
zX=M_R8H9M<vGV#+84#vB9*=;=Rl$!N`?l*Cc*TDajO$Y}*?%Qr*K?9zci$3jY<?j7
zlRau2H%NSLlPc%<SBG`}F8n*=&y}y|GG2{wv~Kwt$sJ!(xgp<0P6-$th-bgOB6^bP
zWs+RCVewJ&XdphqImWvso(Ne?b=fZPFv!15lQ?2=EVy{0hk4V#v-;!8n$u$Z{oY$s
z{h=hDID#SyNaGokF!*IEmi~u46i=wjWA9l#0gRyZn18oz?wzEmY4j3F?8sl+bWxsv
zO)TFYd7G&?O5rYyeO8~NMqyPpXY$sL!zW^f*sQCM>I;mL+1^RaC%NwxnJw#_B5d%*
z!-Bndv1Z9jQrP);qLIPb$p>U`ulMt;=ieM~2?(;$bKj>UuaG7&?a)+m(0AXNPx|IR
zphHz}PNF$|Lzv?&xNP|q;{!LI_v#KDi{5v-XGdj=d$hj)qtl)u)gq8h&fv7?kxwD)
zd$Y3FNvn64H>poUA$abW-&qi_snIt>d!B=$!(<>PLUF^@ctt!|-(MoH8-fAMH@F(H
zYqrK}F%!}_7}TRnhADPVLv>2+XUx*YmMOMHwoXbCS~7{wd#oqXoj;ZDWBJ=ERFxb;
ztX|HU+UT>9H$-v6ygil3U0If}?pB@s7yRU`Z7<JE6~pZr?8L`gMnqri6M8uh!1S9X
zEhrZrI}%3W8~68ajsLlayq4pr74Kt0k~wqPUCDG3MrF<k)bauxq-~e;dc9z`Wn7q-
z#sb<PDtb=c`167vcY8lwvC<6z-=i_@p4g_Y^FH-K2v3CA^iKo=?bms}lA%dY@6`0%
z?p$`jfc3$!KaMzw4OV<3{~95nLMNF?VCi^bLlz}wP`n_}U<ZyB4==yd<Tbo>@HegV
zC55&nR~~pQJ^F{=mMkK-;t{CWWkh5c71zqELZw8G24nk8t}hWw@)sD$mnz#YC!-Wf
zY-r&SC7J>8kl(dUm){<3M4DSsPbAapHFSt;wl<w42jub@o@%uAp^xlyT-w9nA^uar
z0pbZ>g91^%q(2qY?<olq=n@qBI@j$Ic20Y85HZlN23q&ZR_s{>O?HwM<#N==P`zgH
z3fsD4tc?h#?x607Hc;lR>5cMjpNp^nxh7MD(0;}WVrVPN-A4mnNQ1rqdYtg=@iyhV
zTwE)8mr2%wEQ4E$_0aZ43+X3*xCbN+`WXY^3=UJ$AuUOMQWP+=KSZBmtVoR<sZrv5
zXIx+P#ZooN1ycnP0zpgHV+I_A%v^^Z$Cd+sO6+kbP!F@S40)@Ig6O|+Dlew*L1IEU
zUqLPKv;m<8VXx@G@!bEe$~8`$vW!7OXED(-J)-q3t2@<^+^1HLl6DEq*#f;e&ln5_
zH6Z2DG$%F6FP}5vr66~2iC&=eJdpxF`-yHBf_uI@tbg4?-t^UFE)(t?{a)c`=J3sC
zAgxA11MSLOIQ0XCPdCzDdS-FmAoRi1PFfT=+B<wl&MGMu@AOv*$DJj(g}p|CAO?GH
zpB8Z2?y|lZ#eXwwoxK*Ca~r04eYQ>`5Dc~Eg#yAuaKusj((#qIko8k9g97-@DN{Xq
z#AoymsN|Od`pKi56qEl(+|q1b-|%G-#mk3x3yq=ym$GYb4Ow#n3g9gW@<O!-#9TDN
z4}%QUL?T!#=kES*C@$o7zd^8kvN(7LmG^qQTE76FhzzE}7^;Ee?6W5)r#GGUtiMRq
zsxMe)CG>r1{u7aoiW|_#I;%)btncy9>~RDhZD}`4^yYP_#P;l^N2vng<t!7tpj8M|
zvz5JNuWbLen)!d*IXf8A1n^5_n8e-7Tc)_mb9^i@G)R8osVDpMWfh7=k>oto2CKa_
zqf;~FJ8-i0**NNdV|}AH4yiCJveU{wX37&s(GP8Pdqhhf6#i)mFEk<XqM^$pQ#~w!
z1M72td7QkxSTItW7mZ}<l>Zx6EszzKRuSU>)d@`!bz6BXQ>aFdQC)^HT>Af9%oHuR
zB%>G-9DUR1+ewPx!ME&WTZ|Evz5==b8<!nfe&KlW96?`WDA0DRDNb^FvdKJ%q^uY#
zuj4%JZBVpRKoxE!Kj0n9iR?w@+{JoJ#&&nU>C)Sd$In-)KLMz93mmp`u;e&hCW285
zqD|L|y-a}p?VDmMt5v^of9y(+d9xjpm9pbf<jwIN?5?ZQiFwTC;w;id=PHcYGTH9m
zfNALUtDXsKKoP&DB58y4QIz14jbI~cd+|hB@z2zkM{MU;3y%}Kf=d+fT+ib`kd2}5
zIMu|eK7N+EX_7oxy$XJZ;AY`m26||(xC#!mU76pe!g3b-b|r!%!xWZ0Aho@@U4NCm
zO`{J#i%Sgr3~f|R@A#rYnCbwHCxzuBXN1R9$%CoU&m8JlPk^?pRIB|K3ebf--!AbP
z_JWljCO}L1vS9#~ul3!-X&LDq6h=c)OpGuCl_#M6Z=RdXFxo{A`@@=}>&!gGT(zE(
z%i1TzECRLHO+S{X2pJ!$gnFs&WtA_bD%uxgXRaxFEIeH)IY>K9x~~EnxQzad@H%@C
ze5=7Ycid9Gaj-LEZ8LKYT2+c9^w8N}g^Ta^@A6|G9C+L`vW@G>Vz6&h`>hXxa~%>%
z$ne{D@70pq4yR_GAq4(L_;87{ww+CJV7revQ8UQj3CDldrguT<2RHfU+YjXnQpI0q
zesyD=*R^fhni|FL94F;xuQRZ-;wa<wJHWCh^_OI7IfVq*k01_7AOmDBV;nxd4X<J?
zeBt`*eM<8Zqq+QE73FSW$SKPK-U4{ygaVN2vI>DL+`Fp>Eju9StMWqOur)cCYV7<j
z${%;At$gwY<i)q-Y|0$gUbhNXO~FszCS9g2EGvIS!XP&IS&$2+CMJm=`IHM#Ig)o+
zDcums;?g|L($?XoC{e&1P!~VdZ!>gO@+NWQId9x;+H?T|9`b%(jF#1A)5w`%qTA29
zQjXN8q#f}TL2n2;C?KSe8sVoB{?YBxS27(NPMH3piwH?6x!yltV@8w<6F8%}LGFNB
zkUP-2Rw?mgOzfaqZsEVP<n^>6Db{uutY>}oG8{#-by?>9Li3urZQ|8_EgP3O|G?^}
zZAATeJidfnCuP=Pq-9E@tw22J@#Me50FyM28~KVLxb@W6o$0)T6jshB+8~MPuue5N
zIeu$u@n3k@lw~*n;l_vIO6J3bw24-_M`)?V^Rn@Z7Kc*5u_!wWr2t1;K0Vdn6pf>_
z=F##DkqwbP!Ixtk_xwzBetqF&k+r7U=@nlxAMT=%(d7okMpOM=zWv{4gXd|EfT09I
z=99PRN3dMYWVYa^{c2G<=TuI3)y#uW=R4x(*1iZf<iIsz;$D@D#*w~3#aL&voZP|$
zB){GG_E1et#9n3ZF%{*JJ~(x5nwgCvS{mU2{<BQp{4KA5{J&Je@eTtq{j(~=VD$j*
zATXj+wM-GTERtuI9VQA<f7=wFkC@1eLC87Z0V!r11}D(+-p$c9Pg1go8wt6%?L#p3
zeU1f9hNibL<E<e-0ep<k6CUR_i&az4oCCn#IV@V$u)o;1-r&EAVgpk_iZ1cDg3mS;
zeGdkhiV%>qFl--YfgVkW%LDfs3e-HvkEgIj3-y2b_+h@i;F!-%&c`Rkf43*z(lqwO
zSJ`{%e%hQ%G@0oVNaBA7PWynUd1UY;@<m*&)(<N4_!>}?z8|zNUVE)S5#6l&K=M^x
z;{zwx^_jlM4Md9kZFcLstXJ3V$!ZS_G9JBNjhNSIR(u>@kMG4?(<pU2k4}x7+T(vz
P0?^ZbsMVlh_wxS$e42C#

literal 0
HcmV?d00001


From 0116bb86635d9480f74b87e83a267d66e6f904e0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:15:09 +0100
Subject: [PATCH 1011/1292] replacing global pool with local pool DHB

---
 devicehandlers/DeviceHandlerBase.cpp | 39 ++++++++++++++++------------
 devicehandlers/DeviceHandlerBase.h   |  8 +++---
 2 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ccd5bebb..969c4688 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,6 +16,7 @@
 
 #include <iomanip>
 
+#include "../datapoollocal/LocalPoolVariable.h"
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -56,7 +57,7 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId) {
+		gp_id_t thermalStatePoolId, gp_id_t thermalRequestPoolId) {
 	this->deviceThermalRequestPoolId = thermalStatePoolId;
 	this->deviceThermalRequestPoolId = thermalRequestPoolId;
 }
@@ -211,15 +212,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	fillCommandAndReplyMap();
 
 	//Set temperature target state to NON_OP.
-	GlobDataSet mySet;
-	gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-			PoolVariableIF::VAR_WRITE);
-	mySet.read();
-	thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-	mySet.commit(PoolVariableIF::VALID);
+	LocalPoolVar<int8_t> thermalRequest(deviceThermalRequestPoolId, nullptr,
+			pool_rwm_t::VAR_WRITE);
+	ReturnValue_t result = thermalRequest.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		thermalRequest.commit(PoolVariableIF::VALID);
+	}
 
 	return RETURN_OK;
-
 }
 
 void DeviceHandlerBase::decrementDeviceReplyMap() {
@@ -508,14 +509,18 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+		LocalPoolVar<uint8_t> heaterRequest(deviceThermalRequestPoolId,
+				nullptr, PoolVariableIF::VAR_READ_WRITE);
+		ReturnValue_t result = heaterRequest.read();
+		if(heaterRequest == HasReturnvaluesIF::RETURN_OK) {
+			if (heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) {
+				heaterRequest.value = ThermalComponentIF::
+						STATE_REQUEST_NON_OPERATIONAL;
+			}
+			heaterRequest.commit(PoolVariableIF::VALID);
 		}
-		mySet.commit(PoolVariableIF::VALID);
+
 	}
 	changeHK(mode, submode, true);
 }
@@ -1374,8 +1379,8 @@ bool DeviceHandlerBase::commandIsExecuting(DeviceCommandId_t commandId) {
 void DeviceHandlerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
 }
 
-void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_){
-	executingTask = task_;
+void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task){
+	executingTask = task;
 }
 
 // Default implementations empty.
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 627a6423..f5d6ec2b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -103,8 +103,8 @@ public:
 			size_t cmdQueueSize = 20);
 
 	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(uint32_t thermalStatePoolId,
-			uint32_t thermalRequestPoolId);
+	void setThermalStateRequestPoolIds(gp_id_t thermalStatePoolId,
+			gp_id_t thermalRequestPoolId);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -699,14 +699,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalStatePoolId = PoolVariableIF::NO_PARAMETER;
+	gp_id_t deviceThermalStatePoolId;
 
 	/**
 	 * this is the datapool variable with the thermal request of the device
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	uint32_t deviceThermalRequestPoolId = PoolVariableIF::NO_PARAMETER;
+	gp_id_t deviceThermalRequestPoolId;
 
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and

From 3fb3039be530acdc21f41ca09dc7fc9d276827dc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:16:26 +0100
Subject: [PATCH 1012/1292] minus 1 replacement

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f64e1589..f09ddbb8 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -21,7 +21,7 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-    static const DeviceCommandId_t NO_COMMAND = 0xffffffff;
+    static const DeviceCommandId_t NO_COMMAND = -1;
 
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;

From fff928a191eced806e6f8aa9fa2e58d2c26b3565 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:29:00 +0100
Subject: [PATCH 1013/1292] bugfixes and improvements

---
 devicehandlers/DeviceHandlerBase.cpp | 45 ++++++++++++++++++----------
 devicehandlers/DeviceHandlerBase.h   | 20 +++++++++----
 devicehandlers/DeviceHandlerIF.h     |  3 ++
 3 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 969c4688..60929fcd 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -13,10 +13,11 @@
 #include "../ipc/MessageQueueMessage.h"
 #include "../ipc/QueueFactory.h"
 #include "../subsystem/SubsystemBase.h"
+#include "../datapoollocal/LocalPoolVariable.h"
 
 #include <iomanip>
 
-#include "../datapoollocal/LocalPoolVariable.h"
+
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -57,9 +58,9 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		gp_id_t thermalStatePoolId, gp_id_t thermalRequestPoolId) {
-	this->deviceThermalRequestPoolId = thermalStatePoolId;
-	this->deviceThermalRequestPoolId = thermalRequestPoolId;
+		lp_id_t thermalStatePoolId, lp_id_t thermalRequestPoolId) {
+	this->deviceHeaterRequestPoolId = thermalStatePoolId;
+	this->deviceHeaterRequestPoolId = thermalRequestPoolId;
 }
 
 
@@ -211,13 +212,17 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	fillCommandAndReplyMap();
 
-	//Set temperature target state to NON_OP.
-	LocalPoolVar<int8_t> thermalRequest(deviceThermalRequestPoolId, nullptr,
-			pool_rwm_t::VAR_WRITE);
-	ReturnValue_t result = thermalRequest.read();
-	if(result == HasReturnvaluesIF::RETURN_OK) {
-		thermalRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-		thermalRequest.commit(PoolVariableIF::VALID);
+	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+		//Set temperature target state to NON_OP.
+		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
+		heaterRequest(this, deviceHeaterRequestPoolId, nullptr,
+				pool_rwm_t::VAR_WRITE);
+		result = heaterRequest.read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			heaterRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+			heaterRequest.commit(PoolVariableIF::VALID);
+		}
+
 	}
 
 	return RETURN_OK;
@@ -509,10 +514,11 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	Clock::getUptime(&timeoutStart);
 
 	if (mode == MODE_OFF) {
-		LocalPoolVar<uint8_t> heaterRequest(deviceThermalRequestPoolId,
+		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
+		heaterRequest(this, deviceHeaterRequestPoolId,
 				nullptr, PoolVariableIF::VAR_READ_WRITE);
 		ReturnValue_t result = heaterRequest.read();
-		if(heaterRequest == HasReturnvaluesIF::RETURN_OK) {
+		if(result == HasReturnvaluesIF::RETURN_OK) {
 			if (heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
 				heaterRequest.value = ThermalComponentIF::
@@ -987,7 +993,7 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 		GlobDataSet mySet;
 		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
 				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceThermalRequestPoolId, &mySet,
+		gp_uint8_t thermalRequest(deviceHeaterRequestPoolId, &mySet,
 				PoolVariableIF::VAR_READ);
 		mySet.read();
 		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1015,7 +1021,7 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 					MODE_ON);
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceThermalRequestPoolId,
+			gp_int8_t thermalRequest(deviceHeaterRequestPoolId,
 					&mySet, PoolVariableIF::VAR_READ_WRITE);
 			mySet.read();
 			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
@@ -1393,6 +1399,15 @@ void DeviceHandlerBase::performOperationHook() {
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 		LocalDataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
+	if(deviceThermalStatePoolId != localpool::INVALID_LPID) {
+		localDataPoolMap.emplace(deviceThermalStatePoolId,
+				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
+	}
+
+	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+		localDataPoolMap.emplace(deviceHeaterRequestPoolId,
+				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
+	}
 	return RETURN_OK;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f5d6ec2b..b41e7407 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -103,8 +103,18 @@ public:
 			size_t cmdQueueSize = 20);
 
 	void setHkDestination(object_id_t hkDestination);
-	void setThermalStateRequestPoolIds(gp_id_t thermalStatePoolId,
-			gp_id_t thermalRequestPoolId);
+
+	/**
+	 * If the device handler is controlled by the FSFW thermal building blocks,
+	 * this function should be called. The device handler will then take care
+	 * of creating local pool entries for the device thermal state and device
+	 * heating request. Custom local pool IDs can be assigned as well.
+	 * @param thermalStatePoolId
+	 * @param thermalRequestPoolId
+	 */
+	void setThermalStateRequestPoolIds(
+			lp_id_t thermalStatePoolId = localpool::INVALID_LPID - 1,
+			lp_id_t thermalRequestPoolId = localpool::INVALID_LPID - 2);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -220,7 +230,7 @@ protected:
 	 *  - If the device does not change the mode, the mode will be changed to
 	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
 	 *    has passed.
-	 *
+	 * 0xffffffff
 	 * #transitionFailure can be set to a failure code indicating the reason
 	 * for a failed transition
 	 */
@@ -699,14 +709,14 @@ protected:
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	gp_id_t deviceThermalStatePoolId;
+	lp_id_t deviceThermalStatePoolId = localpool::INVALID_LPID;
 
 	/**
 	 * this is the datapool variable with the thermal request of the device
 	 *
 	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
 	 */
-	gp_id_t deviceThermalRequestPoolId;
+	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
 
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f09ddbb8..f1ea8801 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -26,6 +26,9 @@ public:
 	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
 	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
+	using dh_heater_request_t = uint8_t;
+	using dh_thermal_state_t = int8_t;
+
 	/**
 	 * @brief This is the mode the <strong>device handler</strong> is in.
 	 *

From 74b2830d9b2c612bff9467f063617028cbf309a8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 18:55:53 +0100
Subject: [PATCH 1014/1292] using new device handler thermal set

---
 devicehandlers/DeviceHandlerBase.cpp     | 56 ++++++++++++------------
 devicehandlers/DeviceHandlerBase.h       | 11 +++--
 devicehandlers/DeviceHandlerIF.h         |  9 ++++
 devicehandlers/DeviceHandlerThermalSet.h | 44 +++++++++++++++++++
 4 files changed, 90 insertions(+), 30 deletions(-)
 create mode 100644 devicehandlers/DeviceHandlerThermalSet.h

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 60929fcd..609ba315 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -58,9 +58,12 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
-		lp_id_t thermalStatePoolId, lp_id_t thermalRequestPoolId) {
+		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
+		uint32_t thermalSetId) {
 	this->deviceHeaterRequestPoolId = thermalStatePoolId;
-	this->deviceHeaterRequestPoolId = thermalRequestPoolId;
+	this->deviceHeaterRequestPoolId = heaterRequestPoolId;
+	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
+			thermalStatePoolId, heaterRequestPoolId);
 }
 
 
@@ -212,15 +215,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	fillCommandAndReplyMap();
 
-	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
+	if(thermalSet != nullptr) {
 		//Set temperature target state to NON_OP.
-		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
-		heaterRequest(this, deviceHeaterRequestPoolId, nullptr,
-				pool_rwm_t::VAR_WRITE);
-		result = heaterRequest.read();
+		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			heaterRequest = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			heaterRequest.commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+			thermalSet->heaterRequest.value =
+					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
+			thermalSet->commit(PoolVariableIF::VALID);
 		}
 
 	}
@@ -513,18 +515,17 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	}
 	Clock::getUptime(&timeoutStart);
 
-	if (mode == MODE_OFF) {
-		LocalPoolVar<DeviceHandlerIF::dh_heater_request_t>
-		heaterRequest(this, deviceHeaterRequestPoolId,
-				nullptr, PoolVariableIF::VAR_READ_WRITE);
-		ReturnValue_t result = heaterRequest.read();
+	if (mode == MODE_OFF and thermalSet != nullptr) {
+		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			if (heaterRequest.value !=
+			thermalSet->heaterRequest.setReadWriteMode(
+					pool_rwm_t::VAR_READ_WRITE);
+			if (thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				heaterRequest.value = ThermalComponentIF::
+				thermalSet->heaterRequest.value = ThermalComponentIF::
 						STATE_REQUEST_NON_OPERATIONAL;
 			}
-			heaterRequest.commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.commit(PoolVariableIF::VALID);
 		}
 
 	}
@@ -989,17 +990,18 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	}
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)) {
-		GlobDataSet mySet;
-		gp_uint8_t thermalState(deviceThermalStatePoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		gp_uint8_t thermalRequest(deviceHeaterRequestPoolId, &mySet,
-				PoolVariableIF::VAR_READ);
-		mySet.read();
-		if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-			if (!ThermalComponentIF::isOperational(thermalState)) {
+			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)
+			and thermalSet != nullptr) {
+		ReturnValue_t result = thermalSet->read();
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			thermalSet->thermalState.setReadWriteMode(pool_rwm_t::VAR_READ);
+			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_READ);
+			if((thermalSet->heaterRequest.value !=
+					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
+					ThermalComponentIF::isOperational(
+							thermalSet->thermalState.value))) {
 				triggerEvent(ThermalComponentIF::TEMP_NOT_IN_OP_RANGE,
-						thermalState);
+						thermalSet->thermalState.value);
 				return NON_OP_TEMPERATURE;
 			}
 		}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index b41e7407..eb15f22a 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -4,6 +4,7 @@
 #include "DeviceHandlerIF.h"
 #include "DeviceCommunicationIF.h"
 #include "DeviceHandlerFailureIsolation.h"
+#include "DeviceHandlerThermalSet.h"
 
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
@@ -112,9 +113,11 @@ public:
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 */
-	void setThermalStateRequestPoolIds(
-			lp_id_t thermalStatePoolId = localpool::INVALID_LPID - 1,
-			lp_id_t thermalRequestPoolId = localpool::INVALID_LPID - 2);
+	void setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalRequestPoolId =
+			DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
+			uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
 	/**
 	 * @brief   Helper function to ease device handler development.
 	 * This will instruct the transition to MODE_ON immediately
@@ -718,6 +721,8 @@ protected:
 	 */
 	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
 
+	DeviceHandlerThermalSet* thermalSet = nullptr;
+
 	/**
 	 * Optional Error code. Can be set in doStartUp(), doShutDown() and
 	 * doTransition() to signal cause for Transition failure.
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index f1ea8801..a86a2b3a 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -4,6 +4,7 @@
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -151,6 +152,14 @@ public:
 		NOTHING    //!< Do nothing.
 	};
 
+	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SID - 1;
+
+	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
+	        localpool::INVALID_LPID - 2;
+	static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID =
+			localpool::INVALID_LPID - 1;
+
+
 	/**
 	 * Default Destructor
 	 */
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
new file mode 100644
index 00000000..8e9f9c51
--- /dev/null
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -0,0 +1,44 @@
+#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+#define FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
+
+#include "DeviceHandlerIF.h"
+#include "../datapoollocal/StaticLocalDataSet.h"
+#include "../datapoollocal/LocalPoolVariable.h"
+
+
+class DeviceHandlerThermalSet: public StaticLocalDataSet<2> {
+public:
+
+	DeviceHandlerThermalSet(HasLocalDataPoolIF* hkOwner, uint32_t setId =
+			DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t heaterRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
+					thermalStateId, heaterRequestId) {}
+
+	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
+					DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
+			lp_id_t thermalStateId =
+					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
+			lp_id_t thermalStateRequestId =
+					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
+			StaticLocalDataSet(sid_t(deviceHandler, setId)),
+			thermalStatePoolId(thermalStateId),
+			thermalStateRequestPoolId(thermalStateRequestId) {}
+
+	const lp_id_t thermalStatePoolId;
+	const lp_id_t thermalStateRequestPoolId;
+
+	lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
+			lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(
+			thermalStatePoolId, sid.objectId, this);
+	lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
+			lp_var_t<DeviceHandlerIF::dh_heater_request_t>(
+			thermalStateRequestPoolId, sid.objectId, this);
+};
+
+
+
+#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_ */

From e3de5ce7774b8571865ff6755056527912f0e7c2 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 19:12:40 +0100
Subject: [PATCH 1015/1292] device handler changes complete

---
 devicehandlers/DeviceHandlerBase.cpp     | 71 ++++++++++++------------
 devicehandlers/DeviceHandlerBase.h       | 24 +++-----
 devicehandlers/DeviceHandlerIF.h         |  2 +-
 devicehandlers/DeviceHandlerThermalSet.h |  6 +-
 4 files changed, 46 insertions(+), 57 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 609ba315..d14a8e36 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -60,8 +60,6 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
 void DeviceHandlerBase::setThermalStateRequestPoolIds(
 		lp_id_t thermalStatePoolId, lp_id_t heaterRequestPoolId,
 		uint32_t thermalSetId) {
-	this->deviceHeaterRequestPoolId = thermalStatePoolId;
-	this->deviceHeaterRequestPoolId = heaterRequestPoolId;
 	thermalSet = new DeviceHandlerThermalSet(this, thermalSetId,
 			thermalStatePoolId, heaterRequestPoolId);
 }
@@ -217,9 +215,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	if(thermalSet != nullptr) {
 		//Set temperature target state to NON_OP.
-		ReturnValue_t result = thermalSet->read();
+		result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_WRITE);
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
 			thermalSet->commit(PoolVariableIF::VALID);
@@ -518,8 +515,6 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
 	if (mode == MODE_OFF and thermalSet != nullptr) {
 		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->heaterRequest.setReadWriteMode(
-					pool_rwm_t::VAR_READ_WRITE);
 			if (thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) {
 				thermalSet->heaterRequest.value = ThermalComponentIF::
@@ -990,12 +985,9 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode,
 	}
 
 	if ((commandedMode == MODE_ON) && (mode == MODE_OFF)
-			&& (deviceThermalStatePoolId != PoolVariableIF::NO_PARAMETER)
-			and thermalSet != nullptr) {
+			and (thermalSet != nullptr)) {
 		ReturnValue_t result = thermalSet->read();
 		if(result == HasReturnvaluesIF::RETURN_OK) {
-			thermalSet->thermalState.setReadWriteMode(pool_rwm_t::VAR_READ);
-			thermalSet->heaterRequest.setReadWriteMode(pool_rwm_t::VAR_READ);
 			if((thermalSet->heaterRequest.value !=
 					ThermalComponentIF::STATE_REQUEST_IGNORE) and (not
 					ThermalComponentIF::isOperational(
@@ -1014,32 +1006,15 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 		Submode_t commandedSubmode) {
 	switch (commandedMode) {
 	case MODE_ON:
-		if (mode == MODE_OFF) {
-			transitionSourceMode = _MODE_POWER_DOWN;
-			transitionSourceSubMode = SUBMODE_NONE;
-			setMode(_MODE_POWER_ON, commandedSubmode);
-			//already set the delay for the child transition so we don't need to call it twice
-			childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
-					MODE_ON);
-			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
-			GlobDataSet mySet;
-			gp_int8_t thermalRequest(deviceHeaterRequestPoolId,
-					&mySet, PoolVariableIF::VAR_READ_WRITE);
-			mySet.read();
-			if (thermalRequest != ThermalComponentIF::STATE_REQUEST_IGNORE) {
-				thermalRequest = ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
-				mySet.commit(PoolVariableIF::VALID);
-			}
-		} else {
-			setTransition(MODE_ON, commandedSubmode);
-		}
+		handleTransitionToOnMode(commandedMode, commandedSubmode);
 		break;
 	case MODE_OFF:
 		if (mode == MODE_OFF) {
 			triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
 			setMode(_MODE_POWER_DOWN, commandedSubmode);
 		} else {
-			//already set the delay for the child transition so we don't need to call it twice
+			// already set the delay for the child transition
+			// so we don't need to call it twice
 			childTransitionDelay = getTransitionDelayMs(mode, _MODE_POWER_DOWN);
 			transitionSourceMode = _MODE_POWER_DOWN;
 			transitionSourceSubMode = commandedSubmode;
@@ -1065,6 +1040,33 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode,
 	}
 }
 
+void DeviceHandlerBase::handleTransitionToOnMode(Mode_t commandedMode,
+		Submode_t commandedSubmode) {
+	if (mode == MODE_OFF) {
+		transitionSourceMode = _MODE_POWER_DOWN;
+		transitionSourceSubMode = SUBMODE_NONE;
+		setMode(_MODE_POWER_ON, commandedSubmode);
+		// already set the delay for the child transition so we don't
+		// need to call it twice
+		childTransitionDelay = getTransitionDelayMs(_MODE_START_UP,
+				MODE_ON);
+		triggerEvent(CHANGING_MODE, commandedMode, commandedSubmode);
+		if(thermalSet != nullptr) {
+			ReturnValue_t result = thermalSet->read();
+			if(result == HasReturnvaluesIF::RETURN_OK) {
+				if(thermalSet->heaterRequest !=
+						ThermalComponentIF::STATE_REQUEST_IGNORE) {
+					thermalSet->heaterRequest =
+							ThermalComponentIF::STATE_REQUEST_OPERATIONAL;
+					thermalSet->commit();
+				}
+			}
+		}
+	} else {
+		setTransition(MODE_ON, commandedSubmode);
+	}
+}
+
 void DeviceHandlerBase::getMode(Mode_t* mode, Submode_t* submode) {
 	*mode = this->mode;
 	*submode = this->submode;
@@ -1401,13 +1403,10 @@ void DeviceHandlerBase::performOperationHook() {
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 		LocalDataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
-	if(deviceThermalStatePoolId != localpool::INVALID_LPID) {
-		localDataPoolMap.emplace(deviceThermalStatePoolId,
+	if(thermalSet != nullptr) {
+		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
 				new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
-	}
-
-	if(deviceHeaterRequestPoolId != localpool::INVALID_LPID) {
-		localDataPoolMap.emplace(deviceHeaterRequestPoolId,
+		localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
 				new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
 	}
 	return RETURN_OK;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index eb15f22a..4deef763 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -107,9 +107,10 @@ public:
 
 	/**
 	 * If the device handler is controlled by the FSFW thermal building blocks,
-	 * this function should be called. The device handler will then take care
-	 * of creating local pool entries for the device thermal state and device
-	 * heating request. Custom local pool IDs can be assigned as well.
+	 * this function should be called to initialize all required components.
+	 * The device handler will then take care of creating local pool entries
+	 * for the device thermal state and device heating request.
+	 * Custom local pool IDs can be assigned as well.
 	 * @param thermalStatePoolId
 	 * @param thermalRequestPoolId
 	 */
@@ -707,20 +708,6 @@ protected:
 	//! and to send replies.
 	MessageQueueIF* commandQueue = nullptr;
 
-	/**
-	 * this is the datapool variable with the thermal state of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	lp_id_t deviceThermalStatePoolId = localpool::INVALID_LPID;
-
-	/**
-	 * this is the datapool variable with the thermal request of the device
-	 *
-	 * can be set to PoolVariableIF::NO_PARAMETER to deactivate thermal checking
-	 */
-	lp_id_t deviceHeaterRequestPoolId = localpool::INVALID_LPID;
-
 	DeviceHandlerThermalSet* thermalSet = nullptr;
 
 	/**
@@ -1223,6 +1210,9 @@ private:
 
     void parseReply(const uint8_t* receivedData,
                 size_t receivedDataLen);
+
+    void handleTransitionToOnMode(Mode_t commandedMode,
+    		Submode_t commandedSubmode);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index a86a2b3a..4cda99d4 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -152,7 +152,7 @@ public:
 		NOTHING    //!< Do nothing.
 	};
 
-	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SID - 1;
+	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
 
 	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
 	        localpool::INVALID_LPID - 2;
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 8e9f9c51..239012e2 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -26,17 +26,17 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
 			StaticLocalDataSet(sid_t(deviceHandler, setId)),
 			thermalStatePoolId(thermalStateId),
-			thermalStateRequestPoolId(thermalStateRequestId) {}
+			heaterRequestPoolId(thermalStateRequestId) {}
 
 	const lp_id_t thermalStatePoolId;
-	const lp_id_t thermalStateRequestPoolId;
+	const lp_id_t heaterRequestPoolId;
 
 	lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
 			lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(
 			thermalStatePoolId, sid.objectId, this);
 	lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
 			lp_var_t<DeviceHandlerIF::dh_heater_request_t>(
-			thermalStateRequestPoolId, sid.objectId, this);
+			heaterRequestPoolId, sid.objectId, this);
 };
 
 

From 4d76bf24b581aaeba5c2e276f4d09c90c806215e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 1 Dec 2020 19:16:19 +0100
Subject: [PATCH 1016/1292] fsfw compiles without datapoolglob folder

---
 .../datapoolglob}/ControllerSet.cpp                  |  0
 .../datapoolglob}/ControllerSet.h                    |  0
 .../datapoolglob}/DataPoolAdmin.cpp                  |  0
 .../datapoolglob}/DataPoolAdmin.h                    |  0
 .../datapoolglob}/DataPoolParameterWrapper.cpp       |  0
 .../datapoolglob}/DataPoolParameterWrapper.h         |  0
 .../datapoolglob}/GlobalDataPool.cpp                 |  0
 .../datapoolglob}/GlobalDataPool.h                   |  0
 .../datapoolglob}/GlobalDataSet.cpp                  |  0
 .../datapoolglob}/GlobalDataSet.h                    |  0
 .../datapoolglob}/GlobalPoolVariable.h               |  0
 .../datapoolglob}/GlobalPoolVariable.tpp             |  0
 .../datapoolglob}/GlobalPoolVector.h                 |  0
 .../datapoolglob}/GlobalPoolVector.tpp               |  0
 {datapoolglob => archive/datapoolglob}/PIDReader.h   |  0
 .../datapoolglob}/PIDReaderList.h                    |  0
 .../datapoolglob}/PoolRawAccess.cpp                  |  0
 .../datapoolglob}/PoolRawAccess.h                    |  0
 devicehandlers/DeviceHandlerBase.cpp                 | 12 ++++++------
 internalError/InternalErrorReporter.cpp              |  2 --
 20 files changed, 6 insertions(+), 8 deletions(-)
 rename {datapoolglob => archive/datapoolglob}/ControllerSet.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/ControllerSet.h (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolAdmin.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolAdmin.h (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolParameterWrapper.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/DataPoolParameterWrapper.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataPool.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataPool.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataSet.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalDataSet.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVariable.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVariable.tpp (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVector.h (100%)
 rename {datapoolglob => archive/datapoolglob}/GlobalPoolVector.tpp (100%)
 rename {datapoolglob => archive/datapoolglob}/PIDReader.h (100%)
 rename {datapoolglob => archive/datapoolglob}/PIDReaderList.h (100%)
 rename {datapoolglob => archive/datapoolglob}/PoolRawAccess.cpp (100%)
 rename {datapoolglob => archive/datapoolglob}/PoolRawAccess.h (100%)

diff --git a/datapoolglob/ControllerSet.cpp b/archive/datapoolglob/ControllerSet.cpp
similarity index 100%
rename from datapoolglob/ControllerSet.cpp
rename to archive/datapoolglob/ControllerSet.cpp
diff --git a/datapoolglob/ControllerSet.h b/archive/datapoolglob/ControllerSet.h
similarity index 100%
rename from datapoolglob/ControllerSet.h
rename to archive/datapoolglob/ControllerSet.h
diff --git a/datapoolglob/DataPoolAdmin.cpp b/archive/datapoolglob/DataPoolAdmin.cpp
similarity index 100%
rename from datapoolglob/DataPoolAdmin.cpp
rename to archive/datapoolglob/DataPoolAdmin.cpp
diff --git a/datapoolglob/DataPoolAdmin.h b/archive/datapoolglob/DataPoolAdmin.h
similarity index 100%
rename from datapoolglob/DataPoolAdmin.h
rename to archive/datapoolglob/DataPoolAdmin.h
diff --git a/datapoolglob/DataPoolParameterWrapper.cpp b/archive/datapoolglob/DataPoolParameterWrapper.cpp
similarity index 100%
rename from datapoolglob/DataPoolParameterWrapper.cpp
rename to archive/datapoolglob/DataPoolParameterWrapper.cpp
diff --git a/datapoolglob/DataPoolParameterWrapper.h b/archive/datapoolglob/DataPoolParameterWrapper.h
similarity index 100%
rename from datapoolglob/DataPoolParameterWrapper.h
rename to archive/datapoolglob/DataPoolParameterWrapper.h
diff --git a/datapoolglob/GlobalDataPool.cpp b/archive/datapoolglob/GlobalDataPool.cpp
similarity index 100%
rename from datapoolglob/GlobalDataPool.cpp
rename to archive/datapoolglob/GlobalDataPool.cpp
diff --git a/datapoolglob/GlobalDataPool.h b/archive/datapoolglob/GlobalDataPool.h
similarity index 100%
rename from datapoolglob/GlobalDataPool.h
rename to archive/datapoolglob/GlobalDataPool.h
diff --git a/datapoolglob/GlobalDataSet.cpp b/archive/datapoolglob/GlobalDataSet.cpp
similarity index 100%
rename from datapoolglob/GlobalDataSet.cpp
rename to archive/datapoolglob/GlobalDataSet.cpp
diff --git a/datapoolglob/GlobalDataSet.h b/archive/datapoolglob/GlobalDataSet.h
similarity index 100%
rename from datapoolglob/GlobalDataSet.h
rename to archive/datapoolglob/GlobalDataSet.h
diff --git a/datapoolglob/GlobalPoolVariable.h b/archive/datapoolglob/GlobalPoolVariable.h
similarity index 100%
rename from datapoolglob/GlobalPoolVariable.h
rename to archive/datapoolglob/GlobalPoolVariable.h
diff --git a/datapoolglob/GlobalPoolVariable.tpp b/archive/datapoolglob/GlobalPoolVariable.tpp
similarity index 100%
rename from datapoolglob/GlobalPoolVariable.tpp
rename to archive/datapoolglob/GlobalPoolVariable.tpp
diff --git a/datapoolglob/GlobalPoolVector.h b/archive/datapoolglob/GlobalPoolVector.h
similarity index 100%
rename from datapoolglob/GlobalPoolVector.h
rename to archive/datapoolglob/GlobalPoolVector.h
diff --git a/datapoolglob/GlobalPoolVector.tpp b/archive/datapoolglob/GlobalPoolVector.tpp
similarity index 100%
rename from datapoolglob/GlobalPoolVector.tpp
rename to archive/datapoolglob/GlobalPoolVector.tpp
diff --git a/datapoolglob/PIDReader.h b/archive/datapoolglob/PIDReader.h
similarity index 100%
rename from datapoolglob/PIDReader.h
rename to archive/datapoolglob/PIDReader.h
diff --git a/datapoolglob/PIDReaderList.h b/archive/datapoolglob/PIDReaderList.h
similarity index 100%
rename from datapoolglob/PIDReaderList.h
rename to archive/datapoolglob/PIDReaderList.h
diff --git a/datapoolglob/PoolRawAccess.cpp b/archive/datapoolglob/PoolRawAccess.cpp
similarity index 100%
rename from datapoolglob/PoolRawAccess.cpp
rename to archive/datapoolglob/PoolRawAccess.cpp
diff --git a/datapoolglob/PoolRawAccess.h b/archive/datapoolglob/PoolRawAccess.h
similarity index 100%
rename from datapoolglob/PoolRawAccess.h
rename to archive/datapoolglob/PoolRawAccess.h
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d14a8e36..4bb7ed56 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -3,8 +3,6 @@
 #include "DeviceTmReportingWrapper.h"
 
 #include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -1239,10 +1237,12 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* data,
 		}
 	}
 	//Try to cast to GlobDataSet and commit data.
-	if (!neverInDataPool) {
-		GlobDataSet* dataSet = dynamic_cast<GlobDataSet*>(data);
-		if (dataSet != NULL) {
-			dataSet->commit(PoolVariableIF::VALID);
+	if (not neverInDataPool) {
+		LocalPoolDataSetBase* dataSet =
+				dynamic_cast<LocalPoolDataSetBase*>(data);
+		if (dataSet != nullptr) {
+			dataSet->setValidity(true, true);
+			dataSet->commit();
 		}
 	}
 }
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 22e2c38c..8d5c792b 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -1,8 +1,6 @@
 #include "InternalErrorReporter.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../ipc/MutexFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 

From 5e77058add5f51504b4bfab4afe18debf8d8a9df Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:15:30 +0100
Subject: [PATCH 1017/1292] added getter function for pending command

---
 devicehandlers/DeviceHandlerBase.cpp |  2 ++
 devicehandlers/DeviceHandlerBase.h   | 13 +++++++++++--
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index ccd5bebb..1b8c5f3d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1432,3 +1432,5 @@ dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
     return pstIntervalMs;
 }
 
+DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 627a6423..bd53e633 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -737,10 +737,19 @@ protected:
 	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
 
 	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
+
+	/**
+	 * Helper function to get pending command. This is useful for devices
+	 * like SPI sensors to identify the last sent command.
+	 * @return
+	 */
+	DeviceCommandId_t getPendingCommand() const;
+
 	/**
 	 * Helper function to report a missed reply
 	 *
-	 * Can be overwritten by children to act on missed replies or to fake reporting Id.
+	 * Can be overwritten by children to act on missed replies or to fake
+	 * reporting Id.
 	 *
 	 * @param id of the missed reply
 	 */
@@ -1184,7 +1193,7 @@ private:
 	 * @param[out] len
 	 * @return
 	 *   - @c RETURN_OK @c data is valid
-	 *   - @c RETURN_FAILED IPCStore is NULL
+	 *   - @c RETURN_FAILED IPCStore is nullptr
 	 *   - the return value from the IPCStore if it was not @c RETURN_OK
 	 */
 	ReturnValue_t getStorageData(store_address_t storageAddress, uint8_t **data,

From f4ed0ce502b696cc6acf9eac3d20f0d9db6975d3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:18:48 +0100
Subject: [PATCH 1018/1292] doc format improvements

---
 devicehandlers/DeviceHandlerBase.h | 58 ++++++++++++++++++------------
 1 file changed, 35 insertions(+), 23 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index bd53e633..b282ad4b 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -893,7 +893,8 @@ protected:
 	 * @param data data to send
 	 * @param len length of @c data
 	 * @param sendTo the messageQueueId of the one to send to
-	 * @param isCommand marks the raw data as a command, the message then will be of type raw_command
+	 * @param isCommand marks the raw data as a command, the message then
+	 * will be of type raw_command
 	 */
 	virtual void replyRawData(const uint8_t *data, size_t len,
 			MessageQueueId_t sendTo, bool isCommand = false);
@@ -945,10 +946,11 @@ protected:
 	ReturnValue_t getStateOfSwitches(void);
 
 	/**
-	 * set all datapool variables that are update periodically in normal mode invalid
-	 *
-	 * Child classes should provide an implementation which sets all those variables invalid
-	 * which are set periodically during any normal mode.
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details TODO: Use local pools
+	 * Child classes should provide an implementation which sets all those
+	 * variables invalid which are set periodically during any normal mode.
 	 */
 	virtual void setNormalDatapoolEntriesInvalid() = 0;
 
@@ -958,11 +960,12 @@ protected:
 	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
 
 	/**
-	 * Children can overwrite this function to suppress checking of the command Queue
+	 * Children can overwrite this function to suppress checking of the
+	 * command Queue
 	 *
-	 * This can be used when the child does not want to receive a command in a certain
-	 * situation. Care must be taken that checking is not permanentely disabled as this
-	 * would render the handler unusable.
+	 * This can be used when the child does not want to receive a command in
+	 * a certain situation. Care must be taken that checking is not
+	 * permanentely disabled as this would render the handler unusable.
 	 *
 	 * @return whether checking the queue should NOT be done
 	 */
@@ -1001,17 +1004,20 @@ protected:
 	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
 			uint32_t parameter2 = 0) const;
 	/**
-	 * Checks state of switches in conjunction with mode and triggers an event if they don't fit.
+	 * Checks state of switches in conjunction with mode and triggers an event
+	 * if they don't fit.
 	 */
 	virtual void checkSwitchState();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in OFF mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in OFF mode.
 	 */
 	virtual void doOffActivity();
 
 	/**
-	 * Reserved for the rare case where a device needs to perform additional operation cyclically in ON mode.
+	 * Reserved for the rare case where a device needs to perform additional
+	 * operation cyclically in ON mode.
 	 */
 	virtual void doOnActivity();
 
@@ -1052,9 +1058,10 @@ private:
 	/**
 	 * Information about a cookie.
 	 *
-	 * This is stored in a map for each cookie, to not only track the state, but also information
-	 * about  the sent command. Tracking this information is needed as
-	 * the state of a commandId (waiting for reply) is done when a RMAP write reply is received.
+	 * This is stored in a map for each cookie, to not only track the state,
+	 * but also information about the sent command. Tracking this information
+	 * is needed as the state of a commandId (waiting for reply) is done when a
+	 * write reply is received.
 	 */
 	struct CookieInfo {
 		CookieState_t state;
@@ -1111,10 +1118,14 @@ private:
 	/**
 	 * Handle the device handler mode.
 	 *
-	 * - checks whether commands are valid for the current mode, rejects them accordingly
-	 * - checks whether commanded mode transitions are required and calls handleCommandedModeTransition()
-	 * - does the necessary action for the current mode or calls doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
-	 * - actions that happen in transitions (eg setting a timeout) are handled in setMode()
+	 * - checks whether commands are valid for the current mode, rejects
+	 *   them accordingly
+	 * - checks whether commanded mode transitions are required and calls
+	 *   handleCommandedModeTransition()
+	 * - does the necessary action for the current mode or calls
+	 *   doChildStateMachine in modes @c MODE_TO_ON and @c MODE_TO_OFF
+	 * - actions that happen in transitions (e.g. setting a timeout) are
+	 *   handled in setMode()
 	 */
 	void doStateMachine(void);
 
@@ -1124,16 +1135,17 @@ private:
 	/**
 	 * Decrement the counter for the timout of replies.
 	 *
-	 * This is called at the beginning of each cycle. It checks whether a reply has timed out (that means a reply was expected
-	 * but not received).
+	 * This is called at the beginning of each cycle. It checks whether a
+	 * reply has timed out (that means a reply was expected but not received).
 	 */
 	void decrementDeviceReplyMap(void);
 
 	/**
 	 * Convenience function to handle a reply.
 	 *
-	 * Called after scanForReply() has found a packet. Checks if the found id is in the #deviceCommandMap, if so,
-	 * calls interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) for further action.
+	 * Called after scanForReply() has found a packet. Checks if the found ID
+	 * is in the #deviceCommandMap, if so,  calls
+	 * #interpretDeviceReply for further action.
 	 *
 	 * It also resets the timeout counter for the command id.
 	 *

From 586e8b034780fcd107cdd8ae06cd0fbffe5947b3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:22:28 +0100
Subject: [PATCH 1019/1292] function more robust now

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1b8c5f3d..2a4d1338 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1433,4 +1433,8 @@ dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const {
 }
 
 DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
+    if(cookieInfo.pendingCommand != deviceCommandMap.end()) {
+        return cookieInfo.pendingCommand->first;
+    }
+    return DeviceHandlerIF::NO_COMMAND;
 }

From 6d915b7dcf76c76672b07483936b9c9fcbbbb047 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 2 Dec 2020 23:26:40 +0100
Subject: [PATCH 1020/1292] doc formatting

---
 devicehandlers/DeviceHandlerBase.h | 63 ++++++++++++++++++------------
 1 file changed, 38 insertions(+), 25 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6d9b0be6..49617cd5 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -734,11 +734,14 @@ protected:
 	//! before setTaskIF was called.
 	PeriodicTaskIF* executingTask = nullptr;
 
-	static object_id_t powerSwitcherId; //!< Object which switches power on and off.
+	//!< Object which switches power on and off.
+	static object_id_t powerSwitcherId;
 
-	static object_id_t rawDataReceiverId; //!< Object which receives RAW data by default.
+	//!< Object which receives RAW data by default.
+	static object_id_t rawDataReceiverId;
 
-	static object_id_t defaultFdirParentId; //!< Object which may be the root cause of an identified fault.
+	//!< Object which may be the root cause of an identified fault.
+	static object_id_t defaultFdirParentId;
 
 	/**
 	 * Helper function to get pending command. This is useful for devices
@@ -858,15 +861,18 @@ protected:
 	/**
 	 * Build the device command to send for raw mode.
 	 *
-	 * This is only called in @c MODE_RAW. It is for the rare case that in raw mode packets
-	 * are to be sent by the handler itself. It is NOT needed for the raw commanding service.
-	 * Its only current use is in the STR handler which gets its raw packets from a different
-	 * source.
-	 * Also it can be used for transitional commands, to get the device ready for @c MODE_RAW
+	 * This is only called in @c MODE_RAW. It is for the rare case that in
+	 * raw mode packets are to be sent by the handler itself. It is NOT needed
+	 * for the raw commanding service. Its only current use is in the STR
+	 * handler which gets its raw packets from a different source.
+	 * Also it can be used for transitional commands, to get the device ready
+	 * for @c MODE_RAW
 	 *
-	 * As it is almost never used, there is a default implementation returning @c NOTHING_TO_SEND.
+	 * As it is almost never used, there is a default implementation
+	 * returning @c NOTHING_TO_SEND.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the packet
+	 * to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -879,7 +885,9 @@ protected:
 	 * Returns the delay cycle count of a reply.
 	 * A count != 0 indicates that the command is already executed.
 	 * @param deviceCommand	The command to look for
-	 * @return	The current delay count. If the command does not exist (should never happen) it returns 0.
+	 * @return
+	 * The current delay count. If the command does not exist  (should never
+	 * happen) it returns 0.
 	 */
 	uint8_t getReplyDelayCycles(DeviceCommandId_t deviceCommand);
 
@@ -889,8 +897,8 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send raw replies
-	 * and overwrites it accordingly.
+	 * This method is virtual, as the STR has a different channel to send
+	 * raw replies and overwrites it accordingly.
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
@@ -902,8 +910,9 @@ protected:
 			MessageQueueId_t sendTo, bool isCommand = false);
 
 	/**
-	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping is active and if so,
-	 * does not send the Data as the wiretapping will have sent it already
+	 * Calls replyRawData() with #defaultRawReceiver, but checks if wiretapping
+	 * is active and if so, does not send the data as the wiretapping will have
+	 * sent it already
 	 */
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
@@ -915,17 +924,19 @@ protected:
 	/**
 	 * Enable the reply checking for a command
 	 *
-	 * Is only called, if the command was sent (ie the getWriteReply was successful).
-	 * Must ensure that all replies are activated and correctly linked to the command that initiated it.
-	 * The default implementation looks for a reply with the same id as the command id in the replyMap or
-	 * uses the alternativeReplyId if flagged so.
-	 * When found, copies maxDelayCycles to delayCycles in the reply information and sets the command to
-	 * expect one reply.
+	 * Is only called, if the command was sent (i.e. the getWriteReply was
+	 * successful). Must ensure that all replies are activated and correctly
+	 * linked to the command that initiated it.
+	 * The default implementation looks for a reply with the same id as the
+	 * command id in the replyMap or uses the alternativeReplyId if flagged so.
+	 * When found, copies maxDelayCycles to delayCycles in the reply information
+	 * and sets the command to expect one reply.
 	 *
 	 * Can be overwritten by the child, if a command activates multiple replies
 	 * or replyId differs from commandId.
 	 * Notes for child implementations:
-	 * 	- If the command was not found in the reply map, NO_REPLY_EXPECTED MUST be returned.
+	 * 	- If the command was not found in the reply map,
+	 * 	  NO_REPLY_EXPECTED MUST be returned.
 	 * 	- A failure code may be returned if something went fundamentally wrong.
 	 *
 	 * @param deviceCommand
@@ -941,9 +952,11 @@ protected:
 	 * get the state of the PCDU switches in the datapool
 	 *
 	 * @return
-	 *     - @c PowerSwitchIF::SWITCH_ON if all switches specified by #switches are on
-	 *     - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by #switches are off
-	 *     - @c PowerSwitchIF::RETURN_FAILED if an error occured
+	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
+	 *       by #switches are on
+	 *  - @c PowerSwitchIF::SWITCH_OFF one of the switches specified by
+	 *       #switches are off
+	 *  - @c PowerSwitchIF::RETURN_FAILED if an error occured
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 

From b7a29235f876fa60d783654ebfb449799451948d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 13:28:56 +0100
Subject: [PATCH 1021/1292] deleted memory proxy file

---
 memory/MemoryProxyIF.h | 22 ----------------------
 1 file changed, 22 deletions(-)
 delete mode 100644 memory/MemoryProxyIF.h

diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h
deleted file mode 100644
index 31045d3f..00000000
--- a/memory/MemoryProxyIF.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-#define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_
-
-#include "../memory/AcceptsMemoryMessagesIF.h"
-
-/**
- * This was a nice idea to transparently forward incoming messages to another object.
- * But it doesn't work like that.
- */
-class MemoryProxyIF : public AcceptsMemoryMessagesIF {
-public:
-	virtual MessageQueueId_t getProxyQueue() const = 0;
-	MessageQueueId_t getCommandQueue() const {
-		return getProxyQueue();
-	}
-	virtual ~MemoryProxyIF() {}
-
-};
-
-
-
-#endif /* FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ */

From c5c776e676a6b7c39e9bc8d4535ab9cba836d977 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 3 Dec 2020 18:57:50 +0100
Subject: [PATCH 1022/1292] rtems changes taken over from upstream

---
 osal/rtems/MultiObjectTask.cpp |  5 +++--
 osal/rtems/MultiObjectTask.h   | 20 +++++++-------------
 osal/rtems/Mutex.cpp           | 19 ++++++++++++++++---
 osal/rtems/Mutex.h             |  6 +++---
 osal/rtems/PollingTask.cpp     | 10 +++++-----
 osal/rtems/PollingTask.h       |  4 ++--
 6 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 8f969a1d..2342c24c 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -78,8 +78,9 @@ ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
-	ReturnValue_t result = newObject->initializeAfterTaskCreation();
-	return result;
+	newObject->setTaskIF(this);
+
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 uint32_t MultiObjectTask::getPeriodMs() const {
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 28d05fb1..736e79dd 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -1,11 +1,5 @@
-/**
- * @file	MultiObjectTask.h
- * @brief	This file defines the MultiObjectTask class.
- * @date	30.01.2014
- * @author	baetz
- */
-#ifndef MULTIOBJECTTASK_H_
-#define MULTIOBJECTTASK_H_
+#ifndef FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
+#define FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_
 
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
@@ -21,7 +15,7 @@ class ExecutableObjectIF;
  * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
  * 			multiple objects that implement the ExecutableObjectIF interface. The objects must be
  * 			added prior to starting the task.
- *
+ * @author  baetz
  * @ingroup task_handling
  */
 class MultiObjectTask: public TaskBase, public PeriodicTaskIF {
@@ -63,11 +57,11 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object);
+	ReturnValue_t addComponent(object_id_t object) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 protected:
 	typedef std::vector<ExecutableObjectIF*> ObjectList;	//!< Typedef for the List of objects.
 	/**
@@ -110,4 +104,4 @@ protected:
 	void taskFunctionality(void);
 };
 
-#endif /* MULTIOBJECTTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_MULTIOBJECTTASK_H_ */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index d8babcde..9553ac79 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,7 +1,6 @@
 #include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
 uint8_t Mutex::count = 0;
 
 Mutex::Mutex() :
@@ -24,8 +23,22 @@ Mutex::~Mutex() {
 	}
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
+        TimeoutType::BLOCKING, uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+	}
+	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+		timeoutMs = RTEMS_NO_TIMEOUT;
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_NO_WAIT, 0);
+	}
+	else {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, timeoutMs);
+	}
+
 	switch(status){
 	case RTEMS_SUCCESSFUL:
 		//semaphore obtained successfully
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 340bb16b..72368210 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_OSAL_RTEMS_MUTEX_H_
+#define FRAMEWORK_OSAL_RTEMS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include "RtemsBasic.h"
@@ -8,7 +8,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs = 0);
 	ReturnValue_t unlockMutex();
 private:
 	rtems_id mutexId;
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index efb425d9..04191515 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,7 +1,7 @@
-#include "../../tasks/FixedSequenceSlot.h"
+#include "../../devicehandlers/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
-#include "../../osal/rtems/PollingTask.h"
-#include "../../osal/rtems/RtemsBasic.h"
+#include "PollingTask.h"
+#include "RtemsBasic.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <rtems/bspIo.h>
@@ -73,7 +73,7 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	sif::error << "Component " << std::hex << componentId <<
+	error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
@@ -82,7 +82,7 @@ uint32_t PollingTask::getPeriodMs() const {
 	return pst.getLengthMs();
 }
 
-ReturnValue_t PollingTask::checkAndInitializeSequence() const {
+ReturnValue_t PollingTask::checkSequence() const {
 	return pst.checkSequence();
 }
 
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 1502f0c6..199c34e7 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
 #ifndef POLLINGTASK_H_
 #define POLLINGTASK_H_
 
-#include "../../tasks/FixedSlotSequence.h"
+#include "../../devicehandlers/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "TaskBase.h"
 
@@ -42,7 +42,7 @@ class PollingTask: public TaskBase, public FixedTimeslotTaskIF {
 
 	uint32_t getPeriodMs() const;
 
-	ReturnValue_t checkAndInitializeSequence() const;
+	ReturnValue_t checkSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
 protected:

From 248ceebf81e824f337edbb15fa774fb3596289b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 17:09:49 +0100
Subject: [PATCH 1023/1292] taken over host osal from upstream branch

---
 osal/host/Clock.cpp             |  5 -----
 osal/host/FixedTimeslotTask.cpp | 24 +++++++++++++-----------
 osal/host/FixedTimeslotTask.h   |  2 +-
 osal/host/MessageQueue.cpp      |  5 ++---
 osal/host/Mutex.cpp             | 11 ++---------
 osal/host/Mutex.h               |  8 ++++----
 osal/host/PeriodicTask.cpp      | 15 +++++----------
 osal/host/PeriodicTask.h        |  2 +-
 osal/host/QueueFactory.cpp      |  6 +++++-
 osal/host/QueueMapManager.cpp   | 14 +++-----------
 10 files changed, 36 insertions(+), 56 deletions(-)

diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 17d98ba8..41321eeb 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -106,11 +106,6 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t Clock::getUptimeSeconds() {
-	timeval uptime = getUptime();
-	return uptime.tv_sec;
-}
-
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	// do some magic with chrono (C++20!)
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 3c31eb76..9e892bb5 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -1,7 +1,9 @@
-#include "FixedTimeslotTask.h"
-#include "Mutex.h"
+#include "../../osal/host/FixedTimeslotTask.h"
 
 #include "../../ipc/MutexFactory.h"
+#include "../../osal/host/Mutex.h"
+#include "../../osal/host/FixedTimeslotTask.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
@@ -33,18 +35,18 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with "
-                << "code " << GetLastError() << std::endl;
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with "
-                "code " << GetLastError() << std::endl;
+        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
+                << GetLastError() << std::endl;
     }
 #elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
+    // TODO: we can just copy and paste the code from the linux OSAL here.
 #endif
 }
 
@@ -58,8 +60,7 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
-    FixedTimeslotTask *originalTask(
-            reinterpret_cast<FixedTimeslotTask*>(argument));
+    FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
 
     if (not originalTask->started) {
         // we have to suspend/block here until the task is started.
@@ -114,8 +115,9 @@ void FixedTimeslotTask::taskFunctionality() {
         this->pollingSeqTable.executeAndAdvance();
         if (not pollingSeqTable.slotFollowsImmediately()) {
             // we need to wait before executing the current slot
-            //this gives us the time to wait:
-            interval = chron_ms(this->pollingSeqTable.getIntervalToPreviousSlotMs());
+            // this gives us the time to wait:
+            interval = chron_ms(
+                    this->pollingSeqTable.getIntervalToPreviousSlotMs());
             delayForInterval(&currentStartTime, interval);
             //TODO deadline missed check
         }
diff --git a/osal/host/FixedTimeslotTask.h b/osal/host/FixedTimeslotTask.h
index 9985e2ee..f3fffd0f 100644
--- a/osal/host/FixedTimeslotTask.h
+++ b/osal/host/FixedTimeslotTask.h
@@ -74,7 +74,7 @@ protected:
     //!< Typedef for the List of objects.
     typedef std::vector<ExecutableObjectIF*> ObjectList;
     std::thread mainThread;
-    std::atomic<bool> terminateThread = false;
+    std::atomic<bool> terminateThread { false };
 
     //! Polling sequence table which contains the object to execute
     //! and information like the timeslots and the passed execution step.
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index bced3713..d662d782 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -34,7 +34,7 @@ ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 }
 
 ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
-	if (this->lastPartner != 0) {
+	if (this->lastPartner != MessageQueueIF::NO_QUEUE) {
 		return sendMessageFrom(this->lastPartner, message, this->getId());
 	} else {
 		return MessageQueueIF::NO_REPLY_PARTNER;
@@ -106,6 +106,7 @@ bool MessageQueue::isDefaultDestinationSet() const {
 ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
         bool ignoreFault) {
+	message->setSender(sentFrom);
 	if(message->getMessageSize() > message->getMaximumMessageSize()) {
 		// Actually, this should never happen or an error will be emitted
 		// in MessageQueueMessage.
@@ -126,7 +127,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		// TODO: Better returnvalue
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
 		MutexHelper mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
@@ -145,7 +145,6 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 	else {
 		return MessageQueueIF::FULL;
 	}
-    message->setSender(sentFrom);
     return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index 8471cab8..ad8873df 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,21 +4,18 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutMs == MutexIF::BLOCKING) {
+	if(timeoutType == MutexIF::BLOCKING) {
 		mutex.lock();
-		locked = true;
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutMs == MutexIF::POLLING) {
+	else if(timeoutType == MutexIF::POLLING) {
 		if(mutex.try_lock()) {
-			locked = true;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
 	else if(timeoutMs > MutexIF::POLLING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
-			locked = true;
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
@@ -26,11 +23,7 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if(not locked) {
-		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
-	}
 	mutex.unlock();
-	locked = false;
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index af56b8f7..c0fa19b7 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FSFW_OSAL_HOST_MUTEX_H_
-#define FSFW_OSAL_HOST_MUTEX_H_
+#ifndef FSFW_OSAL_HOSTED_MUTEX_H_
+#define FSFW_OSAL_HOSTED_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
@@ -22,8 +22,8 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	bool locked = false;
+	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
-#endif /* FSFW_OSAL_HOST_MUTEX_H_ */
+#endif /* FSFW_OSAL_HOSTED_MUTEX_H_ */
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index f7807a17..5662c7cc 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -89,16 +89,16 @@ ReturnValue_t PeriodicTask::sleepFor(uint32_t ms) {
 }
 
 void PeriodicTask::taskFunctionality() {
+    for (const auto& object: objectList) {
+        object->initializeAfterTaskCreation();
+    }
+
 	std::chrono::milliseconds periodChrono(static_cast<uint32_t>(period*1000));
 	auto currentStartTime {
 	    std::chrono::duration_cast<std::chrono::milliseconds>(
 	    std::chrono::system_clock::now().time_since_epoch())
 	};
-	auto nextStartTime{ currentStartTime };
-
-	for (const auto& object: objectList) {
-	    object->initializeAfterTaskCreation();
-	}
+	auto nextStartTime { currentStartTime };
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
@@ -109,10 +109,6 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 		if(not delayForInterval(&currentStartTime, periodChrono)) {
-#ifdef DEBUG
-			sif::warning << "PeriodicTask: " << taskName <<
-					" missed deadline!\n" << std::flush;
-#endif
 			if(deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
@@ -126,7 +122,6 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/osal/host/PeriodicTask.h b/osal/host/PeriodicTask.h
index 7689788a..00cb6a24 100644
--- a/osal/host/PeriodicTask.h
+++ b/osal/host/PeriodicTask.h
@@ -69,7 +69,7 @@ protected:
 	//!< Typedef for the List of objects.
 	typedef std::vector<ExecutableObjectIF*> ObjectList;
 	std::thread mainThread;
-	std::atomic<bool> terminateThread = false;
+	std::atomic<bool> terminateThread { false };
 
 	/**
 	 * @brief	This attribute holds a list of objects to be executed.
diff --git a/osal/host/QueueFactory.cpp b/osal/host/QueueFactory.cpp
index 7feb1ad6..1a679c96 100644
--- a/osal/host/QueueFactory.cpp
+++ b/osal/host/QueueFactory.cpp
@@ -1,7 +1,11 @@
+
 #include "MessageQueue.h"
-#include "../../ipc/QueueFactory.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
+#include "../../ipc/MessageQueueMessageIF.h"
+#include "../../ipc/QueueFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
+
 #include <cstring>
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index c3d94584..621f46bc 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -44,17 +44,9 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-	    if(messageQueueId == MessageQueueIF::NO_QUEUE) {
-	        sif::error << "QueueMapManager::getQueueHandle: Configuration"
-	                << " error, NO_QUEUE was passed to this function!"
-	                << std::endl;
-	    }
-	    else {
-	        sif::warning << "QueueMapManager::getQueueHandle: The ID "
-	                << messageQueueId << " does not exists in the map."
-	                << std::endl;
-	    }
-	    return nullptr;
+		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
+				messageQueueId << " does not exists in the map" << std::endl;
+		return nullptr;
 	}
 }
 

From 89e80beb62f8f52625a92b397cb2d4b16429c12b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 5 Dec 2020 17:10:36 +0100
Subject: [PATCH 1024/1292] task if set now

---
 osal/host/PeriodicTask.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 5662c7cc..bfa6c3fd 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -122,6 +122,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
+	newObject->setTaskIF(this);
 	objectList.push_back(newObject);
 	return HasReturnvaluesIF::RETURN_OK;
 }

From d9cccdedf30b8ad95b87799dba5b426b66494f56 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 14:34:56 +0100
Subject: [PATCH 1025/1292] event update

---
 datalinklayer/DataLinkLayer.h                 | 10 ++---
 datapool/HkSwitchHelper.h                     |  2 +-
 .../DeviceHandlerFailureIsolation.cpp         |  6 +--
 devicehandlers/DeviceHandlerIF.h              | 22 +++++-----
 events/Event.cpp                              | 16 -------
 events/Event.h                                | 43 ++++++++-----------
 events/EventMessage.cpp                       |  4 +-
 fdir/FailureIsolationBase.cpp                 |  4 +-
 fdir/FailureIsolationBase.h                   |  6 +--
 health/HasHealthIF.h                          | 14 +++---
 modes/HasModesIF.h                            | 16 +++----
 monitoring/MonitoringIF.h                     |  8 ++--
 power/Fuse.h                                  |  8 ++--
 power/PowerSwitchIF.h                         |  2 +-
 pus/Service17Test.h                           |  2 +-
 pus/Service9TimeManagement.h                  |  4 +-
 storagemanager/StorageManagerIF.h             |  4 +-
 thermal/AbstractTemperatureSensor.h           |  6 +--
 thermal/Heater.h                              | 10 ++---
 thermal/ThermalComponentIF.h                  | 10 ++---
 tmstorage/TmStoreBackendIF.h                  | 32 +++++++-------
 21 files changed, 104 insertions(+), 125 deletions(-)
 delete mode 100644 events/Event.cpp

diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 5a900099..30e548e8 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -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_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 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.
diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h
index 385b2047..bb9e7dc6 100644
--- a/datapool/HkSwitchHelper.h
+++ b/datapool/HkSwitchHelper.h
@@ -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();
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 24fe15a0..9d0535bf 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -191,7 +191,7 @@ void DeviceHandlerFailureIsolation::triggerEvent(Event event, uint32_t parameter
 		uint32_t parameter2) {
 	//Do not throw error events if fdirState != none.
 	//This will still forward MODE and HEALTH INFO events in any case.
-	if (fdirState == NONE || EVENT::getSeverity(event) == SEVERITY::INFO) {
+	if (fdirState == NONE || event::getSeverity(event) == severity::INFO) {
 		FailureIsolationBase::triggerEvent(event, parameter1, parameter2);
 	}
 }
@@ -201,7 +201,7 @@ bool DeviceHandlerFailureIsolation::isFdirActionInProgress() {
 }
 
 void DeviceHandlerFailureIsolation::startRecovery(Event reason) {
-	throwFdirEvent(FDIR_STARTS_RECOVERY, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_STARTS_RECOVERY, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::NEEDS_RECOVERY);
 	setFdirState(RECOVERY_ONGOING);
 }
@@ -228,7 +228,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::getParameter(uint8_t domainId,
 }
 
 void DeviceHandlerFailureIsolation::setFaulty(Event reason) {
-	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, EVENT::getEventId(reason));
+	throwFdirEvent(FDIR_TURNS_OFF_DEVICE, event::getEventId(reason));
 	setOwnerHealth(HasHealthIF::FAULTY);
 	setFdirState(AWAIT_SHUTDOWN);
 }
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 4cda99d4..12036bf1 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -95,17 +95,17 @@ public:
 	static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
-	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, SEVERITY::LOW);
-	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, SEVERITY::LOW);
-	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, SEVERITY::LOW);
-	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, SEVERITY::LOW); //!< Indicates a SW bug in child class.
-	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, SEVERITY::LOW);
-	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, SEVERITY::HIGH);
+	static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event DEVICE_SENDING_COMMAND_FAILED = MAKE_EVENT(1, severity::LOW);
+	static const Event DEVICE_REQUESTING_REPLY_FAILED = MAKE_EVENT(2, severity::LOW);
+	static const Event DEVICE_READING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event DEVICE_INTERPRETING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+	static const Event DEVICE_MISSED_REPLY = MAKE_EVENT(5, severity::LOW);
+	static const Event DEVICE_UNKNOWN_REPLY = MAKE_EVENT(6, severity::LOW);
+	static const Event DEVICE_UNREQUESTED_REPLY = MAKE_EVENT(7, severity::LOW);
+	static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW); //!< Indicates a SW bug in child class.
+	static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
+	static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 
diff --git a/events/Event.cpp b/events/Event.cpp
deleted file mode 100644
index 0f76b438..00000000
--- a/events/Event.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "Event.h"
-
-namespace EVENT {
-EventId_t getEventId(Event event) {
-	return (event & 0xFFFF);
-}
-
-EventSeverity_t getSeverity(Event event) {
-	return ((event >> 16) & 0xFF);
-}
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity) {
-	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
-}
-}
diff --git a/events/Event.h b/events/Event.h
index 90ff1a90..aebc4bc5 100644
--- a/events/Event.h
+++ b/events/Event.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 #include "fwSubsystemIdRanges.h"
-//could be move to more suitable location
+// could be moved to more suitable location
 #include <events/subsystemIdRanges.h>
 
 typedef uint16_t EventId_t;
@@ -13,33 +13,28 @@ typedef uint8_t EventSeverity_t;
 
 typedef uint32_t Event;
 
-namespace EVENT {
-EventId_t getEventId(Event event);
+namespace event {
 
-EventSeverity_t getSeverity(Event event);
-
-Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
-		EventSeverity_t eventSeverity);
+constexpr EventId_t getEventId(Event event) {
+	return (event & 0xFFFF);
 }
 
-namespace SEVERITY {
-	static const EventSeverity_t INFO = 1;
-	static const EventSeverity_t LOW = 2;
-	static const EventSeverity_t MEDIUM = 3;
-	static const EventSeverity_t HIGH = 4;
+constexpr EventSeverity_t getSeverity(Event event) {
+	return ((event >> 16) & 0xFF);
 }
 
-//Unfortunately, this does not work nicely because of the inability to define static classes in headers.
-//struct Event {
-//	Event(uint8_t domain, uint8_t counter, EventSeverity_t severity) :
-//			id(domain*100+counter), severity(severity) {
-//	}
-//	EventId_t id;
-//	EventSeverity_t severity;
-//	static const EventSeverity_t INFO = 1;
-//	static const EventSeverity_t LOW = 2;
-//	static const EventSeverity_t MEDIUM = 3;
-//	static const EventSeverity_t HIGH = 4;
-//};
+constexpr Event makeEvent(uint8_t subsystemId, uint8_t uniqueEventId,
+		EventSeverity_t eventSeverity) {
+	return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+}
+
+}
+
+namespace severity {
+	static constexpr EventSeverity_t INFO = 1;
+	static constexpr EventSeverity_t LOW = 2;
+	static constexpr EventSeverity_t MEDIUM = 3;
+	static constexpr EventSeverity_t HIGH = 4;
+}
 
 #endif /* EVENTOBJECT_EVENT_H_ */
diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp
index b911abab..bbc41e10 100644
--- a/events/EventMessage.cpp
+++ b/events/EventMessage.cpp
@@ -48,7 +48,7 @@ void EventMessage::setMessageId(uint8_t id) {
 EventSeverity_t EventMessage::getSeverity() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getSeverity(event);
+	return event::getSeverity(event);
 }
 
 void EventMessage::setSeverity(EventSeverity_t severity) {
@@ -61,7 +61,7 @@ void EventMessage::setSeverity(EventSeverity_t severity) {
 EventId_t EventMessage::getEventId() {
 	Event event;
 	memcpy(&event, getData(), sizeof(Event));
-	return EVENT::getEventId(event);
+	return event::getEventId(event);
 }
 
 void EventMessage::setEventId(EventId_t eventId) {
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index f3b34f0f..a04a0313 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -139,7 +139,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 		uint32_t parameter2) {
 	//With this mechanism, all events are disabled for a certain device.
 	//That's not so good for visibility.
-	if (isFdirDisabledForSeverity(EVENT::getSeverity(event))) {
+	if (isFdirDisabledForSeverity(event::getSeverity(event))) {
 		return;
 	}
 	EventMessage message(event, ownerId, parameter1, parameter2);
@@ -148,7 +148,7 @@ void FailureIsolationBase::triggerEvent(Event event, uint32_t parameter1,
 }
 
 bool FailureIsolationBase::isFdirDisabledForSeverity(EventSeverity_t severity) {
-	if ((owner != NULL) && (severity != SEVERITY::INFO)) {
+	if ((owner != NULL) && (severity != severity::INFO)) {
 		if (owner->getHealth() == HasHealthIF::EXTERNAL_CONTROL) {
 			//External control disables handling of fault messages.
 			return true;
diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h
index 5b2c099a..4a3f5adf 100644
--- a/fdir/FailureIsolationBase.h
+++ b/fdir/FailureIsolationBase.h
@@ -14,9 +14,9 @@ class FailureIsolationBase: public HasReturnvaluesIF,
 		public HasParametersIF {
 public:
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, SEVERITY::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
-	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, SEVERITY::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
+	static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO); //!< FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
+	static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM); //!< FDIR tries to restart device. Par1: event that caused recovery.
+	static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM); //!< FDIR turns off device. Par1: event that caused recovery.
 
 	FailureIsolationBase(object_id_t owner,
 			object_id_t parent = objects::NO_OBJECT,
diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h
index 86863ea8..a6254e39 100644
--- a/health/HasHealthIF.h
+++ b/health/HasHealthIF.h
@@ -21,13 +21,13 @@ public:
 	static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
-	static const Event HEALTH_INFO = MAKE_EVENT(6, SEVERITY::INFO);
-	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, SEVERITY::INFO);
-	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, SEVERITY::LOW);
-	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, SEVERITY::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
-	static const Event TRYING_RECOVERY = MAKE_EVENT(10, SEVERITY::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
-	static const Event RECOVERY_STEP = MAKE_EVENT(11, SEVERITY::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
-	static const Event RECOVERY_DONE = MAKE_EVENT(12, SEVERITY::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
+	static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
+	static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
+	static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
+	static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW); //!< Assembly overwrites health information of children to keep satellite alive.
+	static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM); //!< Someone starts a recovery of a component (typically power-cycle). No parameters.
+	static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM); //!< Recovery is ongoing. Comes twice during recovery. P1: 0 for the first, 1 for the second event. P2: 0
+	static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM); //!< Recovery was completed. Not necessarily successful. No parameters.
 
 	virtual ~HasHealthIF() {
 	}
diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h
index 34a15937..c29a0a96 100644
--- a/modes/HasModesIF.h
+++ b/modes/HasModesIF.h
@@ -18,14 +18,14 @@ public:
 	static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-	static const Event CHANGING_MODE = MAKE_EVENT(0, SEVERITY::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
-	static const Event MODE_INFO = MAKE_EVENT(1, SEVERITY::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
-	static const Event FALLBACK_FAILED = MAKE_EVENT(2, SEVERITY::HIGH);
-	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, SEVERITY::HIGH);
-	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, SEVERITY::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
-	static const Event FORCING_MODE = MAKE_EVENT(6, SEVERITY::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, SEVERITY::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+	static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO); //!< An object announces changing the mode. p1: target mode. p2: target submode
+	static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO); //!< An Object announces its mode; parameter1 is mode, parameter2 is  submode
+	static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
+	static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
+	static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
+	static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW); //!< Indicates a bug or configuration failure: Object is in a mode it should never be in.
+	static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM); //!< The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+	static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW); //!< A mode command was rejected by the called object. Par1: called object id, Par2: return code.
 
 	static const Mode_t MODE_ON = 1; //!< The device is powered and ready to perform operations. In this mode, no commands are sent by the device handler itself, but direct commands van be commanded and will be interpreted
 	static const Mode_t MODE_OFF = 0; //!< The device is powered off. The only command accepted in this mode is a mode change to on.
diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h
index aa266f33..32c62530 100644
--- a/monitoring/MonitoringIF.h
+++ b/monitoring/MonitoringIF.h
@@ -15,10 +15,10 @@ public:
 	static const uint8_t LIMIT_TYPE_OBJECT = 128;
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_2;
-	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event MONITOR_CHANGED_STATE = MAKE_EVENT(1, severity::LOW);
+	static const Event VALUE_BELOW_LOW_LIMIT = MAKE_EVENT(2, severity::LOW);
+	static const Event VALUE_ABOVE_HIGH_LIMIT = MAKE_EVENT(3, severity::LOW);
+	static const Event VALUE_OUT_OF_RANGE = MAKE_EVENT(4, severity::LOW);
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::LIMITS_IF;
 	static const ReturnValue_t UNCHECKED = MAKE_RETURN_CODE(1);
diff --git a/power/Fuse.h b/power/Fuse.h
index e9e9290b..cc1d534f 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -32,10 +32,10 @@ public:
 	};
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
-	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
-	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
-	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
+	static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW); //!< PSS detected a fuse that went off.
+	static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW); //!< PSS detected a fuse that violates its limits.
+	static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW); //!< PSS detected a fuse that violates its limits.
 
 	typedef std::list<PowerComponentIF*> DeviceList;
 	Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet,
diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h
index 1422baeb..b1f53a35 100644
--- a/power/PowerSwitchIF.h
+++ b/power/PowerSwitchIF.h
@@ -30,7 +30,7 @@ public:
 	static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
+	static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
 	/**
 	 * send a direct command to the Power Unit to enable/disable the specified switch.
 	 *
diff --git a/pus/Service17Test.h b/pus/Service17Test.h
index e2681865..83d436ea 100644
--- a/pus/Service17Test.h
+++ b/pus/Service17Test.h
@@ -21,7 +21,7 @@ class Service17Test: public PusServiceBase {
 public:
 	// Custom events which can be triggered
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
-	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+	static constexpr Event TEST = MAKE_EVENT(0, severity::INFO);
 
 	enum Subservice: uint8_t {
 		//! [EXPORT] : [COMMAND] Perform connection test
diff --git a/pus/Service9TimeManagement.h b/pus/Service9TimeManagement.h
index 4802cdec..70b86966 100644
--- a/pus/Service9TimeManagement.h
+++ b/pus/Service9TimeManagement.h
@@ -7,8 +7,8 @@ class Service9TimeManagement: public PusServiceBase {
 public:
 
 	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW); //!< Clock could not be set. P1: Returncode.
 
 	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 
diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h
index 769616d7..62251933 100644
--- a/storagemanager/StorageManagerIF.h
+++ b/storagemanager/StorageManagerIF.h
@@ -40,8 +40,8 @@ public:
 	static const ReturnValue_t POOL_TOO_LARGE = MAKE_RETURN_CODE(6); //!< Pool size too large on initialization.
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::OBSW;
-	static const Event GET_DATA_FAILED = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, SEVERITY::LOW);
+	static const Event GET_DATA_FAILED = MAKE_EVENT(0, severity::LOW);
+	static const Event STORE_DATA_FAILED = MAKE_EVENT(1, severity::LOW);
 
 	//!< Indicates an invalid (i.e unused) storage address.
 	static const uint32_t INVALID_ADDRESS = 0xFFFFFFFF;
diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h
index cc064ce4..a1153314 100644
--- a/thermal/AbstractTemperatureSensor.h
+++ b/thermal/AbstractTemperatureSensor.h
@@ -27,9 +27,9 @@ class AbstractTemperatureSensor: public HasHealthIF,
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::T_SENSORS;
-	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, SEVERITY::LOW);
+	static const Event TEMP_SENSOR_HIGH = MAKE_EVENT(0, severity::LOW);
+	static const Event TEMP_SENSOR_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event TEMP_SENSOR_GRADIENT = MAKE_EVENT(2, severity::LOW);
 
 	static constexpr float ZERO_KELVIN_C = -273.15;
 	AbstractTemperatureSensor(object_id_t setObjectid,
diff --git a/thermal/Heater.h b/thermal/Heater.h
index 63fe2066..b034dfee 100644
--- a/thermal/Heater.h
+++ b/thermal/Heater.h
@@ -14,11 +14,11 @@ class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
-	static const Event HEATER_ON = MAKE_EVENT(0, SEVERITY::INFO);
-	static const Event HEATER_OFF = MAKE_EVENT(1, SEVERITY::INFO);
-	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, SEVERITY::LOW);
+	static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
+	static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
+	static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
+	static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
+	static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
 
 	Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
 	virtual ~Heater();
diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h
index 16739e36..89c2b2d0 100644
--- a/thermal/ThermalComponentIF.h
+++ b/thermal/ThermalComponentIF.h
@@ -10,11 +10,11 @@ class ThermalComponentIF : public HasParametersIF {
 public:
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_1;
-	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, SEVERITY::LOW);
-	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, SEVERITY::LOW);
-	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, SEVERITY::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
+	static const Event COMPONENT_TEMP_LOW = MAKE_EVENT(1, severity::LOW);
+	static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, severity::LOW);
+	static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, severity::LOW);
+	static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, severity::LOW); //!< Is thrown when a device should start-up, but the temperature is out of OP range. P1: thermalState of the component, P2: 0
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
 	static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index bfabdd31..2ebe85e4 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -31,22 +31,22 @@ public:
 	static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
 
 	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, SEVERITY::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, SEVERITY::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, SEVERITY::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-	static const Event STORE_READ_FAILED = MAKE_EVENT(3, SEVERITY::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, SEVERITY::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-	static const Event STORING_FAILED = MAKE_EVENT(5, SEVERITY::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, SEVERITY::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
-	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, SEVERITY::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, SEVERITY::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
-	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, SEVERITY::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
-	static const Event STORE_INITIALIZE = MAKE_EVENT(10, SEVERITY::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event INIT_DONE = MAKE_EVENT(11, SEVERITY::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
-	static const Event DUMP_FINISHED = MAKE_EVENT(12, SEVERITY::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FINISHED = MAKE_EVENT(13, SEVERITY::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
-	static const Event DELETION_FAILED = MAKE_EVENT(14, SEVERITY::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
-	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, SEVERITY::INFO);//!< Info that the a auto catalog report failed
+	static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW); //!< Initiating sending data to store failed. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW); //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW); //!< Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+	static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW); //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+	static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW); //!< An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+	static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW); //!< Storing data failed. May simply be a full store. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW); //!< Dumping retrieved data failed. Low, par1: returnCode, par2: integer (sequence count of failed packet).
+	static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW); //!< Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+	static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO); //!< Store was not initialized. Starts empty. Info, parameters both zero.
+	static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW); //!< Data was read out, but it is inconsistent. Low par1: Memory address of corruption, par2: integer (debug info)
+	static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO); //!< Info event indicating the store will be initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO); //!< Info event indicating the store was successfully initialized, either at boot or after IOB switch. Info. pars: 0
+	static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO); //!< Info event indicating that dumping finished successfully. par1: Number of dumped packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO); //!< Info event indicating that deletion finished successfully. par1: Number of deleted packets. par2: APID/SSC (16bits each)
+	static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW); //!< Info event indicating that something went wrong during deletion. pars: 0
+	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
 

From 322dd1253e222ecfc81f40c671864d75d2e0334a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:15:22 +0100
Subject: [PATCH 1026/1292] map packet extract update

---
 datalinklayer/MapPacketExtraction.cpp |  4 ++--
 datalinklayer/MapPacketExtraction.h   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 45f7d3f8..845ed7c1 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -9,9 +9,9 @@
 
 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(NULL), tcQueueId(MessageQueueIF::NO_QUEUE) {
+		tcQueueId(MessageQueueIF::NO_QUEUE) {
 	std::memset(packetBuffer, 0, sizeof(packetBuffer));
 }
 
diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h
index eff9b7c3..ddb867fb 100644
--- a/datalinklayer/MapPacketExtraction.h
+++ b/datalinklayer/MapPacketExtraction.h
@@ -1,5 +1,5 @@
-#ifndef MAPPACKETEXTRACTION_H_
-#define MAPPACKETEXTRACTION_H_
+#ifndef FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
+#define FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_
 
 #include "MapPacketExtractionIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
@@ -20,11 +20,12 @@ 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.
@@ -69,4 +70,4 @@ public:
 	uint8_t getMapId() const;
 };
 
-#endif /* MAPPACKETEXTRACTION_H_ */
+#endif /* FSFW_DATALINKLAYER_MAPPACKETEXTRACTION_H_ */

From beab942f07458c709cb39d8b4976fd1462438fd6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 15:57:30 +0100
Subject: [PATCH 1027/1292] fixes taken over from master

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4bda0850..733106e5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -693,7 +693,7 @@ void DeviceHandlerBase::doGetRead() {
 void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		size_t receivedDataLen) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	DeviceCommandId_t foundId = 0xffffffff;
+	DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND;
 	size_t foundLen = 0;
 	// The loop may not execute more often than the number of received bytes
 	// (worst case). This approach avoids infinite loops due to buggy

From e9a740f110c61cff3c836afecfdb1f635ba533f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 16:00:02 +0100
Subject: [PATCH 1028/1292] small tweak

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 49617cd5..2bfa62a6 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -234,7 +234,7 @@ protected:
 	 *  - If the device does not change the mode, the mode will be changed to
 	 *    _MODE_POWER_DOWN, when the timeout (from getTransitionDelay())
 	 *    has passed.
-	 * 0xffffffff
+	 *
 	 * #transitionFailure can be set to a failure code indicating the reason
 	 * for a failed transition
 	 */

From df333e0cc828afaacc7b591527ea724b342025b5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 8 Dec 2020 16:01:23 +0100
Subject: [PATCH 1029/1292] tab replacement

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 733106e5..f095834e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -113,7 +113,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-        hkManager.performHkOperation();
+		hkManager.performHkOperation();
 		break;
 	default:
 		break;

From 9a540e97c557e58a8b7b933c6f41fde21e8fa315 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:36:44 +0100
Subject: [PATCH 1030/1292] taken over thermal module from thermal-update

---
 thermal/ThermalModule.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h
index d1e4fccb..0abe51c7 100644
--- a/thermal/ThermalModule.h
+++ b/thermal/ThermalModule.h
@@ -5,8 +5,6 @@
 #include "tcsDefinitions.h"
 #include "RedundantHeater.h"
 
-//#include "../datapoolglob/GlobalDataSet.h"
-//#include "../datapoolglob/GlobalPoolVariable.h"
 #include "../datapoollocal/LocalPoolDataSetBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 #include "../devicehandlers/HealthDevice.h"
@@ -78,7 +76,6 @@ protected:
 	Parameters parameters;
 
 	lp_var_t<float> moduleTemperature;
-	//gp_float_t moduleTemperature;
 
 	RedundantHeater *heater = nullptr;
 

From 5bad1142059af8a946fe57c0cad31284fd8496ea Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:39:31 +0100
Subject: [PATCH 1031/1292] thermal module set heating repaired

---
 thermal/ThermalModule.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 2bc1741f..457a6743 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -256,15 +256,16 @@ bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 }
 
 void ThermalModule::setHeating(bool on) {
-//	GlobDataSet mySet;
-//	gp_int8_t writableTargetState(targetState.getDataPoolId(),
-//			&mySet, PoolVariableIF::VAR_WRITE);
-//	if (on) {
-//		writableTargetState = STATE_REQUEST_HEATING;
-//	} else {
-//		writableTargetState = STATE_REQUEST_PASSIVE;
-//	}
-//	mySet.commit(PoolVariableIF::VALID);
+	ReturnValue_t result = targetState.read();
+	if(result == HasReturnvaluesIF::RETURN_OK) {
+		if(on) {
+			targetState.value = STATE_REQUEST_HEATING;
+		}
+		else {
+			targetState.value = STATE_REQUEST_PASSIVE;
+		}
+	}
+	targetState.setValid(true);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,

From b2d01a31c224cf609ed2cc83e5e482604881a64d Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Thu, 10 Dec 2020 16:58:18 +0100
Subject: [PATCH 1032/1292] removed some commented stuff

---
 power/Fuse.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/power/Fuse.h b/power/Fuse.h
index cc1d534f..b892611b 100644
--- a/power/Fuse.h
+++ b/power/Fuse.h
@@ -85,10 +85,7 @@ private:
 	};
 	PowerMonitor powerMonitor;
 	StaticLocalDataSet<3> set;
-	//LocalPoolDataSetBase* set = nullptr;
-	//PIDReader<float> voltage;
-	//PIDReader<float> current;
-	//PIDReader<uint8_t> state;
+
 	lp_var_t<float> voltage;
 	lp_var_t<float> current;
 	lp_var_t<uint8_t> state;

From b7dbdb072d46d72e8b8730c9edad97c710f4d3ad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:50:33 +0100
Subject: [PATCH 1033/1292] taken over upstream changes

---
 CHANGELOG                             | 49 +++++++++++++++
 CMakeLists.txt                        | 85 +++++++++++++++++++++++++++
 FSFWVersion.h                         |  3 +-
 controller/CMakeLists.txt             |  4 ++
 controller/ControllerBase.cpp         |  7 +--
 controller/ControllerBase.h           |  3 -
 controller/ExtendedControllerBase.cpp |  1 -
 7 files changed, 141 insertions(+), 11 deletions(-)
 create mode 100644 CMakeLists.txt
 create mode 100644 controller/CMakeLists.txt

diff --git a/CHANGELOG b/CHANGELOG
index a6686478..7b07db08 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,5 +1,8 @@
 ## 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
 
@@ -11,3 +14,49 @@ a C file without issues
 - 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 aclear distinction between operation and communication steps
+
+### 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
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 00000000..669283c7
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.13)
+
+set(LIB_FSFW_NAME fsfw)
+add_library(${LIB_FSFW_NAME})
+
+# Set options for FSFW OSAL selection.
+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()
+
+set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
+
+if(${OS_FSFW} STREQUAL host)
+set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+set(OS_FSFW_NAME "Linux")
+elseif(${OS_FSFW} STREQUAL  freertos)
+set(OS_FSFW_NAME "FreeRTOS")
+elseif(${OS_FSFW} STREQUAL rtems)
+set(OS_FSFW_NAME "RTEMS")
+else()
+message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
+set(OS_FSFW_NAME "Host")
+set(OS_FSFW "host")
+endif()
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+
+# 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)
+
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(controller)
+add_subdirectory(coordinates)
+add_subdirectory(datalinklayer)
+add_subdirectory(datapool)
+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)
+
+# 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()
+
+# Required include paths to compile the FSFW
+target_include_directories(${LIB_FSFW_NAME} 
+	INTERFACE 
+		${FSFW_CONFIG_PATH}
+)
diff --git a/FSFWVersion.h b/FSFWVersion.h
index dcb592dc..11a60891 100644
--- a/FSFWVersion.h
+++ b/FSFWVersion.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_DEFAULTCFG_VERSION_H_
 #define FSFW_DEFAULTCFG_VERSION_H_
 
-const char* const FSFW_VERSION_NAME = "fsfw";
+const char* const FSFW_VERSION_NAME = "ASTP";
 
 #define FSFW_VERSION 		0
 #define	FSFW_SUBVERSION 	0
+#define	FSFW_REVISION 	1
 
 
 
diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt
new file mode 100644
index 00000000..6f660738
--- /dev/null
+++ b/controller/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerBase.cpp
+)
\ No newline at end of file
diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp
index 45e678eb..2a402468 100644
--- a/controller/ControllerBase.cpp
+++ b/controller/ControllerBase.cpp
@@ -8,7 +8,7 @@ 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), hkSwitcher(this) {
+		healthHelper(this, setObjectId) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(
 	        commandQueueDepth);
 }
@@ -44,10 +44,6 @@ ReturnValue_t ControllerBase::initialize() {
 		return result;
 	}
 
-	result = hkSwitcher.initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
 	return RETURN_OK;
 }
 
@@ -107,7 +103,6 @@ void ControllerBase::announceMode(bool recursive) {
 
 ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
 	handleQueue();
-	hkSwitcher.performOperation();
 	performControlOperation();
 	return RETURN_OK;
 }
diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h
index 25d3ab1f..6e83fe80 100644
--- a/controller/ControllerBase.h
+++ b/controller/ControllerBase.h
@@ -72,9 +72,6 @@ protected:
 
 	HealthHelper healthHelper;
 
-	// Is this still needed?
-	HkSwitchHelper hkSwitcher;
-
 	/**
 	 * Pointer to the task which executes this component,
 	 * is invalid before setTaskIF was called.
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f69d2ea1..fa4f6786 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -97,7 +97,6 @@ ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    hkSwitcher.performOperation();
     localPoolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;

From 0e42ba062dd9b217e1f89eb62f30295d4e31beb4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:51:46 +0100
Subject: [PATCH 1034/1292] notice taken over

---
 NOTICE | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/NOTICE b/NOTICE
index e1663282..be1a37c4 100644
--- a/NOTICE
+++ b/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.
 

From f69113b4d516b12a2a9fc7624f17ab311e6f91fb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:53:37 +0100
Subject: [PATCH 1035/1292] taken over upstream change in ipc

---
 ipc/MutexFactory.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f34d3b04..f8133d81 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
 #define FRAMEWORK_IPC_MUTEXFACTORY_H_
 
-#include "../ipc/MutexIF.h"
+#include "MutexIF.h"
 /**
  * Creates Mutex.
  * This class is a "singleton" interface, i.e. it provides an

From d944e25d4a3b037f82981fad278de5fb9e367086 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:54:46 +0100
Subject: [PATCH 1036/1292] taken over upstream changes

---
 ipc/MessageQueueSenderIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h
index 42d4078f..683c2908 100644
--- a/ipc/MessageQueueSenderIF.h
+++ b/ipc/MessageQueueSenderIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 
-#include "../ipc/MessageQueueIF.h"
-#include "../ipc/MessageQueueMessageIF.h"
+#include "MessageQueueIF.h"
+#include "MessageQueueMessageIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 
 class MessageQueueSenderIF {

From 0b056720bae878adf65bcb1fa6cf01f98ccdd6a4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:57:06 +0100
Subject: [PATCH 1037/1292] taken over master

---
 ipc/CommandMessage.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h
index 8f5daa04..28822dd0 100644
--- a/ipc/CommandMessage.h
+++ b/ipc/CommandMessage.h
@@ -2,6 +2,7 @@
 #define FSFW_IPC_COMMANDMESSAGE_H_
 
 #include "CommandMessageIF.h"
+
 #include "MessageQueueMessage.h"
 #include "FwMessageTypes.h"
 

From 7c390c07eed79ee02fa23266ece8d0218672923e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 21:58:54 +0100
Subject: [PATCH 1038/1292] taken over unnittest folder from upstream

---
 unittest/core/CatchSetup.cpp                  |  11 +-
 unittest/internal/InternalUnitTester.h        |   2 +-
 unittest/internal/UnittDefinitions.cpp        |   2 +-
 unittest/internal/osal/IntTestMq.cpp          |   9 +-
 unittest/internal/osal/IntTestMutex.cpp       |   8 +-
 unittest/internal/osal/IntTestSemaphore.cpp   |   9 +-
 .../serialize/IntTestSerialization.cpp        |   9 +-
 .../internal/serialize/IntTestSerialization.h |   9 +-
 unittest/testcfg/CatchFactory.cpp             |  60 ++++
 unittest/testcfg/CatchFactory.h               |  16 ++
 unittest/testcfg/FSFWConfig.h                 |   2 +-
 unittest/testcfg/cdatapool/dataPoolInit.h     |   2 +-
 unittest/testcfg/testcfg.mk                   |   1 +
 unittest/tests/action/TestActionHelper.cpp    | 213 +++++++-------
 unittest/tests/action/TestActionHelper.h      | 263 +++++++++---------
 unittest/tests/container/RingBufferTest.cpp   |   4 +-
 unittest/tests/container/TestArrayList.cpp    |   5 +-
 unittest/tests/container/TestDynamicFifo.cpp  |   6 +-
 unittest/tests/container/TestFifo.cpp         |   6 +-
 .../tests/container/TestFixedArrayList.cpp    |   4 +-
 unittest/tests/container/TestFixedMap.cpp     |   4 +-
 .../container/TestFixedOrderedMultimap.cpp    |   4 +-
 unittest/tests/osal/TestMessageQueue.cpp      |   8 +-
 .../serialize/TestSerialBufferAdapter.cpp     |   2 +-
 .../serialize/TestSerialLinkedPacket.cpp      |   7 +-
 .../tests/serialize/TestSerialization.cpp     |   2 +-
 26 files changed, 376 insertions(+), 292 deletions(-)
 create mode 100644 unittest/testcfg/CatchFactory.cpp
 create mode 100644 unittest/testcfg/CatchFactory.h

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 5749ecd1..cb5bd33e 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,8 +1,7 @@
 #include "CatchDefinitions.h"
+#include "CatchFactory.h"
 
 #include <testcfg/cdatapool/dataPoolInit.h>
-#include <testcfg/objects/Factory.h>
-
 
 #ifdef GCOV
 #include <gcov.h>
@@ -11,15 +10,15 @@
 #include "../../objectmanager/ObjectManager.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../datapoolglob/GlobalDataPool.h"
+#include "../../datapool/DataPool.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-namespace glob {
-GlobalDataPool dataPool(datapool::dataPoolInit);
-}
+//namespace glob {
+DataPool dataPool(datapool::dataPoolInit);
+//}
 
 
 namespace sif {
diff --git a/unittest/internal/InternalUnitTester.h b/unittest/internal/InternalUnitTester.h
index b301b923..d0b1c106 100644
--- a/unittest/internal/InternalUnitTester.h
+++ b/unittest/internal/InternalUnitTester.h
@@ -2,7 +2,7 @@
 #define FRAMEWORK_TEST_UNITTESTCLASS_H_
 
 #include "UnittDefinitions.h"
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief	Can be used for internal testing, for example for hardware specific
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 0bdbfcc7..6265e9fd 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
 	sif::error << "Unit Tester error: Failed at test ID "
diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 63016374..8d95f51e 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,7 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/unittest/internal/osal/IntTestMq.h>
-#include <fsfw/unittest/internal/UnittDefinitions.h>
+#include "IntTestMq.h"
+#include "../UnittDefinitions.h"
+
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3fd668df..01581347 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,10 +1,10 @@
 #include "IntTestMutex.h"
 
-#include <fsfw/ipc/MutexFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
+#include "../../ipc/MutexFactory.h"
+#include "../UnittDefinitions.h"
 
 #if defined(hosted)
-#include <fsfw/osal/hosted/Mutex.h>
+#include "../../osal/hosted/Mutex.h"
 #include <thread>
 #include <future>
 #endif
@@ -20,7 +20,7 @@ void testmutex::testMutex() {
 	// timed_mutex from the C++ library specifies undefined behaviour if
 	// the timed mutex is locked twice from the same thread.
 #if defined(hosted)
-	// hold on, this actually worked ? :-D This calls the function from
+	// This calls the function from
 	// another thread and stores the returnvalue in a future.
 	auto future = std::async(&MutexIF::lockMutex, mutex, 1);
 	result = future.get();
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 534a6a6d..f260b6a5 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSemaphore.h"
-#include <fsfw/tasks/SemaphoreFactory.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/timemanager/Stopwatch.h>
+#include "../UnittDefinitions.h"
+
+#include "../../tasks/SemaphoreFactory.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 3f231a41..1e33ff33 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
-#include <fsfw/serialize/SerializeElement.h>
-#include <fsfw/serialize/SerialBufferAdapter.h>
-#include <unittest/internal/UnittDefinitions.h>
-#include <fsfw/serialize/SerializeIF.h>
+#include "../UnittDefinitions.h"
+#include "../../serialize/SerializeElement.h"
+#include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerializeIF.h"
+
 #include <array>
 
 using retval = HasReturnvaluesIF;
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index f8841b82..e8dbd35a 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,6 +1,7 @@
-#ifndef UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#define UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+#define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
+
+#include "../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {
@@ -12,4 +13,4 @@ ReturnValue_t test_serial_buffer_adapter();
 extern std::array<uint8_t, 512> test_array;
 }
 
-#endif /* UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
+#endif /* FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_ */
diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
new file mode 100644
index 00000000..c74a8126
--- /dev/null
+++ b/unittest/testcfg/CatchFactory.cpp
@@ -0,0 +1,60 @@
+#include "CatchFactory.h"
+
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+
+#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/storagemanager/PoolManager.h>
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produce(void) {
+	setStaticFrameworkObjectIds();
+	new EventManager(objects::EVENT_MANAGER);
+	new HealthTable(objects::HEALTH_TABLE);
+	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 5;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
+				n_elements);
+	}
+
+	{
+		static constexpr uint8_t NUMBER_OF_POOLS = 6;
+		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
+				1024, 2048, 4096};
+		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
+		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
+				n_elements);
+	}
+
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+
+}
+
+
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/testcfg/CatchFactory.h
new file mode 100644
index 00000000..84f9207e
--- /dev/null
+++ b/unittest/testcfg/CatchFactory.h
@@ -0,0 +1,16 @@
+#ifndef FACTORY_H_
+#define FACTORY_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+namespace Factory {
+	/**
+	 * @brief 	Creates all SystemObject elements which are persistent
+	 * 			during execution.
+	 */
+	void produce();
+	void setStaticFrameworkObjectIds();
+
+}
+
+#endif /* FACTORY_H_ */
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index d3451985..4fb224c1 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -12,7 +12,7 @@
 #define FSFW_REDUCED_PRINTOUT		0
 
 //! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_VERBOSE_PRINTOUT       0
+#define FSFW_DEBUGGING              0
 
 //! Defines the FIFO depth of each commanding service base which
 //! also determines how many commands a CSB service can handle in one cycle
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/testcfg/cdatapool/dataPoolInit.h
index 23a3d01f..9425d767 100644
--- a/unittest/testcfg/cdatapool/dataPoolInit.h
+++ b/unittest/testcfg/cdatapool/dataPoolInit.h
@@ -1,7 +1,7 @@
 #ifndef HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 #define HOSTED_CONFIG_CDATAPOOL_DATAPOOLINIT_H_
 
-#include <fsfw/datapoolglob/GlobalDataPool.h>
+#include <fsfw/datapool/DataPool.h>
 #include <fsfw/datapool/PoolEntryIF.h>
 #include <map>
 #include <cstdint>
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 64fa87f6..31d3b60a 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -3,6 +3,7 @@ CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
 INCLUDES += $(CURRENTPATH)/objects
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index d5b2e467..944ad705 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,106 +1,107 @@
-//#include "TestActionHelper.h"
-//#include <fsfw/action/ActionHelper.h>
-//#include <fsfw/ipc/CommandMessage.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//
-//TEST_CASE( "Action Helper" , "[ActionHelper]") {
-//	ActionHelperOwnerMockBase testDhMock;
-//	MessageQueueMockBase testMqMock;
-//	ActionHelper actionHelper = ActionHelper(
-//			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
-//	CommandMessage actionMessage;
-//	ActionId_t testActionId = 777;
-//	std::array <uint8_t, 3> testParams {1, 2, 3};
-//	store_address_t paramAddress;
-//	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
-//	ipcStore->addData(&paramAddress, testParams.data(), 3);
-//	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
-//
-//	SECTION ("Simple tests") {
-//		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
-//		 CHECK(not testDhMock.executeActionCalled);
-//		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		 CHECK(testDhMock.executeActionCalled);
-//		 // No message is sent if everything is alright.
-//		 CHECK(not testMqMock.wasMessageSent());
-//		 store_address_t invalidAddress;
-//		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-//		 actionHelper.handleActionMessage(&actionMessage);
-//		 CHECK(testMqMock.wasMessageSent());
-//		 const uint8_t* ptr = nullptr;
-//		 size_t size = 0;
-//		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		 REQUIRE(ptr == nullptr);
-//		 REQUIRE(size == 0);
-//		 testDhMock.getBuffer(&ptr, &size);
-//		 REQUIRE(size == 3);
-//		 for(uint8_t i = 0; i<3;i++){
-//			 REQUIRE(ptr[i] == (i+1));
-//		 }
-//		 testDhMock.clearBuffer();
-//	}
-//
-//	SECTION("Handle failures"){
-//		actionMessage.setCommand(1234);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
-//		CHECK(not testMqMock.wasMessageSent());
-//		uint16_t step = 5;
-//		ReturnValue_t status = 0x1234;
-//		actionHelper.step(step, testMqMock.getId(), testActionId, status);
-//		step += 1;
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
-//		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
-//		REQUIRE(testMessage.getParameter2() == parameter2);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == step);
-//	}
-//
-//	SECTION("Handle finish"){
-//		CHECK(not testMqMock.wasMessageSent());
-//		ReturnValue_t status = 0x9876;
-//		actionHelper.finish(testMqMock.getId(), testActionId, status);
-//		CHECK(testMqMock.wasMessageSent());
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
-//	}
-//
-//	SECTION("Handle failed"){
-//		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
-//		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
-//		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
-//		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
-//	}
-//
-//	SECTION("Missing IPC Data"){
-//		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
-//		CHECK(not testDhMock.executeActionCalled);
-//		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
-//		CommandMessage testMessage;
-//		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
-//		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
-//		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
-//	}
-//
-//
-//	SECTION("Data Reply"){
-//
-//	}
-//}
+#include "TestActionHelper.h"
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+#include <catch2/catch.hpp>
+#include "../../core/CatchDefinitions.h"
+
+
+TEST_CASE( "Action Helper" , "[ActionHelper]") {
+	ActionHelperOwnerMockBase testDhMock;
+	MessageQueueMockBase testMqMock;
+	ActionHelper actionHelper = ActionHelper(
+			&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+	CommandMessage actionMessage;
+	ActionId_t testActionId = 777;
+	std::array <uint8_t, 3> testParams {1, 2, 3};
+	store_address_t paramAddress;
+	StorageManagerIF *ipcStore = tglob::getIpcStoreHandle();
+	REQUIRE(ipcStore != nullptr);
+	ipcStore->addData(&paramAddress, testParams.data(), 3);
+	REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+	SECTION ("Simple tests") {
+		 ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+		 CHECK(not testDhMock.executeActionCalled);
+		 REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		 CHECK(testDhMock.executeActionCalled);
+		 // No message is sent if everything is alright.
+		 CHECK(not testMqMock.wasMessageSent());
+		 store_address_t invalidAddress;
+		 ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+		 actionHelper.handleActionMessage(&actionMessage);
+		 CHECK(testMqMock.wasMessageSent());
+		 const uint8_t* ptr = nullptr;
+		 size_t size = 0;
+		 REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		 REQUIRE(ptr == nullptr);
+		 REQUIRE(size == 0);
+		 testDhMock.getBuffer(&ptr, &size);
+		 REQUIRE(size == 3);
+		 for(uint8_t i = 0; i<3;i++){
+			 REQUIRE(ptr[i] == (i+1));
+		 }
+		 testDhMock.clearBuffer();
+	}
+
+	SECTION("Handle failures"){
+		actionMessage.setCommand(1234);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+		CHECK(not testMqMock.wasMessageSent());
+		uint16_t step = 5;
+		ReturnValue_t status = 0x1234;
+		actionHelper.step(step, testMqMock.getId(), testActionId, status);
+		step += 1;
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+		uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+		REQUIRE(testMessage.getParameter2() == parameter2);
+		REQUIRE(ActionMessage::getStep(&testMessage) == step);
+	}
+
+	SECTION("Handle finish"){
+		CHECK(not testMqMock.wasMessageSent());
+		ReturnValue_t status = 0x9876;
+		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		CHECK(testMqMock.wasMessageSent());
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+	}
+
+	SECTION("Handle failed"){
+		store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+		std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+		REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+		ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		REQUIRE(ipcStore->getData(toLongParamAddress).first == static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+		REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+	}
+
+	SECTION("Missing IPC Data"){
+		ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+		CHECK(not testDhMock.executeActionCalled);
+		REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+		CommandMessage testMessage;
+		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+		REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+		REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+	}
+
+
+	SECTION("Data Reply"){
+
+	}
+}
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 9bc93d3e..4ba417eb 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -1,131 +1,132 @@
-//#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
-//
-//#include <fsfw/action/HasActionsIF.h>
-//#include <fsfw/ipc/MessageQueueIF.h>
-//#include <fsfw/unittest/core/CatchDefinitions.h>
-//#include <cstring>
-//
-//
-//class ActionHelperOwnerMockBase: public HasActionsIF {
-//public:
-//	bool getCommandQueueCalled = false;
-//	bool executeActionCalled = false;
-//	static const size_t MAX_SIZE = 3;
-//	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
-//	size_t size = 0;
-//
-//	MessageQueueId_t getCommandQueue() const override {
-//		return tconst::testQueueId;
-//	}
-//
-//	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-//			const uint8_t* data, size_t size) override {
-//		executeActionCalled = true;
-//		if(size > MAX_SIZE){
-//			return 0xAFFE;
-//		}
-//		this->size = size;
-//		memcpy(buffer, data, size);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//
-//	void clearBuffer(){
-//		this->size = 0;
-//		for(size_t i = 0; i<MAX_SIZE; i++){
-//			buffer[i] = 0;
-//		}
-//	}
-//
-//	void getBuffer(const uint8_t** ptr, size_t* size){
-//		if(size != nullptr){
-//			*size = this->size;
-//		}
-//		if(ptr != nullptr){
-//			*ptr = buffer;
-//		}
-//	}
-//};
-//
-//
-//class MessageQueueMockBase: public MessageQueueIF {
-//public:
-//	MessageQueueId_t myQueueId = 0;
-//	bool defaultDestSet = false;
-//	bool messageSent = false;
-//
-//
-//
-//	bool wasMessageSent() {
-//		bool tempMessageSent = messageSent;
-//		messageSent = false;
-//		return tempMessageSent;
-//	}
-//
-//	virtual ReturnValue_t reply( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	};
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message,
-//			MessageQueueId_t *receivedFrom) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t receiveMessage(MessageQueueMessage* message) {
-//		(*message) = lastMessage;
-//		lastMessage.clear();
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t flush(uint32_t* count) {
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual MessageQueueId_t getLastPartner() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual MessageQueueId_t getId() const {
-//		return tconst::testQueueId;
-//	}
-//	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, MessageQueueId_t sentFrom,
-//			bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-//			MessageQueueMessage* message, bool ignoreFault = false ) override {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message,
-//			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual ReturnValue_t sendToDefault( MessageQueueMessage* message ) {
-//		messageSent = true;
-//		lastMessage = (*message);
-//		return HasReturnvaluesIF::RETURN_OK;
-//	}
-//	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-//		myQueueId = defaultDestination;
-//		defaultDestSet = true;
-//	}
-//
-//	virtual MessageQueueId_t getDefaultDestination() const {
-//		return myQueueId;
-//	}
-//	virtual bool isDefaultDestinationSet() const {
-//		return defaultDestSet;
-//	}
-//private:
-//	MessageQueueMessage lastMessage;
-//
-//};
-//
-//
-//#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class ActionHelperOwnerMockBase: public HasActionsIF {
+public:
+	bool getCommandQueueCalled = false;
+	bool executeActionCalled = false;
+	static const size_t MAX_SIZE = 3;
+	uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+	size_t size = 0;
+
+	MessageQueueId_t getCommandQueue() const override {
+		return tconst::testQueueId;
+	}
+
+	ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+			const uint8_t* data, size_t size) override {
+		executeActionCalled = true;
+		if(size > MAX_SIZE){
+			return 0xAFFE;
+		}
+		this->size = size;
+		memcpy(buffer, data, size);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	void clearBuffer(){
+		this->size = 0;
+		for(size_t i = 0; i<MAX_SIZE; i++){
+			buffer[i] = 0;
+		}
+	}
+
+	void getBuffer(const uint8_t** ptr, size_t* size){
+		if(size != nullptr){
+			*size = this->size;
+		}
+		if(ptr != nullptr){
+			*ptr = buffer;
+		}
+	}
+};
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 8b82d407..9c1c8a23 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,7 +1,7 @@
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
+#include "../../container/SimpleRingBuffer.h"
 
+#include <catch2/catch.hpp>
 #include <cstring>
 
 TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index 914188cb..2f884276 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,5 +1,6 @@
-#include <fsfw/container/ArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/ArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
+
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
 
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index 6c9b7415..bb19131e 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch.hpp>
 #include <CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index 3775f424..bd727e00 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,7 +1,7 @@
 
-#include <fsfw/container/DynamicFIFO.h>
-#include <fsfw/container/FIFO.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/DynamicFIFO.h"
+#include "../../container/FIFO.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 737932e3..5a1bd280 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,7 +1,7 @@
 #include "../../core/CatchDefinitions.h"
 
-#include <fsfw/container/FixedArrayList.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedArrayList.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index 079062f0..da0c84e3 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedMap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedMap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index 95194cb5..e625b559 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,5 +1,5 @@
-#include <fsfw/container/FixedOrderedMultimap.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../container/FixedOrderedMultimap.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 8e59fa08..441d32e7 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,8 +1,8 @@
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include "catch.hpp"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/QueueFactory.h"
+#include <catch.hpp>
 #include <array>
-#include "core/CatchDefinitions.h"
+#include "../../core/CatchDefinitions.h"
 
 TEST_CASE("MessageQueue Basic Test","[TestMq]") {
 	MessageQueueIF* testSenderMq =
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 9919ed84..07cd3f9c 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerialBufferAdapter.h>
+#include "../../serialize/SerialBufferAdapter.h"
 
 #include <catch2/catch.hpp>
 #include "../../core/CatchDefinitions.h"
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 0a09e430..fbe48894 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/globalfunctions/arrayprinter.h>
+#include "TestSerialLinkedPacket.h"
+#include "../../core/CatchDefinitions.h"
+
+#include "../../globalfunctions/arrayprinter.h"
 
 #include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
-#include "TestSerialLinkedPacket.h"
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 4c9ba181..6e31170a 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/serialize/SerializeAdapter.h>
+#include "../../serialize/SerializeAdapter.h"
 
 #include "catch.hpp"
 #include <array>

From 3f77fab2d9ada5b029cf823674adaa5e5ea7d403 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 22:01:38 +0100
Subject: [PATCH 1039/1292] taken over cmake lists

---
 rmap/CMakeLists.txt | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 rmap/CMakeLists.txt

diff --git a/rmap/CMakeLists.txt b/rmap/CMakeLists.txt
new file mode 100644
index 00000000..78c99e42
--- /dev/null
+++ b/rmap/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		RMAP.cpp
+		RMAPCookie.cpp
+		RmapDeviceCommunicationIF.cpp
+)
+

From 692aa087d8d4dfb3c02cb7bf61b93ea47e1ba8df Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 13 Dec 2020 22:13:22 +0100
Subject: [PATCH 1040/1292] taken over cleaned up branch

---
 rmap/RMAP.cpp                      | 10 ++++++----
 rmap/RMAP.h                        |  4 ++--
 rmap/RMAPChannelIF.h               |  8 ++++----
 rmap/RMAPCookie.cpp                |  9 +++++----
 rmap/RMAPCookie.h                  | 11 ++++++-----
 rmap/RmapDeviceCommunicationIF.cpp |  4 ++--
 rmap/RmapDeviceCommunicationIF.h   |  6 +++---
 rmap/rmapStructs.h                 |  8 ++++----
 8 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp
index d0872c8e..7ea6e532 100644
--- a/rmap/RMAP.cpp
+++ b/rmap/RMAP.cpp
@@ -1,8 +1,10 @@
+#include "RMAP.h"
+#include "rmapStructs.h"
+#include "RMAPChannelIF.h"
+
 #include "../devicehandlers/DeviceCommunicationIF.h"
-#include "../rmap/rmapStructs.h"
-#include "../rmap/RMAP.h"
-#include "../rmap/RMAPChannelIF.h"
-#include <stddef.h>
+
+#include <cstddef>
 
 ReturnValue_t RMAP::reset(RMAPCookie* cookie) {
 	return cookie->getChannel()->reset();
diff --git a/rmap/RMAP.h b/rmap/RMAP.h
index e083d407..83e29fed 100644
--- a/rmap/RMAP.h
+++ b/rmap/RMAP.h
@@ -1,5 +1,5 @@
-#ifndef RMAPpp_H_
-#define RMAPpp_H_
+#ifndef FSFW_RMAP_RMAP_H_
+#define FSFW_RMAP_RMAP_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../rmap/RMAPCookie.h"
diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h
index d851885b..0aa809c5 100644
--- a/rmap/RMAPChannelIF.h
+++ b/rmap/RMAPChannelIF.h
@@ -1,7 +1,7 @@
-#ifndef RMAPCHANNELIF_H_
-#define RMAPCHANNELIF_H_
+#ifndef FSFW_RMAP_RMAPCHANNELIF_H_
+#define FSFW_RMAP_RMAPCHANNELIF_H_
 
-#include "../rmap/RMAPCookie.h"
+#include "RMAPCookie.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstddef>
 
@@ -113,4 +113,4 @@ public:
 
 };
 
-#endif /* RMAPCHANNELIF_H_ */
+#endif /* FSFW_RMAP_RMAPCHANNELIF_H_ */
diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp
index c92ee433..f8fe2d3e 100644
--- a/rmap/RMAPCookie.cpp
+++ b/rmap/RMAPCookie.cpp
@@ -1,6 +1,6 @@
-#include "../rmap/RMAPChannelIF.h"
-#include "../rmap/RMAPCookie.h"
-#include <stddef.h>
+#include "RMAPChannelIF.h"
+#include "RMAPCookie.h"
+#include <cstddef>
 
 
 RMAPCookie::RMAPCookie() {
@@ -31,7 +31,8 @@ RMAPCookie::RMAPCookie() {
 
 
 RMAPCookie::RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-		RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen) {
+		RMAPChannelIF *set_channel, uint8_t set_command_mask,
+		size_t maxReplyLen) {
 	this->header.dest_address = 0;
 	this->header.protocol = 0x01;
 	this->header.instruction = 0;
diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h
index 8832f857..38542646 100644
--- a/rmap/RMAPCookie.h
+++ b/rmap/RMAPCookie.h
@@ -1,8 +1,8 @@
-#ifndef RMAPCOOKIE_H_
-#define RMAPCOOKIE_H_
+#ifndef FSFW_RMAP_RMAPCOOKIE_H_
+#define FSFW_RMAP_RMAPCOOKIE_H_
 
+#include "rmapStructs.h"
 #include "../devicehandlers/CookieIF.h"
-#include "../rmap/rmapStructs.h"
 #include <cstddef>
 
 class RMAPChannelIF;
@@ -13,7 +13,8 @@ public:
 	RMAPCookie();
 
 	RMAPCookie(uint32_t set_address, uint8_t set_extended_address,
-			RMAPChannelIF *set_channel, uint8_t set_command_mask, uint32_t maxReplyLen = 0);
+			RMAPChannelIF *set_channel, uint8_t set_command_mask,
+			size_t maxReplyLen = 0);
 	virtual ~RMAPCookie();
 
 
@@ -56,4 +57,4 @@ protected:
 	uint8_t dataCRC;
 };
 
-#endif /* RMAPCOOKIE_H_ */
+#endif /* FSFW_RMAP_RMAPCOOKIE_H_ */
diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp
index 62a3f3ef..d81baabd 100644
--- a/rmap/RmapDeviceCommunicationIF.cpp
+++ b/rmap/RmapDeviceCommunicationIF.cpp
@@ -1,5 +1,5 @@
-#include "../rmap/RmapDeviceCommunicationIF.h"
-#include "../rmap/RMAP.h"
+#include "RmapDeviceCommunicationIF.h"
+#include "RMAP.h"
 
 //TODO Cast here are all potential bugs
 RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() {
diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h
index 52efa3de..1333966a 100644
--- a/rmap/RmapDeviceCommunicationIF.h
+++ b/rmap/RmapDeviceCommunicationIF.h
@@ -1,5 +1,5 @@
-#ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
-#define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#ifndef FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
+#define FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_
 
 #include "../devicehandlers/DeviceCommunicationIF.h"
 
@@ -86,4 +86,4 @@ public:
 	uint32_t getParameter(CookieIF* cookie);
 };
 
-#endif /* MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
+#endif /* FSFW_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ */
diff --git a/rmap/rmapStructs.h b/rmap/rmapStructs.h
index bf0fb260..11d8bb85 100644
--- a/rmap/rmapStructs.h
+++ b/rmap/rmapStructs.h
@@ -1,7 +1,7 @@
-#ifndef RMAPSTRUCTS_H_
-#define RMAPSTRUCTS_H_
+#ifndef FSFW_RMAP_RMAPSTRUCTS_H_
+#define FSFW_RMAP_RMAPSTRUCTS_H_
 
-#include <stdint.h>
+#include <cstdint>
 
 //SHOULDDO: having the defines within a namespace would be nice. Problem are the defines referencing the previous define, eg RMAP_COMMAND_WRITE
 
@@ -95,4 +95,4 @@ struct rmap_write_reply_header {
 
 }
 
-#endif /* RMAPSTRUCTS_H_ */
+#endif /* FSFW_RMAP_RMAPSTRUCTS_H_ */

From f161a94113c6c95ce7014a2cf9597817d8f4c0b1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 10:44:48 +0100
Subject: [PATCH 1041/1292] taken over upstream fixes

---
 thermal/ThermalComponentCore.cpp | 13 +++++++------
 thermal/ThermalModule.cpp        |  6 +++---
 thermal/ThermalModuleIF.h        |  3 +--
 thermal/tcsDefinitions.h         |  6 +++---
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/thermal/ThermalComponentCore.cpp b/thermal/ThermalComponentCore.cpp
index 7b594d0c..ba875053 100644
--- a/thermal/ThermalComponentCore.cpp
+++ b/thermal/ThermalComponentCore.cpp
@@ -1,4 +1,5 @@
 #include "ThermalComponentCore.h"
+#include "tcsDefinitions.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
         uint8_t domainId, gp_id_t temperaturePoolId,
@@ -60,7 +61,7 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
 	//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
 	temperature = getTemperature();
 	updateMinMaxTemp();
-	if (temperature != INVALID_TEMPERATURE) {
+	if (temperature != thermal::INVALID_TEMPERATURE) {
 		temperature.setValid(PoolVariableIF::VALID);
 		State state = getState(temperature.value, getParameters(),
 				targetState.value);
@@ -119,7 +120,7 @@ ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
 }
 
 void ThermalComponentCore::setOutputInvalid() {
-	temperature = INVALID_TEMPERATURE;
+	temperature = thermal::INVALID_TEMPERATURE;
 	temperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	heaterRequest = HEATER_DONT_CARE;
@@ -144,13 +145,13 @@ float ThermalComponentCore::getTemperature() {
 
 	if (thermalModule != nullptr) {
 		float temperature = thermalModule->getTemperature();
-		if (temperature != ThermalModuleIF::INVALID_TEMPERATURE) {
+		if (temperature != thermal::INVALID_TEMPERATURE) {
 			return temperature;
 		} else {
-			return INVALID_TEMPERATURE;
+			return thermal::INVALID_TEMPERATURE;
 		}
 	} else {
-		return INVALID_TEMPERATURE;
+		return thermal::INVALID_TEMPERATURE;
 	}
 }
 
@@ -226,7 +227,7 @@ ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
 }
 
 void ThermalComponentCore::updateMinMaxTemp() {
-	if (temperature == INVALID_TEMPERATURE) {
+	if (temperature == thermal::INVALID_TEMPERATURE) {
 		return;
 	}
 	if (temperature < minTemp) {
diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp
index 457a6743..de347542 100644
--- a/thermal/ThermalModule.cpp
+++ b/thermal/ThermalModule.cpp
@@ -107,7 +107,7 @@ void ThermalModule::calculateTemperature() {
 		moduleTemperature = moduleTemperature.value / numberOfValidSensors;
 		moduleTemperature.setValid(PoolVariableIF::VALID);
 	} else {
-		moduleTemperature = INVALID_TEMPERATURE;
+		moduleTemperature.value = thermal::INVALID_TEMPERATURE;
 		moduleTemperature.setValid(PoolVariableIF::INVALID);
 	}
 }
@@ -219,7 +219,7 @@ void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
 bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
 		Strategy strategy) {
 	currentState.setValid(PoolVariableIF::VALID);
-	if (moduleTemperature == INVALID_TEMPERATURE) {
+	if (moduleTemperature == thermal::INVALID_TEMPERATURE) {
 		currentState = UNKNOWN;
 		return false;
 	}
@@ -282,7 +282,7 @@ void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
 }
 
 void ThermalModule::setOutputInvalid() {
-	moduleTemperature = INVALID_TEMPERATURE;
+	moduleTemperature = thermal::INVALID_TEMPERATURE;
 	moduleTemperature.setValid(PoolVariableIF::INVALID);
 	currentState.setValid(PoolVariableIF::INVALID);
 	std::list<ComponentData>::iterator iter = components.begin();
diff --git a/thermal/ThermalModuleIF.h b/thermal/ThermalModuleIF.h
index 2d11a6f2..89cf93d6 100644
--- a/thermal/ThermalModuleIF.h
+++ b/thermal/ThermalModuleIF.h
@@ -2,6 +2,7 @@
 #define THERMALMODULEIF_H_
 
 #include "ThermalComponentIF.h"
+
 class AbstractTemperatureSensor;
 
 class ThermalModuleIF{
@@ -18,8 +19,6 @@ public:
 		NON_OPERATIONAL = 0, OPERATIONAL = 1, UNKNOWN = 2
 	};
 
-	static constexpr float INVALID_TEMPERATURE = 999;
-
 	virtual ~ThermalModuleIF() {
 
 	}
diff --git a/thermal/tcsDefinitions.h b/thermal/tcsDefinitions.h
index 37e5b849..3225be5c 100644
--- a/thermal/tcsDefinitions.h
+++ b/thermal/tcsDefinitions.h
@@ -1,8 +1,8 @@
 #ifndef TCSDEFINITIONS_H_
 #define TCSDEFINITIONS_H_
 
-
-static const float INVALID_TEMPERATURE = 999;
-
+namespace thermal {
+static constexpr float INVALID_TEMPERATURE = 999;
+}
 
 #endif /* TCSDEFINITIONS_H_ */

From 0ccd266f51f8238f3489b192ec36496c90fc24fe Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 10:49:00 +0100
Subject: [PATCH 1042/1292] internal unittests fixed

---
 unittest/internal/osal/IntTestMq.cpp                 | 4 ++--
 unittest/internal/osal/IntTestMutex.cpp              | 2 +-
 unittest/internal/osal/IntTestSemaphore.cpp          | 6 +++---
 unittest/internal/serialize/IntTestSerialization.cpp | 7 ++++---
 unittest/internal/serialize/IntTestSerialization.h   | 2 +-
 5 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 8d95f51e..9917285f 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,8 +1,8 @@
 #include "IntTestMq.h"
 #include "../UnittDefinitions.h"
 
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/QueueFactory.h"
+#include "../../../ipc/MessageQueueIF.h"
+#include "../../../ipc/QueueFactory.h"
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 01581347..d2f8b962 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,6 +1,6 @@
 #include "IntTestMutex.h"
 
-#include "../../ipc/MutexFactory.h"
+#include "../../../ipc/MutexFactory.h"
 #include "../UnittDefinitions.h"
 
 #if defined(hosted)
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index f260b6a5..6d2719d5 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,9 +1,9 @@
 #include "IntTestSemaphore.h"
 #include "../UnittDefinitions.h"
 
-#include "../../tasks/SemaphoreFactory.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../timemanager/Stopwatch.h"
+#include "../../../tasks/SemaphoreFactory.h"
+#include "../../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../../timemanager/Stopwatch.h"
 
 
 void testsemaph::testBinSemaph() {
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 1e33ff33..793661c5 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,8 +1,9 @@
 #include "IntTestSerialization.h"
 #include "../UnittDefinitions.h"
-#include "../../serialize/SerializeElement.h"
-#include "../../serialize/SerialBufferAdapter.h"
-#include "../../serialize/SerializeIF.h"
+
+#include "../../../serialize/SerializeElement.h"
+#include "../../../serialize/SerialBufferAdapter.h"
+#include "../../../serialize/SerializeIF.h"
 
 #include <array>
 
diff --git a/unittest/internal/serialize/IntTestSerialization.h b/unittest/internal/serialize/IntTestSerialization.h
index e8dbd35a..8706e057 100644
--- a/unittest/internal/serialize/IntTestSerialization.h
+++ b/unittest/internal/serialize/IntTestSerialization.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 #define FSFW_UNITTEST_INTERNAL_INTTESTSERIALIZATION_H_
 
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 #include <array>
 
 namespace testserialize {

From 7ace117c42832ad65d657b2d203f5371fb3ad2a7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:06:09 +0100
Subject: [PATCH 1043/1292] added cmakelistst

---
 globalfunctions/CMakeLists.txt      | 12 ++++++++++++
 globalfunctions/math/CMakeLists.txt |  4 ++++
 2 files changed, 16 insertions(+)
 create mode 100644 globalfunctions/CMakeLists.txt
 create mode 100644 globalfunctions/math/CMakeLists.txt

diff --git a/globalfunctions/CMakeLists.txt b/globalfunctions/CMakeLists.txt
new file mode 100644
index 00000000..2b3dcf8e
--- /dev/null
+++ b/globalfunctions/CMakeLists.txt
@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		arrayprinter.cpp
+		AsciiConverter.cpp
+		CRC.cpp
+		DleEncoder.cpp
+		PeriodicOperationDivider.cpp
+		timevalOperations.cpp
+		Type.cpp
+)
+
+add_subdirectory(math)
\ No newline at end of file
diff --git a/globalfunctions/math/CMakeLists.txt b/globalfunctions/math/CMakeLists.txt
new file mode 100644
index 00000000..a9c4ded7
--- /dev/null
+++ b/globalfunctions/math/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		QuaternionOperations.cpp
+)

From 073cd4f5e1ebbf1bcc09a3c71ae8da16b6e4ddad Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:09:53 +0100
Subject: [PATCH 1044/1292] small tweaks

---
 globalfunctions/Type.cpp | 2 +-
 globalfunctions/Type.h   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp
index 97f38473..fa6d2f28 100644
--- a/globalfunctions/Type.cpp
+++ b/globalfunctions/Type.cpp
@@ -1,4 +1,4 @@
-#include "../globalfunctions/Type.h"
+#include "Type.h"
 #include "../serialize/SerializeAdapter.h"
 
 Type::Type() :
diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d03c467..d28f56ac 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -1,5 +1,5 @@
-#ifndef TYPE_H_
-#define TYPE_H_
+#ifndef FSFW_GLOBALFUNCTIONS_TYPE_H_
+#define FSFW_GLOBALFUNCTIONS_TYPE_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
@@ -95,4 +95,4 @@ struct PodTypeConversion<double> {
 	static const Type::ActualType_t type = Type::DOUBLE;
 };
 
-#endif /* TYPE_H_ */
+#endif /* FSFW_GLOBALFUNCTIONS_TYPE_H_ */

From 620c9c6ae15008631d506aa57181a11ff5130e52 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:19:05 +0100
Subject: [PATCH 1045/1292] taken over freeRTOS changes

---
 osal/FreeRTOS/BinarySemaphore.cpp         |  4 ++--
 osal/FreeRTOS/BinarySemaphore.h           |  6 +++---
 osal/FreeRTOS/Clock.cpp                   |  3 ++-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 +++--
 osal/FreeRTOS/CountingSemaphUsingTask.h   | 10 ++++------
 osal/FreeRTOS/CountingSemaphore.cpp       |  5 +++--
 osal/FreeRTOS/CountingSemaphore.h         |  3 ++-
 osal/FreeRTOS/MessageQueue.h              |  3 ++-
 osal/FreeRTOS/Mutex.cpp                   |  2 +-
 osal/FreeRTOS/MutexFactory.cpp            |  4 +++-
 osal/FreeRTOS/TaskManagement.cpp          |  2 +-
 osal/FreeRTOS/TaskManagement.h            |  5 ++---
 osal/FreeRTOS/Timekeeper.cpp              |  4 ++--
 13 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 8cc3c495..6fee5c35 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -1,5 +1,5 @@
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "BinarySemaphore.h"
+#include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 BinarySemaphore::BinarySemaphore() {
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index c6cedc53..8969d503 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
-#define FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#ifndef FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
+#define FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/SemaphoreIF.h"
@@ -104,4 +104,4 @@ protected:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
+#endif /* FSFW_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index f3d8516a..d3f4e68e 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -1,6 +1,7 @@
+#include "Timekeeper.h"
+
 #include "../../timemanager/Clock.h"
 #include "../../globalfunctions/timevalOperations.h"
-#include "../../osal/FreeRTOS/Timekeeper.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index a47341bc..17cdf7ce 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -1,5 +1,6 @@
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "CountingSemaphUsingTask.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 49ff3ee5..f258197b 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -1,13 +1,11 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
-#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#ifndef FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
+#define FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_
 
-#include "../../osal/FreeRTOS/CountingSemaphUsingTask.h"
+#include "CountingSemaphUsingTask.h"
 #include "../../tasks/SemaphoreIF.h"
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
 
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
@@ -102,4 +100,4 @@ private:
 	const uint8_t maxCount;
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
+#endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index d1310a6a..a202e480 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -1,6 +1,7 @@
-#include "../../osal/FreeRTOS/CountingSemaphore.h"
+#include "CountingSemaphore.h"
+#include "TaskManagement.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/semphr.h>
 
diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h
index ae2f62ae..6af1d6d2 100644
--- a/osal/FreeRTOS/CountingSemaphore.h
+++ b/osal/FreeRTOS/CountingSemaphore.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
 #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
-#include "../../osal/FreeRTOS/BinarySemaphore.h"
+
+#include "BinarySemaphore.h"
 
 /**
  * @brief 	Counting semaphores, which can be acquire more than once.
diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h
index b99bf7c8..8fa86283 100644
--- a/osal/FreeRTOS/MessageQueue.h
+++ b/osal/FreeRTOS/MessageQueue.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
+#include "TaskManagement.h"
+
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
 #include "../../ipc/MessageQueueMessageIF.h"
-#include "../../osal/FreeRTOS/TaskManagement.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 82f23ff9..9d9638b5 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/Mutex.h"
+#include "Mutex.h"
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp
index 1f34cc18..d9569e35 100644
--- a/osal/FreeRTOS/MutexFactory.cpp
+++ b/osal/FreeRTOS/MutexFactory.cpp
@@ -1,5 +1,7 @@
+#include "Mutex.h"
+
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/FreeRTOS/Mutex.h"
+
 
 //TODO: Different variant than the lazy loading in QueueFactory.
 //What's better and why? -> one is on heap the other on bss/data
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index b77f12a9..18572045 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/FreeRTOS/TaskManagement.h"
+#include "TaskManagement.h"
 
 void TaskManagement::vRequestContextSwitchFromTask() {
 	vTaskDelay(0);
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index 4b7fe3eb..c6c46f21 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -3,17 +3,16 @@
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
-extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-}
+
 #include <cstdint>
 
 /**
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern void vRequestContextSwitchFromISR();
+extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp
index 836f0b21..d986d832 100644
--- a/osal/FreeRTOS/Timekeeper.cpp
+++ b/osal/FreeRTOS/Timekeeper.cpp
@@ -1,6 +1,6 @@
-#include "../../osal/FreeRTOS/Timekeeper.h"
+#include "Timekeeper.h"
 
-#include "FreeRTOSConfig.h"
+#include <FreeRTOSConfig.h>
 
 Timekeeper * Timekeeper::myinstance = nullptr;
 

From 5c6916a07848a8aed3c7ec2fbc8fded1f37f2a08 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:23:23 +0100
Subject: [PATCH 1046/1292] small tweaks

---
 ipc/QueueFactory.h             | 1 +
 osal/FreeRTOS/QueueFactory.cpp | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h
index 9853d256..6fc0643e 100644
--- a/ipc/QueueFactory.h
+++ b/ipc/QueueFactory.h
@@ -3,6 +3,7 @@
 
 #include "MessageQueueIF.h"
 #include "MessageQueueMessage.h"
+
 #include <cstdint>
 
 /**
diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp
index 5b3c73dc..ed29e10c 100644
--- a/osal/FreeRTOS/QueueFactory.cpp
+++ b/osal/FreeRTOS/QueueFactory.cpp
@@ -1,8 +1,8 @@
+#include "MessageQueue.h"
+
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/QueueFactory.h"
 
-#include "../../osal/FreeRTOS/MessageQueue.h"
-
 
 QueueFactory* QueueFactory::factoryInstance = nullptr;
 

From 89de4cc321e32ce94d458d72d76c14999cfd6437 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:40:26 +0100
Subject: [PATCH 1047/1292] changes and tweaks taken over

---
 subsystem/CMakeLists.txt              |  7 +++++++
 subsystem/Subsystem.cpp               | 12 ++++++------
 subsystem/Subsystem.h                 |  4 +++-
 subsystem/modes/CMakeLists.txt        |  5 +++++
 subsystem/modes/ModeSequenceMessage.h |  1 +
 subsystem/modes/ModeStore.cpp         |  4 ++--
 subsystem/modes/ModeStore.h           |  4 +++-
 subsystem/modes/ModeStoreIF.h         |  4 +++-
 8 files changed, 30 insertions(+), 11 deletions(-)
 create mode 100644 subsystem/CMakeLists.txt
 create mode 100644 subsystem/modes/CMakeLists.txt

diff --git a/subsystem/CMakeLists.txt b/subsystem/CMakeLists.txt
new file mode 100644
index 00000000..5c98ee70
--- /dev/null
+++ b/subsystem/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Subsystem.cpp
+		SubsystemBase.cpp
+)
+
+add_subdirectory(modes)
\ No newline at end of file
diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp
index 9712d7d4..4de6906c 100644
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@@ -367,7 +367,7 @@ ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(sequence,
 				&(modeSequences.find(id)->entries.firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -410,7 +410,7 @@ ReturnValue_t Subsystem::addTable(ArrayList<ModeListEntry> *table, Mode_t id,
 	}
 
 	if (inStore) {
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 		result = modeStore->storeArray(table,
 				&(modeTables.find(id)->firstLinkedElement));
 		if (result != RETURN_OK) {
@@ -440,7 +440,7 @@ ReturnValue_t Subsystem::deleteSequence(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(sequenceInfo->entries.firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -463,7 +463,7 @@ ReturnValue_t Subsystem::deleteTable(Mode_t id) {
 		return ACCESS_DENIED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore->deleteList(pointer->firstLinkedElement);
 #endif
 	modeSequences.erase(id);
@@ -482,10 +482,10 @@ ReturnValue_t Subsystem::initialize() {
 		return RETURN_FAILED;
 	}
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
 
-	if (modeStore == NULL) {
+	if (modeStore == nullptr) {
 		return RETURN_FAILED;
 	}
 #endif
diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index 09d7850a..c3a72d54 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -10,6 +10,8 @@
 #include "../container/SinglyLinkedList.h"
 #include "../serialize/SerialArrayListAdapter.h"
 
+#include <FSFWConfig.h>
+
 /**
  * @brief   TODO: documentation missing
  * @details
@@ -116,7 +118,7 @@ protected:
 
 	StorageManagerIF *IPCStore = nullptr;
 
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 	ModeStoreIF *modeStore = nullptr;
 #endif
 
diff --git a/subsystem/modes/CMakeLists.txt b/subsystem/modes/CMakeLists.txt
new file mode 100644
index 00000000..6ac6a293
--- /dev/null
+++ b/subsystem/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeSequenceMessage.cpp
+		ModeStore.cpp
+)
diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h
index 9be4586e..7852c984 100644
--- a/subsystem/modes/ModeSequenceMessage.h
+++ b/subsystem/modes/ModeSequenceMessage.h
@@ -2,6 +2,7 @@
 #define FSFW_SUBSYSTEM_MODES_MODESEQUENCEMESSAGE_H_
 
 #include "ModeDefinitions.h"
+
 #include "../../ipc/CommandMessage.h"
 #include "../../storagemanager/StorageManagerIF.h"
 
diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp
index 260e5ab2..e216a167 100644
--- a/subsystem/modes/ModeStore.cpp
+++ b/subsystem/modes/ModeStore.cpp
@@ -1,8 +1,8 @@
-#include "../../subsystem/modes/ModeStore.h"
+#include "ModeStore.h"
 
 // todo: I think some parts are deprecated. If this is used,  the define
 // USE_MODESTORE could be part of the new FSFWConfig.h file.
-#ifdef USE_MODESTORE
+#if FSFW_USE_MODESTORE == 1
 
 ModeStore::ModeStore(object_id_t objectId, uint32_t slots) :
 		SystemObject(objectId), store(slots), emptySlot(store.front()) {
diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index 3d031cc8..c05086c7 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,7 +1,9 @@
 #ifndef MODESTORE_H_
 #define MODESTORE_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 30cca1f7..9e76deef 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -1,7 +1,9 @@
 #ifndef MODESTOREIF_H_
 #define MODESTOREIF_H_
 
-#ifdef USE_MODESTORE
+#include <FSFWConfig.h>
+
+#if FSFW_USE_MODESTORE == 1
 
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"

From d3239b90644126af99b12dd029d2c19690d2e775 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:41:40 +0100
Subject: [PATCH 1048/1292] tiny format stuff

---
 subsystem/modes/ModeStoreIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h
index 9e76deef..9682501d 100644
--- a/subsystem/modes/ModeStoreIF.h
+++ b/subsystem/modes/ModeStoreIF.h
@@ -5,10 +5,11 @@
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeDefinitions.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../subsystem/modes/ModeDefinitions.h"
 
 class ModeStoreIF {
 public:

From 3dd86039bb01448c57425f1b9d6f9c4135de3622 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:43:32 +0100
Subject: [PATCH 1049/1292] changes taken over

---
 subsystem/modes/ModeStore.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h
index c05086c7..a5cb4059 100644
--- a/subsystem/modes/ModeStore.h
+++ b/subsystem/modes/ModeStore.h
@@ -1,14 +1,15 @@
-#ifndef MODESTORE_H_
-#define MODESTORE_H_
+#ifndef FSFW_SUBSYSTEM_MODES_MODESTORE_H_
+#define FSFW_SUBSYSTEM_MODES_MODESTORE_H_
 
 #include <FSFWConfig.h>
 
 #if FSFW_USE_MODESTORE == 1
 
+#include "ModeStoreIF.h"
+
 #include "../../container/ArrayList.h"
 #include "../../container/SinglyLinkedList.h"
 #include "../../objectmanager/SystemObject.h"
-#include "../../subsystem/modes/ModeStoreIF.h"
 
 class ModeStore: public ModeStoreIF, public SystemObject {
 public:
@@ -43,5 +44,5 @@ private:
 
 #endif
 
-#endif /* MODESTORE_H_ */
+#endif /* FSFW_SUBSYSTEM_MODES_MODESTORE_H_ */
 

From a547fafa33576ce33423536f28d1fa1333a6423a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 11:49:01 +0100
Subject: [PATCH 1050/1292] minor tweaks

---
 tasks/CMakeLists.txt        |  5 +++++
 tasks/FixedSlotSequence.h   |  9 +++++++++
 tasks/FixedTimeslotTaskIF.h | 11 ++++++-----
 tasks/TaskFactory.h         | 39 +++++++++++++++++++------------------
 4 files changed, 40 insertions(+), 24 deletions(-)
 create mode 100644 tasks/CMakeLists.txt

diff --git a/tasks/CMakeLists.txt b/tasks/CMakeLists.txt
new file mode 100644
index 00000000..1964bb4e
--- /dev/null
+++ b/tasks/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		FixedSequenceSlot.cpp
+		FixedSlotSequence.cpp
+)
\ No newline at end of file
diff --git a/tasks/FixedSlotSequence.h b/tasks/FixedSlotSequence.h
index 19a05f21..077dd10b 100644
--- a/tasks/FixedSlotSequence.h
+++ b/tasks/FixedSlotSequence.h
@@ -139,6 +139,15 @@ public:
 	 */
 	ReturnValue_t checkSequence() const;
 
+	/**
+	 * @brief   A custom check can be injected for the respective slot list.
+	 * @details
+	 * This can be used by the developer to check the validity of a certain
+	 * sequence. The function will be run in the #checkSequence function.
+	 * The general check will be continued for now if the custom check function
+	 * fails but a diagnostic debug output will be given.
+	 * @param customCheckFunction
+	 */
 	void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
 
 	/**
diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index 6344efa5..a138db4e 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -1,12 +1,12 @@
 #ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 
+#include "PeriodicTaskIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tasks/PeriodicTaskIF.h"
 
 /**
  * @brief Following the same principle as the base class IF.
- *        This is the interface for a Fixed timeslot task
+ * This is the interface for a Fixed timeslot task
  */
 class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
@@ -20,9 +20,8 @@ public:
 	 * @param executionStep
 	 * @return
 	 */
-	virtual ReturnValue_t addSlot(object_id_t componentId,
-			uint32_t slotTimeMs, int8_t executionStep) = 0;
-
+	virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+	        int8_t executionStep) = 0;
 	/**
 	 * Check whether the sequence is valid and perform all other required
 	 * initialization steps which are needed after task creation
@@ -30,4 +29,6 @@ public:
 	virtual ReturnValue_t checkSequence() const = 0;
 };
 
+
+
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */
diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h
index fd2f4460..85cdda90 100644
--- a/tasks/TaskFactory.h
+++ b/tasks/TaskFactory.h
@@ -1,9 +1,10 @@
-#ifndef FRAMEWORK_TASKS_TASKFACTORY_H_
-#define FRAMEWORK_TASKS_TASKFACTORY_H_
+#ifndef FSFW_TASKS_TASKFACTORY_H_
+#define FSFW_TASKS_TASKFACTORY_H_
+
+#include "FixedTimeslotTaskIF.h"
+#include "Typedef.h"
 
 #include <cstdlib>
-#include "../tasks/FixedTimeslotTaskIF.h"
-#include "../tasks/Typedef.h"
 
 /**
  * Singleton Class that produces Tasks.
@@ -19,14 +20,13 @@ public:
 	static TaskFactory* instance();
 
 	/**
-	 * Generic interface to create a periodic task
+	 * Creates a new periodic task and returns the interface pointer.
 	 * @param name_ Name of the task
 	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
+	 * @param stackSize_ Stack Size of the task
+	 * @param period_ Period of the task
+	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
+	 * @return PeriodicTaskIF* Pointer to the newly created Task
 	 */
 	PeriodicTaskIF* createPeriodicTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -34,14 +34,13 @@ public:
 			TaskDeadlineMissedFunction deadLineMissedFunction_);
 
 	/**
-	 * Generic interface to create a fixed timeslot task
+	 *
 	 * @param name_ Name of the task
 	 * @param taskPriority_ Priority of the task
-	 * @param stackSize_ Stack size if the task
-	 * @param periodInSeconds_ Period in seconds
-	 * @param deadLineMissedFunction_ This function is called if a deadline was
-	 * missed
-	 * @return Pointer to the created periodic task class
+	 * @param stackSize_ Stack Size of the task
+	 * @param period_ Period of the task
+	 * @param deadLineMissedFunction_ Function to be called if a deadline was missed
+	 * @return FixedTimeslotTaskIF* Pointer to the newly created Task
 	 */
 	FixedTimeslotTaskIF* createFixedTimeslotTask(TaskName name_,
 			TaskPriority taskPriority_, TaskStackSize stackSize_,
@@ -51,10 +50,10 @@ public:
 	/**
 	 * Function to be called to delete a task
 	 * @param task The pointer to the task that shall be deleted,
-	 * 				NULL specifies current Task
+	 * nullptr specifies current Task
 	 * @return Success of deletion
 	 */
-	static ReturnValue_t deleteTask(PeriodicTaskIF* task = NULL);
+	static ReturnValue_t deleteTask(PeriodicTaskIF* task = nullptr);
 
 	/**
 	 * Function to be called to delay current task
@@ -62,12 +61,14 @@ public:
 	 * @return Success of deletion
 	 */
 	static ReturnValue_t delayTask(uint32_t delayMs);
+
 private:
 	/**
 	 * External instantiation is not allowed.
 	 */
 	TaskFactory();
 	static TaskFactory* factoryInstance;
+
 };
 
-#endif /* FRAMEWORK_TASKS_TASKFACTORY_H_ */
+#endif /* FSFW_TASKS_TASKFACTORY_H_ */

From a0e7584e841f3d9a2469ef091fae79fc55560c7c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:19:23 +0100
Subject: [PATCH 1051/1292] tiny tweak

---
 datalinklayer/DataLinkLayer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h
index 30e548e8..17a57d61 100644
--- a/datalinklayer/DataLinkLayer.h
+++ b/datalinklayer/DataLinkLayer.h
@@ -23,7 +23,7 @@ public:
 	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 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.

From 2100ae34f2c69d9a982e1d52d2f8068558daff9b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:49:17 +0100
Subject: [PATCH 1052/1292] event folder taken over

---
 events/CMakeLists.txt               |  8 ++++++++
 events/EventManager.cpp             |  3 ++-
 events/EventManager.h               | 12 +++++++-----
 events/eventmatching/CMakeLists.txt |  7 +++++++
 events/fwSubsystemIdRanges.h        |  6 +++---
 5 files changed, 27 insertions(+), 9 deletions(-)
 create mode 100644 events/CMakeLists.txt
 create mode 100644 events/eventmatching/CMakeLists.txt

diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
new file mode 100644
index 00000000..9e63deb8
--- /dev/null
+++ b/events/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Event.cpp
+		EventManager.cpp
+		EventMessage.cpp
+)
+
+add_subdirectory(eventmatching)
\ No newline at end of file
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 182fb72b..33276141 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -1,4 +1,6 @@
 #include "EventManager.h"
+#include "EventMessage.h"
+
 #include <FSFWConfig.h>
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../ipc/QueueFactory.h"
@@ -9,7 +11,6 @@
 // objects registering for certain events.
 // Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
-// This should be configurable..
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
         {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
         		sizeof(EventMatchTree::Node)},
diff --git a/events/EventManager.h b/events/EventManager.h
index fe35d9d3..6678fc07 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -1,14 +1,16 @@
-#ifndef EVENTMANAGER_H_
-#define EVENTMANAGER_H_
+#ifndef FSFW_EVENT_EVENTMANAGER_H_
+#define FSFW_EVENT_EVENTMANAGER_H_
 
-#include "eventmatching/EventMatchTree.h"
 #include "EventManagerIF.h"
+#include "eventmatching/EventMatchTree.h"
+
+#include <FSFWConfig.h>
+
 #include "../objectmanager/SystemObject.h"
 #include "../storagemanager/LocalPool.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
-#include <FSFWConfig.h>
 
 #include <map>
 
@@ -68,4 +70,4 @@ protected:
 	void unlockMutex();
 };
 
-#endif /* EVENTMANAGER_H_ */
+#endif /* FSFW_EVENT_EVENTMANAGER_H_ */
diff --git a/events/eventmatching/CMakeLists.txt b/events/eventmatching/CMakeLists.txt
new file mode 100644
index 00000000..81ff9ed8
--- /dev/null
+++ b/events/eventmatching/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventIdRangeMatcher.cpp
+		EventMatchTree.cpp
+		ReporterRangeMatcher.cpp
+		SeverityRangeMatcher.cpp
+)
\ No newline at end of file
diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h
index 8dc4def7..1b0b238e 100644
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
-#define FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#ifndef FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#define FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
 
 namespace SUBSYSTEM_ID {
 enum {
@@ -27,4 +27,4 @@ enum {
 
 
 
-#endif /* FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_ */
+#endif /* FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_ */

From b14c1c43ccbd97fe774a2a2b9f812487b14afcd3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:50:56 +0100
Subject: [PATCH 1053/1292] small fix

---
 events/EventManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 33276141..40c82139 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -119,7 +119,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
 	switch (message->getSeverity()) {
-	case SEVERITY::INFO:
+	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
 		sif::info << "EVENT: ";

From 14a0573f3d99025347a40bea9df2633b188d80ea Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 20:58:20 +0100
Subject: [PATCH 1054/1292] one define now

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 --
 events/EventManager.cpp            | 2 +-
 events/EventManager.h              | 4 ++--
 unittest/testcfg/FSFWConfig.h      | 4 +---
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 1386bf66..7e19235c 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -27,13 +27,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 40c82139..6cc97eb6 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -114,7 +114,7 @@ ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
 	return result;
 }
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 
 void EventManager::printEvent(EventMessage* message) {
 	const char *string = 0;
diff --git a/events/EventManager.h b/events/EventManager.h
index 6678fc07..c6bd07be 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -14,7 +14,7 @@
 
 #include <map>
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 // forward declaration, should be implemented by mission
 extern const char* translateObject(object_id_t object);
 extern const char* translateEvents(Event event);
@@ -61,7 +61,7 @@ protected:
 
 	void notifyListeners(EventMessage *message);
 
-#if FSFW_DEBUG_OUTPUT == 1
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
 	void printEvent(EventMessage *message);
 #endif
 
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 4fb224c1..59934560 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -29,13 +29,11 @@
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO				1
+#define FSFW_DEBUG_INFO             1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From 050770c184a8a965a856df53aea37ad75f0962ff Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:07:58 +0100
Subject: [PATCH 1055/1292] catch factory fixes

---
 unittest/testcfg/CatchFactory.cpp | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
index c74a8126..3177212f 100644
--- a/unittest/testcfg/CatchFactory.cpp
+++ b/unittest/testcfg/CatchFactory.cpp
@@ -24,31 +24,27 @@ void Factory::produce(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
-	//new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TC_STORE, element_sizes,
-				n_elements);
+		PoolManager::LocalPoolConfig poolCfg = {
+		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+		};
+		new PoolManager(objects::TC_STORE, poolCfg);
 	}
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 5;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {16, 32, 64, 128, 1024};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::TM_STORE, element_sizes,
-				n_elements);
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::TM_STORE, poolCfg);
 	}
 
 	{
-		static constexpr uint8_t NUMBER_OF_POOLS = 6;
-		const uint16_t element_sizes[NUMBER_OF_POOLS] = {32, 64, 512,
-				1024, 2048, 4096};
-		const uint16_t n_elements[NUMBER_OF_POOLS] = {200, 100, 50, 25, 15, 5};
-		new PoolManager<NUMBER_OF_POOLS>(objects::IPC_STORE, element_sizes,
-				n_elements);
+        PoolManager::LocalPoolConfig poolCfg = {
+                {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
+        };
+		new PoolManager(objects::IPC_STORE, poolCfg);
 	}
 
 }

From c1a156dde3956be55c96469c98e204d27bb3a0c9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:08:35 +0100
Subject: [PATCH 1056/1292] catch factory in objects folder again

---
 .../testcfg/{ => objects}/CatchFactory.cpp    |  0
 unittest/testcfg/{ => objects}/CatchFactory.h |  0
 unittest/testcfg/objects/Factory.cpp          | 34 -------------------
 unittest/testcfg/objects/Factory.h            | 16 ---------
 4 files changed, 50 deletions(-)
 rename unittest/testcfg/{ => objects}/CatchFactory.cpp (100%)
 rename unittest/testcfg/{ => objects}/CatchFactory.h (100%)
 delete mode 100644 unittest/testcfg/objects/Factory.cpp
 delete mode 100644 unittest/testcfg/objects/Factory.h

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/testcfg/objects/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/CatchFactory.cpp
rename to unittest/testcfg/objects/CatchFactory.cpp
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/testcfg/objects/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/CatchFactory.h
rename to unittest/testcfg/objects/CatchFactory.h
diff --git a/unittest/testcfg/objects/Factory.cpp b/unittest/testcfg/objects/Factory.cpp
deleted file mode 100644
index e05b7942..00000000
--- a/unittest/testcfg/objects/Factory.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "Factory.h"
-
-#include <fsfw/events/EventManager.h>
-#include <fsfw/health/HealthTable.h>
-
-#include <fsfw/internalError/InternalErrorReporter.h>
-#include <fsfw/objectmanager/frameworkObjects.h>
-
-/**
- * @brief Produces system objects.
- * @details
- * Build tasks by using SystemObject Interface (Interface).
- * Header files of all tasks must be included
- * Please note that an object has to implement the system object interface
- * if the interface validity is checked or retrieved later by using the
- * get<TargetInterface>(object_id) function from the ObjectManagerIF.
- *
- * Framework objects are created first.
- *
- * @ingroup init
- */
-void Factory::produce(void) {
-	setStaticFrameworkObjectIds();
-	new EventManager(objects::EVENT_MANAGER);
-	new HealthTable(objects::HEALTH_TABLE);
-	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
-
-}
-
-void Factory::setStaticFrameworkObjectIds() {
-
-}
-
-
diff --git a/unittest/testcfg/objects/Factory.h b/unittest/testcfg/objects/Factory.h
deleted file mode 100644
index 84f9207e..00000000
--- a/unittest/testcfg/objects/Factory.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
-
-#include <fsfw/objectmanager/SystemObjectIF.h>
-
-namespace Factory {
-	/**
-	 * @brief 	Creates all SystemObject elements which are persistent
-	 * 			during execution.
-	 */
-	void produce();
-	void setStaticFrameworkObjectIds();
-
-}
-
-#endif /* FACTORY_H_ */

From 6911f91744ff1b1022adca763bf8b42c208cff97 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:15:41 +0100
Subject: [PATCH 1057/1292] rtems fixes taken over

---
 osal/rtems/Clock.cpp              | 32 ++++++++++++------------------
 osal/rtems/CpuUsage.cpp           |  2 +-
 osal/rtems/InternalErrorCodes.cpp |  4 ++--
 osal/rtems/MessageQueue.cpp       | 33 +++++++++++++++++--------------
 osal/rtems/MessageQueue.h         | 29 ++++++++++-----------------
 osal/rtems/MultiObjectTask.cpp    |  8 ++++----
 osal/rtems/MultiObjectTask.h      |  2 +-
 osal/rtems/Mutex.cpp              | 11 ++++++-----
 osal/rtems/Mutex.h                |  6 +++---
 osal/rtems/MutexFactory.cpp       |  1 -
 osal/rtems/PollingTask.cpp        | 23 ++++++++++-----------
 osal/rtems/PollingTask.h          |  8 ++++----
 osal/rtems/QueueFactory.cpp       |  9 +++++----
 osal/rtems/RtemsBasic.h           |  6 +++---
 osal/rtems/TaskBase.cpp           |  2 +-
 osal/rtems/TaskBase.h             |  6 +++---
 16 files changed, 86 insertions(+), 96 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index eeffd7f3..e5f37ec6 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -3,7 +3,7 @@
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
+MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void){
 	rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
@@ -40,7 +40,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
 	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
 	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,NULL);
+	_TOD_Set(&newTime,nullptr);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -131,7 +131,7 @@ ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
 
 ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
 	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == NULL) {
+	if (timeMutex == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -157,40 +157,34 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+	MutexHelper helper(timeMutex);
+
 
 	leapSeconds = leapSeconds_;
 
-	result = timeMutex->unlockMutex();
-	return result;
+
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if(timeMutex==NULL){
+	if(timeMutex==nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+	MutexHelper helper(timeMutex);
 
 	*leapSeconds_ = leapSeconds;
 
-	result = timeMutex->unlockMutex();
-	return result;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex==nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp
index d49de4ad..6655c69b 100644
--- a/osal/rtems/CpuUsage.cpp
+++ b/osal/rtems/CpuUsage.cpp
@@ -158,7 +158,7 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
 }
 
 ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
-		int32_t* size, Endianness streamEndianness) {
+		size_t* size, Endianness streamEndianness) {
 	ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
 			size, streamEndianness);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index 9346cf15..ddf365d5 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -12,8 +12,8 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 //		return INVALID_WORKSPACE_ADDRESS;
 	case INTERNAL_ERROR_TOO_LITTLE_WORKSPACE:
 		return TOO_LITTLE_WORKSPACE;
-	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
-		return WORKSPACE_ALLOCATION;
+//	case INTERNAL_ERROR_WORKSPACE_ALLOCATION:
+//		return WORKSPACE_ALLOCATION;
 //	case INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL:
 //		return INTERRUPT_STACK_TOO_SMALL;
 	case INTERNAL_ERROR_THREAD_EXITTED:
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 700db444..839182a6 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -1,14 +1,15 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "MessageQueue.h"
 #include "RtemsBasic.h"
 #include <cstring>
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
-		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(NULL) {
+		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(nullptr) {
 	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
 		this->id = 0;
@@ -20,15 +21,15 @@ MessageQueue::~MessageQueue() {
 }
 
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, bool ignoreFault) {
+		MessageQueueMessageIF* message, bool ignoreFault) {
 	return sendMessageFrom(sendTo, message, this->getId(), ignoreFault);
 }
 
-ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::sendToDefault(MessageQueueMessageIF* message) {
 	return sendToDefaultFrom(message, this->getId());
 }
 
-ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::reply(MessageQueueMessageIF* message) {
 	if (this->lastPartner != 0) {
 		return sendMessage(this->lastPartner, message, this->getId());
 	} else {
@@ -36,27 +37,29 @@ ReturnValue_t MessageQueue::reply(MessageQueueMessage* message) {
 	}
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 		MessageQueueId_t* receivedFrom) {
 	ReturnValue_t status = this->receiveMessage(message);
 	*receivedFrom = this->lastPartner;
 	return status;
 }
 
-ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessage* message) {
+ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
+	size_t size = 0;
 	rtems_status_code status = rtems_message_queue_receive(id,
-			message->getBuffer(), &(message->messageSize),
+			message->getBuffer(),&size,
 			RTEMS_NO_WAIT, 1);
 	if (status == RTEMS_SUCCESSFUL) {
+		message->setMessageSize(size);
 		this->lastPartner = message->getSender();
 		//Check size of incoming message.
-		if (message->messageSize < message->getMinimumMessageSize()) {
+		if (message->getMessageSize() < message->getMinimumMessageSize()) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	} else {
 		//No message was received. Keep lastPartner anyway, I might send something later.
 		//But still, delete packet content.
-		memset(message->getData(), 0, message->MAX_DATA_SIZE);
+		memset(message->getData(), 0, message->getMaximumMessageSize());
 	}
 	return convertReturnCode(status);
 }
@@ -79,20 +82,20 @@ void MessageQueue::setDefaultDestination(MessageQueueId_t defaultDestination) {
 }
 
 ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
-		MessageQueueMessage* message, MessageQueueId_t sentFrom,
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 
 	message->setSender(sentFrom);
 	rtems_status_code result = rtems_message_queue_send(sendTo,
-			message->getBuffer(), message->messageSize);
+			message->getBuffer(), message->getMessageSize());
 
 	//TODO: Check if we're in ISR.
 	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
-		if (internalErrorReporter == NULL) {
+		if (internalErrorReporter == nullptr) {
 			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 		}
-		if (internalErrorReporter != NULL) {
+		if (internalErrorReporter != nullptr) {
 			internalErrorReporter->queueMessageNotSent();
 		}
 	}
@@ -105,7 +108,7 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 	return returnCode;
 }
 
-ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessage* message,
+ReturnValue_t MessageQueue::sendToDefaultFrom(MessageQueueMessageIF* message,
 		MessageQueueId_t sentFrom, bool ignoreFault) {
 	return sendMessageFrom(defaultDestination, message, sentFrom, ignoreFault);
 }
diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h
index c6fc62d5..342f1e30 100644
--- a/osal/rtems/MessageQueue.h
+++ b/osal/rtems/MessageQueue.h
@@ -1,14 +1,5 @@
-/**
- *	@file	MessageQueue.h
- *
- *  @date	10/02/2012
- *	@author	Bastian Baetz
- *
- *	@brief	This file contains the definition of the MessageQueue class.
- */
-
-#ifndef MESSAGEQUEUE_H_
-#define MESSAGEQUEUE_H_
+#ifndef FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
+#define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 
 #include "../../internalError/InternalErrorReporterIF.h"
 #include "../../ipc/MessageQueueIF.h"
@@ -60,14 +51,14 @@ public:
 	 * @param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
 	ReturnValue_t sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, bool ignoreFault = false );
+			MessageQueueMessageIF* message, bool ignoreFault = false );
 	/**
 	 * @brief	This operation sends a message to the default destination.
 	 * @details	As in the sendMessage method, this function uses the sendToDefault call of the
 	 * 			MessageQueueSender parent class and adds its queue id as "sentFrom" information.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t sendToDefault( MessageQueueMessage* message );
+	ReturnValue_t sendToDefault( MessageQueueMessageIF* message );
 	/**
 	 * @brief	This operation sends a message to the last communication partner.
 	 * @details	This operation simplifies answering an incoming message by using the stored
@@ -75,7 +66,7 @@ public:
 	 * 			(i.e. lastPartner is zero), an error code is returned.
 	 * @param message	A pointer to a previously created message, which is sent.
 	 */
-	ReturnValue_t reply( MessageQueueMessage* message );
+	ReturnValue_t reply( MessageQueueMessageIF* message );
 
 	/**
 	 * @brief	This function reads available messages from the message queue and returns the sender.
@@ -84,7 +75,7 @@ public:
 	 * @param message	A pointer to a message in which the received data is stored.
 	 * @param receivedFrom	A pointer to a queue id in which the sender's id is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message,
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom);
 
 	/**
@@ -95,7 +86,7 @@ public:
 	 * 			message's content is cleared and the function returns immediately.
 	 * @param message	A pointer to a message in which the received data is stored.
 	 */
-	ReturnValue_t receiveMessage(MessageQueueMessage* message);
+	ReturnValue_t receiveMessage(MessageQueueMessageIF* message);
 	/**
 	 * Deletes all pending messages in the queue.
 	 * @param count The number of flushed messages.
@@ -121,7 +112,7 @@ public:
 	 * 					This variable is set to zero by default.
 	 * \param ignoreFault If set to true, the internal software fault counter is not incremented if queue is full.
 	 */
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	The sendToDefault method sends a queue message to the default destination.
 	 * \details	In all other aspects, it works identical to the sendMessage method.
@@ -129,7 +120,7 @@ public:
 	 * \param sentFrom	The sentFrom information can be set to inject the sender's queue id into the message.
 	 * 					This variable is set to zero by default.
 	 */
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessage* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message, MessageQueueId_t sentFrom = NO_QUEUE, bool ignoreFault = false );
 	/**
 	 * \brief	This method is a simple setter for the default destination.
 	 */
@@ -178,4 +169,4 @@ private:
 	static ReturnValue_t convertReturnCode(rtems_status_code inValue);
 };
 
-#endif /* MESSAGEQUEUE_H_ */
+#endif /* FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_ */
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 2342c24c..970d01e1 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,7 +30,7 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "ObjectTask::startTask for " << std::hex << this->getId()
+		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 	}
 	switch(status){
@@ -63,8 +63,8 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
-			error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
-			if (this->deadlineMissedFunc != NULL) {
+			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
 		}
@@ -74,7 +74,7 @@ void MultiObjectTask::taskFunctionality() {
 ReturnValue_t MultiObjectTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
-	if (newObject == NULL) {
+	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h
index 736e79dd..04d122a3 100644
--- a/osal/rtems/MultiObjectTask.h
+++ b/osal/rtems/MultiObjectTask.h
@@ -80,7 +80,7 @@ protected:
 	/**
 	 * @brief	The pointer to the deadline-missed function.
 	 * @details	This pointer stores the function that is executed if the task's deadline is missed.
-	 * 			So, each may react individually on a timing failure. The pointer may be NULL,
+	 * 			So, each may react individually on a timing failure. The pointer may be nullptr,
 	 * 			then nothing happens on missing the deadline. The deadline is equal to the next execution
 	 * 			of the periodic task.
 	 */
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 9553ac79..a5ec9635 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,7 +10,7 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
+		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
 	}
 }
@@ -18,24 +18,25 @@ Mutex::Mutex() :
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "Mutex: deletion for id " << mutexId
+		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
 	}
 }
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
+	rtems_status_code status = RTEMS_INVALID_ID;
 	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
 	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);
 	}
 	else {
-		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, timeoutMs);
 	}
 
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 72368210..4c861318 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OSAL_RTEMS_MUTEX_H_
-#define FRAMEWORK_OSAL_RTEMS_MUTEX_H_
+#ifndef FSFW_OSAL_RTEMS_MUTEX_H_
+#define FSFW_OSAL_RTEMS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include "RtemsBasic.h"
@@ -15,4 +15,4 @@ private:
 	static uint8_t count;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FSFW_OSAL_RTEMS_MUTEX_H_ */
diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp
index ea594789..24af5fa9 100644
--- a/osal/rtems/MutexFactory.cpp
+++ b/osal/rtems/MutexFactory.cpp
@@ -2,7 +2,6 @@
 #include "Mutex.h"
 #include "RtemsBasic.h"
 
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
 
 MutexFactory::MutexFactory() {
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 04191515..db7864fe 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -1,5 +1,6 @@
-#include "../../devicehandlers/FixedSequenceSlot.h"
+#include "../../tasks/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
+#include "../../objectmanager/ObjectManagerIF.h"
 #include "PollingTask.h"
 #include "RtemsBasic.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
@@ -34,14 +35,14 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-	debug << "Polling task " << originalTask->getId()
+	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
-		error << "PST missed " << PollingTask::deadlineMissedCount
+		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 	}
 }
@@ -50,7 +51,7 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-		error << "PollingTask::startTask for " << std::hex << this->getId()
+		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 	}
 	switch(status){
@@ -68,12 +69,13 @@ ReturnValue_t PollingTask::startTask() {
 
 ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		pst.addSlot(componentId, slotTimeMs, executionStep, this);
+	ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
+	if (object != nullptr) {
+		pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	error << "Component " << std::hex << componentId <<
+	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
@@ -90,11 +92,10 @@ ReturnValue_t PollingTask::checkSequence() const {
 
 void PollingTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	FixedSlotSequence::SlotListIter it = pst.current;
 
 	//The start time for the first entry is read.
-	rtems_interval interval = RtemsBasic::convertMsToTicks(
-			(*it)->pollingTimeMs);
+	rtems_interval interval = RtemsBasic::convertMsToTicks(it->pollingTimeMs);
 	TaskBase::setAndStartPeriod(interval,&periodId);
 	//The task's "infinite" inner loop is entered.
 	while (1) {
@@ -107,7 +108,7 @@ void PollingTask::taskFunctionality() {
 			//If the deadline was missed, the deadlineMissedFunc is called.
 			rtems_status_code status = TaskBase::restartPeriod(interval,periodId);
 			if (status == RTEMS_TIMEOUT) {
-				if (this->deadlineMissedFunc != NULL) {
+				if (this->deadlineMissedFunc != nullptr) {
 					this->deadlineMissedFunc();
 				}
 			}
diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h
index 199c34e7..42deaf09 100644
--- a/osal/rtems/PollingTask.h
+++ b/osal/rtems/PollingTask.h
@@ -1,7 +1,7 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
+#ifndef FSFW_OSAL_RTEMS_POLLINGTASK_H_
+#define FSFW_OSAL_RTEMS_POLLINGTASK_H_
 
-#include "../../devicehandlers/FixedSlotSequence.h"
+#include "../../tasks/FixedSlotSequence.h"
 #include "../../tasks/FixedTimeslotTaskIF.h"
 #include "TaskBase.h"
 
@@ -82,4 +82,4 @@ protected:
 	void taskFunctionality( void );
 };
 
-#endif /* POLLINGTASK_H_ */
+#endif /* FSFW_OSAL_RTEMS_POLLINGTASK_H_ */
diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp
index fce55a0e..ff561304 100644
--- a/osal/rtems/QueueFactory.cpp
+++ b/osal/rtems/QueueFactory.cpp
@@ -1,16 +1,17 @@
 #include "../../ipc/QueueFactory.h"
+#include "../../ipc/MessageQueueSenderIF.h"
 #include "MessageQueue.h"
 #include "RtemsBasic.h"
 
-QueueFactory* QueueFactory::factoryInstance = NULL;
+QueueFactory* QueueFactory::factoryInstance = nullptr;
 
 
 ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
-			MessageQueueMessage* message, MessageQueueId_t sentFrom,bool ignoreFault) {
+		MessageQueueMessageIF* message, MessageQueueId_t sentFrom,bool ignoreFault) {
 	//TODO add ignoreFault functionality
 	message->setSender(sentFrom);
 	rtems_status_code result = rtems_message_queue_send(sendTo, message->getBuffer(),
-			message->messageSize);
+			message->getMessageSize());
 	switch(result){
 	case RTEMS_SUCCESSFUL:
 			//message sent successfully
@@ -37,7 +38,7 @@ ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
 }
 
 QueueFactory* QueueFactory::instance() {
-	if (factoryInstance == NULL) {
+	if (factoryInstance == nullptr) {
 		factoryInstance = new QueueFactory;
 	}
 	return factoryInstance;
diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h
index 78e0d46e..d0ca5aba 100644
--- a/osal/rtems/RtemsBasic.h
+++ b/osal/rtems/RtemsBasic.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_RTEMSBASIC_H_
-#define OS_RTEMS_RTEMSBASIC_H_
+#ifndef FSFW_OSAL_RTEMS_RTEMSBASIC_H_
+#define FSFW_OSAL_RTEMS_RTEMSBASIC_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include <rtems.h>
@@ -22,4 +22,4 @@ public:
 	}
 };
 
-#endif /* OS_RTEMS_RTEMSBASIC_H_ */
+#endif /* FSFW_OSAL_RTEMS_RTEMSBASIC_H_ */
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index adf6ee70..4e0c8f00 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,7 +22,7 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-		error << "TaskBase::TaskBase: createTask with name " << std::hex
+		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
 		this->id = 0;
diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h
index 410d9110..0e186e67 100644
--- a/osal/rtems/TaskBase.h
+++ b/osal/rtems/TaskBase.h
@@ -1,5 +1,5 @@
-#ifndef TASKBASE_H_
-#define TASKBASE_H_
+#ifndef FSFW_OSAL_RTEMS_TASKBASE_H_
+#define FSFW_OSAL_RTEMS_TASKBASE_H_
 
 #include "RtemsBasic.h"
 #include "../../tasks/PeriodicTaskIF.h"
@@ -44,4 +44,4 @@ private:
 };
 
 
-#endif /* TASKBASE_H_ */
+#endif /* FSFW_OSAL_RTEMS_TASKBASE_H_ */

From f604d621e8958ebe906f0cc0bf3c77fad775cd41 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:19:12 +0100
Subject: [PATCH 1058/1292] removed interrupt class

---
 osal/rtems/Interrupt.cpp | 86 ----------------------------------------
 osal/rtems/Interrupt.h   | 50 -----------------------
 2 files changed, 136 deletions(-)
 delete mode 100644 osal/rtems/Interrupt.cpp
 delete mode 100644 osal/rtems/Interrupt.h

diff --git a/osal/rtems/Interrupt.cpp b/osal/rtems/Interrupt.cpp
deleted file mode 100644
index b740f1ca..00000000
--- a/osal/rtems/Interrupt.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "Interrupt.h"
-extern "C" {
-#include <bsp_flp/hw_timer/hw_timer.h>
-#include <bsp_flp/hw_uart/hw_uart.h>
-}
-#include "RtemsBasic.h"
-
-
-ReturnValue_t Interrupt::enableInterrupt(InterruptNumber_t interruptNumber) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask | (1 << interruptNumber);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Interrupt::setInterruptServiceRoutine(IsrHandler_t handler,
-		InterruptNumber_t interrupt, IsrHandler_t* oldHandler) {
-	IsrHandler_t oldHandler_local;
-	if (oldHandler == NULL) {
-		oldHandler = &oldHandler_local;
-	}
-	//+ 0x10 comes because of trap type assignment to IRQs in UT699 processor
-	rtems_status_code status = rtems_interrupt_catch(handler, interrupt + 0x10,
-			oldHandler);
-	switch(status){
-	case RTEMS_SUCCESSFUL:
-		//ISR established successfully
-		return HasReturnvaluesIF::RETURN_OK;
-	case RTEMS_INVALID_NUMBER:
-		//illegal vector number
-		return HasReturnvaluesIF::RETURN_FAILED;
-	case RTEMS_INVALID_ADDRESS:
-		//illegal ISR entry point or invalid old_isr_handler
-		return HasReturnvaluesIF::RETURN_FAILED;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-}
-
-ReturnValue_t Interrupt::disableInterrupt(InterruptNumber_t interruptNumber) {
-	//TODO Not implemented
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-//SHOULDDO: Make default values (edge, polarity) settable?
-ReturnValue_t Interrupt::enableGpioInterrupt(InterruptNumber_t interrupt) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask | (1 << interrupt);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		volatile hw_gpio_port_t* ioPorts = hw_gpio_port;
-		ioPorts->direction &= ~(1 << interrupt); //Direction In
-		ioPorts->interrupt_edge |= 1 << interrupt; //Edge triggered
-		ioPorts->interrupt_polarity |= 1 << interrupt; //Trigger on rising edge
-		ioPorts->interrupt_mask |= 1 << interrupt; //Enable
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Interrupt::disableGpioInterrupt(InterruptNumber_t interrupt) {
-	volatile uint32_t* irqMask = hw_irq_mask;
-	uint32_t expectedValue = *irqMask & ~(1 << interrupt);
-	*irqMask = expectedValue;
-	uint32_t tempValue = *irqMask;
-	if (tempValue == expectedValue) {
-		//Disable gpio IRQ
-		volatile hw_gpio_port_t* ioPorts = hw_gpio_port;
-		ioPorts->interrupt_mask &= ~(1 << interrupt);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-bool Interrupt::isInterruptInProgress() {
-	return rtems_interrupt_is_in_progress();
-}
diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h
deleted file mode 100644
index 2152e2f0..00000000
--- a/osal/rtems/Interrupt.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef OS_RTEMS_INTERRUPT_H_
-#define OS_RTEMS_INTERRUPT_H_
-
-#include "../../returnvalues/HasReturnvaluesIF.h"
-#include <cstring>
-#include <rtems.h>
-
-typedef rtems_isr_entry IsrHandler_t;
-typedef rtems_isr IsrReturn_t;
-typedef rtems_vector_number InterruptNumber_t;
-
-class Interrupt {
-public:
-	virtual ~Interrupt(){};
-
-	/**
-	 * Establishes a new interrupt service routine.
-	 * @param handler	The service routine to establish
-	 * @param interrupt	The interrupt (NOT trap type) the routine shall react to.
-	 * @return	RETURN_OK on success. Otherwise, the OS failure code is returned.
-	 */
-	static ReturnValue_t setInterruptServiceRoutine(IsrHandler_t handler,
-			InterruptNumber_t interrupt, IsrHandler_t *oldHandler = NULL);
-	static ReturnValue_t enableInterrupt(InterruptNumber_t interruptNumber);
-	static ReturnValue_t disableInterrupt(InterruptNumber_t interruptNumber);
-	/**
-	 * Enables the interrupt given.
-	 * The function tests, if the InterruptMask register was written successfully.
-	 * @param interrupt The interrupt to enable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t enableGpioInterrupt(InterruptNumber_t interrupt);
-	/**
-	 * Disables the interrupt given.
-	 * @param interrupt The interrupt to disable.
-	 * @return RETURN_OK if the interrupt was set successfully. RETURN_FAILED else.
-	 */
-	static ReturnValue_t disableGpioInterrupt(InterruptNumber_t interrupt);
-
-
-	/**
-	 * Checks if the current executing context is an ISR.
-	 * @return true if handling an interrupt, false else.
-	 */
-	static bool isInterruptInProgress();
-
-};
-
-
-#endif /* OS_RTEMS_INTERRUPT_H_ */

From d2f631a955bfd439ac04fcf3d75327e5171a3ca0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:20:21 +0100
Subject: [PATCH 1059/1292] cast added

---
 returnvalues/HasReturnvaluesIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h
index a39ac742..4a3835b6 100644
--- a/returnvalues/HasReturnvaluesIF.h
+++ b/returnvalues/HasReturnvaluesIF.h
@@ -24,7 +24,7 @@ public:
 	 */
 	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
 			uint8_t number) {
-	    return (interfaceId << 8) + number;
+	    return (static_cast<ReturnValue_t>(interfaceId) << 8) + number;
 	}
 };
 

From 8c88255873283ea51cbe02f6bf9c3c36900e567c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:31:50 +0100
Subject: [PATCH 1060/1292] taken over some tweaks

---
 tmtcservices/AcceptsTelemetryIF.h      |  9 +++---
 tmtcservices/AcceptsVerifyMessageIF.h  |  6 ++--
 tmtcservices/CMakeLists.txt            |  9 ++++++
 tmtcservices/CommandingServiceBase.cpp | 40 +++++++++++++-------------
 tmtcservices/PusServiceBase.cpp        | 13 +++++----
 tmtcservices/PusServiceBase.h          | 13 +++++----
 tmtcservices/PusVerificationReport.cpp | 25 ----------------
 tmtcservices/ServiceTypes.h            |  8 +-----
 tmtcservices/SourceSequenceCounter.h   | 12 ++------
 tmtcservices/TmTcBridge.cpp            |  3 +-
 tmtcservices/TmTcBridge.h              | 10 +++----
 tmtcservices/TmTcMessage.cpp           |  5 ++--
 tmtcservices/VerificationCodes.h       |  2 +-
 13 files changed, 65 insertions(+), 90 deletions(-)
 create mode 100644 tmtcservices/CMakeLists.txt

diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h
index 2325dbe0..43173d89 100644
--- a/tmtcservices/AcceptsTelemetryIF.h
+++ b/tmtcservices/AcceptsTelemetryIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSTELEMETRYIF_H_
-#define ACCEPTSTELEMETRYIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 /**
@@ -20,7 +20,8 @@ public:
 	 * 			receiving message queue.
 	 * @return	The telemetry reception message queue id.
 	 */
-	virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) = 0;
+	virtual MessageQueueId_t getReportReceptionQueue(
+	        uint8_t virtualChannel = 0) = 0;
 };
 
-#endif /* ACCEPTSTELEMETRYIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_ */
diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h
index c9318ab0..d16def4d 100644
--- a/tmtcservices/AcceptsVerifyMessageIF.h
+++ b/tmtcservices/AcceptsVerifyMessageIF.h
@@ -1,5 +1,5 @@
-#ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_
-#define ACCEPTSVERIFICATIONMESSAGEIF_H_
+#ifndef FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
+#define FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_
 
 #include "../ipc/MessageQueueSenderIF.h"
 
@@ -12,4 +12,4 @@ public:
 };
 
 
-#endif /* ACCEPTSVERIFICATIONMESSAGEIF_H_ */
+#endif /* FSFW_TMTCSERVICES_ACCEPTSVERIFICATIONMESSAGEIF_H_ */
diff --git a/tmtcservices/CMakeLists.txt b/tmtcservices/CMakeLists.txt
new file mode 100644
index 00000000..c30af214
--- /dev/null
+++ b/tmtcservices/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandingServiceBase.cpp
+		PusServiceBase.cpp
+		PusVerificationReport.cpp
+		TmTcBridge.cpp
+		TmTcMessage.cpp
+		VerificationReporter.cpp
+)
\ No newline at end of file
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 0ebc3944..ed765ecc 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -1,9 +1,9 @@
-#include "../tcdistribution/PUSDistributorIF.h"
 #include "AcceptsTelemetryIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
 #include "CommandingServiceBase.h"
 #include "TmTcMessage.h"
+
+#include "../tcdistribution/PUSDistributorIF.h"
+#include "../objectmanager/ObjectManagerIF.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -149,13 +149,13 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, ++iter->second.step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
@@ -184,13 +184,13 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 	if (sendResult == RETURN_OK) {
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::PROGRESS_SUCCESS,
+					tc_verification::PROGRESS_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
-					TC_VERIFY::COMPLETION_SUCCESS,
+					tc_verification::COMPLETION_SUCCESS,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
@@ -200,14 +200,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult,
 					++iter->second.step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE,
+					tc_verification::COMPLETION_FAILURE,
 					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
 					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
@@ -232,14 +232,14 @@ void CommandingServiceBase::handleRequestQueue() {
 
 		if ((packet.getSubService() == 0)
 				or (isValidSubservice(packet.getSubService()) != RETURN_OK)) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE);
+			rejectPacket(tc_verification::START_FAILURE, &packet, INVALID_SUBSERVICE);
 			continue;
 		}
 		result = getMessageQueueAndObject(packet.getSubService(),
 				packet.getApplicationData(), packet.getApplicationDataSize(),
 				&queue, &objectId);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
-			rejectPacket(TC_VERIFY::START_FAILURE, &packet, result);
+			rejectPacket(tc_verification::START_FAILURE, &packet, result);
 			continue;
 		}
 
@@ -250,14 +250,14 @@ void CommandingServiceBase::handleRequestQueue() {
 		if (iter != commandMap.end()) {
 			result = iter->second.fifo.insert(address);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, OBJECT_BUSY);
 			}
 		} else {
 			CommandInfo newInfo; //Info will be set by startExecution if neccessary
 			newInfo.objectId = objectId;
 			result = commandMap.insert(queue, newInfo, &iter);
 			if (result != RETURN_OK) {
-				rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY);
+				rejectPacket(tc_verification::START_FAILURE, &packet, BUSY);
 			} else {
 				startExecution(&packet, iter);
 			}
@@ -338,10 +338,10 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
 			iter->second.tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
-			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::START_SUCCESS, storedPacket);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
@@ -352,18 +352,18 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS,
+			verificationReporter.sendSuccessReport(tc_verification::START_SUCCESS,
 					storedPacket);
-			acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket);
+			acceptPacket(tc_verification::COMPLETION_SUCCESS, storedPacket);
 			checkAndExecuteFifo(iter);
 		} else {
 			command.clearCommandMessage();
-			rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult);
+			rejectPacket(tc_verification::START_FAILURE, storedPacket, sendResult);
 			checkAndExecuteFifo(iter);
 		}
 		break;
 	default:
-		rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, result);
+		rejectPacket(tc_verification::START_FAILURE, storedPacket, result);
 		checkAndExecuteFifo(iter);
 		break;
 	}
@@ -414,7 +414,7 @@ void CommandingServiceBase::checkTimeout() {
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
 		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
+					tc_verification::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
 					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 9d4aabd9..cb5a1247 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -1,9 +1,10 @@
+#include "PusServiceBase.h"
+#include "AcceptsTelemetryIF.h"
+#include "PusVerificationReport.h"
+#include "TmTcMessage.h"
+
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../tcdistribution/PUSDistributorIF.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
-#include "../tmtcservices/PusServiceBase.h"
-#include "../tmtcservices/PusVerificationReport.h"
-#include "../tmtcservices/TmTcMessage.h"
 #include "../ipc/QueueFactory.h"
 
 object_id_t PusServiceBase::packetSource = 0;
@@ -60,11 +61,11 @@ void PusServiceBase::handleRequestQueue() {
 			//    ": handleRequest returned: " << (int)return_code << std::endl;
 			if (result == RETURN_OK) {
 				this->verifyReporter.sendSuccessReport(
-						TC_VERIFY::COMPLETION_SUCCESS, &this->currentPacket);
+						tc_verification::COMPLETION_SUCCESS, &this->currentPacket);
 			}
 			else {
 				this->verifyReporter.sendFailureReport(
-						TC_VERIFY::COMPLETION_FAILURE, &this->currentPacket,
+						tc_verification::COMPLETION_FAILURE, &this->currentPacket,
 						result, 0, errorParameter1, errorParameter2);
 			}
 			this->currentPacket.deletePacket();
diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h
index 7c8f504c..4d3d99bc 100644
--- a/tmtcservices/PusServiceBase.h
+++ b/tmtcservices/PusServiceBase.h
@@ -1,14 +1,15 @@
-#ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
-#define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_
+#ifndef FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+#define FSFW_TMTCSERVICES_PUSSERVICEBASE_H_
+
+#include "AcceptsTelecommandsIF.h"
+#include "VerificationCodes.h"
+#include "VerificationReporter.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../objectmanager/SystemObject.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
-#include "../tmtcservices/VerificationCodes.h"
-#include "../tmtcservices/VerificationReporter.h"
 #include "../ipc/MessageQueueIF.h"
 
 namespace Factory{
@@ -156,4 +157,4 @@ private:
 	void handleRequestQueue();
 };
 
-#endif /* PUSSERVICEBASE_H_ */
+#endif /* FSFW_TMTCSERVICES_PUSSERVICEBASE_H_ */
diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp
index 369519d8..c64e5feb 100644
--- a/tmtcservices/PusVerificationReport.cpp
+++ b/tmtcservices/PusVerificationReport.cpp
@@ -4,31 +4,6 @@
 PusVerificationMessage::PusVerificationMessage() {
 }
 
-//PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
-//		TcPacketBase* current_packet, ReturnValue_t set_error_code,
-//		uint8_t set_step, uint32_t parameter1, uint32_t parameter2) {
-//	uint8_t ackFlags = current_packet->getAcknowledgeFlags();
-//	uint16_t tcPacketId = current_packet->getPacketId();
-//	uint16_t tcSequenceControl = current_packet->getPacketSequenceControl();
-//	uint8_t* data = this->getBuffer();
-//	data[messageSize] = set_report_id;
-//	messageSize += sizeof(set_report_id);
-//	data[messageSize] = ackFlags;
-//	messageSize += sizeof(ackFlags);
-//	memcpy(&data[messageSize], &tcPacketId, sizeof(tcPacketId));
-//	messageSize += sizeof(tcPacketId);
-//	memcpy(&data[messageSize], &tcSequenceControl, sizeof(tcSequenceControl));
-//	messageSize += sizeof(tcSequenceControl);
-//	data[messageSize] = set_step;
-//	messageSize += sizeof(set_step);
-//	memcpy(&data[messageSize], &set_error_code, sizeof(set_error_code));
-//	messageSize += sizeof(set_error_code);
-//	memcpy(&data[messageSize], &parameter1, sizeof(parameter1));
-//	messageSize += sizeof(parameter1);
-//	memcpy(&data[messageSize], &parameter2, sizeof(parameter2));
-//	messageSize += sizeof(parameter2);
-//}
-
 PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
 		uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
 		ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
index 1f5bff42..552601f9 100644
--- a/tmtcservices/ServiceTypes.h
+++ b/tmtcservices/ServiceTypes.h
@@ -1,13 +1,7 @@
-/**
- * @file	ServiceTypes.h
- * @brief	This file defines the ServiceTypes class.
- * @date	11.04.2013
- * @author	baetz
- */
-
 #ifndef SERVICETYPES_H_
 #define SERVICETYPES_H_
 
+// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
 namespace SERVICE {
 enum ServiceTypes {
 	TELECOMMAND_VERIFICATION = 1,
diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h
index 1cc58758..2b30a53f 100644
--- a/tmtcservices/SourceSequenceCounter.h
+++ b/tmtcservices/SourceSequenceCounter.h
@@ -1,12 +1,6 @@
-/**
- * @file	SourceSequenceCounter.h
- * @brief	This file defines the SourceSequenceCounter class.
- * @date	04.02.2013
- * @author	baetz
- */
+#ifndef FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
+#define FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_
 
-#ifndef SOURCESEQUENCECOUNTER_H_
-#define SOURCESEQUENCECOUNTER_H_
 #include "../tmtcpacket/SpacePacketBase.h"
 
 class SourceSequenceCounter {
@@ -27,4 +21,4 @@ public:
 };
 
 
-#endif /* SOURCESEQUENCECOUNTER_H_ */
+#endif /* FSFW_TMTCSERVICES_SOURCESEQUENCECOUNTER_H_ */
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8abe37a2..b4e9967b 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -1,7 +1,6 @@
-#include "../tmtcservices/TmTcBridge.h"
+#include "TmTcBridge.h"
 
 #include "../ipc/QueueFactory.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 62cfdaac..0177648c 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,13 +1,13 @@
-#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
-#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
+#ifndef FSFW_TMTCSERVICES_TMTCBRIDGE_H_
+#define FSFW_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include "AcceptsTelemetryIF.h"
+#include "AcceptsTelecommandsIF.h"
 
 #include "../objectmanager/SystemObject.h"
-#include "../tmtcservices/AcceptsTelemetryIF.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../container/DynamicFIFO.h"
 #include "../tmtcservices/TmTcMessage.h"
 
@@ -159,4 +159,4 @@ protected:
 };
 
 
-#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */
+#endif /* FSFW_TMTCSERVICES_TMTCBRIDGE_H_ */
diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp
index f81eba62..ae028315 100644
--- a/tmtcservices/TmTcMessage.cpp
+++ b/tmtcservices/TmTcMessage.cpp
@@ -1,5 +1,6 @@
-#include "../tmtcservices/TmTcMessage.h"
-#include <string.h>
+#include "TmTcMessage.h"
+
+#include <cstring>
 
 
 TmTcMessage::TmTcMessage() {
diff --git a/tmtcservices/VerificationCodes.h b/tmtcservices/VerificationCodes.h
index e3e89b5a..35ad6819 100644
--- a/tmtcservices/VerificationCodes.h
+++ b/tmtcservices/VerificationCodes.h
@@ -1,7 +1,7 @@
 #ifndef VERIFICATIONCODES_H_
 #define VERIFICATIONCODES_H_
 
-namespace TC_VERIFY {
+namespace tc_verification {
 
 enum verification_flags {
 	NONE = 0b0000,

From 796f0e2e17152a40d6f58c9c592b9c74fc573148 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:33:19 +0100
Subject: [PATCH 1061/1292] important changes adapted

---
 pus/servicepackets/Service1Packets.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h
index ecb62693..2249b4b0 100644
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@@ -49,7 +49,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
+		if (failureSubtype == tc_verification::PROGRESS_FAILURE) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 			        maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -77,7 +77,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
+		if(failureSubtype==tc_verification::PROGRESS_FAILURE){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		size += SerializeAdapter::getSerializedSize(&errorCode);
@@ -131,7 +131,7 @@ public:
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
+		if (subtype == tc_verification::PROGRESS_SUCCESS) {
 			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
 					maxSize, streamEndianness);
 			if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -145,7 +145,7 @@ public:
 		size_t size = 0;
 		size += SerializeAdapter::getSerializedSize(&packetId);
 		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
+		if(subtype == tc_verification::PROGRESS_SUCCESS){
 			size += SerializeAdapter::getSerializedSize(&stepNumber);
 		}
 		return size;

From 1c79da0e75309662bdfe5b94c4a71c93c1825492 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:34:29 +0100
Subject: [PATCH 1062/1292] tc distrib changed  taken over

---
 tcdistribution/PUSDistributor.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 63d1dcde..8e5b94cc 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -77,14 +77,14 @@ ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
 		tcStatus = queueStatus;
 	}
 	if (tcStatus != RETURN_OK) {
-		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+		this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE,
 				currentPacket, tcStatus);
 		// A failed packet is deleted immediately after reporting,
 		// otherwise it will block memory.
 		currentPacket->deletePacket();
 		return RETURN_FAILED;
 	} else {
-		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+		this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS,
 				currentPacket);
 		return RETURN_OK;
 	}
@@ -95,16 +95,19 @@ uint16_t PUSDistributor::getIdentifier() {
 }
 
 ReturnValue_t PUSDistributor::initialize() {
+    currentPacket = new TcPacketStored();
+    if(currentPacket == nullptr) {
+        // Should not happen, memory allocation failed!
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
-	currentPacket = new TcPacketStored();
 	if (ccsdsDistributor == nullptr) {
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
 	    return RETURN_FAILED;
 	}
-	else {
-		return ccsdsDistributor->registerApplication(this);
-	}
+	return ccsdsDistributor->registerApplication(this);
 }

From db42e79fd4eb299c960a3da50ef629098f9bb409 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:38:45 +0100
Subject: [PATCH 1063/1292] taken over cmakelists file

---
 osal/linux/CMakeLists.txt | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 osal/linux/CMakeLists.txt

diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
new file mode 100644
index 00000000..c0096e42
--- /dev/null
+++ b/osal/linux/CMakeLists.txt
@@ -0,0 +1,25 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		BinarySemaphore.cpp
+		CountingSemaphore.cpp
+		FixedTimeslotTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicPosixTask.cpp
+		PosixThread.cpp
+		QueueFactory.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		TcUnixUdpPollingTask.cpp
+		TmTcUnixUdpBridge.cpp
+		Timer.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		pthread
+)

From f2ba653833924f073a44974fd6e902ce6f5d1815 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:47:42 +0100
Subject: [PATCH 1064/1292] ipc changes taken over

---
 ipc/MutexFactory.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h
index f8133d81..db505ff9 100644
--- a/ipc/MutexFactory.h
+++ b/ipc/MutexFactory.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_
-#define FRAMEWORK_IPC_MUTEXFACTORY_H_
+#ifndef FSFW_IPC_MUTEXFACTORY_H_
+#define FSFW_IPC_MUTEXFACTORY_H_
 
 #include "MutexIF.h"
 /**
@@ -31,4 +31,4 @@ private:
 
 
 
-#endif /* FRAMEWORK_IPC_MUTEXFACTORY_H_ */
+#endif /* FSFW_IPC_MUTEXFACTORY_H_ */

From 3ee25785a2cefa7eca6d33bba49e046df75a18e1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 21:54:03 +0100
Subject: [PATCH 1065/1292] linux changes adapted

---
 osal/linux/BinarySemaphore.cpp  |  2 +-
 osal/linux/Clock.cpp            | 20 ++++++++++----------
 osal/linux/Mutex.cpp            |  2 +-
 osal/linux/Mutex.h              |  8 ++------
 osal/linux/MutexFactory.cpp     |  3 ++-
 osal/linux/PosixThread.cpp      |  4 +++-
 osal/linux/SemaphoreFactory.cpp |  3 ++-
 osal/linux/TaskFactory.cpp      |  5 +++--
 osal/linux/Timer.cpp            |  3 ++-
 9 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 8c0eeae7..b81fa109 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/BinarySemaphore.h"
+#include "BinarySemaphore.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 extern "C" {
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 468fcb80..6cddda35 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -1,4 +1,3 @@
-#include <fsfw/timemanager/Stopwatch.h>
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
@@ -86,15 +85,16 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint32_t Clock::getUptimeSeconds() {
-	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
-	int result = sysinfo(&sysInfo);
-	if(result != 0){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return sysInfo.uptime;
-}
+// Wait for new FSFW Clock function delivering seconds uptime.
+//uint32_t Clock::getUptimeSeconds() {
+//	//TODO This is not posix compatible and delivers only seconds precision
+//	struct sysinfo sysInfo;
+//	int result = sysinfo(&sysInfo);
+//	if(result != 0){
+//		return HasReturnvaluesIF::RETURN_FAILED;
+//	}
+//	return sysInfo.uptime;
+//}
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 	timeval uptime;
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index 2ecae0cb..b27ff8c0 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -1,4 +1,4 @@
-#include "../../osal/linux/Mutex.h"
+#include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 3acb6d90..cfce407f 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,12 +1,8 @@
-#ifndef OS_LINUX_MUTEX_H_
-#define OS_LINUX_MUTEX_H_
+#ifndef FSFW_OSAL_LINUX_MUTEX_H_
+#define FSFW_OSAL_LINUX_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
-
-extern "C" {
 #include <pthread.h>
-}
-
 
 class Mutex : public MutexIF {
 public:
diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp
index 73ab10a2..80211f8b 100644
--- a/osal/linux/MutexFactory.cpp
+++ b/osal/linux/MutexFactory.cpp
@@ -1,5 +1,6 @@
+#include "Mutex.h"
+
 #include "../../ipc/MutexFactory.h"
-#include "../../osal/linux/Mutex.h"
 
 //TODO: Different variant than the lazy loading in QueueFactory. What's better and why?
 MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index f6ace380..55d74de3 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,5 +1,7 @@
+#include "PosixThread.h"
+
 #include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../osal/linux/PosixThread.h"
+
 #include <cstring>
 #include <errno.h>
 
diff --git a/osal/linux/SemaphoreFactory.cpp b/osal/linux/SemaphoreFactory.cpp
index e4710933..cfb5f12d 100644
--- a/osal/linux/SemaphoreFactory.cpp
+++ b/osal/linux/SemaphoreFactory.cpp
@@ -1,6 +1,7 @@
-#include "../../tasks/SemaphoreFactory.h"
 #include "BinarySemaphore.h"
 #include "CountingSemaphore.h"
+
+#include "../../tasks/SemaphoreFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp
index a25b817d..d18a0316 100644
--- a/osal/linux/TaskFactory.cpp
+++ b/osal/linux/TaskFactory.cpp
@@ -1,5 +1,6 @@
-#include "../../osal/linux/FixedTimeslotTask.h"
-#include "../../osal/linux/PeriodicPosixTask.h"
+#include "FixedTimeslotTask.h"
+#include "PeriodicPosixTask.h"
+
 #include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index b458fd90..bae631d7 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -1,6 +1,7 @@
+#include "Timer.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <errno.h>
-#include "../../osal/linux/Timer.h"
+
 
 Timer::Timer() {
 	sigevent sigEvent;

From 95b2191824f8ca051021801cf84aa9b440a45d37 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 22:55:12 +0100
Subject: [PATCH 1066/1292] long name

---
 datapoollocal/LocalDataPoolManager.h |  2 +-
 datapoollocal/LocalPoolVariable.h    | 50 ++++++++++++++--------------
 datapoollocal/LocalPoolVariable.tpp  | 46 ++++++++++++-------------
 monitoring/MonitorBase.h             |  2 +-
 4 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 95d48303..c4024cf9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,7 +48,7 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVar;
+	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c18d5443..7b7e443e 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -22,10 +22,10 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
+	LocalPoolVariable() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -64,7 +64,7 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 	/**
@@ -73,10 +73,10 @@ public:
 	 * @param dataSet
 	 * @param setReadWriteMode
 	 */
-	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVar() {};
+	virtual~ LocalPoolVariable() {};
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -118,23 +118,23 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(const T& newValue);
-	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+	LocalPoolVariable<T> &operator=(const T& newValue);
+	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
 	//! Explicit type conversion operator. Allows casting the class to
 	//! its template type to perform operations on value.
 	explicit operator T() const;
 
-	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const LocalPoolVariable<T>& other) const;
 	bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const LocalPoolVariable<T>& other) const;
 	bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const LocalPoolVariable<T>& other) const;
 	bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const LocalPoolVariable<T>& other) const;
 	bool operator>(const T& other) const;
 
 protected:
@@ -160,7 +160,7 @@ protected:
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
+			const LocalPoolVariable<U> &var);
 
 private:
 };
@@ -168,18 +168,18 @@ private:
 #include "LocalPoolVariable.tpp"
 
 template<class T>
-using lp_var_t = LocalPoolVar<T>;
+using lp_var_t = LocalPoolVariable<T>;
 
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
+using lp_bool_t = LocalPoolVariable<uint8_t>;
+using lp_uint8_t = LocalPoolVariable<uint8_t>;
+using lp_uint16_t = LocalPoolVariable<uint16_t>;
+using lp_uint32_t = LocalPoolVariable<uint32_t>;
+using lp_uint64_t = LocalPoolVariable<uint64_t>;
+using lp_int8_t = LocalPoolVariable<int8_t>;
+using lp_int16_t = LocalPoolVariable<int16_t>;
+using lp_int32_t = LocalPoolVariable<int32_t>;
+using lp_int64_t = LocalPoolVariable<int64_t>;
+using lp_float_t = LocalPoolVariable<float>;
+using lp_double_t = LocalPoolVariable<double>;
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b9f7b906..48649ad5 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,32 +6,32 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return readWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
@@ -53,14 +53,14 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return commitWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
@@ -81,88 +81,88 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
-inline size_t LocalPoolVar<T>::getSerializedSize() const {
+inline size_t LocalPoolVariable<T>::getSerializedSize() const {
 	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, SerializeIF::Endianness streamEndianness) {
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVar<T> &var) {
+		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
 
 template<typename T>
-inline LocalPoolVar<T>::operator T() const {
+inline LocalPoolVariable<T>::operator T() const {
 	return value;
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+		const LocalPoolVariable<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 	return this->value == other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 	return not (*this == other);
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 	return this->value < other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 530a3840..967f0f62 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -72,7 +72,7 @@ protected:
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalPoolVar<T> poolVariable;
+	LocalPoolVariable<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */

From 9170f466e8ccaf74da9bd97d260fd846fcb6551a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:21:07 +0100
Subject: [PATCH 1067/1292] freeRTOS version checks

---
 osal/FreeRTOS/BinSemaphUsingTask.h | 5 +++++
 osal/FreeRTOS/PeriodicTask.cpp     | 3 +++
 2 files changed, 8 insertions(+)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 65a091a3..0061c252 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -7,6 +7,9 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 // todo: does not work for older FreeRTOS version, so we should
 // actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
 
@@ -90,4 +93,6 @@ protected:
 	TaskHandle_t handle;
 };
 
+#endif
+
 #endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 5c0a840d..04c588d2 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -112,6 +112,8 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
+#if tskKERNEL_VERSION_MAJOR >= 10 && tskKERNEL_VERSION_MINOR > 4)
+#else
     // Time to wake has not overflown.
     if(timeToWake > xLastWakeTime) {
         /* If the current time has overflown exclusively or the current
@@ -126,6 +128,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
+#endif
 }
 
 TaskHandle_t PeriodicTask::getTaskHandle() {

From b8f4d8690bec206be73a4e819ae71685177ae3e9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:38:06 +0100
Subject: [PATCH 1068/1292] determination of freeRTOS features from version

---
 osal/FreeRTOS/BinSemaphUsingTask.h |  3 ---
 osal/FreeRTOS/PeriodicTask.cpp     | 18 +++++++++++-------
 osal/FreeRTOS/PeriodicTask.h       |  1 +
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 0061c252..8a413d5a 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -10,9 +10,6 @@
 #if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
     tskKERNEL_VERSION_MAJOR > 8
 
-// todo: does not work for older FreeRTOS version, so we should
-// actually check whether tskKERNEL_VERSION_MAJOR is larger than.. 7 or 8 ?
-
 /**
  * @brief 	Binary Semaphore implementation using the task notification value.
  * 			The notification value should therefore not be used
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 04c588d2..96389187 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -80,10 +80,16 @@ void PeriodicTask::taskFunctionality() {
 			object->performOperation();
 		}
 
-		checkMissedDeadline(xLastWakeTime, xPeriod);
-
-		vTaskDelayUntil(&xLastWakeTime, xPeriod);
-
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+		BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, xPeriod);
+		if(wasDelayed == pdFALSE) {
+		    handleMissedDeadline();
+		}
+#else
+        checkMissedDeadline(xLastWakeTime, xPeriod);
+        vTaskDelayUntil(&xLastWakeTime, xPeriod);
+#endif
 	}
 }
 
@@ -112,8 +118,6 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
      * it. */
     TickType_t currentTickCount = xTaskGetTickCount();
     TickType_t timeToWake = xLastWakeTime + interval;
-#if tskKERNEL_VERSION_MAJOR >= 10 && tskKERNEL_VERSION_MINOR > 4)
-#else
     // Time to wake has not overflown.
     if(timeToWake > xLastWakeTime) {
         /* If the current time has overflown exclusively or the current
@@ -128,7 +132,7 @@ void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
     else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
         handleMissedDeadline();
     }
-#endif
+
 }
 
 TaskHandle_t PeriodicTask::getTaskHandle() {
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 87b8b6d2..80d00bf1 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -71,6 +71,7 @@ public:
 
 	TaskHandle_t getTaskHandle() override;
 protected:
+
 	bool started;
 	TaskHandle_t handle;
 

From 0c3e87f1deee38f1ee30acf8090c86377ebcb840 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 14 Dec 2020 23:55:54 +0100
Subject: [PATCH 1069/1292] using new xTaskDelayUntil

---
 osal/FreeRTOS/BinSemaphUsingTask.cpp      |  6 +++
 osal/FreeRTOS/BinSemaphUsingTask.h        |  3 +-
 osal/FreeRTOS/CountingSemaphUsingTask.cpp |  5 ++
 osal/FreeRTOS/CountingSemaphUsingTask.h   |  6 +++
 osal/FreeRTOS/FixedTimeslotTask.cpp       | 42 ++++++-----------
 osal/FreeRTOS/FixedTimeslotTask.h         |  2 -
 osal/FreeRTOS/FreeRTOSTaskIF.h            | 38 +++++++++++++--
 osal/FreeRTOS/PeriodicTask.cpp            | 28 ++---------
 osal/FreeRTOS/PeriodicTask.h              |  2 -
 osal/FreeRTOS/TaskManagement.cpp          |  1 +
 osal/FreeRTOS/TaskManagement.h            | 57 +++++++++++------------
 11 files changed, 98 insertions(+), 92 deletions(-)

diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 9c29948e..a420ec48 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -2,6 +2,9 @@
 #include "TaskManagement.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
@@ -97,3 +100,6 @@ uint8_t BinarySemaphoreUsingTask::getSemaphoreCounterFromISR(
 			higherPriorityTaskWoken);
 	return notificationValue;
 }
+
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 8a413d5a..ec434853 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -90,6 +90,7 @@ protected:
 	TaskHandle_t handle;
 };
 
-#endif
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
 
 #endif /* FSFW_OSAL_FREERTOS_BINSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 17cdf7ce..9d309acc 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -3,6 +3,9 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
@@ -113,3 +116,5 @@ uint8_t CountingSemaphoreUsingTask::getSemaphoreCounterFromISR(
 uint8_t CountingSemaphoreUsingTask::getMaxCount() const {
 	return maxCount;
 }
+
+#endif
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index f258197b..45915b6b 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -7,6 +7,9 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
+#if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8
+
 /**
  * @brief 	Couting Semaphore implementation which uses the notification value
  * 			of the task. The notification value should therefore not be used
@@ -100,4 +103,7 @@ private:
 	const uint8_t maxCount;
 };
 
+#endif /* (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || \
+    tskKERNEL_VERSION_MAJOR > 8 */
+
 #endif /* FSFW_OSAL_FREERTOS_COUNTINGSEMAPHUSINGTASK_H_ */
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 062686e2..fc5b89fe 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -114,38 +114,24 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        checkMissedDeadline(xLastWakeTime, interval);
-
-	        // Wait for the interval. This exits immediately if a deadline was
-	        // missed while also updating the last wake time.
-	        vTaskDelayUntil(&xLastWakeTime, interval);
+#if (tskKERNEL_VERSION_MAJOR == 10 && tskKERNEL_VERSION_MINOR >= 4) || \
+    tskKERNEL_VERSION_MAJOR > 10
+	        BaseType_t wasDelayed = xTaskDelayUntil(&xLastWakeTime, interval);
+	        if(wasDelayed == pdFALSE) {
+	            handleMissedDeadline();
+	        }
+#else
+            if(checkMissedDeadline(xLastWakeTime, interval)) {
+                handleMissedDeadline();
+            }
+            // Wait for the interval. This exits immediately if a deadline was
+            // missed while also updating the last wake time.
+            vTaskDelayUntil(&xLastWakeTime, interval);
+#endif
 	    }
 	}
 }
 
-void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-}
-
 void FixedTimeslotTask::handleMissedDeadline() {
     if(deadlineMissedFunc != nullptr) {
         this->deadlineMissedFunc();
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 7d2cdb70..f2245ba4 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -93,8 +93,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/FreeRTOSTaskIF.h b/osal/FreeRTOS/FreeRTOSTaskIF.h
index 06fda282..2a2d9494 100644
--- a/osal/FreeRTOS/FreeRTOSTaskIF.h
+++ b/osal/FreeRTOS/FreeRTOSTaskIF.h
@@ -1,13 +1,41 @@
-#ifndef FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
-#define FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#ifndef FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
+#define FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
 class FreeRTOSTaskIF {
 public:
-	virtual~ FreeRTOSTaskIF() {}
-	virtual TaskHandle_t getTaskHandle() = 0;
+    virtual~ FreeRTOSTaskIF() {}
+    virtual TaskHandle_t getTaskHandle() = 0;
+
+protected:
+
+    bool checkMissedDeadline(const TickType_t xLastWakeTime,
+            const TickType_t interval) {
+        /* Check whether deadline was missed while also taking overflows
+         * into account. Drawing this on paper with a timeline helps to understand
+         * it. */
+        TickType_t currentTickCount = xTaskGetTickCount();
+        TickType_t timeToWake = xLastWakeTime + interval;
+        // Time to wake has not overflown.
+        if(timeToWake > xLastWakeTime) {
+            /* If the current time has overflown exclusively or the current
+             * tick count is simply larger than the time to wake, a deadline was
+             * missed */
+            if((currentTickCount < xLastWakeTime) or
+                    (currentTickCount > timeToWake)) {
+                return true;
+            }
+        }
+        /* Time to wake has overflown. A deadline was missed if the current time
+         * is larger than the time to wake */
+        else if((timeToWake < xLastWakeTime) and
+                (currentTickCount > timeToWake)) {
+            return true;
+        }
+        return false;
+    }
 };
 
-#endif /* FRAMEWORK_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
+#endif /* FSFW_OSAL_FREERTOS_FREERTOSTASKIF_H_ */
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 96389187..2ee7bec0 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -87,7 +87,9 @@ void PeriodicTask::taskFunctionality() {
 		    handleMissedDeadline();
 		}
 #else
-        checkMissedDeadline(xLastWakeTime, xPeriod);
+        if(checkMissedDeadline(xLastWakeTime, xPeriod)) {
+            handleMissedDeadline();
+        }
         vTaskDelayUntil(&xLastWakeTime, xPeriod);
 #endif
 	}
@@ -111,30 +113,6 @@ uint32_t PeriodicTask::getPeriodMs() const {
 	return period * 1000;
 }
 
-void PeriodicTask::checkMissedDeadline(const TickType_t xLastWakeTime,
-        const TickType_t interval) {
-    /* Check whether deadline was missed while also taking overflows
-     * into account. Drawing this on paper with a timeline helps to understand
-     * it. */
-    TickType_t currentTickCount = xTaskGetTickCount();
-    TickType_t timeToWake = xLastWakeTime + interval;
-    // Time to wake has not overflown.
-    if(timeToWake > xLastWakeTime) {
-        /* If the current time has overflown exclusively or the current
-         * tick count is simply larger than the time to wake, a deadline was
-         * missed */
-        if((currentTickCount < xLastWakeTime) or (currentTickCount > timeToWake)) {
-            handleMissedDeadline();
-        }
-    }
-    /* Time to wake has overflown. A deadline was missed if the current time
-     * is larger than the time to wake */
-    else if((timeToWake < xLastWakeTime) and (currentTickCount > timeToWake)) {
-        handleMissedDeadline();
-    }
-
-}
-
 TaskHandle_t PeriodicTask::getTaskHandle() {
     return handle;
 }
diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h
index 80d00bf1..36ef568f 100644
--- a/osal/FreeRTOS/PeriodicTask.h
+++ b/osal/FreeRTOS/PeriodicTask.h
@@ -119,8 +119,6 @@ protected:
 	 */
 	void taskFunctionality(void);
 
-	void checkMissedDeadline(const TickType_t xLastWakeTime,
-	        const TickType_t interval);
 	void handleMissedDeadline();
 };
 
diff --git a/osal/FreeRTOS/TaskManagement.cpp b/osal/FreeRTOS/TaskManagement.cpp
index 18572045..c0d0067e 100644
--- a/osal/FreeRTOS/TaskManagement.cpp
+++ b/osal/FreeRTOS/TaskManagement.cpp
@@ -22,3 +22,4 @@ size_t TaskManagement::getTaskStackHighWatermark(
         TaskHandle_t task) {
 	return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
 }
+
diff --git a/osal/FreeRTOS/TaskManagement.h b/osal/FreeRTOS/TaskManagement.h
index c6c46f21..b9aece48 100644
--- a/osal/FreeRTOS/TaskManagement.h
+++ b/osal/FreeRTOS/TaskManagement.h
@@ -26,38 +26,37 @@ enum class CallContext {
 };
 
 
-class TaskManagement {
-public:
-	/**
-	 * @brief	In this function, a function dependant on the portmacro.h header
-	 * 			function calls to request a context switch can be specified.
-	 * This can be used if sending to the queue from an ISR caused a task
-	 * to unblock and a context switch is required.
-	 */
-	static void requestContextSwitch(CallContext callContext);
+namespace TaskManagement {
+/**
+ * @brief	In this function, a function dependant on the portmacro.h header
+ * 			function calls to request a context switch can be specified.
+ * This can be used if sending to the queue from an ISR caused a task
+ * to unblock and a context switch is required.
+ */
+void requestContextSwitch(CallContext callContext);
 
-	/**
-	 * If task preemption in FreeRTOS is disabled, a context switch
-	 * can be requested manually by calling this function.
-	 */
-	static void vRequestContextSwitchFromTask(void);
+/**
+ * If task preemption in FreeRTOS is disabled, a context switch
+ * can be requested manually by calling this function.
+ */
+void vRequestContextSwitchFromTask(void);
 
-	/**
-	 * @return The current task handle
-	 */
-	static TaskHandle_t getCurrentTaskHandle();
+/**
+ * @return The current task handle
+ */
+TaskHandle_t getCurrentTaskHandle();
+
+/**
+ * Get returns the minimum amount of remaining stack space in words
+ * that was a available to the task since the task started executing.
+ * Please note that the actual value in bytes depends
+ * on the stack depth type.
+ * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
+ * @return Smallest value of stack remaining since the task was started in
+ * 		   words.
+ */
+size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
 
-	/**
-	 * Get returns the minimum amount of remaining stack space in words
-	 * that was a available to the task since the task started executing.
-	 * Please note that the actual value in bytes depends
-	 * on the stack depth type.
-	 * E.g. on a 32 bit machine, a value of 200 means 800 bytes.
-	 * @return Smallest value of stack remaining since the task was started in
-	 * 		   words.
-	 */
-	static size_t getTaskStackHighWatermark(
-	        TaskHandle_t task = nullptr);
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TASKMANAGEMENT_H_ */

From 052e2ed1e82128356c3cf8260d4d874d47ea53b6 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 14:40:49 +0100
Subject: [PATCH 1070/1292] type update, assert that type is not boolean

---
 globalfunctions/Type.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h
index 8d03c467..d9d2356f 100644
--- a/globalfunctions/Type.h
+++ b/globalfunctions/Type.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include <type_traits>
 
 /**
  * @brief 	Type definition for CCSDS or ECSS.
@@ -56,13 +57,14 @@ private:
 
 template<typename T>
 struct PodTypeConversion {
+	static_assert(not std::is_same<T, bool>::value,
+				"Do not use boolean for the PoolEntry type, use uint8_t "
+				"instead! The ECSS standard defines a boolean as a one bit "
+				"field. Therefore it is preferred to store a boolean as an "
+				"uint8_t");
 	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
 };
 template<>
-struct PodTypeConversion<bool> {
-    static const Type::ActualType_t type = Type::UINT8_T;
-};
-template<>
 struct PodTypeConversion<uint8_t> {
 	static const Type::ActualType_t type = Type::UINT8_T;
 };

From ca52255d300047093bf1939dfafec621b47eec7b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:20:32 +0100
Subject: [PATCH 1071/1292] update

---
 tmtcservices/CommandingServiceBase.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h
index 3611d7c6..e10f2ddd 100644
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@@ -42,7 +42,8 @@ class CommandingServiceBase: public SystemObject,
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	// We could make this configurable via preprocessor and the FSFWConfig file.
-	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = FSFW_CSB_FIFO_DEPTH;
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH =
+			fsfwconfig::FSFW_CSB_FIFO_DEPTH;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 

From 48aef068379cfd9cbb43f2a23481c7853b219b0a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:24:46 +0100
Subject: [PATCH 1072/1292] fsfwconfig update

---
 unittest/testcfg/FSFWConfig.h | 49 +++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 59934560..418992fa 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,36 +1,28 @@
-#ifndef CONFIG_FSFWCONFIG_H_
-#define CONFIG_FSFWCONFIG_H_
+#ifndef FSFWCONFIG_FSFWCONFIG_H_
+#define FSFWCONFIG_FSFWCONFIG_H_
 
-#include <FSFWVersion.h>
+#include <cstddef>
+#include <cstdint>
 
 //! Used to determine whether C++ ostreams are used
 //! Those can lead to code bloat.
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrese code size
+//! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_REDUCED_PRINTOUT		0
+#define FSFW_ENHANCED_PRINTOUT		0
 
-//! Can be used to enable debugging printouts for developing the FSFW
-#define FSFW_DEBUGGING              0
-
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
+//! Can be used to enable additional debugging printouts for developing the FSFW
+#define FSFW_PRINT_VERBOSITY_LEVEL   0
 
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
-#define FSFW_OBJ_EVENT_TRANSLATION	0
+#define FSFW_OBJ_EVENT_TRANSLATION	1
 
-//! If -DDEBUG is supplied in the build defines, there will be
-//! additional output which requires the translation files translateObjects
-//! and translateEvents (and their compiles source files)
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
-#define FSFW_DEBUG_INFO             1
+#define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
@@ -40,5 +32,24 @@
 //! will not be provided. This define should be set to 1 if this is the case.
 #define FSFW_NO_C99_IO 	1
 
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
 
-#endif /* CONFIG_FSFWCONFIG_H_ */
+namespace fsfwconfig {
+//! Default timestamp size. The default timestamp will be an eight byte CDC
+//! short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+}
+
+#endif /* FSFWCONFIG_FSFWCONFIG_H_ */

From 910e6817ef94b6692cde80be3bb3c759a22ff93c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 15:48:06 +0100
Subject: [PATCH 1073/1292] default cfg update

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 7e19235c..334f352a 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -15,23 +15,19 @@
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
-//! Defines the FIFO depth of each commanding service base which
-//! also determines how many commands a CSB service can handle in one cycle
-//! simulataneously. This will increase the required RAM for
-//! each CSB service !
-#define FSFW_CSB_FIFO_DEPTH			6
-
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include <translateObjects.h>
 #include <translateEvents.h>
 #else
+#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
@@ -50,6 +46,12 @@ static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 8;
 static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
 static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
 static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simulataneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From 1f7938f610ca08e35add7264036104d2ecc0280f Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:46:55 +0100
Subject: [PATCH 1074/1292] deleted archive folder

---
 archive/datapoolglob/ControllerSet.cpp        |  14 -
 archive/datapoolglob/ControllerSet.h          |  15 -
 archive/datapoolglob/DataPoolAdmin.cpp        | 301 ------------------
 archive/datapoolglob/DataPoolAdmin.h          |  60 ----
 .../datapoolglob/DataPoolParameterWrapper.cpp | 179 -----------
 .../datapoolglob/DataPoolParameterWrapper.h   |  38 ---
 archive/datapoolglob/GlobalDataPool.cpp       | 133 --------
 archive/datapoolglob/GlobalDataPool.h         | 149 ---------
 archive/datapoolglob/GlobalDataSet.cpp        |  48 ---
 archive/datapoolglob/GlobalDataSet.h          |  98 ------
 archive/datapoolglob/GlobalPoolVariable.h     | 213 -------------
 archive/datapoolglob/GlobalPoolVariable.tpp   | 117 -------
 archive/datapoolglob/GlobalPoolVector.h       | 185 -----------
 archive/datapoolglob/GlobalPoolVector.tpp     | 117 -------
 archive/datapoolglob/PIDReader.h              | 164 ----------
 archive/datapoolglob/PIDReaderList.h          |  27 --
 archive/datapoolglob/PoolRawAccess.cpp        | 239 --------------
 archive/datapoolglob/PoolRawAccess.h          | 220 -------------
 18 files changed, 2317 deletions(-)
 delete mode 100644 archive/datapoolglob/ControllerSet.cpp
 delete mode 100644 archive/datapoolglob/ControllerSet.h
 delete mode 100644 archive/datapoolglob/DataPoolAdmin.cpp
 delete mode 100644 archive/datapoolglob/DataPoolAdmin.h
 delete mode 100644 archive/datapoolglob/DataPoolParameterWrapper.cpp
 delete mode 100644 archive/datapoolglob/DataPoolParameterWrapper.h
 delete mode 100644 archive/datapoolglob/GlobalDataPool.cpp
 delete mode 100644 archive/datapoolglob/GlobalDataPool.h
 delete mode 100644 archive/datapoolglob/GlobalDataSet.cpp
 delete mode 100644 archive/datapoolglob/GlobalDataSet.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVariable.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVariable.tpp
 delete mode 100644 archive/datapoolglob/GlobalPoolVector.h
 delete mode 100644 archive/datapoolglob/GlobalPoolVector.tpp
 delete mode 100644 archive/datapoolglob/PIDReader.h
 delete mode 100644 archive/datapoolglob/PIDReaderList.h
 delete mode 100644 archive/datapoolglob/PoolRawAccess.cpp
 delete mode 100644 archive/datapoolglob/PoolRawAccess.h

diff --git a/archive/datapoolglob/ControllerSet.cpp b/archive/datapoolglob/ControllerSet.cpp
deleted file mode 100644
index 54fc6e8c..00000000
--- a/archive/datapoolglob/ControllerSet.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <fsfw/datapoolglob/ControllerSet.h>
-
-ControllerSet::ControllerSet() {
-
-}
-
-ControllerSet::~ControllerSet() {
-}
-
-void ControllerSet::setInvalid() {
-	read();
-	setToDefault();
-	commit(PoolVariableIF::INVALID);
-}
diff --git a/archive/datapoolglob/ControllerSet.h b/archive/datapoolglob/ControllerSet.h
deleted file mode 100644
index 5da11397..00000000
--- a/archive/datapoolglob/ControllerSet.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-#define FSFW_DATAPOOLGLOB_CONTROLLERSET_H_
-
-#include "../datapoolglob/GlobalDataSet.h"
-
-class ControllerSet :public GlobDataSet {
-public:
-	ControllerSet();
-	virtual ~ControllerSet();
-
-	virtual void setToDefault() = 0;
-	void setInvalid();
-};
-
-#endif /*  FSFW_DATAPOOLGLOB_CONTROLLERSET_H_ */
diff --git a/archive/datapoolglob/DataPoolAdmin.cpp b/archive/datapoolglob/DataPoolAdmin.cpp
deleted file mode 100644
index 2bae75f0..00000000
--- a/archive/datapoolglob/DataPoolAdmin.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#include "DataPoolAdmin.h"
-#include "GlobalDataSet.h"
-#include "GlobalDataPool.h"
-#include "PoolRawAccess.h"
-
-#include "../ipc/CommandMessage.h"
-#include "../ipc/QueueFactory.h"
-#include "../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::getUniqueIdentifierId(
-				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));
-		uint8_t parameterId = HasParametersIF::getUniqueIdentifierId(
-				ParameterMessage::getParameterId(command));
-		uint16_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);
-}
diff --git a/archive/datapoolglob/DataPoolAdmin.h b/archive/datapoolglob/DataPoolAdmin.h
deleted file mode 100644
index d8871b65..00000000
--- a/archive/datapoolglob/DataPoolAdmin.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-#define FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_
-
-#include "DataPoolParameterWrapper.h"
-
-#include "../objectmanager/SystemObject.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../action/HasActionsIF.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../parameters/ReceivesParameterMessagesIF.h"
-#include "../action/SimpleActionHelper.h"
-#include "../memory/MemoryHelper.h"
-
-
-class DataPoolAdmin: public HasActionsIF,
-		public ExecutableObjectIF,
-		public AcceptsMemoryMessagesIF,
-		public HasReturnvaluesIF,
-		public ReceivesParameterMessagesIF,
-		public SystemObject {
-public:
-	static const ActionId_t SET_VALIDITY = 1;
-
-	DataPoolAdmin(object_id_t objectId);
-
-	~DataPoolAdmin();
-
-	ReturnValue_t performOperation(uint8_t opCode);
-
-	MessageQueueId_t getCommandQueue() const;
-
-	ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
-			size_t size, uint8_t** dataPointer);
-	ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
-			uint8_t** dataPointer, uint8_t* copyHere);
-
-	ReturnValue_t executeAction(ActionId_t actionId,
-			MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
-
-	//not implemented as ParameterHelper is no used
-	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex);
-
-	ReturnValue_t initialize();
-private:
-	StorageManagerIF *storage;
-	MessageQueueIF* commandQueue;
-	MemoryHelper memoryHelper;
-	SimpleActionHelper actionHelper;
-	void handleCommand();
-	ReturnValue_t handleParameterCommand(CommandMessage *command);
-	ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
-			const DataPoolParameterWrapper* wrapper);
-	void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
-			Command_t initialCommand);
-};
-
-#endif /* FSFW_DATAPOOLGLOB_DATAPOOLADMIN_H_ */
diff --git a/archive/datapoolglob/DataPoolParameterWrapper.cpp b/archive/datapoolglob/DataPoolParameterWrapper.cpp
deleted file mode 100644
index e5d55006..00000000
--- a/archive/datapoolglob/DataPoolParameterWrapper.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../datapoolglob/DataPoolParameterWrapper.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../parameters/HasParametersIF.h"
-
-
-DataPoolParameterWrapper::DataPoolParameterWrapper() :
-		type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId(
-				PoolVariableIF::NO_PARAMETER) {
-
-}
-
-DataPoolParameterWrapper::~DataPoolParameterWrapper() {
-
-}
-
-ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
-		uint16_t parameterId) {
-	poolId = (domainId << 16) + parameterId;
-
-	GlobDataSet mySet;
-	PoolRawAccess raw(poolId, 0, &mySet, PoolVariableIF::VAR_READ);
-	ReturnValue_t status = mySet.read();
-	if (status != HasReturnvaluesIF::RETURN_OK) {
-		//should only fail for invalid pool id
-		return HasParametersIF::INVALID_IDENTIFIER_ID;
-	}
-
-	type = raw.getType();
-	rows = raw.getArraySize();
-	columns = 1;
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize, Endianness streamEndianness) const {
-	ReturnValue_t result;
-
-	result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	result = SerializeAdapter::serialize(&columns, buffer, size,
-			maxSize, streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
-			streamEndianness);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	for (uint8_t index = 0; index < rows; index++){
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
-		mySet.read();
-		result = raw.serialize(buffer,size,maxSize,streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-//same as ParameterWrapper
-size_t DataPoolParameterWrapper::getSerializedSize() const {
-	size_t serializedSize = 0;
-	serializedSize += type.getSerializedSize();
-	serializedSize += sizeof(rows);
-	serializedSize += sizeof(columns);
-	serializedSize += rows * columns * type.getSize();
-
-	return serializedSize;
-}
-
-ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		size_t* size, Endianness streamEndianness) {
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-template<typename T>
-ReturnValue_t DataPoolParameterWrapper::deSerializeData(uint8_t startingRow,
-		uint8_t startingColumn, const void* from, uint8_t fromRows) {
-	//treat from as a continuous Stream as we copy all of it
-	const uint8_t *fromAsStream = (const uint8_t *) from;
-
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-
-	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
-
-		GlobDataSet mySet;
-		PoolRawAccess raw(poolId, startingRow + fromRow, &mySet,
-				PoolVariableIF::VAR_READ_WRITE);
-		mySet.read();
-
-		result = raw.setEntryFromBigEndian(fromAsStream, sizeof(T));
-
-		fromAsStream += sizeof(T);
-
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		mySet.commit();
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t DataPoolParameterWrapper::copyFrom(const ParameterWrapper* from,
-		uint16_t startWritingAtIndex) {
-	if (poolId == PoolVariableIF::NO_PARAMETER) {
-		return ParameterWrapper::NOT_SET;
-	}
-
-	if (type != from->type) {
-		return ParameterWrapper::DATATYPE_MISSMATCH;
-	}
-
-	//check if from fits into this
-	uint8_t startingRow = startWritingAtIndex / columns;
-	uint8_t startingColumn = startWritingAtIndex % columns;
-
-	if ((from->rows > (rows - startingRow))
-			|| (from->columns > (columns - startingColumn))) {
-		return ParameterWrapper::TOO_BIG;
-	}
-
-	ReturnValue_t result;
-	//copy data
-	if (from->pointsToStream) {
-		switch (type) {
-		case Type::UINT8_T:
-			result = deSerializeData<uint8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT8_T:
-			result = deSerializeData<int8_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT16_T:
-			result = deSerializeData<uint16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT16_T:
-			result = deSerializeData<int16_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::UINT32_T:
-			result = deSerializeData<uint32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::INT32_T:
-			result = deSerializeData<int32_t>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::FLOAT:
-			result = deSerializeData<float>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		case Type::DOUBLE:
-			result = deSerializeData<double>(startingRow, startingColumn,
-					from->readonlyData, from->rows);
-			break;
-		default:
-			result = ParameterWrapper::UNKNOW_DATATYPE;
-			break;
-		}
-	} else {
-		//not supported
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	return result;
-}
diff --git a/archive/datapoolglob/DataPoolParameterWrapper.h b/archive/datapoolglob/DataPoolParameterWrapper.h
deleted file mode 100644
index b1e505a7..00000000
--- a/archive/datapoolglob/DataPoolParameterWrapper.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef DATAPOOLPARAMETERWRAPPER_H_
-#define DATAPOOLPARAMETERWRAPPER_H_
-
-#include "../globalfunctions/Type.h"
-#include "../parameters/ParameterWrapper.h"
-
-class DataPoolParameterWrapper: public SerializeIF {
-public:
-	DataPoolParameterWrapper();
-	virtual ~DataPoolParameterWrapper();
-
-	ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const override;
-
-	virtual size_t getSerializedSize() const override;
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) override;
-
-	ReturnValue_t copyFrom(const ParameterWrapper *from,
-			uint16_t startWritingAtIndex);
-
-private:
-	Type type;
-	uint8_t rows;
-	uint8_t columns;
-
-	uint32_t poolId;
-
-	template<typename T>
-	ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
-			const void *from, uint8_t fromRows);
-
-};
-
-#endif /* DATAPOOLPARAMETERWRAPPER_H_ */
diff --git a/archive/datapoolglob/GlobalDataPool.cpp b/archive/datapoolglob/GlobalDataPool.cpp
deleted file mode 100644
index afb27b77..00000000
--- a/archive/datapoolglob/GlobalDataPool.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/MutexFactory.h"
-
-GlobalDataPool::GlobalDataPool(
-		void(*initFunction)(GlobPoolMap* pool_map)) {
-	mutex = MutexFactory::instance()->createMutex();
-	if (initFunction != NULL ) {
-		initFunction( &this->globDataPool );
-	}
-}
-
-GlobalDataPool::~GlobalDataPool() {
-	MutexFactory::instance()->deleteMutex(mutex);
-	for(GlobPoolMapIter it = this->globDataPool.begin();
-	    it != this->globDataPool.end(); ++it )
-	{
-		delete it->second;
-	}
-}
-
-// The function checks PID, type and array length before returning a copy of
-// the PoolEntry. In failure case, it returns a temp-Entry with size 0 and NULL-ptr.
-template <typename T> PoolEntry<T>* GlobalDataPool::getData( uint32_t data_pool_id,
-		uint8_t sizeOrPosition ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		PoolEntry<T>* entry = dynamic_cast< PoolEntry<T>* >( it->second );
-		if (entry != nullptr ) {
-			if ( sizeOrPosition <= entry->length ) {
-				return entry;
-			}
-		}
-	}
-	return nullptr;
-}
-
-PoolEntryIF* GlobalDataPool::getRawData( uint32_t data_pool_id ) {
-	GlobPoolMapIter it = this->globDataPool.find( data_pool_id );
-	if ( it != this->globDataPool.end() ) {
-		return it->second;
-	} else {
-		return nullptr;
-	}
-}
-
-ReturnValue_t GlobalDataPool::unlockDataPool() {
-	ReturnValue_t status = mutex->unlockMutex();
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: unlock of mutex failed with"
-				" error code: " << status << std::endl;
-	}
-	return status;
-}
-
-ReturnValue_t GlobalDataPool::lockDataPool(uint32_t timeoutMs) {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-	        timeoutMs);
-	if(status != RETURN_OK) {
-		sif::error << "DataPool::DataPool: lock of mutex failed "
-				"with error code: " << status << std::endl;
-	}
-	return status;
-}
-
-void GlobalDataPool::print() {
-	sif::debug << "DataPool contains: " << std::endl;
-	std::map<uint32_t, PoolEntryIF*>::iterator	dataPoolIt;
-	dataPoolIt = this->globDataPool.begin();
-	while( dataPoolIt != this->globDataPool.end() ) {
-		sif::debug << std::hex << dataPoolIt->first << std::dec << " |";
-		dataPoolIt->second->print();
-		dataPoolIt++;
-	}
-}
-
-uint32_t GlobalDataPool::PIDToDataPoolId(uint32_t parameter_id) {
-	return (parameter_id >> 8) & 0x00FFFFFF;
-}
-
-uint8_t GlobalDataPool::PIDToArrayIndex(uint32_t parameter_id) {
-	return (parameter_id & 0x000000FF);
-}
-
-uint32_t GlobalDataPool::poolIdAndPositionToPid(uint32_t poolId, uint8_t index) {
-	return (poolId << 8) + index;
-}
-
-
-//SHOULDDO: Do we need a mutex lock here... I don't think so,
-//as we only check static const values of elements in a list that do not change.
-//there is no guarantee in the standard, but it seems to me that the implementation is safe -UM
-ReturnValue_t GlobalDataPool::getType(uint32_t parameter_id, Type* type) {
-	GlobPoolMapIter it = this->globDataPool.find( PIDToDataPoolId(parameter_id));
-	if ( it != this->globDataPool.end() ) {
-		*type = it->second->getType();
-		return RETURN_OK;
-	} else {
-		*type = Type::UNKNOWN_TYPE;
-		return RETURN_FAILED;
-	}
-}
-
-bool GlobalDataPool::exists(uint32_t parameterId) {
-	uint32_t poolId = PIDToDataPoolId(parameterId);
-	uint32_t index = PIDToArrayIndex(parameterId);
-	GlobPoolMapIter it = this->globDataPool.find( poolId );
-	if (it != globDataPool.end()) {
-		if (it->second->getSize() >= index) {
-			return true;
-		}
-	}
-	return false;
-}
-
-template PoolEntry<uint8_t>* GlobalDataPool::getData<uint8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint16_t>* GlobalDataPool::getData<uint16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint32_t>* GlobalDataPool::getData<uint32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<uint64_t>* GlobalDataPool::getData<uint64_t>(
-		uint32_t data_pool_id, uint8_t size);
-template PoolEntry<int8_t>* GlobalDataPool::getData<int8_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int16_t>* GlobalDataPool::getData<int16_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<int32_t>* GlobalDataPool::getData<int32_t>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<float>* GlobalDataPool::getData<float>(
-		uint32_t data_pool_id, uint8_t size );
-template PoolEntry<double>* GlobalDataPool::getData<double>(
-		uint32_t data_pool_id, uint8_t size);
diff --git a/archive/datapoolglob/GlobalDataPool.h b/archive/datapoolglob/GlobalDataPool.h
deleted file mode 100644
index ce5b132c..00000000
--- a/archive/datapoolglob/GlobalDataPool.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef GLOBALDATAPOOL_H_
-#define GLOBALDATAPOOL_H_
-
-#include "../datapool/PoolEntry.h"
-#include "../globalfunctions/Type.h"
-#include "../ipc/MutexIF.h"
-#include <map>
-
-/**
- * @defgroup data_pool Global data pool
- * This is the group, where all classes associated with global
- * data pool handling belong to.
- * This includes classes to access Data Pool variables.
- */
-
-/**
- * Typedefs for the global pool representations
- */
-using GlobPoolMap = std::map<uint32_t, PoolEntryIF*>;
-using GlobPoolMapIter = GlobPoolMap::iterator;
-
-/**
- * @brief		This class represents the OBSW global data-pool.
- *
- * @details
- * All variables are registered and space is allocated in an initialization
- * function, which is passed do the constructor. Space for the variables is
- * allocated on the heap (with a new call).
- *
- * The data is found by a data pool id, which uniquely represents a variable.
- * Data pool variables should be used with a blackboard logic in mind,
- * which means read data is valid (if flagged so),
- * but not necessarily up-to-date.
- *
- * Variables are either single values or arrays.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobalDataPool : public HasReturnvaluesIF {
-private:
-	/**
-	 * @brief	This is the actual data pool itself.
-	 * @details	It is represented by a map with the data pool id as index
-	 * 			and a pointer to a single PoolEntry as value.
-	 */
-	GlobPoolMap globDataPool;
-
-	/**
-	 * @brief	The mutex is created in the constructor and makes
-	 * 			access mutual exclusive.
-	 * @details	Locking and unlocking the pool is only done by the DataSet class.
-	 */
-	MutexIF*	mutex;
-public:
-	/**
-	 * @brief	In the classes constructor,
-	 * 			the passed initialization function is called.
-	 * @details
-	 * To enable filling the pool, a pointer to the map is passed,
-	 * allowing direct access to the pool's content.
-	 * On runtime, adding or removing variables is forbidden.
-	 */
-	GlobalDataPool( void ( *initFunction )( GlobPoolMap* pool_map ) );
-
-	/**
-	 * 	@brief	The destructor iterates through the data_pool map and
-	 * 			calls all entries destructors to clean up the heap.
-	 */
-	~GlobalDataPool();
-
-	/**
-	 * @brief	This is the default call to access the pool.
-	 * @details
-	 * A pointer to the PoolEntry object is returned.
-	 * The call checks data pool id, type and array size.
-	 * Returns NULL in case of failure.
-	 * @param data_pool_id	The data pool id to search.
-	 * @param sizeOrPosition The array size (not byte size!) of the pool entry,
-	 * or the position the user wants to read.
-	 * 			If smaller than the entry size, everything's ok.
-	 */
-	template <typename T> PoolEntry<T>* getData( uint32_t data_pool_id,
-			uint8_t sizeOrPosition );
-
-	/**
-	 * @brief	An alternative call to get a data pool entry in case the type is not implicitly known
-	 * 			(i.e. in Housekeeping Telemetry).
-	 * @details	It returns a basic interface and does NOT perform
-	 * 			a size check. The caller has to assure he does not copy too much data.
-	 * 			Returns NULL in case the entry is not found.
-	 * @param data_pool_id	The data pool id to search.
-	 */
-	PoolEntryIF* getRawData( uint32_t data_pool_id );
-	/**
-	 * @brief	This is a small helper function to facilitate locking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to acquire the mutex.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs = MutexIF::BLOCKING);
-	/**
-	 * @brief	This is a small helper function to facilitate unlocking the global data pool.
-	 * @details	It fetches the pool's mutex id and tries to free the mutex.
-	 */
-	ReturnValue_t unlockDataPool();
-	/**
-	 * @brief	The print call is a simple debug method.
-	 * @details	It prints the current content of the data pool.
-	 *  		It iterates through the data_pool map and calls each entry's print() method.
-	 */
-	void print();
-	/**
-	 * Extracts the data pool id from a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The data pool id as used within the OBSW.
-	 */
-	static uint32_t PIDToDataPoolId( uint32_t parameter_id );
-	/**
-	 * Extracts an array index out of a SCOS 2000 PID.
-	 * @param parameter_id The passed Parameter ID.
-	 * @return The index of the corresponding data pool entry.
-	 */
-	static uint8_t PIDToArrayIndex( uint32_t parameter_id );
-	/**
-	 * Retransforms a data pool id and an array index to a SCOS 2000 PID.
-	 */
-	static uint32_t poolIdAndPositionToPid( uint32_t poolId, uint8_t index );
-
-	/**
-	 * Method to return the type of a pool variable.
-	 * @param parameter_id A parameterID (not pool id) of a DP member.
-	 * @param type Returns the type or TYPE::UNKNOWN_TYPE
-	 * @return RETURN_OK if parameter exists, RETURN_FAILED else.
-	 */
-	ReturnValue_t getType( uint32_t parameter_id, Type* type );
-
-	/**
-	 * Method to check if a PID exists. Does not lock, as there's no
-	 * possibility to alter the list that is checked during run-time.
-	 * @param parameterId The PID (not pool id!) of a parameter.
-	 * @return	true if exists, false else.
-	 */
-	bool exists(uint32_t parameterId);
-};
-
-//We assume someone globally instantiates a DataPool.
-namespace glob {
-extern GlobalDataPool dataPool;
-}
-
-#endif /* DATAPOOL_H_ */
diff --git a/archive/datapoolglob/GlobalDataSet.cpp b/archive/datapoolglob/GlobalDataSet.cpp
deleted file mode 100644
index 1e99f805..00000000
--- a/archive/datapoolglob/GlobalDataSet.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/GlobalDataSet.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-GlobDataSet::GlobDataSet(): PoolDataSetBase(
-        reinterpret_cast<PoolVariableIF**>(&registeredVariables),
-        DATA_SET_MAX_SIZE) {}
-
-// Don't do anything with your variables, they are dead already!
-// (Destructor is already called)
-GlobDataSet::~GlobDataSet() {}
-
-ReturnValue_t GlobDataSet::commit(bool valid, uint32_t lockTimeout) {
-	setEntriesValid(valid);
-	setSetValid(valid);
-	return commit(lockTimeout);
-}
-
-ReturnValue_t GlobDataSet::commit(uint32_t lockTimeout) {
-	return PoolDataSetBase::commit(lockTimeout);
-}
-
-bool GlobDataSet::isValid() const {
-    return this->valid;
-}
-
-ReturnValue_t GlobDataSet::unlockDataPool() {
-	return glob::dataPool.unlockDataPool();
-}
-
-ReturnValue_t GlobDataSet::lockDataPool(uint32_t timeoutMs) {
-	return glob::dataPool.lockDataPool(timeoutMs);
-}
-
-void GlobDataSet::setEntriesValid(bool valid) {
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ) {
-			registeredVariables[count]->setValid(valid);
-		}
-	}
-}
-
-void GlobDataSet::setSetValid(bool valid) {
-	this->valid = valid;
-}
-
-
diff --git a/archive/datapoolglob/GlobalDataSet.h b/archive/datapoolglob/GlobalDataSet.h
deleted file mode 100644
index 2f0edbd5..00000000
--- a/archive/datapoolglob/GlobalDataSet.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-#define FRAMEWORK_DATAPOOLGLOB_DATASET_H_
-
-#include "../datapool/PoolDataSetBase.h"
-
-/**
- * @brief	The DataSet class manages a set of locally checked out variables
- * 			for the global data pool.
- * @details
- * This class uses the read-commit() semantic provided by the DataSetBase class.
- * It extends the base class by using the global data pool,
- * having a valid state and implementing lock und unlock calls for the global
- * datapool.
- *
- * For more information on how this class works, see the DataSetBase
- * documentation.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class GlobDataSet: public PoolDataSetBase {
-public:
-
-	/**
-	 * @brief	Creates an empty GlobDataSet. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	GlobDataSet();
-
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~GlobDataSet();
-
-	/**
-	 * Variant of method above which sets validity of all elements of the set.
-	 * @param valid Validity information from PoolVariableIF.
-	 * @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
-	 */
-	ReturnValue_t commit(bool valid, uint32_t lockTimeout = MutexIF::BLOCKING);
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-	/**
-	 * Set all entries
-	 * @param valid
-	 */
-	void setSetValid(bool valid);
-
-	bool isValid() const override;
-
-	/**
-	 * Set the valid information of all variables contained in the set which
-	 * are not read-only
-	 *
-	 * @param valid Validity information from PoolVariableIF.
-	 */
-	void setEntriesValid(bool valid);
-
-	//!< This definition sets the maximum number of variables to
-	//! register in one DataSet.
-	static const uint8_t DATA_SET_MAX_SIZE = 63;
-
-private:
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
-
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
-
-	void handleAlreadyReadDatasetCommit();
-	ReturnValue_t handleUnreadDatasetCommit();
-
-	PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
-};
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_DATASET_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVariable.h b/archive/datapoolglob/GlobalPoolVariable.h
deleted file mode 100644
index a995bfaf..00000000
--- a/archive/datapoolglob/GlobalPoolVariable.h
+++ /dev/null
@@ -1,213 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_H_
-#define GLOBALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename T, uint8_t n_var> class PoolVarList;
-
-
-/**
- * @brief	This is the access class for non-array data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly
- * on the data pool entries, but on local copies. This class provides simple
- * type-safe access to single data pool entries (i.e. entries with length = 1).
- * The class can be instantiated as read-write and read only.
- * It provides a commit-and-roll-back semantic, which means that the
- * variable's value in the data pool is not changed until the
- * commit call is executed.
- * 	@tparam	T The template parameter sets the type of the variable.
- * 	Currently, all plain data types are supported, but in principle
- * 	any type is possible.
- *	@ingroup data_pool
- */
-template<typename T>
-class GlobPoolVar: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PoolVarList;
-	static_assert(not std::is_same<T, bool>::value,
-			"Do not use boolean for the PoolEntry type, use uint8_t instead!"
-			"There is no boolean type in CCSDS.");
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if nullptr is not passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but
-	 * sets the value attribute to default (0).
-	 * The value is fetched within the read() operation.
-	 * @param set_id	This is the id in the global data pool
-	 * 					this instance of the access class corresponds to.
-	 * @param dataSet	The data set in which the variable shall register
-	 * 					itself. If NULL, the variable is not registered.
-	 * @param setWritable If this flag is set to true, changes in the value
-	 * 			attribute can be written back to the data pool, otherwise not.
-	 */
-	GlobPoolVar(uint32_t set_id, DataSetIF* dataSet,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
-
-	/**
-	 * @brief 	Copy ctor to copy classes containing Pool Variables.
-	 * 			(Robin): This only copies member variables, which is done
-	 * 			by the default copy ctor. maybe we can ommit this ctor?
-	 */
-	GlobPoolVar(const GlobPoolVar& rhs);
-
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVar() {}
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * The commit call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool is stored.
-	 */
-	uint32_t dataPoolId;
-
-	/**
-	 * @brief	The valid information as it was stored in the data pool is
-	 * 			copied to this attribute.
-	 */
-	uint8_t valid;
-
-	/**
-	 * @brief	The information whether the class is read-write or read-only
-	 * 			is stored here.
-	 */
-	pool_rwm_t readWriteMode;
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	GlobPoolVar();
-public:
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const override;
-
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const override;
-	/**
-	 * This operation sets the data pool id of the variable.
-	 * The method is necessary to set id's of data pool member variables with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId);
-
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const override;
-
-	uint8_t getValid();
-
-	void setValid(bool valid) override;
-
-	operator T() {
-		return value;
-	}
-
-	operator T() const {
-		return value;
-	}
-
-	GlobPoolVar<T> &operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	GlobPoolVar<T> &operator=(GlobPoolVar<T> newPoolVariable) {
-		value = newPoolVariable.value;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size,
-			SerializeIF::Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, max_size,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-		        streamEndianness);
-	}
-};
-
-#include "../datapoolglob/GlobalPoolVariable.tpp"
-
-typedef GlobPoolVar<uint8_t> gp_bool_t;
-typedef GlobPoolVar<uint8_t> gp_uint8_t;
-typedef GlobPoolVar<uint16_t> gp_uint16_t;
-typedef GlobPoolVar<uint32_t> gp_uint32_t;
-typedef GlobPoolVar<int8_t> gp_int8_t;
-typedef GlobPoolVar<int16_t> gp_int16_t;
-typedef GlobPoolVar<int32_t> gp_int32_t;
-typedef GlobPoolVar<float> gp_float_t;
-typedef GlobPoolVar<double> gp_double_t;
-
-#endif /* POOLVARIABLE_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVariable.tpp b/archive/datapoolglob/GlobalPoolVariable.tpp
deleted file mode 100644
index d61d605d..00000000
--- a/archive/datapoolglob/GlobalPoolVariable.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef GLOBALPOOLVARIABLE_TPP_
-#define GLOBALPOOLVARIABLE_TPP_
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(uint32_t set_id,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode):
-		dataPoolId(set_id), valid(PoolVariableIF::INVALID),
-		readWriteMode(setReadWriteMode)
-{
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T>
-inline ReturnValue_t GlobPoolVar<T>::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(dataPoolId, 1);
-	if (read_out != NULL) {
-		valid = read_out->valid;
-		value = *(read_out->address);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		value = 0;
-		valid = false;
-		sif::error << "PoolVariable: read of DP Variable 0x" << std::hex
-				<< dataPoolId << std::dec << " failed." << std::endl;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline ReturnValue_t GlobPoolVar<T>::commitWithoutLock() {
-	PoolEntry<T>* write_back = glob::dataPool.getData<T>(dataPoolId, 1);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->valid = valid;
-		*(write_back->address) = value;
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar():
-		dataPoolId(PoolVariableIF::NO_PARAMETER),
-		valid(PoolVariableIF::INVALID),
-		readWriteMode(VAR_READ), value(0) {}
-
-template <class T>
-inline GlobPoolVar<T>::GlobPoolVar(const GlobPoolVar& rhs) :
-		dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
-		rhs.readWriteMode), value(rhs.value) {}
-
-template <class T>
-inline pool_rwm_t GlobPoolVar<T>::getReadWriteMode() const  {
-	return readWriteMode;
-}
-
-template <class T>
-inline uint32_t GlobPoolVar<T>::getDataPoolId() const {
-	return dataPoolId;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setDataPoolId(uint32_t poolId) {
-	dataPoolId = poolId;
-}
-
-template <class T>
-inline bool GlobPoolVar<T>::isValid() const {
-	if (valid)
-		return true;
-	else
-		return false;
-}
-
-template <class T>
-inline uint8_t GlobPoolVar<T>::getValid() {
-	return valid;
-}
-
-template <class T>
-inline void GlobPoolVar<T>::setValid(bool valid) {
-	this->valid = valid;
-}
-
-#endif
diff --git a/archive/datapoolglob/GlobalPoolVector.h b/archive/datapoolglob/GlobalPoolVector.h
deleted file mode 100644
index 0f5daacd..00000000
--- a/archive/datapoolglob/GlobalPoolVector.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-/**
- * @brief	This is the access class for array-type data pool entries.
- *
- * @details
- * To ensure safe usage of the data pool, operation is not done directly on the
- * data pool entries, but on local copies. This class provides simple type-
- * and length-safe access to vector-style data pool entries (i.e. entries with
- * length > 1). The class can be instantiated as read-write and read only.
- *
- * It provides a commit-and-roll-back semantic, which means that no array
- * entry in the data pool is changed until the commit call is executed.
- * There are two template parameters:
- * @tparam	T
- * This template parameter specifies the data type of an array entry. Currently,
- * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
- * This template parameter specifies the vector size of this entry. Using a
- * template parameter for this is not perfect, but avoids
- * dynamic memory allocation.
- * @ingroup data_pool
- */
-template<typename T, uint16_t vectorSize>
-class GlobPoolVector: public PoolVariableIF {
-public:
-	/**
-	 * @brief	In the constructor, the variable can register itself in a
-	 * 			DataSet (if no nullptr is passed).
-	 * @details
-	 * It DOES NOT fetch the current value from the data pool, but sets the
-	 * value attribute to default (0). The value is fetched within the
-	 * read() operation.
-	 * @param set_id
-	 * This is the id in the global data pool this instance of the access
-	 * class corresponds to.
-	 * @param dataSet
-	 * The data set in which the variable shall register itself. If nullptr,
-	 * the variable is not registered.
-	 * @param setWritable
-	 * If this flag is set to true, changes in the value attribute can be
-	 * written back to the data pool, otherwise not.
-	 */
-	GlobPoolVector(uint32_t set_id, DataSetIF* set,
-			ReadWriteMode_t setReadWriteMode);
-
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a local array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~GlobPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return dataPoolId;
-	}
-	/**
-	 * @brief This operation sets the data pool id of the variable.
-	 * @details
-	 * The method is necessary to set id's of data pool member variables
-	 * with bad initialization.
-	 */
-	void setDataPoolId(uint32_t poolId) {
-		dataPoolId = poolId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return readWriteMode;
-	}
-
-
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid != INVALID)
-			return true;
-		else
-			return false;
-	}
-	void setValid(bool valid) {this->valid = valid;}
-	uint8_t getValid() {return valid;}
-
-	T &operator [](int i) {return value[i];}
-	const T &operator [](int i) const {return value[i];}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t max_size, Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        Endianness streamEndianness) override;
-
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies all array values
-	 * and the valid information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The commit call is protected by a lock of the global data pool.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls,
-	 * 			the data pool id is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The valid information as it was stored in the data pool
-	 * 			is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	The information whether the class is read-write or
-	 * 			read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#include "../datapoolglob/GlobalPoolVector.tpp"
-
-template<typename T, uint16_t vectorSize>
-using gp_vec_t = GlobPoolVector<T, vectorSize>;
-
-#endif /* FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_H_ */
diff --git a/archive/datapoolglob/GlobalPoolVector.tpp b/archive/datapoolglob/GlobalPoolVector.tpp
deleted file mode 100644
index 013a682a..00000000
--- a/archive/datapoolglob/GlobalPoolVector.tpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-#define FSFW_DATAPOOLGLOB_GLOBALPOOLVECTOR_TPP_
-
-
-template<typename T, uint16_t vectorSize>
-inline GlobPoolVector<T, vectorSize>::GlobPoolVector(uint32_t set_id,
-		DataSetIF* set, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), valid(false), readWriteMode(setReadWriteMode) {
-	memset(this->value, 0, vectorSize * sizeof(T));
-	if (set != nullptr) {
-		set->registerVariable(this);
-	}
-}
-
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::readWithoutLock() {
-	PoolEntry<T>* read_out = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if (read_out != nullptr) {
-		this->valid = read_out->valid;
-		memcpy(this->value, read_out->address, read_out->getByteSize());
-
-		return HasReturnvaluesIF::RETURN_OK;
-
-	} else {
-		memset(this->value, 0, vectorSize * sizeof(T));
-		sif::error << "PoolVector: Read of DP Variable 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << dataPoolId <<
-				std::dec << " failed." << std::endl;
-		this->valid = INVALID;
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
-	PoolEntry<T>* writeBack = glob::dataPool.getData<T>(this->dataPoolId,
-			vectorSize);
-	if ((writeBack != nullptr) && (this->readWriteMode != VAR_READ)) {
-		writeBack->valid = valid;
-		memcpy(writeBack->address, this->value, writeBack->getByteSize());
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t max_size,
-		SerializeIF::Endianness streamEndianness) const {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				max_size, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-template<typename T, uint16_t vectorSize>
-inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size,
-		SerializeIF::Endianness streamEndianness) {
-	uint16_t i;
-	ReturnValue_t result;
-	for (i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-#endif
diff --git a/archive/datapoolglob/PIDReader.h b/archive/datapoolglob/PIDReader.h
deleted file mode 100644
index 9431e1d4..00000000
--- a/archive/datapoolglob/PIDReader.h
+++ /dev/null
@@ -1,164 +0,0 @@
-#ifndef PIDREADER_H_
-#define PIDREADER_H_
-#include "../datapool/DataSetIF.h"
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-template<typename U, uint8_t n_var> class PIDReaderList;
-
-template<typename T>
-class PIDReader: public PoolVariableIF {
-	template<typename U, uint8_t n_var> friend class PIDReaderList;
-protected:
-	uint32_t parameterId;
-	uint8_t valid;
-	ReturnValue_t readWithoutLock() {
-		uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
-		PoolEntry<T> *read_out = glob::dataPool.getData<T>(
-				GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
-		if (read_out != NULL) {
-			valid = read_out->valid;
-			value = read_out->address[arrayIndex];
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			value = 0;
-			valid = false;
-			sif::error << "PIDReader: read of PID 0x" << std::hex << parameterId
-					<< std::dec << " failed." << std::endl;
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	/**
-	 * Never commit, is read-only.
-	 * Reason is the possibility to access a single DP vector element, but if we commit,
-	 * we set validity of the whole vector.
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t commitWithoutLock() override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	/**
-	 * Empty ctor for List initialization
-	 */
-	PIDReader() :
-			parameterId(PoolVariableIF::NO_PARAMETER), valid(
-					PoolVariableIF::INVALID), value(0) {
-
-	}
-public:
-	/**
-	 * \brief	This is the local copy of the data pool entry.
-	 */
-	T value;
-	/**
-	 * \brief	In the constructor, the variable can register itself in a DataSet (if not NULL is
-	 * 			passed).
-	 * \details	It DOES NOT fetch the current value from the data pool, but sets the value
-	 * 			attribute to default (0). The value is fetched within the read() operation.
-	 * \param set_id	This is the id in the global data pool this instance of the access class
-	 * 					corresponds to.
-	 * \param dataSet	The data set in which the variable shall register itself. If NULL,
-	 * 					the variable is not registered.
-	 * \param setWritable If this flag is set to true, changes in the value attribute can be
-	 * 					written back to the data pool, otherwise not.
-	 */
-	PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
-			parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
-					0) {
-		if (dataSet != NULL) {
-			dataSet->registerVariable(this);
-		}
-	}
-
-	ReturnValue_t read(uint32_t lockTimeout) override {
-		ReturnValue_t result = glob::dataPool.lockDataPool();
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = readWithoutLock();
-		ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-		if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-			sif::error << "PIDReader::read: Could not unlock data pool!"
-					<< std::endl;
-		}
-		return result;
-	}
-	/**
-	 * Copy ctor to copy classes containing Pool Variables.
-	 */
-	PIDReader(const PIDReader &rhs) :
-			parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
-	}
-
-	/**
-	 * \brief	The classes destructor is empty.
-	 */
-	~PIDReader() {
-
-	}
-	/**
-	 * \brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const {
-		return GlobalDataPool::PIDToDataPoolId(parameterId);
-	}
-	uint32_t getParameterId() const {
-		return parameterId;
-	}
-	/**
-	 * This method returns if the variable is write-only, read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const {
-		return VAR_READ;
-	}
-	/**
-	 * \brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const {
-		if (valid)
-			return true;
-		else
-			return false;
-	}
-
-	uint8_t getValid() {
-		return valid;
-	}
-
-	void setValid(bool valid) {
-		this->valid = valid;
-	}
-
-	operator T() {
-		return value;
-	}
-
-	PIDReader<T>& operator=(T newValue) {
-		value = newValue;
-		return *this;
-	}
-
-	virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-			size_t maxSize, Endianness streamEndianness) const override {
-		return SerializeAdapter::serialize(&value, buffer, size, maxSize,
-				streamEndianness);
-	}
-
-	virtual size_t getSerializedSize() const override {
-		return SerializeAdapter::getSerializedSize(&value);
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-			Endianness streamEndianness) override {
-		return SerializeAdapter::deSerialize(&value, buffer, size,
-				streamEndianness);
-	}
-};
-
-#endif /* PIDREADER_H_ */
diff --git a/archive/datapoolglob/PIDReaderList.h b/archive/datapoolglob/PIDReaderList.h
deleted file mode 100644
index ae99f3aa..00000000
--- a/archive/datapoolglob/PIDReaderList.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-#define FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_
-
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoolglob/PIDReader.h"
-template <class T, uint8_t n_var>
-class PIDReaderList {
-private:
-	PIDReader<T> variables[n_var];
-public:
-	PIDReaderList( const uint32_t setPid[n_var], DataSetIF* dataSet) {
-		//I really should have a look at the new init list c++ syntax.
-		if (dataSet == NULL) {
-			return;
-		}
-		for (uint8_t count = 0; count < n_var; count++) {
-			variables[count].parameterId = setPid[count];
-			dataSet->registerVariable(&variables[count]);
-		}
-	}
-
-	PIDReader<T> &operator [](int i) { return variables[i]; }
-};
-
-
-
-#endif /* FRAMEWORK_DATAPOOLGLOB_PIDREADERLIST_H_ */
diff --git a/archive/datapoolglob/PoolRawAccess.cpp b/archive/datapoolglob/PoolRawAccess.cpp
deleted file mode 100644
index 53706c6d..00000000
--- a/archive/datapoolglob/PoolRawAccess.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#include "../datapoolglob/GlobalDataPool.h"
-#include "../datapoolglob/PoolRawAccess.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../serialize/EndianConverter.h"
-
-#include <cstring>
-
-PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
-		DataSetIF* dataSet, ReadWriteMode_t setReadWriteMode) :
-		dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false),
-		type(Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0),
-		readWriteMode(setReadWriteMode) {
-	memset(value, 0, sizeof(value));
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
-}
-
-PoolRawAccess::~PoolRawAccess() {}
-
-ReturnValue_t PoolRawAccess::read(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = readWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::readWithoutLock() {
-	ReturnValue_t result = RETURN_FAILED;
-	PoolEntryIF* readOut = glob::dataPool.getRawData(dataPoolId);
-	if (readOut != nullptr) {
-		result = handleReadOut(readOut);
-		if(result == RETURN_OK) {
-			return result;
-		}
-	} else {
-		result = READ_ENTRY_NON_EXISTENT;
-	}
-	handleReadError(result);
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::handleReadOut(PoolEntryIF* readOut) {
-	ReturnValue_t result = RETURN_FAILED;
-	valid = readOut->getValid();
-	if (readOut->getSize() > arrayEntry) {
-		arraySize = readOut->getSize();
-		typeSize = readOut->getByteSize() / readOut->getSize();
-		type = readOut->getType();
-		if (typeSize <= sizeof(value)) {
-			uint16_t arrayPosition = arrayEntry * typeSize;
-			sizeTillEnd = readOut->getByteSize() - arrayPosition;
-			uint8_t* ptr = &((uint8_t*) readOut->getRawData())[arrayPosition];
-			memcpy(value, ptr, typeSize);
-			return RETURN_OK;
-		} else {
-			result = READ_TYPE_TOO_LARGE;
-		}
-	} else {
-		//debug << "PoolRawAccess: Size: " << (int)read_out->getSize() << std::endl;
-		result = READ_INDEX_TOO_LARGE;
-	}
-	return result;
-}
-
-void PoolRawAccess::handleReadError(ReturnValue_t result) {
-	sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId
-			<< std::dec << " failed, ";
-	if(result == READ_TYPE_TOO_LARGE) {
-		sif::error << "type too large." << std::endl;
-	}
-	else if(result == READ_INDEX_TOO_LARGE) {
-		sif::error << "index too large." << std::endl;
-	}
-	else if(result == READ_ENTRY_NON_EXISTENT) {
-		sif::error << "entry does not exist." << std::endl;
-	}
-
-	valid = INVALID;
-	typeSize = 0;
-	sizeTillEnd = 0;
-	memset(value, 0, sizeof(value));
-}
-
-ReturnValue_t PoolRawAccess::commit(uint32_t lockTimeout) {
-	ReturnValue_t result = glob::dataPool.lockDataPool(lockTimeout);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = commitWithoutLock();
-	ReturnValue_t unlockResult = glob::dataPool.unlockDataPool();
-	if(unlockResult != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "GlobPoolVar::read: Could not unlock global data pool"
-				<< std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t PoolRawAccess::commitWithoutLock() {
-	PoolEntryIF* write_back = glob::dataPool.getRawData(dataPoolId);
-	if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
-		write_back->setValid(valid);
-		uint8_t array_position = arrayEntry * typeSize;
-		uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position];
-		memcpy(ptr, value, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t* PoolRawAccess::getEntry() {
-	return value;
-}
-
-ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
-		size_t* writtenBytes, size_t max_size) {
-	uint8_t* data_ptr = getEntry();
-	// debug << "PoolRawAccess::getEntry: Array position: " <<
-	// 	      index * size_of_type << " Size of T: " << (int)size_of_type <<
-	//		  " ByteSize: " << byte_size << " Position: " << *size << std::endl;
-	if (typeSize == 0)
-		return DATA_POOL_ACCESS_FAILED;
-	if (typeSize > max_size)
-		return INCORRECT_SIZE;
-	EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
-	*writtenBytes = typeSize;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
-        size_t maxSize, Endianness streamEndianness) const {
-    if (typeSize + *size <= maxSize) {
-    	switch(streamEndianness) {
-    	case(Endianness::BIG):
-    		EndianConverter::convertBigEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(*buffer, value, typeSize);
-    		break;
-    	case(Endianness::MACHINE):
-    	default:
-            memcpy(*buffer, value, typeSize);
-            break;
-        }
-        *size += typeSize;
-        (*buffer) += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    } else {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-}
-
-
-Type PoolRawAccess::getType() {
-	return type;
-}
-
-size_t PoolRawAccess::getSizeOfType() {
-	return typeSize;
-}
-
-size_t PoolRawAccess::getArraySize(){
-	return arraySize;
-}
-
-uint32_t PoolRawAccess::getDataPoolId() const {
-	return dataPoolId;
-}
-
-PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
-	return readWriteMode;
-}
-
-ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
-		size_t setSize) {
-	if (typeSize == setSize) {
-		EndianConverter::convertBigEndian(value, buffer, typeSize);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
-				"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
-				<< std::endl;
-		return INCORRECT_SIZE;
-	}
-}
-
-bool PoolRawAccess::isValid() const {
-	if (valid != INVALID)
-		return true;
-	else
-		return false;
-}
-
-void PoolRawAccess::setValid(bool valid) {
-	this->valid = valid;
-}
-
-size_t PoolRawAccess::getSizeTillEnd() const {
-	return sizeTillEnd;
-}
-
-
-size_t PoolRawAccess::getSerializedSize() const {
-	return typeSize;
-}
-
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
-        Endianness streamEndianness) {
-
-    if (*size >= typeSize) {
-        switch(streamEndianness) {
-        case(Endianness::BIG):
-			EndianConverter::convertBigEndian(value, *buffer, typeSize);
-		    break;
-        case(Endianness::LITTLE):
-			EndianConverter::convertLittleEndian(value, *buffer, typeSize);
-		   	break;
-        case(Endianness::MACHINE):
-        default:
-            memcpy(value, *buffer, typeSize);
-            break;
-        }
-    	*size -= typeSize;
-        *buffer += typeSize;
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-    	return SerializeIF::STREAM_TOO_SHORT;
-    }
-}
diff --git a/archive/datapoolglob/PoolRawAccess.h b/archive/datapoolglob/PoolRawAccess.h
deleted file mode 100644
index 15643a41..00000000
--- a/archive/datapoolglob/PoolRawAccess.h
+++ /dev/null
@@ -1,220 +0,0 @@
-#ifndef POOLRAWACCESS_H_
-#define POOLRAWACCESS_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntryIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../globalfunctions/Type.h"
-
-/**
- * @brief This class allows accessing Data Pool variables as raw bytes.
- * @details
- * This is necessary to have an access method for HK data, as the PID's alone
- * do not provide type information. Please note that the the raw pool access
- * read() and commit() calls are not thread-safe.
- *
- * Please supply a data set and use the data set read(), commit() calls for
- * thread-safe data pool access.
- * @ingroup data_pool
- */
-class PoolRawAccess: public PoolVariableIF, HasReturnvaluesIF {
-public:
-	/**
-	 * This constructor is used to access a data pool entry with a
-	 * given ID if the target type is not known. A DataSet object is supplied
-	 * and the data pool entry with the given ID is registered to that data set.
-	 * Please note that a pool raw access buffer only has a buffer
-	 * with a size of double. As such, for vector entries which have
-	 * @param data_pool_id Target data pool entry ID
-	 * @param arrayEntry
-	 * @param data_set Dataset to register data pool entry to
-	 * @param setReadWriteMode
-	 * @param registerVectors If set to true, the constructor checks if
-	 *                        there are multiple vector entries to registers
-	 *                        and registers all of them recursively into the data_set
-	 *
-	 */
-	PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
-			DataSetIF* data_set, ReadWriteMode_t setReadWriteMode =
-					PoolVariableIF::VAR_READ);
-
-	/**
-	 * @brief	This operation returns a pointer to the entry fetched.
-	 * @details	Return pointer to the buffer containing the raw data
-	 *          Size and number of data can be retrieved by other means.
-	 */
-	uint8_t* getEntry();
-	/**
-	 * @brief 	This operation returns the fetched entry from the data pool and
-	 * 			flips the bytes, if necessary.
-	 * @details	It makes use of the getEntry call of this function, but additionally flips the
-	 * 			bytes to big endian, which is the default for external communication (as House-
-	 * 			keeping telemetry). To achieve this, the data is copied directly to the passed
-	 * 			buffer, if it fits in the given max_size.
-	 * @param buffer	A pointer to a buffer to write to
-	 * @param writtenBytes	The number of bytes written is returned with this value.
-	 * @param max_size	The maximum size that the function may write to buffer.
-	 * @return	- @c RETURN_OK if entry could be acquired
-	 * 			- @c RETURN_FAILED else.
-	 */
-	ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
-			size_t maxSize);
-
-	/**
-	 * @brief 	Serialize raw pool entry into provided buffer directly
-	 * @param buffer Provided buffer. Raw pool data will be copied here
-	 * @param size [out] Increment provided size value by serialized size
-	 * @param max_size Maximum allowed serialization size
-	 * @param bigEndian Specify endianess
-	 * @return - @c RETURN_OK if serialization was successfull
-	 *         - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
-	 */
-	ReturnValue_t serialize(uint8_t **buffer, size_t *size,
-	        size_t maxSize, Endianness streamEndianness) const override;
-
-    size_t getSerializedSize() const override;
-
-    ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-            Endianness streamEndianness) override;
-
-	/**
-	 * With this method, the content can be set from a big endian buffer safely.
-	 * @param buffer	Pointer to the data to set
-	 * @param size		Size of the data to write. Must fit this->size.
-	 * @return	- @c RETURN_OK on success
-	 * 			- @c RETURN_FAILED on failure
-	 */
-	ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
-			size_t setSize);
-	/**
-	 *  @brief This operation returns the type of the entry currently stored.
-	 */
-	Type getType();
-	/**
-	 *  @brief This operation returns the size of the entry currently stored.
-	 */
-	size_t getSizeOfType();
-	/**
-	 *
-	 * @return the size of the datapool array
-	 */
-	size_t getArraySize();
-	/**
-	 * @brief	This operation returns the data pool id of the variable.
-	 */
-	uint32_t getDataPoolId() const;
-
-	static const uint8_t INTERFACE_ID = CLASS_ID::POOL_RAW_ACCESS_CLASS;
-	static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t READ_TYPE_TOO_LARGE = MAKE_RETURN_CODE(0x03);
-	static const ReturnValue_t READ_INDEX_TOO_LARGE = MAKE_RETURN_CODE(0x04);
-	static const ReturnValue_t READ_ENTRY_NON_EXISTENT =  MAKE_RETURN_CODE(0x05);
-	static const uint8_t RAW_MAX_SIZE = sizeof(double);
-	uint8_t value[RAW_MAX_SIZE];
-
-
-	/**
-	 * @brief	The classes destructor is empty. If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~PoolRawAccess();
-
-	/**
-	 * This method returns if the variable is read-write or read-only.
-	 */
-	ReadWriteMode_t getReadWriteMode() const;
-	/**
-	 * @brief	With this call, the valid information of the variable is returned.
-	 */
-	bool isValid() const;
-
-	void setValid(bool valid);
-	/**
-	 * Getter for the remaining size.
-	 */
-	size_t getSizeTillEnd() const;
-
-	/**
-	 * @brief	This is a call to read the value from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the global data pool and copies the value and the valid
-	 * information to its local attributes. In case of a failure (wrong type or
-	 * pool id not found), the variable is set to zero and invalid.
-	 * The call is protected by a lock of the global data pool.
-	 * @return -@c RETURN_OK Read successfull
-	 * 		   -@c READ_TYPE_TOO_LARGE
-	 * 		   -@c READ_INDEX_TOO_LARGE
-	 * 		   -@c READ_ENTRY_NON_EXISTENT
-	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-	/**
-	 * @brief	The commit call writes back the variable's value to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the valid flag is automatically set to "valid".
-	 * The call is protected by a lock of the global data pool.
-	 *
-	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
-
-protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
-
-	ReturnValue_t handleReadOut(PoolEntryIF* read_out);
-	void handleReadError(ReturnValue_t result);
-private:
-	/**
-	 * @brief	To access the correct data pool entry on read and commit calls, the data pool id
-	 * 			is stored.
-	 */
-	uint32_t dataPoolId;
-	/**
-	 * @brief	The array entry that is fetched from the data pool.
-	 */
-	uint8_t arrayEntry;
-	/**
-	 * @brief	The valid information as it was stored in the data pool is copied to this attribute.
-	 */
-	uint8_t valid;
-	/**
-	 * @brief	This value contains the type of the data pool entry.
-	 */
-	Type type;
-	/**
-	 * @brief	This value contains the size of the data pool entry type in bytes.
-	 */
-	size_t typeSize;
-	/**
-	 * The size of the DP array (single values return 1)
-	 */
-	size_t arraySize;
-	/**
-	 * The size (in bytes) from the selected entry till the end of this DataPool variable.
-	 */
-	size_t sizeTillEnd;
-	/**
-	 * @brief	The information whether the class is read-write or read-only is stored here.
-	 */
-	ReadWriteMode_t readWriteMode;
-};
-
-#endif /* POOLRAWACCESS_H_ */

From f99bf6d75c51d84d49f8bbc3ca6d2c736cac06fd Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:51:30 +0100
Subject: [PATCH 1075/1292] taken over cmake list for storagemanager

---
 storagemanager/CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 storagemanager/CMakeLists.txt

diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
new file mode 100644
index 00000000..57c92195
--- /dev/null
+++ b/storagemanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ConstStorageAccessor.cpp
+		StorageAccessor.cpp
+)
\ No newline at end of file

From 8706d663d5121b56277a1f17ca40384087e20189 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 15 Dec 2020 22:57:14 +0100
Subject: [PATCH 1076/1292] upstream changes taken over

---
 devicehandlers/CMakeLists.txt      | 11 +++++++++++
 devicehandlers/DeviceHandlerBase.h |  1 +
 devicehandlers/DeviceHandlerIF.h   | 10 +++++-----
 3 files changed, 17 insertions(+), 5 deletions(-)
 create mode 100644 devicehandlers/CMakeLists.txt

diff --git a/devicehandlers/CMakeLists.txt b/devicehandlers/CMakeLists.txt
new file mode 100644
index 00000000..50c1008f
--- /dev/null
+++ b/devicehandlers/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AssemblyBase.cpp
+		ChildHandlerBase.cpp
+		ChildHandlerFDIR.cpp
+		DeviceHandlerBase.cpp
+		DeviceHandlerFailureIsolation.cpp
+		DeviceHandlerMessage.cpp
+		DeviceTmReportingWrapper.cpp
+		HealthDevice.cpp
+)
\ No newline at end of file
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 2bfa62a6..9a5287e0 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -746,6 +746,7 @@ protected:
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
+	 * This only returns the command sent in the last SEND_WRITE cycle.
 	 * @return
 	 */
 	DeviceCommandId_t getPendingCommand() const;
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 12036bf1..dba6b228 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -22,10 +22,10 @@ using DeviceCommandId_t = uint32_t;
  */
 class DeviceHandlerIF {
 public:
-    static const DeviceCommandId_t NO_COMMAND = -1;
+	static constexpr DeviceCommandId_t NO_COMMAND = -1;
 
-	static const uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-	static const uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+	static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+	static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
 
 	using dh_heater_request_t = uint8_t;
 	using dh_thermal_state_t = int8_t;
@@ -144,7 +144,7 @@ public:
 	 * This is used by the child class to tell the base class what to do.
 	 */
 	enum CommunicationAction: uint8_t {
-	    PERFORM_OPERATION,
+		PERFORM_OPERATION,
 		SEND_WRITE,//!< Send write
 		GET_WRITE, //!< Get write
 		SEND_READ, //!< Send read
@@ -155,7 +155,7 @@ public:
 	static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
 
 	static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID =
-	        localpool::INVALID_LPID - 2;
+			localpool::INVALID_LPID - 2;
 	static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID =
 			localpool::INVALID_LPID - 1;
 

From f8b34bcb5305b946380d2e401c8c57976ad07aae Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 16 Dec 2020 13:53:36 +0100
Subject: [PATCH 1077/1292] some readme improvements

---
 README.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 4aabe36a..fd652f1d 100644
--- a/README.md
+++ b/README.md
@@ -14,9 +14,9 @@ The framework is designed for systems, which communicate with external devices,
 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 recommended hardware is a microprocessor with more than 2 MB of RAM and 1 MB of non-volatile Memory. 
+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 tested on the STM32H743ZI-Nucleo board.
 
 ## Structure
 
@@ -121,12 +121,13 @@ If the communication is based on CCSDS Frames and Space Packets, several classes
 If Space Packets are used, a timestamper must be created. 
 An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
 
-#### DeviceHandling
+#### Device Handlers
 
 DeviceHandlers are a core component of the FSFW. 
 The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
 By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
 The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`.
 A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
 
 #### Modes, Health
@@ -151,7 +152,8 @@ The on-board FDIR uses the health state for isolation and recovery.
 
 ## Example config
 
-A example config can be found in defaultcfg/fsfwconfig.
+A example config can be found in defaultcfg/fsfwconfig. The fsfw will require certain configuration files,
+so a configuration folder should be provided and the folder should be added to the include path.
 
 ## Unit Tests
 

From 60d69c95c497945fbb7650dca21655fbfd9649f5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 17 Dec 2020 17:10:27 +0100
Subject: [PATCH 1078/1292] address in use handling for socket

---
 osal/windows/TmTcWinUdpBridge.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 7e283c2a..2af3daa5 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -137,6 +137,11 @@ void TmTcWinUdpBridge::handleBindError() {
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
+    case(WSAEADDRINUSE): {
+    	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
+    			<< "Port is already in use!" << std::endl;
+    	break;
+    }
     default: {
         /*
         https://docs.microsoft.com/en-us/windows/win32/winsock/

From fc4da433d504efec43814e54dd91c62ed91b13c2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 13:49:42 +0100
Subject: [PATCH 1079/1292] using winsock2 now

---
 globalfunctions/timevalOperations.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 46f763b9..db68f330 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 
 #ifdef WIN32
-#include <Windows.h>
+#include <winsock2.h>
 #else
 #include <sys/time.h>
 #endif

From ca2571464680d6fbef9e011c61fbcabe9b178e84 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:01:48 +0100
Subject: [PATCH 1080/1292] upstream coordinates taken over

---
 coordinates/CMakeLists.txt   | 5 +++++
 coordinates/Sgp4Propagator.h | 2 ++
 2 files changed, 7 insertions(+)
 create mode 100644 coordinates/CMakeLists.txt

diff --git a/coordinates/CMakeLists.txt b/coordinates/CMakeLists.txt
new file mode 100644
index 00000000..a1fa1e52
--- /dev/null
+++ b/coordinates/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CoordinateTransformations.cpp
+		Sgp4Propagator.cpp
+)
\ No newline at end of file
diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h
index 3949547e..f813c6f4 100644
--- a/coordinates/Sgp4Propagator.h
+++ b/coordinates/Sgp4Propagator.h
@@ -1,7 +1,9 @@
 #ifndef SGP4PROPAGATOR_H_
 #define SGP4PROPAGATOR_H_
 
+#ifndef WIN32
 #include <sys/time.h>
+#endif
 #include "../contrib/sgp4/sgp4unit.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 

From de61d0c3ac331e179d0839284f1b537acf56f825 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:02:13 +0100
Subject: [PATCH 1081/1292] upstream timeval op

---
 globalfunctions/timevalOperations.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/globalfunctions/timevalOperations.h b/globalfunctions/timevalOperations.h
index 3977d5d9..db68f330 100644
--- a/globalfunctions/timevalOperations.h
+++ b/globalfunctions/timevalOperations.h
@@ -2,7 +2,12 @@
 #define TIMEVALOPERATIONS_H_
 
 #include <stdint.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
 #include <sys/time.h>
+#endif
 
 timeval& operator+=(timeval& lhs, const timeval& rhs);
 

From e511dc61b48b12d944302a781326ad79811dfd8b Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:02:41 +0100
Subject: [PATCH 1082/1292] upstream osal endiness adapted

---
 osal/Endiness.h | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/osal/Endiness.h b/osal/Endiness.h
index 55d0aeb3..9d3fdef0 100644
--- a/osal/Endiness.h
+++ b/osal/Endiness.h
@@ -1,10 +1,6 @@
 #ifndef FRAMEWORK_OSAL_ENDINESS_H_
 #define FRAMEWORK_OSAL_ENDINESS_H_
 
-/**
- * @defgroup osal Operating System Abstraction Layer
- * @brief Provides clean interfaces to use OS functionalities
- */
 
 /*
  * BSD-style endian declaration
@@ -26,9 +22,23 @@
 #else
 #error "Can't decide which end is which!"
 #endif
+#else
+
+#ifdef WIN32
+#include <Windows.h>
+#if REG_DWORD == REG_DWORD_LITTLE_ENDIAN
+#define BYTE_ORDER_SYSTEM LITTLE_ENDIAN
+#else
+#define BYTE_ORDER_SYSTEM BIG_ENDIAN
+#endif
+
+
 #else
 #error __BYTE_ORDER__ not defined
 #endif
+
+#endif
+
 #endif
 
 

From 30c9209c7488ac4bc69c1ee0bcd6424009d39c07 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:03:19 +0100
Subject: [PATCH 1083/1292] better win udp polling task error handling

---
 osal/windows/TcWinUdpPollingTask.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 7b54bb2c..06deafd1 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -119,7 +119,7 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
-		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 	}
 }
@@ -128,17 +128,22 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSANOTINITIALISED: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
         break;
     }
     case(WSAEFAULT): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSADEFAULT: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
         break;
     }
+    case(WSAEINVAL): {
+        sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
+                << "Invalid input parameters. " << std::endl;
+        break;
+    }
     default: {
-        sif::info << "TmTcWinUdpBridge::handleReadError: Error code: "
+        sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
         break;
     }

From a6e38afb98317abb7d0c592fe7be9edee1cbb356 Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:04:04 +0100
Subject: [PATCH 1084/1292] buffer more explicit eof()

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c5d5b258..e69538d1 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = Traits::eof()) override;
+	int overflow(int c = std::ostream::traits_type::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 17a12b78073c98eb0abdce9f7c46df9c18e46fac Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 14:05:44 +0100
Subject: [PATCH 1085/1292] clock update

---
 timemanager/Clock.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index f4ed847a..9f6f9885 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -7,7 +7,12 @@
 #include "../globalfunctions/timevalOperations.h"
 
 #include <cstdint>
+
+#ifdef WIN32
+#include <winsock2.h>
+#else
 #include <sys/time.h>
+#endif
 
 class Clock {
 public:

From 59eab8866d8cd8c7f34c710ba6eec8e9845caab2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 17:16:44 +0100
Subject: [PATCH 1086/1292] using traits again

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1..c5d5b258 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 71ee86a6884762e40b66fdafb700f9cce65b8cf7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 17:18:31 +0100
Subject: [PATCH 1087/1292] reverted sif buffer changes

---
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1..c5d5b258 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From c2619bf07052faa2d36ec9e09468b2843aa1dac4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 21 Dec 2020 23:39:24 +0100
Subject: [PATCH 1088/1292] transition delay not 0 anymore

---
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index f095834e..53f5aea2 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -928,7 +928,7 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 
 uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
 		Mode_t modeTo) {
-	return 0;
+	return 5000;
 }
 
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {

From 6abc56009405b64e7536f919f025f4f443df8b6a Mon Sep 17 00:00:00 2001
From: Spacefish <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:55:47 +0100
Subject: [PATCH 1089/1292] feed back include improvements

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 4 ++--
 defaultcfg/fsfwconfig/OBSWConfig.h | 4 ++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 334f352a..dda8497d 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -24,8 +24,8 @@
 #define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
 #define FSFW_DEBUG_OUTPUT			0
 #endif
diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index a9f57638..8ad2cb67 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,6 +3,10 @@
 
 #include "OBSWVersion.h"
 
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
 #ifdef __cplusplus
 namespace config {
 #endif

From 38983407fd8973c48f4c23c02f3e8d7c34eb20da Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:22:35 +0100
Subject: [PATCH 1090/1292] added default implementation for setNormalDatapool

entries invalid
---
 devicehandlers/DeviceHandlerBase.cpp |  8 ++++
 devicehandlers/DeviceHandlerBase.h   | 69 ++++++++++++++--------------
 2 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 53f5aea2..cb040714 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1459,3 +1459,11 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
     }
     return DeviceHandlerIF::NO_COMMAND;
 }
+
+void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
+	for(const auto& reply: deviceReplyMap) {
+		if(reply.second.dataSet != nullptr) {
+			reply.second.dataSet->setValidity(false, true);
+		}
+	}
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 9a5287e0..ee4447ed 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -254,9 +254,10 @@ protected:
 	 *
 	 * @param[out] id the device command id that has been built
 	 * @return
-	 *    - @c RETURN_OK to send command after setting #rawPacket and #rawPacketLen.
-	 *    - @c NOTHING_TO_SEND when no command is to be sent.
-	 *    - Anything else triggers an even with the returnvalue as a parameter.
+	 *  - @c RETURN_OK to send command after setting #rawPacket and
+	 *    #rawPacketLen.
+	 *  - @c NOTHING_TO_SEND when no command is to be sent.
+	 *  - Anything else triggers an even with the returnvalue as a parameter.
 	 */
 	virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) = 0;
 
@@ -273,7 +274,8 @@ protected:
 	 * and filling them in doStartUp(), doShutDown() and doTransition() so no
 	 * modes have to be checked here.
 	 *
-	 * #rawPacket and #rawPacketLen must be set by this method to the packet to be sent.
+	 * #rawPacket and #rawPacketLen must be set by this method to the
+	 * packet to be sent.
 	 *
 	 * @param[out] id the device command id built
 	 * @return
@@ -284,19 +286,23 @@ protected:
 	virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) = 0;
 
 	/**
-	 * @brief Build a device command packet from data supplied by a direct command.
+	 * @brief 	Build a device command packet from data supplied by a
+	 * 			direct command.
 	 *
 	 * @details
-	 * #rawPacket and #rawPacketLen should be set by this method to the packet to be sent.
-	 * The existence of the command in the command map and the command size check
-	 * against 0 are done by the base class.
+	 * #rawPacket and #rawPacketLen should be set by this method to the packet
+	 * to be sent. The existence of the command in the command map and the
+	 * command size check against 0 are done by the base class.
 	 *
-	 * @param deviceCommand the command to build, already checked against deviceCommandMap
+	 * @param deviceCommand the command to build, already checked against
+	 * deviceCommandMap
 	 * @param commandData pointer to the data from the direct command
 	 * @param commandDataLen length of commandData
 	 * @return
-	 *     - @c RETURN_OK to send command after #rawPacket and #rawPacketLen have been set.
-	 *     - Anything else triggers an event with the returnvalue as a parameter
+	 *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
+	 *       have been set.
+	 *  - Anything else triggers an event with the
+	 *    returnvalue as a parameter
 	 */
 	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
 			const uint8_t * commandData, size_t commandDataLen) = 0;
@@ -681,7 +687,7 @@ protected:
 		//! The dataset used to access housekeeping data related to the
 		//! respective device reply. Will point to a dataset held by
 		//! the child handler (if one is specified)
-		LocalPoolDataSetBase* dataSet;
+		LocalPoolDataSetBase* dataSet = nullptr;
 		//! The command that expects this reply.
 		DeviceCommandMap::iterator command;
 	};
@@ -743,6 +749,17 @@ protected:
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;
 
+	/**
+	 * @brief   Set all datapool variables that are update periodically in
+	 *          normal mode invalid
+	 * @details
+	 * The default implementation will set all datasets which have been added
+	 * in #fillCommandAndReplyMap to invalid. It will also set all pool
+	 * variables inside the dataset to invalid. The user can override this
+	 * method optionally.
+	 */
+	virtual void setNormalDatapoolEntriesInvalid();
+
 	/**
 	 * Helper function to get pending command. This is useful for devices
 	 * like SPI sensors to identify the last sent command.
@@ -785,7 +802,6 @@ protected:
 	 *
 	 * The submode is left unchanged.
 	 *
-	 *
 	 * @param newMode
 	 */
 	void setMode(Mode_t newMode);
@@ -838,8 +854,6 @@ protected:
 	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom);
 
 	/**
-	 * Is the combination of mode and submode valid?
-	 *
 	 * @param mode
 	 * @param submode
 	 * @return
@@ -850,13 +864,10 @@ protected:
 			Submode_t submode);
 
 	/**
-	 * Get the Rmap action for the current step.
-	 *
+	 * Get the communication action for the current step.
 	 * The step number can be read from #pstStep.
-	 *
-	 * @return The Rmap action to execute in this step
+	 * @return The communication action to execute in this step
 	 */
-
 	virtual CommunicationAction getComAction();
 
 	/**
@@ -898,8 +909,8 @@ protected:
 	 * It gets space in the #IPCStore, copies data there, then sends a raw reply
 	 * containing the store address.
 	 *
-	 * This method is virtual, as the STR has a different channel to send
-	 * raw replies and overwrites it accordingly.
+	 * This method is virtual, as devices can have different channels to send
+	 * raw replies
 	 *
 	 * @param data data to send
 	 * @param len length of @c data
@@ -918,7 +929,7 @@ protected:
 	void replyRawReplyIfnotWiretapped(const uint8_t *data, size_t len);
 
 	/**
-	 * notify child about mode change
+	 * @brief	Notify child about mode change.
 	 */
 	virtual void modeChanged(void);
 
@@ -950,8 +961,7 @@ protected:
 			DeviceCommandId_t alternateReplyID = 0);
 
 	/**
-	 * get the state of the PCDU switches in the datapool
-	 *
+	 * Get the state of the PCDU switches in the local datapool
 	 * @return
 	 *  - @c PowerSwitchIF::SWITCH_ON if all switches specified
 	 *       by #switches are on
@@ -961,15 +971,6 @@ protected:
 	 */
 	ReturnValue_t getStateOfSwitches(void);
 
-	/**
-	 * @brief   Set all datapool variables that are update periodically in
-	 *          normal mode invalid
-	 * @details TODO: Use local pools
-	 * Child classes should provide an implementation which sets all those
-	 * variables invalid which are set periodically during any normal mode.
-	 */
-	virtual void setNormalDatapoolEntriesInvalid() = 0;
-
 	/**
 	 * build a list of sids and pass it to the #hkSwitcher
 	 */

From 81201d6fb73393ce83b725b6a86c09bdc3586c2a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 00:39:51 +0100
Subject: [PATCH 1091/1292] typo

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index dba6b228..e5648751 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -131,7 +131,7 @@ public:
 	// Standard codes used in  interpretDeviceReply
 	static const ReturnValue_t DEVICE_DID_NOT_EXECUTE = MAKE_RETURN_CODE(0xC0); //the device reported, that it did not execute the command
 	static const ReturnValue_t DEVICE_REPORTED_ERROR = MAKE_RETURN_CODE(0xC1);
-	static const ReturnValue_t UNKNOW_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
+	static const ReturnValue_t UNKNOWN_DEVICE_REPLY = MAKE_RETURN_CODE(0xC2); //the deviceCommandId reported by scanforReply is unknown
 	static const ReturnValue_t DEVICE_REPLY_INVALID = MAKE_RETURN_CODE(0xC3); //syntax etc is correct but still not ok, eg parameters where none are expected
 
 	// Standard codes used in buildCommandFromCommand

From 770336fff3de55194b4b0e6fc3f9f582f2ed3ef9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:06:35 +0100
Subject: [PATCH 1092/1292] added ipc cmakelists

---
 ipc/CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 ipc/CMakeLists.txt

diff --git a/ipc/CMakeLists.txt b/ipc/CMakeLists.txt
new file mode 100644
index 00000000..6a3afe33
--- /dev/null
+++ b/ipc/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CommandMessage.cpp
+		CommandMessageCleaner.cpp
+		MessageQueueMessage.cpp
+)
\ No newline at end of file

From b97b67d56e362ef1a329cb0f118653b9f5cc5ea0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:19:07 +0100
Subject: [PATCH 1093/1292] updating unittest folder

---
 unittest/core/CatchSetup.cpp                    | 6 +-----
 unittest/testcfg/{objects => }/CatchFactory.cpp | 0
 unittest/testcfg/{objects => }/CatchFactory.h   | 0
 unittest/testcfg/testcfg.mk                     | 8 --------
 4 files changed, 1 insertion(+), 13 deletions(-)
 rename unittest/testcfg/{objects => }/CatchFactory.cpp (100%)
 rename unittest/testcfg/{objects => }/CatchFactory.h (100%)

diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index cb5bd33e..99ee63b5 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,5 +1,5 @@
 #include "CatchDefinitions.h"
-#include "CatchFactory.h"
+#include <CatchFactory.h>
 
 #include <testcfg/cdatapool/dataPoolInit.h>
 
@@ -10,15 +10,11 @@
 #include "../../objectmanager/ObjectManager.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../storagemanager/StorageManagerIF.h"
-#include "../../datapool/DataPool.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
-//namespace glob {
-DataPool dataPool(datapool::dataPoolInit);
-//}
 
 
 namespace sif {
diff --git a/unittest/testcfg/objects/CatchFactory.cpp b/unittest/testcfg/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/objects/CatchFactory.cpp
rename to unittest/testcfg/CatchFactory.cpp
diff --git a/unittest/testcfg/objects/CatchFactory.h b/unittest/testcfg/CatchFactory.h
similarity index 100%
rename from unittest/testcfg/objects/CatchFactory.h
rename to unittest/testcfg/CatchFactory.h
diff --git a/unittest/testcfg/testcfg.mk b/unittest/testcfg/testcfg.mk
index 31d3b60a..fca2f732 100644
--- a/unittest/testcfg/testcfg.mk
+++ b/unittest/testcfg/testcfg.mk
@@ -6,11 +6,3 @@ CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
 CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
 
 INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/objects
-INCLUDES += $(CURRENTPATH)/ipc
-INCLUDES += $(CURRENTPATH)/pollingsequence
-INCLUDES += $(CURRENTPATH)/returnvalues
-INCLUDES += $(CURRENTPATH)/tmtc
-INCLUDES += $(CURRENTPATH)/events
-INCLUDES += $(CURRENTPATH)/devices
-INCLUDES += $(CURRENTPATH)/cdatapool

From e41aba719c93fe25cf97d8cccee5cb2a01a3530f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:20:17 +0100
Subject: [PATCH 1094/1292] updated testcfg

---
 unittest/testcfg/FSFWConfig.h | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 418992fa..94f6e59d 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -1,5 +1,5 @@
-#ifndef FSFWCONFIG_FSFWCONFIG_H_
-#define FSFWCONFIG_FSFWCONFIG_H_
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
 
 #include <cstddef>
 #include <cstdint>
@@ -18,19 +18,21 @@
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
-#define FSFW_OBJ_EVENT_TRANSLATION	1
+#define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
+#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
-#include <translateObjects.h>
-#include <translateEvents.h>
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
 #else
+#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities
 //! will not be provided. This define should be set to 1 if this is the case.
-#define FSFW_NO_C99_IO 	1
+#define FSFW_NO_C99_IO 	            1
 
 //! Specify whether a special mode store is used for Subsystem components.
 #define FSFW_USE_MODESTORE          0
@@ -52,4 +54,4 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
 }
 
-#endif /* FSFWCONFIG_FSFWCONFIG_H_ */
+#endif /* CONFIG_FSFWCONFIG_H_ */

From 5e8aff0603c6507b6f417ecb882446b25b9b54f7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:25:00 +0100
Subject: [PATCH 1095/1292] unittest update

---
 unittest/{testcfg => core}/CatchFactory.cpp |  0
 unittest/{testcfg => core}/CatchFactory.h   |  6 +++---
 unittest/core/CatchSetup.cpp                |  3 +--
 unittest/testcfg/Makefile-FSFW-Tests        | 13 +++++++------
 4 files changed, 11 insertions(+), 11 deletions(-)
 rename unittest/{testcfg => core}/CatchFactory.cpp (100%)
 rename unittest/{testcfg => core}/CatchFactory.h (71%)

diff --git a/unittest/testcfg/CatchFactory.cpp b/unittest/core/CatchFactory.cpp
similarity index 100%
rename from unittest/testcfg/CatchFactory.cpp
rename to unittest/core/CatchFactory.cpp
diff --git a/unittest/testcfg/CatchFactory.h b/unittest/core/CatchFactory.h
similarity index 71%
rename from unittest/testcfg/CatchFactory.h
rename to unittest/core/CatchFactory.h
index 84f9207e..f06e7ae5 100644
--- a/unittest/testcfg/CatchFactory.h
+++ b/unittest/core/CatchFactory.h
@@ -1,5 +1,5 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
+#ifndef FSFW_CATCHFACTORY_H_
+#define FSFW_CATCHFACTORY_H_
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 
@@ -13,4 +13,4 @@ namespace Factory {
 
 }
 
-#endif /* FACTORY_H_ */
+#endif /* FSFW_CATCHFACTORY_H_ */
diff --git a/unittest/core/CatchSetup.cpp b/unittest/core/CatchSetup.cpp
index 99ee63b5..c93cf032 100644
--- a/unittest/core/CatchSetup.cpp
+++ b/unittest/core/CatchSetup.cpp
@@ -1,6 +1,5 @@
+#include <fsfw/unittest/core/CatchFactory.h>
 #include "CatchDefinitions.h"
-#include <CatchFactory.h>
-
 #include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/testcfg/Makefile-FSFW-Tests
index 2017d2bd..550fd1de 100644
--- a/unittest/testcfg/Makefile-FSFW-Tests
+++ b/unittest/testcfg/Makefile-FSFW-Tests
@@ -15,7 +15,7 @@ SHELL = /bin/sh
 # (can be overriden by adding CHIP=chip and BOARD=board to the command-line)
 # Unit Test can only be run on host machine for now (Linux)
 FRAMEWORK_PATH = fsfw
-FILE_ROOT = $(FRAMEWORK_PATH)/unittest
+TEST_FILE_ROOT = $(FRAMEWORK_PATH)/unittest
 BOARD = unittest
 LINUX = 1
 OS_FSFW = linux
@@ -58,9 +58,10 @@ endif
 
 UNIT_TEST = 1
 # General folder paths
-CONFIG_PATH = $(FILE_ROOT)/config
-UNIT_TEST_PATH = $(FILE_ROOT)/tests
-CORE_PATH = $(FILE_ROOT)/core
+CONFIG_PATH = testcfg
+# Core copy has to be copied as well.
+CORE_PATH = core
+UNIT_TEST_PATH = $(TEST_FILE_ROOT)/tests
 
 # Output file basename
 BASENAME = fsfw
@@ -154,8 +155,8 @@ include $(S)/$(notdir $S).mk
 endef
 $(foreach S,$(SUBDIRS),$(eval $(INCLUDE_FILE)))
 
-INCLUDES += $(FILE_ROOT)
-INCLUDES += $(FILE_ROOT)/catch2/
+INCLUDES += $(TEST_FILE_ROOT)
+INCLUDES += $(TEST_FILE_ROOT)/catch2/
 
 #-------------------------------------------------------------------------------
 #		Source Files

From ee05a34c9ead0bd79b0209afcf8ba9f070db758a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:27:47 +0100
Subject: [PATCH 1096/1292] added gitmodules

---
 .gitmodules | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 .gitmodules

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..e69de29b

From 95a8dd418c487c3b0ab2a76d1e85ff3221a23a22 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:29:58 +0100
Subject: [PATCH 1097/1292] added cmake lists

---
 datapool/CMakeLists.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 datapool/CMakeLists.txt

diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
new file mode 100644
index 00000000..e741f6a1
--- /dev/null
+++ b/datapool/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ControllerSet.cpp
+		DataPool.cpp
+		DataPoolAdmin.cpp
+		DataPoolParameterWrapper.cpp
+		DataSet.cpp
+		HkSwitchHelper.cpp
+		PoolEntry.cpp
+		PoolRawAccess.cpp
+)
\ No newline at end of file

From 632f319a2f181207ad3309c109ff790e919e4abd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:19:00 +0100
Subject: [PATCH 1098/1292] updated readme

---
 README.md                     | 93 +++++++++++------------------------
 doc/README-config.md          | 21 ++++++++
 doc/README-core.md            | 50 +++++++++++++++++++
 doc/README-devicehandlers.txt |  0
 4 files changed, 100 insertions(+), 64 deletions(-)
 create mode 100644 doc/README-config.md
 create mode 100644 doc/README-core.md
 create mode 100644 doc/README-devicehandlers.txt

diff --git a/README.md b/README.md
index fd652f1d..9d5a158c 100644
--- a/README.md
+++ b/README.md
@@ -18,79 +18,48 @@ The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB
 For reference, current Applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC.
 The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 
+## How to Use
+
+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. Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+a configuration folder. 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.
+
 ## Structure
 
-The general structure is driven by the usage of interfaces provided by objects. The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
 The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
 This simplifies the instantiation of objects and allows the usage of some standard containers. 
 Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses Run-time type information.
-Exceptions are not allowed.
+The fsfw uses run-time type information but exceptions are not allowed.
 
 ### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something is gone wrong. 
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
 Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
 The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
 
 ### OSAL
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. A independent OSAL called "host" is currently not finished. This aims to be running on windows as well. 
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+A independent OSAL called "host" is in development. 
+This OSAL is intended to provide abstraction for common type of host OSes (tested for Linux and Windows, not for MacOS yet).
 The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
 
 ### Core Components 
 
-Clock:
- * This is a class of static functions that can be used at anytime
- * Leap Seconds must be set if any time conversions from UTC to other times is used
-
-ObjectManager (must be created): 
-
-* The component which handles all references. All SystemObjects register at this component. 
-* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
-* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
-A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
-
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
-```
-* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
-By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
-
-Event Manager:
-
-* Component which allows routing of events
-* Other objects can subscribe to specific events, ranges of events or all events of an object.
-* Subscriptions can be done during runtime but should be done during initialization
-* Amounts of allowed subscriptions must be configured by setting this parameters:
-
-``` c++
-namespace fsfwconfig {
-//! Configure the allocated pool sizes for the event manager.
-static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
-static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
-}
-```
-
-
-Health Table:
-
-* A component which holds every health state 
-* Provides a thread safe way to access all health states without the need of message exchanges
-
-Stores
-
-* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can be exchanged with Stores. With this, only the store address must be exchanged in the message.
-* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
-* All of them should use the Thread Safe Class storagemanager/PoolManager
-
-Tasks
-
-There are two different types of tasks:
- * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
- * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
 
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
 
 ### Static Ids in the framework
 
@@ -123,12 +92,13 @@ An example can be found in the timemanager folder, this uses CCSDSTime::CDS_shor
 
 #### Device Handlers
 
-DeviceHandlers are a core component of the FSFW. 
+DeviceHandlers are another important component of the FSFW. 
 The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a DH can be tested on different hardware.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
 The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`.
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
 A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
 
 #### Modes, Health
 
@@ -150,11 +120,6 @@ The health state represents if the component is able to perform its tasks.
 This can be used to signal the system to avoid using this component instead of a redundant one.
 The on-board FDIR uses the health state for isolation and recovery. 
 
-## Example config
-
-A example config can be found in defaultcfg/fsfwconfig. The fsfw will require certain configuration files,
-so a configuration folder should be provided and the folder should be added to the include path.
-
 ## Unit Tests
 
 Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
diff --git a/doc/README-config.md b/doc/README-config.md
new file mode 100644
index 00000000..036a7d14
--- /dev/null
+++ b/doc/README-config.md
@@ -0,0 +1,21 @@
+
+## Configuring the FSFW
+
+The FSFW can be configured via the `fsfwconfig` folder. A template folder has
+been provided to have a starting point for this. The folder should be added
+to the include path.
+
+
+### Configuring the Event Manager
+
+The number of allowed subscriptions can be modified with the following
+parameters:
+
+``` c++
+namespace fsfwconfig {
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+}
+```
\ No newline at end of file
diff --git a/doc/README-core.md b/doc/README-core.md
new file mode 100644
index 00000000..c47ae0f2
--- /dev/null
+++ b/doc/README-core.md
@@ -0,0 +1,50 @@
+## FSFW Core Modules
+
+These core modules provide the most important functionalities of the 
+Flight Software Framework
+
+### Clock
+
+ * This is a class of static functions that can be used at anytime
+ * Leap Seconds must be set if any time conversions from UTC to other times is used
+
+### ObjectManager
+
+* Must be created during program startup
+* The component which handles all references. All SystemObjects register at this component. 
+* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
+* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
+A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
+
+``` c++
+	template <typename T> T* ObjectManagerIF::get( object_id_t id )
+
+```
+* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
+By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+
+### Event Manager
+
+* Component which allows routing of events
+* Other objects can subscribe to specific events, ranges of events or all events of an object.
+* Subscriptions can be done during runtime but should be done during initialization
+* Amounts of allowed subscriptions can be configured in `FSFWConfig.h`
+
+### Health Table
+
+* A component which holds every health state 
+* Provides a thread safe way to access all health states without the need of message exchanges
+
+### Stores
+
+* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can 
+  be exchanged with Stores. With this, only the store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* All of them should use the Thread Safe Class storagemanager/PoolManager
+
+### Tasks
+
+There are two different types of tasks:
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+
diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.txt
new file mode 100644
index 00000000..e69de29b

From 88967529277732fca91a74696a06d63dd43cd3fa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 13:22:10 +0100
Subject: [PATCH 1099/1292] updated readme

---
 README.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 9d5a158c..8552e0c8 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 ![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+
 # Flight Software Framework (FSFW)
 
 The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
@@ -21,8 +22,10 @@ The `fsfw` was also tested on the STM32H743ZI-Nucleo board.
 ## How to Use
 
 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. Generally, the FSFW is included in a project by compiling the FSFW sources and providing
-a configuration folder. A template configuration folder was provided and can be copied into the project root to have
+to see the FSFW capabilities and build it with the Make or the CMake build system. 
+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. 
+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.
 
@@ -44,9 +47,9 @@ The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds
 ### OSAL
 
 The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent OSAL called "host" is in development. 
-This OSAL is intended to provide abstraction for common type of host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and Semaphores as well as Mutexes.
+A independent Host OSAL is in development which will provide abstraction for common type of 
+host OSes (tested for Linux and Windows, not for MacOS yet).
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
 
 ### Core Components 
 

From 362578e982e5754911ae93e3edc90420f207d813 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:12:35 +0100
Subject: [PATCH 1100/1292] transition delay abstract

---
 devicehandlers/DeviceHandlerBase.cpp | 5 -----
 devicehandlers/DeviceHandlerBase.h   | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index cb040714..d2d4ecb8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -926,11 +926,6 @@ void DeviceHandlerBase::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 	setMode(getBaseMode(mode));
 }
 
-uint32_t DeviceHandlerBase::getTransitionDelayMs(Mode_t modeFrom,
-		Mode_t modeTo) {
-	return 5000;
-}
-
 ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 	if(powerSwitcher == nullptr) {
 		return NO_SWITCH;
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index ee4447ed..45450f62 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -490,7 +490,7 @@ protected:
 	 * @param modeTo
 	 * @return time in ms
 	 */
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo);
+	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) = 0;
 
 	/**
 	 * Return the switches connected to the device.

From 947dfd69e97f894287d758eb929cdf9caa1b1f23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:16:33 +0100
Subject: [PATCH 1101/1292] service types.h delted

---
 tmtcservices/ServiceTypes.h | 26 --------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 tmtcservices/ServiceTypes.h

diff --git a/tmtcservices/ServiceTypes.h b/tmtcservices/ServiceTypes.h
deleted file mode 100644
index 552601f9..00000000
--- a/tmtcservices/ServiceTypes.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef SERVICETYPES_H_
-#define SERVICETYPES_H_
-
-// SHOULDDO: This is a duplication of existing configuration structures. Delete it?
-namespace SERVICE {
-enum ServiceTypes {
-	TELECOMMAND_VERIFICATION = 1,
-	DEVICE_COMMAND_DISTRIBUTION = 2,
-	HOUSEKEEPING_AND_DIAGNOSTIC_DATA_REPORTING = 3,
-	PARAMETER_STATISTICS_REPORTING = 4,
-	EVENT_REPORTING = 5,
-	MEMORY_MANAGEMENT = 6,
-	FUNCTION_MANAGEMENT = 8,
-	TIME_MANAGEMENT = 9,
-	ON_BOARD_OPERATIONS_SCHEDULING = 11,
-	ON_BOARD_MONITORING = 12,
-	LARGE_DATA_TRANSFER = 13,
-	PACKET_FORWARDING_CONTROL = 14,
-	ON_BOARD_STORAGE_AND_RETRIEVAL = 15,
-	TEST = 17,
-	ON_BOARD_OPERATIONS_PROCEDURE = 18,
-	EVENT_ACTION = 19
-};
-}
-
-#endif /* SERVICETYPES_H_ */

From 7ba660a222a3c0cdb1276942557ba27891783138 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 14:18:48 +0100
Subject: [PATCH 1102/1292] removed comment

---
 tmtcservices/AcceptsTelecommandsIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h
index bff0e955..7c871049 100644
--- a/tmtcservices/AcceptsTelecommandsIF.h
+++ b/tmtcservices/AcceptsTelecommandsIF.h
@@ -12,7 +12,7 @@
 class AcceptsTelecommandsIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::ACCEPTS_TELECOMMANDS_IF;
-	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1); // is this used anywhere or can it be removed?
+	static const ReturnValue_t ACTIVITY_STARTED = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t INVALID_SUBSERVICE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t ILLEGAL_APPLICATION_DATA = MAKE_RETURN_CODE(3);
 	static const ReturnValue_t SEND_TM_FAILED = MAKE_RETURN_CODE(4);

From 021b9b8c50e15adfdd0705663ea447ff7fdf10ab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:57:43 +0100
Subject: [PATCH 1103/1292] improvements

---
 tmstorage/TmStoreBackendIF.h  | 25 ++++++++++++++++++++++---
 tmstorage/TmStoreFrontendIF.h | 17 +++++++++++++----
 tmstorage/TmStoreMessage.cpp  |  4 ++--
 tmstorage/TmStoreMessage.h    |  4 ++--
 tmstorage/TmStorePackets.h    |  8 ++++----
 5 files changed, 43 insertions(+), 15 deletions(-)

diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 4b2a8836..4ae77609 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,5 +1,5 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -49,14 +49,33 @@ public:
 	static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);//!< Info that the a auto catalog report failed
 
 	virtual ~TmStoreBackendIF() {}
+
+	/**
+	 * SHOULDDO: Specification on what has to be implemented here
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	virtual ReturnValue_t initialize() = 0;
+
+	/**
+	 * Implement the storage of TM packets to mass memory
+	 * @param tmPacket
+	 * @return
+	 */
 	virtual ReturnValue_t storePacket(TmPacketMinimal* tmPacket) = 0;
 	virtual ReturnValue_t setFetchLimitTime(const timeval* loverLimit, const timeval* upperLimit) = 0;
 	virtual ReturnValue_t setFetchLimitBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t fetchPackets(bool fromBegin = false) = 0;
 	virtual ReturnValue_t initializeStore(object_id_t dumpTarget) = 0;
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
+
+	/**
+	 * SHOULDDO: Adapt for file management system?
+	 * @param startAddress
+	 * @param endAddress
+	 * @return
+	 */
 	virtual ReturnValue_t deleteBlocks(uint32_t startAddress, uint32_t endAddress) = 0;
 	virtual ReturnValue_t deleteTime(const timeval* timeUntil,
 				uint32_t* deletedPackets) = 0;
@@ -73,4 +92,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index e1bc3a14..beee7ede 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,9 +1,10 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "TmStorePackets.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 class TmPacketMinimal;
 class SpacePacketBase;
 class TmStoreBackendIF;
@@ -11,6 +12,14 @@ class TmStoreBackendIF;
 class TmStoreFrontendIF {
 public:
 	virtual TmStoreBackendIF* getBackend() const = 0;
+
+	/**
+	 * What do I need to implement here?
+	 * This is propably used by PUS Service 15 so we should propably check for messages..
+	 * Provide base implementation?
+	 * @param opCode
+	 * @return
+	 */
 	virtual ReturnValue_t performOperation(uint8_t opCode) = 0;
 	/**
 	 * Callback from the back-end to indicate a certain packet was received.
@@ -52,4 +61,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index d2efd403..753ac1b7 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
 #include "../objectmanager/ObjectManagerIF.h"
-#include "TmStoreMessage.h"
+#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
@@ -74,7 +74,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
 	case DELETE_STORE_CONTENT_BLOCKS:
 	case DOWNLINK_STORE_CONTENT_BLOCKS:
 	case REPORT_INDEX_REQUEST:
-		cmd->setCommand(UNKNOWN_COMMAND);
+		cmd->setCommand(CommandMessage::UNKNOWN_COMMAND);
 		cmd->setParameter(0);
 		cmd->setParameter2(0);
 		break;
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 5b928569..59354a20 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -3,9 +3,9 @@
 
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "TmStorePackets.h"
+#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
-class TmStoreMessage: public CommandMessage {
+class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
 			bool setEnabled);
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index b46ae6f6..0312a998 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -140,8 +140,8 @@ public:
 		if(packet->isValid()){
 			timeval packetTime = {0,0};
 			size_t foundlen = 0;
-			CCSDSTime::convertFromCcsds(&packetTime,
-					&packet->rawTimestamp[0],&foundlen,sizeof(rawTimestamp));
+			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime <= *cmpTime){
 				return true;
 			}
@@ -154,7 +154,7 @@ public:
 			timeval packetTime = {0,0};
 			size_t foundlen = 0;
 			CCSDSTime::convertFromCcsds(&packetTime,&packet->rawTimestamp[0],
-					&foundlen,sizeof(rawTimestamp));
+			        &foundlen,sizeof(rawTimestamp));
 			if(packetTime >= *cmpTime){
 				return true;
 			}
@@ -208,7 +208,7 @@ public:
 		timeval packetTime = {0,0};
 		size_t foundlen = 0;
 		CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0],
-				&foundlen,sizeof(rawTimestamp));
+		        &foundlen, sizeof(rawTimestamp));
 		return packetTime;
 	}
 

From 09161f22d070089265202a7fb67a11ac53990c26 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:58:52 +0100
Subject: [PATCH 1104/1292] updated tm storage

---
 tmstorage/TmStoreMessage.cpp |  2 +-
 tmstorage/TmStoreMessage.h   | 15 +++++++++------
 tmstorage/TmStorePackets.h   |  6 +++---
 3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 753ac1b7..033cbb1d 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
+#include "TmStoreMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 59354a20..d0178920 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
 
+#include "TmStorePackets.h"
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
+
 class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
@@ -25,8 +26,10 @@ public:
 	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
 	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
 	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
 	static void setDeleteContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
@@ -60,4 +63,4 @@ private:
 	TmStoreMessage();
 };
 
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 0312a998..3abd0c1c 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
+#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -300,4 +300,4 @@ private:
 	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
 
 };
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */

From 75a0df4cd97fd14bd5bb99475dcbaf14fbc4dda8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:59:28 +0100
Subject: [PATCH 1105/1292] tm storage update

---
 tmstorage/CMakeLists.txt      |  4 ++++
 tmstorage/TmStoreBackendIF.h  | 10 +++++-----
 tmstorage/TmStoreFrontendIF.h |  9 +++++----
 tmstorage/TmStoreMessage.cpp  |  2 +-
 tmstorage/TmStoreMessage.h    | 15 +++++++++------
 tmstorage/TmStorePackets.h    |  6 +++---
 6 files changed, 27 insertions(+), 19 deletions(-)
 create mode 100644 tmstorage/CMakeLists.txt

diff --git a/tmstorage/CMakeLists.txt b/tmstorage/CMakeLists.txt
new file mode 100644
index 00000000..7990d85a
--- /dev/null
+++ b/tmstorage/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TmStoreMessage.cpp
+)
diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h
index 2ebe85e4..4ae77609 100644
--- a/tmstorage/TmStoreBackendIF.h
+++ b/tmstorage/TmStoreBackendIF.h
@@ -1,5 +1,5 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../objectmanager/SystemObjectIF.h"
@@ -51,7 +51,7 @@ public:
 	virtual ~TmStoreBackendIF() {}
 
 	/**
-	 * What do I need to implement here ?
+	 * SHOULDDO: Specification on what has to be implemented here
 	 * @param opCode
 	 * @return
 	 */
@@ -71,7 +71,7 @@ public:
 	virtual ReturnValue_t dumpIndex(store_address_t* storeId) = 0;
 
 	/**
-	 * TODO: Adapt for file management system?
+	 * SHOULDDO: Adapt for file management system?
 	 * @param startAddress
 	 * @param endAddress
 	 * @return
@@ -92,4 +92,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREBACKENDIF_H_ */
diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h
index e0a7e078..beee7ede 100644
--- a/tmstorage/TmStoreFrontendIF.h
+++ b/tmstorage/TmStoreFrontendIF.h
@@ -1,9 +1,10 @@
-#ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
-#define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#ifndef FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
+#define FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_
 
+#include "TmStorePackets.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../ipc/MessageQueueSenderIF.h"
+
 class TmPacketMinimal;
 class SpacePacketBase;
 class TmStoreBackendIF;
@@ -60,4 +61,4 @@ public:
 
 
 
-#endif /* PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
+#endif /* FSFW_TMTCSERVICES_TMSTOREFRONTENDIF_H_ */
diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp
index 753ac1b7..033cbb1d 100644
--- a/tmstorage/TmStoreMessage.cpp
+++ b/tmstorage/TmStoreMessage.cpp
@@ -1,5 +1,5 @@
+#include "TmStoreMessage.h"
 #include "../objectmanager/ObjectManagerIF.h"
-#include "../tmstorage/TmStoreMessage.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h
index 59354a20..d0178920 100644
--- a/tmstorage/TmStoreMessage.h
+++ b/tmstorage/TmStoreMessage.h
@@ -1,10 +1,11 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
+#define FSFW_TMSTORAGE_TMSTOREMESSAGE_H_
 
+#include "TmStorePackets.h"
 #include "../ipc/CommandMessage.h"
 #include "../storagemanager/StorageManagerIF.h"
-#include "../tmstorage/TmStorePackets.h"
 #include "../objectmanager/SystemObjectIF.h"
+
 class TmStoreMessage  {
 public:
 	static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd,
@@ -25,8 +26,10 @@ public:
 	static void setDownlinkContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
 	static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
-	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
-	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd, uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
+	static ReturnValue_t setDownlinkBlocksMessage(CommandMessage* cmd,
+			uint32_t addressLow, uint32_t addressHigh);
 	static ReturnValue_t setIndexRequestMessage(CommandMessage* cmd);
 	static void setDeleteContentTimeMessage(CommandMessage* cmd,
 			store_address_t storeId);
@@ -60,4 +63,4 @@ private:
 	TmStoreMessage();
 };
 
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREMESSAGE_H_ */
diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h
index 0312a998..3abd0c1c 100644
--- a/tmstorage/TmStorePackets.h
+++ b/tmstorage/TmStorePackets.h
@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
-#define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_
+#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
+#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
 
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -300,4 +300,4 @@ private:
 	uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
 
 };
-#endif /* FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ */
+#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */

From a73cd37e52119057da75030643b41389c16c4ce2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 15:59:46 +0100
Subject: [PATCH 1106/1292] taken over changelog

---
 CHANGELOG | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 7b07db08..2d901791 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -53,6 +53,12 @@ ID for now.
 
 - 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 aclear 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
 
@@ -60,3 +66,7 @@ that DHB users adapt their polling sequence tables to perform this step. This st
 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

From 8f88032110f8be06e7eb653fa39e95335f7a7104 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:00:30 +0100
Subject: [PATCH 1107/1292] taken over upstream .mk file

---
 fsfw.mk | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fsfw.mk b/fsfw.mk
index 1dd4f166..3df63060 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -9,7 +9,6 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
@@ -73,5 +72,3 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
-
-INCLUDES += $(CURRENTPATH)

From df7a2322bfa34504049238a0c299cc1aa2eccac4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:03:56 +0100
Subject: [PATCH 1108/1292] timemanager update

---
 timemanager/CCSDSTime.h    |   1 +
 timemanager/CMakeLists.txt |   8 ++
 timemanager/Clock.h        | 274 ++++++++++++++++++-------------------
 3 files changed, 146 insertions(+), 137 deletions(-)
 create mode 100644 timemanager/CMakeLists.txt

diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index e9e6957f..d74adc61 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -7,6 +7,7 @@
 #include "clockDefinitions.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <cstdint>
+#include <cstddef>
 
 bool operator<(const timeval& lhs, const timeval& rhs);
 bool operator<=(const timeval& lhs, const timeval& rhs);
diff --git a/timemanager/CMakeLists.txt b/timemanager/CMakeLists.txt
new file mode 100644
index 00000000..3367775f
--- /dev/null
+++ b/timemanager/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSTime.cpp
+		Countdown.cpp
+		Stopwatch.cpp
+		TimeMessage.cpp
+		TimeStamper.cpp
+)
diff --git a/timemanager/Clock.h b/timemanager/Clock.h
index 9f6f9885..6400d284 100644
--- a/timemanager/Clock.h
+++ b/timemanager/Clock.h
@@ -16,156 +16,156 @@
 
 class Clock {
 public:
-    typedef struct {
-        uint32_t year; //!< Year, A.D.
-        uint32_t month; //!< Month, 1 .. 12.
-        uint32_t day; //!< Day, 1 .. 31.
-        uint32_t hour; //!< Hour, 0 .. 23.
-        uint32_t minute; //!< Minute, 0 .. 59.
-        uint32_t second; //!< Second, 0 .. 59.
-        uint32_t usecond; //!< Microseconds, 0 .. 999999
-    } TimeOfDay_t;
+	typedef struct {
+		uint32_t year; //!< Year, A.D.
+		uint32_t month; //!< Month, 1 .. 12.
+		uint32_t day; //!< Day, 1 .. 31.
+		uint32_t hour; //!< Hour, 0 .. 23.
+		uint32_t minute; //!< Minute, 0 .. 59.
+		uint32_t second; //!< Second, 0 .. 59.
+		uint32_t usecond; //!< Microseconds, 0 .. 999999
+	} TimeOfDay_t;
 
-    /**
-     * This method returns the number of clock ticks per second.
-     * In RTEMS, this is typically 1000.
-     * @return	The number of ticks.
-     *
-     * @deprecated, we should not worry about ticks, but only time
-     */
-    static uint32_t getTicksPerSecond(void);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a TimeOfDay_t struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
-     * 				is returned.
-     */
-    static ReturnValue_t setClock(const TimeOfDay_t* time);
-    /**
-     * This system call sets the system time.
-     * To set the time, it uses a timeval struct.
-     * @param time The struct with the time settings to set.
-     * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setClock(const timeval* time);
-    /**
-     * This system call returns the current system clock in timeval format.
-     * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
-     * microseconds since an OS-defined epoch.
-     * @param time	A pointer to a timeval struct where the current time is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_timeval(timeval* time);
+	/**
+	 * This method returns the number of clock ticks per second.
+	 * In RTEMS, this is typically 1000.
+	 * @return	The number of ticks.
+	 *
+	 * @deprecated, we should not worry about ticks, but only time
+	 */
+	static uint32_t getTicksPerSecond(void);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a TimeOfDay_t struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code
+	 * 				is returned.
+	 */
+	static ReturnValue_t setClock(const TimeOfDay_t* time);
+	/**
+	 * This system call sets the system time.
+	 * To set the time, it uses a timeval struct.
+	 * @param time The struct with the time settings to set.
+	 * @return	-@c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setClock(const timeval* time);
+	/**
+	 * This system call returns the current system clock in timeval format.
+	 * The timval format has the fields @c tv_sec with seconds and @c tv_usec with
+	 * microseconds since an OS-defined epoch.
+	 * @param time	A pointer to a timeval struct where the current time is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_timeval(timeval* time);
 
-    /**
-     * Get the time since boot in a timeval struct
-     *
-     * @param[out] time A pointer to a timeval struct where the uptime is stored.
-     * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
-     *
-     * @deprecated, I do not think this should be able to fail, use timeval getUptime()
-     */
-    static ReturnValue_t getUptime(timeval* uptime);
+	/**
+	 * Get the time since boot in a timeval struct
+	 *
+	 * @param[out] time A pointer to a timeval struct where the uptime is stored.
+	 * @return @c RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 *
+	 * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+	 */
+	static ReturnValue_t getUptime(timeval* uptime);
 
-    static timeval getUptime();
+	static timeval getUptime();
 
-    /**
-     * Get the time since boot in milliseconds
-     *
-     * This value can overflow! Still, it can be used to calculate time intervalls
-     * between two calls up to 49 days by always using uint32_t in the calculation
-     *
-     * @param ms uptime in ms
-     * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getUptime(uint32_t* uptimeMs);
+	/**
+	 * Get the time since boot in milliseconds
+	 *
+	 * This value can overflow! Still, it can be used to calculate time intervalls
+	 * between two calls up to 49 days by always using uint32_t in the calculation
+	 *
+	 * @param ms uptime in ms
+	 * @return RETURN_OK on success. Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getUptime(uint32_t* uptimeMs);
 
-    /**
-     * Returns the time in microseconds since an OS-defined epoch.
-     * The time is returned in a 64 bit unsigned integer.
-     * @param time A pointer to a 64 bit unisigned integer where the data is stored.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getClock_usecs(uint64_t* time);
-    /**
-     * Returns the time in a TimeOfDay_t struct.
-     * @param time A pointer to a TimeOfDay_t struct.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
+	/**
+	 * Returns the time in microseconds since an OS-defined epoch.
+	 * The time is returned in a 64 bit unsigned integer.
+	 * @param time A pointer to a 64 bit unisigned integer where the data is stored.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getClock_usecs(uint64_t* time);
+	/**
+	 * Returns the time in a TimeOfDay_t struct.
+	 * @param time A pointer to a TimeOfDay_t struct.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getDateAndTime(TimeOfDay_t* time);
 
-    /**
-     * Converts a time of day struct to POSIX seconds.
-     * @param time The time of day as input
-     * @param timeval The corresponding seconds since the epoch.
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-            timeval* to);
+	/**
+	 * Converts a time of day struct to POSIX seconds.
+	 * @param time The time of day as input
+	 * @param timeval The corresponding seconds since the epoch.
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t convertTimeOfDayToTimeval(const TimeOfDay_t* from,
+			timeval* to);
 
-    /**
-     * Converts a time represented as seconds and subseconds since unix
-     * epoch to days since J2000
-     *
-     * @param time seconds since unix epoch
-     * @param[out] JD2000 days since J2000
-     * @return @c RETURN_OK
-     */
-    static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
+	/**
+	 * Converts a time represented as seconds and subseconds since unix
+	 * epoch to days since J2000
+	 *
+	 * @param time seconds since unix epoch
+	 * @param[out] JD2000 days since J2000
+	 * @return @c RETURN_OK
+	 */
+	static ReturnValue_t convertTimevalToJD2000(timeval time, double* JD2000);
 
-    /**
-     * Calculates and adds the offset between UTC and TT
-     *
-     * Depends on the leap seconds to be set correctly.
-     *
-     * @param utc timeval, corresponding to UTC time
-     * @param[out] tt timeval, corresponding to Terrestial Time
-     * @return
-     *  - @c RETURN_OK on success
-     *  - @c RETURN_FAILED if leapSeconds are not set
-     */
-    static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
+	/**
+	 * Calculates and adds the offset between UTC and TT
+	 *
+	 * Depends on the leap seconds to be set correctly.
+	 *
+	 * @param utc timeval, corresponding to UTC time
+	 * @param[out] tt timeval, corresponding to Terrestial Time
+	 * @return
+	 *  - @c RETURN_OK on success
+	 *  - @c RETURN_FAILED if leapSeconds are not set
+	 */
+	static ReturnValue_t convertUTCToTT(timeval utc, timeval* tt);
 
-    /**
-     * Set the Leap Seconds since 1972
-     *
-     * @param leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+	/**
+	 * Set the Leap Seconds since 1972
+	 *
+	 * @param leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
 
-    /**
-     * Get the Leap Seconds since 1972
-     *
-     * Must be set before!
-     *
-     * @param[out] leapSeconds_
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise, the OS failure code is returned.
-     */
-    static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
+	/**
+	 * Get the Leap Seconds since 1972
+	 *
+	 * Must be set before!
+	 *
+	 * @param[out] leapSeconds_
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise, the OS failure code is returned.
+	 */
+	static ReturnValue_t getLeapSeconds(uint16_t *leapSeconds_);
 
-    /**
-     * Function to check and create the Mutex for the clock
-     * @return
-     *  - @c RETURN_OK on success.
-     *  - Otherwise @c RETURN_FAILED if not able to create one
-     */
-    static ReturnValue_t checkOrCreateClockMutex();
+	/**
+	 * Function to check and create the Mutex for the clock
+	 * @return
+	 *  - @c RETURN_OK on success.
+	 *  - Otherwise @c RETURN_FAILED if not able to create one
+	 */
+	static ReturnValue_t checkOrCreateClockMutex();
 
 private:
-    static MutexIF* timeMutex;
-    static uint16_t leapSeconds;
+	static MutexIF* timeMutex;
+	static uint16_t leapSeconds;
 };
 
 

From 7b98b0d5dd01806048753f6f6992402d84632654 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:04:39 +0100
Subject: [PATCH 1109/1292] txt is md now

---
 doc/{README-devicehandlers.txt => README-devicehandlers.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename doc/{README-devicehandlers.txt => README-devicehandlers.md} (100%)

diff --git a/doc/README-devicehandlers.txt b/doc/README-devicehandlers.md
similarity index 100%
rename from doc/README-devicehandlers.txt
rename to doc/README-devicehandlers.md

From f21f43754bd02535d4f3e31fd70779617e701178 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:06:46 +0100
Subject: [PATCH 1110/1292] taken over upstream defaultcfg

---
 defaultcfg/fsfwconfig/CMakeLists.txt | 15 +++++++++++++++
 defaultcfg/fsfwconfig/FSFWConfig.h   |  2 --
 2 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 defaultcfg/fsfwconfig/CMakeLists.txt

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
new file mode 100644
index 00000000..b8b41c93
--- /dev/null
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -0,0 +1,15 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# Add include paths for the FSFW library
+target_include_directories(${LIB_FSFW_NAME} 
+	PUBLIC
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
\ No newline at end of file
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index dda8497d..e1815d05 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -21,13 +21,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include "objects/translateObjects.h"
 #include "events/translateEvents.h"
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From c603bcc91c528f1d2c76c2af8132e26873c9f7c1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:08:24 +0100
Subject: [PATCH 1111/1292] some upstream stuff taken over

---
 action/CMakeLists.txt        |  7 +++++++
 container/CMakeLists.txt     |  5 +++++
 datalinklayer/CMakeLists.txt | 12 ++++++++++++
 datapool/CMakeLists.txt      |  7 +------
 datapoollocal/CMakeLists.txt |  8 ++++++++
 doc/README-devicehandlers.md |  1 +
 6 files changed, 34 insertions(+), 6 deletions(-)
 create mode 100644 action/CMakeLists.txt
 create mode 100644 container/CMakeLists.txt
 create mode 100644 datalinklayer/CMakeLists.txt
 create mode 100644 datapoollocal/CMakeLists.txt

diff --git a/action/CMakeLists.txt b/action/CMakeLists.txt
new file mode 100644
index 00000000..a62d4044
--- /dev/null
+++ b/action/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ActionHelper.cpp
+		ActionMessage.cpp
+		CommandActionHelper.cpp
+		SimpleActionHelper.cpp
+)
\ No newline at end of file
diff --git a/container/CMakeLists.txt b/container/CMakeLists.txt
new file mode 100644
index 00000000..904cde55
--- /dev/null
+++ b/container/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SharedRingBuffer.cpp
+		SimpleRingBuffer.cpp
+)
\ No newline at end of file
diff --git a/datalinklayer/CMakeLists.txt b/datalinklayer/CMakeLists.txt
new file mode 100644
index 00000000..148e7c5d
--- /dev/null
+++ b/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
+)
\ No newline at end of file
diff --git a/datapool/CMakeLists.txt b/datapool/CMakeLists.txt
index e741f6a1..0d53e1ba 100644
--- a/datapool/CMakeLists.txt
+++ b/datapool/CMakeLists.txt
@@ -1,11 +1,6 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		ControllerSet.cpp
-		DataPool.cpp
-		DataPoolAdmin.cpp
-		DataPoolParameterWrapper.cpp
-		DataSet.cpp
 		HkSwitchHelper.cpp
+		PoolDataSetBase.cpp
 		PoolEntry.cpp
-		PoolRawAccess.cpp
 )
\ No newline at end of file
diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
new file mode 100644
index 00000000..c6b187cd
--- /dev/null
+++ b/datapoollocal/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LocalDataPoolManager.cpp
+		LocalDataSet.cpp
+		LocalPoolDataSetBase.cpp
+		LocalPoolObjectBase.cpp
+		SharedLocalDataSet.cpp
+)
\ No newline at end of file
diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index e69de29b..6e737cc5 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -0,0 +1 @@
+## FSFW DeviceHandlers
\ No newline at end of file

From e052a9694ffa14cda100ce39a3c106b23dbc79f3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:10:13 +0100
Subject: [PATCH 1112/1292] upstream stuff

---
 CMakeLists.txt                          | 114 ++++++++++++++++++------
 events/CMakeLists.txt                   |   1 -
 fdir/CMakeLists.txt                     |   6 ++
 health/CMakeLists.txt                   |   6 ++
 housekeeping/CMakeLists.txt             |   5 ++
 internalError/CMakeLists.txt            |   4 +
 internalError/InternalErrorReporter.cpp |   3 +-
 memory/CMakeLists.txt                   |   5 ++
 modes/CMakeLists.txt                    |   5 ++
 monitoring/CMakeLists.txt               |   5 ++
 objectmanager/CMakeLists.txt            |   5 ++
 11 files changed, 128 insertions(+), 31 deletions(-)
 create mode 100644 fdir/CMakeLists.txt
 create mode 100644 health/CMakeLists.txt
 create mode 100644 housekeeping/CMakeLists.txt
 create mode 100644 internalError/CMakeLists.txt
 create mode 100644 memory/CMakeLists.txt
 create mode 100644 modes/CMakeLists.txt
 create mode 100644 monitoring/CMakeLists.txt
 create mode 100644 objectmanager/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 669283c7..02849ca4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,30 +3,42 @@ cmake_minimum_required(VERSION 3.13)
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
 
-# Set options for FSFW OSAL selection.
-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()
-
 set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
 
-if(${OS_FSFW} STREQUAL host)
-set(OS_FSFW_NAME "Host")
-elseif(${OS_FSFW} STREQUAL linux)
-set(OS_FSFW_NAME "Linux")
-elseif(${OS_FSFW} STREQUAL  freertos)
-set(OS_FSFW_NAME "FreeRTOS")
-elseif(${OS_FSFW} STREQUAL rtems)
-set(OS_FSFW_NAME "RTEMS")
-else()
-message(WARNING "Invalid operating system for FSFW specified! Setting to host..")
-set(OS_FSFW_NAME "Host")
-set(OS_FSFW "host")
+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()
 
-message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system")
+if(${OS_FSFW} STREQUAL host)
+	set(OS_FSFW_NAME "Host")
+elseif(${OS_FSFW} STREQUAL linux)
+	set(OS_FSFW_NAME "Linux")
+elseif(${OS_FSFW} STREQUAL  freertos)
+	set(OS_FSFW_NAME "FreeRTOS")
+	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
+elseif(${OS_FSFW} STREQUAL rtems)
+	set(OS_FSFW_NAME "RTEMS")
+else()
+	message(WARNING 
+		"Invalid operating system for FSFW specified! Setting to host.."
+	)
+	set(OS_FSFW_NAME "Host")
+	set(OS_FSFW "host")
+endif()
+
+message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_USE_RMAP "Compile with RMAP" ON)
@@ -36,8 +48,14 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(controller)
 add_subdirectory(coordinates)
-add_subdirectory(datalinklayer)
+
+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)
@@ -55,7 +73,7 @@ add_subdirectory(power)
 add_subdirectory(pus)
 
 if(FSFW_USE_RMAP)
-add_subdirectory(rmap)
+	add_subdirectory(rmap)
 endif()
 
 add_subdirectory(serialize)
@@ -73,13 +91,53 @@ add_subdirectory(tmtcservices)
 # 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)
+	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()
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wshadow=local
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+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 
-		${FSFW_CONFIG_PATH}
+target_include_directories(${LIB_FSFW_NAME} INTERFACE 
+	${CMAKE_SOURCE_DIR}
+	${FSFW_CONFIG_PATH_ABSOLUTE}
+)
+
+# 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}
+)
+
+# Machine specific options can be set with the ABI_FLAGS variable.
+target_compile_options(${LIB_FSFW_NAME} PRIVATE 
+	${WARNING_FLAGS}
+	${COMPILER_FLAGS}
+	${ABI_FLAGS}
 )
diff --git a/events/CMakeLists.txt b/events/CMakeLists.txt
index 9e63deb8..4e935167 100644
--- a/events/CMakeLists.txt
+++ b/events/CMakeLists.txt
@@ -1,6 +1,5 @@
 target_sources(${LIB_FSFW_NAME} 
 	PRIVATE 
-		Event.cpp
 		EventManager.cpp
 		EventMessage.cpp
 )
diff --git a/fdir/CMakeLists.txt b/fdir/CMakeLists.txt
new file mode 100644
index 00000000..f5ffbba8
--- /dev/null
+++ b/fdir/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		EventCorrelation.cpp
+		FailureIsolationBase.cpp
+		FaultCounter.cpp
+)
\ No newline at end of file
diff --git a/health/CMakeLists.txt b/health/CMakeLists.txt
new file mode 100644
index 00000000..d5f3ccd3
--- /dev/null
+++ b/health/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HealthHelper.cpp
+		HealthMessage.cpp
+		HealthTable.cpp	
+)
\ No newline at end of file
diff --git a/housekeeping/CMakeLists.txt b/housekeeping/CMakeLists.txt
new file mode 100644
index 00000000..fecad2e3
--- /dev/null
+++ b/housekeeping/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HousekeepingMessage.cpp
+		PeriodicHousekeepingHelper.cpp
+)
\ No newline at end of file
diff --git a/internalError/CMakeLists.txt b/internalError/CMakeLists.txt
new file mode 100644
index 00000000..2b383914
--- /dev/null
+++ b/internalError/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		InternalErrorReporter.cpp
+)
\ No newline at end of file
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 8d5c792b..bfb67289 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -5,8 +5,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
-        uint32_t messageQueueDepth) :
-		SystemObject(setObjectId),
+        uint32_t messageQueueDepth): SystemObject(setObjectId),
 		commandQueue(QueueFactory::instance()->
 		        createMessageQueue(messageQueueDepth)),
 		poolManager(this, commandQueue),
diff --git a/memory/CMakeLists.txt b/memory/CMakeLists.txt
new file mode 100644
index 00000000..9edb9031
--- /dev/null
+++ b/memory/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		MemoryHelper.cpp
+		MemoryMessage.cpp
+)
\ No newline at end of file
diff --git a/modes/CMakeLists.txt b/modes/CMakeLists.txt
new file mode 100644
index 00000000..8e5c719b
--- /dev/null
+++ b/modes/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ModeHelper.cpp
+		ModeMessage.cpp
+)
\ No newline at end of file
diff --git a/monitoring/CMakeLists.txt b/monitoring/CMakeLists.txt
new file mode 100644
index 00000000..d26e807c
--- /dev/null
+++ b/monitoring/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		LimitViolationReporter.cpp
+		MonitoringMessage.cpp
+)
\ No newline at end of file
diff --git a/objectmanager/CMakeLists.txt b/objectmanager/CMakeLists.txt
new file mode 100644
index 00000000..72aaec89
--- /dev/null
+++ b/objectmanager/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ObjectManager.cpp
+		SystemObject.cpp
+)
\ No newline at end of file

From c174c9ecb82fd18a796cdaf41706b44982e3ba79 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:15:18 +0100
Subject: [PATCH 1113/1292] osal taken over

---
 osal/CMakeLists.txt               | 34 +++++++++++++++++++++++++++++++
 osal/FreeRTOS/CMakeLists.txt      | 30 +++++++++++++++++++++++++++
 osal/host/CMakeLists.txt          | 21 +++++++++++++++++++
 osal/windows/CMakeLists.txt       | 11 ++++++++++
 osal/windows/TmTcWinUdpBridge.cpp |  9 ++++----
 5 files changed, 101 insertions(+), 4 deletions(-)
 create mode 100644 osal/CMakeLists.txt
 create mode 100644 osal/FreeRTOS/CMakeLists.txt
 create mode 100644 osal/host/CMakeLists.txt
 create mode 100644 osal/windows/CMakeLists.txt

diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt
new file mode 100644
index 00000000..02ff2405
--- /dev/null
+++ b/osal/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Check the OS_FSFW variable
+if(${OS_FSFW} STREQUAL "freertos")
+	add_subdirectory(FreeRTOS)
+elseif(${OS_FSFW} STREQUAL "rtems")
+	add_subdirectory(rtems)
+elseif(${OS_FSFW} STREQUAL "linux")
+	add_subdirectory(linux)
+elseif(${OS_FSFW} STREQUAL "host")
+	add_subdirectory(host)
+	if (WIN32)
+		add_subdirectory(windows)
+	elseif(UNIX)
+		target_sources(${LIB_FSFW_NAME}
+			PUBLIC
+				linux/TcUnixUdpPollingTask.cpp
+				linux/TmTcUnixUdpBridge.cpp
+		)
+	endif ()
+
+else()
+
+	message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
+	# Not set. Assumuing this is a host build, try to determine host OS
+	if (WIN32)
+		add_subdirectory(host)
+		add_subdirectory(windows)
+	elseif (UNIX)
+		add_subdirectory(linux)
+	else ()
+		# MacOS or other OSes have not been tested yet / are not supported.
+		message(FATAL_ERROR "The host OS could not be determined! Aborting.")
+	endif()
+
+endif()
\ No newline at end of file
diff --git a/osal/FreeRTOS/CMakeLists.txt b/osal/FreeRTOS/CMakeLists.txt
new file mode 100644
index 00000000..95462010
--- /dev/null
+++ b/osal/FreeRTOS/CMakeLists.txt
@@ -0,0 +1,30 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		BinarySemaphore.cpp
+		BinSemaphUsingTask.cpp
+		CountingSemaphore.cpp
+		CountingSemaphUsingTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+		Timekeeper.cpp
+		TaskManagement.cpp
+)
+
+# FreeRTOS is required to link the FSFW now. It is recommended to compile 
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# library.
+if(NOT LIB_OS_NAME)
+	message(FATAL_ERROR 
+		"FreeRTOS needs to be linked as a target and "
+		"LIB_OS_NAME needs to be set to the target"
+	)
+endif()
+
+target_link_libraries(${LIB_FSWFW_NAME} ${LIB_OS_NAME})
\ No newline at end of file
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
new file mode 100644
index 00000000..aa32990b
--- /dev/null
+++ b/osal/host/CMakeLists.txt
@@ -0,0 +1,21 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		FixedTimeslotTask.cpp
+		MessageQueue.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PeriodicTask.cpp
+		QueueFactory.cpp
+		QueueMapManager.cpp
+		SemaphoreFactory.cpp
+		TaskFactory.cpp
+)
+
+if(UNIX)
+	target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		rt
+		pthread
+	)
+endif()
\ No newline at end of file
diff --git a/osal/windows/CMakeLists.txt b/osal/windows/CMakeLists.txt
new file mode 100644
index 00000000..b6e76d6a
--- /dev/null
+++ b/osal/windows/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcWinUdpPollingTask.cpp
+		TmTcWinUdpBridge.cpp
+)
+
+target_link_libraries(${LIB_FSFW_NAME} 
+	PRIVATE
+		wsock32 
+		ws2_32
+)
\ No newline at end of file
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index 2af3daa5..e1ba132e 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -6,6 +6,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
         uint16_t serverPort, uint16_t clientPort):
         TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
     mutex = MutexFactory::instance()->createMutex();
+    communicationLinkUp = false;
 
     // Initiates Winsock DLL.
     WSAData wsaData;
@@ -90,7 +91,6 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
     return HasReturnvaluesIF::RETURN_OK;
-    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
@@ -101,6 +101,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
 //          &newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 //  sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
 //          &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+    registerCommConnect();
 
     // Set new IP address if it has changed.
     if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
@@ -114,7 +115,7 @@ void TmTcWinUdpBridge::handleSocketError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     default: {
@@ -159,11 +160,11 @@ void TmTcWinUdpBridge::handleSendError() {
     switch(errCode) {
     case(WSANOTINITIALISED): {
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
-                << "WSAStartup(...) call " << "necessary" << std::endl;
+                << "WSAStartup(...) call necessary" << std::endl;
         break;
     }
     case(WSAEADDRNOTAVAIL): {
-        sif::info << "TmTcWinUdpBridge::handleReadError: WSAEADDRNOTAVAIL: "
+        sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
         break;
     }

From f6e7e232f58ce9119265ac9be8c6cf596b3af76d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:17:15 +0100
Subject: [PATCH 1114/1292] parameter upstream taken over

---
 parameters/CMakeLists.txt       | 6 ++++++
 parameters/ParameterWrapper.cpp | 7 ++++---
 2 files changed, 10 insertions(+), 3 deletions(-)
 create mode 100644 parameters/CMakeLists.txt

diff --git a/parameters/CMakeLists.txt b/parameters/CMakeLists.txt
new file mode 100644
index 00000000..fb5e4590
--- /dev/null
+++ b/parameters/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ParameterHelper.cpp
+		ParameterMessage.cpp
+		ParameterWrapper.cpp
+)
\ No newline at end of file
diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp
index 23955516..d9f1ef68 100644
--- a/parameters/ParameterWrapper.cpp
+++ b/parameters/ParameterWrapper.cpp
@@ -123,7 +123,8 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 	for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
 
 		//get the start element of this row in data
-	    uint16_t offset = (((startingRow + fromRow) * columns) + startingColumn);
+	    uint16_t offset = (((startingRow + fromRow) *
+	    		static_cast<uint16_t>(columns)) + startingColumn);
 		T *dataWithDataType = static_cast<T*>(data) + offset;
 
 		for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
@@ -296,8 +297,8 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
 		//need a type to do arithmetic
 		uint8_t* typedData = static_cast<uint8_t*>(data);
 		for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
-			size_t offset = (((startingRow + fromRow) * columns) +
-					startingColumn) * typeSize;
+			size_t offset = (((startingRow + fromRow) * static_cast<uint16_t>(
+					columns)) + startingColumn) * typeSize;
 			std::memcpy(typedData +  offset, from->readonlyData,
 					typeSize * from->columns);
 		}

From 2e1ad41da76ea50847a9fa9756e1751d503ae85c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:18:12 +0100
Subject: [PATCH 1115/1292] power and pus upstream taken over

---
 power/CMakeLists.txt                |  7 +++++++
 pus/CMakeLists.txt                  | 11 +++++++++++
 pus/CService201HealthCommanding.cpp |  6 +++++-
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 power/CMakeLists.txt
 create mode 100644 pus/CMakeLists.txt

diff --git a/power/CMakeLists.txt b/power/CMakeLists.txt
new file mode 100644
index 00000000..1c625db1
--- /dev/null
+++ b/power/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Fuse.cpp
+		PowerComponent.cpp
+		PowerSensor.cpp
+		PowerSwitcher.cpp
+)
\ No newline at end of file
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
new file mode 100644
index 00000000..758c2629
--- /dev/null
+++ b/pus/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CService200ModeCommanding.cpp
+		CService201HealthCommanding.cpp
+		Service17Test.cpp
+		Service1TelecommandVerification.cpp
+		Service2DeviceAccess.cpp
+		Service5EventReporting.cpp
+		Service8FunctionManagement.cpp
+		Service9TimeManagement.cpp
+)
\ No newline at end of file
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index db43db89..edacd73a 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -86,11 +86,15 @@ ReturnValue_t CService201HealthCommanding::handleReply
 		object_id_t objectId, bool *isStep) {
 	Command_t replyId = reply->getCommand();
 	if (replyId == HealthMessage::REPLY_HEALTH_SET) {
-		return prepareHealthSetReply(reply);
+		return EXECUTION_COMPLETE;
+	}
+	else if(replyId == CommandMessageIF::REPLY_REJECTED) {
+		return reply->getReplyRejectedReason();
 	}
 	return CommandingServiceBase::INVALID_REPLY;
 }
 
+// Not used for now, health state already reported by event
 ReturnValue_t CService201HealthCommanding::prepareHealthSetReply(
         const CommandMessage* reply) {
 	prepareHealthSetReply(reply);

From 707bb9dd5d3fe500d511c30f95f7bed596dd9e66 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:18:50 +0100
Subject: [PATCH 1116/1292] serviceinterface taken over

---
 serviceinterface/CMakeLists.txt           | 5 +++++
 serviceinterface/ServiceInterfaceBuffer.h | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 serviceinterface/CMakeLists.txt

diff --git a/serviceinterface/CMakeLists.txt b/serviceinterface/CMakeLists.txt
new file mode 100644
index 00000000..d84adbeb
--- /dev/null
+++ b/serviceinterface/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		ServiceInterfaceStream.cpp
+		ServiceInterfaceBuffer.cpp
+)
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index e69538d1..c5d5b258 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -30,7 +30,7 @@ protected:
 	//! This is called when buffer becomes full. If
 	//! buffer is not used, then this is called every
 	//! time when characters are put to stream.
-	int overflow(int c = std::ostream::traits_type::eof()) override;
+	int overflow(int c = Traits::eof()) override;
 
 	//! This function is called when stream is flushed,
 	//! for example when std::endl is put to stream.

From 41dc9ce6c6942ef92722d9a6c82dde8efa954a88 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:19:30 +0100
Subject: [PATCH 1117/1292] cmake lists form upstream taken over

---
 serialize/CMakeLists.txt      |  4 ++++
 storagemanager/CMakeLists.txt |  2 ++
 tcdistribution/CMakeLists.txt |  7 +++++++
 thermal/CMakeLists.txt        | 10 ++++++++++
 4 files changed, 23 insertions(+)
 create mode 100644 serialize/CMakeLists.txt
 create mode 100644 tcdistribution/CMakeLists.txt
 create mode 100644 thermal/CMakeLists.txt

diff --git a/serialize/CMakeLists.txt b/serialize/CMakeLists.txt
new file mode 100644
index 00000000..fc2387e8
--- /dev/null
+++ b/serialize/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SerialBufferAdapter.cpp
+)
\ No newline at end of file
diff --git a/storagemanager/CMakeLists.txt b/storagemanager/CMakeLists.txt
index 57c92195..b8138cae 100644
--- a/storagemanager/CMakeLists.txt
+++ b/storagemanager/CMakeLists.txt
@@ -2,4 +2,6 @@ target_sources(${LIB_FSFW_NAME}
 	PRIVATE 
 		ConstStorageAccessor.cpp
 		StorageAccessor.cpp
+		LocalPool.cpp
+		PoolManager.cpp
 )
\ No newline at end of file
diff --git a/tcdistribution/CMakeLists.txt b/tcdistribution/CMakeLists.txt
new file mode 100644
index 00000000..17dc186c
--- /dev/null
+++ b/tcdistribution/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		CCSDSDistributor.cpp
+		PUSDistributor.cpp
+		TcDistributor.cpp
+		TcPacketCheck.cpp
+)
diff --git a/thermal/CMakeLists.txt b/thermal/CMakeLists.txt
new file mode 100644
index 00000000..ad532721
--- /dev/null
+++ b/thermal/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		AbstractTemperatureSensor.cpp
+		Heater.cpp
+		RedundantHeater.cpp
+		ThermalComponentCore.cpp
+		ThermalComponent.cpp
+		ThermalModule.cpp
+		ThermalMonitorReporter.cpp
+)

From f905a753e2b7517bdeff19fc9bbaf9435df9f807 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:20:24 +0100
Subject: [PATCH 1118/1292] upstream unittest folder adapted

---
 unittest/testcfg/FSFWConfig.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/testcfg/FSFWConfig.h
index 94f6e59d..6b0def90 100644
--- a/unittest/testcfg/FSFWConfig.h
+++ b/unittest/testcfg/FSFWConfig.h
@@ -21,13 +21,11 @@
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-#define FSFW_DEBUG_OUTPUT 			1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
 #include "objects/translateObjects.h"
 #include "events/translateEvents.h"
 #else
-#define FSFW_DEBUG_OUTPUT			0
 #endif
 
 //! When using the newlib nano library, C99 support for stdio facilities

From 27d03dc17f6bb14a03f85f5c69f21eed485b52ed Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:21:17 +0100
Subject: [PATCH 1119/1292] upstream cmakelists f iles taken over

---
 tmtcpacket/CMakeLists.txt               | 8 ++++++++
 tmtcpacket/packetmatcher/CMakeLists.txt | 4 ++++
 tmtcpacket/pus/CMakeLists.txt           | 8 ++++++++
 3 files changed, 20 insertions(+)
 create mode 100644 tmtcpacket/CMakeLists.txt
 create mode 100644 tmtcpacket/packetmatcher/CMakeLists.txt
 create mode 100644 tmtcpacket/pus/CMakeLists.txt

diff --git a/tmtcpacket/CMakeLists.txt b/tmtcpacket/CMakeLists.txt
new file mode 100644
index 00000000..fe3d2a4d
--- /dev/null
+++ b/tmtcpacket/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		SpacePacket.cpp
+		SpacePacketBase.cpp
+)
+
+add_subdirectory(packetmatcher)
+add_subdirectory(pus)
\ No newline at end of file
diff --git a/tmtcpacket/packetmatcher/CMakeLists.txt b/tmtcpacket/packetmatcher/CMakeLists.txt
new file mode 100644
index 00000000..e9a8d03b
--- /dev/null
+++ b/tmtcpacket/packetmatcher/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		PacketMatchTree.cpp
+)
diff --git a/tmtcpacket/pus/CMakeLists.txt b/tmtcpacket/pus/CMakeLists.txt
new file mode 100644
index 00000000..fcfc82d2
--- /dev/null
+++ b/tmtcpacket/pus/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		TcPacketBase.cpp
+		TcPacketStored.cpp
+		TmPacketBase.cpp
+		TmPacketMinimal.cpp
+		TmPacketStored.cpp
+)

From e55df691ff1d121e5b72dbefd0493aee737ef55e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:24:15 +0100
Subject: [PATCH 1120/1292] upstream subsystem taken over

---
 subsystem/Subsystem.h | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h
index c3a72d54..69563643 100644
--- a/subsystem/Subsystem.h
+++ b/subsystem/Subsystem.h
@@ -62,21 +62,6 @@ public:
 
 	virtual MessageQueueId_t getSequenceCommandQueue() const override;
 
-	/**
-	 * @brief    Checks whether a sequence, identified by a mode.
-	 * @param sequence
-	 * @return
-	 */
-	ReturnValue_t checkSequence(Mode_t sequence);
-
-	/**
-	 * @brief   Checks whether a sequence, identified by a mode list iterator
-	 *          and a fallback sequence.
-	 * @param iter
-	 * @return
-	 */
-	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
-	        Mode_t fallbackSequence);
 protected:
 
 	struct EntryPointer {
@@ -166,6 +151,22 @@ protected:
 
 	void cantKeepMode();
 
+	/**
+	 * @brief    Checks whether a sequence, identified by a mode.
+	 * @param sequence
+	 * @return
+	 */
+	ReturnValue_t checkSequence(Mode_t sequence);
+
+	/**
+	 * @brief   Checks whether a sequence, identified by a mode list iterator
+	 *          and a fallback sequence. Iterator needs to point to a valid
+	 *          sequence.
+	 * @param iter
+	 * @return
+	 */
+	ReturnValue_t checkSequence(HybridIterator<ModeListEntry> iter,
+	        Mode_t fallbackSequence);
 };
 
 #endif /* FSFW_SUBSYSTEM_SUBSYSTEM_H_ */

From 208ad7d479d983f77629ee6b86ca19c24d2ed95b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 22 Dec 2020 16:24:52 +0100
Subject: [PATCH 1121/1292] fixed timeslot task doc

---
 tasks/FixedTimeslotTaskIF.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h
index a138db4e..2fc7e092 100644
--- a/tasks/FixedTimeslotTaskIF.h
+++ b/tasks/FixedTimeslotTaskIF.h
@@ -14,7 +14,8 @@ public:
 
 	/**
 	 * Add an object with a slot time and the execution step to the task.
-	 * The execution step shall be passed to the object.
+	 * The execution step will be passed to the object (e.g. as an operation
+	 * code in #performOperation)
 	 * @param componentId
 	 * @param slotTimeMs
 	 * @param executionStep

From 68fe923a014533e1097465e0b279aaaff9e34f86 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 24 Dec 2020 02:03:33 +0100
Subject: [PATCH 1122/1292] renamed class enums

---
 datapool/PoolDataSetBase.cpp | 12 ++++++------
 datapool/PoolDataSetBase.h   |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f7..49495a88 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -11,7 +11,7 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,7 +33,7 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
@@ -41,7 +41,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				break;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -80,7 +80,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -99,7 +99,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 			registeredVariables[count]->commitWithoutLock();
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -121,7 +121,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d62..66a1924c 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -124,14 +124,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		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::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.

From 3486a04741a1705d67f450c312e099935973552d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Dec 2020 00:37:24 +0100
Subject: [PATCH 1123/1292] renaming for name shadowing

---
 datapool/PoolDataSetBase.cpp | 12 ++++++------
 datapool/PoolDataSetBase.h   |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f7..49495a88 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -11,7 +11,7 @@ PoolDataSetBase::~PoolDataSetBase() {}
 
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,7 +33,7 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
@@ -41,7 +41,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				break;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -80,7 +80,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -99,7 +99,7 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 			registeredVariables[count]->commitWithoutLock();
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -121,7 +121,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d62..66a1924c 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -124,14 +124,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		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::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.

From 9eec75df263f3c184a279281a793b520c5daed81 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 25 Dec 2020 01:49:44 +0100
Subject: [PATCH 1124/1292] linking against thread lib

---
 osal/host/CMakeLists.txt  | 2 +-
 osal/linux/CMakeLists.txt | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index aa32990b..ee6b4cdb 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -16,6 +16,6 @@ if(UNIX)
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
-		pthread
+		${CMAKE_THREAD_LIBS_INIT}
 	)
 endif()
\ No newline at end of file
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index c0096e42..e9a2935b 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,8 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
-target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
-		pthread
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+	${CMAKE_THREAD_LIBS_INIT}
+	rt
 )
+

From b469340ef45fc63c65069874e413c9aeeab198b3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 18:06:56 +0100
Subject: [PATCH 1125/1292] bugfix

---
 datapoollocal/LocalPoolVariable.tpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 48649ad5..fb129635 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -40,11 +40,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK and poolEntry != nullptr) {
+	if(result != RETURN_OK or poolEntry == nullptr) {
 		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,7 +62,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}

From e35c2cd604658ac83850aa27891543e461f3a1e9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 23:16:33 +0100
Subject: [PATCH 1126/1292] hk manager optional now

---
 datapoollocal/LocalPoolDataSetBase.cpp | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 640956db..dc81a612 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -34,13 +34,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner == nullptr) {
-        // Configuration error.
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
-        return;
+    if(hkOwner != nullptr) {
+    	hkManager = hkOwner->getHkManagerHandle();
     }
-    hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
 
     mutex = MutexFactory::instance()->createMutex();
@@ -50,8 +46,11 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -127,8 +126,11 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->unlockMutex();
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->unlockMutex();
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,

From 76696e34be711277fdbdd07575380f1e2b294a17 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 26 Dec 2020 23:57:23 +0100
Subject: [PATCH 1127/1292] its possible to protect every read/commit now

---
 datapool/PoolDataSetBase.cpp           | 31 +++++++++++++++++++++++---
 datapool/PoolDataSetBase.h             | 13 +++++++++++
 datapoollocal/LocalPoolDataSetBase.cpp | 10 +++++++--
 datapoollocal/LocalPoolDataSetBase.h   | 13 ++++++++++-
 4 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 49495a88..ad1de8e4 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -9,6 +9,8 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 
 PoolDataSetBase::~PoolDataSetBase() {}
 
+
+
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
@@ -71,7 +73,13 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 		registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER)
 	{
-		result = registeredVariables[count]->readWithoutLock();
+		if(protectEveryReadCommitCall) {
+			result = registeredVariables[count]->read(mutexTimeout);
+		}
+		else {
+			result = registeredVariables[count]->readWithoutLock();
+		}
+
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			result = INVALID_PARAMETER_DEFINITION;
 		}
@@ -96,7 +104,12 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				registeredVariables[count]->commitWithoutLock();
+			}
 		}
 	}
 	state = States::STATE_SET_UNINITIALISED;
@@ -111,7 +124,13 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				result = registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				result = registeredVariables[count]->commitWithoutLock();
+			}
+
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -172,3 +191,9 @@ size_t PoolDataSetBase::getSerializedSize() const {
 void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	this->protectEveryReadCommitCall = protectEveryReadCommit;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 66a1924c..3f52fcd0 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -89,6 +89,7 @@ public:
 	 * @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
@@ -114,6 +115,15 @@ public:
 	        SerializeIF::Endianness streamEndianness) override;
 
 protected:
+
+	/**
+	 * Can be used to individually protect every read and commit call.
+	 * @param protectEveryReadCommit
+	 * @param mutexTimeout
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -144,6 +154,9 @@ protected:
 	void setContainer(PoolVariableIF** variablesContainer);
 
 private:
+	bool protectEveryReadCommitCall = false;
+	uint32_t mutexTimeout = 20;
+
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dc81a612..9ecad218 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
@@ -23,7 +23,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
-    if(not noPeriodicHandling) {
+    if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
@@ -278,3 +278,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     }
     this->valid = valid;
 }
+
+void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
+			mutexTimeout);
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index aa155bf1..7eabd368 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -54,7 +54,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
+	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
 	 * @brief	Constructor for users of local pool data.
@@ -77,6 +77,16 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	/**
+	 * If the data is pulled from different local data pools, every read and
+	 * commit call should be mutex protected for thread safety.
+	 * This can be specified with the second parameter.
+	 * @param dataCreator
+	 * @param protectEveryReadCommit
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -128,6 +138,7 @@ public:
 
 protected:
 	sid_t sid;
+	uint32_t mutexTimeout = 20;
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;

From 639dbee8a342593f6b765b0efff09f69606d3563 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 00:21:39 +0100
Subject: [PATCH 1128/1292] form stuff

---
 datapoollocal/LocalPoolVariable.tpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index fb129635..a685ea8d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -11,14 +11,14 @@ inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 

From 535b51ef7046b9e056371092737c07069dbb2ff1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:15:52 +0100
Subject: [PATCH 1129/1292] improvements and clarifications

---
 datapool/PoolDataSetBase.cpp         |  7 ++++++-
 datapool/PoolDataSetBase.h           | 15 ++++++++++-----
 datapoollocal/HasLocalDataPoolIF.h   |  3 +++
 datapoollocal/LocalDataPoolManager.h | 15 ++++++---------
 4 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index ad1de8e4..63cbe73e 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -35,12 +35,13 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	ReturnValue_t error = result;
 	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
-				break;
+				error = result;
 			}
 		}
 		state = States::STATE_SET_WAS_READ;
@@ -52,6 +53,10 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
+
+	if(error != HasReturnvaluesIF::RETURN_OK) {
+		result = error;
+	}
 	return result;
 }
 
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 3f52fcd0..18715b1b 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -44,7 +44,11 @@ public:
 
 	/**
 	 * @brief	The read call initializes reading out all registered variables.
+	 * 			It is mandatory to call commit after every read call!
 	 * @details
+	 *
+	 * TODO: Write RAII helper so user can not forget to call commit anymore.
+	 *
 	 * 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.
@@ -52,13 +56,14 @@ public:
 	 * 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.
+	 * 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 PID, size or type of the
-	 * requested variable is invalid.
+	 * - @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
+	 *      commit() in between
 	 */
 	virtual ReturnValue_t read(uint32_t lockTimeout =
 			MutexIF::BLOCKING) override;
@@ -75,7 +80,7 @@ public:
 	 * 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.
+	 * 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
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7f1f202e..df855110 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -44,6 +44,9 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c4024cf9..cdefa2c2 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -55,14 +55,11 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
-
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -380,14 +377,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localPoolMap.end()) {
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
+		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }

From f852c774f8e41a6ebf00b5cb6e5e24a815345837 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:52:48 +0100
Subject: [PATCH 1130/1292] accessor test

---
 datapool/PoolDataSetIF.h               |  6 ++--
 datapool/PoolVariableIF.h              | 40 ++-----------------------
 datapool/ReadCommitIF.h                | 31 +++++++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/PoolReadHelper.h         | 41 ++++++++++++++++++++++++++
 5 files changed, 78 insertions(+), 42 deletions(-)
 create mode 100644 datapool/ReadCommitIF.h
 create mode 100644 datapoollocal/PoolReadHelper.h

diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index aa45fa54..99c06cfd 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,19 +1,17 @@
 #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: public DataSetIF {
+class PoolDataSetIF: public DataSetIF, public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 
-    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
-    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
-
     /**
      * @brief   Most underlying data structures will have a pool like structure
      *          and will require a lock and unlock mechanism to ensure
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index cd15f744..9740fc12 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include "ReadCommitIF.h"
 
 /**
  * @brief	This interface is used to control data pool
@@ -17,9 +18,9 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF {
+class PoolVariableIF : public SerializeIF,
+		public ReadCommitIF {
 	friend class PoolDataSetBase;
-	friend class GlobDataSet;
 	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
@@ -57,41 +58,6 @@ public:
 	 */
 	virtual void setValid(bool validity) = 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;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
new file mode 100644
index 00000000..0cdce371
--- /dev/null
+++ b/datapool/ReadCommitIF.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 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(20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a362..5f0d15d3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
new file mode 100644
index 00000000..4fe506ee
--- /dev/null
+++ b/datapoollocal/PoolReadHelper.h
@@ -0,0 +1,41 @@
+#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadHelper {
+public:
+	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+			readObject(readObject), mutexTimeout(mutexTimeout) {
+		if(readObject != nullptr) {
+			readResult = readObject->read(mutexTimeout);
+#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
+		}
+	}
+
+	ReturnValue_t getReadResult() const {
+		return readResult;
+	}
+
+	~PoolReadHelper() {
+		if(readObject != nullptr) {
+			readObject->commit(mutexTimeout);
+		}
+
+	}
+
+private:
+	ReadCommitIF* readObject = nullptr;
+	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */

From 76403ce0aba4ae4b68d2011a40310f7573296d62 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 01:53:59 +0100
Subject: [PATCH 1131/1292] renaming

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a362..5f0d15d3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;

From ed473d0a1bbd6bc80c3526eb2a02b8586bbfeec7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 02:04:45 +0100
Subject: [PATCH 1132/1292] bugfix

---
 datapoollocal/LocalPoolDataSetBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 7eabd368..d9b6a221 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -192,7 +192,7 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager;
+	LocalDataPoolManager* hkManager = nullptr;
 
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0

From e24e50b5eea21840a1f74f451baffddc96637ae4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 12:58:05 +0100
Subject: [PATCH 1133/1292] removed todo

---
 datapool/PoolDataSetBase.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 18715b1b..7c1d84a4 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -46,9 +46,6 @@ public:
 	 * @brief	The read call initializes reading out all registered variables.
 	 * 			It is mandatory to call commit after every read call!
 	 * @details
-	 *
-	 * TODO: Write RAII helper so user can not forget to call commit anymore.
-	 *
 	 * 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.

From 39887db8d2b457aeb5edc0801c136d44e6d8258c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 12:59:25 +0100
Subject: [PATCH 1134/1292] removed newline

---
 datapool/PoolDataSetBase.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 63cbe73e..8f073359 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -10,7 +10,6 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 PoolDataSetBase::~PoolDataSetBase() {}
 
 
-
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {

From 37463b660b626133c53376fedfb98646a82b11be Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:14:38 +0100
Subject: [PATCH 1135/1292] restructured test folder and enabled cmake v3
 support

---
 unittest/CMakeLists.txt                          |  2 ++
 unittest/internal/CMakeLists.txt                 |  7 +++++++
 unittest/internal/osal/CMakeLists.txt            |  5 +++++
 unittest/internal/serialize/CMakeLists.txt       |  3 +++
 unittest/tests/CMakeLists.txt                    |  6 ++++++
 unittest/tests/action/CMakeLists.txt             |  3 +++
 unittest/tests/action/TestActionHelper.cpp       |  7 +++++--
 unittest/tests/action/TestActionHelper.h         |  2 +-
 unittest/tests/container/CMakeLists.txt          | 10 ++++++++++
 unittest/tests/container/RingBufferTest.cpp      |  6 +++---
 unittest/tests/container/TestArrayList.cpp       |  8 ++++----
 unittest/tests/container/TestDynamicFifo.cpp     | 11 +++++------
 unittest/tests/container/TestFifo.cpp            | 11 +++++------
 unittest/tests/container/TestFixedArrayList.cpp  |  9 ++++-----
 unittest/tests/container/TestFixedMap.cpp        |  8 ++++----
 .../tests/container/TestFixedOrderedMultimap.cpp |  8 ++++----
 unittest/tests/osal/CMakeLists.txt               |  4 ++++
 unittest/tests/osal/TestMessageQueue.cpp         | 10 ++++++----
 unittest/tests/serialize/CMakeLists.txt          |  5 +++++
 .../tests/serialize/TestSerialBufferAdapter.cpp  |  8 +++++---
 .../tests/serialize/TestSerialLinkedPacket.cpp   |  9 ++++++---
 .../tests/serialize/TestSerialLinkedPacket.h     |  2 +-
 unittest/tests/serialize/TestSerialization.cpp   | 16 +++++++++-------
 unittest/tests/storagemanager/CMakeLists.txt     |  4 ++++
 unittest/tests/storagemanager/TestPool.cpp       |  6 ++----
 unittest/user/CMakeLists.txt                     |  1 +
 unittest/user/testcfg/CMakeLists.txt             | 11 +++++++++++
 unittest/{ => user}/testcfg/FSFWConfig.h         |  0
 unittest/{ => user}/testcfg/Makefile-FSFW-Tests  |  0
 unittest/{ => user}/testcfg/TestsConfig.h        |  0
 .../testcfg/cdatapool/dataPoolInit.cpp           |  0
 .../{ => user}/testcfg/cdatapool/dataPoolInit.h  |  0
 .../testcfg/devices/logicalAddresses.cpp         |  0
 .../testcfg/devices/logicalAddresses.h           |  0
 .../testcfg/devices/powerSwitcherList.cpp        |  0
 .../testcfg/devices/powerSwitcherList.h          |  0
 .../testcfg/events/subsystemIdRanges.h           |  0
 .../testcfg/ipc/MissionMessageTypes.cpp          |  0
 .../{ => user}/testcfg/ipc/MissionMessageTypes.h |  0
 .../testcfg/objects/systemObjectList.h           |  0
 .../pollingsequence/PollingSequenceFactory.cpp   |  0
 .../pollingsequence/PollingSequenceFactory.h     |  0
 .../{ => user}/testcfg/returnvalues/classIds.h   |  0
 unittest/{ => user}/testcfg/testcfg.mk           |  0
 unittest/{ => user}/testcfg/tmtc/apid.h          |  0
 unittest/{ => user}/testcfg/tmtc/pusIds.h        |  0
 .../{ => user}/testtemplate/TestTemplate.cpp     |  0
 unittest/user/unittest/core/CMakeLists.txt       |  7 +++++++
 .../unittest}/core/CatchDefinitions.cpp          |  0
 .../{ => user/unittest}/core/CatchDefinitions.h  |  0
 .../{ => user/unittest}/core/CatchFactory.cpp    |  0
 unittest/{ => user/unittest}/core/CatchFactory.h |  0
 .../{ => user/unittest}/core/CatchRunner.cpp     |  0
 unittest/{ => user/unittest}/core/CatchSetup.cpp |  0
 unittest/{ => user/unittest}/core/core.mk        |  0
 unittest/{ => user/unittest}/core/printChar.cpp  |  0
 unittest/{ => user/unittest}/core/printChar.h    |  0
 unittest/{ => user}/unlockRealtime.sh            |  0
 58 files changed, 132 insertions(+), 57 deletions(-)
 create mode 100644 unittest/CMakeLists.txt
 create mode 100644 unittest/internal/CMakeLists.txt
 create mode 100644 unittest/internal/osal/CMakeLists.txt
 create mode 100644 unittest/internal/serialize/CMakeLists.txt
 create mode 100644 unittest/tests/CMakeLists.txt
 create mode 100644 unittest/tests/action/CMakeLists.txt
 create mode 100644 unittest/tests/container/CMakeLists.txt
 create mode 100644 unittest/tests/osal/CMakeLists.txt
 create mode 100644 unittest/tests/serialize/CMakeLists.txt
 create mode 100644 unittest/tests/storagemanager/CMakeLists.txt
 create mode 100644 unittest/user/CMakeLists.txt
 create mode 100644 unittest/user/testcfg/CMakeLists.txt
 rename unittest/{ => user}/testcfg/FSFWConfig.h (100%)
 rename unittest/{ => user}/testcfg/Makefile-FSFW-Tests (100%)
 rename unittest/{ => user}/testcfg/TestsConfig.h (100%)
 rename unittest/{ => user}/testcfg/cdatapool/dataPoolInit.cpp (100%)
 rename unittest/{ => user}/testcfg/cdatapool/dataPoolInit.h (100%)
 rename unittest/{ => user}/testcfg/devices/logicalAddresses.cpp (100%)
 rename unittest/{ => user}/testcfg/devices/logicalAddresses.h (100%)
 rename unittest/{ => user}/testcfg/devices/powerSwitcherList.cpp (100%)
 rename unittest/{ => user}/testcfg/devices/powerSwitcherList.h (100%)
 rename unittest/{ => user}/testcfg/events/subsystemIdRanges.h (100%)
 rename unittest/{ => user}/testcfg/ipc/MissionMessageTypes.cpp (100%)
 rename unittest/{ => user}/testcfg/ipc/MissionMessageTypes.h (100%)
 rename unittest/{ => user}/testcfg/objects/systemObjectList.h (100%)
 rename unittest/{ => user}/testcfg/pollingsequence/PollingSequenceFactory.cpp (100%)
 rename unittest/{ => user}/testcfg/pollingsequence/PollingSequenceFactory.h (100%)
 rename unittest/{ => user}/testcfg/returnvalues/classIds.h (100%)
 rename unittest/{ => user}/testcfg/testcfg.mk (100%)
 rename unittest/{ => user}/testcfg/tmtc/apid.h (100%)
 rename unittest/{ => user}/testcfg/tmtc/pusIds.h (100%)
 rename unittest/{ => user}/testtemplate/TestTemplate.cpp (100%)
 create mode 100644 unittest/user/unittest/core/CMakeLists.txt
 rename unittest/{ => user/unittest}/core/CatchDefinitions.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchDefinitions.h (100%)
 rename unittest/{ => user/unittest}/core/CatchFactory.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchFactory.h (100%)
 rename unittest/{ => user/unittest}/core/CatchRunner.cpp (100%)
 rename unittest/{ => user/unittest}/core/CatchSetup.cpp (100%)
 rename unittest/{ => user/unittest}/core/core.mk (100%)
 rename unittest/{ => user/unittest}/core/printChar.cpp (100%)
 rename unittest/{ => user/unittest}/core/printChar.h (100%)
 rename unittest/{ => user}/unlockRealtime.sh (100%)

diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
new file mode 100644
index 00000000..119ef243
--- /dev/null
+++ b/unittest/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(internal)
+add_subdirectory(tests)
\ No newline at end of file
diff --git a/unittest/internal/CMakeLists.txt b/unittest/internal/CMakeLists.txt
new file mode 100644
index 00000000..9c24317f
--- /dev/null
+++ b/unittest/internal/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} PRIVATE
+	InternalUnitTester.cpp
+	UnittDefinitions.cpp
+)
+
+add_subdirectory(osal)
+add_subdirectory(serialize)
\ No newline at end of file
diff --git a/unittest/internal/osal/CMakeLists.txt b/unittest/internal/osal/CMakeLists.txt
new file mode 100644
index 00000000..c6f1eb95
--- /dev/null
+++ b/unittest/internal/osal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${TARGET_NAME} PRIVATE
+	IntTestMq.cpp
+	IntTestMutex.cpp
+	IntTestSemaphore.cpp
+)
diff --git a/unittest/internal/serialize/CMakeLists.txt b/unittest/internal/serialize/CMakeLists.txt
new file mode 100644
index 00000000..e8dc5717
--- /dev/null
+++ b/unittest/internal/serialize/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	IntTestSerialization.cpp
+)
diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
new file mode 100644
index 00000000..97074417
--- /dev/null
+++ b/unittest/tests/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_subdirectory(action)
+add_subdirectory(container)
+add_subdirectory(osal)
+add_subdirectory(serialize)
+add_subdirectory(storagemanager)
+
diff --git a/unittest/tests/action/CMakeLists.txt b/unittest/tests/action/CMakeLists.txt
new file mode 100644
index 00000000..0339000f
--- /dev/null
+++ b/unittest/tests/action/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestActionHelper.cpp
+)
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 944ad705..3109eba1 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -1,8 +1,11 @@
 #include "TestActionHelper.h"
+
+#include <unittest/core/CatchDefinitions.h>
+
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+
+#include <catch2/catch_test_macros.hpp>
 
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 4ba417eb..610fb09e 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -3,7 +3,7 @@
 
 #include <fsfw/action/HasActionsIF.h>
 #include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/unittest/core/CatchDefinitions.h>
+#include <unittest/core/CatchDefinitions.h>
 #include <cstring>
 
 
diff --git a/unittest/tests/container/CMakeLists.txt b/unittest/tests/container/CMakeLists.txt
new file mode 100644
index 00000000..966c5834
--- /dev/null
+++ b/unittest/tests/container/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(${TARGET_NAME} PRIVATE
+	RingBufferTest.cpp
+	TestArrayList.cpp
+	TestDynamicFifo.cpp
+	TestFifo.cpp
+	TestFixedArrayList.cpp
+	TestFixedMap.cpp
+	TestFixedOrderedMultimap.cpp
+	TestPlacementFactory.cpp
+)
diff --git a/unittest/tests/container/RingBufferTest.cpp b/unittest/tests/container/RingBufferTest.cpp
index 9c1c8a23..32a2502d 100644
--- a/unittest/tests/container/RingBufferTest.cpp
+++ b/unittest/tests/container/RingBufferTest.cpp
@@ -1,7 +1,7 @@
-#include "../../core/CatchDefinitions.h"
-#include "../../container/SimpleRingBuffer.h"
+#include <unittest/core/CatchDefinitions.h>
+#include <fsfw/container/SimpleRingBuffer.h>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include <cstring>
 
 TEST_CASE("Ring Buffer Test" , "[RingBufferTest]") {
diff --git a/unittest/tests/container/TestArrayList.cpp b/unittest/tests/container/TestArrayList.cpp
index 2f884276..1fd330b6 100644
--- a/unittest/tests/container/TestArrayList.cpp
+++ b/unittest/tests/container/TestArrayList.cpp
@@ -1,8 +1,8 @@
-#include "../../container/ArrayList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 /**
  * @brief 	Array List test
diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index bb19131e..759fcc66 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,10 +1,9 @@
+#include "../../../container/DynamicFIFO.h"
+#include "../../../container/FIFO.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/DynamicFIFO.h"
-#include "../../container/FIFO.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch.hpp>
-#include <CatchDefinitions.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "Dynamic Fifo Tests", "[TestDynamicFifo]") {
 	INFO("Dynamic Fifo Tests");
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index bd727e00..f7bfb1de 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,10 +1,9 @@
+#include "../../../container/DynamicFIFO.h"
+#include "../../../container/FIFO.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/DynamicFIFO.h"
-#include "../../container/FIFO.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "Static Fifo Tests", "[TestFifo]") {
 	INFO("Fifo Tests");
diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index 5a1bd280..b2baa3e7 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,9 +1,8 @@
-#include "../../core/CatchDefinitions.h"
+#include "../../../container/FixedArrayList.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include "../../container/FixedArrayList.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 
 TEST_CASE( "FixedArrayList Tests", "[TestFixedArrayList]") {
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index da0c84e3..f93065b6 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,8 +1,8 @@
-#include "../../container/FixedMap.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../container/FixedMap.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 template class FixedMap<unsigned int, unsigned short>;
 
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index e625b559..b337a9c8 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,8 +1,8 @@
-#include "../../container/FixedOrderedMultimap.h"
-#include "../../returnvalues/HasReturnvaluesIF.h"
+#include "../../../container/FixedOrderedMultimap.h"
+#include "../../../returnvalues/HasReturnvaluesIF.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
 	INFO("FixedOrderedMultimap Tests");
diff --git a/unittest/tests/osal/CMakeLists.txt b/unittest/tests/osal/CMakeLists.txt
new file mode 100644
index 00000000..5ca5e400
--- /dev/null
+++ b/unittest/tests/osal/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestMessageQueue.cpp
+	TestSemaphore.cpp
+)
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 441d32e7..5360974f 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,8 +1,10 @@
-#include "../../ipc/MessageQueueIF.h"
-#include "../../ipc/QueueFactory.h"
-#include <catch.hpp>
+#include "../../../ipc/MessageQueueIF.h"
+#include "../../../ipc/QueueFactory.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
 #include <array>
-#include "../../core/CatchDefinitions.h"
 
 TEST_CASE("MessageQueue Basic Test","[TestMq]") {
 	MessageQueueIF* testSenderMq =
diff --git a/unittest/tests/serialize/CMakeLists.txt b/unittest/tests/serialize/CMakeLists.txt
new file mode 100644
index 00000000..5a9d9a0f
--- /dev/null
+++ b/unittest/tests/serialize/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestSerialBufferAdapter.cpp
+	TestSerialization.cpp
+	TestSerialLinkedPacket.cpp
+)
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 07cd3f9c..778f857e 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,7 +1,9 @@
-#include "../../serialize/SerialBufferAdapter.h"
+#include "../../../serialize/SerialBufferAdapter.h"
 
-#include <catch2/catch.hpp>
-#include "../../core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+#include <array>
 
 
 static bool test_value_bool = true;
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index fbe48894..83bdf857 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,9 +1,12 @@
 #include "TestSerialLinkedPacket.h"
-#include "../../core/CatchDefinitions.h"
+#include <unittest/core/CatchDefinitions.h>
 
-#include "../../globalfunctions/arrayprinter.h"
+#include "../../../globalfunctions/arrayprinter.h"
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+#include <array>
 
 
 TEST_CASE("Serial Linked Packet" , "[SerLinkPacket]") {
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.h b/unittest/tests/serialize/TestSerialLinkedPacket.h
index 6c720577..71f258f9 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.h
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.h
@@ -37,7 +37,7 @@ public:
 		return buffer.entry.getConstBuffer();
 	}
 
-	const size_t getBufferLength() {
+	size_t getBufferLength() {
 		return buffer.getSerializedSize();
 	}
 
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 6e31170a..2877d09a 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,8 +1,10 @@
-#include "../../serialize/SerializeAdapter.h"
+#include "../../../serialize/SerializeAdapter.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
-#include "catch.hpp"
 #include <array>
-#include "../../core/CatchDefinitions.h"
 
 static bool test_value_bool = true;
 static uint8_t tv_uint8   {5};
@@ -119,10 +121,10 @@ TEST_CASE("Auto Serialize Adapter testing", "[single-file]") {
 		REQUIRE(tv_int16 == -829);
 		REQUIRE(tv_int32 == -2312);
 
-		REQUIRE(tv_float == Approx(8.214921));
-		REQUIRE(tv_double == Approx(9.2132142141e8));
-		REQUIRE(tv_sfloat == Approx(-922.2321321));
-		REQUIRE(tv_sdouble == Approx(-2.2421e19));
+		REQUIRE(tv_float == Catch::Approx(8.214921));
+		REQUIRE(tv_double == Catch::Approx(9.2132142141e8));
+		REQUIRE(tv_sfloat == Catch::Approx(-922.2321321));
+		REQUIRE(tv_sdouble == Catch::Approx(-2.2421e19));
 	}
 }
 
diff --git a/unittest/tests/storagemanager/CMakeLists.txt b/unittest/tests/storagemanager/CMakeLists.txt
new file mode 100644
index 00000000..ed7be7d5
--- /dev/null
+++ b/unittest/tests/storagemanager/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(${TARGET_NAME} PRIVATE
+	TestNewAccessor.cpp
+	TestPool.cpp
+)
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index daeb6bb5..dcfb6c03 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -1,10 +1,8 @@
-#include "CatchDefinitions.h"
-
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/storagemanager/LocalPool.h>
 
-#include <catch.hpp>
-#include <CatchDefinitions.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
 
 #include <cstring>
 
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
new file mode 100644
index 00000000..ad6d4787
--- /dev/null
+++ b/unittest/user/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/testcfg/CMakeLists.txt b/unittest/user/testcfg/CMakeLists.txt
new file mode 100644
index 00000000..dbf0256f
--- /dev/null
+++ b/unittest/user/testcfg/CMakeLists.txt
@@ -0,0 +1,11 @@
+target_sources(${TARGET_NAME} 
+	PRIVATE
+		ipc/MissionMessageTypes.cpp
+		pollingsequence/PollingSequenceFactory.cpp
+)
+
+# Add include paths for the executable
+target_include_directories(${TARGET_NAME} 
+	PUBLIC 
+		${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/unittest/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
similarity index 100%
rename from unittest/testcfg/FSFWConfig.h
rename to unittest/user/testcfg/FSFWConfig.h
diff --git a/unittest/testcfg/Makefile-FSFW-Tests b/unittest/user/testcfg/Makefile-FSFW-Tests
similarity index 100%
rename from unittest/testcfg/Makefile-FSFW-Tests
rename to unittest/user/testcfg/Makefile-FSFW-Tests
diff --git a/unittest/testcfg/TestsConfig.h b/unittest/user/testcfg/TestsConfig.h
similarity index 100%
rename from unittest/testcfg/TestsConfig.h
rename to unittest/user/testcfg/TestsConfig.h
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.cpp b/unittest/user/testcfg/cdatapool/dataPoolInit.cpp
similarity index 100%
rename from unittest/testcfg/cdatapool/dataPoolInit.cpp
rename to unittest/user/testcfg/cdatapool/dataPoolInit.cpp
diff --git a/unittest/testcfg/cdatapool/dataPoolInit.h b/unittest/user/testcfg/cdatapool/dataPoolInit.h
similarity index 100%
rename from unittest/testcfg/cdatapool/dataPoolInit.h
rename to unittest/user/testcfg/cdatapool/dataPoolInit.h
diff --git a/unittest/testcfg/devices/logicalAddresses.cpp b/unittest/user/testcfg/devices/logicalAddresses.cpp
similarity index 100%
rename from unittest/testcfg/devices/logicalAddresses.cpp
rename to unittest/user/testcfg/devices/logicalAddresses.cpp
diff --git a/unittest/testcfg/devices/logicalAddresses.h b/unittest/user/testcfg/devices/logicalAddresses.h
similarity index 100%
rename from unittest/testcfg/devices/logicalAddresses.h
rename to unittest/user/testcfg/devices/logicalAddresses.h
diff --git a/unittest/testcfg/devices/powerSwitcherList.cpp b/unittest/user/testcfg/devices/powerSwitcherList.cpp
similarity index 100%
rename from unittest/testcfg/devices/powerSwitcherList.cpp
rename to unittest/user/testcfg/devices/powerSwitcherList.cpp
diff --git a/unittest/testcfg/devices/powerSwitcherList.h b/unittest/user/testcfg/devices/powerSwitcherList.h
similarity index 100%
rename from unittest/testcfg/devices/powerSwitcherList.h
rename to unittest/user/testcfg/devices/powerSwitcherList.h
diff --git a/unittest/testcfg/events/subsystemIdRanges.h b/unittest/user/testcfg/events/subsystemIdRanges.h
similarity index 100%
rename from unittest/testcfg/events/subsystemIdRanges.h
rename to unittest/user/testcfg/events/subsystemIdRanges.h
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.cpp b/unittest/user/testcfg/ipc/MissionMessageTypes.cpp
similarity index 100%
rename from unittest/testcfg/ipc/MissionMessageTypes.cpp
rename to unittest/user/testcfg/ipc/MissionMessageTypes.cpp
diff --git a/unittest/testcfg/ipc/MissionMessageTypes.h b/unittest/user/testcfg/ipc/MissionMessageTypes.h
similarity index 100%
rename from unittest/testcfg/ipc/MissionMessageTypes.h
rename to unittest/user/testcfg/ipc/MissionMessageTypes.h
diff --git a/unittest/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
similarity index 100%
rename from unittest/testcfg/objects/systemObjectList.h
rename to unittest/user/testcfg/objects/systemObjectList.h
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
similarity index 100%
rename from unittest/testcfg/pollingsequence/PollingSequenceFactory.cpp
rename to unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
diff --git a/unittest/testcfg/pollingsequence/PollingSequenceFactory.h b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.h
similarity index 100%
rename from unittest/testcfg/pollingsequence/PollingSequenceFactory.h
rename to unittest/user/testcfg/pollingsequence/PollingSequenceFactory.h
diff --git a/unittest/testcfg/returnvalues/classIds.h b/unittest/user/testcfg/returnvalues/classIds.h
similarity index 100%
rename from unittest/testcfg/returnvalues/classIds.h
rename to unittest/user/testcfg/returnvalues/classIds.h
diff --git a/unittest/testcfg/testcfg.mk b/unittest/user/testcfg/testcfg.mk
similarity index 100%
rename from unittest/testcfg/testcfg.mk
rename to unittest/user/testcfg/testcfg.mk
diff --git a/unittest/testcfg/tmtc/apid.h b/unittest/user/testcfg/tmtc/apid.h
similarity index 100%
rename from unittest/testcfg/tmtc/apid.h
rename to unittest/user/testcfg/tmtc/apid.h
diff --git a/unittest/testcfg/tmtc/pusIds.h b/unittest/user/testcfg/tmtc/pusIds.h
similarity index 100%
rename from unittest/testcfg/tmtc/pusIds.h
rename to unittest/user/testcfg/tmtc/pusIds.h
diff --git a/unittest/testtemplate/TestTemplate.cpp b/unittest/user/testtemplate/TestTemplate.cpp
similarity index 100%
rename from unittest/testtemplate/TestTemplate.cpp
rename to unittest/user/testtemplate/TestTemplate.cpp
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
new file mode 100644
index 00000000..d78f45f1
--- /dev/null
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${TARGET_NAME} PRIVATE
+	CatchDefinitions.cpp
+	CatchFactory.cpp
+	CatchRunner.cpp
+	CatchSetup.cpp
+	printChar.cpp
+)
diff --git a/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
similarity index 100%
rename from unittest/core/CatchDefinitions.cpp
rename to unittest/user/unittest/core/CatchDefinitions.cpp
diff --git a/unittest/core/CatchDefinitions.h b/unittest/user/unittest/core/CatchDefinitions.h
similarity index 100%
rename from unittest/core/CatchDefinitions.h
rename to unittest/user/unittest/core/CatchDefinitions.h
diff --git a/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
similarity index 100%
rename from unittest/core/CatchFactory.cpp
rename to unittest/user/unittest/core/CatchFactory.cpp
diff --git a/unittest/core/CatchFactory.h b/unittest/user/unittest/core/CatchFactory.h
similarity index 100%
rename from unittest/core/CatchFactory.h
rename to unittest/user/unittest/core/CatchFactory.h
diff --git a/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
similarity index 100%
rename from unittest/core/CatchRunner.cpp
rename to unittest/user/unittest/core/CatchRunner.cpp
diff --git a/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
similarity index 100%
rename from unittest/core/CatchSetup.cpp
rename to unittest/user/unittest/core/CatchSetup.cpp
diff --git a/unittest/core/core.mk b/unittest/user/unittest/core/core.mk
similarity index 100%
rename from unittest/core/core.mk
rename to unittest/user/unittest/core/core.mk
diff --git a/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
similarity index 100%
rename from unittest/core/printChar.cpp
rename to unittest/user/unittest/core/printChar.cpp
diff --git a/unittest/core/printChar.h b/unittest/user/unittest/core/printChar.h
similarity index 100%
rename from unittest/core/printChar.h
rename to unittest/user/unittest/core/printChar.h
diff --git a/unittest/unlockRealtime.sh b/unittest/user/unlockRealtime.sh
similarity index 100%
rename from unittest/unlockRealtime.sh
rename to unittest/user/unlockRealtime.sh

From d8d2f207e172ec8fd4f20104112f38fe176231b9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:20:26 +0100
Subject: [PATCH 1136/1292] cleaned up includes

---
 unittest/tests/container/TestDynamicFifo.cpp         | 6 +++---
 unittest/tests/container/TestFifo.cpp                | 6 +++---
 unittest/tests/container/TestFixedMap.cpp            | 4 ++--
 unittest/tests/osal/TestMessageQueue.cpp             | 4 ++--
 unittest/tests/serialize/TestSerialBufferAdapter.cpp | 2 +-
 unittest/tests/serialize/TestSerialLinkedPacket.cpp  | 2 +-
 unittest/tests/serialize/TestSerialization.cpp       | 2 +-
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/unittest/tests/container/TestDynamicFifo.cpp b/unittest/tests/container/TestDynamicFifo.cpp
index 759fcc66..2b572d52 100644
--- a/unittest/tests/container/TestDynamicFifo.cpp
+++ b/unittest/tests/container/TestDynamicFifo.cpp
@@ -1,6 +1,6 @@
-#include "../../../container/DynamicFIFO.h"
-#include "../../../container/FIFO.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFifo.cpp b/unittest/tests/container/TestFifo.cpp
index f7bfb1de..fbcd40cc 100644
--- a/unittest/tests/container/TestFifo.cpp
+++ b/unittest/tests/container/TestFifo.cpp
@@ -1,6 +1,6 @@
-#include "../../../container/DynamicFIFO.h"
-#include "../../../container/FIFO.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFixedMap.cpp b/unittest/tests/container/TestFixedMap.cpp
index f93065b6..297171ca 100644
--- a/unittest/tests/container/TestFixedMap.cpp
+++ b/unittest/tests/container/TestFixedMap.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedMap.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/osal/TestMessageQueue.cpp b/unittest/tests/osal/TestMessageQueue.cpp
index 5360974f..e33b7240 100644
--- a/unittest/tests/osal/TestMessageQueue.cpp
+++ b/unittest/tests/osal/TestMessageQueue.cpp
@@ -1,5 +1,5 @@
-#include "../../../ipc/MessageQueueIF.h"
-#include "../../../ipc/QueueFactory.h"
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialBufferAdapter.cpp b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
index 778f857e..1938746d 100644
--- a/unittest/tests/serialize/TestSerialBufferAdapter.cpp
+++ b/unittest/tests/serialize/TestSerialBufferAdapter.cpp
@@ -1,4 +1,4 @@
-#include "../../../serialize/SerialBufferAdapter.h"
+#include <fsfw/serialize/SerialBufferAdapter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialLinkedPacket.cpp b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
index 83bdf857..b90ae9f8 100644
--- a/unittest/tests/serialize/TestSerialLinkedPacket.cpp
+++ b/unittest/tests/serialize/TestSerialLinkedPacket.cpp
@@ -1,7 +1,7 @@
 #include "TestSerialLinkedPacket.h"
 #include <unittest/core/CatchDefinitions.h>
 
-#include "../../../globalfunctions/arrayprinter.h"
+#include <fsfw/globalfunctions/arrayprinter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/serialize/TestSerialization.cpp b/unittest/tests/serialize/TestSerialization.cpp
index 2877d09a..3de581ec 100644
--- a/unittest/tests/serialize/TestSerialization.cpp
+++ b/unittest/tests/serialize/TestSerialization.cpp
@@ -1,4 +1,4 @@
-#include "../../../serialize/SerializeAdapter.h"
+#include <fsfw/serialize/SerializeAdapter.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>

From f60f02c5b84033a63b94b80925ed2f8e1a64953d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 14:53:37 +0100
Subject: [PATCH 1137/1292] updated readme

---
 unittest/README.md           |  62 +++----------
 unittest/user/CMakeLists.txt | 166 ++++++++++++++++++++++++++++++++++-
 2 files changed, 176 insertions(+), 52 deletions(-)

diff --git a/unittest/README.md b/unittest/README.md
index 8a787c07..d6a4bb85 100644
--- a/unittest/README.md
+++ b/unittest/README.md
@@ -1,59 +1,19 @@
 ## FSFW Testing
-This repository contains testing and unit testing components.
 
-[Catch2](https://github.com/catchorg/Catch2) has been used as a framework,
-and these unit tests can only be run on a linux host machine.
-The makefile with default settings creates the unit test binary which can be
-run in the terminal or in eclipse.
+This folder contains testing and unit testing components.
 
 ### Instructions
 
-To run the fsfw unittests in the project, perform following steps:
+The easiest way to run the unittest contained in this folder is to follow
+the steps in the [test repository](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests).
+This is recommended even if the goal is to set up a custom test repository to have
+a starting point.
 
-1. Copy the testcfg folder  the project root (folder containing the FSFW).
-2. There is a makefile inside the testcfg folder which can be used to have 
-   a starting point to compile the unit tests. Copy that Makefile to the project
-   root
-3. Create a folder named catch2 (can have other name which requires Makefile 
-   adaption) and copy the Catch2 header files there (NOTE: CMake support
-   not enabled yet!)
+To set up a custom test repository or project, following steps can be performed:
+
+1. Copy the user folder content into the project root.
+2. Clone [Catch2](https://github.com/catchorg/Catch2) in the project root.
+3. Use the `CMakeLists.txt` as a starting point to add tests and build the test
+   executable.
    
-### Eclipse CDT settings
-
-The default eclipse terminal has issues displaying the colors used
-when running the unit test binary by catch2. To fix this issue,
-install the ANSI Escape In Console package from the eclipse marketplace.
-
-### GCOV integration
-
-GCOV has been integrated as a code coverage tool.
-It can be enabled by adding `GCOV=1` to the build process as an additional argument.
-Coverage data will be provided in form of .gcno and .gcda files.
-These can be displayed in eclipse by looking
-for a .gcno or .gcda file in the \_obj folder, double-clicking it
-and picking the right source-binary. This will generate 
-information about which lines of a file have run, provided it is open in 
-eclipse.
-
-### LCOV integration
-
-The files generated by GCOV can also be processed by the tool LCOV.
-On ubuntu, the tool can be installed with the following command:
-
-```sh 
-sudo apt-get install lcov
-```` 
-
-After that, the tool can be run by building the unit tests with `GCOV=1`,
-running them at least one time and then executing the `lcov.sh` script.
-
-### Adding unit tests
-
-The catch unit tests are located in unittest/testfw. To add new unit tests,
-add them to the UnitTestCatch.cpp file or add a new source file which
-includes catch.hpp.
-
-For writing basics tests, the [assertion documentation](https://github.com/catchorg/Catch2/blob/master/docs/assertions.md#top)
-or the existing examples are a good guideliens.
-For more advanced tests, refer to the [catch2 documentation](https://github.com/catchorg/Catch2/blob/master/docs/Readme.md#top).
 
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index ad6d4787..6ec314c3 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -1 +1,165 @@
-add_subdirectory(core)
+################################################################################
+# CMake support for the Flight Software Framework Tests
+# 
+# Developed in an effort to replace Make with a modern build system.
+# 
+# Author: R. Mueller
+################################################################################
+
+################################################################################
+# Pre-Project preparation
+################################################################################
+cmake_minimum_required(VERSION 3.13)
+
+# set(CMAKE_VERBOSE TRUE)
+
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+
+# Tests can be built with the Host OSAL or with the Linux OSAL.
+if(NOT OS_FSFW)
+	set(OS_FSFW host CACHE STRING "OS for the FSFW.")
+endif()
+
+option(CUSTOM_UNITTEST_RUNNER 
+	"Specify whether custom main or Catch2 main is used" TRUE
+)
+
+# Perform steps like loading toolchain files where applicable.
+#include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
+#pre_project_config()
+
+# Project Name
+project(fsfw_tests C CXX)
+
+################################################################################
+# Pre-Sources preparation
+################################################################################
+
+# Specify the C++ standard
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Set names and variables
+set(TARGET_NAME ${CMAKE_PROJECT_NAME}) 
+if(CUSTOM_UNITTEST_RUNNER)
+	set(CATCH2_TARGET Catch2)
+else()
+	set(CATCH2_TARGET Catch2WithMain)
+endif()
+set(LIB_FSFW_NAME fsfw)
+
+# Set path names
+set(FSFW_PATH fsfw)
+set(CATCH2_PATH Catch2)
+set(FSFW_TESTS_PATH fsfw/unittest)
+set(TEST_SETUP_PATH unittest)
+
+# Analyse different OS and architecture/target options and
+# determine BSP_PATH
+
+# FreeRTOS
+if(${OS_FSFW} STREQUAL linux)
+	add_definitions(-DUNIX -DLINUX)	
+	find_package(Threads REQUIRED)
+# Hosted
+else()
+	if(WIN32)
+    	add_definitions(-DWIN32)
+	elseif(UNIX)
+		find_package(Threads REQUIRED)
+		add_definitions(-DUNIX -DLINUX)	
+	endif()
+endif()
+
+set(FSFW_CONFIG_PATH testcfg)
+
+################################################################################
+# Executable and Sources
+################################################################################
+
+# Add executable
+add_executable(${TARGET_NAME})
+
+# Add subdirectories
+add_subdirectory(${FSFW_PATH})
+add_subdirectory(${CATCH2_PATH})
+add_subdirectory(${FSFW_CONFIG_PATH})
+add_subdirectory(${FSFW_TESTS_PATH})
+add_subdirectory(${TEST_SETUP_PATH})
+
+################################################################################
+# Post-Sources preparation
+################################################################################
+
+# Add libraries for all sources.
+target_link_libraries(${TARGET_NAME} PRIVATE
+	${LIB_FSFW_NAME} 
+	${CATCH2_TARGET}
+)
+
+# Add include paths for all sources.
+target_include_directories(${TARGET_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${FSFW_CONFIG_PATH}
+)	
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wshadow=local
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+	
+	# Remove unused sections.
+	target_compile_options(${TARGET_NAME} PRIVATE
+		"-ffunction-sections"
+		"-fdata-sections"
+	)
+
+	# Removed unused sections.
+	target_link_options(${TARGET_NAME} PRIVATE
+		"-Wl,--gc-sections"
+	)
+	
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
+endif()
+
+if(CMAKE_VERBOSE)
+	message(STATUS "Warning flags: ${WARNING_FLAGS}")
+endif()
+		 
+
+# Compile options for all sources.
+target_compile_options(${TARGET_NAME} PRIVATE
+	$<$<COMPILE_LANGUAGE:C>:${WARNING_FLAGS} ${COMPILER_FLAGS}>
+	$<$<COMPILE_LANGUAGE:CXX>:${WARNING_FLAGS} ${COMPILER_FLAGS}>
+	${ABI_FLAGS}
+)
+
+if(NOT CMAKE_SIZE)
+	set(CMAKE_SIZE size)
+	if(WIN32)
+		set(FILE_SUFFIX ".exe")
+	endif()
+endif()
+
+add_custom_command(
+   TARGET ${TARGET_NAME}
+   POST_BUILD
+   COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
+   COMMAND echo "Target OSAL: ${OS_FSFW}"
+   COMMAND echo "Target Build Type: ${CMAKE_BUILD_TYPE}"
+   COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
+)
+
+include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+set_build_type()
+
+
+
+
+

From 254b1437e978f7f17a57a07876f3ac7668898ef0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 27 Dec 2020 15:15:51 +0100
Subject: [PATCH 1138/1292] repaired windows unittests

---
 unittest/internal/osal/IntTestMq.cpp                 |  6 +++---
 unittest/internal/osal/IntTestMutex.cpp              |  6 +++---
 unittest/internal/osal/IntTestSemaphore.cpp          | 11 ++++++-----
 unittest/internal/serialize/IntTestSerialization.cpp |  8 ++++----
 4 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/unittest/internal/osal/IntTestMq.cpp b/unittest/internal/osal/IntTestMq.cpp
index 9917285f..fc8e963e 100644
--- a/unittest/internal/osal/IntTestMq.cpp
+++ b/unittest/internal/osal/IntTestMq.cpp
@@ -1,8 +1,8 @@
 #include "IntTestMq.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../ipc/MessageQueueIF.h"
-#include "../../../ipc/QueueFactory.h"
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
 
 #include <array>
 
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index d2f8b962..3316de74 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -1,10 +1,10 @@
 #include "IntTestMutex.h"
 
-#include "../../../ipc/MutexFactory.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
 #if defined(hosted)
-#include "../../osal/hosted/Mutex.h"
+#include <fsfw/osal/hosted/Mutex.h>
 #include <thread>
 #include <future>
 #endif
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 6d2719d5..5a82f78c 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -1,10 +1,11 @@
 #include "IntTestSemaphore.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../tasks/SemaphoreFactory.h"
-#include "../../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../../timemanager/Stopwatch.h"
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
 
+#include <cstdlib>
 
 void testsemaph::testBinSemaph() {
 	std::string id = "[BinSemaphore]";
@@ -138,7 +139,7 @@ void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph,
 		// attempt to take when count is 0, measure time
 		result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		dur_millis_t time = stopwatch.stop();
-		if(abs(time - 10) > 1) {
+		if(std::abs(static_cast<int32_t>(time - 10)) > 1) {
 			unitt::put_error(id);
 		}
 	}
diff --git a/unittest/internal/serialize/IntTestSerialization.cpp b/unittest/internal/serialize/IntTestSerialization.cpp
index 793661c5..69d82942 100644
--- a/unittest/internal/serialize/IntTestSerialization.cpp
+++ b/unittest/internal/serialize/IntTestSerialization.cpp
@@ -1,9 +1,9 @@
 #include "IntTestSerialization.h"
-#include "../UnittDefinitions.h"
+#include <fsfw/unittest/internal/UnittDefinitions.h>
 
-#include "../../../serialize/SerializeElement.h"
-#include "../../../serialize/SerialBufferAdapter.h"
-#include "../../../serialize/SerializeIF.h"
+#include <fsfw/serialize/SerializeElement.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerializeIF.h>
 
 #include <array>
 

From f9bcc835d7e170c97b153422ea80f2a2306dbe16 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 01:17:03 +0100
Subject: [PATCH 1139/1292] include updated

---
 unittest/tests/container/TestFixedArrayList.cpp       | 4 ++--
 unittest/tests/container/TestFixedOrderedMultimap.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/unittest/tests/container/TestFixedArrayList.cpp b/unittest/tests/container/TestFixedArrayList.cpp
index b2baa3e7..1a85f30d 100644
--- a/unittest/tests/container/TestFixedArrayList.cpp
+++ b/unittest/tests/container/TestFixedArrayList.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedArrayList.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
diff --git a/unittest/tests/container/TestFixedOrderedMultimap.cpp b/unittest/tests/container/TestFixedOrderedMultimap.cpp
index b337a9c8..a47d6efb 100644
--- a/unittest/tests/container/TestFixedOrderedMultimap.cpp
+++ b/unittest/tests/container/TestFixedOrderedMultimap.cpp
@@ -1,5 +1,5 @@
-#include "../../../container/FixedOrderedMultimap.h"
-#include "../../../returnvalues/HasReturnvaluesIF.h"
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>

From b126149215b8f1c9536f8a9c19ea63705f7ed7c6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 16:49:43 +0100
Subject: [PATCH 1140/1292] removed abi flags, are part of cross compile file
 now

---
 CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02849ca4..3cc5ffd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -139,5 +139,4 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${WARNING_FLAGS}
 	${COMPILER_FLAGS}
-	${ABI_FLAGS}
 )

From d268c6d96cf22cb7317c87b80f648b81c8afb1db Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 16:59:39 +0100
Subject: [PATCH 1141/1292] moved includes to allow c inclusion

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb67..6ed8ea2c 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From bc475f0a9a794d75b90317ade116d7e3ada7aa9b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 17:48:26 +0100
Subject: [PATCH 1142/1292] bugfixes

---
 osal/host/CMakeLists.txt  | 2 ++
 osal/linux/CMakeLists.txt | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index ee6b4cdb..367f721e 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,6 +13,8 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
+	find_package(Threads REQUIRED)
+	
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index e9a2935b..474e548b 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,14 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
+find_package(Threads REQUIRED)
+
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
 	${CMAKE_THREAD_LIBS_INIT}
 	rt
 )
 
+target_link_libraries(${LIB_FSFW_NAME} INTERFACE
+	${CMAKE_THREAD_LIBS_INIT}
+)
+

From 91cb061da941f610d2c7001ed2e47d64eaa6872f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 17:55:19 +0100
Subject: [PATCH 1143/1292] datapool updates, fixes, pool read helper

---
 datapool/PoolDataSetBase.cpp           | 49 ++++++++++++++++++++------
 datapool/PoolDataSetBase.h             | 31 +++++++++++-----
 datapool/PoolDataSetIF.h               |  6 ++--
 datapool/PoolVariableIF.h              | 40 ++-------------------
 datapool/ReadCommitIF.h                | 31 ++++++++++++++++
 datapoollocal/HasLocalDataPoolIF.h     |  3 ++
 datapoollocal/LocalDataPoolManager.cpp |  2 +-
 datapoollocal/LocalDataPoolManager.h   | 15 ++++----
 datapoollocal/LocalPoolDataSetBase.cpp | 32 ++++++++++-------
 datapoollocal/LocalPoolDataSetBase.h   | 15 ++++++--
 datapoollocal/LocalPoolVariable.tpp    | 18 +++++-----
 datapoollocal/PoolReadHelper.h         | 41 +++++++++++++++++++++
 12 files changed, 191 insertions(+), 92 deletions(-)
 create mode 100644 datapool/ReadCommitIF.h
 create mode 100644 datapoollocal/PoolReadHelper.h

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index cb2348f7..8f073359 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -9,9 +9,10 @@ PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
 
 PoolDataSetBase::~PoolDataSetBase() {}
 
+
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
-	if (state != States::DATA_SET_UNINITIALISED) {
+	if (state != States::STATE_SET_UNINITIALISED) {
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 		return DataSetIF::DATA_SET_UNINITIALISED;
@@ -33,15 +34,16 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 
 ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if (state == States::DATA_SET_UNINITIALISED) {
+	ReturnValue_t error = result;
+	if (state == States::STATE_SET_UNINITIALISED) {
 		lockDataPool(lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
-				break;
+				error = result;
 			}
 		}
-		state = States::DATA_SET_WAS_READ;
+		state = States::STATE_SET_WAS_READ;
 		unlockDataPool();
 	}
 	else {
@@ -50,6 +52,10 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 				" member datasets!" << std::endl;
 		result = SET_WAS_ALREADY_READ;
 	}
+
+	if(error != HasReturnvaluesIF::RETURN_OK) {
+		result = error;
+	}
 	return result;
 }
 
@@ -71,7 +77,13 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 		registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER)
 	{
-		result = registeredVariables[count]->readWithoutLock();
+		if(protectEveryReadCommitCall) {
+			result = registeredVariables[count]->read(mutexTimeout);
+		}
+		else {
+			result = registeredVariables[count]->readWithoutLock();
+		}
+
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			result = INVALID_PARAMETER_DEFINITION;
 		}
@@ -80,7 +92,7 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 }
 
 ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
-	if (state == States::DATA_SET_WAS_READ) {
+	if (state == States::STATE_SET_WAS_READ) {
 		handleAlreadyReadDatasetCommit(lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -96,10 +108,15 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 				!= PoolVariableIF::VAR_READ
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				registeredVariables[count]->commitWithoutLock();
+			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 }
 
@@ -111,7 +128,13 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
-			registeredVariables[count]->commitWithoutLock();
+			if(protectEveryReadCommitCall) {
+				result = registeredVariables[count]->commit(mutexTimeout);
+			}
+			else {
+				result = registeredVariables[count]->commitWithoutLock();
+			}
+
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
@@ -121,7 +144,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 			}
 		}
 	}
-	state = States::DATA_SET_UNINITIALISED;
+	state = States::STATE_SET_UNINITIALISED;
 	unlockDataPool();
 	return result;
 }
@@ -172,3 +195,9 @@ size_t PoolDataSetBase::getSerializedSize() const {
 void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
+
+void PoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	this->protectEveryReadCommitCall = protectEveryReadCommit;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index a8931d62..7c1d84a4 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -44,6 +44,7 @@ public:
 
 	/**
 	 * @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
@@ -52,13 +53,14 @@ public:
 	 * 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.
+	 * 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 PID, size or type of the
-	 * requested variable is invalid.
+	 * - @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
+	 *      commit() in between
 	 */
 	virtual ReturnValue_t read(uint32_t lockTimeout =
 			MutexIF::BLOCKING) override;
@@ -75,7 +77,7 @@ public:
 	 * 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.
+	 * 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
@@ -89,6 +91,7 @@ public:
 	 * @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
@@ -114,6 +117,15 @@ public:
 	        SerializeIF::Endianness streamEndianness) override;
 
 protected:
+
+	/**
+	 * Can be used to individually protect every read and commit call.
+	 * @param protectEveryReadCommit
+	 * @param mutexTimeout
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum
@@ -124,14 +136,14 @@ protected:
 	 * States of the seet.
 	 */
 	enum class States {
-		DATA_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		DATA_SET_WAS_READ     //!< DATA_SET_WAS_READ
+		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::DATA_SET_UNINITIALISED;
+	States state = States::STATE_SET_UNINITIALISED;
 
 	/**
 	 * @brief	This array represents all pool variables registered in this set.
@@ -144,6 +156,9 @@ protected:
 	void setContainer(PoolVariableIF** variablesContainer);
 
 private:
+	bool protectEveryReadCommitCall = false;
+	uint32_t mutexTimeout = 20;
+
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
 	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index aa45fa54..99c06cfd 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -1,19 +1,17 @@
 #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: public DataSetIF {
+class PoolDataSetIF: public DataSetIF, public ReadCommitIF {
 public:
     virtual~ PoolDataSetIF() {};
 
-    virtual ReturnValue_t read(dur_millis_t lockTimeout) = 0;
-    virtual ReturnValue_t commit(dur_millis_t lockTimeout) = 0;
-
     /**
      * @brief   Most underlying data structures will have a pool like structure
      *          and will require a lock and unlock mechanism to ensure
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index cd15f744..9740fc12 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -3,6 +3,7 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "../serialize/SerializeIF.h"
+#include "ReadCommitIF.h"
 
 /**
  * @brief	This interface is used to control data pool
@@ -17,9 +18,9 @@
  * @author 	Bastian Baetz
  * @ingroup data_pool
  */
-class PoolVariableIF : public SerializeIF {
+class PoolVariableIF : public SerializeIF,
+		public ReadCommitIF {
 	friend class PoolDataSetBase;
-	friend class GlobDataSet;
 	friend class LocalPoolDataSetBase;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
@@ -57,41 +58,6 @@ public:
 	 */
 	virtual void setValid(bool validity) = 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;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
new file mode 100644
index 00000000..0cdce371
--- /dev/null
+++ b/datapool/ReadCommitIF.h
@@ -0,0 +1,31 @@
+#ifndef FSFW_DATAPOOL_READCOMMITIF_H_
+#define FSFW_DATAPOOL_READCOMMITIF_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief 	Common interface for all software objects which employ read-commit
+ * 			semantics.
+ */
+class ReadCommitIF {
+public:
+	virtual ~ReadCommitIF() {}
+	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 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(20);
+	}
+
+	virtual ReturnValue_t commitWithoutLock() {
+		return commit(20);
+	}
+};
+
+
+#endif /* FSFW_DATAPOOL_READCOMMITIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7f1f202e..df855110 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -44,6 +44,9 @@ public:
 
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 
+    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index f649a362..5f0d15d3 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -577,7 +577,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
     if (poolIter == localPoolMap.end()) {
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
-        return POOL_ENTRY_NOT_FOUND;
+        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index c4024cf9..cdefa2c2 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -55,14 +55,11 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x02);
-
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x03);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x04);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x05);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -380,14 +377,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	if (poolIter == localPoolMap.end()) {
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
-		return POOL_ENTRY_NOT_FOUND;
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
-		return POOL_ENTRY_TYPE_CONFLICT;
+		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 640956db..9ecad218 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool noPeriodicHandling):
+        const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
@@ -23,7 +23,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
-    if(not noPeriodicHandling) {
+    if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
     }
 }
@@ -34,13 +34,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner == nullptr) {
-        // Configuration error.
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
-        return;
+    if(hkOwner != nullptr) {
+    	hkManager = hkOwner->getHkManagerHandle();
     }
-    hkManager = hkOwner->getHkManagerHandle();
     this->sid = sid;
 
     mutex = MutexFactory::instance()->createMutex();
@@ -50,8 +46,11 @@ LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
@@ -127,8 +126,11 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-    MutexIF* mutex = hkManager->getMutexHandle();
-    return mutex->unlockMutex();
+	if(hkManager != nullptr) {
+	    MutexIF* mutex = hkManager->getMutexHandle();
+	    return mutex->unlockMutex();
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
@@ -276,3 +278,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     }
     this->valid = valid;
 }
+
+void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
+		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
+			mutexTimeout);
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index aa155bf1..d9b6a221 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -54,7 +54,7 @@ public:
 	 */
 	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool noPeriodicHandling = false);
+	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
 	 * @brief	Constructor for users of local pool data.
@@ -77,6 +77,16 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
+	/**
+	 * If the data is pulled from different local data pools, every read and
+	 * commit call should be mutex protected for thread safety.
+	 * This can be specified with the second parameter.
+	 * @param dataCreator
+	 * @param protectEveryReadCommit
+	 */
+	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			uint32_t mutexTimeout = 20);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -128,6 +138,7 @@ public:
 
 protected:
 	sid_t sid;
+	uint32_t mutexTimeout = 20;
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
@@ -181,7 +192,7 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager;
+	LocalDataPoolManager* hkManager = nullptr;
 
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 48649ad5..a685ea8d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -11,14 +11,14 @@ inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
+		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
+		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
@@ -40,11 +40,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK and poolEntry != nullptr) {
+	if(result != RETURN_OK or poolEntry == nullptr) {
 		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,7 +62,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
new file mode 100644
index 00000000..4fe506ee
--- /dev/null
+++ b/datapoollocal/PoolReadHelper.h
@@ -0,0 +1,41 @@
+#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include <FSFWConfig.h>
+
+/**
+ * @brief 	Helper class to read data sets or pool variables
+ */
+class PoolReadHelper {
+public:
+	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+			readObject(readObject), mutexTimeout(mutexTimeout) {
+		if(readObject != nullptr) {
+			readResult = readObject->read(mutexTimeout);
+#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
+		}
+	}
+
+	ReturnValue_t getReadResult() const {
+		return readResult;
+	}
+
+	~PoolReadHelper() {
+		if(readObject != nullptr) {
+			readObject->commit(mutexTimeout);
+		}
+
+	}
+
+private:
+	ReadCommitIF* readObject = nullptr;
+	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	uint32_t mutexTimeout = 20;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */

From bc1513c649dc6e8d8c4ab161537b1a2f12d41d3c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 18:06:00 +0100
Subject: [PATCH 1144/1292] cmake lists updates

---
 CMakeLists.txt            |  1 -
 osal/host/CMakeLists.txt  |  4 +++-
 osal/linux/CMakeLists.txt | 14 ++++++++++----
 unittest/CMakeLists.txt   |  2 ++
 4 files changed, 15 insertions(+), 6 deletions(-)
 create mode 100644 unittest/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02849ca4..3cc5ffd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -139,5 +139,4 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${WARNING_FLAGS}
 	${COMPILER_FLAGS}
-	${ABI_FLAGS}
 )
diff --git a/osal/host/CMakeLists.txt b/osal/host/CMakeLists.txt
index aa32990b..367f721e 100644
--- a/osal/host/CMakeLists.txt
+++ b/osal/host/CMakeLists.txt
@@ -13,9 +13,11 @@ target_sources(${LIB_FSFW_NAME}
 )
 
 if(UNIX)
+	find_package(Threads REQUIRED)
+	
 	target_link_libraries(${LIB_FSFW_NAME} 
 	PRIVATE
 		rt
-		pthread
+		${CMAKE_THREAD_LIBS_INIT}
 	)
 endif()
\ No newline at end of file
diff --git a/osal/linux/CMakeLists.txt b/osal/linux/CMakeLists.txt
index c0096e42..474e548b 100644
--- a/osal/linux/CMakeLists.txt
+++ b/osal/linux/CMakeLists.txt
@@ -18,8 +18,14 @@ target_sources(${LIB_FSFW_NAME}
 		Timer.cpp
 )
 
-target_link_libraries(${LIB_FSFW_NAME} 
-	PRIVATE
-		rt
-		pthread
+find_package(Threads REQUIRED)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+	${CMAKE_THREAD_LIBS_INIT}
+	rt
 )
+
+target_link_libraries(${LIB_FSFW_NAME} INTERFACE
+	${CMAKE_THREAD_LIBS_INIT}
+)
+
diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
new file mode 100644
index 00000000..119ef243
--- /dev/null
+++ b/unittest/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(internal)
+add_subdirectory(tests)
\ No newline at end of file

From c8af75f9c754816dba4561baf64aa5e8753406fb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 28 Dec 2020 18:06:34 +0100
Subject: [PATCH 1145/1292] moved inlcudes

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb67..6ed8ea2c 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From 219c057fb9821b3b75805acb4b177b52e16d2f51 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 29 Dec 2020 14:08:48 +0100
Subject: [PATCH 1146/1292] added service 3 cmake support

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c2629..c0e00448 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 44dcd3104eae56157adee88e0ecbd8712fe86881 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:01:11 +0100
Subject: [PATCH 1147/1292] device handler base update

---
 devicehandlers/DeviceHandlerBase.cpp | 19 +++++++++++--------
 devicehandlers/DeviceHandlerBase.h   |  4 ++--
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d0630854..efee1462 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,8 +16,8 @@
 #include <iomanip>
 
 
-object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultPowerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::defaultRawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
@@ -151,9 +151,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	if(rawDataReceiverId != objects::NO_OBJECT) {
+	if(defaultRawDataReceiverId != objects::NO_OBJECT) {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(rawDataReceiverId);
+				AcceptsDeviceResponsesIF>(defaultRawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
@@ -165,8 +165,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	if(powerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+	if(defaultPowerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(
+				defaultPowerSwitcherId);
 		if (powerSwitcher == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Power switcher "
 					<< "object ID set but no valid object found." << std::endl;
@@ -682,8 +683,10 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	if (mode == MODE_RAW) {
+		if(defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+		}
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372..0d14bf4e 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -739,10 +739,10 @@ protected:
 	PeriodicTaskIF* executingTask = nullptr;
 
 	//!< Object which switches power on and off.
-	static object_id_t powerSwitcherId;
+	static object_id_t defaultPowerSwitcherId;
 
 	//!< Object which receives RAW data by default.
-	static object_id_t rawDataReceiverId;
+	static object_id_t defaultRawDataReceiverId;
 
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;

From 56eac4647265deb8b115eb1c970a0b81153a03cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:17:08 +0100
Subject: [PATCH 1148/1292] Revert "device handler base update"

This reverts commit 44dcd3104eae56157adee88e0ecbd8712fe86881.
---
 devicehandlers/DeviceHandlerBase.cpp | 19 ++++++++-----------
 devicehandlers/DeviceHandlerBase.h   |  4 ++--
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index efee1462..d0630854 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -16,8 +16,8 @@
 #include <iomanip>
 
 
-object_id_t DeviceHandlerBase::defaultPowerSwitcherId = objects::NO_OBJECT;
-object_id_t DeviceHandlerBase::defaultRawDataReceiverId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
 
 DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
@@ -151,9 +151,9 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
-	if(defaultRawDataReceiverId != objects::NO_OBJECT) {
+	if(rawDataReceiverId != objects::NO_OBJECT) {
 		AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
-				AcceptsDeviceResponsesIF>(defaultRawDataReceiverId);
+				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
@@ -165,9 +165,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
 	}
 
-	if(defaultPowerSwitcherId != objects::NO_OBJECT) {
-		powerSwitcher = objectManager->get<PowerSwitchIF>(
-				defaultPowerSwitcherId);
+	if(powerSwitcherId != objects::NO_OBJECT) {
+		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
 			sif::error << "DeviceHandlerBase::initialize: Power switcher "
 					<< "object ID set but no valid object found." << std::endl;
@@ -683,10 +682,8 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW) {
-		if(defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
-		}
+	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 0d14bf4e..24ba0372 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -739,10 +739,10 @@ protected:
 	PeriodicTaskIF* executingTask = nullptr;
 
 	//!< Object which switches power on and off.
-	static object_id_t defaultPowerSwitcherId;
+	static object_id_t powerSwitcherId;
 
 	//!< Object which receives RAW data by default.
-	static object_id_t defaultRawDataReceiverId;
+	static object_id_t rawDataReceiverId;
 
 	//!< Object which may be the root cause of an identified fault.
 	static object_id_t defaultFdirParentId;

From 0a4d0b593713e61b7ddf47ecb4b1657d8a0a8674 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:34:40 +0100
Subject: [PATCH 1149/1292] bugfix

---
 devicehandlers/DeviceHandlerBase.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index d0630854..251320cb 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -682,8 +682,10 @@ void DeviceHandlerBase::doGetRead() {
 		replyRawData(receivedData, receivedDataLen, requestedRawTraffic);
 	}
 
-	if (mode == MODE_RAW and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-		replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+	if (mode == MODE_RAW) {
+		if (defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
+			replyRawReplyIfnotWiretapped(receivedData, receivedDataLen);
+		}
 	}
 	else {
 		parseReply(receivedData, receivedDataLen);

From c4fb1f49d813a97113099d4c6e257d5606955182 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:56:46 +0100
Subject: [PATCH 1150/1292] updated defaultcfg

---
 defaultcfg/fsfwconfig/CMakeLists.txt          | 21 +++++++-------
 .../fsfwconfig/devices/logicalAddresses.cpp   |  5 ----
 .../fsfwconfig/devices/logicalAddresses.h     |  2 +-
 .../fsfwconfig/devices/powerSwitcherList.cpp  |  4 ---
 .../objects/{Factory.cpp => FsfwFactory.cpp}  | 29 +++++++++----------
 .../objects/{Factory.h => FsfwFactory.h}      |  2 +-
 6 files changed, 26 insertions(+), 37 deletions(-)
 delete mode 100644 defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
 delete mode 100644 defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
 rename defaultcfg/fsfwconfig/objects/{Factory.cpp => FsfwFactory.cpp} (60%)
 rename defaultcfg/fsfwconfig/objects/{Factory.h => FsfwFactory.h} (91%)

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index b8b41c93..4b8f4474 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -1,15 +1,14 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	ipc/missionMessageTypes.cpp
+	objects/FsfwFactory.cpp
+	pollingsequence/PollingSequenceFactory.cpp
 )
 
-# Add include paths for the executable
-target_include_directories(${TARGET_NAME} 
-	PUBLIC 
-		${CMAKE_CURRENT_SOURCE_DIR}
+# Should be added to include path
+target_include_directories(${TARGET_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-# Add include paths for the FSFW library
-target_include_directories(${LIB_FSFW_NAME} 
-	PUBLIC
-		${CMAKE_CURRENT_SOURCE_DIR}
-)
\ No newline at end of file
+if(NOT FSFW_CONFIG_PATH)
+	set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp b/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
deleted file mode 100644
index c7ce314d..00000000
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "logicalAddresses.h"
-
-
-
-
diff --git a/defaultcfg/fsfwconfig/devices/logicalAddresses.h b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
index e0827ba3..53edcd54 100644
--- a/defaultcfg/fsfwconfig/devices/logicalAddresses.h
+++ b/defaultcfg/fsfwconfig/devices/logicalAddresses.h
@@ -2,7 +2,7 @@
 #define CONFIG_DEVICES_LOGICALADDRESSES_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include "../objects/systemObjectList.h"
+#include <objects/systemObjectList.h>
 #include <cstdint>
 
 /**
diff --git a/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp b/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
deleted file mode 100644
index 343f78d0..00000000
--- a/defaultcfg/fsfwconfig/devices/powerSwitcherList.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "powerSwitcherList.h"
-
-
-
diff --git a/defaultcfg/fsfwconfig/objects/Factory.cpp b/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
similarity index 60%
rename from defaultcfg/fsfwconfig/objects/Factory.cpp
rename to defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
index 41333b1c..428adf1d 100644
--- a/defaultcfg/fsfwconfig/objects/Factory.cpp
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
@@ -1,9 +1,5 @@
-#include "Factory.h"
-#include "../tmtc/apid.h"
-#include "../tmtc/pusIds.h"
-#include "../objects/systemObjectList.h"
-#include "../devices/logicalAddresses.h"
-#include "../devices/powerSwitcherList.h"
+#include "FsfwFactory.h"
+#include <OBSWConfig.h>
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
@@ -11,24 +7,27 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <internalError/InternalErrorReporter.h>
+#include <fsfw/internalError/InternalErrorReporter.h>
 
 #include <cstdint>
 
 /**
- * This class should be used to create all system objects required for
- * the on-board software, using the object ID list from the configuration
- * folder.
+ * This function builds all system objects required for using
+ * the FSFW. It is recommended to build all other required objects
+ * in a function with an identical prototype, call this function in it and
+ * then pass the function to the object manager so it builds all system
+ * objects on software startup.
  *
- * The objects are registered in the internal object manager automatically.
- * This is used later to add objects to tasks.
+ * All system objects are registered in the internal object manager
+ * automatically. The objects should be added to tasks at a later stage, using
+ * their objects IDs.
  *
- * This file also sets static framework IDs.
+ * This function also sets static framework IDs.
  *
- * Framework objects are created first.
+ * Framework should be created first before creating mission system objects.
  * @ingroup init
  */
-void Factory::produce(void) {
+void Factory::produceFsfwObjects(void) {
 	setStaticFrameworkObjectIds();
 	new EventManager(objects::EVENT_MANAGER);
 	new HealthTable(objects::HEALTH_TABLE);
diff --git a/defaultcfg/fsfwconfig/objects/Factory.h b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
similarity index 91%
rename from defaultcfg/fsfwconfig/objects/Factory.h
rename to defaultcfg/fsfwconfig/objects/FsfwFactory.h
index fe55deff..2724d2e3 100644
--- a/defaultcfg/fsfwconfig/objects/Factory.h
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
@@ -9,7 +9,7 @@ namespace Factory {
 	 * @brief   Creates all SystemObject elements which are persistent
 	 *          during execution.
 	 */
-	void produce();
+	void produceFsfwObjects();
 	void setStaticFrameworkObjectIds();
 }
 

From 7b15a5a431b7a2b1c8d1cbdeffbf2431f0b37315 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 30 Dec 2020 22:57:52 +0100
Subject: [PATCH 1151/1292] moved includes

---
 defaultcfg/fsfwconfig/OBSWConfig.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/OBSWConfig.h b/defaultcfg/fsfwconfig/OBSWConfig.h
index 8ad2cb67..6ed8ea2c 100644
--- a/defaultcfg/fsfwconfig/OBSWConfig.h
+++ b/defaultcfg/fsfwconfig/OBSWConfig.h
@@ -3,11 +3,12 @@
 
 #include "OBSWVersion.h"
 
+#ifdef __cplusplus
+
 #include "objects/systemObjectList.h"
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-#ifdef __cplusplus
 namespace config {
 #endif
 

From 5be95fada76a6ea8ab24ed9d37d4f157a6910ac0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 17:18:37 +0100
Subject: [PATCH 1152/1292] bugfixes and RTEMS update for STM32

---
 defaultcfg/fsfwconfig/CMakeLists.txt |  8 +++-----
 osal/rtems/CMakeLists.txt            | 18 ++++++++++++++++++
 osal/rtems/Clock.cpp                 |  5 ++++-
 osal/rtems/InternalErrorCodes.cpp    |  2 ++
 4 files changed, 27 insertions(+), 6 deletions(-)
 create mode 100644 osal/rtems/CMakeLists.txt

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index b8b41c93..c37d8ddd 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -8,8 +8,6 @@ target_include_directories(${TARGET_NAME}
 		${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-# Add include paths for the FSFW library
-target_include_directories(${LIB_FSFW_NAME} 
-	PUBLIC
-		${CMAKE_CURRENT_SOURCE_DIR}
-)
\ No newline at end of file
+if(NOT DEFINED FSFW_CONFIG_DIRECTORY)
+	set(FSFW_CONFIG_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
\ No newline at end of file
diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
new file mode 100644
index 00000000..bff03184
--- /dev/null
+++ b/osal/rtems/CMakeLists.txt
@@ -0,0 +1,18 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		CpuUsage.cpp
+		InitTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		MultiObjectTask.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PollingTask.cpp
+		QueueFactory.cpp
+		RtemsBasic.cpp
+		TaskBase.cpp
+		TaskFactory.cpp
+)
+
+
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index e5f37ec6..aa135ade 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,5 +1,8 @@
-#include "../../timemanager/Clock.h"
 #include "RtemsBasic.h"
+
+#include "../../timemanager/Clock.h"
+#include "../../ipc/MutexHelper.h"
+
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index ddf365d5..f4079814 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -34,8 +34,10 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 		return OUT_OF_PROXIES;
 	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
 		return INVALID_GLOBAL_ID;
+#ifndef STM32H743ZI_NUCLEO
 	case INTERNAL_ERROR_BAD_STACK_HOOK:
 		return BAD_STACK_HOOK;
+#endif
 //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
 //		return BAD_ATTRIBUTES;
 //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

From f223aa148edc13ee76ffc807b933a29cab92aae1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 18:05:02 +0100
Subject: [PATCH 1153/1292] updated cmake lists

---
 defaultcfg/fsfwconfig/CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/CMakeLists.txt b/defaultcfg/fsfwconfig/CMakeLists.txt
index 8c8d8086..cbd4ecde 100644
--- a/defaultcfg/fsfwconfig/CMakeLists.txt
+++ b/defaultcfg/fsfwconfig/CMakeLists.txt
@@ -9,6 +9,7 @@ target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-if(NOT DEFINED FSFW_CONFIG_DIRECTORY)
-	set(FSFW_CONFIG_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+if(NOT FSFW_CONFIG_PATH)
+	set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
+

From ced753b513f65ed6948e4a3b048bb744b2c04805 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 18:06:33 +0100
Subject: [PATCH 1154/1292] include guard

---
 defaultcfg/fsfwconfig/objects/FsfwFactory.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/defaultcfg/fsfwconfig/objects/FsfwFactory.h b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
index 2724d2e3..198b22f2 100644
--- a/defaultcfg/fsfwconfig/objects/FsfwFactory.h
+++ b/defaultcfg/fsfwconfig/objects/FsfwFactory.h
@@ -1,5 +1,5 @@
-#ifndef FACTORY_H_
-#define FACTORY_H_
+#ifndef FSFWCONFIG_OBJECTS_FACTORY_H_
+#define FSFWCONFIG_OBJECTS_FACTORY_H_
 
 #include <fsfw/objectmanager/SystemObjectIF.h>
 #include <cstddef>
@@ -14,4 +14,4 @@ namespace Factory {
 }
 
 
-#endif /* FACTORY_H_ */
+#endif /* FSFWCONFIG_OBJECTS_FACTORY_H_ */

From 4de5fc44b429812c1de1da77c8745157a06d045f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 1 Jan 2021 21:19:42 +0100
Subject: [PATCH 1155/1292] rtems init

---
 osal/rtems/CMakeLists.txt         | 18 ++++++++++++++++++
 osal/rtems/Clock.cpp              |  5 ++++-
 osal/rtems/InternalErrorCodes.cpp |  2 ++
 3 files changed, 24 insertions(+), 1 deletion(-)
 create mode 100644 osal/rtems/CMakeLists.txt

diff --git a/osal/rtems/CMakeLists.txt b/osal/rtems/CMakeLists.txt
new file mode 100644
index 00000000..bff03184
--- /dev/null
+++ b/osal/rtems/CMakeLists.txt
@@ -0,0 +1,18 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		Clock.cpp
+		CpuUsage.cpp
+		InitTask.cpp
+		InternalErrorCodes.cpp
+		MessageQueue.cpp
+		MultiObjectTask.cpp
+		Mutex.cpp
+		MutexFactory.cpp
+		PollingTask.cpp
+		QueueFactory.cpp
+		RtemsBasic.cpp
+		TaskBase.cpp
+		TaskFactory.cpp
+)
+
+
diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index e5f37ec6..aa135ade 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -1,5 +1,8 @@
-#include "../../timemanager/Clock.h"
 #include "RtemsBasic.h"
+
+#include "../../timemanager/Clock.h"
+#include "../../ipc/MutexHelper.h"
+
 #include <rtems/score/todimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp
index ddf365d5..f4079814 100644
--- a/osal/rtems/InternalErrorCodes.cpp
+++ b/osal/rtems/InternalErrorCodes.cpp
@@ -34,8 +34,10 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
 		return OUT_OF_PROXIES;
 	case INTERNAL_ERROR_INVALID_GLOBAL_ID:
 		return INVALID_GLOBAL_ID;
+#ifndef STM32H743ZI_NUCLEO
 	case INTERNAL_ERROR_BAD_STACK_HOOK:
 		return BAD_STACK_HOOK;
+#endif
 //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
 //		return BAD_ATTRIBUTES;
 //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

From e5b3f991efbf74cd7d50c74ed774779b25b7c56c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 19:39:02 +0100
Subject: [PATCH 1156/1292] added important rtems include

---
 osal/rtems/Clock.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aa135ade..dda15464 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -4,6 +4,7 @@
 #include "../../ipc/MutexHelper.h"
 
 #include <rtems/score/todimpl.h>
+#include <rtems/rtems/clockimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;

From 4c07ca21eb7c9c36c49608107afc687ea08e53cd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 19:40:00 +0100
Subject: [PATCH 1157/1292] important include fix

---
 osal/rtems/Clock.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index aa135ade..dda15464 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -4,6 +4,7 @@
 #include "../../ipc/MutexHelper.h"
 
 #include <rtems/score/todimpl.h>
+#include <rtems/rtems/clockimpl.h>
 
 uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;

From 7759b19961a9892d9f1473c49fe64f450dee468d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 2 Jan 2021 23:22:50 +0100
Subject: [PATCH 1158/1292] added new files

---
 serviceinterface/CMakeLists.txt              | 8 ++++----
 serviceinterface/ServiceInterfacePrinter.cpp | 2 ++
 serviceinterface/ServiceInterfacePrinter.h   | 0
 3 files changed, 6 insertions(+), 4 deletions(-)
 create mode 100644 serviceinterface/ServiceInterfacePrinter.cpp
 create mode 100644 serviceinterface/ServiceInterfacePrinter.h

diff --git a/serviceinterface/CMakeLists.txt b/serviceinterface/CMakeLists.txt
index d84adbeb..84c79177 100644
--- a/serviceinterface/CMakeLists.txt
+++ b/serviceinterface/CMakeLists.txt
@@ -1,5 +1,5 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ServiceInterfaceStream.cpp
-		ServiceInterfaceBuffer.cpp
+target_sources(${LIB_FSFW_NAME} PRIVATE 
+	ServiceInterfaceStream.cpp
+	ServiceInterfaceBuffer.cpp
+	ServiceInterfacePrinter.cpp
 )
\ No newline at end of file
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
new file mode 100644
index 00000000..4c4c28cb
--- /dev/null
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -0,0 +1,2 @@
+#include "ServiceInterfacePrinter.h"
+
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
new file mode 100644
index 00000000..e69de29b

From b30405fee73317379f6c959adce720d5ba677a23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:02:07 +0100
Subject: [PATCH 1159/1292] added stdio pinters

---
 defaultcfg/fsfwconfig/FSFWConfig.h           |  14 ++-
 serviceinterface/ServiceInterfaceBuffer.h    |   3 +-
 serviceinterface/ServiceInterfacePrinter.cpp | 102 +++++++++++++++++++
 serviceinterface/ServiceInterfacePrinter.h   |  33 ++++++
 4 files changed, 149 insertions(+), 3 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index e1815d05..d94f6cc7 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -4,14 +4,20 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
 //! Reduced printout to further decrease code size
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
@@ -20,6 +26,8 @@
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
+#define FSFW_COLORED_OUTPUT 		1
+
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
@@ -50,6 +58,8 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c5d5b258..c953846d 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include <FSFWConfig.h>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -54,7 +55,7 @@ private:
 	bool errStream;
 
 	//! Needed for buffered mode.
-	static size_t const BUF_SIZE = 128;
+	static size_t const BUF_SIZE = fsfwconfig::FSFW_PRINT_BUFFER_SIZE;
 	char buf[BUF_SIZE];
 
 	//! In this function, the characters are parsed.
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 4c4c28cb..04430d61 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,2 +1,104 @@
 #include "ServiceInterfacePrinter.h"
 
+#include "../timemanager/Clock.h"
+
+#include <FSFWConfig.h>
+#include <cstdarg>
+#include <cstdint>
+
+
+fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+
+void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+    uint32_t len = 0;
+
+    /* Check logger level */
+    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+        return;
+    }
+
+    /* Log message to terminal */
+
+#if FSFW_COLORED_OUTPUT == 1
+    if(printType == fsfw::PrintLevel::INFO) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
+    }
+    else if(printType == fsfw::PrintLevel::DEBUG) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_BLUE);
+    }
+    else if(printType == fsfw::PrintLevel::WARNING) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
+    }
+    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_RED);
+    }
+#endif
+
+   if (printType == fsfw::PrintLevel::INFO) {
+       len += sprintf((char *)printBuffer + len, "INFO: ");
+   }
+   if(printType == fsfw::PrintLevel::DEBUG) {
+	   len += sprintf((char *)printBuffer + len, "DEBUG: ");
+   }
+   if(printType == fsfw::PrintLevel::WARNING) {
+	   len += sprintf((char *)printBuffer + len, "WARNING: ");
+   }
+
+   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+	   len += sprintf((char *)printBuffer + len, "ERROR: ");
+   }
+
+    Clock::TimeOfDay_t now;
+    Clock::getDateAndTime(&now);
+    /*
+     * Log current time to terminal if desired.
+     */
+    len += sprintf((char*)printBuffer + len, "| %lu:%02lu:%02lu.%03lu | ",
+    		(unsigned long) now.hour,
+			(unsigned long) now.minute,
+			(unsigned long) now.second,
+			(unsigned long) now.usecond /1000);
+
+    //changed Jan 2017.  Need to update length with buffer size
+    len += vsnprintf((char *)(printBuffer + len),
+    		sizeof(printBuffer)-len, fmt, arg);
+
+    printf("%s", printBuffer);
+}
+
+void fsfw::setPrintLevel(PrintLevel printLevel_) {
+	printLevel = printLevel_;
+}
+
+fsfw::PrintLevel fsfw::getPrintLevel() {
+	return printLevel;
+}
+
+void fsfw::printInfo(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printWarning(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printDebug(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
+    va_end(args);
+}
+
+void fsfw::printError(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
+    va_end(args);
+}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index e69de29b..a2ba483d 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -0,0 +1,33 @@
+#include <stdio.h>
+
+namespace fsfw {
+
+enum class PrintLevel {
+	NONE = 0,
+	//! Strange error when using just ERROR..
+	ERROR_TYPE = 1,
+	WARNING = 2,
+	INFO = 3,
+	DEBUG = 4
+};
+
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+void setPrintLevel(PrintLevel printLevel);
+PrintLevel getPrintLevel();
+
+
+void printInfo(const char *fmt, ...);
+void printWarning(const char* fmt, ...);
+void printDebug(const char* fmt, ...);
+void printError(const char* fmt, ...);
+
+}
+

From 0e2875b22d20c68408b052d37c0ff0e69e37b903 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:35:17 +0100
Subject: [PATCH 1160/1292] added colored output for streams as well

---
 defaultcfg/fsfwconfig/FSFWConfig.h            |  9 ++++----
 serviceinterface/ServiceInterfaceBuffer.cpp   | 23 +++++++++++++++++++
 serviceinterface/ServiceInterfaceBuffer.h     |  5 ++++
 serviceinterface/ServiceInterfacePrinter.cpp  |  4 +++-
 serviceinterface/ServiceInterfacePrinter.h    |  9 --------
 serviceinterface/ServiceInterfaceStream.cpp   | 17 --------------
 serviceinterface/ServiceInterfaceStream.h     |  7 ------
 serviceinterface/serviceInterfaceDefintions.h | 16 +++++++++++++
 8 files changed, 52 insertions(+), 38 deletions(-)
 create mode 100644 serviceinterface/serviceInterfaceDefintions.h

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index d94f6cc7..261e3d6d 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,25 +9,26 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
+//! More FSFW related printouts.
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
+
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
 #define FSFW_OBJ_EVENT_TRANSLATION	0
 
-#define FSFW_COLORED_OUTPUT 		1
-
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 //! Specify whether info events are printed too.
 #define FSFW_DEBUG_INFO				1
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 68fc4dec..eb940cfa 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,5 +1,7 @@
 #include "../timemanager/Clock.h"
 #include "ServiceInterfaceBuffer.h"
+#include "serviceInterfaceDefintions.h"
+#include <FSFWConfig.h>
 #include <cstring>
 #include <inttypes.h>
 
@@ -17,6 +19,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
+
+#if FSFW_COLORED_OUTPUT == 1
+	if(setMessage.find("DEBUG")) {
+		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+	}
+	else if(setMessage.find("INFO")) {
+		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+	}
+	else if(setMessage.find("WARNING")) {
+		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+	}
+	else if(setMessage.find("ERROR")) {
+		colorPrefix = fsfw::ANSI_COLOR_RED;
+	}
+#endif
 	preamble.reserve(MAX_PREAMBLE_SIZE);
 	preamble.resize(MAX_PREAMBLE_SIZE);
 }
@@ -102,6 +119,12 @@ std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 		currentSize += 1;
 		parsePosition += 1;
 	}
+
+#if FSFW_COLORED_OUTPUT == 1
+	currentSize += sprintf(parsePosition, "%s", colorPrefix.c_str());
+	parsePosition += colorPrefix.size();
+#endif
+
 	int32_t charCount = sprintf(parsePosition,
 			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
 					this->logMessage.c_str(), loggerTime.hour,
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index c953846d..8f2a601c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -42,6 +42,11 @@ private:
 	//! For additional message information
 	std::string logMessage;
 	std::string preamble;
+
+#if FSFW_COLORED_OUTPUT == 1
+	std::string colorPrefix;
+#endif
+
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 04430d61..177d7c4a 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,8 +1,10 @@
 #include "ServiceInterfacePrinter.h"
+#include "serviceInterfaceDefintions.h"
 
 #include "../timemanager/Clock.h"
 
 #include <FSFWConfig.h>
+
 #include <cstdarg>
 #include <cstdint>
 
@@ -25,7 +27,7 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
     }
     else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_BLUE);
+    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_MAGENTA);
     }
     else if(printType == fsfw::PrintLevel::WARNING) {
     	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index a2ba483d..1991f412 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -11,15 +11,6 @@ enum class PrintLevel {
 	DEBUG = 4
 };
 
-
-static const char* const ANSI_COLOR_RED = "\x1b[31m";
-static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
-static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
-static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
-static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
-static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
-static const char* const ANSI_COLOR_RESET = "\x1b[0m";
-
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 5b7b9f00..05643460 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -13,20 +13,3 @@ std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
-void ServiceInterfaceStream::print(std::string error,
-		bool withPreamble, bool withNewline, bool flush) {
-	if(not streambuf.isBuffered() and withPreamble) {
-		*this << getPreamble() << error;
-	}
-	else {
-		*this << error;
-	}
-
-	if(withNewline) {
-		*this << "\n";
-	}
-	// if mode is non-buffered, no need to flush.
-	if(flush and streambuf.isBuffered()) {
-		this->flush();
-	}
-}
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 76fa1bf2..cd2adf85 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -35,13 +35,6 @@ public:
 	 */
 	std::string* getPreamble();
 
-	/**
-	 * This prints an error with a preamble. Useful if using the unbuffered
-	 * mode. Flushes in default mode (prints immediately).
-	 */
-	void print(std::string error, bool withPreamble = true,
-			bool withNewline = true, bool flush = true);
-
 protected:
 	ServiceInterfaceBuffer streambuf;
 };
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
new file mode 100644
index 00000000..684c7366
--- /dev/null
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -0,0 +1,16 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+
+namespace fsfw {
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+}
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_ */

From 5c42888f10c10e42f1c90de98e17feb9fc560cae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:39:06 +0100
Subject: [PATCH 1161/1292] whitespace

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index eb940cfa..bbfb69c7 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -34,6 +34,7 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
 #endif
+
 	preamble.reserve(MAX_PREAMBLE_SIZE);
 	preamble.resize(MAX_PREAMBLE_SIZE);
 }

From e300207f48d8c4a6790c37c360ce88dab007be54 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:40:35 +0100
Subject: [PATCH 1162/1292] removed comment

---
 serviceinterface/ServiceInterfacePrinter.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 177d7c4a..5ab9e425 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -62,7 +62,6 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 			(unsigned long) now.second,
 			(unsigned long) now.usecond /1000);
 
-    //changed Jan 2017.  Need to update length with buffer size
     len += vsnprintf((char *)(printBuffer + len),
     		sizeof(printBuffer)-len, fmt, arg);
 

From 717027792e830dc046209842500a7aa74761c51e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:47:01 +0100
Subject: [PATCH 1163/1292] minor improvements and docuemntation

---
 serviceinterface/ServiceInterfacePrinter.cpp | 22 ++++++++++----------
 serviceinterface/ServiceInterfacePrinter.h   |  8 ++++++-
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 5ab9e425..f67dfb53 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -14,6 +14,7 @@ uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     uint32_t len = 0;
+    char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
     if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
@@ -24,31 +25,31 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if FSFW_COLORED_OUTPUT == 1
     if(printType == fsfw::PrintLevel::INFO) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_GREEN);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
     }
     else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_MAGENTA);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
     }
     else if(printType == fsfw::PrintLevel::WARNING) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_YELLOW);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
     }
     else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-    	len += sprintf((char *)printBuffer, fsfw::ANSI_COLOR_RED);
+    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
     }
 #endif
 
    if (printType == fsfw::PrintLevel::INFO) {
-       len += sprintf((char *)printBuffer + len, "INFO: ");
+       len += sprintf(bufferPosition + len, "INFO: ");
    }
    if(printType == fsfw::PrintLevel::DEBUG) {
-	   len += sprintf((char *)printBuffer + len, "DEBUG: ");
+	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
    if(printType == fsfw::PrintLevel::WARNING) {
-	   len += sprintf((char *)printBuffer + len, "WARNING: ");
+	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
    if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-	   len += sprintf((char *)printBuffer + len, "ERROR: ");
+	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
     Clock::TimeOfDay_t now;
@@ -56,14 +57,13 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     /*
      * Log current time to terminal if desired.
      */
-    len += sprintf((char*)printBuffer + len, "| %lu:%02lu:%02lu.%03lu | ",
+    len += sprintf(bufferPosition + len, "| %lu:%02lu:%02lu.%03lu | ",
     		(unsigned long) now.hour,
 			(unsigned long) now.minute,
 			(unsigned long) now.second,
 			(unsigned long) now.usecond /1000);
 
-    len += vsnprintf((char *)(printBuffer + len),
-    		sizeof(printBuffer)-len, fmt, arg);
+    len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
     printf("%s", printBuffer);
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 1991f412..8b81ee7a 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -14,7 +14,13 @@ enum class PrintLevel {
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
-
+/**
+ * These functions can be used like the C stdio printf and forward the
+ * supplied formatted string arguments to a printf function.
+ * They prepend the string with a color (if enabled), a log preamble and
+ * a timestamp.
+ * @param fmt Formatted string
+ */
 void printInfo(const char *fmt, ...);
 void printWarning(const char* fmt, ...);
 void printDebug(const char* fmt, ...);

From 087482300d0177e7297a7749adf279959b34625f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 01:49:12 +0100
Subject: [PATCH 1164/1292] include order

---
 serviceinterface/ServiceInterfacePrinter.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index f67dfb53..369edd0f 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -1,10 +1,8 @@
+#include <FSFWConfig.h>
 #include "ServiceInterfacePrinter.h"
 #include "serviceInterfaceDefintions.h"
-
 #include "../timemanager/Clock.h"
 
-#include <FSFWConfig.h>
-
 #include <cstdarg>
 #include <cstdint>
 
@@ -13,7 +11,7 @@ fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
-    uint32_t len = 0;
+    size_t len = 0;
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */

From 61fc6cac97e8febcc2dfcff7956819b8737d3a64 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 13:25:42 +0100
Subject: [PATCH 1165/1292] added change for windows

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index bbfb69c7..222c1e2c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -5,6 +5,10 @@
 #include <cstring>
 #include <inttypes.h>
 
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+#include "Windows.h"
+#endif
+
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
 
@@ -33,6 +37,15 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	else if(setMessage.find("ERROR")) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+
+#ifdef WIN32
+	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+	DWORD dwMode = 0;
+	GetConsoleMode(hOut, &dwMode);
+	dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+	SetConsoleMode(hOut, dwMode);
+#endif
+
 #endif
 
 	preamble.reserve(MAX_PREAMBLE_SIZE);

From c19e628d7971e23b64ce87f36bd1f6b2caf2a113 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 13:58:18 +0100
Subject: [PATCH 1166/1292] all cstdout uses wrapped in preprocessor defines

---
 container/SharedRingBuffer.cpp                |  2 ++
 controller/ExtendedControllerBase.cpp         |  2 ++
 datalinklayer/Clcw.cpp                        |  2 ++
 datalinklayer/DataLinkLayer.cpp               |  4 +++
 datalinklayer/MapPacketExtraction.cpp         | 12 +++++++
 datalinklayer/TcTransferFrame.cpp             | 23 ++++++++----
 datalinklayer/TcTransferFrameLocal.cpp        |  2 ++
 datalinklayer/VirtualChannelReception.cpp     |  2 ++
 datapool/PoolDataSetBase.cpp                  | 10 ++++++
 datapool/PoolEntry.cpp                        |  6 ++++
 datapoollocal/HasLocalDataPoolIF.h            |  2 ++
 datapoollocal/LocalDataPoolManager.cpp        | 28 +++++++++++++++
 datapoollocal/LocalDataPoolManager.h          |  4 +++
 datapoollocal/LocalPoolDataSetBase.cpp        |  8 +++++
 datapoollocal/LocalPoolObjectBase.cpp         |  8 +++++
 datapoollocal/LocalPoolVariable.tpp           |  8 +++++
 datapoollocal/LocalPoolVector.tpp             | 12 +++++++
 datapoollocal/PoolReadHelper.h                |  2 ++
 .../PollingSequenceFactory.cpp                |  2 ++
 devicehandlers/DeviceHandlerBase.cpp          | 20 +++++++++++
 .../DeviceHandlerFailureIsolation.cpp         |  4 +++
 events/EventManager.cpp                       |  7 ++--
 fdir/FailureIsolationBase.cpp                 |  8 +++++
 globalfunctions/arrayprinter.cpp              | 10 +++++-
 health/HealthHelper.cpp                       |  8 +++++
 internalError/InternalErrorReporter.cpp       |  4 ++-
 ipc/MessageQueueMessage.cpp                   |  4 +++
 ipc/MutexHelper.h                             |  4 +++
 memory/MemoryHelper.cpp                       |  2 ++
 monitoring/MonitoringMessageContent.h         |  2 ++
 objectmanager/ObjectManager.cpp               | 24 ++++++++++++-
 objectmanager/ObjectManagerIF.h               |  2 ++
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  2 ++
 osal/FreeRTOS/BinarySemaphore.cpp             |  6 ++++
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  6 ++++
 osal/FreeRTOS/CountingSemaphore.cpp           |  8 +++++
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  6 ++++
 osal/FreeRTOS/MessageQueue.cpp                |  3 ++
 osal/FreeRTOS/Mutex.cpp                       |  2 ++
 osal/FreeRTOS/PeriodicTask.cpp                |  6 ++++
 osal/FreeRTOS/SemaphoreFactory.cpp            |  4 +++
 osal/host/Clock.cpp                           | 16 +++++++++
 osal/host/FixedTimeslotTask.cpp               |  8 +++++
 osal/host/MessageQueue.cpp                    |  4 +++
 osal/host/PeriodicTask.cpp                    |  6 ++++
 osal/host/QueueMapManager.cpp                 |  4 +++
 osal/host/SemaphoreFactory.cpp                |  4 +++
 osal/linux/BinarySemaphore.cpp                |  6 ++++
 osal/linux/Clock.cpp                          |  2 ++
 osal/linux/CountingSemaphore.cpp              |  2 ++
 osal/linux/FixedTimeslotTask.cpp              |  4 +++
 osal/linux/MessageQueue.cpp                   | 35 ++++++++++++++++++-
 osal/linux/Mutex.cpp                          |  8 +++++
 osal/linux/PeriodicPosixTask.cpp              |  8 +++++
 osal/linux/PosixThread.cpp                    | 32 +++++++++++++++++
 osal/linux/TcUnixUdpPollingTask.cpp           | 18 ++++++++++
 osal/linux/Timer.cpp                          |  2 ++
 osal/linux/TmTcUnixUdpBridge.cpp              | 24 +++++++++++++
 osal/rtems/MessageQueue.cpp                   |  2 ++
 osal/rtems/MultiObjectTask.cpp                |  4 +++
 osal/rtems/Mutex.cpp                          |  4 +++
 osal/rtems/PollingTask.cpp                    |  8 +++++
 osal/rtems/TaskBase.cpp                       |  2 ++
 osal/windows/TcWinUdpPollingTask.cpp          | 24 +++++++++++++
 osal/windows/TmTcWinUdpBridge.cpp             | 30 ++++++++++++++++
 parameters/ParameterHelper.cpp                |  2 ++
 pus/CService201HealthCommanding.cpp           |  2 ++
 pus/Service1TelecommandVerification.cpp       |  4 +++
 pus/Service2DeviceAccess.cpp                  |  6 ++++
 pus/Service3Housekeeping.cpp                  |  6 ++++
 pus/Service5EventReporting.cpp                |  4 +++
 pus/Service8FunctionManagement.cpp            |  6 ++++
 serialize/SerialBufferAdapter.cpp             |  4 +++
 storagemanager/ConstStorageAccessor.cpp       |  8 +++++
 storagemanager/LocalPool.cpp                  | 16 +++++++++
 storagemanager/PoolManager.cpp                |  2 ++
 storagemanager/StorageAccessor.cpp            | 10 ++++++
 subsystem/SubsystemBase.cpp                   |  2 ++
 tasks/FixedSlotSequence.cpp                   | 12 +++++++
 tcdistribution/CCSDSDistributor.cpp           |  8 +++++
 tcdistribution/PUSDistributor.cpp             | 12 +++++++
 tcdistribution/TcDistributor.cpp              |  3 +-
 timemanager/Stopwatch.cpp                     |  4 +++
 tmtcpacket/pus/TcPacketBase.cpp               |  2 ++
 tmtcpacket/pus/TcPacketStored.cpp             |  6 ++++
 tmtcpacket/pus/TmPacketBase.cpp               |  4 +++
 tmtcpacket/pus/TmPacketStored.cpp             |  2 ++
 tmtcservices/CommandingServiceBase.cpp        |  4 +++
 tmtcservices/PusServiceBase.cpp               |  8 +++++
 tmtcservices/TmTcBridge.cpp                   | 30 ++++++++++++++++
 tmtcservices/VerificationReporter.cpp         | 12 +++++++
 unittest/internal/InternalUnitTester.cpp      |  4 +++
 unittest/internal/UnittDefinitions.cpp        |  2 ++
 unittest/internal/osal/IntTestSemaphore.cpp   |  2 ++
 .../PollingSequenceFactory.cpp                |  2 ++
 .../user/unittest/core/CatchDefinitions.cpp   |  2 ++
 96 files changed, 715 insertions(+), 14 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 6ddb3d3e..340bce37 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -47,9 +47,11 @@ ReturnValue_t SharedRingBuffer::initialize() {
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
 	if(receiveSizesFIFO == nullptr) {
 		// Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
 				<< " was not configured to have sizes FIFO, returning nullptr!"
 				<< std::endl;
+#endif
 	}
 	return receiveSizesFIFO;
 }
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index fa4f6786..f9f7534d 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -107,7 +107,9 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
 }
 
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
+#if CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
+#endif
     return nullptr;
 }
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index dc435a2b..19aa4e7b 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,9 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
+#endif
 }
 
 void Clcw::setWhole(uint32_t rawClcw) {
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 75f2edda..6a383851 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -98,8 +98,10 @@ ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
 	receivedDataLength = length;
 	ReturnValue_t status = allFramesReception();
 	if (status != RETURN_OK) {
+#if 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 CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 845ed7c1..0bf79f42 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -29,9 +29,11 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 			bufferPosition = &packetBuffer[packetLength];
 			status = RETURN_OK;
 		} else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 					<< packetLength << std::endl;
+#endif
 			clearBuffers();
 			status = CONTENT_TOO_LARGE;
 		}
@@ -51,24 +53,30 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				}
 				status = RETURN_OK;
 			} else {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error
 						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 						<< packetLength << std::endl;
+#endif
 				clearBuffers();
 				status = CONTENT_TOO_LARGE;
 			}
 		} else {
+#if 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 CPP_OSTREAM_ENABLED == 1
 		sif::error
 				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
 				<< (int) segmentationFlag << std::endl;
+#endif
 		clearBuffers();
 		status = DATA_CORRUPTED;
 		break;
@@ -135,10 +143,14 @@ ReturnValue_t MapPacketExtraction::initialize() {
 }
 
 void MapPacketExtraction::printPacketBuffer(void) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "DLL: packet_buffer contains: " << std::endl;
+#endif
 	for (uint32_t i = 0; i < this->packetLength; ++i) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
 				<< (uint16_t) this->packetBuffer[i] << std::endl;
+#endif
 	}
 }
 
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index f1a70bdc..0050994a 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -87,16 +87,25 @@ uint8_t* TcTransferFrame::getFullDataField() {
 }
 
 void TcTransferFrame::print() {
+#if 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
 }
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index e8785c92..1ef772a2 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -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 CPP_OSTREAM_ENABLED == 1
 			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
+#endif
 		}
 	} else {
 		//No data in frame
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index cde28de3..8ad65740 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -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 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();
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 8f073359..f2c2b867 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -13,18 +13,24 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
+#endif
 		return DataSetIF::DATA_SET_UNINITIALISED;
 	}
 	if (variable == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Pool variable is nullptr." << std::endl;
+#endif
 		return DataSetIF::POOL_VAR_NULL;
 	}
 	if (fillCount >= maxFillCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
+#endif
 		return DataSetIF::DATA_SET_FULL;
 	}
 	registeredVariables[fillCount] = variable;
@@ -47,9 +53,11 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 		unlockDataPool();
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::read(): "
 				"Call made in wrong position. Don't forget to commit"
 				" member datasets!" << std::endl;
+#endif
 		result = SET_WAS_ALREADY_READ;
 	}
 
@@ -138,8 +146,10 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
+#if 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;
 			}
 		}
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index fb73328c..b1ccb260 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -12,9 +12,11 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else if (initValue.size() != setLength){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "PoolEntry: setLength is not equal to initializer list"
 				"length! Performing zero initialization with given setLength"
 				<< std::endl;
+#endif
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else {
@@ -67,10 +69,14 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
+#endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << std::dec << std::endl;
+#endif
 }
 
 template<typename T>
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index df855110..e94af167 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -89,8 +89,10 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
+#endif
 	    return nullptr;
 	}
 
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 5f0d15d3..0eb6f5f5 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -21,15 +21,19 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
+#endif
         return;
     }
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Could not create mutex." << std::endl;
+#endif
     }
 
     hkQueue = queueToUse;
@@ -39,17 +43,21 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ". Supplied "
                 << "queue invalid!" << std::dec << std::endl;
+#endif
     }
     hkQueue = queueToUse;
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ": Could not "
                 << "set IPC store." <<std::dec << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -61,8 +69,10 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                     << "Default HK destination object is invalid!" << std::endl;
+#endif
             return HasReturnvaluesIF::RETURN_FAILED;
         }
     }
@@ -85,8 +95,10 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
+#if CPP_OSTREAM_ENABLED == 1
     sif::warning << "HousekeepingManager: The map should only be initialized "
             << "once!" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -339,8 +351,10 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_OK;
     }
 
@@ -369,8 +383,10 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_OK;
     }
 
@@ -575,8 +591,10 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
+#endif
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
@@ -596,8 +614,10 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -678,10 +698,12 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
             sid, dataSet, true);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalDataPoolManager::performHkOperation:"
                 << "0x" << std::hex << std::setfill('0') << std::setw(8)
                 << owner->getObjectId() << " Error generating "
                 << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+#endif
     }
 }
 
@@ -726,8 +748,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found" << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -752,8 +776,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 << "Could not get free element from IPC store." << std::endl;
+#endif
         return result;
     }
 
@@ -762,8 +788,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 << "Expected size is not equal to serialized size" << std::endl;
+#endif
     }
 
     // Send structure reporting reply.
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cdefa2c2..37ae8152 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -375,15 +375,19 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
+#endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
+#endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 9ecad218..8e13b602 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -12,8 +12,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -147,8 +149,10 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
+#endif
             return result;
         }
     }
@@ -206,8 +210,10 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
+#endif
         return;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
@@ -256,8 +262,10 @@ sid_t LocalPoolDataSetBase::getSid() const {
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
         uint8_t position) const {
     if(position > 7) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
+#endif
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b4d0e306..5abef424 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -5,12 +5,16 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
+#endif
     }
     if(hkOwner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
                 << "owner is a invalid!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -23,15 +27,19 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
+#endif
     }
     HasLocalDataPoolIF* hkOwner =
             objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVariable: The supplied pool owner did not "
                 << "implement the correct interface"
                 << " HasLocalDataPoolIF!" << std::endl;
+#endif
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index a685ea8d..38e9cf4b 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,18 +33,22 @@ inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
+#endif
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -62,17 +66,21 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
 				std::dec << " failed.\n" << std::flush;
+#endif
 		return result;
 	}
 	*(poolEntry->address) = this->value;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 46123ccc..dc91fb9b 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,8 +32,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout)
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -42,10 +44,12 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
 				std::dec << " failed." << std::endl;
+#endif
 		return result;
 	}
 	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
@@ -64,17 +68,21 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for commit() call." << std::endl;
+#endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
 				std::dec << " failed.\n" << std::flush;
+#endif
 		return result;
 	}
 	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
@@ -89,8 +97,10 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#endif
 	return value[i];
 }
 
@@ -101,8 +111,10 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#endif
 	return value[i];
 }
 
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 4fe506ee..bf962c95 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -14,7 +14,9 @@ public:
 		if(readObject != nullptr) {
 			readResult = readObject->read(mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#endif
 #endif
 		}
 	}
diff --git a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
index f836a746..443b2bbb 100644
--- a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
+++ b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
@@ -15,8 +15,10 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 251320cb..da2b823d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,11 +39,13 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
 				<< std::setw(8) << std::setfill('0') << this->getObjectId()
 				<< std::dec << ": Do not pass nullptr as a cookie, consider "
 				<< std::setfill(' ') << "passing a dummy cookie instead!"
 				<< std::endl;
+#endif
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -130,24 +132,30 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: Communication interface "
 				"invalid." << std::endl;
 		sif::error << "Make sure it is set up properly and implements"
 				" DeviceCommunicationIF" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerBase::initialize: Initializing "
 	            "communication interface failed!" << std::endl;
+#endif
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
 				"factory." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -156,10 +164,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
 					"ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
 					" and implements AcceptsDeviceResponsesIF" << std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 		defaultRawReceiver = rawReceiver->getDeviceQueue();
@@ -168,10 +178,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "DeviceHandlerBase::initialize: Power switcher "
 					<< "object ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
 					<< " and implements PowerSwitchIF" << std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
@@ -708,8 +720,10 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
+#endif
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -720,8 +734,10 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
+#endif
 			}
 			break;
 		}
@@ -1275,9 +1291,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    //so we can track misconfigurations
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Busy" << std::dec
 					<< std::endl;
+#endif
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1302,10 +1320,12 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
 			//so we can track misconfigurations
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
 					<< deviceCommandId << " isExecuting" << std::dec
 					<< std::endl;
+#endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index 9d0535bf..c7f87859 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -169,8 +169,10 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
 				" initialize FailureIsolationBase." << std::endl;
+#endif
 		return result;
 	}
 	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
@@ -250,8 +252,10 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 
 	if (owner == nullptr) {
 	    // Configuration error.
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerFailureIsolation::"
 	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+#endif
 	    return false;
 	}
 
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 6cc97eb6..6742ff86 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -122,6 +122,7 @@ void EventManager::printEvent(EventMessage* message) {
 	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
+#if CPP_OSTREAM_ENABLED == 1
 		sif::info << "EVENT: ";
 		if (string != 0) {
 			sif::info << string;
@@ -132,10 +133,12 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
-#endif
+#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* DEBUG_INFO_EVENT == 1 */
 		break;
 	default:
 		string = translateObject(message->getReporter());
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "EventManager: ";
 		if (string != 0) {
 			sif::debug << string;
@@ -146,13 +149,13 @@ void EventManager::printEvent(EventMessage* message) {
 		sif::debug << " reported " << translateEvents(message->getEvent())
 				<< " (" << std::dec << message->getEventId() << ") "
 				<< std::endl;
-
 		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
 				<< ", P1 Dec: " << std::dec << message->getParameter1()
 				<< std::endl;
 		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
 				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
 				<< std::endl;
+#endif
 		break;
 	}
 }
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index a04a0313..fed301b5 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -21,8 +21,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
 	if (manager == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
 				" been initialized!" << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	ReturnValue_t result = manager->registerListener(eventQueue->getId());
@@ -36,8 +38,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
 		if (owner == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Owner object "
 					"invalid. Make sure it implements HasHealthIF" << std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
 	}
@@ -45,10 +49,14 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
 		if (parentIF == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Parent object"
 					<< "invalid." << std::endl;
+#endif
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure it implements ConfirmsFailuresIF."
 					<< std::endl;
+#endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 			return RETURN_FAILED;
 		}
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index b1e888c5..c14cc7c6 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -4,10 +4,12 @@
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
 	}
@@ -21,6 +23,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 
 void arrayprinter::printHex(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -28,16 +31,18 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 			sif::info << " , ";
 			if(i > 0 and i % maxCharPerLine == 0) {
 				sif::info << std::endl;
+
 			}
-		}
 
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#endif
 }
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);
@@ -49,13 +54,16 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#endif
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
+#if CPP_OSTREAM_ENABLED == 1
     sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
         sif::info << "Byte " << i + 1 << ": 0b"<<
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#endif
 }
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index d574634d..de795a6c 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -41,14 +41,18 @@ ReturnValue_t HealthHelper::initialize() {
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
 
 	if (healthTable == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Health table object needs"
 	            "to be created in factory." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	if(eventSender == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Owner has to implement "
 	            "ReportingProxyIF." << std::endl;
+#endif
 	    return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -79,8 +83,10 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
+#endif
 	}
 }
 
@@ -98,8 +104,10 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
+#endif
 
 	}
 }
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index bfb67289..a2dc529d 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -29,14 +29,16 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#ifdef DEBUG
+#if FSFW_ENHANCED_PRINTOUT == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+#if CPP_OSTREAM_ENABLED == 1
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#endif
 	    }
 	}
 #endif
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index dcd4def3..cdd4d943 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -15,8 +15,10 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
 		this->messageSize = this->HEADER_SIZE + size;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
 				"allowed size! Setting content to 0" << std::endl;
+#endif
 		memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
 		this->messageSize = this->HEADER_SIZE;
 	}
@@ -52,7 +54,9 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 }
 
 void MessageQueueMessage::print(bool printWholeMessage) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "MessageQueueMessage content: " << std::endl;
+#endif
 	if(printWholeMessage) {
 	    arrayprinter::print(getData(), getMaximumMessageSize());
 	}
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index 97001ade..bd2f5187 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -12,12 +12,16 @@ public:
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
+#endif
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of Mutex failed with code "
 			        << status << std::endl;
+#endif
 		}
 	}
 
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 6b11882f..1d2a62a9 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -16,7 +16,9 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	lastSender = message->getSender();
 	lastCommand = message->getCommand();
 	if (busy) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "MemHelper: Busy!" << std::endl;
+#endif
 	}
 	switch (lastCommand) {
 	case MemoryMessage::CMD_MEMORY_DUMP:
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 44d32656..44661e4c 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -72,8 +72,10 @@ private:
 		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
 			if ( timeStamper == nullptr ) {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
+#endif
 				return false;
 			}
 		}
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 5871bfcd..12f4ef4f 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -18,13 +18,18 @@ ObjectManager::~ObjectManager() {
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	auto returnPair = objectList.emplace(id, object);
 	if (returnPair.second) {
+#if CPP_OSTREAM_ENABLED == 1
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
+#endif
 		return this->RETURN_OK;
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << (int)id << std::dec << " is already in use!" << std::endl;
+		           << static_cast<uint32_t> id << std::dec
+				   << " is already in use!" << std::endl;
 		sif::error << "Terminating program." << std::endl;
+#endif
 		//This is very severe and difficult to handle in other places.
 		std::exit(INSERTION_FAILED);
 	}
@@ -33,12 +38,16 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
 		//           << (int)id << std::dec << " removed." << std::endl;
+#endif
 		return RETURN_OK;
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::removeObject: Requested object "
 		        << std::hex << (int)id << std::dec << " not found." << std::endl;
+#endif
 		return NOT_FOUND;
 	}
 }
@@ -60,8 +69,10 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
+#endif
 		return;
 	}
 	this->produceObjects();
@@ -71,37 +82,48 @@ void ObjectManager::initialize() {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
 			object_id_t var = it.first;
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
 					"initialize with code 0x" << result << std::dec <<
 					std::setfill(' ') << std::endl;
+#endif
 			errorCount++;
 		}
 	}
 	if (errorCount > 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
+#endif
 	}
 	//Init was successful. Now check successful interconnections.
 	errorCount = 0;
 	for (auto const& it : objectList) {
 		result = it.second->checkObjectConnections();
 		if ( result != RETURN_OK ) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
 					(int) it.first  << " connection check failed with code 0x"
 					<< result << std::dec << std::endl;
+#endif
 			errorCount++;
 		}
 	}
 	if (errorCount > 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
+#endif
 	}
 }
 
 void ObjectManager::printList() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
+
 	}
+#endif
 }
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 4bd1d915..16700625 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -86,8 +86,10 @@ extern ObjectManagerIF *objectManager;
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
+#endif
 	}
 	SystemObjectIF* temp = this->getSystemObject(id);
 	return dynamic_cast<T*>(temp);
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index a420ec48..d9f4a3cb 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -8,8 +8,10 @@
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Could not retrieve task handle. Please ensure the"
 				"constructor was called inside a task." << std::endl;
+#endif
 	}
 	xTaskNotifyGive(handle);
 }
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 6fee5c35..3915afe9 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -5,7 +5,9 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
+#endif
 	}
 	// Initiated semaphore must be given before it can be taken.
 	xSemaphoreGive(handle);
@@ -18,7 +20,9 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "Binary semaphore creation failure" << std::endl;
+#endif
     }
     xSemaphoreGive(handle);
 }
@@ -28,7 +32,9 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "Binary semaphore creation failure" << std::endl;
+#endif
         }
         xSemaphoreGive(handle);
     }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index 9d309acc..e66f044d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,25 +9,31 @@
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
 				"handle. Please ensure the constructor was called inside a "
 				"task." << std::endl;
+#endif
 	}
 
 	uint32_t oldNotificationValue;
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
 			&oldNotificationValue);
 	if(oldNotificationValue != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
 				"current notification value is not 0. Please ensure the "
 				"notification value is not used for other purposes!" << std::endl;
+#endif
 	}
 	for(int i = 0; i < initCount; i++) {
 		xTaskNotifyGive(handle);
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index a202e480..2521e52e 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,14 +10,18 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
 	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 }
 
@@ -25,7 +29,9 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
 		maxCount(other.maxCount), initCount(other.initCount) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 }
 
@@ -33,7 +39,9 @@ CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+#endif
 	}
 	return * this;
 }
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index fc5b89fe..6b289df7 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -37,15 +37,19 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -69,8 +73,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index fdadf8b7..27b9a769 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -10,6 +10,7 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
+#if CPP_OSTREAM_ENABLED == 1
 	if (handle == nullptr) {
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Creation failed." << std::endl;
@@ -17,7 +18,9 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		        << std::endl;
 		sif::error << "Specified Maximum Message Size: "
 		        << maxMessageSize << std::endl;
+
 	}
+#endif
 }
 
 MessageQueue::~MessageQueue() {
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 9d9638b5..1722660c 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -5,7 +5,9 @@
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 2ee7bec0..155f6ac7 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -13,8 +13,10 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
+#endif
 	}
 
 }
@@ -41,8 +43,10 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t PeriodicTask::startTask() {
@@ -99,8 +103,10 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 	            "it implement ExecutableObjectIF" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index beb0d096..4db46c69 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -32,8 +32,10 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 		return new BinarySemaphoreUsingTask();
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 				"binary semaphore" << std::endl;
+#endif
 		return new BinarySemaphore();
 	}
 }
@@ -47,8 +49,10 @@ SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
+#endif
 		return new CountingSemaphore(maxCount, initCount);
 	}
 
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 41321eeb..7a763a60 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -14,7 +14,9 @@ MutexIF* Clock::timeMutex = NULL;
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void){
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
+#endif
 	return 0;
 	//return CLOCKS_PER_SEC;
 	//uint32_t ticks = sysconf(_SC_CLK_TCK);
@@ -23,7 +25,9 @@ uint32_t Clock::getTicksPerSecond(void){
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 	// do some magic with chrono
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -36,7 +40,9 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 #else
 
 #endif
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -60,7 +66,9 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	time->tv_usec = timeUnix.tv_nsec / 1000.0;
 	return HasReturnvaluesIF::RETURN_OK;
 #else
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 #endif
 
@@ -68,7 +76,9 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	// do some magic with chrono
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -90,7 +100,9 @@ timeval Clock::getUptime() {
 		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
 	}
 #else
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
+#endif
 #endif
 	return timeval;
 }
@@ -126,7 +138,9 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
 	time->usecond = usecond.count();
 
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -148,7 +162,9 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 	to->tv_usec = from->usecond;
 	//Fails in 2038..
 	return HasReturnvaluesIF::RETURN_OK;
+#if CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 9e892bb5..1fd3cd7f 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -35,15 +35,19 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
 #elif defined(LINUX)
     // TODO: we can just copy and paste the code from the linux OSAL here.
@@ -70,8 +74,10 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
     }
 
     this->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
     sif::debug << "FixedTimeslotTask::taskEntryPoint: "
             "Returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t FixedTimeslotTask::startTask() {
@@ -134,8 +140,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         return HasReturnvaluesIF::RETURN_OK;
     }
 
+#if CPP_OSTREAM_ENABLED == 1
     sif::error << "Component " << std::hex << componentId <<
             " not found, not adding it to pst" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index d662d782..0c048120 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -10,8 +10,10 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Could not be created" << std::endl;
+#endif
 	}
 }
 
@@ -137,8 +139,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			targetQueue->messageQueue.push(*mqmMessage);
 		}
 		else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
 					"is not MessageQueueMessage!" << std::endl;
+#endif
 		}
 
 	}
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index bfa6c3fd..09acd2cb 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -33,15 +33,19 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
     result = SetThreadPriority(
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
+#endif
     }
 #elif defined(LINUX)
     // we can just copy and paste the code from linux here.
@@ -69,8 +73,10 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	this->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "PeriodicTask::taskEntryPoint: "
 			"Returned from taskFunctionality." << std::endl;
+#endif
 }
 
 ReturnValue_t PeriodicTask::startTask() {
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 621f46bc..620f8add 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -26,8 +26,10 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
 		// this should never happen for the atomic variable.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "QueueMapManager: This ID is already inside the map!"
 				<< std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if (id != nullptr) {
@@ -44,8 +46,10 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
 				messageQueueId << " does not exists in the map" << std::endl;
+#endif
 		return nullptr;
 	}
 }
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index b19b2c75..840dacef 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -21,16 +21,20 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
 			" Returning nullptr!\n" << std::flush;
+#endif
 	return nullptr;
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
 				" Returning nullptr!\n" << std::flush;
+#endif
 	return nullptr;
 }
 
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index b81fa109..22d35e3a 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -43,8 +43,10 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 	    result = sem_timedwait(&handle, &timeOut);
 	    if(result != 0 and errno == EINVAL) {
+#if CPP_OSTREAM_ENABLED == 1
 	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
 	    			<< std::endl;
+#endif
 	    }
 	}
 	if(result == 0) {
@@ -62,8 +64,10 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
 				"Code " << strerror(errno) << std::endl;
+#endif
 		/* No break */
 	default:
 		return HasReturnvaluesIF::RETURN_FAILED;
@@ -126,8 +130,10 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
 				<< std::endl;
+#endif
 		}
 	}
 }
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 6cddda35..e4e7df86 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -69,7 +69,9 @@ timeval Clock::getUptime() {
 	timeval uptime;
 	auto result = getUptime(&uptime);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
+#endif
 	}
 	return uptime;
 }
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 18339399..22cb1615 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -4,8 +4,10 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
+#endif
 		initCount = maxCount;
 	}
 
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 247a34ed..0635b560 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -47,8 +47,10 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::dec << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -91,7 +93,9 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				   << " deadlines." << std::endl;
+#endif
 	}
 }
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index cfadb793..28dfb9c7 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -10,7 +10,6 @@
 #include <errno.h>
 
 
-
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 		id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
 		defaultDestination(MessageQueueIF::NO_QUEUE),
@@ -43,13 +42,17 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
 				   << strerror(errno) <<std::endl;
+#endif
 	}
 	status = mq_unlink(name);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
 				   << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -57,8 +60,10 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
+#endif
 		size_t defaultMqMaxMsg = 0;
 		// Not POSIX conformant, but should work for all UNIX systems.
 		// Just an additional helpful printout :-)
@@ -79,11 +84,13 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
 			Apply changes with: sudo sysctl -p
 			*/
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
 			sif::error << "This error can be fixed by setting the maximum "
 					"allowed message size higher!" << std::endl;
+#endif
 
 		}
 		break;
@@ -95,8 +102,10 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		//We unlink the other queue
 		int status = mq_unlink(name);
 		if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "mq_unlink Failed with status: " << strerror(errno)
 													<< std::endl;
+#endif
 		}
 		else {
 			// Successful unlinking, try to open again
@@ -114,9 +123,11 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 
 	default:
 		// Failed either the first time or the second time
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 		<< name << std::dec << " failed with status: "
 		<< strerror(errno) << std::endl;
+#endif
 
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -151,15 +162,19 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(message == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message is "
 				"nullptr!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message size "
 				<< message->getMaximumMessageSize()
 				<< " too small to receive data!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -187,8 +202,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -200,8 +217,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
 			 *   been set in the queue's mq_flags.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EMSGSIZE:
 			/*
@@ -213,8 +232,10 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   given msg_len is too short for the message that would have
 			 *   been received.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINTR:
 			//The operation was interrupted by a signal.
@@ -237,8 +258,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			//mq_attr is NULL
@@ -253,8 +276,10 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EINVAL:
 			/*
@@ -306,8 +331,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	if(message == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -335,11 +362,13 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
 					<< " destination invalid."  << std::endl;
 			sif::error << strerror(errno) << " in "
 					<<"mq_send to: " << sendTo << " sent from "
 					<< sentFrom << std::endl;
+#endif
 			return DESTINVATION_INVALID;
 		}
 		case EINTR:
@@ -354,14 +383,18 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
 			 *   msg_prio is greater than the priority of the calling process.
 			 */
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
+#endif
 			/*NO BREAK*/
 		case EMSGSIZE:
 			// The msg_len is greater than the msgsize associated with
 			//the specified queue.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Size error [" <<
 					strerror(errno) << "] in mq_send" << std::endl;
+#endif
 			/*NO BREAK*/
 		default:
 			return HasReturnvaluesIF::RETURN_FAILED;
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index b27ff8c0..e2012634 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -12,24 +12,32 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
+#endif
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
+#endif
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
+#endif
 	}
 	// After a mutex attributes object has been used to initialize one or more
 	// mutexes, any function affecting the attributes object
 	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 3c1df6bb..1c69124d 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -25,8 +25,10 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 				<< " it implements ExecutableObjectIF!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
@@ -42,7 +44,9 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << stackSize << std::endl;
+#endif
 	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -67,12 +71,16 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
 			if(status == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
+#endif
 			}
 			else {
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
+#endif
 			}
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 55d74de3..80bf52c2 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -48,8 +48,10 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
 				caughtSig << std::endl;
+#endif
 	}
 }
 
@@ -118,7 +120,9 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::debug << "PosixThread::createTask" << std::endl;
+#endif
 	/*
 	 * The attr argument points to a pthread_attr_t structure whose contents
        are used at thread creation time to determine attributes for the new
@@ -129,53 +133,69 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 	void* stackPointer;
 	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
+#endif
 		if(errno == ENOMEM) {
 			uint64_t stackMb = stackSize/10e6;
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#endif
 		}
 		else if(errno == EINVAL) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#endif
 		}
 		return;
 	}
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: pthread_attr_setstack "
 				" failed with: " << strerror(status) <<  std::endl;
 		sif::error << "Make sure the specified stack size is valid and is "
 				"larger than the minimum allowed stack size." << std::endl;
+#endif
 	}
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
 					strerror(status) << std::endl;
+#endif
 	}
 
 	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	sched_param scheduleParams;
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule params failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	//Set Signal Mask for suspend until startTask is called
@@ -184,36 +204,48 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread sigmask failed failed with: " <<
 				strerror(status) << " errno: " << strerror(errno) << std::endl;
+#endif
 	}
 
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread create failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
+#endif
 		if(status == ERANGE) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Task name length longer"
 					" than 16 chars. Truncating.." << std::endl;
+#endif
 			name[15] = '\0';
 			status = pthread_setname_np(thread,name);
 			if(status != 0){
+#if CPP_OSTREAM_ENABLED == 1
 				sif::error << "PosixThread::createTask: Setting name"
 						" did not work.." << std::endl;
+#endif
 			}
 		}
 	}
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute destroy failed with: " <<
 				strerror(status) << std::endl;
+#endif
 	}
 }
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index af99ec91..9cbb1d02 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,14 +39,18 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcSocketPollingTask::performOperation: Reception"
 					"error." << std::endl;
+#endif
 			handleReadError();
 
 			continue;
 		}
+#if CPP_OSTREAM_ENABLED == 1
 //		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 //				<< " bytes received" << std::endl;
+#endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -65,9 +69,11 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -75,8 +81,10 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
+#endif
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -85,15 +93,19 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcUnixUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -115,8 +127,10 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			&tval, sizeof(receptionTimeout));
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -126,13 +140,17 @@ void TcUnixUdpPollingTask::handleReadError() {
 	case(EAGAIN): {
 		// todo: When working in timeout mode, this will occur more often
 		// and is not an error.
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
 				<< std::endl;
+#endif
 		break;
 	}
 	default: {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: "
 				<< strerror(errno) << std::endl;
+#endif
 	}
 	}
 }
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index bae631d7..0142025e 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -10,8 +10,10 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Timer creation failed with: " << status <<
 				" errno: " << errno << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index ab28623e..769e8aff 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -26,8 +26,10 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(serverSocket < 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
+#endif
 		handleSocketError();
 		return;
 	}
@@ -51,9 +53,11 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
+#endif
 		handleBindError();
 		return;
 	}
@@ -74,18 +78,24 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	}
 
 //	char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
 
 	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
 			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
 	if(bytesSent < 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
+#endif
 		handleSendError();
 	}
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //			" sent." << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -93,10 +103,12 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 //	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
 //			&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
 
 	// Set new IP address if it has changed.
 	if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
@@ -117,12 +129,16 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+#endif
 		break;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
+#endif
 		break;
 	}
 }
@@ -135,10 +151,12 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
 				"Ports 1-1024 are reserved on UNIX systems and require root "
 				"rights while ephermeral ports should not be used as well."
 				<< std::endl;
+#endif
 	}
 	break;
 	case(EADDRINUSE):
@@ -153,13 +171,17 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
+#endif
 		break;
 	}
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
+#endif
 		break;
 	}
 }
@@ -167,8 +189,10 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 839182a6..eff8a0fb 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,9 +9,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 970d01e1..a315681b 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,8 +30,10 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -63,7 +65,9 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+#endif
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index a5ec9635..5278a076 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,16 +10,20 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index db7864fe..591ba743 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,15 +35,19 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -51,8 +55,10 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -75,8 +81,10 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 4e0c8f00..7e3bd57a 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,9 +22,11 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index 06deafd1..e5931609 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -43,13 +43,17 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 				&senderAddressSize);
 		if(bytesReceived == SOCKET_ERROR) {
 			// handle error
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
 					" error." << std::endl;
+#endif
 			handleReadError();
 			continue;
 		}
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
 		//		<< " bytes received" << std::endl;
+#endif
 
 		ReturnValue_t result = handleSuccessfullTcRead(bytesReceived);
 		if(result != HasReturnvaluesIF::RETURN_FAILED) {
@@ -68,9 +72,11 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -78,8 +84,10 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
+#endif
 		tcStore->deleteData(storeId);
 	}
 	return result;
@@ -88,21 +96,27 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
 	//        << serverUdpSocket << std::endl;
+#endif
 
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -119,8 +133,10 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
+#endif
 	}
 }
 
@@ -128,23 +144,31 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEFAULT): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
+#endif
         break;
     }
     case(WSAEINVAL): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
                 << "Invalid input parameters. " << std::endl;
+#endif
         break;
     }
     default: {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
+#endif
         break;
     }
     }
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index e1ba132e..b9945168 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -15,8 +15,10 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     if (err != 0) {
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
                 "WSAStartup failed with error: " << err << std::endl;
+#endif
         return;
     }
 
@@ -34,8 +36,10 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
+#endif
         handleSocketError();
         return;
     }
@@ -59,9 +63,11 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
     if(result != 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
+#endif
         handleBindError();
     }
 }
@@ -77,19 +83,25 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     //clientAddressLen = sizeof(serverAddress);
 
 //  char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
 
     ssize_t bytesSent = sendto(serverSocket,
             reinterpret_cast<const char*>(data), dataLen, flags,
             reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
     if(bytesSent == SOCKET_ERROR) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
                 << std::endl;
+#endif
         handleSendError();
     }
+#if CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -97,10 +109,12 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
     MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //  char ipAddress [15];
+#if CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //          &newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 //  sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
 //          &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
+#endif
     registerCommConnect();
 
     // Set new IP address if it has changed.
@@ -114,8 +128,10 @@ void TmTcWinUdpBridge::handleSocketError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
+#endif
         break;
     }
     default: {
@@ -123,8 +139,10 @@ void TmTcWinUdpBridge::handleSocketError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
          */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
@@ -134,13 +152,17 @@ void TmTcWinUdpBridge::handleBindError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEADDRINUSE): {
+#if CPP_OSTREAM_ENABLED == 1
     	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
     			<< "Port is already in use!" << std::endl;
+#endif
     	break;
     }
     default: {
@@ -148,8 +170,10 @@ void TmTcWinUdpBridge::handleBindError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
@@ -159,13 +183,17 @@ void TmTcWinUdpBridge::handleSendError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
+#endif
         break;
     }
     case(WSAEADDRNOTAVAIL): {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
+#endif
         break;
     }
     default: {
@@ -173,8 +201,10 @@ void TmTcWinUdpBridge::handleSendError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
+#endif
         break;
     }
     }
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 23d1a1f3..5014e44c 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -48,8 +48,10 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         ConstStorageAccessor accessor(storeId);
         result = storage->getData(storeId, accessor);
         if (result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "ParameterHelper::handleParameterMessage: Getting"
                     << " store data failed for load command." << std::endl;
+#endif
             break;
         }
 
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index edacd73a..f2c579d5 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -22,7 +22,9 @@ ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice)
 	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
+#endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
 	}
 }
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 86b0dcde..9194ab24 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -51,8 +51,10 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -88,9 +90,11 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
 	AcceptsTelemetryIF* funnel = objectManager->
 			get<AcceptsTelemetryIF>(targetDestination);
 	if(funnel == nullptr){
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "Service1TelecommandVerification::initialize: Specified"
 	            " TM funnel invalid. Make sure it is set up and implements"
 	            " AcceptsTelemetryIF." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index 3648b7eb..f79c0a79 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -25,7 +25,9 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
+#endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
 	}
 }
@@ -125,9 +127,11 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Unknown message in Service2DeviceAccess::"
 				"handleUnrequestedReply with command ID " <<
 				reply->getCommand() << std::endl;
+#endif
 		break;
 	}
 	//Must be reached by all cases to clear message
@@ -143,9 +147,11 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	size_t size = 0;
 	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
 		        << std::endl;
+#endif
 		return;
 	}
 
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index 175af026..d52ab50d 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -222,8 +222,10 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
 				<< "reply command " << command << "!" << std::endl;
+#endif
 		return CommandingServiceBase::INVALID_REPLY;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -249,16 +251,20 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
 		        << "reply with " << "reply command " << command << "!"
 		        << std::endl;
+#endif
 		return;
 	}
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
 				<< "Could not generate reply!" << std::endl;
+#endif
 	}
 }
 
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index e0b34a5b..21bf2780 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -37,8 +37,10 @@ ReturnValue_t Service5EventReporting::performService() {
 	       }
 	    }
 	}
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug <<  "Service5EventReporting::generateEventReport:"
 	        " Too many events" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -53,8 +55,10 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	ReturnValue_t result = tmPacket.sendPacket(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service5EventReporting::generateEventReport:"
 		        " Could not send TM packet" << std::endl;
+#endif
 	}
 	return result;
 }
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index d710c56e..df25dd85 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -60,9 +60,11 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
     if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
                 << " TC size smaller thant minimum size of direct command."
                 << std::endl;
+#endif
         return CommandingServiceBase::INVALID_TC;
     }
 
@@ -125,8 +127,10 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     const uint8_t * buffer = nullptr;
     ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
     if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "Service 8: Could not retrieve data for data reply"
                 << std::endl;
+#endif
         return result;
     }
     DataReply dataReply(objectId, actionId, buffer, size);
@@ -135,8 +139,10 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "Service8FunctionManagement::handleReply: Deletion"
                 << " of data in pool failed." << std::endl;
+#endif
     }
     return result;
 }
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 1c11afd4..303de742 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -95,8 +95,10 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(buffer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()." << std::endl;
+#endif
 		return nullptr;
 	}
 	return buffer;
@@ -105,8 +107,10 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "SerialBufferAdapter::getConstBuffer:"
 				" Buffers are unitialized!" << std::endl;
+#endif
 		return nullptr;
 	}
 	return constBuffer;
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 842f1ce8..0beef64f 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -46,7 +46,9 @@ const uint8_t* ConstStorageAccessor::data() const {
 
 size_t ConstStorageAccessor::size() const {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 	}
 	return size_;
 }
@@ -54,12 +56,16 @@ size_t ConstStorageAccessor::size() const {
 ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large enough"
 				<< std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(constDataPointer, constDataPointer + size_, pointer);
@@ -76,7 +82,9 @@ store_address_t ConstStorageAccessor::getId() const {
 
 void ConstStorageAccessor::print() const {
 	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return;
 	}
 	arrayprinter::print(constDataPointer, size_);
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index 74e362d4..b2d5ffc4 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -8,8 +8,10 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
 	if(NUMBER_OF_POOLS == 0) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
 				<< " invalid!" << std::endl;
+#endif
 	}
 	max_pools_t index = 0;
 	for (const auto& currentPoolConfig: poolConfig) {
@@ -118,8 +120,10 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
+#endif
 
 #endif
     ReturnValue_t status = RETURN_OK;
@@ -134,8 +138,10 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
         		<< std::endl;
+#endif
         status = ILLEGAL_STORAGE_ID;
     }
     return status;
@@ -158,8 +164,10 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             result = deleteData(localId);
 #if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
+#if CPP_OSTREAM_ENABLED == 1
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
+#endif
             }
 #endif
             break;
@@ -186,8 +194,10 @@ ReturnValue_t LocalPool::initialize() {
     //Check if any pool size is large than the maximum allowed.
     for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
         if (elementSizes[count] >= STORAGE_FREE) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalPool::initialize: Pool is too large! "
                     "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
+#endif
             return StorageManagerIF::POOL_TOO_LARGE;
         }
     }
@@ -209,8 +219,10 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         store_address_t *storeId, bool ignoreFault) {
     ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
     if (status != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
                 << " )::reserveSpace: Packet too large." << std::endl;
+#endif
         return status;
     }
     status = findEmpty(storeId->poolIndex, &storeId->packetIndex);
@@ -224,9 +236,11 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
     }
     if (status == RETURN_OK) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
+#endif
 #endif
         sizeLists[storeId->poolIndex][storeId->packetIndex] = size;
     }
@@ -266,8 +280,10 @@ ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
+#endif
 #endif
         if (elementSizes[n] >= packetSize) {
             *poolIndex = n;
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 3b7b549b..7612fbc0 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -26,9 +26,11 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
+#if CPP_OSTREAM_ENABLED == 1
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
+#endif
 #endif
     MutexHelper mutexHelper(mutex, MutexIF::TimeoutType::WAITING,
             mutexTimeoutMs);
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 9c2f936a..373407b0 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -26,12 +26,16 @@ StorageAccessor::StorageAccessor(StorageAccessor&& other):
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large "
 				"enough" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(dataPointer, dataPointer + size_, pointer);
@@ -40,7 +44,9 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 	}
 	return dataPointer;
 }
@@ -48,12 +54,16 @@ uint8_t* StorageAccessor::data() {
 ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		uint16_t offset) {
 	if(internalState == AccessState::UNINIT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Data too large for pool "
 				"entry!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	std::copy(data, data + size, dataPointer + offset);
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index f60c8847..4ae50858 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -86,8 +86,10 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table
+#if CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
 					<< std::endl;
+#endif
 			continue;
 		}
 
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index e5db4301..9d15a9c7 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -91,8 +91,10 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedSlotSequence::checkSequence:"
 				<< " Slot list is empty!" << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 
@@ -100,8 +102,10 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		ReturnValue_t result = customCheckFunction(slotList);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			// Continue for now but print error output.
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence:"
 					<< " Custom check failed!" << std::endl;
+#endif
 		}
 	}
 
@@ -112,21 +116,27 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
+#endif
 			errorCount++;
 		}
 		else {
 			// All ok, print slot.
+#if CPP_OSTREAM_ENABLED == 1
 			//sif::info << "Current slot polling time: " << std::endl;
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
+#endif
 		}
 		time = slot.pollingTimeMs;
 
 	}
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
+#endif
 	if (errorCount > 0) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -149,8 +159,10 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
         }
     }
     if (count > 0) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
                 "Counted " << count << " failed initializations!"  << std::endl;
+#endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index ddd63308..742dd648 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -11,21 +11,27 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 CCSDSDistributor::~CCSDSDistributor() {}
 
 TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+#if CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
+#endif
 	const uint8_t* packet = nullptr;
 	size_t size = 0;
 	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
 				" store failed!" << std::endl;
+#endif
 	}
 	SpacePacketBase currentPacket(packet);
 
+#if CPP_OSTREAM_ENABLED == 1
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+#endif
 	TcMqMapIter position = this->queueMap.find(currentPacket.getAPID());
 	if ( position != this->queueMap.end() ) {
 		return position;
@@ -70,8 +76,10 @@ ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
 	            " TC store!" << std::endl;
+#endif
 	    status = RETURN_FAILED;
 	}
 	return status;
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 8e5b94cc..3a214268 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,9 +13,11 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+#if CPP_OSTREAM_ENABLED == 1
     // sif:: debug << "PUSDistributor::handlePacket received: "
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
+#endif
     TcMqMapIter queueMapIt = this->queueMap.end();
     if(this->currentPacket == nullptr) {
         return queueMapIt;
@@ -25,9 +27,11 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
             sif::debug << "PUSDistributor::handlePacket: Packet format "
                     << "invalid, code "<< static_cast<int>(tcStatus)
                     << std::endl;
+#endif
         }
 #endif
         uint32_t queue_id = currentPacket->getService();
@@ -40,8 +44,10 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     if (queueMapIt == this->queueMap.end()) {
         tcStatus = DESTINATION_NOT_FOUND;
 #ifdef DEBUG
+#if CPP_OSTREAM_ENABLED == 1
         sif::debug << "PUSDistributor::handlePacket: Destination not found, "
                 << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
 #endif
     }
 
@@ -57,12 +63,16 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
+#if CPP_OSTREAM_ENABLED == 1
 	// sif::info << "Service ID: " << (int)serviceId << std::endl;
+#endif
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
+#endif
 		return SERVICE_ID_ALREADY_EXISTS;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
@@ -104,9 +114,11 @@ ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
 	if (ccsdsDistributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
+#endif
 	    return RETURN_FAILED;
 	}
 	return ccsdsDistributor->registerApplication(this);
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 06e1817f..0bd4a906 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -39,6 +39,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Distributor content is: " << std::endl
 	        << "ID\t| Message Queue ID" << std::endl;
 	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
@@ -47,7 +48,7 @@ void TcDistributor::print() {
 		         << std::endl;
 	}
 	sif::debug << std::setfill(' ') << std::dec;
-
+#endif
 }
 
 ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index 302e2ac0..b3d080ba 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -28,13 +28,17 @@ double Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
+#endif
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
+#if CPP_OSTREAM_ENABLED == 1
         sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
+#endif
     }
 }
 
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index eaa8416a..1a28419c 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -63,7 +63,9 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
+#if CPP_OSTREAM_ENABLED == 1
     sif::debug << "TcPacketBase::print: " << std::endl;
+#endif
 	arrayprinter::print(getWholeData(), getFullSize());
 }
 
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index fffc86ae..021b6d67 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -23,8 +23,10 @@ TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &pData);
 	if (returnValue != this->store->RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get free element from store!"
 				<< std::endl;
+#endif
 		return;
 	}
 	this->setData(pData);
@@ -39,7 +41,9 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 		size_t* dataSize) {
 	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -61,8 +65,10 @@ bool TcPacketStored::checkAndSetStore() {
 	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 		if (this->store == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index 2c8bfd63..bf892ccf 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -57,7 +57,9 @@ void TmPacketBase::setData(const uint8_t* p_Data) {
 }
 
 void TmPacketBase::print() {
+#if CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "TmPacketBase::print: " << std::endl;
+#endif
 	 arrayprinter::print(getWholeData(), getFullSize());
 }
 
@@ -65,8 +67,10 @@ bool TmPacketBase::checkAndSetStamper() {
 	if (timeStamper == NULL) {
 		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
 		if (timeStamper == NULL) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 0fb789aa..21f237bd 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -105,8 +105,10 @@ bool TmPacketStored::checkAndSetStore() {
 	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
 		if (store == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
+#endif
 			return false;
 		}
 	}
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index ed765ecc..2be6e2ce 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -75,8 +75,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			packetSource);
 
 	if (packetForwarding == nullptr or distributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -88,8 +90,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
 	                    "not initialized yet!" << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index cb5a1247..1b03a7f0 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -25,9 +25,11 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	handleRequestQueue();
 	ReturnValue_t result = this->performService();
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusService " << (uint16_t) this->serviceId
 				<< ": performService returned with " << (int16_t) result
 				<< std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 	return RETURN_OK;
@@ -43,11 +45,13 @@ void PusServiceBase::handleRequestQueue() {
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
 //		if(status != MessageQueueIF::EMPTY) {
+#if CPP_OSTREAM_ENABLED == 1
 //			sif::debug << "PusServiceBase::performOperation: Receiving from "
 //					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
 //					<< std::setfill('0') << this->requestQueue->getId()
 //					<< std::dec << " returned: " << status << std::setfill(' ')
 //					<<  std::endl;
+#endif
 //		}
 
 		if (status == RETURN_OK) {
@@ -79,9 +83,11 @@ void PusServiceBase::handleRequestQueue() {
 			break;
 		}
 		else {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< this->serviceId << ": Error receiving packet. Code: "
 					<< std::hex << status << std::dec << std::endl;
+#endif
 		}
 	}
 }
@@ -104,10 +110,12 @@ ReturnValue_t PusServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (destService == nullptr or distributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< this->serviceId << ": Configuration error. Make sure "
 				<<	"packetSource and packetDestination are defined correctly"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	this->requestQueue->setDefaultDestination(
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index b4e9967b..954e3e75 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -23,9 +23,11 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
 	             << "packets sent per cycle exceeds limits. "
 	             << "Keeping default value." << std::endl;
+#endif
 		return RETURN_FAILED;
 	}
 }
@@ -37,9 +39,11 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
+#if CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
                 << "packets stored exceeds limits. "
                 << "Keeping default value." << std::endl;
+#endif
         return RETURN_FAILED;
     }
 }
@@ -47,21 +51,27 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
 	if (tcStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
 	if (tmStore == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
 			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
 	if (tcDistributor == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
 				<< std::endl;
+#endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -75,13 +85,17 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::debug << "TmTcBridge::performOperation: "
 		        << "Error handling TCs" << std::endl;
+#endif
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::performOperation: "
 	                    << "Error handling TMs" << std::endl;
+#endif
 	}
 	return result;
 }
@@ -94,9 +108,11 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
 		       << "error code 0x" << std::hex << result  << std::dec
 			   << "!" << std::endl;
+#endif
 		status = result;
 	}
 
@@ -104,8 +120,10 @@ ReturnValue_t TmTcBridge::handleTm() {
 	        (packetSentCounter < sentPacketsPerCycle)) {
 	    result = handleStoredTm();
 	    if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
 	                << std::endl;
+#endif
 	        status = result;
 	    }
 	}
@@ -122,7 +140,9 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
+#if CPP_OSTREAM_ENABLED == 1
 	    //sif::info << (int) packetSentCounter << std::endl;
+#endif
 		if(communicationLinkUp == false or
 		        packetSentCounter >= sentPacketsPerCycle) {
 			storeDownlinkData(&message);
@@ -151,8 +171,10 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo->full()) {
+#if CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
 	                    << "of stored packet IDs reached! " << std::endl;
+#endif
 	    if(overwriteOld) {
 	        tmFifo->retrieve(&storeId);
 	        tmStore->deleteData(storeId);
@@ -171,8 +193,10 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
+#endif
 
 		store_address_t storeId;
 		const uint8_t* data = nullptr;
@@ -185,8 +209,10 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 		result = sendTm(data,size);
 		if(result != RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
+#endif
 			status = result;
 		}
 		packetSentCounter ++;
@@ -201,13 +227,17 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
+#if CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
+#endif
 		communicationLinkUp = true;
 	}
 }
 
 void TmTcBridge::registerCommDisconnect() {
+#if CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
+#endif
 	if(communicationLinkUp) {
 		communicationLinkUp = false;
 	}
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 7e40bd27..3bd1f067 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -27,9 +27,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -44,9 +46,11 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -64,9 +68,11 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
@@ -82,24 +88,30 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
+#endif
 	}
 }
 
 void VerificationReporter::initialize() {
 	if(messageReceiver == objects::NO_OBJECT) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::warning << "VerificationReporter::initialize: Verification message"
 				" receiver object ID not set yet in Factory!" << std::endl;
+#endif
 		return;
 	}
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
 	if (temp == nullptr) {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
 				<< "implementsAcceptsVerifyMessageIF" << std::endl;
+#endif
 		return;
 	}
 	this->acknowledgeQueue = temp->getVerificationQueue();
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 503a71ec..6771b17e 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -13,13 +13,17 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
+#endif
 	testserialize::test_serialization();
 	testmq::testMq();
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
+#if CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
+#endif
 	return RETURN_OK;
 }
 
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 6265e9fd..292c4b8a 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,7 +1,9 @@
 #include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
+#if CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << "\n" << std::flush;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 5a82f78c..908326d4 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -94,8 +94,10 @@ void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
 		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		//dur_millis_t time = stopwatch.stop();
 //		if(abs(time - 10) > 2) {
+#if CPP_OSTREAM_ENABLED == 1
 //		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
 //		            << std::endl;
+#endif
 //			unitt::put_error(id);
 //		}
 	}
diff --git a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
index f836a746..443b2bbb 100644
--- a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
+++ b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -15,8 +15,10 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
+#endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 0b66558a..6504700c 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -5,7 +5,9 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
 		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	} else {
+#if CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
+#endif
 		return nullptr;
 	}
 }

From afda3b2fa063b8d45b5b725ad2a36822041dc4d8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:00:29 +0100
Subject: [PATCH 1167/1292] small tweak

---
 objectmanager/ObjectManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 12f4ef4f..a7e3ac4c 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -81,8 +81,8 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
-			object_id_t var = it.first;
 #if CPP_OSTREAM_ENABLED == 1
+			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
 					"initialize with code 0x" << result << std::dec <<

From 4515c0d3cd5c4eb00218767da8d75c72448e1f23 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:08:40 +0100
Subject: [PATCH 1168/1292] exlcuding ostream headers

---
 datapool/PoolEntry.cpp                      | 1 +
 health/HealthTableIF.h                      | 2 ++
 objectmanager/ObjectManager.cpp             | 3 +++
 serviceinterface/ServiceInterfaceBuffer.cpp | 9 +++++++--
 serviceinterface/ServiceInterfaceBuffer.h   | 4 ++++
 serviceinterface/ServiceInterfaceStream.cpp | 4 ++++
 serviceinterface/ServiceInterfaceStream.h   | 5 +++++
 7 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index b1ccb260..369799c2 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -3,6 +3,7 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
+#include <algorithm>
 
 template <typename T>
 PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h
index d61e6761..727c4496 100644
--- a/health/HealthTableIF.h
+++ b/health/HealthTableIF.h
@@ -5,6 +5,8 @@
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+#include <utility>
+
 class HealthTableIF: public ManagesHealthIF {
 public:
 	virtual ~HealthTableIF() {}
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index a7e3ac4c..251dbc70 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,6 +1,9 @@
 #include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
+
+#if CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
+#endif
 #include <cstdlib>
 
 ObjectManager::ObjectManager( void (*setProducer)() ):
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 222c1e2c..abe296cb 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,7 +1,10 @@
-#include "../timemanager/Clock.h"
 #include "ServiceInterfaceBuffer.h"
+
+#if CPP_OSTREAM_ENABLED == 1
+
+#include "../timemanager/Clock.h"
+
 #include "serviceInterfaceDefintions.h"
-#include <FSFWConfig.h>
 #include <cstring>
 #include <inttypes.h>
 
@@ -252,3 +255,5 @@ void ServiceInterfaceBuffer::initSocket() {
 }
 
 #endif //ML505
+
+#endif /* CPP_OSTREAM_ENABLED == 1 */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 8f2a601c..d13143cd 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -3,6 +3,9 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <FSFWConfig.h>
+
+#if CPP_OSTREAM_ENABLED == 1
+
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -147,5 +150,6 @@ private:
 };
 #endif //ML505
 
+#endif /* CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 05643460..c618d989 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,5 +1,7 @@
 #include "ServiceInterfaceStream.h"
 
+#if CPP_OSTREAM_ENABLED == 1
+
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
 		std::ostream(&streambuf),
@@ -13,3 +15,5 @@ std::string* ServiceInterfaceStream::getPreamble() {
 	return streambuf.getPreamble();
 }
 
+#endif
+
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index cd2adf85..ddeded80 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -2,6 +2,9 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
 #include "ServiceInterfaceBuffer.h"
+
+#if CPP_OSTREAM_ENABLED == 1
+
 #include <iostream>
 #include <cstdio>
 
@@ -48,4 +51,6 @@ extern ServiceInterfaceStream warning;
 extern ServiceInterfaceStream error;
 }
 
+#endif /* CPP_OSTREAM_ENABLED == 1 */
+
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 2edf15831202666468599a2880933a4398ab0681 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:16:52 +0100
Subject: [PATCH 1169/1292] correct preprocessor define now used

---
 container/SharedRingBuffer.cpp                |  2 +-
 controller/ExtendedControllerBase.cpp         |  2 +-
 datalinklayer/Clcw.cpp                        |  2 +-
 datalinklayer/DataLinkLayer.cpp               |  4 +--
 datalinklayer/MapPacketExtraction.cpp         | 12 +++----
 datalinklayer/TcTransferFrame.cpp             |  2 +-
 datalinklayer/TcTransferFrameLocal.cpp        |  2 +-
 datalinklayer/VirtualChannelReception.cpp     |  2 +-
 datapool/PoolDataSetBase.cpp                  | 10 +++---
 datapool/PoolEntry.cpp                        |  6 ++--
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        | 28 +++++++--------
 datapoollocal/LocalDataPoolManager.h          |  4 +--
 datapoollocal/LocalPoolDataSetBase.cpp        |  8 ++---
 datapoollocal/LocalPoolObjectBase.cpp         |  8 ++---
 datapoollocal/LocalPoolVariable.tpp           |  8 ++---
 datapoollocal/LocalPoolVector.tpp             | 12 +++----
 datapoollocal/PoolReadHelper.h                |  2 +-
 .../PollingSequenceFactory.cpp                |  2 +-
 devicehandlers/DeviceHandlerBase.cpp          | 20 +++++------
 .../DeviceHandlerFailureIsolation.cpp         |  4 +--
 events/EventManager.cpp                       |  6 ++--
 fdir/FailureIsolationBase.cpp                 |  8 ++---
 globalfunctions/arrayprinter.cpp              |  8 ++---
 health/HealthHelper.cpp                       |  8 ++---
 internalError/InternalErrorReporter.cpp       |  2 +-
 ipc/MessageQueueMessage.cpp                   |  4 +--
 ipc/MutexHelper.h                             |  4 +--
 memory/MemoryHelper.cpp                       |  2 +-
 monitoring/MonitoringMessageContent.h         |  2 +-
 objectmanager/ObjectManager.cpp               | 22 ++++++------
 objectmanager/ObjectManagerIF.h               |  2 +-
 osal/FreeRTOS/BinSemaphUsingTask.cpp          |  2 +-
 osal/FreeRTOS/BinarySemaphore.cpp             |  6 ++--
 osal/FreeRTOS/CountingSemaphUsingTask.cpp     |  6 ++--
 osal/FreeRTOS/CountingSemaphore.cpp           |  8 ++---
 osal/FreeRTOS/FixedTimeslotTask.cpp           |  6 ++--
 osal/FreeRTOS/MessageQueue.cpp                |  2 +-
 osal/FreeRTOS/Mutex.cpp                       |  2 +-
 osal/FreeRTOS/PeriodicTask.cpp                |  6 ++--
 osal/FreeRTOS/SemaphoreFactory.cpp            |  4 +--
 osal/host/Clock.cpp                           | 16 ++++-----
 osal/host/FixedTimeslotTask.cpp               |  8 ++---
 osal/host/MessageQueue.cpp                    |  4 +--
 osal/host/PeriodicTask.cpp                    |  6 ++--
 osal/host/QueueMapManager.cpp                 |  4 +--
 osal/host/SemaphoreFactory.cpp                |  4 +--
 osal/linux/BinarySemaphore.cpp                |  6 ++--
 osal/linux/Clock.cpp                          |  2 +-
 osal/linux/CountingSemaphore.cpp              |  2 +-
 osal/linux/FixedTimeslotTask.cpp              |  4 +--
 osal/linux/MessageQueue.cpp                   | 34 +++++++++----------
 osal/linux/Mutex.cpp                          |  8 ++---
 osal/linux/PeriodicPosixTask.cpp              |  8 ++---
 osal/linux/PosixThread.cpp                    | 32 ++++++++---------
 osal/linux/TcUnixUdpPollingTask.cpp           | 18 +++++-----
 osal/linux/Timer.cpp                          |  2 +-
 osal/linux/TmTcUnixUdpBridge.cpp              | 24 ++++++-------
 osal/rtems/MessageQueue.cpp                   |  2 +-
 osal/rtems/MultiObjectTask.cpp                |  4 +--
 osal/rtems/Mutex.cpp                          |  4 +--
 osal/rtems/PollingTask.cpp                    |  8 ++---
 osal/rtems/TaskBase.cpp                       |  2 +-
 osal/windows/TcWinUdpPollingTask.cpp          | 24 ++++++-------
 osal/windows/TmTcWinUdpBridge.cpp             | 30 ++++++++--------
 parameters/ParameterHelper.cpp                |  2 +-
 pus/CService201HealthCommanding.cpp           |  2 +-
 pus/Service1TelecommandVerification.cpp       |  4 +--
 pus/Service2DeviceAccess.cpp                  |  6 ++--
 pus/Service3Housekeeping.cpp                  |  6 ++--
 pus/Service5EventReporting.cpp                |  4 +--
 pus/Service8FunctionManagement.cpp            |  6 ++--
 serialize/SerialBufferAdapter.cpp             |  4 +--
 serviceinterface/ServiceInterfaceBuffer.cpp   |  4 +--
 serviceinterface/ServiceInterfaceBuffer.h     |  4 +--
 serviceinterface/ServiceInterfaceStream.cpp   |  2 +-
 serviceinterface/ServiceInterfaceStream.h     |  4 +--
 storagemanager/ConstStorageAccessor.cpp       |  8 ++---
 storagemanager/LocalPool.cpp                  | 16 ++++-----
 storagemanager/PoolManager.cpp                |  2 +-
 storagemanager/StorageAccessor.cpp            | 10 +++---
 subsystem/SubsystemBase.cpp                   |  2 +-
 tasks/FixedSlotSequence.cpp                   | 12 +++----
 tcdistribution/CCSDSDistributor.cpp           |  8 ++---
 tcdistribution/PUSDistributor.cpp             | 12 +++----
 tcdistribution/TcDistributor.cpp              |  2 +-
 timemanager/Stopwatch.cpp                     |  4 +--
 tmtcpacket/pus/TcPacketBase.cpp               |  2 +-
 tmtcpacket/pus/TcPacketStored.cpp             |  6 ++--
 tmtcpacket/pus/TmPacketBase.cpp               |  4 +--
 tmtcpacket/pus/TmPacketStored.cpp             |  2 +-
 tmtcservices/CommandingServiceBase.cpp        |  4 +--
 tmtcservices/PusServiceBase.cpp               |  8 ++---
 tmtcservices/TmTcBridge.cpp                   | 30 ++++++++--------
 tmtcservices/VerificationReporter.cpp         | 12 +++----
 unittest/internal/InternalUnitTester.cpp      |  4 +--
 unittest/internal/UnittDefinitions.cpp        |  2 +-
 unittest/internal/osal/IntTestSemaphore.cpp   |  2 +-
 .../PollingSequenceFactory.cpp                |  2 +-
 .../user/unittest/core/CatchDefinitions.cpp   |  2 +-
 100 files changed, 356 insertions(+), 356 deletions(-)

diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 340bce37..769ce000 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -47,7 +47,7 @@ ReturnValue_t SharedRingBuffer::initialize() {
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
 	if(receiveSizesFIFO == nullptr) {
 		// Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
 				<< " was not configured to have sizes FIFO, returning nullptr!"
 				<< std::endl;
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index f9f7534d..017acafe 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -107,7 +107,7 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
 }
 
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
             << " implementation provided, returning nullptr!" << std::endl;
 #endif
diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp
index 19aa4e7b..13971929 100644
--- a/datalinklayer/Clcw.cpp
+++ b/datalinklayer/Clcw.cpp
@@ -55,7 +55,7 @@ void Clcw::setBitLock(bool bitLock) {
 }
 
 void Clcw::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Clcw::print: Clcw is: " << std::hex << getAsWhole() << std::dec << std::endl;
 #endif
 }
diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp
index 6a383851..1bdaa4f5 100644
--- a/datalinklayer/DataLinkLayer.cpp
+++ b/datalinklayer/DataLinkLayer.cpp
@@ -98,7 +98,7 @@ ReturnValue_t DataLinkLayer::processFrame(uint16_t length) {
 	receivedDataLength = length;
 	ReturnValue_t status = allFramesReception();
 	if (status != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::processFrame: frame reception failed. "
 		         "Error code: " << std::hex << status << std::dec << std::endl;
 #endif
@@ -126,7 +126,7 @@ ReturnValue_t DataLinkLayer::initialize() {
 	if ( virtualChannels.begin() != virtualChannels.end() ) {
 		clcw->setVirtualChannel( virtualChannels.begin()->second->getChannelId() );
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataLinkLayer::initialize: No VC assigned to this DLL instance! " << std::endl;
 #endif
 		return RETURN_FAILED;
diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp
index 0bf79f42..cdc9ae27 100644
--- a/datalinklayer/MapPacketExtraction.cpp
+++ b/datalinklayer/MapPacketExtraction.cpp
@@ -29,7 +29,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 			bufferPosition = &packetBuffer[packetLength];
 			status = RETURN_OK;
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 					<< packetLength << std::endl;
@@ -53,7 +53,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				}
 				status = RETURN_OK;
 			} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error
 						<< "MapPacketExtraction::extractPackets. Packet too large! Size: "
 						<< packetLength << std::endl;
@@ -62,7 +62,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 				status = CONTENT_TOO_LARGE;
 			}
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error
 					<< "MapPacketExtraction::extractPackets. Illegal segment! Last flag: "
 					<< (int) lastSegmentationFlag << std::endl;
@@ -72,7 +72,7 @@ ReturnValue_t MapPacketExtraction::extractPackets(TcTransferFrame* frame) {
 		}
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error
 				<< "MapPacketExtraction::extractPackets. Illegal segmentationFlag: "
 				<< (int) segmentationFlag << std::endl;
@@ -143,11 +143,11 @@ ReturnValue_t MapPacketExtraction::initialize() {
 }
 
 void MapPacketExtraction::printPacketBuffer(void) {
-#if CPP_OSTREAM_ENABLED == 1
+#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 CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "packet_buffer[" << std::dec << i << "]: 0x" << std::hex
 				<< (uint16_t) this->packetBuffer[i] << std::endl;
 #endif
diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp
index 0050994a..ee094dc3 100644
--- a/datalinklayer/TcTransferFrame.cpp
+++ b/datalinklayer/TcTransferFrame.cpp
@@ -87,7 +87,7 @@ uint8_t* TcTransferFrame::getFullDataField() {
 }
 
 void TcTransferFrame::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#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] << " ";
diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp
index 1ef772a2..de8f568f 100644
--- a/datalinklayer/TcTransferFrameLocal.cpp
+++ b/datalinklayer/TcTransferFrameLocal.cpp
@@ -37,7 +37,7 @@ TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uin
 			this->getFullFrame()[getFullSize()-2] = (crc & 0xFF00) >> 8;
 			this->getFullFrame()[getFullSize()-1] = (crc & 0x00FF);
 		} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << "TcTransferFrameLocal: dataSize too large: " << dataSize << std::endl;
 #endif
 		}
diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp
index 8ad65740..3a56fe1e 100644
--- a/datalinklayer/VirtualChannelReception.cpp
+++ b/datalinklayer/VirtualChannelReception.cpp
@@ -102,7 +102,7 @@ uint8_t VirtualChannelReception::getChannelId() const {
 ReturnValue_t VirtualChannelReception::initialize() {
 	ReturnValue_t returnValue = RETURN_FAILED;
 	if ((slidingWindowWidth > 254) || (slidingWindowWidth % 2 != 0)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VirtualChannelReception::initialize: Illegal sliding window width: "
 				<< (int) slidingWindowWidth << std::endl;
 #endif
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index f2c2b867..5fb1c3c7 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -13,21 +13,21 @@ PoolDataSetBase::~PoolDataSetBase() {}
 ReturnValue_t PoolDataSetBase::registerVariable(
 		PoolVariableIF *variable) {
 	if (state != States::STATE_SET_UNINITIALISED) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Call made in wrong position." << std::endl;
 #endif
 		return DataSetIF::DATA_SET_UNINITIALISED;
 	}
 	if (variable == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"Pool variable is nullptr." << std::endl;
 #endif
 		return DataSetIF::POOL_VAR_NULL;
 	}
 	if (fillCount >= maxFillCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::registerVariable: "
 				"DataSet is full." << std::endl;
 #endif
@@ -53,7 +53,7 @@ ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
 		unlockDataPool();
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DataSet::read(): "
 				"Call made in wrong position. Don't forget to commit"
 				" member datasets!" << std::endl;
@@ -146,7 +146,7 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 		} else if (registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if (result != COMMITING_WITHOUT_READING) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "DataSet::commit(): commit-without-read call made "
 						"with non write-only variable." << std::endl;
 #endif
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 369799c2..58375162 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -13,7 +13,7 @@ PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
 		std::memset(this->address, 0, this->getByteSize());
 	}
 	else if (initValue.size() != setLength){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "PoolEntry: setLength is not equal to initializer list"
 				"length! Performing zero initialization with given setLength"
 				<< std::endl;
@@ -70,12 +70,12 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "Pool Entry Validity: " <<
 			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
 #endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << std::dec << std::endl;
 #endif
 }
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index e94af167..7707fab8 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -89,7 +89,7 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
 #endif
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0eb6f5f5..24516aad 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -21,7 +21,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Invalid supplied owner!" << std::endl;
 #endif
@@ -30,7 +30,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                 << "Could not create mutex." << std::endl;
 #endif
@@ -43,7 +43,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ". Supplied "
                 << "queue invalid!" << std::dec << std::endl;
@@ -53,7 +53,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::initialize: "
                 << std::hex << "0x" << owner->getObjectId() << ": Could not "
                 << "set IPC store." <<std::dec << std::endl;
@@ -69,7 +69,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
                     << "Default HK destination object is invalid!" << std::endl;
 #endif
@@ -95,7 +95,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "HousekeepingManager: The map should only be initialized "
             << "once!" << std::endl;
 #endif
@@ -351,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
 #endif
@@ -383,7 +383,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
                 << " Invalid receiver!"<< std::endl;
 #endif
@@ -591,7 +591,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "HousekeepingManager::fechPoolEntry:"
                 << " Pool entry not found." << std::endl;
 #endif
@@ -614,7 +614,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
 #endif
@@ -698,7 +698,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
             sid, dataSet, true);
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalDataPoolManager::performHkOperation:"
                 << "0x" << std::hex << std::setfill('0') << std::setw(8)
                 << owner->getObjectId() << " Error generating "
@@ -748,7 +748,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found" << std::endl;
 #endif
@@ -776,7 +776,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateHousekeepingPacket: "
                 << "Could not get free element from IPC store." << std::endl;
 #endif
@@ -788,7 +788,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "HousekeepingManager::generateSetStructurePacket: "
                 << "Expected size is not equal to serialized size" << std::endl;
 #endif
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 37ae8152..0e98b90c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -375,7 +375,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
 #endif
@@ -384,7 +384,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HousekeepingManager::fetchPoolEntry:"
 				" Pool entry not found." << std::endl;
 #endif
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8e13b602..dbe34dfd 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -12,7 +12,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
     if(hkOwner == nullptr) {
         // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
 #endif
@@ -149,7 +149,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
         auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
                     " error!" << std::endl;
 #endif
@@ -210,7 +210,7 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
 #endif
@@ -262,7 +262,7 @@ sid_t LocalPoolDataSetBase::getSid() const {
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
         uint8_t position) const {
     if(position > 7) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Pool Raw Access: Bit setting invalid position"
                 << std::endl;
 #endif
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 5abef424..4b57dede 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -5,13 +5,13 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
         pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
 #endif
     }
     if(hkOwner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
                 << "owner is a invalid!" << std::endl;
 #endif
@@ -27,7 +27,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
         readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                 << "which is the NO_PARAMETER value!" << std::endl;
 #endif
@@ -35,7 +35,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
     HasLocalDataPoolIF* hkOwner =
             objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVariable: The supplied pool owner did not "
                 << "implement the correct interface"
                 << " HasLocalDataPoolIF!" << std::endl;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 38e9cf4b..aa5e5393 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,7 +33,7 @@ inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
@@ -43,7 +43,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
@@ -66,7 +66,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 #endif
@@ -75,7 +75,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index dc91fb9b..5c3b0ce0 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,7 +32,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout)
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
@@ -68,7 +68,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for commit() call." << std::endl;
 #endif
@@ -77,7 +77,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolVector: Read of local pool variable of object "
 				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
 				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
@@ -97,7 +97,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #endif
@@ -111,7 +111,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #endif
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index bf962c95..a059685b 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -14,7 +14,7 @@ public:
 		if(readObject != nullptr) {
 			readResult = readObject->read(mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
 #endif
diff --git a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
index 443b2bbb..b7f1fb3e 100644
--- a/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
+++ b/defaultcfg/fsfwconfig/pollingsequence/PollingSequenceFactory.cpp
@@ -15,7 +15,7 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
 #endif
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index da2b823d..1af6932a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,7 +39,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
 				<< std::setw(8) << std::setfill('0') << this->getObjectId()
 				<< std::dec << ": Do not pass nullptr as a cookie, consider "
@@ -132,7 +132,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: Communication interface "
 				"invalid." << std::endl;
 		sif::error << "Make sure it is set up properly and implements"
@@ -143,7 +143,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerBase::initialize: Initializing "
 	            "communication interface failed!" << std::endl;
 #endif
@@ -152,7 +152,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
 				"factory." << std::endl;
 #endif
@@ -164,7 +164,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
 					"ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
@@ -178,7 +178,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "DeviceHandlerBase::initialize: Power switcher "
 					<< "object ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
@@ -720,7 +720,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
 #endif
@@ -734,7 +734,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
 #endif
@@ -1291,7 +1291,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    //so we can track misconfigurations
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Busy" << std::dec
 					<< std::endl;
@@ -1320,7 +1320,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
 			//so we can track misconfigurations
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId()
 					<< ": DHB::buildInternalCommand: Command "
 					<< deviceCommandId << " isExecuting" << std::dec
diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp
index c7f87859..5f7ab89f 100644
--- a/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp
@@ -169,7 +169,7 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 	ReturnValue_t result = FailureIsolationBase::initialize();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
 				" initialize FailureIsolationBase." << std::endl;
 #endif
@@ -252,7 +252,7 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(
 
 	if (owner == nullptr) {
 	    // Configuration error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "DeviceHandlerFailureIsolation::"
 	            << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
 #endif
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 6742ff86..65e19d10 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -122,7 +122,7 @@ void EventManager::printEvent(EventMessage* message) {
 	case severity::INFO:
 #if DEBUG_INFO_EVENT == 1
 		string = translateObject(message->getReporter());
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "EVENT: ";
 		if (string != 0) {
 			sif::info << string;
@@ -133,12 +133,12 @@ void EventManager::printEvent(EventMessage* message) {
 				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
 				<< message->getParameter1() << " P2: 0x"
 				<< message->getParameter2() << std::dec << std::endl;
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* DEBUG_INFO_EVENT == 1 */
 		break;
 	default:
 		string = translateObject(message->getReporter());
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "EventManager: ";
 		if (string != 0) {
 			sif::debug << string;
diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp
index fed301b5..69cb0f01 100644
--- a/fdir/FailureIsolationBase.cpp
+++ b/fdir/FailureIsolationBase.cpp
@@ -21,7 +21,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 	EventManagerIF* manager = objectManager->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
 	if (manager == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FailureIsolationBase::initialize: Event Manager has not"
 				" been initialized!" << std::endl;
 #endif
@@ -38,7 +38,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		}
 		owner = objectManager->get<HasHealthIF>(ownerId);
 		if (owner == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Owner object "
 					"invalid. Make sure it implements HasHealthIF" << std::endl;
 #endif
@@ -49,11 +49,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
 				faultTreeParent);
 		if (parentIF == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Parent object"
 					<< "invalid." << std::endl;
 #endif
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure it implements ConfirmsFailuresIF."
 					<< std::endl;
 #endif
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c14cc7c6..d0b0a3bf 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -4,7 +4,7 @@
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		bool printInfo, size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	if(printInfo) {
 		sif::info << "Printing data with size " << size << ": ";
 	}
@@ -23,7 +23,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 
 void arrayprinter::printHex(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << std::hex;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << "0x" << static_cast<int>(data[i]);
@@ -42,7 +42,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 
 void arrayprinter::printDec(const uint8_t *data, size_t size,
 		size_t maxCharPerLine) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << std::dec;
 	for(size_t i = 0; i < size; i++) {
 		sif::info << static_cast<int>(data[i]);
@@ -58,7 +58,7 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::info << "\n" << std::flush;
     for(size_t i = 0; i < size; i++) {
         sif::info << "Byte " << i + 1 << ": 0b"<<
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index de795a6c..231d616e 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -41,7 +41,7 @@ ReturnValue_t HealthHelper::initialize() {
 	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
 
 	if (healthTable == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Health table object needs"
 	            "to be created in factory." << std::endl;
 #endif
@@ -49,7 +49,7 @@ ReturnValue_t HealthHelper::initialize() {
 	}
 
 	if(eventSender == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "HealthHelper::initialize: Owner has to implement "
 	            "ReportingProxyIF." << std::endl;
 #endif
@@ -83,7 +83,7 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
 			health, oldHealth);
 	if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::informParent: sending health reply failed."
 				<< std::endl;
 #endif
@@ -104,7 +104,7 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
 	}
 	if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
 	        owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "HealthHelper::handleHealthCommand: sending health "
 		        "reply failed." << std::endl;
 #endif
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index a2dc529d..48b6f851 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -32,7 +32,7 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 #if FSFW_ENHANCED_PRINTOUT == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	        sif::debug << "InternalErrorReporter::performOperation: Errors "
 	                << "occured!" << std::endl;
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp
index cdd4d943..e97778c3 100644
--- a/ipc/MessageQueueMessage.cpp
+++ b/ipc/MessageQueueMessage.cpp
@@ -15,7 +15,7 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size) :
 		this->messageSize = this->HEADER_SIZE + size;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "MessageQueueMessage: Passed size larger than maximum"
 				"allowed size! Setting content to 0" << std::endl;
 #endif
@@ -54,7 +54,7 @@ void MessageQueueMessage::setSender(MessageQueueId_t setId) {
 }
 
 void MessageQueueMessage::print(bool printWholeMessage) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "MessageQueueMessage content: " << std::endl;
 #endif
 	if(printWholeMessage) {
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index bd2f5187..befa69bc 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -12,13 +12,13 @@ public:
 		ReturnValue_t status = mutex->lockMutex(timeoutType,
 		        timeoutMs);
 		if(status == MutexIF::MUTEX_TIMEOUT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
 					<< timeoutMs << " milliseconds!" << std::endl;
 #endif
 		}
 		else if(status != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MutexHelper: Lock of Mutex failed with code "
 			        << status << std::endl;
 #endif
diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp
index 1d2a62a9..42ac2654 100644
--- a/memory/MemoryHelper.cpp
+++ b/memory/MemoryHelper.cpp
@@ -16,7 +16,7 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
 	lastSender = message->getSender();
 	lastCommand = message->getCommand();
 	if (busy) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "MemHelper: Busy!" << std::endl;
 #endif
 	}
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 44661e4c..2822743a 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -72,7 +72,7 @@ private:
 		if (timeStamper == nullptr) {
 			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
 			if ( timeStamper == nullptr ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "
 				        "Stamper not found!" << std::endl;
 #endif
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 251dbc70..69dd905b 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -1,7 +1,7 @@
 #include "ObjectManager.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
 #endif
 #include <cstdlib>
@@ -21,13 +21,13 @@ ObjectManager::~ObjectManager() {
 ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	auto returnPair = objectList.emplace(id, object);
 	if (returnPair.second) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    // sif::debug << "ObjectManager::insert: Object " << std::hex
 	    //            << (int)id << std::dec << " inserted." << std::endl;
 #endif
 		return this->RETURN_OK;
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
 		           << static_cast<uint32_t> id << std::dec
 				   << " is already in use!" << std::endl;
@@ -41,13 +41,13 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 ReturnValue_t ObjectManager::remove( object_id_t id ) {
 	if ( this->getSystemObject(id) != NULL ) {
 		this->objectList.erase( id );
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "ObjectManager::removeObject: Object " << std::hex
 		//           << (int)id << std::dec << " removed." << std::endl;
 #endif
 		return RETURN_OK;
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::removeObject: Requested object "
 		        << std::hex << (int)id << std::dec << " not found." << std::endl;
 #endif
@@ -72,7 +72,7 @@ ObjectManager::ObjectManager() : produceObjects(nullptr) {
 
 void ObjectManager::initialize() {
 	if(produceObjects == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
 #endif
@@ -84,7 +84,7 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->initialize();
 		if ( result != RETURN_OK ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			object_id_t var = it.first;
 			sif::error << "ObjectManager::initialize: Object 0x" << std::hex <<
 					std::setw(8) << std::setfill('0')<< var << " failed to "
@@ -95,7 +95,7 @@ void ObjectManager::initialize() {
 		}
 	}
 	if (errorCount > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed initializations." << std::endl;
 #endif
@@ -105,7 +105,7 @@ void ObjectManager::initialize() {
 	for (auto const& it : objectList) {
 		result = it.second->checkObjectConnections();
 		if ( result != RETURN_OK ) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectManager::ObjectManager: Object " << std::hex <<
 					(int) it.first  << " connection check failed with code 0x"
 					<< result << std::dec << std::endl;
@@ -114,7 +114,7 @@ void ObjectManager::initialize() {
 		}
 	}
 	if (errorCount > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
 		           << " failed connection checks." << std::endl;
 #endif
@@ -122,7 +122,7 @@ void ObjectManager::initialize() {
 }
 
 void ObjectManager::printList() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "ObjectManager: Object List contains:" << std::endl;
 	for (auto const& it : objectList) {
 		sif::debug << std::hex << it.first << " | " << it.second << std::endl;
diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index 16700625..8bebb609 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -86,7 +86,7 @@ extern ObjectManagerIF *objectManager;
 template <typename T>
 T* ObjectManagerIF::get( object_id_t id ) {
 	if(objectManager == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManagerIF: Global object manager has not "
 				"been initialized yet!" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index d9f4a3cb..7d609aee 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -8,7 +8,7 @@
 BinarySemaphoreUsingTask::BinarySemaphoreUsingTask() {
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Could not retrieve task handle. Please ensure the"
 				"constructor was called inside a task." << std::endl;
 #endif
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index 3915afe9..c0349b7c 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -5,7 +5,7 @@
 BinarySemaphore::BinarySemaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 #endif
 	}
@@ -20,7 +20,7 @@ BinarySemaphore::~BinarySemaphore() {
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Binary semaphore creation failure" << std::endl;
 #endif
     }
@@ -32,7 +32,7 @@ BinarySemaphore& BinarySemaphore::operator =(
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "Binary semaphore creation failure" << std::endl;
 #endif
         }
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index e66f044d..750ea9d6 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -9,7 +9,7 @@
 CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 		uint8_t initCount): maxCount(maxCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
@@ -18,7 +18,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 
 	handle = TaskManagement::getCurrentTaskHandle();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Could not retrieve task "
 				"handle. Please ensure the constructor was called inside a "
 				"task." << std::endl;
@@ -29,7 +29,7 @@ CountingSemaphoreUsingTask::CountingSemaphoreUsingTask(const uint8_t maxCount,
 	xTaskNotifyAndQuery(handle, 0, eSetValueWithOverwrite,
 			&oldNotificationValue);
 	if(oldNotificationValue != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "CountinSemaphoreUsingTask: Semaphore initiated but "
 				"current notification value is not 0. Please ensure the "
 				"notification value is not used for other purposes!" << std::endl;
diff --git a/osal/FreeRTOS/CountingSemaphore.cpp b/osal/FreeRTOS/CountingSemaphore.cpp
index 2521e52e..40884d27 100644
--- a/osal/FreeRTOS/CountingSemaphore.cpp
+++ b/osal/FreeRTOS/CountingSemaphore.cpp
@@ -10,7 +10,7 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
@@ -19,7 +19,7 @@ CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 
 	handle = xSemaphoreCreateCounting(maxCount, initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
@@ -29,7 +29,7 @@ CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
 		maxCount(other.maxCount), initCount(other.initCount) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
@@ -39,7 +39,7 @@ CountingSemaphore& CountingSemaphore::operator =(
 		CountingSemaphore&& other) {
 	handle = xSemaphoreCreateCounting(other.maxCount, other.initCount);
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphore: Creation failure" << std::endl;
 #endif
 	}
diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 6b289df7..aa7e6c59 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -37,7 +37,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -46,7 +46,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 #endif
@@ -73,7 +73,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index 27b9a769..c0c82cf1 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -10,7 +10,7 @@
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
 	handle = xQueueCreate(messageDepth, maxMessageSize);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	if (handle == nullptr) {
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Creation failed." << std::endl;
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 1722660c..0b85ca13 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -5,7 +5,7 @@
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
 	if(handle == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
 #endif
 	}
diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp
index 155f6ac7..3e830c7f 100644
--- a/osal/FreeRTOS/PeriodicTask.cpp
+++ b/osal/FreeRTOS/PeriodicTask.cpp
@@ -13,7 +13,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 	BaseType_t status = xTaskCreate(taskEntryPoint, name,
 			stackSize, this, setPriority, &handle);
 	if(status != pdPASS){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "PeriodicTask Insufficient heap memory remaining. "
 		        "Status: " << status << std::endl;
 #endif
@@ -43,7 +43,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->handle
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -103,7 +103,7 @@ ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 	            "it implement ExecutableObjectIF" << std::endl;
 #endif
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 4db46c69..df005f6a 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -32,7 +32,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
 		return new BinarySemaphoreUsingTask();
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 				"binary semaphore" << std::endl;
 #endif
@@ -49,7 +49,7 @@ SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount,
 		return new CountingSemaphoreUsingTask(maxCount, initCount);
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "SemaphoreFactory: Invalid argument, return regular"
 						"binary semaphore" << std::endl;
 #endif
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 7a763a60..2bc78785 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -14,7 +14,7 @@ MutexIF* Clock::timeMutex = NULL;
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getTicksPerSecond: not implemented yet" << std::endl;
 #endif
 	return 0;
@@ -25,7 +25,7 @@ uint32_t Clock::getTicksPerSecond(void){
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 	// do some magic with chrono
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::setClock: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -40,7 +40,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 #else
 
 #endif
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -66,7 +66,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 	time->tv_usec = timeUnix.tv_nsec / 1000.0;
 	return HasReturnvaluesIF::RETURN_OK;
 #else
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_FAILED;
@@ -76,7 +76,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 	// do some magic with chrono
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::gerClock_usecs: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -100,7 +100,7 @@ timeval Clock::getUptime() {
 		timeval.tv_usec = uptimeSeconds *(double) 1e6 - (timeval.tv_sec *1e6);
 	}
 #else
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
 #endif
 #endif
@@ -138,7 +138,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 	auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
 	time->usecond = usecond.count();
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::warning << "Clock::getDateAndTime: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
@@ -162,7 +162,7 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
 	to->tv_usec = from->usecond;
 	//Fails in 2038..
 	return HasReturnvaluesIF::RETURN_OK;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << "Clock::convertTimeBla: not implemented yet" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/host/FixedTimeslotTask.cpp b/osal/host/FixedTimeslotTask.cpp
index 1fd3cd7f..272d99b9 100644
--- a/osal/host/FixedTimeslotTask.cpp
+++ b/osal/host/FixedTimeslotTask.cpp
@@ -35,7 +35,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -44,7 +44,7 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -74,7 +74,7 @@ void FixedTimeslotTask::taskEntryPoint(void* argument) {
     }
 
     this->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "FixedTimeslotTask::taskEntryPoint: "
             "Returned from taskFunctionality." << std::endl;
 #endif
@@ -140,7 +140,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         return HasReturnvaluesIF::RETURN_OK;
     }
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "Component " << std::hex << componentId <<
             " not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/host/MessageQueue.cpp b/osal/host/MessageQueue.cpp
index 0c048120..dfc045e8 100644
--- a/osal/host/MessageQueue.cpp
+++ b/osal/host/MessageQueue.cpp
@@ -10,7 +10,7 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	queueLock = MutexFactory::instance()->createMutex();
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue:"
 		        << " Could not be created" << std::endl;
 #endif
@@ -139,7 +139,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			targetQueue->messageQueue.push(*mqmMessage);
 		}
 		else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessageFromMessageQueue: Message"
 					"is not MessageQueueMessage!" << std::endl;
 #endif
diff --git a/osal/host/PeriodicTask.cpp b/osal/host/PeriodicTask.cpp
index 09acd2cb..1f427546 100644
--- a/osal/host/PeriodicTask.cpp
+++ b/osal/host/PeriodicTask.cpp
@@ -33,7 +33,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             ABOVE_NORMAL_PRIORITY_CLASS);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -42,7 +42,7 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
             reinterpret_cast<HANDLE>(mainThread.native_handle()),
             THREAD_PRIORITY_NORMAL);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
                 << GetLastError() << std::endl;
 #endif
@@ -73,7 +73,7 @@ void PeriodicTask::taskEntryPoint(void* argument) {
 	}
 
 	this->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "PeriodicTask::taskEntryPoint: "
 			"Returned from taskFunctionality." << std::endl;
 #endif
diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp
index 620f8add..7ffd4758 100644
--- a/osal/host/QueueMapManager.cpp
+++ b/osal/host/QueueMapManager.cpp
@@ -26,7 +26,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 	auto returnPair = queueMap.emplace(currentId, queueToInsert);
 	if(not returnPair.second) {
 		// this should never happen for the atomic variable.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "QueueMapManager: This ID is already inside the map!"
 				<< std::endl;
 #endif
@@ -46,7 +46,7 @@ MessageQueueIF* QueueMapManager::getMessageQueue(
 		return queueIter->second;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "QueueMapManager::getQueueHandle: The ID " <<
 				messageQueueId << " does not exists in the map" << std::endl;
 #endif
diff --git a/osal/host/SemaphoreFactory.cpp b/osal/host/SemaphoreFactory.cpp
index 840dacef..3d3fe17f 100644
--- a/osal/host/SemaphoreFactory.cpp
+++ b/osal/host/SemaphoreFactory.cpp
@@ -21,7 +21,7 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Binary Semaphore not implemented yet."
 			" Returning nullptr!\n" << std::flush;
 #endif
@@ -31,7 +31,7 @@ SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t arguments) {
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(const uint8_t maxCount,
 		uint8_t initCount, uint32_t arguments) {
 	// Just gonna wait for full C++20 for now.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "SemaphoreFactory: Counting Semaphore not implemented yet."
 				" Returning nullptr!\n" << std::flush;
 #endif
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 22d35e3a..0a6bb29f 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -43,7 +43,7 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 	    result = sem_timedwait(&handle, &timeOut);
 	    if(result != 0 and errno == EINVAL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
 	    			<< std::endl;
 #endif
@@ -64,7 +64,7 @@ ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
 		return SemaphoreIF::SEMAPHORE_INVALID;
 	case(EINTR):
 		// Call was interrupted by signal handler
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
 				"Code " << strerror(errno) << std::endl;
 #endif
@@ -130,7 +130,7 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 			// Value exceeds SEM_VALUE_MAX
 		case(ENOSYS):
 		// System does not support process-shared semaphores
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
 				<< std::endl;
 #endif
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index e4e7df86..54dad839 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -69,7 +69,7 @@ timeval Clock::getUptime() {
 	timeval uptime;
 	auto result = getUptime(&uptime);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
 #endif
 	}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 22cb1615..0bb71831 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -4,7 +4,7 @@
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
 	if(initCount > maxCount) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
 				"intial cout. Setting initial count to max count." << std::endl;
 #endif
diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp
index 0635b560..a545eeb7 100644
--- a/osal/linux/FixedTimeslotTask.cpp
+++ b/osal/linux/FixedTimeslotTask.cpp
@@ -47,7 +47,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::dec << std::endl;
 #endif
@@ -93,7 +93,7 @@ void FixedTimeslotTask::taskFunctionality() {
 void FixedTimeslotTask::missedDeadlineCounter() {
 	FixedTimeslotTask::deadlineMissedCount++;
 	if (FixedTimeslotTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << FixedTimeslotTask::deadlineMissedCount
 				   << " deadlines." << std::endl;
 #endif
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index 28dfb9c7..e7b09b4f 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -42,14 +42,14 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 MessageQueue::~MessageQueue() {
 	int status = mq_close(this->id);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
 				   << strerror(errno) <<std::endl;
 #endif
 	}
 	status = mq_unlink(name);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
 				   << strerror(errno) << std::endl;
 #endif
@@ -60,7 +60,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		uint32_t messageDepth) {
 	switch(errno) {
 	case(EINVAL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
 				" for message size" << std::endl;
 #endif
@@ -84,7 +84,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
 			Apply changes with: sudo sysctl -p
 			*/
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::MessageQueue: Default MQ size "
 					<< defaultMqMaxMsg << " is too small for requested size "
 					<< messageDepth << std::endl;
@@ -102,7 +102,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		//We unlink the other queue
 		int status = mq_unlink(name);
 		if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "mq_unlink Failed with status: " << strerror(errno)
 													<< std::endl;
 #endif
@@ -123,7 +123,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 
 	default:
 		// Failed either the first time or the second time
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 		<< name << std::dec << " failed with status: "
 		<< strerror(errno) << std::endl;
@@ -162,7 +162,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message,
 
 ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(message == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message is "
 				"nullptr!" << std::endl;
 #endif
@@ -170,7 +170,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	}
 
 	if(message->getMaximumMessageSize() < maxMessageSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::receiveMessage: Message size "
 				<< message->getMaximumMessageSize()
 				<< " too small to receive data!" << std::endl;
@@ -202,7 +202,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			return MessageQueueIF::EMPTY;
 		case EBADF:
 			//mqdes doesn't represent a valid queue open for reading.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
 #endif
@@ -217,7 +217,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
 			 *   been set in the queue's mq_flags.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 					   << strerror(errno)  << std::endl;
 #endif
@@ -232,7 +232,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 			 *   given msg_len is too short for the message that would have
 			 *   been received.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::receive: configuration error "
 			           << strerror(errno)  << std::endl;
 #endif
@@ -258,7 +258,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
 #endif
@@ -276,7 +276,7 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
 		switch(errno){
 		case EBADF:
 			//mqdes doesn't represent a valid message queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::flush configuration error, "
 					"called flush with an invalid queue ID" << std::endl;
 #endif
@@ -331,7 +331,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		MessageQueueMessageIF *message, MessageQueueId_t sentFrom,
 		bool ignoreFault) {
 	if(message == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
 				"nullptr!" << std::endl;
 #endif
@@ -362,7 +362,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EBADF: {
 			//mq_des doesn't represent a valid message queue descriptor,
 			//or mq_des wasn't opened for writing.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
 					<< " destination invalid."  << std::endl;
 			sif::error << strerror(errno) << " in "
@@ -383,7 +383,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			 * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
 			 *   msg_prio is greater than the priority of the calling process.
 			 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Configuration error "
 			           << strerror(errno) << " in mq_send" << std::endl;
 #endif
@@ -391,7 +391,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		case EMSGSIZE:
 			// The msg_len is greater than the msgsize associated with
 			//the specified queue.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "MessageQueue::sendMessage: Size error [" <<
 					strerror(errno) << "] in mq_send" << std::endl;
 #endif
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index e2012634..c642b132 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -12,20 +12,20 @@ Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
 #endif
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
 				<< std::endl;
 #endif
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 #endif
@@ -35,7 +35,7 @@ Mutex::Mutex() {
 	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
 #endif
 	}
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index 1c69124d..a8f2de60 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 				<< " it implements ExecutableObjectIF!" << std::endl;
 #endif
@@ -44,7 +44,7 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << stackSize << std::endl;
 #endif
 	PosixThread::createTask(&taskEntryPoint,this);
@@ -71,13 +71,13 @@ void PeriodicPosixTask::taskFunctionality(void) {
 			char name[20] = {0};
 			int status = pthread_getname_np(pthread_self(), name, sizeof(name));
 			if(status == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask " << name << ": Deadline "
 						"missed." << std::endl;
 #endif
 			}
 			else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PeriodicPosixTask X: Deadline missed. " <<
 						status << std::endl;
 #endif
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 80bf52c2..a0e540cf 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -48,7 +48,7 @@ void PosixThread::suspend() {
 	sigaddset(&waitSignal, SIGUSR1);
 	sigwait(&waitSignal, &caughtSig);
 	if (caughtSig != SIGUSR1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
 				caughtSig << std::endl;
 #endif
@@ -120,7 +120,7 @@ uint64_t PosixThread::getCurrentMonotonicTimeMs(){
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::debug << "PosixThread::createTask" << std::endl;
 #endif
 	/*
@@ -133,7 +133,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	pthread_attr_t attributes;
 	int status = pthread_attr_init(&attributes);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute init failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -141,19 +141,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	void* stackPointer;
 	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: Stack init failed with: " <<
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
 			uint64_t stackMb = stackSize/10e6;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 #endif
 		}
 		else if(errno == EINVAL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
 #endif
@@ -163,7 +163,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: pthread_attr_setstack "
 				" failed with: " << strerror(status) <<  std::endl;
 		sif::error << "Make sure the specified stack size is valid and is "
@@ -173,7 +173,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
 					strerror(status) << std::endl;
 #endif
@@ -182,7 +182,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	// TODO FIFO -> This needs root privileges for the process
 	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule policy failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -192,7 +192,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	scheduleParams.__sched_priority = priority;
 	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute schedule params failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -204,7 +204,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 	sigaddset(&waitSignal, SIGUSR1);
 	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread sigmask failed failed with: " <<
 				strerror(status) << " errno: " << strerror(errno) << std::endl;
 #endif
@@ -213,7 +213,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_create(&thread,&attributes,fnc_,arg_);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread create failed with: " <<
 				strerror(status) << std::endl;
 #endif
@@ -221,19 +221,19 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_setname_np(thread,name);
 	if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PosixThread::createTask: setname failed with: " <<
 				strerror(status) << std::endl;
 #endif
 		if(status == ERANGE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Task name length longer"
 					" than 16 chars. Truncating.." << std::endl;
 #endif
 			name[15] = '\0';
 			status = pthread_setname_np(thread,name);
 			if(status != 0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "PosixThread::createTask: Setting name"
 						" did not work.." << std::endl;
 #endif
@@ -243,7 +243,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 
 	status = pthread_attr_destroy(&attributes);
 	if(status!=0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Posix Thread attribute destroy failed with: " <<
 				strerror(status) << std::endl;
 #endif
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index 9cbb1d02..a8387e87 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -39,7 +39,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 				reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
 		if(bytesReceived < 0) {
 			// handle error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcSocketPollingTask::performOperation: Reception"
 					"error." << std::endl;
 #endif
@@ -47,7 +47,7 @@ ReturnValue_t TcUnixUdpPollingTask::performOperation(uint8_t opCode) {
 
 			continue;
 		}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //		sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
 //				<< " bytes received" << std::endl;
 #endif
@@ -69,7 +69,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
@@ -81,7 +81,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
 #endif
@@ -93,7 +93,7 @@ ReturnValue_t TcUnixUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcUnixUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
 #endif
@@ -102,7 +102,7 @@ ReturnValue_t TcUnixUdpPollingTask::initialize() {
 
 	tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
 #endif
@@ -127,7 +127,7 @@ void TcUnixUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			&tval, sizeof(receptionTimeout));
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 #endif
@@ -140,14 +140,14 @@ void TcUnixUdpPollingTask::handleReadError() {
 	case(EAGAIN): {
 		// todo: When working in timeout mode, this will occur more often
 		// and is not an error.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: Timeout."
 				<< std::endl;
 #endif
 		break;
 	}
 	default: {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcUnixUdpPollingTask::handleReadError: "
 				<< strerror(errno) << std::endl;
 #endif
diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp
index 0142025e..fe0fbebb 100644
--- a/osal/linux/Timer.cpp
+++ b/osal/linux/Timer.cpp
@@ -10,7 +10,7 @@ Timer::Timer() {
 	sigEvent.sigev_value.sival_ptr = &timerId;
 	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
 	if(status!=0){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Timer creation failed with: " << status <<
 				" errno: " << errno << std::endl;
 #endif
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 769e8aff..1d318d3b 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -26,7 +26,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 	//clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	if(serverSocket < 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
 				" UDP socket!" << std::endl;
 #endif
@@ -53,7 +53,7 @@ TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
 			reinterpret_cast<struct sockaddr*>(&serverAddress),
 			serverAddressLen);
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
 				"local port " << setServerPort << " to server socket!"
 				<< std::endl;
@@ -78,7 +78,7 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	}
 
 //	char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //					&clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
@@ -86,13 +86,13 @@ ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
 	ssize_t bytesSent = sendto(serverSocket, data, dataLen, flags,
 			reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
 	if(bytesSent < 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed."
 				<< std::endl;
 #endif
 		handleSendError();
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //			" sent." << std::endl;
 #endif
@@ -103,7 +103,7 @@ void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in& newAddress) {
 	MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //	char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //			&newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 //	sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
@@ -129,13 +129,13 @@ void TmTcUnixUdpBridge::handleSocketError() {
 	case(ENOBUFS):
 	case(ENOMEM):
 	case(EPROTONOSUPPORT):
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 #endif
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSocketError: Unknown error"
 				<< std::endl;
 #endif
@@ -151,7 +151,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 		 Ephermeral ports can be shown with following command:
 		 sysctl -A | grep ip_local_port_range
 		 */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Port access issue."
 				"Ports 1-1024 are reserved on UNIX systems and require root "
 				"rights while ephermeral ports should not be used as well."
@@ -171,14 +171,14 @@ void TmTcUnixUdpBridge::handleBindError() {
 	case(ENOMEM):
 	case(ENOTDIR):
 	case(EROFS): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Socket creation failed"
 				<< " with " << strerror(errno) << std::endl;
 #endif
 		break;
 	}
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleBindError: Unknown error"
 				<< std::endl;
 #endif
@@ -189,7 +189,7 @@ void TmTcUnixUdpBridge::handleBindError() {
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
 #endif
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index eff8a0fb..bfaf3569 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,7 +9,7 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index a315681b..b111f724 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,7 +30,7 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 #endif
@@ -65,7 +65,7 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
 #endif
 			if (this->deadlineMissedFunc != nullptr) {
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 5278a076..71c5782f 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,7 +10,7 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
 #endif
@@ -20,7 +20,7 @@ Mutex::Mutex() :
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
 #endif
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index 591ba743..0ebf63e2 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,7 +35,7 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
 #endif
@@ -44,7 +44,7 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
 #endif
@@ -55,7 +55,7 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
 #endif
@@ -81,7 +81,7 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
 #endif
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 7e3bd57a..6abfcca8 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,7 +22,7 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
diff --git a/osal/windows/TcWinUdpPollingTask.cpp b/osal/windows/TcWinUdpPollingTask.cpp
index e5931609..4fd88c93 100644
--- a/osal/windows/TcWinUdpPollingTask.cpp
+++ b/osal/windows/TcWinUdpPollingTask.cpp
@@ -43,14 +43,14 @@ ReturnValue_t TcWinUdpPollingTask::performOperation(uint8_t opCode) {
 				&senderAddressSize);
 		if(bytesReceived == SOCKET_ERROR) {
 			// handle error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcWinUdpPollingTask::performOperation: Reception"
 					" error." << std::endl;
 #endif
 			handleReadError();
 			continue;
 		}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::debug << "TcWinUdpPollingTask::performOperation: " << bytesReceived
 		//		<< " bytes received" << std::endl;
 #endif
@@ -72,7 +72,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 			receptionBuffer.data(), bytesRead);
 	// arrayprinter::print(receptionBuffer.data(), bytesRead);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::transferPusToSoftwareBus: Data "
 				"storage failed" << std::endl;
 		sif::error << "Packet size: " << bytesRead << std::endl;
@@ -84,7 +84,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
 	result  = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Serial Polling: Sending message to queue failed"
 				<< std::endl;
 #endif
@@ -96,7 +96,7 @@ ReturnValue_t TcWinUdpPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t TcWinUdpPollingTask::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSerialPollingTask::initialize: TC Store uninitialized!"
 				<< std::endl;
 #endif
@@ -105,7 +105,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 
 	tmtcBridge = objectManager->get<TmTcWinUdpBridge>(tmtcBridgeId);
 	if(tmtcBridge == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
 				" TMTC bridge object!" << std::endl;
 #endif
@@ -113,7 +113,7 @@ ReturnValue_t TcWinUdpPollingTask::initialize() {
 	}
 
 	serverUdpSocket = tmtcBridge->serverSocket;
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TcWinUdpPollingTask::initialize: Server UDP socket "
 	//        << serverUdpSocket << std::endl;
 #endif
@@ -133,7 +133,7 @@ void TcWinUdpPollingTask::setTimeout(double timeoutSeconds) {
 	int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
 			reinterpret_cast<const char*>(&timeoutMs), sizeof(DWORD));
 	if(result == -1) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TcWinUdpPollingTask::TcSocketPollingTask: Setting "
 				"receive timeout failed with " << strerror(errno) << std::endl;
 #endif
@@ -144,28 +144,28 @@ void TcWinUdpPollingTask::handleReadError() {
     int error = WSAGetLastError();
     switch(error) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEFAULT): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSADEFAULT: "
                 << "Bad address " << std::endl;
 #endif
         break;
     }
     case(WSAEINVAL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: WSAEINVAL: "
                 << "Invalid input parameters. " << std::endl;
 #endif
         break;
     }
     default: {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TcWinUdpPollingTask::handleReadError: Error code: "
                 << error << std::endl;
 #endif
diff --git a/osal/windows/TmTcWinUdpBridge.cpp b/osal/windows/TmTcWinUdpBridge.cpp
index b9945168..69a48f3e 100644
--- a/osal/windows/TmTcWinUdpBridge.cpp
+++ b/osal/windows/TmTcWinUdpBridge.cpp
@@ -15,7 +15,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     if (err != 0) {
         /* Tell the user that we could not find a usable */
         /* Winsock DLL.                                  */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge:"
                 "WSAStartup failed with error: " << err << std::endl;
 #endif
@@ -36,7 +36,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
     //clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
     serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     if(serverSocket == INVALID_SOCKET) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not open"
                 " UDP socket!" << std::endl;
 #endif
@@ -63,7 +63,7 @@ TmTcWinUdpBridge::TmTcWinUdpBridge(object_id_t objectId,
             reinterpret_cast<struct sockaddr*>(&serverAddress),
             serverAddressLen);
     if(result != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::TmTcWinUdpBridge: Could not bind "
                 "local port " << setServerPort << " to server socket!"
                 << std::endl;
@@ -83,7 +83,7 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
     //clientAddressLen = sizeof(serverAddress);
 
 //  char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //                  &clientAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 #endif
@@ -92,13 +92,13 @@ ReturnValue_t TmTcWinUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
             reinterpret_cast<const char*>(data), dataLen, flags,
             reinterpret_cast<sockaddr*>(&clientAddress), clientAddressLen);
     if(bytesSent == SOCKET_ERROR) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TmTcWinUdpBridge::sendTm: Send operation failed."
                 << std::endl;
 #endif
         handleSendError();
     }
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "TmTcUnixUdpBridge::sendTm: " << bytesSent << " bytes were"
 //          " sent." << std::endl;
 #endif
@@ -109,7 +109,7 @@ void TmTcWinUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
     MutexHelper lock(mutex, MutexIF::TimeoutType::WAITING, 10);
 
 //  char ipAddress [15];
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //  sif::debug << "IP Address Sender: "<< inet_ntop(AF_INET,
 //          &newAddress.sin_addr.s_addr, ipAddress, 15) << std::endl;
 //  sif::debug << "IP Address Old: " <<  inet_ntop(AF_INET,
@@ -128,7 +128,7 @@ void TmTcWinUdpBridge::handleSocketError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
 #endif
@@ -139,7 +139,7 @@ void TmTcWinUdpBridge::handleSocketError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
          */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSocketError: Error code: "
                 << errCode << std::endl;
 #endif
@@ -152,14 +152,14 @@ void TmTcWinUdpBridge::handleBindError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call " << "necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEADDRINUSE): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     	sif::warning << "TmTcWinUdpBridge::handleBindError: WSAEADDRINUSE: "
     			<< "Port is already in use!" << std::endl;
 #endif
@@ -170,7 +170,7 @@ void TmTcWinUdpBridge::handleBindError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleBindError: Error code: "
                 << errCode << std::endl;
 #endif
@@ -183,14 +183,14 @@ void TmTcWinUdpBridge::handleSendError() {
     int errCode = WSAGetLastError();
     switch(errCode) {
     case(WSANOTINITIALISED): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSANOTINITIALISED: "
                 << "WSAStartup(...) call necessary" << std::endl;
 #endif
         break;
     }
     case(WSAEADDRNOTAVAIL): {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: WSAEADDRNOTAVAIL: "
                 << "Check target address. " << std::endl;
 #endif
@@ -201,7 +201,7 @@ void TmTcWinUdpBridge::handleSendError() {
         https://docs.microsoft.com/en-us/windows/win32/winsock/
         windows-sockets-error-codes-2
         */
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "TmTcWinUdpBridge::handleSendError: Error code: "
                 << errCode << std::endl;
 #endif
diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp
index 5014e44c..4ad5cdf2 100644
--- a/parameters/ParameterHelper.cpp
+++ b/parameters/ParameterHelper.cpp
@@ -48,7 +48,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
         ConstStorageAccessor accessor(storeId);
         result = storage->getData(storeId, accessor);
         if (result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "ParameterHelper::handleParameterMessage: Getting"
                     << " store data failed for load command." << std::endl;
 #endif
diff --git a/pus/CService201HealthCommanding.cpp b/pus/CService201HealthCommanding.cpp
index f2c579d5..ca761f14 100644
--- a/pus/CService201HealthCommanding.cpp
+++ b/pus/CService201HealthCommanding.cpp
@@ -22,7 +22,7 @@ ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice)
 	case(Subservice::COMMAND_ANNOUNCE_HEALTH_ALL):
 		return RETURN_OK;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
 #endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp
index 9194ab24..9e86c752 100644
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@@ -51,7 +51,7 @@ ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
 		result = generateSuccessReport(message);
 	}
 	if(result != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service1TelecommandVerification::sendVerificationReport: "
 		        "Sending verification packet failed !" << std::endl;
 #endif
@@ -90,7 +90,7 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
 	AcceptsTelemetryIF* funnel = objectManager->
 			get<AcceptsTelemetryIF>(targetDestination);
 	if(funnel == nullptr){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "Service1TelecommandVerification::initialize: Specified"
 	            " TM funnel invalid. Make sure it is set up and implements"
 	            " AcceptsTelemetryIF." << std::endl;
diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp
index f79c0a79..72db82df 100644
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@@ -25,7 +25,7 @@ ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
 	case Subservice::COMMAND_TOGGLE_WIRETAPPING:
 		return HasReturnvaluesIF::RETURN_OK;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Invalid Subservice" << std::endl;
 #endif
 		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@@ -127,7 +127,7 @@ void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
 				static_cast<uint8_t>(Subservice::REPLY_RAW));
 		break;
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Unknown message in Service2DeviceAccess::"
 				"handleUnrequestedReply with command ID " <<
 				reply->getCommand() << std::endl;
@@ -147,7 +147,7 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
 	size_t size = 0;
 	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
 	if(result != HasReturnvaluesIF::RETURN_OK){
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
 		        "handleUnrequestedReply with failure ID "<< result
 		        << std::endl;
diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp
index d52ab50d..ba7ff6ee 100644
--- a/pus/Service3Housekeeping.cpp
+++ b/pus/Service3Housekeeping.cpp
@@ -222,7 +222,7 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
 	}
 
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleReply: Invalid reply with "
 				<< "reply command " << command << "!" << std::endl;
 #endif
@@ -251,7 +251,7 @@ void Service3Housekeeping::handleUnrequestedReply(
 	}
 
 	default:
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid "
 		        << "reply with " << "reply command " << command << "!"
 		        << std::endl;
@@ -261,7 +261,7 @@ void Service3Housekeeping::handleUnrequestedReply(
 
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		// Configuration error
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service3Housekeeping::handleUnrequestedReply:"
 				<< "Could not generate reply!" << std::endl;
 #endif
diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp
index 21bf2780..29eb7f20 100644
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@@ -37,7 +37,7 @@ ReturnValue_t Service5EventReporting::performService() {
 	       }
 	    }
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug <<  "Service5EventReporting::generateEventReport:"
 	        " Too many events" << std::endl;
 #endif
@@ -55,7 +55,7 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	ReturnValue_t result = tmPacket.sendPacket(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "Service5EventReporting::generateEventReport:"
 		        " Could not send TM packet" << std::endl;
 #endif
diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp
index df25dd85..49fa6ebe 100644
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@@ -60,7 +60,7 @@ ReturnValue_t Service8FunctionManagement::prepareCommand(
 ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
 		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
     if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
                 << " TC size smaller thant minimum size of direct command."
                 << std::endl;
@@ -127,7 +127,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
     const uint8_t * buffer = nullptr;
     ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
     if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Service 8: Could not retrieve data for data reply"
                 << std::endl;
 #endif
@@ -139,7 +139,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(
 
     auto deletionResult = IPCStore->deleteData(storeId);
     if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "Service8FunctionManagement::handleReply: Deletion"
                 << " of data in pool failed." << std::endl;
 #endif
diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp
index 303de742..53b8c3d5 100644
--- a/serialize/SerialBufferAdapter.cpp
+++ b/serialize/SerialBufferAdapter.cpp
@@ -95,7 +95,7 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(buffer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Wrong access function for stored type !"
 				 " Use getConstBuffer()." << std::endl;
 #endif
@@ -107,7 +107,7 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "SerialBufferAdapter::getConstBuffer:"
 				" Buffers are unitialized!" << std::endl;
 #endif
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index abe296cb..20ea61dd 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,6 @@
 #include "ServiceInterfaceBuffer.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include "../timemanager/Clock.h"
 
@@ -256,4 +256,4 @@ void ServiceInterfaceBuffer::initSocket() {
 
 #endif //ML505
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index d13143cd..b1a50848 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -4,7 +4,7 @@
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include <FSFWConfig.h>
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include <iostream>
 #include <sstream>
@@ -150,6 +150,6 @@ private:
 };
 #endif //ML505
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c618d989..59526536 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,6 +1,6 @@
 #include "ServiceInterfaceStream.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index ddeded80..c18c6c2e 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,7 +3,7 @@
 
 #include "ServiceInterfaceBuffer.h"
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 
 #include <iostream>
 #include <cstdio>
@@ -51,6 +51,6 @@ extern ServiceInterfaceStream warning;
 extern ServiceInterfaceStream error;
 }
 
-#endif /* CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 0beef64f..39530ac9 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -46,7 +46,7 @@ const uint8_t* ConstStorageAccessor::data() const {
 
 size_t ConstStorageAccessor::size() const {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 	}
@@ -56,13 +56,13 @@ size_t ConstStorageAccessor::size() const {
 ReturnValue_t ConstStorageAccessor::getDataCopy(uint8_t *pointer,
 		size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large enough"
 				<< std::endl;
 #endif
@@ -82,7 +82,7 @@ store_address_t ConstStorageAccessor::getId() const {
 
 void ConstStorageAccessor::print() const {
 	if(internalState == AccessState::UNINIT or constDataPointer == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return;
diff --git a/storagemanager/LocalPool.cpp b/storagemanager/LocalPool.cpp
index b2d5ffc4..cc7c9266 100644
--- a/storagemanager/LocalPool.cpp
+++ b/storagemanager/LocalPool.cpp
@@ -8,7 +8,7 @@ LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
 		NUMBER_OF_POOLS(poolConfig.size()),
 		spillsToHigherPools(spillsToHigherPools) {
 	if(NUMBER_OF_POOLS == 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPool::LocalPool: Passed pool configuration is "
 				<< " invalid!" << std::endl;
 #endif
@@ -120,7 +120,7 @@ ReturnValue_t LocalPool::modifyData(store_address_t storeId,
 
 ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::debug << "Delete: Pool: " << std::dec << storeId.poolIndex
               << " Index: " << storeId.packetIndex << std::endl;
 #endif
@@ -138,7 +138,7 @@ ReturnValue_t LocalPool::deleteData(store_address_t storeId) {
     }
     else {
         //pool_index or packet_index is too large
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool::deleteData: Illegal store ID, no deletion!"
         		<< std::endl;
 #endif
@@ -164,7 +164,7 @@ ReturnValue_t LocalPool::deleteData(uint8_t *ptr, size_t size,
             result = deleteData(localId);
 #if FSFW_VERBOSE_PRINTOUT == 2
             if (deltaAddress % elementSizes[n] != 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
                 sif::error << "LocalPool::deleteData: Address not aligned!"
                         << std::endl;
 #endif
@@ -194,7 +194,7 @@ ReturnValue_t LocalPool::initialize() {
     //Check if any pool size is large than the maximum allowed.
     for (uint8_t count = 0; count < NUMBER_OF_POOLS; count++) {
         if (elementSizes[count] >= STORAGE_FREE) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "LocalPool::initialize: Pool is too large! "
                     "Max. allowed size is: " << (STORAGE_FREE - 1) << std::endl;
 #endif
@@ -219,7 +219,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
         store_address_t *storeId, bool ignoreFault) {
     ReturnValue_t status = getPoolIndex(size, &storeId->poolIndex);
     if (status != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPool( " << std::hex << getObjectId() << std::dec
                 << " )::reserveSpace: Packet too large." << std::endl;
 #endif
@@ -236,7 +236,7 @@ ReturnValue_t LocalPool::reserveSpace(const size_t size,
     }
     if (status == RETURN_OK) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "Reserve: Pool: " << std::dec
                 << storeId->poolIndex << " Index: " << storeId->packetIndex
                 << std::endl;
@@ -280,7 +280,7 @@ ReturnValue_t LocalPool::getPoolIndex(size_t packetSize, uint16_t *poolIndex,
         uint16_t startAtIndex) {
     for (uint16_t n = startAtIndex; n < NUMBER_OF_POOLS; n++) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "LocalPool " << getObjectId() << "::getPoolIndex: Pool: "
              << n << ", Element Size: " << elementSizes[n] << std::endl;
 #endif
diff --git a/storagemanager/PoolManager.cpp b/storagemanager/PoolManager.cpp
index 7612fbc0..4e8014fd 100644
--- a/storagemanager/PoolManager.cpp
+++ b/storagemanager/PoolManager.cpp
@@ -26,7 +26,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size,
 ReturnValue_t PoolManager::deleteData(
         store_address_t storeId) {
 #if FSFW_VERBOSE_PRINTOUT == 2
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::debug << "PoolManager( " << translateObject(getObjectId()) <<
            " )::deleteData from store " << storeId.poolIndex <<
            ". id is "<< storeId.packetIndex << std::endl;
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index 373407b0..fec5d75e 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -26,13 +26,13 @@ StorageAccessor::StorageAccessor(StorageAccessor&& other):
 
 ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(size_ > maxSize) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Supplied buffer not large "
 				"enough" << std::endl;
 #endif
@@ -44,7 +44,7 @@ ReturnValue_t StorageAccessor::getDataCopy(uint8_t *pointer, size_t maxSize) {
 
 uint8_t* StorageAccessor::data() {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 	}
@@ -54,13 +54,13 @@ uint8_t* StorageAccessor::data() {
 ReturnValue_t StorageAccessor::write(uint8_t *data, size_t size,
 		uint16_t offset) {
 	if(internalState == AccessState::UNINIT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "StorageAccessor: Not initialized!" << std::endl;
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(offset + size > size_) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "StorageAccessor: Data too large for pool "
 				"entry!" << std::endl;
 #endif
diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp
index 4ae50858..bcfa4b0e 100644
--- a/subsystem/SubsystemBase.cpp
+++ b/subsystem/SubsystemBase.cpp
@@ -86,7 +86,7 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter,
 		object_id_t object = tableIter.value->getObject();
 		if ((iter = childrenMap.find(object)) == childrenMap.end()) {
 			//illegal table entry, should only happen due to misconfigured mode table
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::debug << std::hex << getObjectId() << ": invalid mode table entry"
 					<< std::endl;
 #endif
diff --git a/tasks/FixedSlotSequence.cpp b/tasks/FixedSlotSequence.cpp
index 9d15a9c7..54b6ae6d 100644
--- a/tasks/FixedSlotSequence.cpp
+++ b/tasks/FixedSlotSequence.cpp
@@ -91,7 +91,7 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "FixedSlotSequence::checkSequence:"
 				<< " Slot list is empty!" << std::endl;
 #endif
@@ -102,7 +102,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		ReturnValue_t result = customCheckFunction(slotList);
 		if(result != HasReturnvaluesIF::RETURN_OK) {
 			// Continue for now but print error output.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence:"
 					<< " Custom check failed!" << std::endl;
 #endif
@@ -116,7 +116,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 			errorCount++;
 		}
 		else if (slot.pollingTimeMs < time) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FixedSlotSequence::checkSequence: Time: "
 					<< slot.pollingTimeMs << " is smaller than previous with "
 					<< time << std::endl;
@@ -125,7 +125,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		}
 		else {
 			// All ok, print slot.
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			//sif::info << "Current slot polling time: " << std::endl;
 			//sif::info << std::dec << slotIt->pollingTimeMs << std::endl;
 #endif
@@ -133,7 +133,7 @@ ReturnValue_t FixedSlotSequence::checkSequence() const {
 		time = slot.pollingTimeMs;
 
 	}
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "Number of elements in slot list: "
 	//	   << slotList.size() << std::endl;
 #endif
@@ -159,7 +159,7 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
         }
     }
     if (count > 0) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "FixedSlotSequence::intializeSequenceAfterTaskCreation:"
                 "Counted " << count << " failed initializations!"  << std::endl;
 #endif
diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp
index 742dd648..b795854f 100644
--- a/tcdistribution/CCSDSDistributor.cpp
+++ b/tcdistribution/CCSDSDistributor.cpp
@@ -11,7 +11,7 @@ CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
 CCSDSDistributor::~CCSDSDistributor() {}
 
 TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif::debug << "CCSDSDistributor::selectDestination received: " <<
 //			this->currentMessage.getStorageId().pool_index << ", " <<
 //			this->currentMessage.getStorageId().packet_index << std::endl;
@@ -21,14 +21,14 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
 			&packet, &size );
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
 				" store failed!" << std::endl;
 #endif
 	}
 	SpacePacketBase currentPacket(packet);
 
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
 //			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
 #endif
@@ -76,7 +76,7 @@ ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
 	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
 	            " TC store!" << std::endl;
 #endif
diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp
index 3a214268..00fd9029 100644
--- a/tcdistribution/PUSDistributor.cpp
+++ b/tcdistribution/PUSDistributor.cpp
@@ -13,7 +13,7 @@ PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
 PUSDistributor::~PUSDistributor() {}
 
 PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     // sif:: debug << "PUSDistributor::handlePacket received: "
     //          << this->current_packet_id.store_index << ", "
     //          << this->current_packet_id.packet_index << std::endl;
@@ -27,7 +27,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
         tcStatus = checker.checkPacket(currentPacket);
 #ifdef DEBUG
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::debug << "PUSDistributor::handlePacket: Packet format "
                     << "invalid, code "<< static_cast<int>(tcStatus)
                     << std::endl;
@@ -44,7 +44,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     if (queueMapIt == this->queueMap.end()) {
         tcStatus = DESTINATION_NOT_FOUND;
 #ifdef DEBUG
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::debug << "PUSDistributor::handlePacket: Destination not found, "
                 << "code "<< static_cast<int>(tcStatus) << std::endl;
 #endif
@@ -63,13 +63,13 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 
 ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
 	uint16_t serviceId = service->getIdentifier();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// sif::info << "Service ID: " << (int)serviceId << std::endl;
 #endif
 	MessageQueueId_t queue = service->getRequestQueue();
 	auto returnPair = queueMap.emplace(serviceId, queue);
 	if (not returnPair.second) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::registerService: Service ID already"
 				" exists in map." << std::endl;
 #endif
@@ -114,7 +114,7 @@ ReturnValue_t PUSDistributor::initialize() {
 	CCSDSDistributorIF* ccsdsDistributor =
 			objectManager->get<CCSDSDistributorIF>(packetSource);
 	if (ccsdsDistributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PUSDistributor::initialize: Packet source invalid."
 		        << " Make sure it exists and implements CCSDSDistributorIF!"
 		        << std::endl;
diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp
index 0bd4a906..df069556 100644
--- a/tcdistribution/TcDistributor.cpp
+++ b/tcdistribution/TcDistributor.cpp
@@ -39,7 +39,7 @@ ReturnValue_t TcDistributor::handlePacket() {
 }
 
 void TcDistributor::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Distributor content is: " << std::endl
 	        << "ID\t| Message Queue ID" << std::endl;
 	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp
index b3d080ba..f79d2eeb 100644
--- a/timemanager/Stopwatch.cpp
+++ b/timemanager/Stopwatch.cpp
@@ -28,13 +28,13 @@ double Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
                 elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
 #endif
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::info <<"Stopwatch: Operation took "  << std::setprecision(3)
              << std::fixed << timevalOperations::toDouble(elapsedTime)
              << " seconds" << std::endl;
diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp
index 1a28419c..ca3e2a99 100644
--- a/tmtcpacket/pus/TcPacketBase.cpp
+++ b/tmtcpacket/pus/TcPacketBase.cpp
@@ -63,7 +63,7 @@ uint8_t TcPacketBase::getPusVersionNumber() {
 }
 
 void TcPacketBase::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "TcPacketBase::print: " << std::endl;
 #endif
 	arrayprinter::print(getWholeData(), getFullSize());
diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp
index 021b6d67..f320386c 100644
--- a/tmtcpacket/pus/TcPacketStored.cpp
+++ b/tmtcpacket/pus/TcPacketStored.cpp
@@ -23,7 +23,7 @@ TcPacketStored::TcPacketStored(uint16_t apid,  uint8_t service,
 	ReturnValue_t returnValue = this->store->getFreeElement(&this->storeAddress,
 			(TC_PACKET_MIN_SIZE + size), &pData);
 	if (returnValue != this->store->RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get free element from store!"
 				<< std::endl;
 #endif
@@ -41,7 +41,7 @@ ReturnValue_t TcPacketStored::getData(const uint8_t ** dataPtr,
 		size_t* dataSize) {
 	auto result = this->store->getData(storeAddress, dataPtr, dataSize);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "TcPacketStored: Could not get data!" << std::endl;
 #endif
 	}
@@ -65,7 +65,7 @@ bool TcPacketStored::checkAndSetStore() {
 	if (this->store == nullptr) {
 		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 		if (this->store == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp
index bf892ccf..c8e4b430 100644
--- a/tmtcpacket/pus/TmPacketBase.cpp
+++ b/tmtcpacket/pus/TmPacketBase.cpp
@@ -57,7 +57,7 @@ void TmPacketBase::setData(const uint8_t* p_Data) {
 }
 
 void TmPacketBase::print() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	 sif::debug << "TmPacketBase::print: " << std::endl;
 #endif
 	 arrayprinter::print(getWholeData(), getFullSize());
@@ -67,7 +67,7 @@ bool TmPacketBase::checkAndSetStamper() {
 	if (timeStamper == NULL) {
 		timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
 		if (timeStamper == NULL) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketBase::checkAndSetStamper: Stamper not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp
index 21f237bd..0fd2a4a0 100644
--- a/tmtcpacket/pus/TmPacketStored.cpp
+++ b/tmtcpacket/pus/TmPacketStored.cpp
@@ -105,7 +105,7 @@ bool TmPacketStored::checkAndSetStore() {
 	if (store == nullptr) {
 		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
 		if (store == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
 					<< std::endl;
 #endif
diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp
index 2be6e2ce..259f2ccb 100644
--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@@ -75,7 +75,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 			packetSource);
 
 	if (packetForwarding == nullptr or distributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
 #endif
@@ -90,7 +90,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::error << "CommandingServiceBase::intialize: IPC store or TC store "
 	                    "not initialized yet!" << std::endl;
 #endif
diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp
index 1b03a7f0..0a5cb202 100644
--- a/tmtcservices/PusServiceBase.cpp
+++ b/tmtcservices/PusServiceBase.cpp
@@ -25,7 +25,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
 	handleRequestQueue();
 	ReturnValue_t result = this->performService();
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusService " << (uint16_t) this->serviceId
 				<< ": performService returned with " << (int16_t) result
 				<< std::endl;
@@ -45,7 +45,7 @@ void PusServiceBase::handleRequestQueue() {
 	for (uint8_t count = 0; count < PUS_SERVICE_MAX_RECEPTION; count++) {
 		ReturnValue_t status = this->requestQueue->receiveMessage(&message);
 //		if(status != MessageQueueIF::EMPTY) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //			sif::debug << "PusServiceBase::performOperation: Receiving from "
 //					<< "MQ ID: " << std::hex << "0x" << std::setw(8)
 //					<< std::setfill('0') << this->requestQueue->getId()
@@ -83,7 +83,7 @@ void PusServiceBase::handleRequestQueue() {
 			break;
 		}
 		else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PusServiceBase::performOperation: Service "
 					<< this->serviceId << ": Error receiving packet. Code: "
 					<< std::hex << status << std::dec << std::endl;
@@ -110,7 +110,7 @@ ReturnValue_t PusServiceBase::initialize() {
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
 	if (destService == nullptr or distributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PusServiceBase::PusServiceBase: Service "
 				<< this->serviceId << ": Configuration error. Make sure "
 				<<	"packetSource and packetDestination are defined correctly"
diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 954e3e75..2513071a 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -23,7 +23,7 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
 	             << "packets sent per cycle exceeds limits. "
 	             << "Keeping default value." << std::endl;
@@ -39,7 +39,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
                 << "packets stored exceeds limits. "
                 << "Keeping default value." << std::endl;
@@ -51,7 +51,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 ReturnValue_t TmTcBridge::initialize() {
 	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
 	if (tcStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
 #endif
@@ -59,7 +59,7 @@ ReturnValue_t TmTcBridge::initialize() {
 	}
 	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
 	if (tmStore == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
 				"it is created and set up properly." << std::endl;
 #endif
@@ -68,7 +68,7 @@ ReturnValue_t TmTcBridge::initialize() {
 	AcceptsTelecommandsIF* tcDistributor =
 			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
 	if (tcDistributor == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
 				<< std::endl;
 #endif
@@ -85,14 +85,14 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::debug << "TmTcBridge::performOperation: "
 		        << "Error handling TCs" << std::endl;
 #endif
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::performOperation: "
 	                    << "Error handling TMs" << std::endl;
 #endif
@@ -108,7 +108,7 @@ ReturnValue_t TmTcBridge::handleTm() {
     ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::handleTm: Error handling TM queue with "
 		       << "error code 0x" << std::hex << result  << std::dec
 			   << "!" << std::endl;
@@ -120,7 +120,7 @@ ReturnValue_t TmTcBridge::handleTm() {
 	        (packetSentCounter < sentPacketsPerCycle)) {
 	    result = handleStoredTm();
 	    if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	        sif::error << "TmTcBridge::handleTm: Error handling stored TMs!"
 	                << std::endl;
 #endif
@@ -140,7 +140,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 		 result == HasReturnvaluesIF::RETURN_OK;
 		 result = tmTcReceptionQueue->receiveMessage(&message))
 	{
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    //sif::info << (int) packetSentCounter << std::endl;
 #endif
 		if(communicationLinkUp == false or
@@ -171,7 +171,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	store_address_t storeId = 0;
 
 	if(tmFifo->full()) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::debug << "TmTcBridge::storeDownlinkData: TM downlink max. number "
 	                    << "of stored packet IDs reached! " << std::endl;
 #endif
@@ -193,7 +193,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 ReturnValue_t TmTcBridge::handleStoredTm() {
     ReturnValue_t status = RETURN_OK;
 	while(not tmFifo->empty() and packetSentCounter < sentPacketsPerCycle) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Sending stored TM data. There are "
 		//     << (int) tmFifo->size() << " left to send\r\n" << std::flush;
 #endif
@@ -209,7 +209,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 		result = sendTm(data,size);
 		if(result != RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TMTC Bridge: Could not send stored downlink data"
 			      << std::endl;
 #endif
@@ -227,7 +227,7 @@ ReturnValue_t TmTcBridge::handleStoredTm() {
 
 void TmTcBridge::registerCommConnect() {
 	if(not communicationLinkUp) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		//sif::info << "TMTC Bridge: Registered Comm Link Connect" << std::endl;
 #endif
 		communicationLinkUp = true;
@@ -235,7 +235,7 @@ void TmTcBridge::registerCommConnect() {
 }
 
 void TmTcBridge::registerCommDisconnect() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	//sif::info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl;
 #endif
 	if(communicationLinkUp) {
diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp
index 3bd1f067..ff6f54f9 100644
--- a/tmtcservices/VerificationReporter.cpp
+++ b/tmtcservices/VerificationReporter.cpp
@@ -27,7 +27,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
@@ -46,7 +46,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 			&message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendSuccessReport: Error writing "
 				<< "to queue. Code: " << std::hex << status << std::dec
 				<< std::endl;
@@ -68,7 +68,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex  << "0x" << status << std::dec
 				<< std::endl;
@@ -88,7 +88,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 	ReturnValue_t status = MessageQueueSenderIF::sendMessage(acknowledgeQueue,
 	        &message);
 	if (status != HasReturnvaluesIF::RETURN_OK) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::sendFailureReport: Error writing "
 				<< "to queue. Code: " << std::hex << "0x" << status << std::dec
 				<< std::endl;
@@ -98,7 +98,7 @@ void VerificationReporter::sendFailureReport(uint8_t report_id,
 
 void VerificationReporter::initialize() {
 	if(messageReceiver == objects::NO_OBJECT) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "VerificationReporter::initialize: Verification message"
 				" receiver object ID not set yet in Factory!" << std::endl;
 #endif
@@ -107,7 +107,7 @@ void VerificationReporter::initialize() {
 	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
 	if (temp == nullptr) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "VerificationReporter::initialize: Message "
 				<< "receiver invalid. Make sure it is set up properly and "
 				<< "implementsAcceptsVerifyMessageIF" << std::endl;
diff --git a/unittest/internal/InternalUnitTester.cpp b/unittest/internal/InternalUnitTester.cpp
index 6771b17e..bd41969c 100644
--- a/unittest/internal/InternalUnitTester.cpp
+++ b/unittest/internal/InternalUnitTester.cpp
@@ -13,7 +13,7 @@ InternalUnitTester::InternalUnitTester() {}
 InternalUnitTester::~InternalUnitTester() {}
 
 ReturnValue_t InternalUnitTester::performTests() {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Running internal unit tests.." << std::endl;
 #endif
 	testserialize::test_serialization();
@@ -21,7 +21,7 @@ ReturnValue_t InternalUnitTester::performTests() {
 	testsemaph::testBinSemaph();
 	testsemaph::testCountingSemaph();
 	testmutex::testMutex();
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::info << "Internal unit tests finished." << std::endl;
 #endif
 	return RETURN_OK;
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 292c4b8a..7138e6c6 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -1,7 +1,7 @@
 #include "UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << "\n" << std::flush;
 #endif
diff --git a/unittest/internal/osal/IntTestSemaphore.cpp b/unittest/internal/osal/IntTestSemaphore.cpp
index 908326d4..43990c2c 100644
--- a/unittest/internal/osal/IntTestSemaphore.cpp
+++ b/unittest/internal/osal/IntTestSemaphore.cpp
@@ -94,7 +94,7 @@ void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph,
 		result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
 		//dur_millis_t time = stopwatch.stop();
 //		if(abs(time - 10) > 2) {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 //		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
 //		            << std::endl;
 #endif
diff --git a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
index 443b2bbb..b7f1fb3e 100644
--- a/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
+++ b/unittest/user/testcfg/pollingsequence/PollingSequenceFactory.cpp
@@ -15,7 +15,7 @@ ReturnValue_t pst::pollingSequenceInitDefault(
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!"
 		        << std::endl;
 #endif
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 6504700c..00daf015 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -5,7 +5,7 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	if(objectManager != nullptr) {
 		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	} else {
-#if CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #endif
 		return nullptr;

From 695a767164573b73a3360e9bf10a70773236ef2c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:33:17 +0100
Subject: [PATCH 1170/1292] some include fixes

---
 globalfunctions/arrayprinter.cpp          | 2 +-
 objectmanager/ObjectManager.cpp           | 2 +-
 serviceinterface/ServiceInterfaceStream.h | 1 +
 storagemanager/ConstStorageAccessor.cpp   | 2 ++
 storagemanager/StorageAccessor.cpp        | 2 ++
 5 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index d0b0a3bf..c273b250 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -33,7 +33,7 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 				sif::info << std::endl;
 
 			}
-
+		}
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp
index 69dd905b..882d2762 100644
--- a/objectmanager/ObjectManager.cpp
+++ b/objectmanager/ObjectManager.cpp
@@ -29,7 +29,7 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::insert: Object id " << std::hex
-		           << static_cast<uint32_t> id << std::dec
+		           << static_cast<uint32_t>(id) << std::dec
 				   << " is already in use!" << std::endl;
 		sif::error << "Terminating program." << std::endl;
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index c18c6c2e..f3cb2cd0 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -2,6 +2,7 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 
 #include "ServiceInterfaceBuffer.h"
+#include <FSFWConfig.h>
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 
diff --git a/storagemanager/ConstStorageAccessor.cpp b/storagemanager/ConstStorageAccessor.cpp
index 39530ac9..aab84862 100644
--- a/storagemanager/ConstStorageAccessor.cpp
+++ b/storagemanager/ConstStorageAccessor.cpp
@@ -4,6 +4,8 @@
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../globalfunctions/arrayprinter.h"
 
+#include <algorithm>
+
 ConstStorageAccessor::ConstStorageAccessor(store_address_t storeId):
 		storeId(storeId) {}
 
diff --git a/storagemanager/StorageAccessor.cpp b/storagemanager/StorageAccessor.cpp
index fec5d75e..a7b4fae4 100644
--- a/storagemanager/StorageAccessor.cpp
+++ b/storagemanager/StorageAccessor.cpp
@@ -2,6 +2,8 @@
 #include "StorageManagerIF.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 
+#include <algorithm>
+
 StorageAccessor::StorageAccessor(store_address_t storeId):
 		ConstStorageAccessor(storeId) {
 }

From 98af84c1455f57e96cf300a9746d759930e31f78 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 14:41:54 +0100
Subject: [PATCH 1171/1292] additional tweask

---
 datapoollocal/LocalPoolVariable.h   | 2 ++
 datapoollocal/LocalPoolVariable.tpp | 2 ++
 serialize/EndianConverter.h         | 1 -
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 7b7e443e..84be54b1 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -157,10 +157,12 @@ protected:
 	 */
 	ReturnValue_t commitWithoutLock() override;
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
+#endif
 
 private:
 };
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index aa5e5393..cd5117c8 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -106,12 +106,14 @@ inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
 		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
+#endif
 
 template<typename T>
 inline LocalPoolVariable<T>::operator T() const {
diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index c888a905..8f3c7a7e 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,7 +3,6 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
-#include <iostream>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From 8c8965177f5007a770e323311e287bf0ab186ad9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:04:37 +0100
Subject: [PATCH 1172/1292] new amalgated header

---
 serviceinterface/ServiceInterface.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 serviceinterface/ServiceInterface.h

diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
new file mode 100644
index 00000000..0c7c4383
--- /dev/null
+++ b/serviceinterface/ServiceInterface.h
@@ -0,0 +1,12 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+
+#include <FSFWConfig.h>
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#else
+#include <fsfw/serviceinterface/ServiceInterfacePrinter.h>
+#endif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_ */

From 59d327f8b6f27eea4e3694541505ae86b96a81f7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:15:03 +0100
Subject: [PATCH 1173/1292] console init for printf on windows

---
 serviceinterface/ServiceInterfacePrinter.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 369edd0f..e8eb498f 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -9,8 +9,23 @@
 
 fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+bool consoleInitialized = false;
+#endif
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+	if(not consoleInitialized) {
+		HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+		DWORD dwMode = 0;
+		GetConsoleMode(hOut, &dwMode);
+		dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+		SetConsoleMode(hOut, dwMode);
+	}
+	consoleInitialized = true;
+#endif
+
     size_t len = 0;
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 

From c94a396ffb478a96b67269bc72bbb6f63dcc88fd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 15:31:44 +0100
Subject: [PATCH 1174/1292] changelog update

---
 CHANGELOG | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/CHANGELOG b/CHANGELOG
index 2d901791..298ef0d4 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -70,3 +70,15 @@ 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.
+- 
\ No newline at end of file

From f64e356de398cf20d467110f9d1078efcaefbec5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 16:42:29 +0100
Subject: [PATCH 1175/1292] small include fix

---
 serialize/EndianConverter.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 8f3c7a7e..3b19832e 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,6 +3,7 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
+#include <cstdint>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From 51cdf6cc76262e64c3362ee256046fb8293ba97a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 16:48:18 +0100
Subject: [PATCH 1176/1292] missing include added

---
 serialize/EndianConverter.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h
index 8f3c7a7e..3b19832e 100644
--- a/serialize/EndianConverter.h
+++ b/serialize/EndianConverter.h
@@ -3,6 +3,7 @@
 
 #include "../osal/Endiness.h"
 #include <cstring>
+#include <cstdint>
 
 /**
  * Helper class to convert variables or bitstreams between machine

From e9da8e79f32fc2dfc34b779aa069c0c1faae339a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 22:00:40 +0100
Subject: [PATCH 1177/1292] updated testcfg

---
 unittest/user/testcfg/FSFWConfig.h | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 6b0def90..261e3d6d 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -4,17 +4,26 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
+//! More FSFW related printouts.
 //! Be careful, this also turns off most diagnostic prinouts!
 #define FSFW_ENHANCED_PRINTOUT		0
 
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
 //! Can be used to enable additional debugging printouts for developing the FSFW
 #define FSFW_PRINT_VERBOSITY_LEVEL   0
 
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
+
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
 //! and translateEvents (and their compiled source files)
@@ -49,7 +58,9 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
-static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */

From e9a8313df7e5f4ae8f5afb732ef461bd348fcbb5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 23:18:10 +0100
Subject: [PATCH 1178/1292] repaired unit tests

---
 container/FixedOrderedMultimap.h              |   1 +
 .../tests/container/TestPlacementFactory.cpp  |  93 ++---
 .../tests/storagemanager/TestNewAccessor.cpp  | 321 +++++++++---------
 unittest/tests/storagemanager/TestPool.cpp    |   2 -
 4 files changed, 209 insertions(+), 208 deletions(-)

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 96bc0073..acf2368a 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -3,6 +3,7 @@
 
 #include "ArrayList.h"
 #include <cstring>
+#include <functional>
 
 /**
  * @brief  An associative container which allows multiple entries of the same key.
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index 5edbb9d2..14cf8eb4 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,48 @@
-//#include <fsfw/container/PlacementFactory.h>
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-//#include <fsfw/container/ArrayList.h>
-//
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-//	INFO("PlacementFactory Tests");
-//
-//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-//	const uint16_t n_elements[3] = {1, 1, 1};
-//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-//	PlacementFactory factory(&storagePool);
-//
-//	SECTION("Pool overload"){
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-//		REQUIRE(list2 == nullptr);
-//	}
-//
-//	SECTION("Test generate and destroy"){
-//		uint64_t* number = factory.generate<uint64_t>(32000);
-//		REQUIRE(number != nullptr);
-//		REQUIRE(*number == 32000);
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		uint64_t* number2 = factory.generate<uint64_t>(12345);
-//		REQUIRE(number2 == nullptr);
-//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//
-//		//Check that PlacementFactory checks for nullptr
-//		ptr = nullptr;
-//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-//	}
-//}
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	LocalPool::LocalPoolConfig poolCfg= {{1, sizeof(uint16_t)},
+			{1, sizeof(uint32_t)}, {1, sizeof(uint64_t)}
+	};
+	//const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	//const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool storagePool(0x1, poolCfg, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7bd0dee2..87ea00ca 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,160 @@
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//#include <array>
-//
-//TEST_CASE( "New Accessor" , "[NewAccessor]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
-//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 10;
-//
-//	SECTION ("Simple tests getter functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		CHECK(resultPair.second.getId() == testStoreId);
-//		CHECK(resultPair.second.size() == 10);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		std::copy(resultPair.second.data(), resultPair.second.data() +
-//				resultPair.second.size(), receptionArray.data());
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		{
-//			auto resultPairLoc = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			// data should be deleted when accessor goes out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			ConstStorageAccessor constAccessor(testStoreId);
-//			result = SimplePool.getData(testStoreId, constAccessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			constAccessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// likewise, data should be deleted when accessor gets out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		{
-//			resultPair = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			resultPair.second.release();
-//			// now data should not be deleted anymore
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//	}
-//
-//
-//	SECTION("Simple tests modify functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			StorageAccessor accessor(testStoreId);
-//			result = SimplePool.modifyData(testStoreId, accessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(accessor.getId() == testStoreId);
-//			CHECK(accessor.size() == 10);
-//			accessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(accessor.data(), accessor.data() +
-//					accessor.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// data should be deleted when accessor goes out of scope
-//		}
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			CHECK(resultPairLoc.second.getId() == testStoreId);
-//			CHECK(resultPairLoc.second.size() == 10);
-//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-//					resultPairLoc.second.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			resultPairLoc.second.release();
-//			// data should not be deleted when accessor goes out of scope
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//	}
-//
-//
-//	SECTION("Write tests") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPair = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			testDataArray[9] = 42;
-//			resultPair.second.write(testDataArray.data(), 10, 0);
-//			// now data should not be deleted
-//			resultPair.second.release();
-//		}
-//		auto resultConstPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-//
-//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-//		for(size_t i = 0; i < size-1; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		CHECK(receptionArray[9] == 42 );
-//
-//		auto resultPair = SimplePool.modifyData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		result = resultPair.second.write(testDataArray.data(), 20, 0);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//		result = resultPair.second.write(testDataArray.data(), 10, 5);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//
-//		memset(testDataArray.data(), 42, 5);
-//		result = resultPair.second.write(testDataArray.data(), 5, 5);
-//		REQUIRE(result == retval::CATCH_OK);
-//		resultConstPair = SimplePool.getData(testStoreId);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 5; i < 10; i++) {
-//			CHECK(receptionArray[i] == 42 );
-//		}
-//
-//	}
-//}
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+#include <array>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
+	LocalPool SimplePool = LocalPool(0, poolCfg);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index dcfb6c03..50bde01a 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -8,8 +8,6 @@
 
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
 	LocalPool::LocalPoolConfig config = {{1, 10}};
 	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;

From 49c6cd947300bef7db1622a547af7ce5fdf7980b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 3 Jan 2021 23:27:49 +0100
Subject: [PATCH 1179/1292] added local pool owner base

---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 unittest/tests/datapoollocal/LocalPoolOwnerBase.h

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
new file mode 100644
index 00000000..5e62234b
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -0,0 +1,8 @@
+#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+
+
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */

From 8e3aef5df05669d686d1ec0a6a899e3c6a369d7a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 00:21:44 +0100
Subject: [PATCH 1180/1292] adding new tests for local pool variable

---
 unittest/tests/CMakeLists.txt                 |  1 +
 unittest/tests/datapoollocal/CMakeLists.txt   |  3 +
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 75 +++++++++++++++++++
 .../datapoollocal/LocalPoolVariableTest.cpp   | 37 +++++++++
 .../user/testcfg/objects/systemObjectList.h   | 14 +++-
 5 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 unittest/tests/datapoollocal/CMakeLists.txt
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVariableTest.cpp

diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
index 97074417..180e1a51 100644
--- a/unittest/tests/CMakeLists.txt
+++ b/unittest/tests/CMakeLists.txt
@@ -2,5 +2,6 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)
+add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
new file mode 100644
index 00000000..569a8d5f
--- /dev/null
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(${TARGET_NAME} PRIVATE
+	LocalPoolVariableTest.cpp
+)
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5e62234b..b73c5299 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -1,8 +1,83 @@
 #ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <testcfg/objects/systemObjectList.h>
+
+namespace lpool {
+static constexpr lp_id_t uint8VarId = 0;
+static constexpr lp_id_t floatVarId = 1;
+}
 
 
+class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
+public:
+	LocalPoolOwnerBase(
+			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
+		SystemObject(objectId), hkManager(this, messageQueue)  {
+		messageQueue = QueueFactory::instance()->createMessageQueue(10);
+	}
 
+	~LocalPoolOwnerBase() {
+		QueueFactory::instance()->deleteMessageQueue(messageQueue);
+	}
+
+	object_id_t getObjectId() const override {
+		return SystemObject::getObjectId();
+	}
+
+	ReturnValue_t initializeHkManager() {
+		return hkManager.initialize(messageQueue);
+
+	}
+
+	ReturnValue_t initializeHkManagerAfterTaskCreation() {
+		return hkManager.initializeAfterTaskCreation();
+	}
+
+	/** Command queue for housekeeping messages. */
+	MessageQueueId_t getCommandQueue() const override {
+		return messageQueue->getId();
+	}
+
+	virtual ReturnValue_t initializeLocalDataPool(
+	        LocalDataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) {
+		// Default initialization empty for now.
+		localDataPoolMap.emplace(lpool::uint8VarId, new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId, new PoolEntry<float>({0}));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	LocalDataPoolManager* getHkManagerHandle() override {
+		return &hkManager;
+	}
+
+	uint32_t getPeriodicOperationFrequency() const override {
+		return 0;
+	}
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
+		// empty for now
+		return nullptr;
+	}
+private:
+
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+
+	MessageQueueIF* messageQueue = nullptr;
+	LocalDataPoolManager hkManager;
+
+};
 
 #endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
new file mode 100644
index 00000000..0c233193
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -0,0 +1,37 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
+	LocalPoolOwnerBase poolOwner(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner.initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	// very basic test.
+	lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+	REQUIRE(testVariable.read() == retval::CATCH_OK);
+	CHECK(testVariable.value == 0);
+	testVariable.value = 5;
+	REQUIRE(testVariable.commit() == retval::CATCH_OK);
+	REQUIRE(testVariable.read() == retval::CATCH_OK);
+	REQUIRE(testVariable.value == 5);
+
+	// not try to use a local pool variable which does not exist
+	lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+	REQUIRE(invalidVariable.read() ==
+			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+	// now try to access with wrong type
+	lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+	REQUIRE(invalidVariable2.read() ==
+			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+}
+
+
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index 0e034aff..da95617c 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -9,7 +9,19 @@ namespace objects {
 	enum sourceObjects: uint32_t {
 		/* All addresses between start and end are reserved for the FSFW */
 		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
-		FSFW_CONFIG_RESERVED_END = TM_STORE
+		FSFW_CONFIG_RESERVED_END = TM_STORE,
+
+		CCSDS_DISTRIBUTOR = 10,
+		PUS_DISTRIBUTOR = 11,
+		TM_FUNNEL = 12,
+
+		UDP_BRIDGE = 15,
+		UDP_POLLING_TASK = 16,
+
+		TEST_ECHO_COM_IF = 20,
+		TEST_DEVICE = 21,
+
+		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }
 

From cca5689a18425627559308e87dfde34f22cc28d0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:17:11 +0100
Subject: [PATCH 1181/1292] clock improvements for rtems

---
 osal/rtems/Clock.cpp | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index dda15464..8bd7ac37 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -37,15 +37,24 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
 	timespec newTime;
 	newTime.tv_sec = time->tv_sec;
+	if(time->tv_usec < 0) {
+		// better returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,nullptr);
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ISR_lock_Context context;
+	_TOD_Lock();
+	_TOD_Acquire(&context);
+	Status_Control status = _TOD_Set(&newTime, &context);
+	_TOD_Unlock();
+	if(status == STATUS_SUCCESSFUL) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	// better returnvalue
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
@@ -95,6 +104,7 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// TIsn't this a bug? Are RTEMS ticks always microseconds?
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
 	switch (status) {

From 3c041388d6705bccda5790ceeb5545ed9e48613d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:31:06 +0100
Subject: [PATCH 1182/1292] bugfix

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 20ea61dd..5846d233 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -28,18 +28,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	}
 
 #if FSFW_COLORED_OUTPUT == 1
-	if(setMessage.find("DEBUG")) {
+	if(setMessage.find("DEBUG") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
 	}
-	else if(setMessage.find("INFO")) {
+	else if(setMessage.find("INFO") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_GREEN;
 	}
-	else if(setMessage.find("WARNING")) {
+	else if(setMessage.find("WARNING") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
 	}
-	else if(setMessage.find("ERROR")) {
+	else if(setMessage.find("ERROR") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+	else {
+		colorPrefix = fsfw::ANSI_COLOR_RESET;
+	}
 
 #ifdef WIN32
 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

From 63e80206bcb8a36e9f0ead86f15b4fd687223756 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:34:08 +0100
Subject: [PATCH 1183/1292] rtems osal update

---
 osal/rtems/Clock.cpp           | 22 ++++++++++++++++------
 osal/rtems/MessageQueue.cpp    |  2 ++
 osal/rtems/MultiObjectTask.cpp |  4 ++++
 osal/rtems/Mutex.cpp           |  4 ++++
 osal/rtems/PollingTask.cpp     |  8 ++++++++
 osal/rtems/TaskBase.cpp        |  2 ++
 6 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp
index dda15464..8bd7ac37 100644
--- a/osal/rtems/Clock.cpp
+++ b/osal/rtems/Clock.cpp
@@ -37,15 +37,24 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	//TODO This routine uses _TOD_Set which is not
 	timespec newTime;
 	newTime.tv_sec = time->tv_sec;
+	if(time->tv_usec < 0) {
+		// better returnvalue.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 	newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-	//SHOULDDO: Not sure if we need to protect this call somehow (by thread lock or something).
-	//Uli: rtems docu says you can call this from an ISR, not sure if this means no protetion needed
-	//TODO Second parameter is ISR_lock_Context
-	_TOD_Set(&newTime,nullptr);
-	return HasReturnvaluesIF::RETURN_OK;
+
+	ISR_lock_Context context;
+	_TOD_Lock();
+	_TOD_Acquire(&context);
+	Status_Control status = _TOD_Set(&newTime, &context);
+	_TOD_Unlock();
+	if(status == STATUS_SUCCESSFUL) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	// better returnvalue
+	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
@@ -95,6 +104,7 @@ ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+	// TIsn't this a bug? Are RTEMS ticks always microseconds?
 	rtems_time_of_day* timeRtems = reinterpret_cast<rtems_time_of_day*>(time);
 	rtems_status_code status = rtems_clock_get_tod(timeRtems);
 	switch (status) {
diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp
index 839182a6..bfaf3569 100644
--- a/osal/rtems/MessageQueue.cpp
+++ b/osal/rtems/MessageQueue.cpp
@@ -9,9 +9,11 @@ MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 	rtems_status_code status = rtems_message_queue_create(name, message_depth,
 			max_message_size, 0, &(this->id));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
 				<< name << std::dec << " failed with status:"
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }
diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp
index 970d01e1..b111f724 100644
--- a/osal/rtems/MultiObjectTask.cpp
+++ b/osal/rtems/MultiObjectTask.cpp
@@ -30,8 +30,10 @@ ReturnValue_t MultiObjectTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, MultiObjectTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -63,7 +65,9 @@ void MultiObjectTask::taskFunctionality() {
 			char nameSpace[8] = { 0 };
 			char* ptr = rtems_object_get_name(getId(), sizeof(nameSpace),
 					nameSpace);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "ObjectTask: " << ptr << " Deadline missed." << std::endl;
+#endif
 			if (this->deadlineMissedFunc != nullptr) {
 				this->deadlineMissedFunc();
 			}
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index a5ec9635..71c5782f 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -10,16 +10,20 @@ Mutex::Mutex() :
 	RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0,
 			&mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: creation with name, id " << mutexName << ", " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
 Mutex::~Mutex() {
 	rtems_status_code status = rtems_semaphore_delete(mutexId);
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Mutex: deletion for id " << mutexId
 				<< " failed with " << status << std::endl;
+#endif
 	}
 }
 
diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp
index db7864fe..0ebf63e2 100644
--- a/osal/rtems/PollingTask.cpp
+++ b/osal/rtems/PollingTask.cpp
@@ -35,15 +35,19 @@ rtems_task PollingTask::taskEntryPoint(rtems_task_argument argument) {
 	PollingTask *originalTask(reinterpret_cast<PollingTask*>(argument));
 	//The task's functionality is called.
 	originalTask->taskFunctionality();
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::debug << "Polling task " << originalTask->getId()
 			<< " returned from taskFunctionality." << std::endl;
+#endif
 }
 
 void PollingTask::missedDeadlineCounter() {
 	PollingTask::deadlineMissedCount++;
 	if (PollingTask::deadlineMissedCount % 10 == 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PST missed " << PollingTask::deadlineMissedCount
 				<< " deadlines." << std::endl;
+#endif
 	}
 }
 
@@ -51,8 +55,10 @@ ReturnValue_t PollingTask::startTask() {
 	rtems_status_code status = rtems_task_start(id, PollingTask::taskEntryPoint,
 			rtems_task_argument((void *) this));
 	if (status != RTEMS_SUCCESSFUL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PollingTask::startTask for " << std::hex << this->getId()
 				<< std::dec << " failed." << std::endl;
+#endif
 	}
 	switch(status){
 	case RTEMS_SUCCESSFUL:
@@ -75,8 +81,10 @@ ReturnValue_t PollingTask::addSlot(object_id_t componentId,
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Component " << std::hex << componentId <<
 			" not found, not adding it to pst" << std::endl;
+#endif
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp
index 4e0c8f00..6abfcca8 100644
--- a/osal/rtems/TaskBase.cpp
+++ b/osal/rtems/TaskBase.cpp
@@ -22,9 +22,11 @@ TaskBase::TaskBase(rtems_task_priority set_priority, size_t stack_size,
 	}
 	ReturnValue_t result = convertReturnCode(status);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TaskBase::TaskBase: createTask with name " << std::hex
 				<< osalName << std::dec << " failed with return code "
 				<< (uint32_t) status << std::endl;
+#endif
 		this->id = 0;
 	}
 }

From e64b2e0616a6fbdc126f28f4a84f7af4662aa4b3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 4 Jan 2021 15:38:46 +0100
Subject: [PATCH 1184/1292] bugfix

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 20ea61dd..5846d233 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -28,18 +28,21 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 	}
 
 #if FSFW_COLORED_OUTPUT == 1
-	if(setMessage.find("DEBUG")) {
+	if(setMessage.find("DEBUG") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
 	}
-	else if(setMessage.find("INFO")) {
+	else if(setMessage.find("INFO") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_GREEN;
 	}
-	else if(setMessage.find("WARNING")) {
+	else if(setMessage.find("WARNING") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
 	}
-	else if(setMessage.find("ERROR")) {
+	else if(setMessage.find("ERROR") != std::string::npos) {
 		colorPrefix = fsfw::ANSI_COLOR_RED;
 	}
+	else {
+		colorPrefix = fsfw::ANSI_COLOR_RESET;
+	}
 
 #ifdef WIN32
 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

From 85764ba94c3f4edf1cbabc260cb94dd916b2d72f Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 17:30:15 +0100
Subject: [PATCH 1185/1292] added include

---
 unittest/tests/storagemanager/TestNewAccessor.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 87ea00ca..10d05c6b 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <unittest/core/CatchDefinitions.h>
 #include <array>
+#include <cstring>
 
 TEST_CASE( "New Accessor" , "[NewAccessor]") {
 	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
@@ -147,7 +148,7 @@ TEST_CASE( "New Accessor" , "[NewAccessor]") {
 		result = resultPair.second.write(testDataArray.data(), 10, 5);
 		REQUIRE(result == retval::CATCH_FAILED);
 
-		memset(testDataArray.data(), 42, 5);
+		std::memset(testDataArray.data(), 42, 5);
 		result = resultPair.second.write(testDataArray.data(), 5, 5);
 		REQUIRE(result == retval::CATCH_OK);
 		resultConstPair = SimplePool.getData(testStoreId);

From a05cf8d4ab54066f6cc9f6450f80f98577fad1af Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 22:46:17 +0100
Subject: [PATCH 1186/1292] updated tests

---
 .../datapoollocal/LocalPoolVariableTest.cpp   | 50 ++++++++++++-------
 1 file changed, 31 insertions(+), 19 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 0c233193..f52ff925 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -11,27 +11,39 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
 
-	// very basic test.
-	lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-	REQUIRE(testVariable.read() == retval::CATCH_OK);
-	CHECK(testVariable.value == 0);
-	testVariable.value = 5;
-	REQUIRE(testVariable.commit() == retval::CATCH_OK);
-	REQUIRE(testVariable.read() == retval::CATCH_OK);
-	REQUIRE(testVariable.value == 5);
+	SECTION("Basic Tests") {
+		// very basic test.
+		lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		CHECK(testVariable.value == 0);
+		testVariable.value = 5;
+		REQUIRE(testVariable.commit() == retval::CATCH_OK);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable.value == 5);
 
-	// not try to use a local pool variable which does not exist
-	lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-	REQUIRE(invalidVariable.read() ==
-			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+		CHECK(not testVariable.isValid());
+
+		// not try to use a local pool variable which does not exist
+		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVariable.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(invalidVariable2.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+
+		// now try to access with wrong type
+		lp_var_t<int8_t> readOnlyVar = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVar.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+	}
 
-	// now try to access with wrong type
-	lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
-			objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-	REQUIRE(invalidVariable2.read() ==
-			static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 }
 
 

From b241ef6aad5861dc570548fd17bdf856e3332984 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 5 Jan 2021 22:51:49 +0100
Subject: [PATCH 1187/1292] continued tests

---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h  |  2 ++
 .../tests/datapoollocal/LocalPoolVariableTest.cpp  | 14 ++++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index b73c5299..40f657be 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -10,6 +10,7 @@
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
 static constexpr lp_id_t floatVarId = 1;
+static constexpr lp_id_t uint32VarId = 2;
 }
 
 
@@ -74,6 +75,7 @@ private:
 
 	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
 	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
 	MessageQueueIF* messageQueue = nullptr;
 	LocalDataPoolManager hkManager;
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index f52ff925..faca03e3 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -23,6 +23,8 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(testVariable.value == 5);
 
 		CHECK(not testVariable.isValid());
+		testVariable.setValid(true);
+		CHECK(testVariable.isValid());
 
 		// not try to use a local pool variable which does not exist
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
@@ -36,12 +38,20 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(invalidVariable2.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 
-		// now try to access with wrong type
-		lp_var_t<int8_t> readOnlyVar = lp_var_t<int8_t>(
+		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
 				nullptr, pool_rwm_t::VAR_READ);
 		REQUIRE(readOnlyVar.commit() ==
 				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+		lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVar.read() == static_cast<int>(
+				PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
 	}
 
 }

From bd93392b59b3904ef450a61d0005196d896af948 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 16:26:08 +0100
Subject: [PATCH 1188/1292] local pool variabel tweaks and fixes

---
 datapoollocal/LocalPoolVariable.tpp | 34 +++++++++++++++++------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index cd5117c8..dd6219b1 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -34,7 +34,7 @@ template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVariable: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
+		sif::error << "PoolPoolVariable: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID " << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
@@ -67,7 +67,7 @@ template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVariable: Invalid read write "
+		sif::warning << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -76,10 +76,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+		sif::error << "PoolPoolVariable: Read of local pool variable of "
+				<< "object " << std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
@@ -89,8 +89,9 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
@@ -121,7 +122,8 @@ inline LocalPoolVariable<T>::operator T() const {
 }
 
 template<typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+		const T& newValue) {
     value = newValue;
     return *this;
 }
@@ -134,7 +136,8 @@ inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
 }
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(
+		const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
@@ -145,7 +148,8 @@ inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
@@ -156,7 +160,8 @@ inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(
+		const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
@@ -167,7 +172,8 @@ inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 

From 16458f6a1e42fa75c4ca0155f22117bd0acf2b0b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 18:20:38 +0100
Subject: [PATCH 1189/1292] continued tests

---
 datapoollocal/LocalPoolVariable.tpp           |  4 ++--
 datapoollocal/LocalPoolVector.tpp             | 20 +++++++++----------
 .../datapoollocal/LocalPoolVariableTest.cpp   | 11 ++++++++++
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index dd6219b1..153a13d0 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -46,7 +46,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolPoolVariable: Read of local pool variable of object "
 				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 #endif
 		return result;
@@ -78,7 +78,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PoolPoolVariable: Read of local pool variable of "
 				<< "object " << std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 5c3b0ce0..a010a8bb 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -33,7 +33,7 @@ template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVector: Invalid read write "
 				"mode for read() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -45,10 +45,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
-				std::dec << " failed." << std::endl;
+		sif::error << "LocalPoolVector: Read of local pool variable of object "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << "and lp ID 0x" << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
@@ -69,7 +69,7 @@ template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
+		sif::warning << "LocalPoolVector: Invalid read write "
 				"mode for commit() call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
@@ -78,10 +78,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
+		sif::error << "LocalPoolVector: Read of local pool variable of object "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< hkManager->getOwner() << " and lp ID " << localPoolId
+				<< std::dec << " failed." << std::endl;
 #endif
 		return result;
 	}
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index faca03e3..2a7f9863 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -26,12 +26,23 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
 
+		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable == 5);
+	}
+
+	SECTION("ErrorHandling") {
+
 		// not try to use a local pool variable which does not exist
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVariable.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
 
+		REQUIRE(invalidVariable.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
 		// now try to access with wrong type
 		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);

From dc8dd770e7e9500da1ce5813a954ea5c8111ca8f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:07:35 +0100
Subject: [PATCH 1190/1292] added more tests

---
 .../datapoollocal/LocalPoolVariableTest.cpp   | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 2a7f9863..e60d5a6b 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -29,8 +29,25 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
 				lpool::uint8VarId);
 		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
-		REQUIRE(testVariable.read() == retval::CATCH_OK);
-		REQUIRE(testVariable == 5);
+		REQUIRE(testVariable2.read() == retval::CATCH_OK);
+		CHECK(testVariable2 == 5);
+		CHECK(testVariable == testVariable2);
+		testVariable = 10;
+		CHECK(testVariable != 5);
+		//CHECK(not testVariable != testVariable2);
+		uint8_t variableRaw = 0;
+		uint8_t* varPtr = &variableRaw;
+		size_t maxSize = testVariable.getSerializedSize();
+		CHECK(maxSize == 1);
+		size_t serSize = 0;
+		CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(variableRaw == 10);
+		const uint8_t* varConstPtr = &variableRaw;
+		testVariable = 5;
+		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVariable == 10);
 	}
 
 	SECTION("ErrorHandling") {

From 8807772d134c04dc495627ebeef7d4f45cb31057 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:16:41 +0100
Subject: [PATCH 1191/1292] 100 % line coverage reached

---
 .../tests/datapoollocal/LocalPoolVariableTest.cpp     | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index e60d5a6b..b173089c 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -48,6 +48,17 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
 				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
 		CHECK(testVariable == 10);
+		CHECK(testVariable != testVariable2);
+		CHECK(testVariable2 < testVariable);
+		CHECK(testVariable2 < 10);
+		CHECK(testVariable > 5);
+		CHECK(testVariable > testVariable2);
+		variableRaw = static_cast<uint8_t>(testVariable2);
+		CHECK(variableRaw == 5);
+
+		CHECK(testVariable == 10);
+		testVariable = testVariable2;
+		CHECK(testVariable == 5);
 	}
 
 	SECTION("ErrorHandling") {

From db7d28f8526c7a6998f712b5ed4f904f757f011a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:32:33 +0100
Subject: [PATCH 1192/1292] test update

---
 datapoollocal/LocalPoolVariable.h             |   1 +
 datapoollocal/LocalPoolVariable.tpp           |  21 +++-
 unittest/internal/UnittDefinitions.h          |   1 +
 unittest/tests/action/TestActionHelper.cpp    |   2 +
 .../datapoollocal/LocalPoolVariableTest.cpp   |   2 +
 unittest/user/CMakeLists.txt                  | 108 ++++++++++++++++--
 unittest/user/unittest/core/CMakeLists.txt    |   6 +
 .../user/unittest/core/CatchDefinitions.cpp   |   3 +
 unittest/user/unittest/core/CatchFactory.cpp  |  22 +++-
 unittest/user/unittest/core/CatchRunner.cpp   |  13 +--
 unittest/user/unittest/core/CatchSetup.cpp    |  14 +--
 unittest/user/unittest/core/printChar.cpp     |   2 +-
 12 files changed, 164 insertions(+), 31 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 84be54b1..21ee2764 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -7,6 +7,7 @@
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 153a13d0..f35c8be2 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -35,8 +35,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+				"mode for read call." << std::endl;
+#else
+		fsfw::printWarning("LocalPoolVariable: Invalid read write "
+				"mode for read call.");
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -48,7 +51,11 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#endif
+#else
+		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
+				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
+				localPoolId);
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
 	this->value = *(poolEntry->address);
@@ -69,7 +76,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
 				 "mode for commit() call." << std::endl;
-#endif
+#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
@@ -80,7 +87,11 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				<< "object " << std::hex << std::setw(8) << std::setfill('0')
 				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
 				<< std::dec << " failed." << std::endl;
-#endif
+#else
+		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
+				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
+				localPoolId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
 	*(poolEntry->address) = this->value;
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index ea36fea4..d319f4bc 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -5,6 +5,7 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include <cstdint>
 #include <cstddef>
+#include <string>
 
 namespace tv {
 // POD test values
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3109eba1..3957bba2 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -7,6 +7,8 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <array>
+
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	ActionHelperOwnerMockBase testDhMock;
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index b173089c..cf4f4b6b 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -90,7 +90,9 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 
 		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
+#endif
 	}
 
 }
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index 6ec314c3..722cc424 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -13,7 +13,19 @@ cmake_minimum_required(VERSION 3.13)
 
 # set(CMAKE_VERBOSE TRUE)
 
-set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+option(TMTC_TEST "Build binary for manual or automatic TMTC tests" FALSE)
+option(GENERATE_COVERAGE 
+	"Specify whether coverage data is generated with GCOV" 
+	TRUE
+)
+
+if(TMTC_TEST)
+	set(LINK_CATCH2 FALSE)
+else()
+	set(LINK_CATCH2 TRUE)
+endif()
 
 # Tests can be built with the Host OSAL or with the Linux OSAL.
 if(NOT OS_FSFW)
@@ -53,6 +65,7 @@ set(FSFW_PATH fsfw)
 set(CATCH2_PATH Catch2)
 set(FSFW_TESTS_PATH fsfw/unittest)
 set(TEST_SETUP_PATH unittest)
+set(TMTC_TEST_PATH tests)
 
 # Analyse different OS and architecture/target options and
 # determine BSP_PATH
@@ -71,6 +84,15 @@ else()
 	endif()
 endif()
 
+if(GENERATE_COVERAGE)
+	list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/cmake-modules)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+    	include(CodeCoverage)
+    	# Add compile options on target base, we don't want coverage for Catch2
+    	# append_coverage_compiler_flags()
+   	endif()
+endif()
+
 set(FSFW_CONFIG_PATH testcfg)
 
 ################################################################################
@@ -82,10 +104,16 @@ add_executable(${TARGET_NAME})
 
 # Add subdirectories
 add_subdirectory(${FSFW_PATH})
-add_subdirectory(${CATCH2_PATH})
 add_subdirectory(${FSFW_CONFIG_PATH})
-add_subdirectory(${FSFW_TESTS_PATH})
-add_subdirectory(${TEST_SETUP_PATH})
+
+if(LINK_CATCH2)
+	add_subdirectory(${CATCH2_PATH})
+	add_subdirectory(${FSFW_TESTS_PATH})
+	add_subdirectory(${TEST_SETUP_PATH})
+else()
+	add_subdirectory(${TMTC_TEST_PATH})
+endif()
+
 
 ################################################################################
 # Post-Sources preparation
@@ -94,9 +122,74 @@ add_subdirectory(${TEST_SETUP_PATH})
 # Add libraries for all sources.
 target_link_libraries(${TARGET_NAME} PRIVATE
 	${LIB_FSFW_NAME} 
-	${CATCH2_TARGET}
 )
 
+if(LINK_CATCH2)
+	target_link_libraries(${TARGET_NAME} PRIVATE
+		${CATCH2_TARGET}
+	)
+endif()
+
+if(GENERATE_COVERAGE)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(CODE_COVERAGE_VERBOSE TRUE)
+    	include(CodeCoverage)
+    	
+    	# Remove quotes.
+    	separate_arguments(COVERAGE_COMPILER_FLAGS 
+    		NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+    	# Add compile options manually, we don't want coverage for Catch2
+    	target_compile_options(${TARGET_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+		# Exclude internal unittest from coverage for now.
+    	if(WIN32)
+			set(GCOVR_ADDITIONAL_ARGS 
+				"--exclude-throw-branches"
+				"--exclude-unreachable-branches"
+			)
+			set(COVERAGE_EXCLUDES
+				"/c/msys64/mingw64/*" "Catch2"
+				"${CMAKE_CURRENT_SOURCE_DIR}/fsfw/unittest/internal"
+			)
+		elseif(UNIX)
+			set(COVERAGE_EXCLUDES
+				"/usr/include/*" "/usr/bin/*" "Catch2/*"
+				"fsfw/unittest/internal/*"
+			)
+		endif()
+    	
+		target_link_options(${TARGET_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	target_link_options(${LIB_FSFW_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	
+		if(WIN32)
+			setup_target_for_coverage_gcovr_html(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+    	else()
+			setup_target_for_coverage_lcov(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+		endif()
+	endif()
+endif()
+
 # Add include paths for all sources.
 target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
@@ -147,8 +240,7 @@ if(NOT CMAKE_SIZE)
 	endif()
 endif()
 
-add_custom_command(
-   TARGET ${TARGET_NAME}
+add_custom_command(TARGET ${TARGET_NAME}
    POST_BUILD
    COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
    COMMAND echo "Target OSAL: ${OS_FSFW}"
@@ -156,7 +248,7 @@ add_custom_command(
    COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
 )
 
-include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()
 
 
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
index d78f45f1..0989926c 100644
--- a/unittest/user/unittest/core/CMakeLists.txt
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -5,3 +5,9 @@ target_sources(${TARGET_NAME} PRIVATE
 	CatchSetup.cpp
 	printChar.cpp
 )
+
+if(CUSTOM_UNITTEST_RUNNER)
+	target_sources(${TARGET_NAME} PRIVATE
+		CatchRunner.cpp
+	)
+endif()
\ No newline at end of file
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 00daf015..02a935d2 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
@@ -7,6 +8,8 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
+#else
+		fsfw::printError("Global object manager uninitialized");
 #endif
 		return nullptr;
 	}
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 3177212f..0597f08c 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -1,11 +1,15 @@
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include "CatchFactory.h"
 
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 #include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
 
 /**
  * @brief Produces system objects.
@@ -50,7 +54,23 @@ void Factory::produce(void) {
 }
 
 void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
 
+
diff --git a/unittest/user/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
index 35c53cd4..886d641f 100644
--- a/unittest/user/unittest/core/CatchRunner.cpp
+++ b/unittest/user/unittest/core/CatchRunner.cpp
@@ -1,17 +1,16 @@
 /**
- * @file 	CatchSource.cpp
+ * @file 	CatchRunner.cpp
  * @brief 	Source file to compile catch framework.
  * @details	All tests should be written in other files.
  * For eclipse console output, install ANSI Escape in Console
  * from the eclipse market place to get colored characters.
  */
 
-#ifndef NO_UNIT_TEST_FRAMEWORK
+#include <TestsConfig.h>
 
-#define CATCH_CONFIG_RUNNER
-#include <catch2/catch.hpp>
+#define CATCH_CONFIG_COLOUR_WINDOWS
 
-#if CUSTOM_UNITTEST_RUNNER == 0
+#include <catch2/catch_session.hpp>
 
 extern int customSetup();
 
@@ -25,7 +24,3 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
-#endif
-
-
-#endif
diff --git a/unittest/user/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
index c93cf032..bda31400 100644
--- a/unittest/user/unittest/core/CatchSetup.cpp
+++ b/unittest/user/unittest/core/CatchSetup.cpp
@@ -1,21 +1,20 @@
-#include <fsfw/unittest/core/CatchFactory.h>
+#include "CatchFactory.h"
 #include "CatchDefinitions.h"
-#include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include "../../objectmanager/ObjectManager.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 namespace sif {
 /* Set up output streams */
 ServiceInterfaceStream debug("DEBUG");
@@ -23,6 +22,7 @@ ServiceInterfaceStream info("INFO");
 ServiceInterfaceStream error("ERROR");
 ServiceInterfaceStream warning("WARNING");
 }
+#endif
 
 /* Global object manager */
 ObjectManagerIF *objectManager;
diff --git a/unittest/user/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
index 755a13b2..5d4f1b17 100644
--- a/unittest/user/unittest/core/printChar.cpp
+++ b/unittest/user/unittest/core/printChar.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/core/printChar.h>
+#include "printChar.h"
 #include <cstdio>
 
 void printChar(const char* character, bool errStream) {

From 91cf5f176400a12c18e66ef53bf7efe1fab9265f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 19:49:58 +0100
Subject: [PATCH 1193/1292] added way to completely disable printouts

---
 datapoollocal/LocalPoolVariable.tpp          | 15 +++++----
 serviceinterface/ServiceInterfacePrinter.cpp | 32 ++++++++++++++------
 serviceinterface/ServiceInterfacePrinter.h   |  2 ++
 unittest/internal/UnittDefinitions.cpp       |  6 ++--
 unittest/internal/UnittDefinitions.h         |  2 +-
 5 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index f35c8be2..f70e4e91 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -38,7 +38,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				"mode for read call." << std::endl;
 #else
 		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				"mode for read call.");
+				"mode for read call.\n\r");
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
@@ -53,8 +53,8 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
 #else
 		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
-				localPoolId);
+				"object 0x%08x and lp ID 0x%08x failed.\n\r",
+				hkManager->getOwner(), localPoolId);
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
@@ -75,7 +75,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVariable: Invalid read write "
-				 "mode for commit() call." << std::endl;
+				 "mode for commit call." << std::endl;
+#else
+		fsfw::printWarning("LocalPoolVariable: Invalid read write "
+				 "mode for commit call.\n\r");
 #endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
@@ -89,8 +92,8 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				<< std::dec << " failed." << std::endl;
 #else
 		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x08x failed.", hkManager->getOwner(),
-				localPoolId);
+				"object 0x%08x and lp ID 0x%08x failed.\n\r",
+				hkManager->getOwner(), localPoolId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return result;
 	}
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index e8eb498f..15e738a8 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,12 +6,14 @@
 #include <cstdarg>
 #include <cstdint>
 
-
 fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
-uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 bool consoleInitialized = false;
-#endif
+#endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
+
+
+#if FSFW_DISABLE_PRINTOUT == 0
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
@@ -81,13 +83,6 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     printf("%s", printBuffer);
 }
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
-	printLevel = printLevel_;
-}
-
-fsfw::PrintLevel fsfw::getPrintLevel() {
-	return printLevel;
-}
 
 void fsfw::printInfo(const char *fmt, ...) {
     va_list args;
@@ -116,3 +111,20 @@ void fsfw::printError(const char *fmt, ...) {
     fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
     va_end(args);
 }
+
+#else
+
+void fsfw::printInfo(const char *fmt, ...) {}
+void fsfw::printWarning(const char *fmt, ...) {}
+void fsfw::printDebug(const char *fmt, ...) {}
+void fsfw::printError(const char *fmt, ...) {}
+
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+
+void fsfw::setPrintLevel(PrintLevel printLevel_) {
+	printLevel = printLevel_;
+}
+
+fsfw::PrintLevel fsfw::getPrintLevel() {
+	return printLevel;
+}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 8b81ee7a..a60b6332 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,4 +1,6 @@
+#if FSFW_DISABLE_PRINTOUT == 0
 #include <stdio.h>
+#endif
 
 namespace fsfw {
 
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 7138e6c6..d20771a4 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -3,7 +3,9 @@
  ReturnValue_t unitt::put_error(std::string errorId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
-			<< errorId << "\n" << std::flush;
-#endif
+			<< errorId << std::endl;
+#else
+	fsfw::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index d319f4bc..3e14fec5 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -2,7 +2,7 @@
 #define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include <cstdint>
 #include <cstddef>
 #include <string>

From dacdfc62d3841a89be5aa4988e35784737027dd1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:14:23 +0100
Subject: [PATCH 1194/1292] a lot of bugfixes and important api change

---
 datapool/PoolDataSetBase.cpp                  | 34 ++++++----
 datapool/PoolDataSetBase.h                    | 23 ++++---
 datapool/PoolDataSetIF.h                      |  5 +-
 datapool/PoolEntry.cpp                        |  2 +
 datapool/ReadCommitIF.h                       | 11 ++--
 datapoollocal/LocalPoolDataSetBase.cpp        | 65 +++++++++++++++----
 datapoollocal/LocalPoolDataSetBase.h          | 21 +++++-
 datapoollocal/LocalPoolVariable.h             | 19 +++++-
 datapoollocal/LocalPoolVariable.tpp           | 19 ++++--
 datapoollocal/LocalPoolVector.h               | 14 ++--
 datapoollocal/LocalPoolVector.tpp             | 13 ++--
 devicehandlers/DeviceHandlerBase.cpp          |  3 +-
 events/EventManager.cpp                       |  8 ++-
 events/EventManager.h                         |  4 ++
 internalError/InternalErrorReporter.cpp       | 29 +++++----
 internalError/InternalErrorReporter.h         |  8 ++-
 ipc/MutexIF.h                                 |  2 +-
 osal/host/Clock.cpp                           |  4 +-
 osal/host/Mutex.cpp                           |  6 +-
 power/Fuse.cpp                                |  7 +-
 power/PowerSensor.cpp                         |  3 +-
 unittest/internal/osal/IntTestMutex.cpp       |  2 +-
 unittest/tests/datapoollocal/DataSetTest.cpp  | 21 ++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 39 +++++++++--
 .../datapoollocal/LocalPoolVariableTest.cpp   | 29 ++++++++-
 .../datapoollocal/LocalPoolVectorTest.cpp     | 16 +++++
 26 files changed, 314 insertions(+), 93 deletions(-)
 create mode 100644 unittest/tests/datapoollocal/DataSetTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVectorTest.cpp

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 5fb1c3c7..05797012 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -38,11 +38,12 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
+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(lockTimeout);
+		lockDataPool(timeoutType, lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
@@ -86,7 +87,8 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(mutexTimeout);
+			result = registeredVariables[count]->read(
+					MutexIF::TimeoutType::WAITING, mutexTimeout);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -99,25 +101,28 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
+		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit(lockTimeout);
+		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
 	}
 }
 
-void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(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
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(mutexTimeout);
+				registeredVariables[count]->commit(
+						MutexIF::TimeoutType::WAITING, mutexTimeout);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -128,16 +133,18 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(mutexTimeout);
+				result = registeredVariables[count]->commit(
+						MutexIF::TimeoutType::WAITING, mutexTimeout);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -160,7 +167,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 7c1d84a4..0528f40f 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -62,8 +62,9 @@ public:
 	 * - @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;
+	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
@@ -82,8 +83,9 @@ public:
 	 * 			- @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;
+	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.
@@ -97,8 +99,9 @@ public:
 	 * thread-safety. Default implementation is empty
 	 * @return Always returns -@c RETURN_OK
 	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
+	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
@@ -160,8 +163,12 @@ private:
 	uint32_t mutexTimeout = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+	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_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 99c06cfd..1f52871d 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -18,7 +18,10 @@ public:
      *          thread-safety
      * @return Lock operation result
      */
-    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    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
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 58375162..5f5f56f2 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -88,8 +88,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>;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index 0cdce371..efe51594 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit
@@ -10,8 +11,10 @@
 class ReadCommitIF {
 public:
 	virtual ~ReadCommitIF() {}
-	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
 
 protected:
 
@@ -19,11 +22,11 @@ protected:
 	//! members with commit and read semantics where the lock is only necessary
 	//! once.
 	virtual ReturnValue_t readWithoutLock()  {
-		return read(20);
+		return read(MutexIF::TimeoutType::WAITING, 20);
 	}
 
 	virtual ReturnValue_t commitWithoutLock() {
-		return commit(20);
+		return commit(MutexIF::TimeoutType::WAITING, 20);
 	}
 };
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dbe34dfd..af492146 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,6 @@
 #include "LocalPoolDataSetBase.h"
+
+#include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -15,7 +17,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
-#endif
+#else
+        fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
     hkManager = hkOwner->getHkManagerHandle();
@@ -44,13 +49,26 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     mutex = MutexFactory::instance()->createMutex();
 }
 
+LocalPoolDataSetBase::LocalPoolDataSetBase(
+		PoolVariableIF **registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool protectFunctions):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(protectFunctions) {
+	    mutex = MutexFactory::instance()->createMutex();
+	}
+
+}
+
+
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
 }
 
-ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(
+		MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
 	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+	    MutexIF* poolMutex = hkManager->getMutexHandle();
+	    return poolMutex->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -150,9 +168,12 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-#endif
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		<< "Serialization error!" << std::endl;
+#else
+            fsfw::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		"Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
         }
     }
@@ -211,8 +232,11 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
+#else
+        fsfw::printWarning("LocalPoolDataSetBase::bitSetter: "
+        		"Invalid position!\n\r");
 #endif
         return;
     }
@@ -244,14 +268,19 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	if(mutex == nullptr) {
+		this->changed = changed;
+		return;
+	}
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
+	if(mutex == nullptr) {
+		return changed;
+	}
+    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     return changed;
 }
 
@@ -273,18 +302,22 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
+	if(mutex == nullptr) {
+		return this->valid;
+	}
     MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
+	mutex->lockMutex(timeoutType, mutexTimeout);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
         }
     }
     this->valid = valid;
+    mutex->unlockMutex();
 }
 
 void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
@@ -292,3 +325,9 @@ void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
 	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
 			mutexTimeout);
 }
+
+void LocalPoolDataSetBase::setDataSetMutexTimeout(
+		MutexIF::TimeoutType timeoutType, uint32_t mutexTimeout) {
+	this->timeoutType = timeoutType;
+	this->mutexTimeout = mutexTimeout;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d9b6a221..b44f607f 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -67,6 +67,15 @@ public:
 	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
+	/**
+	 * Simple constructor, if the dataset is not owner permanently by
+	 * a class with a HK manager.
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
+	 */
+	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables, bool protectFunctions = true);
+
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -87,6 +96,9 @@ public:
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
 			uint32_t mutexTimeout = 20);
 
+	void setDataSetMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t mutexTimeout);
+
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -138,7 +150,12 @@ public:
 
 protected:
 	sid_t sid;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
+	/**
+	 * This mutex is required because the dataset can potentially be accessed
+	 * by multiple threads for information like change status or validity.
+	 */
 	MutexIF* mutex = nullptr;
 
 	bool diagnostic = false;
@@ -183,7 +200,9 @@ protected:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) override;
+
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 21ee2764..c81967a1 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -106,7 +106,9 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -116,8 +118,21 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit function can be used to set the pool variable valid
+	 * 			as well.
+	 * @param setValid
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 	LocalPoolVariable<T> &operator=(const T& newValue);
 	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index f70e4e91..9387acc5 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -24,9 +24,9 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
@@ -64,9 +64,16 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(setValid);
+	return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 58face3c..773a52cc 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -7,7 +7,7 @@
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 
 /**
@@ -123,7 +123,9 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -133,7 +135,9 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
 protected:
 	/**
@@ -157,12 +161,12 @@ protected:
 
 private:
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
-
+#endif
 
 };
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a010a8bb..6af80de6 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -24,9 +24,9 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -59,9 +59,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -153,6 +152,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {
@@ -166,5 +166,6 @@ inline std::ostream& operator<< (std::ostream &out,
     out << "]";
     return out;
 }
+#endif
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1af6932a..580f8c0d 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -229,7 +229,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			thermalSet->commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setValid(true);
+			thermalSet->commit();
 		}
 
 	}
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 65e19d10..e25e574f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -162,9 +162,15 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(timeoutType, timeoutMs);
 }
 
 void EventManager::unlockMutex() {
 	mutex->unlockMutex();
 }
+
+void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index c6bd07be..abce9b8b 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -29,6 +29,8 @@ public:
 	EventManager(object_id_t setObjectId);
 	virtual ~EventManager();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
 	MessageQueueId_t getEventReportQueue();
 
 	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
@@ -51,6 +53,8 @@ protected:
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool factoryBackend;
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 48b6f851..6842da8e 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -23,7 +23,7 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
 }
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
+    internalErrorDataset.read(timeoutType, timeoutMs);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
@@ -46,8 +46,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	internalErrorDataset.queueHits.value += newQueueHits;
 	internalErrorDataset.storeHits.value += newStoreHits;
 	internalErrorDataset.tmHits.value += newTmHits;
-
-	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+	internalErrorDataset.setValidity(true, true);
+	internalErrorDataset.commit(timeoutType, timeoutMs);
 
 	poolManager.performHkOperation();
 
@@ -69,7 +69,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -78,21 +78,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -101,14 +101,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -119,7 +119,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -128,14 +128,14 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
 	mutex->unlockMutex();
 }
@@ -190,3 +190,8 @@ ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
     return poolManager.initializeAfterTaskCreation();
 }
 
+void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8d33c06e..c85057d6 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -22,7 +22,6 @@ class InternalErrorReporter: public SystemObject,
 		public InternalErrorReporterIF,
 		public HasLocalDataPoolIF {
 public:
-    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
 
 	InternalErrorReporter(object_id_t setObjectId,
 	        uint32_t messageQueueDepth = 5);
@@ -34,6 +33,9 @@ public:
 	 */
 	void setDiagnosticPrintout(bool enable);
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+
 	virtual ~InternalErrorReporter();
 
     virtual object_id_t getObjectId() const override;
@@ -61,7 +63,11 @@ protected:
 	LocalDataPoolManager poolManager;
 
 	PeriodicTaskIF* executingTask = nullptr;
+
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
+
 	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 5673e4d7..084b702b 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -14,7 +14,7 @@ public:
     /**
      * Different types of timeout for the mutex lock.
      */
-    enum TimeoutType {
+    enum class TimeoutType {
         POLLING, //!< If mutex is not available, return immediately
         WAITING, //!< Wait a specified time for the mutex to become available
         BLOCKING //!< Block indefinitely until the mutex becomes available.
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 2bc78785..88bf51d2 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -202,7 +202,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -217,7 +217,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index ad8873df..892028b2 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,16 +4,16 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutType == MutexIF::BLOCKING) {
+	if(timeoutType == TimeoutType::BLOCKING) {
 		mutex.lock();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutType == MutexIF::POLLING) {
+	else if(timeoutType == TimeoutType::POLLING) {
 		if(mutex.try_lock()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			return HasReturnvaluesIF::RETURN_OK;
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 1c30d83f..b6e0a7f1 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -65,8 +65,8 @@ ReturnValue_t Fuse::check() {
 	set.read();
 	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
 		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
+		set.setValidity(false, true);
+		return set.commit();
 	}
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	checkFuseState();
@@ -206,7 +206,8 @@ float Fuse::getPower() {
 
 void Fuse::setDataPoolEntriesInvalid() {
 	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	set.setValidity(false, true);
+	set.commit();
 }
 
 ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 1ef041e3..fb181d9f 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -97,7 +97,8 @@ void PowerSensor::checkCommandQueue() {
 
 void PowerSensor::setDataPoolEntriesInvalid() {
 	powerSensorSet.read();
-	powerSensorSet.commit(PoolVariableIF::INVALID);
+	powerSensorSet.setValidity(false, true);
+	powerSensorSet.commit();
 }
 
 float PowerSensor::getPower() {
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3316de74..2a1584b8 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -13,7 +13,7 @@
 void testmutex::testMutex() {
 	std::string id = "[testMutex]";
 	MutexIF* mutex = MutexFactory::instance()->createMutex();
-	auto result = mutex->lockMutex(MutexIF::POLLING);
+	auto result = mutex->lockMutex(MutexIF::TimeoutType::POLLING);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		unitt::put_error(id);
 	}
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
new file mode 100644
index 00000000..ccb7603d
--- /dev/null
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -0,0 +1,21 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		//StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>()
+	}
+}
+
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 40f657be..c665cb7f 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -4,6 +4,7 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <testcfg/objects/systemObjectList.h>
 
@@ -11,9 +12,12 @@ namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
 static constexpr lp_id_t floatVarId = 1;
 static constexpr lp_id_t uint32VarId = 2;
+static constexpr lp_id_t uint16Vec3Id = 3;
+static constexpr lp_id_t int64Vec2Id = 4;
 }
 
 
+
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
@@ -31,12 +35,19 @@ public:
 	}
 
 	ReturnValue_t initializeHkManager() {
-		return hkManager.initialize(messageQueue);
-
+		if(not initialized) {
+			initialized = true;
+			return hkManager.initialize(messageQueue);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	ReturnValue_t initializeHkManagerAfterTaskCreation() {
-		return hkManager.initializeAfterTaskCreation();
+		if(not initializedAfterTaskCreation) {
+			initializedAfterTaskCreation = true;
+			return hkManager.initializeAfterTaskCreation();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 
 	/** Command queue for housekeeping messages. */
@@ -44,12 +55,22 @@ public:
 		return messageQueue->getId();
 	}
 
+	// This is called by initializeAfterTaskCreation of the HK manager.
 	virtual ReturnValue_t initializeLocalDataPool(
 	        LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) {
 		// Default initialization empty for now.
-		localDataPoolMap.emplace(lpool::uint8VarId, new PoolEntry<uint8_t>({0}));
-		localDataPoolMap.emplace(lpool::floatVarId, new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint8VarId,
+				new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId,
+				new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint32VarId,
+				new PoolEntry<uint32_t>({0}));
+
+		localDataPoolMap.emplace(lpool::uint16Vec3Id,
+				new PoolEntry<uint16_t>({0, 0, 0}));
+		localDataPoolMap.emplace(lpool::int64Vec2Id,
+				new PoolEntry<int64_t>({0, 0}));
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
@@ -77,9 +98,17 @@ private:
 	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
 	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
+	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
+			lpool::uint16Vec3Id);
+	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
+			lpool::int64Vec2Id);
+
 	MessageQueueIF* messageQueue = nullptr;
 	LocalDataPoolManager hkManager;
 
+	bool initialized = false;
+	bool initializedAfterTaskCreation = false;
+
 };
 
 #endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index cf4f4b6b..eb5abf35 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -6,9 +6,11 @@
 
 
 TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
-	LocalPoolOwnerBase poolOwner(objects::TEST_LOCAL_POOL_OWNER_BASE);
-	REQUIRE(poolOwner.initializeHkManager() == retval::CATCH_OK);
-	REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation()
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
 
 	SECTION("Basic Tests") {
@@ -26,6 +28,18 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
 
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+
+		testVariable.setDataPoolId(22);
+		CHECK(testVariable.getDataPoolId() == 22);
+		testVariable.setDataPoolId(lpool::uint8VarId);
+
+		testVariable.setChanged(true);
+		CHECK(testVariable.hasChanged());
+		testVariable.setChanged(false);
+
 		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
 				lpool::uint8VarId);
 		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
@@ -93,6 +107,15 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
 #endif
+
+		// for code coverage. If program does not crash -> OK
+		lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
+				0xffffffff, lpool::uint8VarId);
+		gp_id_t globPoolId(0xffffffff,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+		lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
+				lpool::uint8VarId);
 	}
 
 }
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
new file mode 100644
index 00000000..c86a2681
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -0,0 +1,16 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+}
+
+

From 2b287dfc3ac227af78f68a003948b92656cd4005 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:33:54 +0100
Subject: [PATCH 1195/1292] freertos and pool read helper fix

---
 datapoollocal/PoolReadHelper.h | 9 ++++++---
 osal/FreeRTOS/Clock.cpp        | 4 ++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index a059685b..c89fff98 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -9,10 +9,12 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+	PoolReadHelper(ReadCommitIF* readObject,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t mutexTimeout = 20):
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
-			readResult = readObject->read(mutexTimeout);
+			readResult = readObject->read(timeoutType, mutexTimeout);
 #if FSFW_PRINT_VERBOSITY_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
@@ -27,7 +29,7 @@ public:
 
 	~PoolReadHelper() {
 		if(readObject != nullptr) {
-			readObject->commit(mutexTimeout);
+			readObject->commit(timeoutType, mutexTimeout);
 		}
 
 	}
@@ -35,6 +37,7 @@ public:
 private:
 	ReadCommitIF* readObject = nullptr;
 	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
 };
 
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d3f4e68e..9c0a0267 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -163,7 +163,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -178,7 +178,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

From fcb33201a4c40ae868d82fcff1060fc6fdf2c342 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:45:35 +0100
Subject: [PATCH 1196/1292] fixed linux osal

---
 osal/linux/Clock.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 54dad839..35cbfae0 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -182,7 +182,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -197,7 +197,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -209,13 +209,13 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex == nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}

From 8aaf45049faa4677208d3486ce4e6c2946416ee2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 6 Jan 2021 21:49:40 +0100
Subject: [PATCH 1197/1292] major bugfix in rtems osal

---
 osal/rtems/Mutex.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 71c5782f..7dd512fa 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -30,11 +30,11 @@ Mutex::~Mutex() {
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
 	rtems_status_code status = RTEMS_INVALID_ID;
-	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+	if(timeoutType == MutexIF::TimeoutType::BLOCKING) {
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
-	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+	else if(timeoutType == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);

From 007526c0502d7db92d37dcdc080bf4c08c5f9030 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 19:10:07 +0100
Subject: [PATCH 1198/1292] new f unctions for read error reporting, bugfix

---
 datapool/PoolVariableIF.h            |  1 +
 datapoollocal/LocalDataPoolManager.h | 11 +++++-
 datapoollocal/LocalPoolVariable.h    |  1 +
 datapoollocal/LocalPoolVariable.tpp  | 58 ++++++++++++++++++----------
 4 files changed, 48 insertions(+), 23 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9740fc12..444e19d0 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -25,6 +25,7 @@ class PoolVariableIF : public SerializeIF,
 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 ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90c..bcb8f0af 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -3,6 +3,7 @@
 
 #include "HasLocalDataPoolIF.h"
 
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
@@ -378,6 +379,9 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
 		        "not found." << std::endl;
+#else
+		fsfw::printWarning("HousekeepingManager::fechPoolEntry: Pool entry "
+		        "not found.");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
@@ -385,8 +389,11 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
+		sif::warning << "HousekeepingManager::fetchPoolEntry:"
+				" Pool entry type conflict." << std::endl;
+#else
+		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
+				" Pool entry type conflict.");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c81967a1..ca0aede9 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -181,6 +181,7 @@ protected:
 #endif
 
 private:
+	void reportReadCommitError(bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 9387acc5..c20e9230 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -46,18 +46,17 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK or poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolPoolVariable: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#else
-		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x%08x failed.\n\r",
-				hkManager->getOwner(), localPoolId);
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(true, ownerObjectId, localPoolId);
 		return result;
 	}
+
+	if(poolEntry->address == nullptr) {
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(true, ownerObjectId, localPoolId);
+		return PoolVariableIF::INVALID_POOL_ENTRY;
+	}
+
 	this->value = *(poolEntry->address);
 	this->valid = poolEntry->valid;
 	return RETURN_OK;
@@ -91,19 +90,12 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolPoolVariable: Read of local pool variable of "
-				<< "object " << std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::endl;
-#else
-		fsfw::printError("LocalPoolVariable: Read of local pool variable of "
-				"object 0x%08x and lp ID 0x%08x failed.\n\r",
-				hkManager->getOwner(), localPoolId);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+	if(result != RETURN_OK or poolEntry == nullptr) {
+		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError(false, ownerObjectId, localPoolId);
 		return result;
 	}
+
 	*(poolEntry->address) = this->value;
 	poolEntry->valid = this->valid;
 	return RETURN_OK;
@@ -203,4 +195,28 @@ inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
+template<typename T>
+inline void LocalPoolVariable<T>::reportReadCommitError(bool read,
+		object_id_t objectId, lp_id_t lpId) {
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << "PoolPoolVariable: " << type << " of local pool "
+			<<"variable of object " << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << " and lp ID 0x" << lpId
+			<< std::dec << " failed." << std::endl;
+#else
+	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
+			"object 0x%08x and lp ID 0x%08x failed.\n\r",
+			type, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+}
+
+
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */

From 3be51762cccb8964ab3d19e379f1d427a99710b7 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:23:23 +0100
Subject: [PATCH 1199/1292] improved error handling significantly

---
 datapoollocal/LocalPoolObjectBase.cpp | 41 +++++++++++++++++++++++++++
 datapoollocal/LocalPoolObjectBase.h   |  2 ++
 datapoollocal/LocalPoolVariable.h     |  3 --
 datapoollocal/LocalPoolVariable.tpp   | 41 +++++++--------------------
 datapoollocal/LocalPoolVector.tpp     | 23 +++++++--------
 5 files changed, 64 insertions(+), 46 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 4b57dede..b84569b8 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -79,3 +79,44 @@ bool LocalPoolObjectBase::hasChanged() const {
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 	this->readWriteMode = newReadWriteMode;
 }
+
+void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
+		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+#if FSFW_DISABLE_PRINTOUT == 0
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+	const char* errMsg = nullptr;
+	if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+		errMsg = "Pool entry not found";
+	}
+	else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+		errMsg = "Pool entry type conflict";
+	}
+	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+		errMsg = "Pool variable wrong read-write mode";
+	}
+	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+		errMsg = "Pool entry invalid";
+	}
+	else {
+		errMsg = "Unknown error code";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << variableType << ": " << type << " call | " << errMsg
+			<< " | Owner: " << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << " LPID: 0x" << lpId
+			<< std::dec << std::endl;
+#else
+	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
+			"object 0x%08x and lp ID 0x%08x failed.\n\r",
+			type, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 7165fc24..25ca594d 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -56,6 +56,8 @@ protected:
     //! @brief  Pointer to the class which manages the HK pool.
     LocalDataPoolManager* hkManager;
 
+	void reportReadCommitError(const char* variableType,
+			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index ca0aede9..22019c2f 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -179,9 +179,6 @@ protected:
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
 #endif
-
-private:
-	void reportReadCommitError(bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index c20e9230..4d472c31 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -45,16 +45,20 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
+	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(true, ownerObjectId, localPoolId);
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
 
+	// Actually this should never happen..
 	if(poolEntry->address == nullptr) {
+		result = PoolVariableIF::INVALID_POOL_ENTRY;
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(true, ownerObjectId, localPoolId);
-		return PoolVariableIF::INVALID_POOL_ENTRY;
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
+		return result;
 	}
 
 	this->value = *(poolEntry->address);
@@ -90,9 +94,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
+	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError(false, ownerObjectId, localPoolId);
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
 
@@ -195,28 +200,4 @@ inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
-template<typename T>
-inline void LocalPoolVariable<T>::reportReadCommitError(bool read,
-		object_id_t objectId, lp_id_t lpId) {
-	const char* type = nullptr;
-	if(read) {
-		type = "read";
-	}
-	else {
-		type = "commit";
-	}
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "PoolPoolVariable: " << type << " of local pool "
-			<<"variable of object " << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << " and lp ID 0x" << lpId
-			<< std::dec << " failed." << std::endl;
-#else
-	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
-			"object 0x%08x and lp ID 0x%08x failed.\n\r",
-			type, objectId, lpId);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-}
-
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 6af80de6..99e37a87 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -44,12 +44,9 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << "and lp ID 0x" << localPoolId
-				<< std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
 	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
@@ -69,19 +66,19 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit() call." << std::endl;
+				"mode for commit call." << std::endl;
+#else
+		sif::warning << "LocalPoolVector: Invalid read write "
+				"mode for commit call." << std::endl;
 #endif
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
-				<< std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
 	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());

From 44a5430555766db0d6bae8a1dca7221c122c80a9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:28:03 +0100
Subject: [PATCH 1200/1292] pool vector improvements

---
 datapoollocal/LocalPoolVector.tpp | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 99e37a87..88ba084a 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,10 +32,10 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -64,20 +64,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit call." << std::endl;
-#else
-		sif::warning << "LocalPoolVector: Invalid read write "
-				"mode for commit call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
 				localPoolId);
 		return result;
 	}

From d3fbe4a3b96184b1f1620041fd7f433cf902b56e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:29:38 +0100
Subject: [PATCH 1201/1292] local pool variable error handling improved

---
 datapoollocal/LocalPoolVariable.tpp | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 4d472c31..3cf0fc84 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,13 +33,10 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVariable: Invalid read write "
-				"mode for read call." << std::endl;
-#else
-		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				"mode for read call.\n\r");
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
@@ -83,13 +80,10 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVariable: Invalid read write "
-				 "mode for commit call." << std::endl;
-#else
-		fsfw::printWarning("LocalPoolVariable: Invalid read write "
-				 "mode for commit call.\n\r");
-#endif  /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;

From d3405ee34063eca17a529dcf521ff860d91e5b50 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 7 Jan 2021 20:30:52 +0100
Subject: [PATCH 1202/1292] whitespace

---
 datapoollocal/LocalPoolVariable.tpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 3cf0fc84..d9d45d38 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -86,6 +86,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
+
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {

From c1c331e29ef4501d923830cc38a3179d7d7b6332 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:10:10 +0100
Subject: [PATCH 1203/1292] fixed vector test

---
 datapool/PoolEntry.cpp                        | 14 +++---------
 datapool/PoolEntry.h                          |  8 +++----
 datapoollocal/LocalPoolVector.h               |  8 +++++++
 datapoollocal/LocalPoolVector.tpp             |  7 ++++++
 osal/host/Mutex.h                             |  1 -
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 .../datapoollocal/LocalPoolVectorTest.cpp     | 22 +++++++++++++++++++
 7 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 5f5f56f2..d21cf2ec 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -6,27 +6,19 @@
 #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(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){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		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) {
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 033db40d..83f7fc50 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -43,16 +43,16 @@ public:
 	 * corresponding length should be passed too, otherwise a zero
 	 * initialization will be performed with the given setLength.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
-	 * initialize the two entries to zero.
+	 * 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 setLength
 	 * Defines the array length of this entry. Should be equal to the
 	 * intializer list length.
 	 * @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.
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 773a52cc..ce3b1a14 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -139,6 +139,14 @@ public:
 			MutexIF::TimeoutType::WAITING,
 			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit call also sets the validity of the pool entry.
+	 * @details
+	 */
+	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 88ba084a..ce68982b 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -54,6 +54,13 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	return RETURN_OK;
 }
 
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(valid);
+	return commit(timeoutType, timeoutMs);
+}
+
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index c0fa19b7..0bd93c8a 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -22,7 +22,6 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index 569a8d5f..9d828de5 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -1,3 +1,4 @@
 target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index c86a2681..188011df 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -11,6 +11,28 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
 	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		// very basic test.
+		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		CHECK(testVector.read() == retval::CATCH_OK);
+		testVector.value[0] = 5;
+		testVector.value[1] = 232;
+		testVector.value[2] = 32023;
+
+		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+		CHECK(testVector.isValid());
+
+		testVector.value[0] = 0;
+		testVector.value[1] = 0;
+		testVector.value[2] = 0;
+
+		CHECK(testVector.read() == retval::CATCH_OK);
+		CHECK(testVector.value[0] == 5);
+		CHECK(testVector.value[1] == 232);
+		CHECK(testVector.value[2] == 32023);
+	}
 }
 
 

From 8e3f4c81a5d0db9709052012e71824ca019938b9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:20:39 +0100
Subject: [PATCH 1204/1292] pool entry doc correction

---
 datapool/PoolEntry.h | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 83f7fc50..d3d4cd6d 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -35,19 +35,17 @@ 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 a pool entry of a vector with two entries to 0.
-	 * @param setLength
-	 * Defines the array length of this entry. Should be equal to the
-	 * intializer list length.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */

From 41d8cbda5597c61aac6c965cc14f4fe571fe3263 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 00:22:04 +0100
Subject: [PATCH 1205/1292] small form changes

---
 datapool/PoolEntry.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index d3d4cd6d..aecfce94 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -64,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;
 
 	/**

From 4255176b5c499d3be11947f8b77d9bbcc21bb12c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 01:49:00 +0100
Subject: [PATCH 1206/1292] more tests, minor bugfix

---
 datapoollocal/LocalPoolVector.h               |  5 +--
 datapoollocal/LocalPoolVector.tpp             | 18 ++++++----
 .../datapoollocal/LocalPoolVectorTest.cpp     | 34 ++++++++++++++++++-
 3 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index ce3b1a14..a28fe327 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -100,8 +100,8 @@ public:
 		return vectorSize;
 	}
 
-	T& operator [](int i);
-	const T &operator [](int i) const;
+	T& operator [](size_t i);
+	const T &operator [](size_t i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t maxSize,
@@ -126,6 +126,7 @@ public:
 	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
 			MutexIF::TimeoutType::WAITING,
 			uint32_t timeoutMs = 20) override;
+
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index ce68982b..6612a491 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -91,8 +91,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 }
 
 template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
-	if(i <= vectorSize) {
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
@@ -100,13 +100,16 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n\r");
 #endif
-	return value[i];
+	return value[vectorSize];
 }
 
 template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
-	if(i <= vectorSize) {
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
@@ -114,8 +117,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n\r");
 #endif
-	return value[i];
+	return value[vectorSize];
 }
 
 template<typename T, uint16_t vectorSize>
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 188011df..7e40e898 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -16,7 +16,7 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		// very basic test.
 		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
-		CHECK(testVector.read() == retval::CATCH_OK);
+		REQUIRE(testVector.read() == retval::CATCH_OK);
 		testVector.value[0] = 5;
 		testVector.value[1] = 232;
 		testVector.value[2] = 32023;
@@ -32,6 +32,38 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		CHECK(testVector.value[0] == 5);
 		CHECK(testVector.value[1] == 232);
 		CHECK(testVector.value[2] == 32023);
+
+		CHECK(testVector[0] == 5);
+
+		// This is invalid access, so the last value will be set instead.
+		// (we can't throw exceptions)
+		testVector[4] = 12;
+		CHECK(testVector[3] == 12);
+		CHECK(testVector.commit() == retval::CATCH_OK);
+
+		// Use read-only reference.
+		const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+		uint16_t valueOne = roTestVec[0];
+		CHECK(valueOne == 5);
+
+		uint16_t lastVal = roTestVec[25];
+		CHECK(lastVal == 12);
+	}
+
+	SECTION("ErrorHandling") {
+		// not try to use a local pool variable which does not exist
+		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVector.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+		REQUIRE(invalidVector.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(invalidVector2.read() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
 	}
 }
 

From 2ef3e0aa7b502b5ac1d40057a4fdc9b324af9fcb Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 02:06:27 +0100
Subject: [PATCH 1207/1292] added option to add CR for printf support

---
 datapoollocal/LocalDataPoolManager.h         |  8 ++++----
 datapoollocal/LocalPoolObjectBase.cpp        | 11 +++++------
 datapoollocal/LocalPoolVector.tpp            | 12 ++++++------
 serviceinterface/ServiceInterfacePrinter.cpp | 10 +++++++++-
 serviceinterface/ServiceInterfacePrinter.h   |  2 ++
 5 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index bcb8f0af..7fa480cb 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -377,11 +377,11 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
+		sif::warning << "HousekeepingManager::fetchPoolEntry: Pool entry "
 		        "not found." << std::endl;
 #else
-		fsfw::printWarning("HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found.");
+		fsfw::printWarning("HousekeepingManager::fetchPoolEntry: Pool entry "
+		        "not found.\n");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
@@ -393,7 +393,7 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 				" Pool entry type conflict." << std::endl;
 #else
 		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict.");
+				" Pool entry type conflict.\n");
 #endif
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index b84569b8..bb7822da 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -110,13 +110,12 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::warning << variableType << ": " << type << " call | " << errMsg
-			<< " | Owner: " << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << " LPID: 0x" << lpId
-			<< std::dec << std::endl;
+			<< " | Owner: 0x" << std::hex << std::setw(8)
+			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
+			<< std::endl;
 #else
-	fsfw::printWarning("LocalPoolVariable: %s of local pool variable of "
-			"object 0x%08x and lp ID 0x%08x failed.\n\r",
-			type, objectId, lpId);
+	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+			variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 6612a491..94f3916e 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -98,11 +98,11 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n\r");
+	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
 	return value[vectorSize];
 }
@@ -115,11 +115,11 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printError("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n\r");
+	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
 	return value[vectorSize];
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index 15e738a8..cb3a958d 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -10,7 +10,7 @@ fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-
+bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
@@ -80,6 +80,10 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
     len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
+    if(addCrAtEnd) {
+    	len += sprintf(bufferPosition + len, "\r");
+    }
+
     printf("%s", printBuffer);
 }
 
@@ -105,6 +109,10 @@ void fsfw::printDebug(const char *fmt, ...) {
     va_end(args);
 }
 
+void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
+	addCrAtEnd = addCrAtEnd_;
+}
+
 void fsfw::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index a60b6332..1f82ba98 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -16,6 +16,8 @@ enum class PrintLevel {
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
+void setToAddCrAtEnd(bool addCrAtEnd_);
+
 /**
  * These functions can be used like the C stdio printf and forward the
  * supplied formatted string arguments to a printf function.

From 3b39c6b6e26fd523b732b14bf00c4c5933cf0ea3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 02:07:37 +0100
Subject: [PATCH 1208/1292] defaultcfg update

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 261e3d6d..e251729c 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,8 +9,7 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
+//! More FSFW related printouts. Useful for development.
 #define FSFW_ENHANCED_PRINTOUT		0
 
 //! Can be used to completely disable printouts, even the C stdio ones.

From 5a8647d36701b9eda4d6b6a29f2d83dd9b5eeeab Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 13:40:13 +0100
Subject: [PATCH 1209/1292] better returnvalues etc.

---
 datapool/PoolEntry.cpp                 | 26 +++++++++++++------
 datapool/PoolEntry.h                   | 35 ++++++++++++++++----------
 datapoollocal/LocalDataPoolManager.cpp |  6 ++---
 datapoollocal/LocalDataPoolManager.h   | 10 +++++---
 datapoollocal/LocalPoolVariable.tpp    | 22 ++++++++--------
 datapoollocal/LocalPoolVector.tpp      |  8 +++---
 globalfunctions/arrayprinter.cpp       | 10 +++++++-
 7 files changed, 74 insertions(+), 43 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index d21cf2ec..1e99a28c 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,6 +1,6 @@
 #include "PoolEntry.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
 #include <cstring>
 #include <algorithm>
@@ -62,14 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	else {
+		validString = "Invalid";
+	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-#endif
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << std::dec << std::endl;
+	 sif::info << "PoolEntry information." << std::endl;
+	 sif::info << "PoolEntry validity: " << validString << std::endl;
+#else
+	 fsfw::printInfo("PoolEntry information.\n");
+	 fsfw::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>
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index aecfce94..30940320 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -80,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();
 	/**
@@ -121,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 /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 24516aad..db5cd5dd 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -213,7 +213,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+            return POOLOBJECT_NOT_FOUND;
         }
 
         if (not poolObj->hasChanged()) {
@@ -249,7 +249,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+            return DATASET_NOT_FOUND;
         }
 
         if(not dataSet->hasChanged()) {
@@ -618,7 +618,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
                 << " Set ID not found or dataset not assigned!" << std::endl;
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
+        return DATASET_NOT_FOUND;
     }
 
     store_address_t storeId;
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 7fa480cb..098158da 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,11 +56,13 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0);
 
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
+    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
 
     /**
      * This constructor is used by a class which wants to implement
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index d9d45d38..ef94b620 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -50,16 +50,16 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	}
 
 	// Actually this should never happen..
-	if(poolEntry->address == nullptr) {
-		result = PoolVariableIF::INVALID_POOL_ENTRY;
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+//	if(poolEntry->address == nullptr) {
+//		result = PoolVariableIF::INVALID_POOL_ENTRY;
+//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+//		reportReadCommitError("LocalPoolVariable", result,
+//				false, ownerObjectId, localPoolId);
+//		return result;
+//	}
 
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
+	this->value = *(poolEntry->getDataPtr());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
@@ -96,8 +96,8 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 		return result;
 	}
 
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
+	*(poolEntry->getDataPtr()) = this->value;
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 94f3916e..a0e32f62 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -49,8 +49,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 				localPoolId);
 		return result;
 	}
-	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
-	this->valid = poolEntry->valid;
+	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
@@ -85,8 +85,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 				localPoolId);
 		return result;
 	}
-	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
-	poolEntry->valid = this->valid;
+	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c273b250..ebf21bb8 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,5 +1,5 @@
 #include "arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <bitset>
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
@@ -9,6 +9,8 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#else
+	fsfw::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
@@ -37,6 +39,8 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -54,6 +58,8 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -65,5 +71,7 @@ void arrayprinter::printBin(const uint8_t *data, size_t size) {
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#else
+    // how much memory to reserve for printout?
 #endif
 }

From f2ecd6d740763e55e682c5892b8ad3b0df74e627 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 15:10:33 +0100
Subject: [PATCH 1210/1292] revamed and imroved error handling

---
 datapoollocal/LocalDataPoolManager.cpp | 187 ++++++++++++++++---------
 datapoollocal/LocalDataPoolManager.h   |  11 +-
 2 files changed, 131 insertions(+), 67 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index db5cd5dd..e5ee499c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -3,6 +3,7 @@
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 
@@ -21,19 +22,17 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Invalid supplied owner!" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Invalid supplied owner");
         return;
     }
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Could not create mutex." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not create mutex");
     }
 
     hkQueue = queueToUse;
@@ -43,21 +42,18 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
-                << "queue invalid!" << std::dec << std::endl;
-#endif
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ": Could not "
-                << "set IPC store." <<std::dec << std::endl;
-#endif
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
     }
 
@@ -69,11 +65,9 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                    << "Default HK destination object is invalid!" << std::endl;
-#endif
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::ERROR_TYPE,
+        			"initialize", QUEUE_OR_DESTINATION_INVALID);
+            return QUEUE_OR_DESTINATION_INVALID;
         }
     }
 
@@ -95,10 +89,10 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         }
         return result;
     }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HousekeepingManager: The map should only be initialized "
-            << "once!" << std::endl;
-#endif
+
+	printWarningOrError(ErrorTypes::WARNING_TYPE,
+			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -163,7 +157,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+            return POOLOBJECT_NOT_FOUND;
         }
         if(poolObj->hasChanged()) {
             // prepare and send update notification.
@@ -183,7 +179,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationUpdate", DATASET_NOT_FOUND);
+            return DATASET_NOT_FOUND;
         }
         if(dataSet->hasChanged()) {
             // prepare and send update notification
@@ -213,6 +211,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
 
@@ -249,6 +249,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
 
@@ -351,11 +353,9 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
 
     struct HkReceiver hkReceiver;
@@ -383,11 +383,9 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
 
     struct HkReceiver hkReceiver;
@@ -591,10 +589,8 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "HousekeepingManager::fechPoolEntry:"
-                << " Pool entry not found." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE, "printPoolEntry",
+    			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
     poolIter->second->print();
@@ -614,10 +610,9 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found or dataset not assigned!" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateHousekeepingPacket",
+    			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
     }
 
@@ -640,12 +635,18 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     }
 
     if(hkQueue == nullptr) {
-        return QUEUE_OR_DESTINATION_NOT_SET;
+        // error, all destinations invalid
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateHousekeepingPacket",
+    			QUEUE_OR_DESTINATION_INVALID);
+        return QUEUE_OR_DESTINATION_INVALID;
     }
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-            return HasReturnvaluesIF::RETURN_FAILED;
+        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        			"generateHousekeepingPacket",
+        			QUEUE_OR_DESTINATION_INVALID);
         }
         destination = hkDestinationId;
     }
@@ -681,6 +682,13 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+    if(dataSet == nullptr) {
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"performPeriodicHkGeneration",
+    			DATASET_NOT_FOUND);
+    	return;
+    }
+
     if(not dataSet->getReportingEnabled()) {
         return;
     }
@@ -699,10 +707,11 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     if(result != HasReturnvaluesIF::RETURN_OK) {
         // configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "LocalDataPoolManager::performHkOperation:"
-                << "0x" << std::hex << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+        sif::warning << "LocalDataPoolManager::performHkOperation: "
+                << "HK generation failed." << std::endl;
+#else
+        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+        		"HK generation failed.\n");
 #endif
     }
 }
@@ -748,11 +757,10 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"performPeriodicHkGeneration",
+    			DATASET_NOT_FOUND);
+        return DATASET_NOT_FOUND;
     }
 
 
@@ -776,10 +784,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                << "Could not get free element from IPC store." << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not get free element from IPC store.");
         return result;
     }
 
@@ -788,10 +795,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                << "Expected size is not equal to serialized size" << std::endl;
-#endif
+    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Expected size is not equal to serialized size");
     }
 
     // Send structure reporting reply.
@@ -808,3 +814,52 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     hkQueue->reply(&reply);
     return result;
 }
+
+void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
+		const char* functionName, ReturnValue_t error, const char* errorPrint) {
+	if(errorPrint == nullptr) {
+		if(error == DATASET_NOT_FOUND) {
+			errorPrint = "Dataset not found";
+		}
+		else if(error == POOLOBJECT_NOT_FOUND) {
+			errorPrint = "Pool Object not found";
+		}
+		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == ErrorTypes::WARNING_TYPE) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic error";
+			}
+		}
+		else if(error == QUEUE_OR_DESTINATION_INVALID) {
+			errorPrint = "Queue or destination not set";
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == ErrorTypes::WARNING_TYPE) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == ErrorTypes::ERROR_TYPE) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 098158da..6502294e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -56,7 +56,7 @@ class LocalDataPoolManager {
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
 
     static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
@@ -370,6 +370,15 @@ private:
             ReturnValue_t& status);
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
+
+	enum class ErrorTypes {
+		WARNING_TYPE,
+		ERROR_TYPE
+	};
+
+	void printWarningOrError(ErrorTypes errorType, const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 

From 541478e4d5f4ad029dd4fd968e10ccc6cc72068d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 15:15:02 +0100
Subject: [PATCH 1211/1292] another small improvement

---
 datapoollocal/LocalDataPoolManager.cpp |  8 ++++++--
 datapoollocal/LocalDataPoolManager.h   | 18 ++++--------------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index e5ee499c..d1ab553d 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -3,10 +3,8 @@
 #include "LocalPoolDataSetBase.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
-#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
-
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -835,6 +833,12 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 		else if(error == QUEUE_OR_DESTINATION_INVALID) {
 			errorPrint = "Queue or destination not set";
 		}
+		else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+			errorPrint = "Pool entry type conflict";
+		}
+		else if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+			errorPrint = "Pool entry not found";
+		}
 		else {
 			errorPrint = "Unknown error";
 		}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6502294e..730e03e4 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -387,25 +387,15 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fetchPoolEntry: Pool entry "
-		        "not found." << std::endl;
-#else
-		fsfw::printWarning("HousekeepingManager::fetchPoolEntry: Pool entry "
-		        "not found.\n");
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict." << std::endl;
-#else
-		fsfw::printWarning("HousekeepingManager::fetchPoolEntry:"
-				" Pool entry type conflict.\n");
-#endif
+    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;

From c0fd981360dbb7d16018e9803a2a9a0f97de32f9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:14:11 +0100
Subject: [PATCH 1212/1292] improved DHB error handling

---
 datapoollocal/LocalDataPoolManager.cpp        |  48 +++---
 datapoollocal/LocalDataPoolManager.h          |  12 +-
 devicehandlers/DeviceHandlerBase.cpp          | 143 ++++++++++++------
 devicehandlers/DeviceHandlerBase.h            |  20 ++-
 serviceinterface/ServiceInterface.h           |   1 +
 serviceinterface/ServiceInterfacePrinter.h    |   8 +-
 serviceinterface/serviceInterfaceDefintions.h |   7 +
 7 files changed, 152 insertions(+), 87 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index d1ab553d..0ab6f150 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -20,7 +20,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
         return;
@@ -28,7 +28,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
     }
@@ -41,7 +41,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
@@ -49,7 +49,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -63,7 +63,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-        	printWarningOrError(ErrorTypes::ERROR_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
             return QUEUE_OR_DESTINATION_INVALID;
         }
@@ -88,7 +88,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         return result;
     }
 
-	printWarningOrError(ErrorTypes::WARNING_TYPE,
+	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -177,7 +177,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -209,7 +209,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -247,7 +247,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -351,7 +351,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -381,7 +381,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -587,7 +587,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE, "printPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
     			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
@@ -608,7 +608,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -634,7 +634,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
     if(hkQueue == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
@@ -642,7 +642,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-        	printWarningOrError(ErrorTypes::WARNING_TYPE,
+        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"generateHousekeepingPacket",
         			QUEUE_OR_DESTINATION_INVALID);
         }
@@ -681,7 +681,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
     	return;
@@ -755,7 +755,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -782,7 +782,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
         return result;
@@ -793,7 +793,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-    	printWarningOrError(ErrorTypes::WARNING_TYPE,
+    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
     }
@@ -813,7 +813,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     return result;
 }
 
-void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
+void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
 		if(error == DATASET_NOT_FOUND) {
@@ -823,7 +823,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 			errorPrint = "Pool Object not found";
 		}
 		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
-			if(errorType == ErrorTypes::WARNING_TYPE) {
+			if(outputType == fsfw::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -844,7 +844,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 		}
 	}
 
-	if(errorType == ErrorTypes::WARNING_TYPE) {
+	if(outputType == fsfw::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
@@ -855,7 +855,7 @@ void LocalDataPoolManager::printWarningOrError(ErrorTypes errorType,
 				owner->getObjectId(), errorPrint);
 #endif
 	}
-	else if(errorType == ErrorTypes::ERROR_TYPE) {
+	else if(outputType == fsfw::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 730e03e4..eee4c593 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -371,12 +371,8 @@ private:
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
 
-	enum class ErrorTypes {
-		WARNING_TYPE,
-		ERROR_TYPE
-	};
-
-	void printWarningOrError(ErrorTypes errorType, const char* functionName,
+	void printWarningOrError(fsfw::OutputTypes outputType,
+			const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
 };
@@ -387,14 +383,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
 				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-    	printWarningOrError(ErrorTypes::ERROR_TYPE, "fetchPoolEntry",
+    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
     			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 580f8c0d..7ca9922a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -39,13 +39,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << this->getObjectId()
-				<< std::dec << ": Do not pass nullptr as a cookie, consider "
-				<< std::setfill(' ') << "passing a dummy cookie instead!"
-				<< std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -132,30 +127,24 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: Communication interface "
-				"invalid." << std::endl;
-		sif::error << "Make sure it is set up properly and implements"
-				" DeviceCommunicationIF" << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"ComIF initialization failed");
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-#endif
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -164,11 +153,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
-					"ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
 					" and implements AcceptsDeviceResponsesIF" << std::endl;
+#else
+			fsfw::printError("Make sure the raw receiver object is set up "
+					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -178,11 +171,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "DeviceHandlerBase::initialize: Power switcher "
-					<< "object ID set but no valid object found." << std::endl;
-			sif::error << "Make sure the raw receiver object is set up properly"
-					<< " and implements PowerSwitchIF" << std::endl;
+			sif::error << "Make sure the power switcher object is set up "
+					<< "properly and implements PowerSwitchIF" << std::endl;
+#else
+			fsfw::printError("Make sure the power switcher object is set up "
+					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -556,17 +553,17 @@ void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-//Check if we reply to a raw command.
+	// Check if we reply to a raw command.
 	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
 		if (status == NO_REPLY_EXPECTED) {
 			status = RETURN_OK;
 		}
 		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
+		// Always delete data from a raw command.
 		IPCStore->deleteData(storedRawData);
 		return;
 	}
-//Check if we were externally commanded.
+	// Check if we were externally commanded.
 	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
 		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
 		if (status == NO_REPLY_EXPECTED) {
@@ -581,15 +578,17 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	// No need to check if iter exists, as this is checked by callers.
+	// If someone else uses the method, add check.
 	if (iter->second.command == deviceCommandMap.end()) {
 		//Is most likely periodic reply. Silent return.
 		return;
 	}
-//Check if more replies are expected. If so, do nothing.
+	// Check if more replies are expected. If so, do nothing.
 	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
+		// Check if it was transition or internal command.
+		// Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
 			actionHelper.finish(info->sendReplyTo, iter->first, status);
 		}
@@ -606,7 +605,7 @@ void DeviceHandlerBase::doSendWrite() {
 		if (result == RETURN_OK) {
 			cookieInfo.state = COOKIE_WRITE_SENT;
 		} else {
-			//always generate a failure event, so that FDIR knows what's up
+			// always generate a failure event, so that FDIR knows what's up
 			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
 					cookieInfo.pendingCommand->first);
 			replyToCommand(result);
@@ -735,6 +734,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+				printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
@@ -968,7 +970,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 }
 
 Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
+	// only child action special modes are handled, as a child should
+	// never see any base action modes
 	if (transitionMode == _MODE_START_UP) {
 		return _MODE_TO_ON;
 	}
@@ -1291,12 +1294,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
-		    //so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::dec
-					<< std::endl;
-#endif
+		    // so we can track misconfigurations
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					"Busy.");
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1320,13 +1322,13 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			//so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::dec
-					<< std::endl;
-#endif
+			char* output = nullptr;
+			sprintf(output, "Command %lu is executing", deviceCommandId);
+			// so we can track misconfigurations
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					output);
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
@@ -1485,3 +1487,48 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 		}
 	}
 }
+
+void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
+		const char *functionName, ReturnValue_t errorCode,
+		const char *errorPrint) {
+	if(errorPrint == nullptr) {
+		if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
+			errorPrint = "Initialization error";
+		}
+		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic Error";
+			}
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		fsfw::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == fsfw::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		fsfw::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372..4c745b4f 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -6,6 +6,8 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerThermalSet.h"
 
+#include "../serviceinterface/ServiceInterface.h"
+#include "../serviceinterface/serviceInterfaceDefintions.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -1111,7 +1113,7 @@ private:
 	/**
 	 * @brief   The mode the current transition originated from
 	 *
-	 * This is private so the child can not change it and fuck up the timeouts
+	 * This is private so the child can not change it and mess up the timeouts
 	 *
 	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
 	 * (it is _MODE_POWER_DOWN during this modes)
@@ -1190,7 +1192,8 @@ private:
 	 * Check if the RMAP sendWrite action was successful.
 	 *
 	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the device command was external commanded, a reply is sent
+	 *   indicating the result
 	 * - if the action was successful, the reply timout counter is initialized
 	 */
 	void doGetWrite(void);
@@ -1206,9 +1209,9 @@ private:
 	/**
 	 * Check the getRead reply and the contained data.
 	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
+	 * If data was received scanForReply() and, if successful, handleReply()
+	 * are called. If the current mode is @c MODE_RAW, the received packet
+	 * is sent to the commanding object via commandQueue.
 	 */
 	void doGetRead(void);
 
@@ -1227,7 +1230,7 @@ private:
 			uint32_t *len);
 
 	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
 	 */
 	void setTransition(Mode_t modeTo, Submode_t submodeTo);
 
@@ -1247,6 +1250,11 @@ private:
 
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
+
+    void printWarningOrError(fsfw::OutputTypes errorType,
+    		const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
index 0c7c4383..1f7e5e84 100644
--- a/serviceinterface/ServiceInterface.h
+++ b/serviceinterface/ServiceInterface.h
@@ -2,6 +2,7 @@
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 
 #include <FSFWConfig.h>
+#include "serviceInterfaceDefintions.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 1f82ba98..9a84f629 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -4,7 +4,7 @@
 
 namespace fsfw {
 
-enum class PrintLevel {
+enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
 	ERROR_TYPE = 1,
@@ -13,6 +13,12 @@ enum class PrintLevel {
 	DEBUG = 4
 };
 
+/**
+ * Set the print level. All print types with a smaller level will be printed
+ * as well. For example, set to PrintLevel::WARNING to only enable error
+ * and warning output.
+ * @param printLevel
+ */
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index 684c7366..de445907 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -3,6 +3,13 @@
 
 namespace fsfw {
 
+enum class OutputTypes {
+	OUT_INFO,
+	OUT_DEBUG,
+	OUT_WARNING,
+	OUT_ERROR
+};
+
 static const char* const ANSI_COLOR_RED = "\x1b[31m";
 static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
 static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";

From a9dba82661f6a88eeaa3fd1aab0948bf1919158c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:16:17 +0100
Subject: [PATCH 1213/1292] bugfix

---
 devicehandlers/DeviceHandlerBase.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 7ca9922a..1a106844 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1322,8 +1322,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			char* output = nullptr;
-			sprintf(output, "Command %lu is executing", deviceCommandId);
+			char output[36];
+			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
 			// so we can track misconfigurations
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",

From a1c394143a1b6ba4c80abcb54302ca1020053f69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:18:08 +0100
Subject: [PATCH 1214/1292] small formatting stuff

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1a106844..835a02b8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -749,7 +749,8 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
-			//We need to wait for timeout.. don't know what command failed and who sent it.
+			// We need to wait for timeout.. don't know what command failed
+			// and who sent it.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
 			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
 			break;

From 9f15cd697d154d0d464560ce2c26cedee9c87388 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 16:23:57 +0100
Subject: [PATCH 1215/1292] improved includes

---
 devicehandlers/DeviceHandlerBase.cpp       | 14 ++++++--------
 serviceinterface/ServiceInterfacePrinter.h |  2 +-
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 835a02b8..0efdeba0 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,7 +2,7 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -13,9 +13,6 @@
 #include "../subsystem/SubsystemBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
-#include <iomanip>
-
-
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -720,10 +717,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-#endif
+				printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Found length is one, parsing might be stuck");
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -1323,6 +1319,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
+#if FSFW_DISABLE_PRINTOUT == 0
 			char output[36];
 			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
 			// so we can track misconfigurations
@@ -1330,6 +1327,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					output);
+#endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
 			return;
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 9a84f629..fdff797a 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,5 +1,5 @@
 #if FSFW_DISABLE_PRINTOUT == 0
-#include <stdio.h>
+#include <cstdio>
 #endif
 
 namespace fsfw {

From 7c47b1ce345182c6a69ff2fcaf6e89d81ef8c867 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 20:44:05 +0100
Subject: [PATCH 1216/1292] 100 percent test coverage for pool vector

---
 datapoollocal/LocalPoolVector.tpp             |  4 +-
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 unittest/tests/datapoollocal/DataSetTest.cpp  |  6 ++-
 .../datapoollocal/LocalPoolVariableTest.cpp   |  2 +-
 .../datapoollocal/LocalPoolVectorTest.cpp     | 52 ++++++++++++++++++-
 5 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index a0e32f62..f311c23d 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -104,7 +104,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
-	return value[vectorSize];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -121,7 +121,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
-	return value[vectorSize];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index 9d828de5..fd7f61b8 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -1,4 +1,5 @@
 target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
 	LocalPoolVectorTest.cpp
+	DataSetTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
index ccb7603d..968a0b3d 100644
--- a/unittest/tests/datapoollocal/DataSetTest.cpp
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -2,6 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
@@ -11,9 +12,10 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
 	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
 	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
-
+	const uint32_t setId = 0;
 	SECTION("BasicTest") {
-		//StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>()
+		StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
+				sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index eb5abf35..5f7118ff 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -23,10 +23,10 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		REQUIRE(testVariable.commit() == retval::CATCH_OK);
 		REQUIRE(testVariable.read() == retval::CATCH_OK);
 		REQUIRE(testVariable.value == 5);
-
 		CHECK(not testVariable.isValid());
 		testVariable.setValid(true);
 		CHECK(testVariable.isValid());
+		CHECK(testVariable.commit(true) == retval::CATCH_OK);
 
 		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
 		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index 7e40e898..cfc2ec2e 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -38,7 +38,7 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		// This is invalid access, so the last value will be set instead.
 		// (we can't throw exceptions)
 		testVector[4] = 12;
-		CHECK(testVector[3] == 12);
+		CHECK(testVector[2] == 12);
 		CHECK(testVector.commit() == retval::CATCH_OK);
 
 		// Use read-only reference.
@@ -48,6 +48,42 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 
 		uint16_t lastVal = roTestVec[25];
 		CHECK(lastVal == 12);
+
+		size_t maxSize = testVector.getSerializedSize();
+		CHECK(maxSize == 6);
+
+		uint16_t serializedVector[3];
+		uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+		size_t serSize = 0;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+
+		CHECK(serSize == 6);
+		CHECK(serializedVector[0] == 5);
+		CHECK(serializedVector[1] == 232);
+		CHECK(serializedVector[2] == 12);
+
+		maxSize = 1;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+
+		serializedVector[0] = 16;
+		serializedVector[1] = 7832;
+		serializedVector[2] = 39232;
+
+		const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
+				serializedVector);
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVector[0] == 16);
+		CHECK(testVector[1] == 7832);
+		CHECK(testVector[2] == 39232);
+
+		serSize = 1;
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
 	}
 
 	SECTION("ErrorHandling") {
@@ -64,6 +100,20 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
 		REQUIRE(invalidVector2.read() ==
 				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+		REQUIRE(invalidVector2.commit() ==
+				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVec.read() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVec.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
 	}
 }
 

From 12091ca6ab48df043708b2a63e0b695679f5315d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 20:55:36 +0100
Subject: [PATCH 1217/1292] enum members renamed, global vars static now

---
 serviceinterface/ServiceInterfacePrinter.cpp | 30 ++++++++++----------
 serviceinterface/ServiceInterfacePrinter.h   |  8 +++---
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index cb3a958d..fff6753b 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,11 +6,11 @@
 #include <cstdarg>
 #include <cstdint>
 
-fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
+static fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
-bool consoleInitialized = false;
+static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-bool addCrAtEnd = false;
+static bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
@@ -39,31 +39,31 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO) {
+    if(printType == fsfw::PrintLevel::INFO_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG) {
+    else if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING) {
+    else if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+    else if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
     	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO) {
+   if (printType == fsfw::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG) {
+   if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING) {
+   if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+   if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -91,21 +91,21 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 void fsfw::printInfo(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::INFO_LEVEL, fmt, args);
     va_end(args);
 }
 
 void fsfw::printWarning(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::WARNING_LEVEL, fmt, args);
     va_end(args);
 }
 
 void fsfw::printDebug(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::DEBUG_LEVEL, fmt, args);
     va_end(args);
 }
 
@@ -116,7 +116,7 @@ void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
 void fsfw::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
+    fsfwPrint(fsfw::PrintLevel::ERROR_LEVEL, fmt, args);
     va_end(args);
 }
 
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index fdff797a..f49ccbb7 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -7,10 +7,10 @@ namespace fsfw {
 enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
-	ERROR_TYPE = 1,
-	WARNING = 2,
-	INFO = 3,
-	DEBUG = 4
+	ERROR_LEVEL = 1,
+	WARNING_LEVEL = 2,
+	INFO_LEVEL = 3,
+	DEBUG_LEVEL = 4
 };
 
 /**

From 57829faa64f004a48510e057742c4a9fb03a3726 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Fri, 8 Jan 2021 21:03:47 +0100
Subject: [PATCH 1218/1292] added cast

---
 devicehandlers/DeviceHandlerBase.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 0efdeba0..4fa7b09c 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1321,7 +1321,8 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		} else if (iter->second.isExecuting) {
 #if FSFW_DISABLE_PRINTOUT == 0
 			char output[36];
-			sprintf(output, "Command 0x%08x is executing", deviceCommandId);
+			sprintf(output, "Command 0x%08x is executing",
+					static_cast<unsigned int>(deviceCommandId));
 			// so we can track misconfigurations
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",

From dbe326e78743ca64888cea4506acefdbb1bf566b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 13:52:47 +0100
Subject: [PATCH 1219/1292] minor tweak

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cc5ffd5..587e6701 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,7 +106,7 @@ else()
 	)
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(WARNING_FLAGS
 		-Wall
 		-Wextra

From 7129ea67bdf4c85d496a22c692a84f0f7a6ede97 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 16:06:54 +0100
Subject: [PATCH 1220/1292] linux fixes

---
 osal/linux/BinarySemaphore.cpp      | 20 +++++++++++++-------
 osal/linux/CountingSemaphore.cpp    |  4 +++-
 osal/linux/MessageQueue.cpp         | 14 ++++++++------
 osal/linux/TcUnixUdpPollingTask.cpp |  2 ++
 osal/linux/TmTcUnixUdpBridge.cpp    |  8 ++++++--
 5 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 0a6bb29f..c2eb8514 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,10 +1,11 @@
 #include "BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfacePrinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-extern "C" {
+#include <time.h>
 #include <errno.h>
 #include <string.h>
-}
+
 
 BinarySemaphore::BinarySemaphore() {
 	// Using unnamed semaphores for now
@@ -113,7 +114,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		fsfw::printError("BinarySemaphore::getSemaphoreCounter: "
+				"Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -128,13 +130,17 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 		switch(errno) {
 		case(EINVAL):
 			// Value exceeds SEM_VALUE_MAX
-		case(ENOSYS):
-		// System does not support process-shared semaphores
+		case(ENOSYS): {
+			// System does not support process-shared semaphores
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-				<< std::endl;
+				sif::error << "BinarySemaphore: Init failed with "
+						<< strerror(errno) << std::endl;
+#else
+				fsfw::printError("BinarySemaphore: Init failed with %s\n",
+						strerror(errno));
 #endif
 		}
+		}
 	}
 }
 
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 0bb71831..07c52212 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,5 +1,7 @@
 #include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <errno.h>
 
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index e7b09b4f..d93b7f6d 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
@@ -121,14 +121,16 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		break;
 	}
 
-	default:
+	default: {
 		// Failed either the first time or the second time
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
+				<< " failed with status: " << strerror(errno) << std::endl;
+#else
+		fsfw::printError("MessageQueue::MessageQueue: Creating Queue %s"
+				" failed with status: %s\n", name, strerror(errno));
 #endif
-
+	}
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
 
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index a8387e87..11ed7fee 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,8 @@
 #include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
+#include <errno.h>
+
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 1d318d3b..0bedce0f 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,5 @@
 #include "TmTcUnixUdpBridge.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
@@ -188,12 +188,16 @@ void TmTcUnixUdpBridge::handleBindError() {
 
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
-	default:
+	default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#else
+		fsfw::printError("TmTcUnixBridge::handleSendError: %s\n",
+				strerror(errno));
 #endif
 	}
+	}
 }
 
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){

From 13ffcfe801c61a5d4cca3ccb55d2d9300e100ffd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Sat, 9 Jan 2021 16:20:35 +0100
Subject: [PATCH 1221/1292] prints added

---
 osal/linux/PosixThread.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index a0e540cf..8d368c18 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,6 +1,6 @@
 #include "PosixThread.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 #include <errno.h>
@@ -146,16 +146,22 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
+			size_t stackMb = stackSize/10e6;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#else
+			fsfw::printError("PosixThread::createTask: Insufficient memory for "
+					"the requested %zu MB\n", stackMb);
 #endif
 		}
 		else if(errno == EINVAL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#else
+			fsfw::printError("PosixThread::createTask: "
+					"Wrong alignment argument!\n");
 #endif
 		}
 		return;

From f8abf3527dead67938a7c03f39cf63f46ca73ff5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 11:51:33 +0100
Subject: [PATCH 1222/1292] fixed indentation

---
 datapoollocal/LocalDataPoolManager.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 0ab6f150..8ccc620c 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -509,10 +509,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
         break;
     }
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, true);
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, false);
+    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+        return generateSetStructurePacket(sid, true);
+    }
+
+    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+        return generateSetStructurePacket(sid, false);
+    }
     case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
     case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
         float newCollIntvl = 0;

From 918200e88c542a985e9751c1a053dfa37bc4c66e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 12:53:01 +0100
Subject: [PATCH 1223/1292] added first unit tests for hk manager

---
 datapool/PoolDataSetBase.cpp                  |  4 +
 datapool/PoolDataSetBase.h                    |  1 +
 datapoollocal/LocalDataPoolManager.cpp        |  6 +-
 unittest/tests/action/TestActionHelper.cpp    |  1 +
 unittest/tests/action/TestActionHelper.h      | 81 -----------------
 unittest/tests/datapoollocal/CMakeLists.txt   |  1 +
 .../datapoollocal/LocalPoolManagerTest.cpp    | 28 ++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 59 ++++++++++--
 unittest/tests/mocks/MessageQueueMockBase.h   | 90 +++++++++++++++++++
 9 files changed, 179 insertions(+), 92 deletions(-)
 create mode 100644 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
 create mode 100644 unittest/tests/mocks/MessageQueueMockBase.h

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 05797012..7731a8df 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -214,6 +214,10 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
 
+PoolVariableIF** PoolDataSetBase::getContainer() const {
+	return registeredVariables;
+}
+
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
 		bool protectEveryReadCommit, uint32_t mutexTimeout) {
 	this->protectEveryReadCommitCall = protectEveryReadCommit;
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 0528f40f..665f4b33 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -157,6 +157,7 @@ protected:
 	const size_t maxFillCount = 0;
 
 	void setContainer(PoolVariableIF** variablesContainer);
+	PoolVariableIF** getContainer() const;
 
 private:
 	bool protectEveryReadCommitCall = false;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 8ccc620c..564604cd 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -308,8 +308,8 @@ void LocalDataPoolManager::handleChangeResetLogic(
         // config error!
         return;
     }
-
-    for(auto& changeInfo: *hkUpdateResetList) {
+    HkUpdateResetList& listRef = *hkUpdateResetList;
+    for(auto& changeInfo: listRef) {
         if(changeInfo.dataType != type) {
             continue;
         }
@@ -636,7 +636,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     }
 
     if(hkQueue == nullptr) {
-        // error, all destinations invalid
+        // error, no queue available to send packet with.
     	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3957bba2..2493a6b8 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -4,6 +4,7 @@
 
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 #include <catch2/catch_test_macros.hpp>
 
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 610fb09e..641ea2c6 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -48,85 +48,4 @@ public:
 };
 
 
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		memcpy(message->getBuffer(), lastMessage.getBuffer(),
-				message->getMessageSize());
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
 #endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
index fd7f61b8..f196a080 100644
--- a/unittest/tests/datapoollocal/CMakeLists.txt
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -2,4 +2,5 @@ target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
 	LocalPoolVectorTest.cpp
 	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
 )
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
new file mode 100644
index 00000000..4cea3ed1
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -0,0 +1,28 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+	REQUIRE(mqMock != nullptr);
+
+	poolOwner->subscribeWrapperSetUpdate();
+	SECTION("BasicTest") {
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent() == true);
+
+	}
+}
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index c665cb7f..c211801a 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -7,6 +7,8 @@
 #include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <testcfg/objects/systemObjectList.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
@@ -14,16 +16,45 @@ static constexpr lp_id_t floatVarId = 1;
 static constexpr lp_id_t uint32VarId = 2;
 static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
 }
 
 
+class LocalPoolTestDataSet: public StaticLocalDataSet<3> {
+public:
+	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+		StaticLocalDataSet(owner, setId) {
+	}
+
+	ReturnValue_t assignPointers() {
+		PoolVariableIF** rawVarArray = getContainer();
+		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+				rawVarArray[2]);
+		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+				localPoolUint16Vec == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+	lp_var_t<float>* localPoolVarFloat = nullptr;
+	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+
+private:
+};
+
 
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
 			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), hkManager(this, messageQueue)  {
-		messageQueue = QueueFactory::instance()->createMessageQueue(10);
+		SystemObject(objectId), hkManager(this, messageQueue),
+		dataset(this, lpool::testSetId) {
+		messageQueue = new MessageQueueMockBase();
 	}
 
 	~LocalPoolOwnerBase() {
@@ -89,22 +120,34 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
-		// empty for now
-		return nullptr;
+		return &dataset;
 	}
+
+	MessageQueueMockBase* getMockQueueHandle() const {
+		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+	}
+
+	void subscribeWrapperSetUpdate() {
+		hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	LocalDataPoolManager hkManager;
+	LocalPoolTestDataSet dataset;
 private:
 
-	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
-	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
+			&dataset);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+			&dataset);
 	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
 	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
-			lpool::uint16Vec3Id);
+			lpool::uint16Vec3Id, &dataset);
 	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
 			lpool::int64Vec2Id);
 
 	MessageQueueIF* messageQueue = nullptr;
-	LocalDataPoolManager hkManager;
 
 	bool initialized = false;
 	bool initializedAfterTaskCreation = false;
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
new file mode 100644
index 00000000..5a157329
--- /dev/null
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -0,0 +1,90 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
+#include <unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		std::memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */

From b570da6467fb11497e14d3d05abd20d386f68e4b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 13:58:33 +0100
Subject: [PATCH 1224/1292] more tests added

---
 datapoollocal/HasLocalDataPoolIF.h            |  4 +
 .../datapoollocal/LocalPoolManagerTest.cpp    | 40 +++++++++-
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 21 ++++-
 unittest/tests/mocks/HkReceiverMock.h         | 20 +++++
 unittest/tests/mocks/MessageQueueMockBase.h   | 76 ++++++++++++-------
 .../user/testcfg/objects/systemObjectList.h   |  1 +
 6 files changed, 131 insertions(+), 31 deletions(-)
 create mode 100644 unittest/tests/mocks/HkReceiverMock.h

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7707fab8..07c6882b 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -4,6 +4,7 @@
 #include "locPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 
@@ -92,6 +93,9 @@ public:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
+#else
+	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
 #endif
 	    return nullptr;
 	}
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 4cea3ed1..2c797505 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -3,6 +3,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
 #include <unittest/core/CatchDefinitions.h>
 
 
@@ -17,12 +18,49 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
 	REQUIRE(mqMock != nullptr);
 
-	poolOwner->subscribeWrapperSetUpdate();
+
 	SECTION("BasicTest") {
+		// Subscribe for message generation on update.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		// Subscribe for an update message.
 		poolOwner->dataset.setChanged(true);
+		// Now the update message should be generated.
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
+		CommandMessage messageSent;
+		uint8_t messagesSent = 0;
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
 
+		// Should have been reset.
+		CHECK(poolOwner->dataset.hasChanged() == false);
+		// Set changed again, result should be the same.
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// now subscribe for set update HK as well.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		// first message sent should be the update notification, considering
+		// the internal list is a vector checked in insertion order.
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index c211801a..5ff14698 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -18,6 +18,8 @@ static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
 
 static constexpr uint32_t testSetId = 0;
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
+		testSetId);
 }
 
 
@@ -123,12 +125,27 @@ public:
 		return &dataset;
 	}
 
+	virtual LocalPoolObjectBase* getPoolObjectHandle(
+			lp_id_t localPoolId) override {
+		return &testUint8;
+	}
+
 	MessageQueueMockBase* getMockQueueHandle() const {
 		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
 	}
 
-	void subscribeWrapperSetUpdate() {
-		hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+	ReturnValue_t subscribeWrapperSetUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+				false, objects::HK_RECEIVER_MOCK);
+	}
+
+	ReturnValue_t subscribeWrapperVariableUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
 				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
 	}
 
diff --git a/unittest/tests/mocks/HkReceiverMock.h b/unittest/tests/mocks/HkReceiverMock.h
new file mode 100644
index 00000000..e7509c59
--- /dev/null
+++ b/unittest/tests/mocks/HkReceiverMock.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class HkReceiverMock: public SystemObject, public AcceptsHkPacketsIF {
+public:
+	HkReceiverMock(object_id_t objectId): SystemObject(objectId) {
+
+	}
+
+	MessageQueueId_t getHkQueue() const {
+		return MessageQueueIF::NO_QUEUE;
+	}
+};
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 5a157329..4792772f 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -6,68 +6,81 @@
 #include <unittest/core/CatchDefinitions.h>
 #include <cstring>
 
+#include <queue>
 
 class MessageQueueMockBase: public MessageQueueIF {
 public:
-	MessageQueueId_t myQueueId = 0;
+	MessageQueueId_t myQueueId = tconst::testQueueId;
+	uint8_t messageSentCounter = 0;
 	bool defaultDestSet = false;
 	bool messageSent = false;
 
 
-	bool wasMessageSent() {
+	bool wasMessageSent(uint8_t* messageSentCounter = nullptr,
+			bool resetCounter = true) {
 		bool tempMessageSent = messageSent;
 		messageSent = false;
+		if(messageSentCounter != nullptr) {
+			*messageSentCounter = this->messageSentCounter;
+		}
+		if(resetCounter) {
+			this->messageSentCounter = 0;
+		}
 		return tempMessageSent;
 	}
 
 	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
 		return HasReturnvaluesIF::RETURN_OK;
 	};
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
 			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
+		return receiveMessage(message);
 	}
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		std::memcpy(message->getBuffer(), lastMessage.getBuffer(),
+		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
 				message->getMessageSize());
-		lastMessage.clear();
+		messagesSentQueue.pop();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual ReturnValue_t flush(uint32_t* count) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
+		return myQueueId;
 	}
 	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
+		return myQueueId;
 	}
 	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
 			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(sendTo, message);
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
 	}
 	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
 			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
 		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		messageSentCounter++;
+		MessageQueueMessage& messageRef = *(
+				dynamic_cast<MessageQueueMessage*>(message));
+		messagesSentQueue.push(messageRef);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
@@ -81,9 +94,16 @@ public:
 	virtual bool isDefaultDestinationSet() const {
 		return defaultDestSet;
 	}
-private:
-	MessageQueueMessage lastMessage;
 
+	void clearMessages() {
+		while(not messagesSentQueue.empty()) {
+			messagesSentQueue.pop();
+		}
+	}
+
+private:
+	std::queue<MessageQueueMessage> messagesSentQueue;
+	//MessageQueueMessage lastMessage;
 };
 
 
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index da95617c..88b92131 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -21,6 +21,7 @@ namespace objects {
 		TEST_ECHO_COM_IF = 20,
 		TEST_DEVICE = 21,
 
+		HK_RECEIVER_MOCK = 22,
 		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }

From 1af28dd45737440a43cf4f8560e9d28ed3b9cd69 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 13:59:40 +0100
Subject: [PATCH 1225/1292] updated user folder for unittests

---
 unittest/user/unittest/CMakeLists.txt            | 1 +
 unittest/user/unittest/core/CatchDefinitions.cpp | 4 ++--
 unittest/user/unittest/core/CatchFactory.cpp     | 7 ++++++-
 3 files changed, 9 insertions(+), 3 deletions(-)
 create mode 100644 unittest/user/unittest/CMakeLists.txt

diff --git a/unittest/user/unittest/CMakeLists.txt b/unittest/user/unittest/CMakeLists.txt
new file mode 100644
index 00000000..ad6d4787
--- /dev/null
+++ b/unittest/user/unittest/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 02a935d2..531ee87b 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -9,8 +9,8 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #else
-		fsfw::printError("Global object manager uninitialized");
-#endif
+		fsfw::printError("Global object manager uninitialized\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 0597f08c..eabaa21d 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -10,6 +10,8 @@
 #include <fsfw/tmtcpacket/pus/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/unittest/tests/datapoollocal/LocalPoolOwnerBase.h>
+#include <fsfw/unittest/tests/mocks/HkReceiverMock.h>
 
 /**
  * @brief Produces system objects.
@@ -30,6 +32,9 @@ void Factory::produce(void) {
 	new HealthTable(objects::HEALTH_TABLE);
 	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
+	new LocalPoolOwnerBase (objects::TEST_LOCAL_POOL_OWNER_BASE);
+	new HkReceiverMock(objects::HK_RECEIVER_MOCK);
+
 	{
 		PoolManager::LocalPoolConfig poolCfg = {
 		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
@@ -65,7 +70,7 @@ void Factory::setStaticFrameworkObjectIds() {
 	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
 
-	LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+	LocalDataPoolManager::defaultHkDestination = objects::HK_RECEIVER_MOCK;
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 

From 69e931c07b8a6dbb7c3c0f665b33d8722cce8223 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:27:57 +0100
Subject: [PATCH 1226/1292] important logic fix

---
 datapoollocal/LocalDataPoolManager.cpp        |  6 +++-
 .../datapoollocal/LocalPoolManagerTest.cpp    | 18 +++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 31 +++++++++++++++----
 3 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 564604cd..c12203f7 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -322,12 +322,16 @@ void LocalDataPoolManager::handleChangeResetLogic(
             continue;
         }
 
+        // only one update recipient, we can reset changes status immediately.
         if(changeInfo.updateCounter <= 1) {
             toReset->setChanged(false);
         }
-        if(changeInfo.currentUpdateCounter == 0) {
+        // All recipients have been notified, reset the changed flag.
+        if(changeInfo.currentUpdateCounter <= 1) {
             toReset->setChanged(false);
+            changeInfo.currentUpdateCounter = 0;
         }
+        // Not all recipiens have been notified yet, decrement.
         else {
             changeInfo.currentUpdateCounter--;
         }
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 2c797505..bc07c9d9 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -60,7 +60,25 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::HK_REPORT));
+		// clear message to avoid memory leak, our mock won't do it for us (yet)
 		CommandMessageCleaner::clearCommandMessage(&messageSent);
+
+		// now subscribe for variable update as well
+		REQUIRE(not poolOwner->dataset.hasChanged());
+		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
+				retval::CATCH_OK);
+		lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+		REQUIRE(poolVar != nullptr);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 5ff14698..430c8b07 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -2,6 +2,7 @@
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/LocalDataSet.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
 #include <fsfw/datapoollocal/LocalPoolVector.h>
@@ -18,15 +19,16 @@ static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
 
 static constexpr uint32_t testSetId = 0;
+static constexpr uint8_t dataSetMaxVariables = 10;
 static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
 		testSetId);
 }
 
 
-class LocalPoolTestDataSet: public StaticLocalDataSet<3> {
+class LocalPoolTestDataSet: public LocalDataSet {
 public:
 	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
-		StaticLocalDataSet(owner, setId) {
+		LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
 	}
 
 	ReturnValue_t assignPointers() {
@@ -127,7 +129,24 @@ public:
 
 	virtual LocalPoolObjectBase* getPoolObjectHandle(
 			lp_id_t localPoolId) override {
-		return &testUint8;
+		if(localPoolId == lpool::uint8VarId) {
+			return &testUint8;
+		}
+		else if(localPoolId == lpool::uint16Vec3Id) {
+			return &testUint16Vec;
+		}
+		else if(localPoolId == lpool::floatVarId) {
+			return &testFloat;
+		}
+		else if(localPoolId == lpool::int64Vec2Id) {
+			return &testInt64Vec;
+		}
+		else if(localPoolId == lpool::uint32VarId) {
+			return &testUint32;
+		}
+		else {
+			return &testUint8;
+		}
 	}
 
 	MessageQueueMockBase* getMockQueueHandle() const {
@@ -144,9 +163,9 @@ public:
 				false, objects::HK_RECEIVER_MOCK);
 	}
 
-	ReturnValue_t subscribeWrapperVariableUpdate() {
-		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
-				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
 	LocalDataPoolManager hkManager;

From 4fa9a1fe1934694999a031fc802119721f05bd93 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:33:02 +0100
Subject: [PATCH 1227/1292] added more tests

---
 .../datapoollocal/LocalPoolManagerTest.cpp      | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index bc07c9d9..ef8f7f33 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -17,6 +17,8 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
 	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
 	REQUIRE(mqMock != nullptr);
+	CommandMessage messageSent;
+	uint8_t messagesSent = 0;
 
 
 	SECTION("BasicTest") {
@@ -27,8 +29,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// Now the update message should be generated.
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
-		CommandMessage messageSent;
-		uint8_t messagesSent = 0;
+
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
@@ -62,8 +63,10 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 				HousekeepingMessage::HK_REPORT));
 		// clear message to avoid memory leak, our mock won't do it for us (yet)
 		CommandMessageCleaner::clearCommandMessage(&messageSent);
+	}
 
-		// now subscribe for variable update as well
+	SECTION("AdvancedTests") {
+		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());
 		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
 				retval::CATCH_OK);
@@ -73,12 +76,20 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		poolVar->setChanged(true);
 		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
 
+		// Check update notification was sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 1);
+		// Should have been reset.
+		CHECK(poolVar->hasChanged() == false);
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
 		CHECK(messageSent.getCommand() == static_cast<int>(
 				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
 
+		// now subscribe for the dataset update (HK and update) again
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+
+
 	}
 }
 

From 6993415873b88b68e987ef7796e5f371a21fbef4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:54:05 +0100
Subject: [PATCH 1228/1292] more tests

---
 datapoollocal/LocalDataPoolManager.cpp        |  5 ++++
 datapoollocal/LocalDataPoolManager.h          |  6 +++++
 .../datapoollocal/LocalPoolManagerTest.cpp    | 25 +++++++++++++++++++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  4 +++
 unittest/tests/mocks/MessageQueueMockBase.h   | 13 +++++++++-
 5 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c12203f7..da6e91a8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -820,6 +820,11 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     return result;
 }
 
+void LocalDataPoolManager::clearReceiversList() {
+	// clear the vector completely and releases allocated memory.
+	HkReceivers().swap(hkReceiversMap);
+}
+
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index eee4c593..2ced2efd 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -250,6 +250,12 @@ public:
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
+    /**
+     * This function can be used to clear the receivers list. This is
+     * intended for test functions and not for regular operations, because
+     * the insertion operations allocate dynamically.
+     */
+    void clearReceiversList();
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index ef8f7f33..2ea169b2 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -66,6 +66,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	}
 
 	SECTION("AdvancedTests") {
+		poolOwner->resetSubscriptionList();
 		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());
 		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
@@ -89,7 +90,31 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		// now two messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		mqMock->clearMessages(true);
 
+		poolOwner->dataset.setChanged(true);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		// now three messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 3);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+		REQUIRE(mqMock->receiveMessage(&messageSent) ==
+				static_cast<int>(MessageQueueIF::EMPTY));
 	}
 }
 
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index 430c8b07..a5389812 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -168,6 +168,10 @@ public:
 				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
+	void resetSubscriptionList() {
+		hkManager.clearReceiversList();
+	}
+
 	LocalDataPoolManager hkManager;
 	LocalPoolTestDataSet dataset;
 private:
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
index 4792772f..7b810b41 100644
--- a/unittest/tests/mocks/MessageQueueMockBase.h
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -40,6 +40,10 @@ public:
 		return receiveMessage(message);
 	}
 	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		if(messagesSentQueue.empty()) {
+			return MessageQueueIF::EMPTY;
+		}
+
 		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
 				message->getMessageSize());
 		messagesSentQueue.pop();
@@ -95,8 +99,15 @@ public:
 		return defaultDestSet;
 	}
 
-	void clearMessages() {
+	void clearMessages(bool clearCommandMessages = true) {
 		while(not messagesSentQueue.empty()) {
+			if(clearCommandMessages) {
+				CommandMessage message;
+				std::memcpy(message.getBuffer(),
+						messagesSentQueue.front().getBuffer(),
+						message.getMessageSize());
+				message.clear();
+			}
 			messagesSentQueue.pop();
 		}
 	}

From 15b65b78e730d73a840d9708658a7d0d2817a19e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:57:56 +0100
Subject: [PATCH 1229/1292] ndentiation

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index da6e91a8..19c94049 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -48,7 +48,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
-        // error, all destinations invalid
+    	// error, all destinations invalid
     	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");

From 63ce87acab188be447f820c421661487fda7b5a9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 14:59:03 +0100
Subject: [PATCH 1230/1292] more indentation corrections

---
 datapoollocal/LocalDataPoolManager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 19c94049..2a0ec923 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -65,7 +65,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
         else {
         	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
-            return QUEUE_OR_DESTINATION_INVALID;
+        	return QUEUE_OR_DESTINATION_INVALID;
         }
     }
 

From 4bfbeead0024898b1e2139ec6ed4a877e60980c3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 15:04:47 +0100
Subject: [PATCH 1231/1292] additional doc

---
 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index 2ea169b2..f497e610 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -66,6 +66,8 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 	}
 
 	SECTION("AdvancedTests") {
+		// we need to reset the subscription list because the pool owner
+		// is a global object.
 		poolOwner->resetSubscriptionList();
 		// Subscribe for variable update as well
 		REQUIRE(not poolOwner->dataset.hasChanged());

From 7a053b6f72b50a3868019bcbc9af4f80c5f03d55 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:24:19 +0100
Subject: [PATCH 1232/1292] updated README

---
 README.md               | 130 +++++++---------------------------------
 doc/README-highlevel.md |  99 ++++++++++++++++++++++++++++++
 doc/README-osal.md      |  32 ++++++++++
 3 files changed, 153 insertions(+), 108 deletions(-)
 create mode 100644 doc/README-highlevel.md
 create mode 100644 doc/README-osal.md

diff --git a/README.md b/README.md
index 8552e0c8..f308ac9f 100644
--- a/README.md
+++ b/README.md
@@ -9,121 +9,35 @@ 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.
 
-## Intended Use
+## 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 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 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 tested on the STM32H743ZI-Nucleo board.
+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.
 
-## How to Use
+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.
+
+## 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.
 
-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. 
 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. 
+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.
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
 
-## Structure
+## Index
 
-The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
-This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses run-time type information but exceptions are not allowed.
+[1. High-level overview](doc/README-highlevel.md#top)
+[2. Core components](doc/README-core.md#top)
+[3. OSAL overview](doc/README-osal.md#top)
 
-### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
-Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
-The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
-
-### OSAL
-
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent Host OSAL is in development which will provide abstraction for common type of 
-host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-
-### Core Components 
-
-The FSFW has following core components. More detailed informations can be found in the
-[core component section](doc/README-core.md#top):
-
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
-   using dynamic memory allocation. These pools are allocated up front.
-3. Clock: This module provided common time related functions
-4. EventManager: This module allows routing of events generated by `SystemObjects`
-5. HealthTable: A component which stores the health states of objects
-
-### Static Ids in the framework
-
-Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
-
-### Events
-
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
-Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
-Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
-
-### Internal Communication
-
-Components communicate mostly over Message through Queues. 
-Those queues are created by calling the singleton QueueFactory::instance()->create(). 
-
-### External Communication
-
-The external communication with the mission control system is mostly up to the user implementation.
-The FSFW provides PUS Services which can be used to but don't need to be used. 
-The services can be seen as a conversion from a TC to a message based communication and back.
-
-#### CCSDS Frames, CCSDS Space Packets and PUS
-
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
-If Space Packets are used, a timestamper must be created. 
-An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
-
-#### Device Handlers
-
-DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
-More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
-
-#### Modes, Health
-
-The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
-On-board Mode Management is implement in hierarchy system. 
-DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
-Assemblies share a common core with the next level which are the Subsystems. 
-
-Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
-The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
-The target table is used to describe the state that is checked continuously by the subsystem. 
-All of this allows System Modes to be generated as Subsystem object as well from the same database. 
-This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
-
-The health state represents if the component is able to perform its tasks. 
-This can be used to signal the system to avoid using this component instead of a redundant one.
-The on-board FDIR uses the health state for isolation and recovery. 
-
-## Unit Tests
-
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
-See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/doc/README-highlevel.md b/doc/README-highlevel.md
new file mode 100644
index 00000000..fac89c53
--- /dev/null
+++ b/doc/README-highlevel.md
@@ -0,0 +1,99 @@
+# High-level overview
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses run-time type information but exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
+The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components and how to use them.
+
+### Core Components 
+
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
+
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
+
+### Static IDs in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### Device Handlers
+
+DeviceHandlers are another important component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. More information on how to run these tests can be found in the separate
+[`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)
diff --git a/doc/README-osal.md b/doc/README-osal.md
new file mode 100644
index 00000000..206596ac
--- /dev/null
+++ b/doc/README-osal.md
@@ -0,0 +1,32 @@
+# Operating System Abstraction Layer (OSAL)
+
+Some specific information on the provided OSALs are provided.
+
+## Linux OSAL
+
+This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
+embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
+and real-time functionalities. This is generally done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+
+More information on how to set up a Linux system accordingly can be found in the 
+[Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)
+
+## Hosted OSAL
+
+This is the newest OSAL. Support for Semaphores has not been implemented yet and will propably be implemented as soon as C++20 with Semaphore support has matured. This OSAL can be used to run the FSFW on any host system, but currently has only been tested on Windows 10 and Ubuntu 20.04. Unlike the other OSALs, it uses dynamic memory allocation (e.g. for the message queue implementation). Cross-platform serial port (USB) support might be added soon.
+
+## FreeRTOS OSAL
+
+FreeRTOS is not included and the developer needs to take care of compiling the FreeRTOS sources and adding the `FreeRTOSConfig.h` file location to the include path. This OSAL has only been tested extensively with the pre-emptive scheduler configuration so far but it should in principle also be possible to use a cooperative scheduler. It is recommended to use the `heap_4` allocation scheme. When using newlib (nano), it is also recommended to add `#define configUSE_NEWLIB_REENTRANT` to the FreeRTOS configuration file to ensure thread-safety.
+
+When using this OSAL, developers also need to provide an implementation for the `vRequestContextSwitchFromISR` function. This has been done because the call to request a context switch from an ISR is generally located in the `portmacro.h` header and is different depending on the target architecture or device.
+
+## RTEMS OSAL
+
+The RTEMS OSAL was the first implemented OSAL which is also used on the active satellite Flying Laptop.
+
+## TCP/IP socket abstraction
+
+The Linux and Host OSAL provide abstraction layers for the socket API. Currently, only UDP sockets have been imlemented. This is very useful to test TMTC handling either on the host computer directly (targeting localhost with a TMTC application) or on embedded Linux devices, sending TMTC packets via Ethernet.
+
+

From 952438f2528aa792638348fb5cce90a36e116837 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:25:19 +0100
Subject: [PATCH 1233/1292] README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f308ac9f..d74c4c76 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ Currently, the FSFW provides the following OSALs:
 - 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.
+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
 

From 6dde0ab8f66dc144b0323437f93e3e8d689eb41f Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:25:51 +0100
Subject: [PATCH 1234/1292] readme update

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d74c4c76..ba64f757 100644
--- a/README.md
+++ b/README.md
@@ -36,8 +36,8 @@ a starting point. The [configuration section](doc/README-config.md#top) provides
 
 ## Index
 
-[1. High-level overview](doc/README-highlevel.md#top)
-[2. Core components](doc/README-core.md#top)
-[3. OSAL overview](doc/README-osal.md#top)
+[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>
 
 

From 368b42c7b031cbc9c4689ed41576249b51c396f2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:26:48 +0100
Subject: [PATCH 1235/1292] formatting improvements

---
 doc/README-core.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/doc/README-core.md b/doc/README-core.md
index c47ae0f2..6431b831 100644
--- a/doc/README-core.md
+++ b/doc/README-core.md
@@ -16,9 +16,8 @@ Flight Software Framework
 * A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
 A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
 
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
+```cpp
+template <typename T> T* ObjectManagerIF::get( object_id_t id )
 ```
 * A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
 By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.

From 1f901a14ffcb8af674dfc7703b79eefb78bb5cf9 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:28:13 +0100
Subject: [PATCH 1236/1292] updated osal readme

---
 doc/README-osal.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-osal.md b/doc/README-osal.md
index 206596ac..6f8ce60f 100644
--- a/doc/README-osal.md
+++ b/doc/README-osal.md
@@ -6,7 +6,7 @@ Some specific information on the provided OSALs are provided.
 
 This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
 embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
-and real-time functionalities. This is generally done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+and real-time functionalities. For most UNIX systems, this is done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
 
 More information on how to set up a Linux system accordingly can be found in the 
 [Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)

From c956feafd6fc5932570181cde9e51b525f20980c Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:30:31 +0100
Subject: [PATCH 1237/1292] added new readme which will be filled later

---
 doc/README-devicehandlers.md | 2 +-
 doc/README-localpools.md     | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 doc/README-localpools.md

diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index 6e737cc5..8b6551aa 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -1 +1 @@
-## FSFW DeviceHandlers
\ No newline at end of file
+## Device Handlers
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
new file mode 100644
index 00000000..8dd83385
--- /dev/null
+++ b/doc/README-localpools.md
@@ -0,0 +1,3 @@
+## Local Data Pools
+
+

From e497c4ab1505f7438c96283a391f3b71de81fd8e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Sun, 10 Jan 2021 17:34:21 +0100
Subject: [PATCH 1238/1292] added new reamde file stubs

---
 README.md                 | 5 +++++
 doc/README-controllers.md | 1 +
 doc/README-pus.md         | 1 +
 3 files changed, 7 insertions(+)
 create mode 100644 doc/README-controllers.md
 create mode 100644 doc/README-pus.md

diff --git a/README.md b/README.md
index ba64f757..fb3be429 100644
--- a/README.md
+++ b/README.md
@@ -39,5 +39,10 @@ a starting point. The [configuration section](doc/README-config.md#top) provides
 [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>
+
 
 
diff --git a/doc/README-controllers.md b/doc/README-controllers.md
new file mode 100644
index 00000000..7af0652d
--- /dev/null
+++ b/doc/README-controllers.md
@@ -0,0 +1 @@
+## Controllers
diff --git a/doc/README-pus.md b/doc/README-pus.md
new file mode 100644
index 00000000..928d2eda
--- /dev/null
+++ b/doc/README-pus.md
@@ -0,0 +1 @@
+## PUS Services

From 60102465927399d7c66d4bd1e8a379770325212b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:21:41 +0100
Subject: [PATCH 1239/1292] rearchitectured a little bit

---
 datapool/PoolDataSetBase.cpp           | 15 ++++---
 datapool/PoolDataSetBase.h             |  4 +-
 datapoollocal/LocalPoolDataSetBase.cpp | 58 +++++++-------------------
 datapoollocal/LocalPoolDataSetBase.h   | 42 +++++++------------
 4 files changed, 43 insertions(+), 76 deletions(-)

diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 7731a8df..01069785 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -88,7 +88,8 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	{
 		if(protectEveryReadCommitCall) {
 			result = registeredVariables[count]->read(
-					MutexIF::TimeoutType::WAITING, mutexTimeout);
+					timeoutTypeForSingleVars,
+					mutexTimeoutForSingleVars);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -122,7 +123,8 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
 				registeredVariables[count]->commit(
-						MutexIF::TimeoutType::WAITING, mutexTimeout);
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -144,7 +146,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
 				result = registeredVariables[count]->commit(
-						MutexIF::TimeoutType::WAITING, mutexTimeout);
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -219,7 +222,9 @@ PoolVariableIF** PoolDataSetBase::getContainer() const {
 }
 
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
+		bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
+		uint32_t mutexTimeout) {
 	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->mutexTimeout = mutexTimeout;
+	this->timeoutTypeForSingleVars = timeoutType;
+	this->mutexTimeoutForSingleVars = mutexTimeout;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 665f4b33..6f3c5fa4 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -127,6 +127,7 @@ protected:
 	 * @param mutexTimeout
 	 */
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t mutexTimeout = 20);
 
 	/**
@@ -161,7 +162,8 @@ protected:
 
 private:
 	bool protectEveryReadCommitCall = false;
-	uint32_t mutexTimeout = 20;
+	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
 	void handleAlreadyReadDatasetCommit(
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index af492146..006239f6 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -19,15 +19,16 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
                 << "invalid!" << std::endl;
 #else
         fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                "invalid!\n\r");
+                "invalid!\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
+    mutexIfSingleDataCreator = hkManager->getMutexHandle();
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    mutex = MutexFactory::instance()->createMutex();
+    //mutex = MutexFactory::instance()->createMutex();
 
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
@@ -41,34 +42,29 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    if(hkOwner != nullptr) {
-    	hkManager = hkOwner->getHkManagerHandle();
-    }
+    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
+    mutexIfSingleDataCreator = hkManager->getMutexHandle();
     this->sid = sid;
-
-    mutex = MutexFactory::instance()->createMutex();
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
 		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool protectFunctions):
+		const size_t maxNumberOfVariables):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(protectFunctions) {
-	    mutex = MutexFactory::instance()->createMutex();
-	}
-
 }
 
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+	if(periodicHelper != nullptr) {
+		delete periodicHelper;
+	}
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(
 		MutexIF::TimeoutType timeoutType,
 		uint32_t timeoutMs) {
-	if(hkManager != nullptr) {
-	    MutexIF* poolMutex = hkManager->getMutexHandle();
-	    return poolMutex->lockMutex(timeoutType, timeoutMs);
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -146,9 +142,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->unlockMutex();
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -268,19 +263,10 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-	if(mutex == nullptr) {
-		this->changed = changed;
-		return;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-	if(mutex == nullptr) {
-		return changed;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, mutexTimeout);
     return changed;
 }
 
@@ -302,32 +288,16 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-	if(mutex == nullptr) {
-		return this->valid;
-	}
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-	mutex->lockMutex(timeoutType, mutexTimeout);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
         }
     }
     this->valid = valid;
-    mutex->unlockMutex();
 }
 
-void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
-			mutexTimeout);
-}
 
-void LocalPoolDataSetBase::setDataSetMutexTimeout(
-		MutexIF::TimeoutType timeoutType, uint32_t mutexTimeout) {
-	this->timeoutType = timeoutType;
-	this->mutexTimeout = mutexTimeout;
-}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index b44f607f..fdd8b3c7 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -57,7 +57,8 @@ public:
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
-	 * @brief	Constructor for users of local pool data.
+	 * @brief	Constructor for users of the local pool data, which need
+	 *          to access data created by one HK manager.
 	 * @details
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
@@ -68,13 +69,22 @@ public:
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * Simple constructor, if the dataset is not owner permanently by
-	 * a class with a HK manager.
+	 * Simple constructor, if the dataset is not the owner by
+	 * a class with a HK manager. This function should also be called by
+	 * classes which needs to access pool variables from different creators.
+	 *
+	 * If the class is intended to access pool variables from different
+	 * creators, the third argument should be set to true. The mutex
+	 * properties can be set with #setReadCommitProtectionBehaviour .
 	 * @param registeredVariablesArray
 	 * @param maxNumberOfVariables
+	 * @param protectEveryReadCommitCall If the pool variables are created by
+	 * multiple creators, this flag can be set to protect all read and
+	 * commit calls separately.
 	 */
 	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool protectFunctions = true);
+	        const size_t maxNumberOfVariables,
+			bool protectEveryReadCommitCall = true);
 
 	/**
 	 * @brief	The destructor automatically manages writing the valid
@@ -86,19 +96,6 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
-	/**
-	 * If the data is pulled from different local data pools, every read and
-	 * commit call should be mutex protected for thread safety.
-	 * This can be specified with the second parameter.
-	 * @param dataCreator
-	 * @param protectEveryReadCommit
-	 */
-	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-			uint32_t mutexTimeout = 20);
-
-	void setDataSetMutexTimeout(MutexIF::TimeoutType timeoutType,
-			uint32_t mutexTimeout);
-
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -150,13 +147,8 @@ public:
 
 protected:
 	sid_t sid;
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeout = 20;
-	/**
-	 * This mutex is required because the dataset can potentially be accessed
-	 * by multiple threads for information like change status or validity.
-	 */
-	MutexIF* mutex = nullptr;
+	//! This mutex is used if the data is created by one object only.
+	MutexIF* mutexIfSingleDataCreator = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
@@ -211,8 +203,6 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager = nullptr;
-
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
 	 * (most significant bit) to 7 (least significant bit)

From af7def3368a7e1ed7cec29242bc265c5c17bffd3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:26:46 +0100
Subject: [PATCH 1240/1292] some bugfixes

---
 datapoollocal/LocalPoolDataSetBase.cpp | 3 ++-
 internalError/InternalErrorDataset.h   | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 006239f6..163ef342 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -49,8 +49,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
 		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables):
+		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
 		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
 }
 
 
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index fa91116d..bd9062ed 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,11 +21,11 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId,
     		TM_HITS, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId,
     		QUEUE_HITS, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId,
     		STORE_HITS, this);
 };
 

From 5e251705f682642b683b1b91bae7c7a5cce9bce8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:33:02 +0100
Subject: [PATCH 1241/1292] getter function for object iD

---
 datapoollocal/LocalPoolDataSetBase.cpp | 29 +++++++++++++++++++-------
 datapoollocal/LocalPoolDataSetBase.h   |  2 ++
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 163ef342..8a39823e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -23,13 +23,15 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
-    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    hkManager = hkOwner->getHkManagerHandle();
+
+    if(hkManager != nullptr) {
+        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    }
+
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    //mutex = MutexFactory::instance()->createMutex();
-
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -42,8 +44,13 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
             sid.objectId);
-    LocalDataPoolManager* hkManager = hkOwner->getHkManagerHandle();
-    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    if(hkOwner != nullptr) {
+        hkManager = hkOwner->getHkManagerHandle();
+    }
+
+    if(hkManager != nullptr) {
+        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    }
     this->sid = sid;
 }
 
@@ -301,4 +308,12 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-
+object_id_t LocalPoolDataSetBase::getCreatorObjectId(object_id_t objectId) {
+	if(hkManager != nullptr) {
+		HasLocalDataPoolIF* owner = hkManager->getOwner();
+		if(owner != nullptr) {
+			return owner->getObjectId();
+		}
+	}
+	return objects::NO_OBJECT;
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index fdd8b3c7..ccbf7b96 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -145,6 +145,7 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
+	object_id_t getCreatorObjectId(object_id_t objectId);
 protected:
 	sid_t sid;
 	//! This mutex is used if the data is created by one object only.
@@ -211,6 +212,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
+	LocalDataPoolManager* hkManager = nullptr;
 
 };
 

From ef9ad60ba8a79be6e32f24aee9f6d2c3cb0c1d0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 16:38:25 +0100
Subject: [PATCH 1242/1292] doc update

---
 datapoollocal/LocalPoolDataSetBase.h | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index ccbf7b96..77a22f14 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -58,8 +58,10 @@ public:
 
 	/**
 	 * @brief	Constructor for users of the local pool data, which need
-	 *          to access data created by one HK manager.
+	 *          to access data created by one (!) HK manager.
 	 * @details
+	 * Unlike the first constructor, no component for periodic handling
+	 * will be initiated.
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
 	 * @param registeredVariablesArray
@@ -69,9 +71,13 @@ public:
 	        const size_t maxNumberOfVariables);
 
 	/**
-	 * Simple constructor, if the dataset is not the owner by
-	 * a class with a HK manager. This function should also be called by
-	 * classes which needs to access pool variables from different creators.
+	 * @brief	Simple constructor, if the dataset is not the owner by
+	 * 			a class with a HK manager.
+	 * @details
+	 * This constructor won't create components required for periodic handling
+	 * and it also won't try to deduce the HK manager because no SID is
+	 * supplied. This function should therefore be called by classes which need
+	 * to access pool variables from different creators.
 	 *
 	 * If the class is intended to access pool variables from different
 	 * creators, the third argument should be set to true. The mutex

From 217866c042d92bdfe7ea8bccab4338fd22b2bfda Mon Sep 17 00:00:00 2001
From: NguSa1 <sa.nguyen@gmx.de>
Date: Mon, 11 Jan 2021 19:44:07 +0100
Subject: [PATCH 1243/1292] SubscriptIF implementation started

---
 datapoollocal/LocalDataPoolManager.h          | 14 ++--
 .../ProvidesDataPoolSubscriptionIF.h          | 79 +++++++++++++++++++
 2 files changed, 88 insertions(+), 5 deletions(-)
 create mode 100644 datapoollocal/ProvidesDataPoolSubscriptionIF.h

diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90c..d4e2052c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
+#include <fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h>
 #include "HasLocalDataPoolIF.h"
 
 #include "../housekeeping/HousekeepingPacketDownlink.h"
@@ -47,11 +48,13 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager {
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
+
+
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -61,6 +64,7 @@ public:
     static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
     static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
+
     /**
      * This constructor is used by a class which wants to implement
      * a personal local data pool. The queueToUse can be supplied if it
@@ -116,7 +120,7 @@ public:
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination);
+			object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
@@ -130,7 +134,7 @@ public:
 	 */
     ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
-            object_id_t packetDestination = defaultHkDestination);
+            object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
@@ -149,7 +153,7 @@ public:
 	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
 	        object_id_t destinationObject,
 	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot);
+	        bool generateSnapshot) override;
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -168,7 +172,7 @@ public:
     ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
-            bool generateSnapshot);
+            bool generateSnapshot) override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
new file mode 100644
index 00000000..6f96d518
--- /dev/null
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -0,0 +1,79 @@
+#include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+
+
+class ProvidesDataPoolSubscriptionIF{
+public:
+	virtual ~ProvidesDataPoolSubscriptionIF(){};
+
+	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator
+	 * to generate housekeeping packets which are downlinked directly.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+			bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+			bool reportingEnabled,
+			bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+	/**
+	 * @brief   Subscribe for an notification message which will be sent if a
+	 *          pool variable has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param localPoolId Pool ID of the pool variable
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForVariableUpdateMessages(
+			const lp_id_t localPoolId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+};

From 0bf0d8e743de5978910726d3e73358ebe42b81f8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 20:20:39 +0100
Subject: [PATCH 1244/1292] stuff

---
 datapoollocal/HasLocalDataPoolIF.h | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 07c6882b..55b98c45 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -40,6 +40,8 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
+	friend class LocalPoolDataSetBase;
+	friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -64,9 +66,6 @@ public:
 	        LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
 	/**
 	 * Returns the minimum sampling frequency in milliseconds, which will
 	 * usually be the period the pool owner performs its periodic operation.
@@ -140,6 +139,12 @@ public:
 	        float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
+
+	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
+protected:
+
+	/** Can be used to get a handle to the local data pool manager. */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */

From 037bd83af9cd7f05680323e1ae856b73b31eb007 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 21:31:03 +0100
Subject: [PATCH 1245/1292] trying new interface

---
 controller/ExtendedControllerBase.cpp         |  5 ++
 controller/ExtendedControllerBase.h           |  2 +
 datapoollocal/AccessLocalDataPoolIF.h         | 17 ++++
 datapoollocal/HasLocalDataPoolIF.h            | 81 +++++++++++--------
 datapoollocal/LocalDataPoolManager.h          |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |  2 +-
 datapoollocal/LocalPoolDataSetBase.h          |  8 +-
 datapoollocal/LocalPoolObjectBase.h           |  2 +-
 .../ProvidesDataPoolSubscriptionIF.h          |  7 +-
 devicehandlers/DeviceHandlerBase.cpp          |  4 +
 devicehandlers/DeviceHandlerBase.h            |  4 +-
 internalError/InternalErrorReporter.cpp       |  5 ++
 internalError/InternalErrorReporter.h         |  1 +
 13 files changed, 100 insertions(+), 40 deletions(-)
 create mode 100644 datapoollocal/AccessLocalDataPoolIF.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 017acafe..101ac558 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -113,3 +113,8 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #endif
     return nullptr;
 }
+
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubsciptionInterface(
+		) {
+	return &localPoolManager;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 02c5728e..ec8d149d 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,6 +32,8 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
+   ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+
 protected:
     LocalDataPoolManager localPoolManager;
     ActionHelper actionHelper;
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
new file mode 100644
index 00000000..d204a088
--- /dev/null
+++ b/datapoollocal/AccessLocalDataPoolIF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+
+class AccessLocalDataPoolIF {
+public:
+	virtual ~AccessLocalDataPoolIF() {};
+
+protected:
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 55b98c45..5b296d97 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "ProvidesDataPoolSubscriptionIF.h"
 #include "locPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
@@ -40,8 +41,9 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
-	friend class LocalPoolDataSetBase;
-	friend class LocalPoolObjectBase;
+	friend class LocalDataPoolManager;
+	//friend class LocalPoolDataSetBase;
+	//friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -73,36 +75,10 @@ public:
 	 */
 	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
-
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
-#else
-	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
-	    		"Not overriden. Returning nullptr!\n");
-#endif
-	    return nullptr;
-	}
-
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
-     * @details
+     * @details  HasLocalDataPoolIF
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
      * @param storeId If a snapshot was requested, data will be located inside
@@ -127,8 +103,10 @@ public:
         return;
     }
 
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
+	/**
+	 * These function can be implemented by pool owner, if they are required
+	 * and used by the housekeeping message interface.
+	 * */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
@@ -140,11 +118,50 @@ public:
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 
+	/**
+	 * This function can be used by data pool consumers to retrieve a  handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
 protected:
 
-	/** Can be used to get a handle to the local data pool manager. */
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
 	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID. This function is protected to prevent users from
+     * using raw data set pointers which could not be thread-safe. Users
+     * should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract. This function is protected to prevent users from
+     * using raw pool variable pointers which could not be thread-safe.
+     * Users should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+#else
+	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
+#endif
+	    return nullptr;
+	}
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index d0a1181f..7a4e376c 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
-#include <fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h>
+#include "ProvidesDataPoolSubscriptionIF.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8a39823e..9fc3f924 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 77a22f14..58b65880 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
+#include "AccessLocalDataPoolIF.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
@@ -42,7 +43,8 @@ class PeriodicHousekeepingHelper;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
-        public MarkChangedIF {
+        public MarkChangedIF,
+		public AccessLocalDataPoolIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -52,7 +54,7 @@ public:
 	 * This constructor also initializes the components required for
 	 * periodic handling.
 	 */
-	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
@@ -218,7 +220,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* hkManager = nullptr;
+	AccessLocalDataPoolIF* hkManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 25ca594d..e7414131 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -54,7 +54,7 @@ protected:
     ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
 
     //! @brief  Pointer to the class which manages the HK pool.
-    LocalDataPoolManager* hkManager;
+    LocalDataPoolManager* hkManager = nullptr;
 
 	void reportReadCommitError(const char* variableType,
 			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 6f96d518..7f0cc754 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,10 +1,13 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
 #include <fsfw/datapoollocal/locPoolDefinitions.h>
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 
 
-class ProvidesDataPoolSubscriptionIF{
+class ProvidesDataPoolSubscriptionIF {
 public:
 	virtual ~ProvidesDataPoolSubscriptionIF(){};
 
@@ -77,3 +80,5 @@ public:
 			bool generateSnapshot) = 0;
 
 };
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4fa7b09c..de45c7d4 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1532,3 +1532,7 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 	}
 
 }
+
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubsciptionInterface() {
+	return &hkManager;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c745b4f..556c23a2 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -518,7 +518,9 @@ protected:
 				LocalDataPoolManager& poolManager) override;
 
 	/** Get the HK manager object handle */
-	virtual LocalDataPoolManager* getHkManagerHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
+
+    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 6842da8e..16c6412b 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -195,3 +195,8 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutType = timeoutType;
 	this->timeoutMs = timeoutMs;
 }
+
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubsciptionInterface(
+		) {
+	return &poolManager;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index c85057d6..1fcf733f 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,6 +46,7 @@ public:
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 5bc46bae02eb34a352df97ebafe9b594d799c604 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:18:42 +0100
Subject: [PATCH 1246/1292] reverted some stuff

---
 datapool/PoolDataSetBase.h             |  1 +
 datapoollocal/AccessLocalDataPoolIF.h  | 20 ++++++++++++--------
 datapoollocal/HasLocalDataPoolIF.h     |  4 ++--
 datapoollocal/LocalDataPoolManager.h   |  2 ++
 datapoollocal/LocalPoolDataSetBase.cpp |  2 +-
 datapoollocal/LocalPoolDataSetBase.h   |  7 +++----
 6 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 6f3c5fa4..d741dabc 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "PoolDataSetIF.h"
 #include "PoolVariableIF.h"
+#include "../serialize/SerializeIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
index d204a088..5bed34ad 100644
--- a/datapoollocal/AccessLocalDataPoolIF.h
+++ b/datapoollocal/AccessLocalDataPoolIF.h
@@ -4,14 +4,18 @@
 #include <fsfw/datapoollocal/LocalDataPoolManager.h>
 
 
-class AccessLocalDataPoolIF {
-public:
-	virtual ~AccessLocalDataPoolIF() {};
-
-protected:
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
-};
+//class AccessLocalDataPoolIF {
+//public:
+//	virtual ~AccessLocalDataPoolIF() {};
+//
+//protected:
+//
+//	template <class T> ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+//			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+//		return manager.fetchPoolEntry(localPoolId, poolEntry);
+//	}
+//
+//};
 
 
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 5b296d97..215ac8a5 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -42,8 +42,8 @@ using LocalDataPoolMapIter = LocalDataPool::iterator;
  */
 class HasLocalDataPoolIF {
 	friend class LocalDataPoolManager;
-	//friend class LocalPoolDataSetBase;
-	//friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+	friend class LocalPoolObjectBase;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 7a4e376c..8571aa02 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -17,6 +17,7 @@
 #include "../ipc/MutexHelper.h"
 
 #include <map>
+#include <vector>
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -53,6 +54,7 @@ class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
+	//friend class AccessLocalDataPoolIF;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 9fc3f924..8a39823e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -8,7 +8,7 @@
 #include <cmath>
 #include <cstring>
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
+LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         uint32_t setId, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables, bool periodicHandling):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 58b65880..5ad02269 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -43,8 +43,7 @@ class PeriodicHousekeepingHelper;
  * @ingroup data_pool
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
-        public MarkChangedIF,
-		public AccessLocalDataPoolIF {
+        public MarkChangedIF {
 	friend class LocalDataPoolManager;
 	friend class PeriodicHousekeepingHelper;
 public:
@@ -54,7 +53,7 @@ public:
 	 * This constructor also initializes the components required for
 	 * periodic handling.
 	 */
-	LocalPoolDataSetBase(AccessLocalDataPoolIF *hkOwner,
+	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 			uint32_t setId, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
@@ -220,7 +219,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	AccessLocalDataPoolIF* hkManager = nullptr;
+	LocalDataPoolManager* hkManager = nullptr;
 
 };
 

From 065f79615ad97b96bad42e1e588f172179c70281 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:21:21 +0100
Subject: [PATCH 1247/1292] compiling again

---
 datapoollocal/LocalPoolDataSetBase.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5ad02269..9df65b9c 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -3,11 +3,9 @@
 
 #include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
-#include "AccessLocalDataPoolIF.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../serialize/SerializeIF.h"
 
 #include <vector>
 

From a8873e608c7f86ca544221b02b583e664584c803 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:25:39 +0100
Subject: [PATCH 1248/1292] cleaning up

---
 controller/ExtendedControllerBase.cpp   |  3 +--
 controller/ExtendedControllerBase.h     |  2 +-
 datapoollocal/AccessLocalDataPoolIF.h   | 21 ---------------------
 datapoollocal/HasLocalDataPoolIF.h      |  2 +-
 datapoollocal/LocalDataPoolManager.h    |  3 ---
 devicehandlers/DeviceHandlerBase.cpp    |  2 +-
 devicehandlers/DeviceHandlerBase.h      |  2 +-
 internalError/InternalErrorReporter.cpp |  5 ++---
 internalError/InternalErrorReporter.h   |  2 +-
 9 files changed, 8 insertions(+), 34 deletions(-)
 delete mode 100644 datapoollocal/AccessLocalDataPoolIF.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 101ac558..3759d9c7 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -114,7 +114,6 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     return nullptr;
 }
 
-ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubsciptionInterface(
-		) {
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
 	return &localPoolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index ec8d149d..7e6d32da 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,7 +32,7 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-   ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+   ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
diff --git a/datapoollocal/AccessLocalDataPoolIF.h b/datapoollocal/AccessLocalDataPoolIF.h
deleted file mode 100644
index 5bed34ad..00000000
--- a/datapoollocal/AccessLocalDataPoolIF.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
-#define FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_
-
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
-
-
-//class AccessLocalDataPoolIF {
-//public:
-//	virtual ~AccessLocalDataPoolIF() {};
-//
-//protected:
-//
-//	template <class T> ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
-//			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
-//		return manager.fetchPoolEntry(localPoolId, poolEntry);
-//	}
-//
-//};
-
-
-#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 215ac8a5..263a4e79 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -123,7 +123,7 @@ public:
 	 * which allows subscriptions to dataset and variable updates.
 	 * @return
 	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() = 0;
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 protected:
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 8571aa02..6a87e716 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -54,10 +54,7 @@ class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
-	//friend class AccessLocalDataPoolIF;
 	friend void (Factory::setStaticFrameworkObjectIds)();
-
-
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index de45c7d4..8f64dd25 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1533,6 +1533,6 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 
 }
 
-ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubsciptionInterface() {
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
 	return &hkManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 556c23a2..19084358 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -520,7 +520,7 @@ protected:
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
-    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 16c6412b..6c722789 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -2,7 +2,7 @@
 
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
         uint32_t messageQueueDepth): SystemObject(setObjectId),
@@ -196,7 +196,6 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutMs = timeoutMs;
 }
 
-ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubsciptionInterface(
-		) {
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
 	return &poolManager;
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 1fcf733f..8085d918 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -46,7 +46,7 @@ public:
     virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ProvidesDataPoolSubscriptionIF* getSubsciptionInterface() override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 44955db341c4b732437e75bd00e134fa0c5da333 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:27:24 +0100
Subject: [PATCH 1249/1292] tab replacement

---
 devicehandlers/DeviceHandlerBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 19084358..a2f60392 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -520,7 +520,7 @@ protected:
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per

From 0be4c35b737d08d4ba6b78d664be8bba915b5e2d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:32:36 +0100
Subject: [PATCH 1250/1292] using 100 line width now

---
 datapoollocal/LocalDataPoolManager.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 2a0ec923..ff399aba 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -16,9 +16,9 @@
 object_id_t LocalDataPoolManager::defaultHkDestination =
         objects::PUS_SERVICE_3_HOUSEKEEPING;
 
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-                        appendValidityBuffer(appendValidityBuffer) {
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+		bool appendValidityBuffer):
+				appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
     	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
@@ -148,12 +148,11 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
-        HkReceiver& receiver, ReturnValue_t& status) {
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
+		ReturnValue_t& status) {
     MarkChangedIF* toReset = nullptr;
     if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
+        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
         	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
@@ -162,8 +161,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         if(poolObj->hasChanged()) {
             // prepare and send update notification.
             CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(
-                    &notification, receiver.dataId.localPoolId);
+            HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+            		receiver.dataId.localPoolId);
             ReturnValue_t result = hkQueue->sendMessage(
                     receiver.destinationQueue, &notification);
             if(result != HasReturnvaluesIF::RETURN_OK) {
@@ -174,8 +173,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
 
     }
     else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
+        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
         if(dataSet == nullptr) {
         	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);

From 58d813c249842e3c627123d0584607e5f3f338a6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:33:58 +0100
Subject: [PATCH 1251/1292] minor formatting stuff

---
 datapoollocal/LocalPoolObjectBase.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bb7822da..18414d40 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,9 +1,8 @@
 #include "LocalPoolObjectBase.h"
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
@@ -23,9 +22,9 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
     }
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
@@ -109,10 +108,9 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 	}
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << variableType << ": " << type << " call | " << errMsg
-			<< " | Owner: 0x" << std::hex << std::setw(8)
-			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
-			<< std::endl;
+	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+			<< " LPID: " << lpId << std::endl;
 #else
 	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
 			variableType, type, errMsg, objectId, lpId);

From fa5580cb7fb12cccaff1feac60f2eb21544e2bfa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:45:04 +0100
Subject: [PATCH 1252/1292] indentation

---
 datapoollocal/AccessLocalPoolF.h       |   17 +
 datapoollocal/LocalDataPoolManager.cpp | 1290 ++++++++++++------------
 datapoollocal/LocalPoolVariable.h      |    3 +-
 3 files changed, 664 insertions(+), 646 deletions(-)
 create mode 100644 datapoollocal/AccessLocalPoolF.h

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
new file mode 100644
index 00000000..7b507523
--- /dev/null
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -0,0 +1,17 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+
+#include <fsfw/datapool/PoolEntry.h>
+#include <fsfw/datapoollocal/locPoolDefinitions.h>
+
+template <typename T>
+class AccessLocalPoolIF {
+public:
+	virtual~ AccessLocalPoolIF() {};
+
+	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index ff399aba..995a54a4 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -14,808 +14,808 @@
 #include <cmath>
 
 object_id_t LocalDataPoolManager::defaultHkDestination =
-        objects::PUS_SERVICE_3_HOUSEKEEPING;
+		objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 		bool appendValidityBuffer):
-				appendValidityBuffer(appendValidityBuffer) {
-    if(owner == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+						appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
-        return;
-    }
-    this->owner = owner;
-    mutex = MutexFactory::instance()->createMutex();
-    if(mutex == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
-    }
+	}
 
-    hkQueue = queueToUse;
+	hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-    if(queueToUse == nullptr) {
-        // error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"initialize", QUEUE_OR_DESTINATION_INVALID);
-    }
-    hkQueue = queueToUse;
+	if(queueToUse == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"initialize", QUEUE_OR_DESTINATION_INVALID);
+	}
+	hkQueue = queueToUse;
 
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-    if(ipcStore == nullptr) {
-    	// error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
 
-    if(defaultHkDestination != objects::NO_OBJECT) {
-        AcceptsHkPacketsIF* hkPacketReceiver =
-                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-        if(hkPacketReceiver != nullptr) {
-            hkDestinationId = hkPacketReceiver->getHkQueue();
-        }
-        else {
-        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-        			"initialize", QUEUE_OR_DESTINATION_INVALID);
-        	return QUEUE_OR_DESTINATION_INVALID;
-        }
-    }
+	if(defaultHkDestination != objects::NO_OBJECT) {
+		AcceptsHkPacketsIF* hkPacketReceiver =
+				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+		if(hkPacketReceiver != nullptr) {
+			hkDestinationId = hkPacketReceiver->getHkQueue();
+		}
+		else {
+			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+					"initialize", QUEUE_OR_DESTINATION_INVALID);
+			return QUEUE_OR_DESTINATION_INVALID;
+		}
+	}
 
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
-        uint8_t nonDiagInvlFactor) {
-    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    return initializeHousekeepingPoolEntriesOnce();
+		uint8_t nonDiagInvlFactor) {
+	setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+	return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-    if(not mapInitialized) {
-        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-                *this);
-        if(result == HasReturnvaluesIF::RETURN_OK) {
-            mapInitialized = true;
-        }
-        return result;
-    }
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+				*this);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
 
 	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-    for(auto& receiver: hkReceiversMap) {
-        switch(receiver.reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_HK): {
-            handleHkUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_NOTIFICATION): {
-            handleNotificationUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            handleNotificationSnapshot(receiver, status);
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    resetHkUpdateResetHelper();
-    return status;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for(auto& receiver: hkReceiversMap) {
+		switch(receiver.reportingType) {
+		case(ReportingType::PERIODIC): {
+			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+				// Periodic packets shall only be generated from datasets.
+				continue;
+			}
+			performPeriodicHkGeneration(receiver);
+			break;
+		}
+		case(ReportingType::UPDATE_HK): {
+			handleHkUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_NOTIFICATION): {
+			handleNotificationUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_SNAPSHOT): {
+			handleNotificationSnapshot(receiver, status);
+			break;
+		}
+		default:
+			// This should never happen.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	resetHkUpdateResetHelper();
+	return status;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-        ReturnValue_t& status) {
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        // Update packets shall only be generated from datasets.
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-            receiver.dataId.sid);
-    if(dataSet->hasChanged()) {
-        // prepare and send update notification
-        ReturnValue_t result = generateHousekeepingPacket(
-                receiver.dataId.sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-    }
-    handleChangeResetLogic(receiver.dataType, receiver.dataId,
-            dataSet);
-    return HasReturnvaluesIF::RETURN_OK;
+		ReturnValue_t& status) {
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		// Update packets shall only be generated from datasets.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+			receiver.dataId.sid);
+	if(dataSet->hasChanged()) {
+		// prepare and send update notification
+		ReturnValue_t result = generateHousekeepingPacket(
+				receiver.dataId.sid, dataSet, true);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+	}
+	handleChangeResetLogic(receiver.dataType, receiver.dataId,
+			dataSet);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
 		ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
-            return POOLOBJECT_NOT_FOUND;
-        }
-        if(poolObj->hasChanged()) {
-            // prepare and send update notification.
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
-            		receiver.dataId.localPoolId);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = poolObj;
-        }
+	MarkChangedIF* toReset = nullptr;
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
+		if(poolObj->hasChanged()) {
+			// prepare and send update notification.
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+					receiver.dataId.localPoolId);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = poolObj;
+		}
 
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
-        if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationUpdate", DATASET_NOT_FOUND);
-            return DATASET_NOT_FOUND;
-        }
-        if(dataSet->hasChanged()) {
-            // prepare and send update notification
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationSetCommand(
-                    &notification, receiver.dataId.sid);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = dataSet;
-        }
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
+		if(dataSet->hasChanged()) {
+			// prepare and send update notification
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationSetCommand(
+					&notification, receiver.dataId.sid);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = dataSet;
+		}
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    // check whether data has changed and send messages in case it has.
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
-            return POOLOBJECT_NOT_FOUND;
-        }
+		HkReceiver& receiver, ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	// check whether data has changed and send messages in case it has.
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+				receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
 
-        if (not poolObj->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if (not poolObj->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), owner->getPoolObjectHandle(
+						receiver.dataId.localPoolId));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-                receiver.dataId.localPoolId, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue,
-                &notification);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = poolObj;
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"handleNotificationSnapshot", DATASET_NOT_FOUND);
-            return DATASET_NOT_FOUND;
-        }
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+				receiver.dataId.localPoolId, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue,
+				&notification);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = poolObj;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
 
-        if(not dataSet->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if(not dataSet->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotSetCommand(
-                &notification, receiver.dataId.sid, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = dataSet;
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotSetCommand(
+				&notification, receiver.dataId.sid, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = dataSet;
 
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
-    size_t updatePacketSize = updatePacket.getSerializedSize();
-    uint8_t *storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            updatePacket.getSerializedSize(), &storePtr);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    size_t serializedSize = 0;
-    result = updatePacket.serialize(&storePtr, &serializedSize,
-            updatePacketSize, SerializeIF::Endianness::MACHINE);
-    return result;;
+		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+	size_t updatePacketSize = updatePacket.getSerializedSize();
+	uint8_t *storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			updatePacket.getSerializedSize(), &storePtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t serializedSize = 0;
+	result = updatePacket.serialize(&storePtr, &serializedSize,
+			updatePacketSize, SerializeIF::Endianness::MACHINE);
+	return result;;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
-        DataType type, DataId dataId, MarkChangedIF* toReset) {
-    if(hkUpdateResetList == nullptr) {
-        // config error!
-        return;
-    }
-    HkUpdateResetList& listRef = *hkUpdateResetList;
-    for(auto& changeInfo: listRef) {
-        if(changeInfo.dataType != type) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::DATA_SET) and
-                (changeInfo.dataId.sid != dataId.sid)) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-            continue;
-        }
+		DataType type, DataId dataId, MarkChangedIF* toReset) {
+	if(hkUpdateResetList == nullptr) {
+		// config error!
+		return;
+	}
+	HkUpdateResetList& listRef = *hkUpdateResetList;
+	for(auto& changeInfo: listRef) {
+		if(changeInfo.dataType != type) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::DATA_SET) and
+				(changeInfo.dataId.sid != dataId.sid)) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+				(changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+			continue;
+		}
 
-        // only one update recipient, we can reset changes status immediately.
-        if(changeInfo.updateCounter <= 1) {
-            toReset->setChanged(false);
-        }
-        // All recipients have been notified, reset the changed flag.
-        if(changeInfo.currentUpdateCounter <= 1) {
-            toReset->setChanged(false);
-            changeInfo.currentUpdateCounter = 0;
-        }
-        // Not all recipiens have been notified yet, decrement.
-        else {
-            changeInfo.currentUpdateCounter--;
-        }
-        return;
-    }
+		// only one update recipient, we can reset changes status immediately.
+		if(changeInfo.updateCounter <= 1) {
+			toReset->setChanged(false);
+		}
+		// All recipients have been notified, reset the changed flag.
+		if(changeInfo.currentUpdateCounter <= 1) {
+			toReset->setChanged(false);
+			changeInfo.currentUpdateCounter = 0;
+		}
+		// Not all recipiens have been notified yet, decrement.
+		else {
+			changeInfo.currentUpdateCounter--;
+		}
+		return;
+	}
 }
 
 void LocalDataPoolManager::resetHkUpdateResetHelper() {
-    if(hkUpdateResetList == nullptr) {
-        return;
-    }
+	if(hkUpdateResetList == nullptr) {
+		return;
+	}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-    }
+	for(auto& changeInfo: *hkUpdateResetList) {
+		changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+	}
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-        bool enableReporting, float collectionInterval, bool isDiagnostics,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::PERIODIC;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(enableReporting);
-        dataSet->setDiagnostic(isDiagnostics);
-        dataSet->initializePeriodicHelper(collectionInterval,
-                owner->getPeriodicOperationFrequency(), isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(enableReporting);
+		dataSet->setDiagnostic(isDiagnostics);
+		dataSet->initializePeriodicHelper(collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
-    return HasReturnvaluesIF::RETURN_OK;
+	hkReceiversMap.push_back(hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
-        bool isDiagnostics, bool reportingEnabled,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
+		bool isDiagnostics, bool reportingEnabled,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::UPDATE_HK;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::UPDATE_HK;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(true);
-        dataSet->setDiagnostic(isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		dataSet->setReportingEnabled(true);
+		dataSet->setDiagnostic(isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
-        const uint32_t setId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const uint32_t setId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
-        const lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-    hkReceiver.dataId.localPoolId = localPoolId;
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const lp_id_t localPoolId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+	hkReceiver.dataId.localPoolId = localPoolId;
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
-        DataId dataId) {
-    if(hkUpdateResetList == nullptr) {
-        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-    }
+		DataId dataId) {
+	if(hkUpdateResetList == nullptr) {
+		hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+	}
 
-    for(auto& updateResetStruct: *hkUpdateResetList) {
-        if(dataType == DataType::DATA_SET) {
-            if(updateResetStruct.dataId.sid == dataId.sid) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
-        else {
-            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
+	for(auto& updateResetStruct: *hkUpdateResetList) {
+		if(dataType == DataType::DATA_SET) {
+			if(updateResetStruct.dataId.sid == dataId.sid) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
+		else {
+			if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
 
-    }
-    HkUpdateResetHelper hkUpdateResetHelper;
-    hkUpdateResetHelper.currentUpdateCounter = 1;
-    hkUpdateResetHelper.updateCounter = 1;
-    hkUpdateResetHelper.dataType = dataType;
-    if(dataType == DataType::DATA_SET) {
-        hkUpdateResetHelper.dataId.sid = dataId.sid;
-    }
-    else {
-        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-    }
-    hkUpdateResetList->push_back(hkUpdateResetHelper);
+	}
+	HkUpdateResetHelper hkUpdateResetHelper;
+	hkUpdateResetHelper.currentUpdateCounter = 1;
+	hkUpdateResetHelper.updateCounter = 1;
+	hkUpdateResetHelper.dataType = dataType;
+	if(dataType == DataType::DATA_SET) {
+		hkUpdateResetHelper.dataId.sid = dataId.sid;
+	}
+	else {
+		hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+	}
+	hkUpdateResetList->push_back(hkUpdateResetHelper);
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-        CommandMessage* message) {
-    Command_t command = message->getCommand();
-    sid_t sid = HousekeepingMessage::getSid(message);
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(command) {
-    // Houskeeping interface handling.
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, true);
-        break;
-    }
+		CommandMessage* message) {
+	Command_t command = message->getCommand();
+	sid_t sid = HousekeepingMessage::getSid(message);
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	switch(command) {
+	// Houskeeping interface handling.
+	case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, true);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, true);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, true);
+		break;
+	}
 
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, false);
-        break;
-    }
+	case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, false);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, false);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, false);
+		break;
+	}
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
-        return generateSetStructurePacket(sid, true);
-    }
+	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, true);
+	}
 
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
-        return generateSetStructurePacket(sid, false);
-    }
-    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
-    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-        float newCollIntvl = 0;
-        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-                &newCollIntvl);
-        if(command == HousekeepingMessage::
-                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-            result = changeCollectionInterval(sid, newCollIntvl, true);
-        }
-        else {
-            result = changeCollectionInterval(sid, newCollIntvl, false);
-        }
-        break;
-    }
+	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, false);
+	}
+	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+		float newCollIntvl = 0;
+		HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+				&newCollIntvl);
+		if(command == HousekeepingMessage::
+				MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+			result = changeCollectionInterval(sid, newCollIntvl, true);
+		}
+		else {
+			result = changeCollectionInterval(sid, newCollIntvl, false);
+		}
+		break;
+	}
 
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-                and dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-                and not dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-                dataSet, true);
-    }
+	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+				and dataSet->isDiagnostics()) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+				and not dataSet->isDiagnostics()) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				dataSet, true);
+	}
 
-    // Notification handling.
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDataset(sid);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-        lp_id_t locPoolId = HousekeepingMessage::
-                getUpdateNotificationVariableCommand(message);
-        owner->handleChangedPoolVariable(locPoolId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-        store_address_t storeId;
-        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-        owner->handleChangedDataset(sid, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-        store_address_t storeId;
-        lp_id_t localPoolId = HousekeepingMessage::
-                getUpdateSnapshotVariableCommand(message, &storeId);
-        owner->handleChangedPoolVariable(localPoolId, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+	// Notification handling.
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+		owner->handleChangedDataset(sid);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+		lp_id_t locPoolId = HousekeepingMessage::
+				getUpdateNotificationVariableCommand(message);
+		owner->handleChangedPoolVariable(locPoolId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+		store_address_t storeId;
+		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+		owner->handleChangedDataset(sid, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+		store_address_t storeId;
+		lp_id_t localPoolId = HousekeepingMessage::
+				getUpdateSnapshotVariableCommand(message, &storeId);
+		owner->handleChangedPoolVariable(localPoolId, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
 
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
+	default:
+		return CommandMessageIF::UNKNOWN_COMMAND;
+	}
 
-    CommandMessage reply;
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-    }
-    else {
-        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-    }
-    hkQueue->sendMessage(hkDestinationId, &reply);
-    return result;
+	CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-        lp_id_t localPoolId) {
-    auto poolIter = localPoolMap.find(localPoolId);
-    if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
-    			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
-    }
-    poolIter->second->print();
-    return HasReturnvaluesIF::RETURN_OK;
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
+				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
+		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-    return mutex;
+	return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
-    return owner;
+	return owner;
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        LocalPoolDataSetBase* dataSet, bool forDownlink,
-        MessageQueueId_t destination) {
-    if(dataSet == nullptr) {
-        // Configuration error.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateHousekeepingPacket",
-    			DATASET_NOT_FOUND);
-        return DATASET_NOT_FOUND;
-    }
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
-    store_address_t storeId;
-    HousekeepingPacketDownlink hkPacket(sid, dataSet);
-    size_t serializedSize = 0;
-    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-            forDownlink, &serializedSize);
-    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-        return result;
-    }
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+		return result;
+	}
 
-    // and now we set a HK message and send it the HK packet destination.
-    CommandMessage hkMessage;
-    if(dataSet->isDiagnostics()) {
-        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-    }
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	if(dataSet->isDiagnostics()) {
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+	}
 
-    if(hkQueue == nullptr) {
-        // error, no queue available to send packet with.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateHousekeepingPacket",
-    			QUEUE_OR_DESTINATION_INVALID);
-        return QUEUE_OR_DESTINATION_INVALID;
-    }
-    if(destination == MessageQueueIF::NO_QUEUE) {
-        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-            // error, all destinations invalid
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-        			"generateHousekeepingPacket",
-        			QUEUE_OR_DESTINATION_INVALID);
-        }
-        destination = hkDestinationId;
-    }
+	if(hkQueue == nullptr) {
+		// error, no queue available to send packet with.
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+			// error, all destinations invalid
+			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+					"generateHousekeepingPacket",
+					QUEUE_OR_DESTINATION_INVALID);
+		}
+		destination = hkDestinationId;
+	}
 
-    return hkQueue->sendMessage(destination, &hkMessage);
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        HousekeepingPacketDownlink& hkPacket,
-        store_address_t& storeId, bool forDownlink,
-        size_t* serializedSize) {
-    uint8_t* dataPtr = nullptr;
-    const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            maxSize, &dataPtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
+		HousekeepingPacketDownlink& hkPacket,
+		store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
+	uint8_t* dataPtr = nullptr;
+	const size_t maxSize = hkPacket.getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			maxSize, &dataPtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
-    if(forDownlink) {
-        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-                SerializeIF::Endianness::BIG);
-    }
-    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-            SerializeIF::Endianness::MACHINE);
+	if(forDownlink) {
+		return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+			SerializeIF::Endianness::MACHINE);
 }
 
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
-        uint8_t nonDiagInvlFactor) {
-    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
+		uint8_t nonDiagInvlFactor) {
+	this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-    sid_t sid = receiver.dataId.sid;
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"performPeriodicHkGeneration",
-    			DATASET_NOT_FOUND);
-    	return;
-    }
+	sid_t sid = receiver.dataId.sid;
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return;
+	}
 
-    if(not dataSet->getReportingEnabled()) {
-        return;
-    }
+	if(not dataSet->getReportingEnabled()) {
+		return;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // Configuration error.
-        return;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
 
-    if(not dataSet->periodicHelper->checkOpNecessary()) {
-        return;
-    }
+	if(not dataSet->periodicHelper->checkOpNecessary()) {
+		return;
+	}
 
-    ReturnValue_t result = generateHousekeepingPacket(
-            sid, dataSet, true);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        // configuration error
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalDataPoolManager::performHkOperation: "
-                << "HK generation failed." << std::endl;
+		sif::warning << "LocalDataPoolManager::performHkOperation: "
+				<< "HK generation failed." << std::endl;
 #else
-        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
-        		"HK generation failed.\n");
+		fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+				"HK generation failed.\n");
 #endif
-    }
+	}
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-        bool enable, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if((dataSet->isDiagnostics() and not isDiagnostics) or
-            (not dataSet->isDiagnostics() and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		bool enable, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if((dataSet->isDiagnostics() and not isDiagnostics) or
+			(not dataSet->isDiagnostics() and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if((dataSet->getReportingEnabled() and enable) or
-            (not dataSet->getReportingEnabled() and not enable)) {
-        return REPORTING_STATUS_UNCHANGED;
-    }
+	if((dataSet->getReportingEnabled() and enable) or
+			(not dataSet->getReportingEnabled() and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
 
-    dataSet->setReportingEnabled(enable);
-    return HasReturnvaluesIF::RETURN_OK;
+	dataSet->setReportingEnabled(enable);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-        float newCollectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		float newCollectionInterval, bool isDiagnostics) {
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // config error
-        return PERIODIC_HELPER_INVALID;
-    }
+	if(dataSet->periodicHelper == nullptr) {
+		// config error
+		return PERIODIC_HELPER_INVALID;
+	}
 
-    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-    return HasReturnvaluesIF::RETURN_OK;
+	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-        bool isDiagnostics) {
-    // Get and check dataset first.
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"performPeriodicHkGeneration",
-    			DATASET_NOT_FOUND);
-        return DATASET_NOT_FOUND;
-    }
+		bool isDiagnostics) {
+	// Get and check dataset first.
+	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
 
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    bool valid = dataSet->isValid();
-    bool reportingEnabled = dataSet->getReportingEnabled();
-    float collectionInterval =
-            dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = dataSet->getReportingEnabled();
+	float collectionInterval =
+			dataSet->periodicHelper->getCollectionIntervalInSeconds();
 
-    // Generate set packet which can be serialized.
-    HousekeepingSetPacket setPacket(sid,
-            reportingEnabled, valid, collectionInterval, dataSet);
-    size_t expectedSize = setPacket.getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
-    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+	// Generate set packet which can be serialized.
+	HousekeepingSetPacket setPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
-        return result;
-    }
+		return result;
+	}
 
-    // Serialize set packet into store.
-    size_t size = 0;
-    result = setPacket.serialize(&storePtr, &size, expectedSize,
-            SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
-    			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+	// Serialize set packet into store.
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
-    }
+	}
 
-    // Send structure reporting reply.
-    CommandMessage reply;
-    if(isDiagnostics) {
-        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-                sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkStuctureReportReply(&reply,
-                sid, storeId);
-    }
+	// Send structure reporting reply.
+	CommandMessage reply;
+	if(isDiagnostics) {
+		HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+				sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkStuctureReportReply(&reply,
+				sid, storeId);
+	}
 
-    hkQueue->reply(&reply);
-    return result;
+	hkQueue->reply(&reply);
+	return result;
 }
 
 void LocalDataPoolManager::clearReceiversList() {
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 22019c2f..26eb9fce 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -4,6 +4,7 @@
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
+#include "AccessLocalPoolF.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
@@ -23,7 +24,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVariable: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase, public AccessLocalPoolIF<T> {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVariable() = delete;

From 0109428d470193820d5cd66bdee83db216ea9f73 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Mon, 11 Jan 2021 22:46:40 +0100
Subject: [PATCH 1253/1292] indentation

---
 datapoollocal/LocalDataPoolManager.cpp |  5 +-
 datapoollocal/LocalPoolObjectBase.cpp  | 74 +++++++++++++-------------
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 995a54a4..de851787 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -13,12 +13,11 @@
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination =
-		objects::PUS_SERVICE_3_HOUSEKEEPING;
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
 
 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
 		bool appendValidityBuffer):
-						appendValidityBuffer(appendValidityBuffer) {
+		appendValidityBuffer(appendValidityBuffer) {
 	if(owner == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 18414d40..c74380cf 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -3,76 +3,76 @@
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    if(hkOwner == nullptr) {
+	}
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-                << "owner is a invalid!" << std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+				<< "owner is a invalid!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if (dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+				localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
+	}
+	HasLocalDataPoolIF* hkOwner =
+			objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface"
+				<< " HasLocalDataPoolIF!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if(dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	hkManager = hkOwner->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-    return readWriteMode;
+	return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-    return valid;
+	return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-    this->valid = valid;
+	this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-    return localPoolId;
+	return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-    this->localPoolId = poolId;
+	this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {

From bb10c259096d9837c1dfe35b4d6a55c846eca0f6 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 00:13:49 +0100
Subject: [PATCH 1254/1292] introduced new accessor IF

---
 controller/ExtendedControllerBase.cpp    |  4 ++++
 controller/ExtendedControllerBase.h      |  1 +
 datapoollocal/AccessLocalPoolF.h         | 22 +++++++++++++++----
 datapoollocal/HasLocalDataPoolIF.h       |  5 +++--
 datapoollocal/LocalDataPoolManager.cpp   | 18 ++++++++++++---
 datapoollocal/LocalDataPoolManager.h     |  9 ++++++--
 datapoollocal/LocalPoolDataSetBase.cpp   | 28 +++++++++++-------------
 datapoollocal/LocalPoolDataSetBase.h     |  4 ++--
 datapoollocal/LocalPoolVariable.h        |  2 +-
 datapoollocal/LocalPoolVariable.tpp      |  8 +++----
 datapoollocal/LocalPoolVector.tpp        |  8 +++----
 devicehandlers/DeviceHandlerBase.cpp     |  4 ++++
 devicehandlers/DeviceHandlerBase.h       |  3 +++
 devicehandlers/DeviceHandlerThermalSet.h |  2 +-
 internalError/InternalErrorReporter.cpp  |  4 ++++
 internalError/InternalErrorReporter.h    |  1 +
 16 files changed, 85 insertions(+), 38 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 3759d9c7..2b72a89d 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -106,6 +106,10 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
     return commandQueue->getId();
 }
 
+AccessLocalPoolIF* ExtendedControllerBase::getAccessorHandle() {
+	return &localPoolManager;
+}
+
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 7e6d32da..47c180e6 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -33,6 +33,7 @@ public:
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+   AccessLocalPoolIF* getAccessorHandle() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 7b507523..51d2ec46 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,17 +1,31 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-#include <fsfw/datapool/PoolEntry.h>
 #include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/datapool/PoolEntry.h>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
-template <typename T>
 class AccessLocalPoolIF {
 public:
-	virtual~ AccessLocalPoolIF() {};
+	virtual ~AccessLocalPoolIF() {};
 
-	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+	virtual ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) = 0;
+	virtual object_id_t getCreatorObjectId() const = 0;
+
+protected:
+
+	//virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
+//template <typename T>
+//class AccessLocalPoolTypedIF {
+//public:
+//	virtual ~AccessLocalPoolTypedIF() {};
+//
+//	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
+//};
+
 
 
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 263a4e79..967abd4a 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
+#include "AccessLocalPoolF.h"
 #include "ProvidesDataPoolSubscriptionIF.h"
 #include "locPoolDefinitions.h"
 
@@ -54,8 +55,6 @@ public:
 
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	virtual object_id_t getObjectId() const = 0;
-
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -124,6 +123,8 @@ public:
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+
+	virtual AccessLocalPoolIF* getAccessorHandle() = 0;
 protected:
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index de851787..4aeb8677 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -410,7 +410,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
+	hkReceiver.dataId.sid = sid_t(this->getCreatorObjectId(), setId);
 	hkReceiver.destinationQueue = targetQueueId;
 	hkReceiver.objectId = destinationObject;
 	if(generateSnapshot) {
@@ -822,6 +822,18 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
+ReturnValue_t LocalDataPoolManager::retrieveLocalPoolMutex(MutexIF *mutex) {
+	if(this->mutex == nullptr) {
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	mutex = this->mutex;
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+object_id_t LocalDataPoolManager::getCreatorObjectId() const {
+	return owner->getAccessorHandle()->getCreatorObjectId();
+}
+
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
@@ -857,7 +869,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -868,7 +880,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 6a87e716..3544c944 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -50,10 +50,11 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF {
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
+		public AccessLocalPoolIF {
 	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+	//friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
@@ -176,6 +177,8 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
+    ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) override;
+
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
 	 * than diagnostic packets.
@@ -259,6 +262,8 @@ public:
      * the insertion operations allocate dynamically.
      */
     void clearReceiversList();
+
+    object_id_t getCreatorObjectId() const override;
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 8a39823e..c4bed0a4 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -23,13 +23,14 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    localPoolAccessor = hkOwner->getAccessorHandle();
 
-    if(hkManager != nullptr) {
-        mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    if(localPoolAccessor != nullptr) {
+    	localPoolAccessor->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
+        //mutexIfSingleDataCreator = hkManager->getAc();
     }
 
-    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.objectId = localPoolAccessor->getCreatorObjectId();
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
@@ -42,15 +43,15 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+	AccessLocalPoolIF* hkOwner = objectManager->get<AccessLocalPoolIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-        hkManager = hkOwner->getHkManagerHandle();
+        ReturnValue_t result = hkOwner->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
     }
 
-    if(hkManager != nullptr) {
-        mutexIfSingleDataCreator = hkManager->getMutexHandle();
-    }
+    //if(hkManager != nullptr) {
+    //    mutexIfSingleDataCreator = hkManager->getMutexHandle();
+    //}
     this->sid = sid;
 }
 
@@ -308,12 +309,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-object_id_t LocalPoolDataSetBase::getCreatorObjectId(object_id_t objectId) {
-	if(hkManager != nullptr) {
-		HasLocalDataPoolIF* owner = hkManager->getOwner();
-		if(owner != nullptr) {
-			return owner->getObjectId();
-		}
+object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
+	if(localPoolAccessor != nullptr) {
+		return localPoolAccessor->getCreatorObjectId();
 	}
 	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 9df65b9c..442d93c8 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -150,7 +150,7 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
-	object_id_t getCreatorObjectId(object_id_t objectId);
+	object_id_t getCreatorObjectId();
 protected:
 	sid_t sid;
 	//! This mutex is used if the data is created by one object only.
@@ -217,7 +217,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* hkManager = nullptr;
+	AccessLocalPoolIF* localPoolAccessor = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 26eb9fce..eac91516 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -24,7 +24,7 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVariable: public LocalPoolObjectBase, public AccessLocalPoolIF<T> {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
 	LocalPoolVariable() = delete;
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index ef94b620..e55ea2a0 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -33,7 +33,7 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
 				localPoolId);
@@ -43,7 +43,7 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
 				false, ownerObjectId, localPoolId);
 		return result;
@@ -80,7 +80,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
 				localPoolId);
@@ -90,7 +90,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
 				false, ownerObjectId, localPoolId);
 		return result;
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index f311c23d..24421b0b 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -32,7 +32,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
 				localPoolId);
@@ -44,7 +44,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
 				localPoolId);
 		return result;
@@ -71,7 +71,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector",
 				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
 				localPoolId);
@@ -80,7 +80,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	PoolEntry<T>* poolEntry = nullptr;
 	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
 				localPoolId);
 		return result;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 8f64dd25..2492535a 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1488,6 +1488,10 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
+AccessLocalPoolIF* DeviceHandlerBase::getAccessorHandle() {
+	return &hkManager;
+}
+
 void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index a2f60392..f3f208a6 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -517,11 +517,14 @@ protected:
 	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
+
 	/** Get the HK manager object handle */
 	LocalDataPoolManager* getHkManagerHandle() override;
 
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
+	AccessLocalPoolIF* getAccessorHandle() override;
+
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
 	 * 			performOperation(). Default implementation is empty.
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 239012e2..0fabd3b3 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -15,7 +15,7 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
 			lp_id_t heaterRequestId =
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
-			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
+			DeviceHandlerThermalSet(hkOwner->getAccessorHandle()->getCreatorObjectId(), setId,
 					thermalStateId, heaterRequestId) {}
 
 	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 6c722789..0817c080 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -134,6 +134,10 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
+AccessLocalPoolIF* InternalErrorReporter::getAccessorHandle() {
+	return &poolManager;
+}
+
 void InternalErrorReporter::incrementStoreHits() {
 	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8085d918..5bd5785a 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -47,6 +47,7 @@ public:
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
     ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	AccessLocalPoolIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 071ce21f09a0afd7abf10e34e003d76a6e24e02a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:12:44 +0100
Subject: [PATCH 1255/1292] renamed namepsace for printers

---
 serviceinterface/ServiceInterfacePrinter.cpp  | 60 +++++++++----------
 serviceinterface/ServiceInterfacePrinter.h    |  2 +-
 serviceinterface/serviceInterfaceDefintions.h |  2 +-
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index fff6753b..f3d34bb0 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,7 +6,7 @@
 #include <cstdarg>
 #include <cstdint>
 
-static fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG_LEVEL;
+static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
@@ -15,7 +15,7 @@ static bool addCrAtEnd = false;
 #if FSFW_DISABLE_PRINTOUT == 0
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
-void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 	if(not consoleInitialized) {
@@ -32,38 +32,38 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
-    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+    if(printType == sif::PrintLevel::NONE or printType > printLevel) {
         return;
     }
 
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
+    if(printType == sif::PrintLevel::INFO_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
+    else if(printType == sif::PrintLevel::DEBUG_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
+    else if(printType == sif::PrintLevel::WARNING_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
+    else if(printType == sif::PrintLevel::ERROR_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO_LEVEL) {
+   if (printType == sif::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG_LEVEL) {
+   if(printType == sif::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING_LEVEL) {
+   if(printType == sif::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_LEVEL) {
+   if(printType == sif::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -88,51 +88,51 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 }
 
 
-void fsfw::printInfo(const char *fmt, ...) {
+void sif::printInfo(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::printWarning(const char *fmt, ...) {
+void sif::printWarning(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::printDebug(const char *fmt, ...) {
+void sif::printDebug(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
     va_end(args);
 }
 
-void fsfw::setToAddCrAtEnd(bool addCrAtEnd_) {
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) {
 	addCrAtEnd = addCrAtEnd_;
 }
 
-void fsfw::printError(const char *fmt, ...) {
+void sif::printError(const char *fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_LEVEL, fmt, args);
+    fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
     va_end(args);
 }
 
 #else
 
-void fsfw::printInfo(const char *fmt, ...) {}
-void fsfw::printWarning(const char *fmt, ...) {}
-void fsfw::printDebug(const char *fmt, ...) {}
-void fsfw::printError(const char *fmt, ...) {}
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
 
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
+void sif::setPrintLevel(PrintLevel printLevel_) {
 	printLevel = printLevel_;
 }
 
-fsfw::PrintLevel fsfw::getPrintLevel() {
+sif::PrintLevel sif::getPrintLevel() {
 	return printLevel;
 }
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index f49ccbb7..fbdccdd1 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -2,7 +2,7 @@
 #include <cstdio>
 #endif
 
-namespace fsfw {
+namespace sif {
 
 enum PrintLevel {
 	NONE = 0,
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index de445907..eb36a84b 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 
-namespace fsfw {
+namespace sif {
 
 enum class OutputTypes {
 	OUT_INFO,

From 7e394ea15fd199d9adcef11b779e12bb747cdcaa Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:18:18 +0100
Subject: [PATCH 1256/1292] replaced all fsfw:: by sif:: for printouts

---
 datapool/PoolEntry.cpp                        |  4 +-
 datapoollocal/HasLocalDataPoolIF.h            |  2 +-
 datapoollocal/LocalDataPoolManager.cpp        | 54 +++++++++----------
 datapoollocal/LocalDataPoolManager.h          |  6 +--
 datapoollocal/LocalPoolDataSetBase.cpp        |  6 +--
 datapoollocal/LocalPoolObjectBase.cpp         |  2 +-
 datapoollocal/LocalPoolVector.tpp             |  4 +-
 devicehandlers/DeviceHandlerBase.cpp          | 36 ++++++-------
 devicehandlers/DeviceHandlerBase.h            |  2 +-
 globalfunctions/arrayprinter.cpp              |  2 +-
 osal/linux/BinarySemaphore.cpp                |  4 +-
 osal/linux/MessageQueue.cpp                   |  2 +-
 osal/linux/PosixThread.cpp                    |  4 +-
 osal/linux/TmTcUnixUdpBridge.cpp              |  2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp   | 10 ++--
 unittest/internal/UnittDefinitions.cpp        |  2 +-
 .../user/unittest/core/CatchDefinitions.cpp   |  2 +-
 17 files changed, 72 insertions(+), 72 deletions(-)

diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 1e99a28c..a5867222 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -73,8 +73,8 @@ void PoolEntry<T>::print() {
 	 sif::info << "PoolEntry information." << std::endl;
 	 sif::info << "PoolEntry validity: " << validString << std::endl;
 #else
-	 fsfw::printInfo("PoolEntry information.\n");
-	 fsfw::printInfo("PoolEntry validity: %s\n", validString);
+	 sif::printInfo("PoolEntry information.\n");
+	 sif::printInfo("PoolEntry validity: %s\n", validString);
 #endif
 	arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
 }
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 07c6882b..3aa9a554 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -94,7 +94,7 @@ public:
 	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
 	            << ". Returning nullptr!" << std::endl;
 #else
-	    fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
 	    		"Not overriden. Returning nullptr!\n");
 #endif
 	    return nullptr;
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 2a0ec923..0c5e6d70 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -20,7 +20,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
         MessageQueueIF* queueToUse, bool appendValidityBuffer):
                         appendValidityBuffer(appendValidityBuffer) {
     if(owner == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Invalid supplied owner");
         return;
@@ -28,7 +28,7 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
     this->owner = owner;
     mutex = MutexFactory::instance()->createMutex();
     if(mutex == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not create mutex");
     }
@@ -41,7 +41,7 @@ LocalDataPoolManager::~LocalDataPoolManager() {}
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     if(queueToUse == nullptr) {
         // error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"initialize", QUEUE_OR_DESTINATION_INVALID);
     }
     hkQueue = queueToUse;
@@ -49,7 +49,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
     ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
     if(ipcStore == nullptr) {
     	// error, all destinations invalid
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -63,7 +63,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
             hkDestinationId = hkPacketReceiver->getHkQueue();
         }
         else {
-        	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+        	printWarningOrError(sif::OutputTypes::OUT_ERROR,
         			"initialize", QUEUE_OR_DESTINATION_INVALID);
         	return QUEUE_OR_DESTINATION_INVALID;
         }
@@ -88,7 +88,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
         return result;
     }
 
-	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+	printWarningOrError(sif::OutputTypes::OUT_WARNING,
 			"initialize", HasReturnvaluesIF::RETURN_FAILED,
 			"The map should only be initialized once");
     return HasReturnvaluesIF::RETURN_OK;
@@ -155,7 +155,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -177,7 +177,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationUpdate", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -209,7 +209,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
                 receiver.dataId.localPoolId);
         if(poolObj == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
             return POOLOBJECT_NOT_FOUND;
         }
@@ -247,7 +247,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
         LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
                 receiver.dataId.sid);
         if(dataSet == nullptr) {
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"handleNotificationSnapshot", DATASET_NOT_FOUND);
             return DATASET_NOT_FOUND;
         }
@@ -355,7 +355,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -385,7 +385,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
     AcceptsHkPacketsIF* hkReceiverObject =
             objectManager->get<AcceptsHkPacketsIF>(packetDestination);
     if(hkReceiverObject == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
     }
@@ -594,7 +594,7 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
         lp_id_t localPoolId) {
     auto poolIter = localPoolMap.find(localPoolId);
     if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING, "printPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
     			 HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
         return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
     }
@@ -615,7 +615,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
         MessageQueueId_t destination) {
     if(dataSet == nullptr) {
         // Configuration error.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -641,7 +641,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
     if(hkQueue == nullptr) {
         // error, no queue available to send packet with.
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);
         return QUEUE_OR_DESTINATION_INVALID;
@@ -649,7 +649,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     if(destination == MessageQueueIF::NO_QUEUE) {
         if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
             // error, all destinations invalid
-        	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+        	printWarningOrError(sif::OutputTypes::OUT_WARNING,
         			"generateHousekeepingPacket",
         			QUEUE_OR_DESTINATION_INVALID);
         }
@@ -688,7 +688,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
     sid_t sid = receiver.dataId.sid;
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
     	return;
@@ -715,7 +715,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
         sif::warning << "LocalDataPoolManager::performHkOperation: "
                 << "HK generation failed." << std::endl;
 #else
-        fsfw::printWarning("LocalDataPoolManager::performHkOperation: "
+        sif::printWarning("LocalDataPoolManager::performHkOperation: "
         		"HK generation failed.\n");
 #endif
     }
@@ -762,7 +762,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     // Get and check dataset first.
     LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
     if(dataSet == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"performPeriodicHkGeneration",
     			DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
@@ -789,7 +789,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     ReturnValue_t result = ipcStore->getFreeElement(&storeId,
             expectedSize,&storePtr);
     if(result != HasReturnvaluesIF::RETURN_OK) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not get free element from IPC store.");
         return result;
@@ -800,7 +800,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
     result = setPacket.serialize(&storePtr, &size, expectedSize,
             SerializeIF::Endianness::BIG);
     if(expectedSize != size) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+    	printWarningOrError(sif::OutputTypes::OUT_WARNING,
     			"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
 				"Expected size is not equal to serialized size");
     }
@@ -825,7 +825,7 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
-void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
+void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		const char* functionName, ReturnValue_t error, const char* errorPrint) {
 	if(errorPrint == nullptr) {
 		if(error == DATASET_NOT_FOUND) {
@@ -835,7 +835,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 			errorPrint = "Pool Object not found";
 		}
 		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
-			if(outputType == fsfw::OutputTypes::OUT_WARNING) {
+			if(outputType == sif::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -856,25 +856,25 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 		}
 	}
 
-	if(outputType == fsfw::OutputTypes::OUT_WARNING) {
+	if(outputType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
-		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				owner->getObjectId(), errorPrint);
 #endif
 	}
-	else if(outputType == fsfw::OutputTypes::OUT_ERROR) {
+	else if(outputType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
 				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
-		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
 				owner->getObjectId(), errorPrint);
 #endif
 	}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 2ced2efd..2bc0cf7e 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -377,7 +377,7 @@ private:
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
 
-	void printWarningOrError(fsfw::OutputTypes outputType,
+	void printWarningOrError(sif::OutputTypes outputType,
 			const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
@@ -389,14 +389,14 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
 				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
 		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-    	printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
     			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
 		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
 	}
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index af492146..bd22698f 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -18,7 +18,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
 #else
-        fsfw::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 "invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
@@ -171,7 +171,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
             sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
             		<< "Serialization error!" << std::endl;
 #else
-            fsfw::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
             		"Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
@@ -235,7 +235,7 @@ void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
         sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
 #else
-        fsfw::printWarning("LocalPoolDataSetBase::bitSetter: "
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
         		"Invalid position!\n\r");
 #endif
         return;
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bb7822da..c2872617 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -114,7 +114,7 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 			<< std::setfill('0') << objectId << std::dec << " LPID: " << lpId
 			<< std::endl;
 #else
-	fsfw::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
 			variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index f311c23d..df2feb24 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -101,7 +101,7 @@ inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
 	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
 	return value[vectorSize - 1];
@@ -118,7 +118,7 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
 	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
 #else
-	fsfw::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
 			" last value!\n");
 #endif
 	return value[vectorSize - 1];
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 4fa7b09c..d515ac97 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -36,7 +36,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
 				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
@@ -124,7 +124,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED,
 				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -132,7 +132,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED,
 				"ComIF initialization failed");
 	    return result;
@@ -140,7 +140,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-		printWarningOrError(fsfw::OutputTypes::OUT_ERROR, "initialize",
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
 				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
@@ -150,14 +150,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
-			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
 					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
 					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure the raw receiver object is set up properly"
 					" and implements AcceptsDeviceResponsesIF" << std::endl;
 #else
-			fsfw::printError("Make sure the raw receiver object is set up "
+			sif::printError("Make sure the raw receiver object is set up "
 					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -168,14 +168,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
-			printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
 					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
 					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "Make sure the power switcher object is set up "
 					<< "properly and implements PowerSwitchIF" << std::endl;
 #else
-			fsfw::printError("Make sure the power switcher object is set up "
+			sif::printError("Make sure the power switcher object is set up "
 					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -717,7 +717,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-				printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+				printWarningOrError(sif::OutputTypes::OUT_WARNING,
 						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
 						"Found length is one, parsing might be stuck");
 			}
@@ -730,7 +730,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
-				printWarningOrError(fsfw::OutputTypes::OUT_ERROR,
+				printWarningOrError(sif::OutputTypes::OUT_ERROR,
 						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
 						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -1292,7 +1292,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
 		    // so we can track misconfigurations
-			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					"Busy.");
@@ -1324,7 +1324,7 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 			sprintf(output, "Command 0x%08x is executing",
 					static_cast<unsigned int>(deviceCommandId));
 			// so we can track misconfigurations
-			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
 					"buildInternalCommand",
 					HasReturnvaluesIF::RETURN_FAILED,
 					output);
@@ -1488,7 +1488,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
+void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
 	if(errorPrint == nullptr) {
@@ -1496,7 +1496,7 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 			errorPrint = "Initialization error";
 		}
 		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
-			if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+			if(errorType == sif::OutputTypes::OUT_WARNING) {
 				errorPrint = "Generic Warning";
 			}
 			else {
@@ -1508,25 +1508,25 @@ void DeviceHandlerBase::printWarningOrError(fsfw::OutputTypes errorType,
 		}
 	}
 
-	if(errorType == fsfw::OutputTypes::OUT_WARNING) {
+	if(errorType == sif::OutputTypes::OUT_WARNING) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< this->getObjectId() << " | " << errorPrint << std::dec
 				<< std::setfill(' ') << std::endl;
 #else
-		fsfw::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+		sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
 				this->getObjectId(), errorPrint);
 #endif
 	}
-	else if(errorType == fsfw::OutputTypes::OUT_ERROR) {
+	else if(errorType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
 				<< std::hex << std::setw(8) << std::setfill('0')
 				<< this->getObjectId() << " | " << errorPrint << std::dec
 				<< std::setfill(' ') << std::endl;
 #else
-		fsfw::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+		sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
 				this->getObjectId(), errorPrint);
 #endif
 	}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 4c745b4f..414588e1 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -1251,7 +1251,7 @@ private:
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
 
-    void printWarningOrError(fsfw::OutputTypes errorType,
+    void printWarningOrError(sif::OutputTypes errorType,
     		const char* functionName,
 			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
 			const char* errorPrint = nullptr);
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index ebf21bb8..25d6fcf4 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -10,7 +10,7 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 	}
 	sif::info << "[";
 #else
-	fsfw::printInfo("Printing data with size %zu: [", size);
+	sif::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index c2eb8514..5716e560 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -114,7 +114,7 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		fsfw::printError("BinarySemaphore::getSemaphoreCounter: "
+		sif::printError("BinarySemaphore::getSemaphoreCounter: "
 				"Invalid semaphore\n");
 		return 0;
 	}
@@ -136,7 +136,7 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 				sif::error << "BinarySemaphore: Init failed with "
 						<< strerror(errno) << std::endl;
 #else
-				fsfw::printError("BinarySemaphore: Init failed with %s\n",
+				sif::printError("BinarySemaphore: Init failed with %s\n",
 						strerror(errno));
 #endif
 		}
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index d93b7f6d..60d15dee 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -127,7 +127,7 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
 				<< " failed with status: " << strerror(errno) << std::endl;
 #else
-		fsfw::printError("MessageQueue::MessageQueue: Creating Queue %s"
+		sif::printError("MessageQueue::MessageQueue: Creating Queue %s"
 				" failed with status: %s\n", name, strerror(errno));
 #endif
 	}
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index 8d368c18..2499b442 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -151,7 +151,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
 #else
-			fsfw::printError("PosixThread::createTask: Insufficient memory for "
+			sif::printError("PosixThread::createTask: Insufficient memory for "
 					"the requested %zu MB\n", stackMb);
 #endif
 		}
@@ -160,7 +160,7 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
 #else
-			fsfw::printError("PosixThread::createTask: "
+			sif::printError("PosixThread::createTask: "
 					"Wrong alignment argument!\n");
 #endif
 		}
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 0bedce0f..0af1fc68 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -193,7 +193,7 @@ void TmTcUnixUdpBridge::handleSendError() {
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
 #else
-		fsfw::printError("TmTcUnixBridge::handleSendError: %s\n",
+		sif::printError("TmTcUnixBridge::handleSendError: %s\n",
 				strerror(errno));
 #endif
 	}
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5846d233..1a02d6e9 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -29,19 +29,19 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 
 #if FSFW_COLORED_OUTPUT == 1
 	if(setMessage.find("DEBUG") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+		colorPrefix = sif::ANSI_COLOR_MAGENTA;
 	}
 	else if(setMessage.find("INFO") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+		colorPrefix = sif::ANSI_COLOR_GREEN;
 	}
 	else if(setMessage.find("WARNING") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+		colorPrefix = sif::ANSI_COLOR_YELLOW;
 	}
 	else if(setMessage.find("ERROR") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_RED;
+		colorPrefix = sif::ANSI_COLOR_RED;
 	}
 	else {
-		colorPrefix = fsfw::ANSI_COLOR_RESET;
+		colorPrefix = sif::ANSI_COLOR_RESET;
 	}
 
 #ifdef WIN32
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index d20771a4..517f561a 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -5,7 +5,7 @@
 	sif::error << "Unit Tester error: Failed at test ID "
 			<< errorId << std::endl;
 #else
-	fsfw::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+	sif::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 531ee87b..bae02875 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -9,7 +9,7 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
 #else
-		fsfw::printError("Global object manager uninitialized\n\r");
+		sif::printError("Global object manager uninitialized\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}

From 25a86e91de099405992b9666fecf0605216907c0 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 13:23:24 +0100
Subject: [PATCH 1257/1292] fixed warning of static var

---
 serviceinterface/ServiceInterfacePrinter.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index f3d34bb0..a12f49e3 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -10,9 +10,11 @@ static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 static bool consoleInitialized = false;
 #endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
-static bool addCrAtEnd = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
+
+static bool addCrAtEnd = false;
+
 uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
 void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {

From cafc8e4ccbdd8ee5df48b7b7a247898b16d1cc20 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 14:08:51 +0100
Subject: [PATCH 1258/1292] updated attorneys

---
 controller/ExtendedControllerBase.cpp      |   6 +-
 controller/ExtendedControllerBase.h        |   3 +-
 datapoollocal/AccessLocalPoolF.h           |  33 +++---
 datapoollocal/HasLocalDataPoolIF.h         |  56 ++++------
 datapoollocal/HasLocalDataPoolIFAttorney.h |  38 +++++++
 datapoollocal/LocalDataPoolManager.cpp     | 114 ++++++++++++---------
 datapoollocal/LocalDataPoolManager.h       |  14 +--
 datapoollocal/LocalDpManagerAttorney.h     |  32 ++++++
 datapoollocal/LocalPoolDataSetAttorney.h   |  40 ++++++++
 datapoollocal/LocalPoolDataSetBase.cpp     |  19 ++--
 datapoollocal/LocalPoolDataSetBase.h       |   5 +-
 datapoollocal/LocalPoolObjectBase.cpp      |  10 +-
 datapoollocal/LocalPoolVariable.h          |   2 +-
 datapoollocal/LocalPoolVariable.tpp        |  12 ++-
 datapoollocal/LocalPoolVector.h            |   1 +
 datapoollocal/LocalPoolVector.tpp          |  10 +-
 devicehandlers/DeviceHandlerBase.cpp       |   7 +-
 devicehandlers/DeviceHandlerBase.h         |   4 +-
 devicehandlers/DeviceHandlerThermalSet.h   |   2 +-
 internalError/InternalErrorReporter.cpp    |   6 +-
 internalError/InternalErrorReporter.h      |   3 +-
 21 files changed, 266 insertions(+), 151 deletions(-)
 create mode 100644 datapoollocal/HasLocalDataPoolIFAttorney.h
 create mode 100644 datapoollocal/LocalDpManagerAttorney.h
 create mode 100644 datapoollocal/LocalPoolDataSetAttorney.h

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 2b72a89d..379f189c 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -26,7 +26,7 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
     return &localPoolManager;
 }
 
@@ -106,10 +106,6 @@ MessageQueueId_t ExtendedControllerBase::getCommandQueue() const {
     return commandQueue->getId();
 }
 
-AccessLocalPoolIF* ExtendedControllerBase::getAccessorHandle() {
-	return &localPoolManager;
-}
-
 LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "ExtendedControllerBase::getDataSetHandle: No child "
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 47c180e6..ed1d7193 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -33,7 +33,7 @@ public:
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-   AccessLocalPoolIF* getAccessorHandle() override;
+   AccessPoolManagerIF* getAccessorHandle() override;
 
 protected:
     LocalDataPoolManager localPoolManager;
@@ -65,7 +65,6 @@ protected:
     virtual ReturnValue_t initializeLocalDataPool(
             LocalDataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 };
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 51d2ec46..88ccec93 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,31 +1,26 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-#include <fsfw/datapoollocal/locPoolDefinitions.h>
-#include <fsfw/datapool/PoolEntry.h>
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+//#include "LocalDataPoolManager.h"
 #include <fsfw/ipc/MutexIF.h>
 
-class AccessLocalPoolIF {
-public:
-	virtual ~AccessLocalPoolIF() {};
+class LocalDataPoolManager;
 
-	virtual ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) = 0;
-	virtual object_id_t getCreatorObjectId() const = 0;
+class AccessPoolManagerIF {
+public:
+	virtual ~AccessPoolManagerIF() {};
+
+	virtual MutexIF* getLocalPoolMutex() = 0;
+
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 protected:
 
-	//virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 };
 
-//template <typename T>
-//class AccessLocalPoolTypedIF {
-//public:
-//	virtual ~AccessLocalPoolTypedIF() {};
-//
-//	virtual ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T> **poolEntry) = 0;
-//};
-
-
-
 #endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 967abd4a..c0899203 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -12,7 +12,6 @@
 
 #include <map>
 
-class LocalDataPoolManager;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
 
@@ -20,31 +19,26 @@ using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using LocalDataPoolMapIter = LocalDataPool::iterator;
 
 /**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
+ * @brief 		This interface is implemented by classes which posses a local data pool (not the
+ * 				managing class). It defines the relationship between the local data pool owner
+ * 				and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ * This is required because the pool entries are templates, which makes specifying an interface
+ * rather difficult. The local data pool can be accessed by using the LocalPoolVariable,
+ * LocalPoolVector or LocalDataSet classes.
  *
  * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
+ * This could be circumvented by using a wrapper/accessor function or implementing the templated
+ * function in this interface.. The first solution sounds better than the second but the
+ * LocalPoolVariable classes are templates as well, so this just shifts the problem somewhere else.
+ * Interfaces are nice, but the most pragmatic solution I found was to offer the client the full
+ * interface of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
-	friend class LocalDataPoolManager;
-	friend class LocalPoolDataSetBase;
-	friend class LocalPoolObjectBase;
+	friend class HasLocalDpIFManagerAttorney;
+	friend class HasLocalDpIFUserAttorney;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
@@ -55,6 +49,8 @@ public:
 
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
+	virtual object_id_t getObjectId() const = 0;
+
 	/** Command queue for housekeeping messages. */
 	virtual MessageQueueId_t getCommandQueue() const = 0;
 
@@ -63,8 +59,7 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
 	/**
@@ -84,7 +79,7 @@ public:
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -112,27 +107,20 @@ public:
 	virtual ReturnValue_t removeDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        float newIntervalSeconds) {
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 
 	/**
-	 * This function can be used by data pool consumers to retrieve a  handle
+	 * This function can be used by data pool consumers to retrieve a handle
 	 * which allows subscriptions to dataset and variable updates.
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
-	virtual AccessLocalPoolIF* getAccessorHandle() = 0;
 protected:
 
-	/**
-	 * Can be used to get a handle to the local data pool manager.
-	 * This function is protected because it should only be used by the
-	 * class imlementing the interface.
-	 */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
 	/**
 	 * This function is used by the pool manager to get a valid dataset
diff --git a/datapoollocal/HasLocalDataPoolIFAttorney.h b/datapoollocal/HasLocalDataPoolIFAttorney.h
new file mode 100644
index 00000000..dd01e74e
--- /dev/null
+++ b/datapoollocal/HasLocalDataPoolIFAttorney.h
@@ -0,0 +1,38 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
+		return interface->getAccessorHandle();
+	}
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+class HasLocalDpIFManagerAttorney {
+
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid) {
+		return interface->getDataSetHandle(sid);
+	}
+
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
+			lp_id_t localPoolId) {
+		return interface->getPoolObjectHandle(localPoolId);
+	}
+
+	static object_id_t getObjectId(HasLocalDataPoolIF* interface) {
+		return interface->getObjectId();
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 4aeb8677..f471bea8 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,6 +1,8 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
+#include "LocalPoolDataSetAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -132,7 +134,7 @@ ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
 		// Update packets shall only be generated from datasets.
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 			receiver.dataId.sid);
 	if(dataSet->hasChanged()) {
 		// prepare and send update notification
@@ -151,7 +153,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 		ReturnValue_t& status) {
 	MarkChangedIF* toReset = nullptr;
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
 		if(poolObj == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
@@ -172,7 +176,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
 
 	}
 	else {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(receiver.dataId.sid);
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
 		if(dataSet == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 					"handleNotificationUpdate", DATASET_NOT_FOUND);
@@ -203,7 +208,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 	MarkChangedIF* toReset = nullptr;
 	// check whether data has changed and send messages in case it has.
 	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 				receiver.dataId.localPoolId);
 		if(poolObj == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
@@ -221,7 +226,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
 		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), owner->getPoolObjectHandle(
+				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
 						receiver.dataId.localPoolId));
 
 		store_address_t storeId;
@@ -241,7 +246,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		toReset = poolObj;
 	}
 	else {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
 				receiver.dataId.sid);
 		if(dataSet == nullptr) {
 			printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
@@ -259,7 +264,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
 		CCSDSTime::CDS_short cds;
 		CCSDSTime::convertToCcsds(&cds, &now);
 		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+						receiver.dataId.sid));
 
 		store_address_t storeId;
 		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
@@ -363,11 +369,12 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(enableReporting);
-		dataSet->setDiagnostic(isDiagnostics);
-		dataSet->initializePeriodicHelper(collectionInterval,
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
 				owner->getPeriodicOperationFrequency(), isDiagnostics);
 	}
 
@@ -393,10 +400,11 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
 	hkReceiver.dataType = DataType::DATA_SET;
 	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 	if(dataSet != nullptr) {
-		dataSet->setReportingEnabled(true);
-		dataSet->setDiagnostic(isDiagnostics);
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
 	}
 
 	hkReceiversMap.push_back(hkReceiver);
@@ -410,7 +418,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
 		MessageQueueId_t targetQueueId, bool generateSnapshot) {
 	struct HkReceiver hkReceiver;
 	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.dataId.sid = sid_t(this->getCreatorObjectId(), setId);
+	hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
 	hkReceiver.destinationQueue = targetQueueId;
 	hkReceiver.objectId = destinationObject;
 	if(generateSnapshot) {
@@ -534,13 +542,14 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
 
 	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
 	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-		LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
 		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-				and dataSet->isDiagnostics()) {
+				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 			return WRONG_HK_PACKET_TYPE;
 		}
 		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-				and not dataSet->isDiagnostics()) {
+				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 			return WRONG_HK_PACKET_TYPE;
 		}
 		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
@@ -629,7 +638,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
 	// and now we set a HK message and send it the HK packet destination.
 	CommandMessage hkMessage;
-	if(dataSet->isDiagnostics()) {
+	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
 		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
 	}
 	else {
@@ -683,7 +692,8 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 	sid_t sid = receiver.dataId.sid;
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"performPeriodicHkGeneration",
@@ -691,16 +701,19 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 		return;
 	}
 
-	if(not dataSet->getReportingEnabled()) {
+	if(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
 		return;
 	}
 
-	if(dataSet->periodicHelper == nullptr) {
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
+
+	if(periodicHelper == nullptr) {
 		// Configuration error.
 		return;
 	}
 
-	if(not dataSet->periodicHelper->checkOpNecessary()) {
+	if(periodicHelper->checkOpNecessary()) {
 		return;
 	}
 
@@ -721,43 +734,49 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
 		bool enable, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if((dataSet->isDiagnostics() and not isDiagnostics) or
-			(not dataSet->isDiagnostics() and isDiagnostics)) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
+			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	if((dataSet->getReportingEnabled() and enable) or
-			(not dataSet->getReportingEnabled() and not enable)) {
+	if((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
+			(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
 		return REPORTING_STATUS_UNCHANGED;
 	}
 
-	dataSet->setReportingEnabled(enable);
+	LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
 		float newCollectionInterval, bool isDiagnostics) {
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
-	if(dataSet->periodicHelper == nullptr) {
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
+
+	if(periodicHelper == nullptr) {
 		// config error
 		return PERIODIC_HELPER_INVALID;
 	}
 
-	dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
+	periodicHelper->changeCollectionInterval(newCollectionInterval);
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 		bool isDiagnostics) {
 	// Get and check dataset first.
-	LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
 	if(dataSet == nullptr) {
 		printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
 				"performPeriodicHkGeneration",
@@ -766,16 +785,16 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
 	}
 
 
-	bool targetIsDiagnostics = dataSet->isDiagnostics();
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
 	if((targetIsDiagnostics and not isDiagnostics) or
 			(not targetIsDiagnostics and isDiagnostics)) {
 		return WRONG_HK_PACKET_TYPE;
 	}
 
 	bool valid = dataSet->isValid();
-	bool reportingEnabled = dataSet->getReportingEnabled();
-	float collectionInterval =
-			dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
+	float collectionInterval = LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->
+			getCollectionIntervalInSeconds();
 
 	// Generate set packet which can be serialized.
 	HousekeepingSetPacket setPacket(sid,
@@ -822,16 +841,13 @@ void LocalDataPoolManager::clearReceiversList() {
 	HkReceivers().swap(hkReceiversMap);
 }
 
-ReturnValue_t LocalDataPoolManager::retrieveLocalPoolMutex(MutexIF *mutex) {
-	if(this->mutex == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	mutex = this->mutex;
-	return HasReturnvaluesIF::RETURN_OK;
+MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
+	return this->mutex;
 }
 
 object_id_t LocalDataPoolManager::getCreatorObjectId() const {
-	return owner->getAccessorHandle()->getCreatorObjectId();
+	return owner->getObjectId();
+	//return owner->getObjectId();
 }
 
 void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
@@ -869,7 +885,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::warning << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -880,7 +896,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalDataPoolManager::" << functionName
 				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << this->getCreatorObjectId() << " | " << errorPrint
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
 				<< std::dec << std::setfill(' ') << std::endl;
 #else
 		fsfw::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
@@ -888,3 +904,7 @@ void LocalDataPoolManager::printWarningOrError(fsfw::OutputTypes outputType,
 #endif
 	}
 }
+
+LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
+	return this;
+}
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 3544c944..f94f0ec1 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -51,11 +51,11 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
-		public AccessLocalPoolIF {
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	//friend class LocalPoolDataSetBase;
+		public AccessPoolManagerIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
+	//! Some classes using the pool manager directly need to access class internals of the
+	//! manager. The attorney provides granular control of access to these internals.
+	friend class LocalDpManagerAttorney;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
@@ -177,7 +177,7 @@ public:
             MessageQueueId_t targetQueueId,
             bool generateSnapshot) override;
 
-    ReturnValue_t retrieveLocalPoolMutex(MutexIF* mutex) override;
+    MutexIF* getLocalPoolMutex() override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -263,7 +263,9 @@ public:
      */
     void clearReceiversList();
 
-    object_id_t getCreatorObjectId() const override;
+    object_id_t getCreatorObjectId() const;
+
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
     LocalDataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
diff --git a/datapoollocal/LocalDpManagerAttorney.h b/datapoollocal/LocalDpManagerAttorney.h
new file mode 100644
index 00000000..1d72f607
--- /dev/null
+++ b/datapoollocal/LocalDpManagerAttorney.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+/**
+ * @brief	This is a helper class implements the Attorney-Client idiom for access to
+ * 			LocalDataPoolManager internals
+ * @details
+ * This helper class provides better control over which classes are allowed to access
+ * LocalDataPoolManager internals in a granular and encapsulated way when compared to
+ * other methods like direct friend declarations. It allows these classes to use
+ * an explicit subset of the pool manager private/protected functions.
+ * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
+ */
+class LocalDpManagerAttorney {
+private:
+	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+		return manager.fetchPoolEntry(localPoolId, poolEntry);
+	}
+
+	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+		return manager.getMutexHandle();
+	}
+
+
+	template<typename T> friend class LocalPoolVariable;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/LocalPoolDataSetAttorney.h b/datapoollocal/LocalPoolDataSetAttorney.h
new file mode 100644
index 00000000..36358db4
--- /dev/null
+++ b/datapoollocal/LocalPoolDataSetAttorney.h
@@ -0,0 +1,40 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+
+class LocalPoolDataSetAttorney {
+private:
+	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+		set.setDiagnostic(diagnostics);
+	}
+
+	static bool isDiagnostics(LocalPoolDataSetBase& set) {
+		return set.isDiagnostics();
+	}
+
+	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+			uint32_t minimumPeriodicIntervalMs,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+				nonDiagIntervalFactor);
+	}
+
+	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+		set.setReportingEnabled(enabled);
+	}
+
+	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+		return set.getReportingEnabled();
+	}
+
+	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+		return set.periodicHelper;
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index c4bed0a4..9bed8583 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,5 @@
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
@@ -23,14 +24,14 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    localPoolAccessor = hkOwner->getAccessorHandle();
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-    if(localPoolAccessor != nullptr) {
-    	localPoolAccessor->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
-        //mutexIfSingleDataCreator = hkManager->getAc();
+    if(poolManager != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
     }
 
-    this->sid.objectId = localPoolAccessor->getCreatorObjectId();
+    this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
     // Data creators get a periodic helper for periodic HK data generation.
@@ -43,10 +44,10 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	AccessLocalPoolIF* hkOwner = objectManager->get<AccessLocalPoolIF>(
+	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-        ReturnValue_t result = hkOwner->retrieveLocalPoolMutex(mutexIfSingleDataCreator);
+    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
 
     //if(hkManager != nullptr) {
@@ -310,8 +311,8 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
-	if(localPoolAccessor != nullptr) {
-		return localPoolAccessor->getCreatorObjectId();
+	if(poolManager != nullptr) {
+		return poolManager->getCreatorObjectId();
 	}
 	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 442d93c8..f815ac44 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -42,7 +42,8 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalDataPoolManager;
+	//friend class LocalDataPoolManager;
+	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
 	/**
@@ -217,7 +218,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	AccessLocalPoolIF* localPoolAccessor = nullptr;
+	LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index c74380cf..e7abf9df 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,4 +1,5 @@
 #include "LocalPoolObjectBase.h"
+#include "HasLocalDataPoolIFAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -16,7 +17,9 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkO
 #endif
 		return;
 	}
-	hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+	//HasLohkOwner->getHkManagerHandle();
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
@@ -41,7 +44,10 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 #endif
 		return;
 	}
-	hkManager = hkOwner->getHkManagerHandle();
+	//hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
 	if(dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index eac91516..e66c565c 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
+#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "AccessLocalPoolF.h"
-
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index e55ea2a0..6fd34171 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -26,7 +26,7 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
@@ -41,7 +41,9 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
@@ -73,7 +75,7 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -88,7 +90,9 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVariable", result,
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index a28fe327..3f26b9f5 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,6 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
+#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 24421b0b..6476b1e1 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -26,7 +26,7 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
@@ -40,7 +40,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
@@ -64,7 +65,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(hkManager->getMutexHandle(), timeoutType, timeoutMs);
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
@@ -78,7 +79,8 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
 		object_id_t targetObjectId = hkManager->getCreatorObjectId();
 		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 2492535a..ef0219e8 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1432,11 +1432,6 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 	return RETURN_OK;
 }
 
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     // In this function, the task handle should be valid if the task
     // was implemented correctly. We still check to be 1000 % sure :-)
@@ -1488,7 +1483,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-AccessLocalPoolIF* DeviceHandlerBase::getAccessorHandle() {
+AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
 	return &hkManager;
 }
 
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index f3f208a6..7abc6705 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -519,11 +519,11 @@ protected:
 
 
 	/** Get the HK manager object handle */
-	LocalDataPoolManager* getHkManagerHandle() override;
+	//LocalDataPoolManager* getHkManagerHandle() override;
 
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
-	AccessLocalPoolIF* getAccessorHandle() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/devicehandlers/DeviceHandlerThermalSet.h b/devicehandlers/DeviceHandlerThermalSet.h
index 0fabd3b3..239012e2 100644
--- a/devicehandlers/DeviceHandlerThermalSet.h
+++ b/devicehandlers/DeviceHandlerThermalSet.h
@@ -15,7 +15,7 @@ public:
 					DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
 			lp_id_t heaterRequestId =
 					DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID):
-			DeviceHandlerThermalSet(hkOwner->getAccessorHandle()->getCreatorObjectId(), setId,
+			DeviceHandlerThermalSet(hkOwner->getObjectId(), setId,
 					thermalStateId, heaterRequestId) {}
 
 	DeviceHandlerThermalSet(object_id_t deviceHandler, uint32_t setId =
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 0817c080..3a05b350 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -134,7 +134,7 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
-AccessLocalPoolIF* InternalErrorReporter::getAccessorHandle() {
+AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
 	return &poolManager;
 }
 
@@ -166,10 +166,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
-    return &poolManager;
-}
-
 dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 5bd5785a..0cb6be59 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -43,11 +43,10 @@ public:
     virtual ReturnValue_t initializeLocalDataPool(
             LocalDataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
     ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-	AccessLocalPoolIF* getAccessorHandle() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 165710b43c2d24f405d3f1a0f184c72c9a0c0c51 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 15:06:25 +0100
Subject: [PATCH 1259/1292] service interface update

---
 serviceinterface/ServiceInterface.h           |   1 +
 serviceinterface/ServiceInterfaceBuffer.cpp   |  10 +-
 serviceinterface/ServiceInterfacePrinter.cpp  | 120 +++++++++++-------
 serviceinterface/ServiceInterfacePrinter.h    |  24 +++-
 serviceinterface/serviceInterfaceDefintions.h |   9 +-
 5 files changed, 102 insertions(+), 62 deletions(-)

diff --git a/serviceinterface/ServiceInterface.h b/serviceinterface/ServiceInterface.h
index 0c7c4383..1f7e5e84 100644
--- a/serviceinterface/ServiceInterface.h
+++ b/serviceinterface/ServiceInterface.h
@@ -2,6 +2,7 @@
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 
 #include <FSFWConfig.h>
+#include "serviceInterfaceDefintions.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 5846d233..1a02d6e9 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -29,19 +29,19 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 
 #if FSFW_COLORED_OUTPUT == 1
 	if(setMessage.find("DEBUG") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_MAGENTA;
+		colorPrefix = sif::ANSI_COLOR_MAGENTA;
 	}
 	else if(setMessage.find("INFO") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_GREEN;
+		colorPrefix = sif::ANSI_COLOR_GREEN;
 	}
 	else if(setMessage.find("WARNING") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_YELLOW;
+		colorPrefix = sif::ANSI_COLOR_YELLOW;
 	}
 	else if(setMessage.find("ERROR") != std::string::npos) {
-		colorPrefix = fsfw::ANSI_COLOR_RED;
+		colorPrefix = sif::ANSI_COLOR_RED;
 	}
 	else {
-		colorPrefix = fsfw::ANSI_COLOR_RESET;
+		colorPrefix = sif::ANSI_COLOR_RESET;
 	}
 
 #ifdef WIN32
diff --git a/serviceinterface/ServiceInterfacePrinter.cpp b/serviceinterface/ServiceInterfacePrinter.cpp
index e8eb498f..a12f49e3 100644
--- a/serviceinterface/ServiceInterfacePrinter.cpp
+++ b/serviceinterface/ServiceInterfacePrinter.cpp
@@ -6,14 +6,18 @@
 #include <cstdarg>
 #include <cstdint>
 
-
-fsfw::PrintLevel printLevel = fsfw::PrintLevel::DEBUG;
-uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+static sif::PrintLevel printLevel = sif::PrintLevel::DEBUG_LEVEL;
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
-bool consoleInitialized = false;
-#endif
+static bool consoleInitialized = false;
+#endif /* defined(WIN32) && FSFW_COLORED_OUTPUT == 1 */
 
-void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
+#if FSFW_DISABLE_PRINTOUT == 0
+
+static bool addCrAtEnd = false;
+
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
+
+void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
 
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
 	if(not consoleInitialized) {
@@ -30,38 +34,38 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
     char* bufferPosition = reinterpret_cast<char*>(printBuffer);
 
     /* Check logger level */
-    if(printType == fsfw::PrintLevel::NONE or printType > printLevel) {
+    if(printType == sif::PrintLevel::NONE or printType > printLevel) {
         return;
     }
 
     /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
-    if(printType == fsfw::PrintLevel::INFO) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_GREEN);
+    if(printType == sif::PrintLevel::INFO_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_GREEN);
     }
-    else if(printType == fsfw::PrintLevel::DEBUG) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_MAGENTA);
+    else if(printType == sif::PrintLevel::DEBUG_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_MAGENTA);
     }
-    else if(printType == fsfw::PrintLevel::WARNING) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_YELLOW);
+    else if(printType == sif::PrintLevel::WARNING_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_YELLOW);
     }
-    else if(printType == fsfw::PrintLevel::ERROR_TYPE) {
-    	len += sprintf(bufferPosition, fsfw::ANSI_COLOR_RED);
+    else if(printType == sif::PrintLevel::ERROR_LEVEL) {
+    	len += sprintf(bufferPosition, sif::ANSI_COLOR_RED);
     }
 #endif
 
-   if (printType == fsfw::PrintLevel::INFO) {
+   if (printType == sif::PrintLevel::INFO_LEVEL) {
        len += sprintf(bufferPosition + len, "INFO: ");
    }
-   if(printType == fsfw::PrintLevel::DEBUG) {
+   if(printType == sif::PrintLevel::DEBUG_LEVEL) {
 	   len += sprintf(bufferPosition + len, "DEBUG: ");
    }
-   if(printType == fsfw::PrintLevel::WARNING) {
+   if(printType == sif::PrintLevel::WARNING_LEVEL) {
 	   len += sprintf(bufferPosition + len, "WARNING: ");
    }
 
-   if(printType == fsfw::PrintLevel::ERROR_TYPE) {
+   if(printType == sif::PrintLevel::ERROR_LEVEL) {
 	   len += sprintf(bufferPosition + len, "ERROR: ");
    }
 
@@ -78,41 +82,59 @@ void fsfwPrint(fsfw::PrintLevel printType, const char* fmt, va_list arg) {
 
     len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
+    if(addCrAtEnd) {
+    	len += sprintf(bufferPosition + len, "\r");
+    }
+
     printf("%s", printBuffer);
 }
 
-void fsfw::setPrintLevel(PrintLevel printLevel_) {
+
+void sif::printInfo(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::printWarning(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::printDebug(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
+    va_end(args);
+}
+
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) {
+	addCrAtEnd = addCrAtEnd_;
+}
+
+void sif::printError(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
+    va_end(args);
+}
+
+#else
+
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
+
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+
+void sif::setPrintLevel(PrintLevel printLevel_) {
 	printLevel = printLevel_;
 }
 
-fsfw::PrintLevel fsfw::getPrintLevel() {
+sif::PrintLevel sif::getPrintLevel() {
 	return printLevel;
 }
-
-void fsfw::printInfo(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::INFO, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printWarning(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::WARNING, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printDebug(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::DEBUG, fmt, args);
-    va_end(args);
-}
-
-void fsfw::printError(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    fsfwPrint(fsfw::PrintLevel::ERROR_TYPE, fmt, args);
-    va_end(args);
-}
diff --git a/serviceinterface/ServiceInterfacePrinter.h b/serviceinterface/ServiceInterfacePrinter.h
index 8b81ee7a..fbdccdd1 100644
--- a/serviceinterface/ServiceInterfacePrinter.h
+++ b/serviceinterface/ServiceInterfacePrinter.h
@@ -1,19 +1,29 @@
-#include <stdio.h>
+#if FSFW_DISABLE_PRINTOUT == 0
+#include <cstdio>
+#endif
 
-namespace fsfw {
+namespace sif {
 
-enum class PrintLevel {
+enum PrintLevel {
 	NONE = 0,
 	//! Strange error when using just ERROR..
-	ERROR_TYPE = 1,
-	WARNING = 2,
-	INFO = 3,
-	DEBUG = 4
+	ERROR_LEVEL = 1,
+	WARNING_LEVEL = 2,
+	INFO_LEVEL = 3,
+	DEBUG_LEVEL = 4
 };
 
+/**
+ * Set the print level. All print types with a smaller level will be printed
+ * as well. For example, set to PrintLevel::WARNING to only enable error
+ * and warning output.
+ * @param printLevel
+ */
 void setPrintLevel(PrintLevel printLevel);
 PrintLevel getPrintLevel();
 
+void setToAddCrAtEnd(bool addCrAtEnd_);
+
 /**
  * These functions can be used like the C stdio printf and forward the
  * supplied formatted string arguments to a printf function.
diff --git a/serviceinterface/serviceInterfaceDefintions.h b/serviceinterface/serviceInterfaceDefintions.h
index 684c7366..eb36a84b 100644
--- a/serviceinterface/serviceInterfaceDefintions.h
+++ b/serviceinterface/serviceInterfaceDefintions.h
@@ -1,7 +1,14 @@
 #ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
 
-namespace fsfw {
+namespace sif {
+
+enum class OutputTypes {
+	OUT_INFO,
+	OUT_DEBUG,
+	OUT_WARNING,
+	OUT_ERROR
+};
 
 static const char* const ANSI_COLOR_RED = "\x1b[31m";
 static const char* const ANSI_COLOR_GREEN = "\x1b[32m";

From 71a12792a94ac3008876eade5c9c8515713483e3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:41:47 +0100
Subject: [PATCH 1260/1292] hopefully this fixes circular includes

---
 ...torney.h => HasLocalDpIFManagerAttorney.h} | 22 +++++--------------
 datapoollocal/HasLocalDpIFUserAttorney.h      | 20 +++++++++++++++++
 datapoollocal/LocalDataPoolManager.cpp        |  2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |  6 ++---
 datapoollocal/LocalPoolDataSetBase.h          |  4 ++--
 datapoollocal/LocalPoolObjectBase.cpp         |  5 +++--
 datapoollocal/LocalPoolObjectBase.h           |  7 +++++-
 7 files changed, 39 insertions(+), 27 deletions(-)
 rename datapoollocal/{HasLocalDataPoolIFAttorney.h => HasLocalDpIFManagerAttorney.h} (50%)
 create mode 100644 datapoollocal/HasLocalDpIFUserAttorney.h

diff --git a/datapoollocal/HasLocalDataPoolIFAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
similarity index 50%
rename from datapoollocal/HasLocalDataPoolIFAttorney.h
rename to datapoollocal/HasLocalDpIFManagerAttorney.h
index dd01e74e..bb47639c 100644
--- a/datapoollocal/HasLocalDataPoolIFAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -1,19 +1,9 @@
-#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
-#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include "HasLocalDataPoolIF.h"
 
-class HasLocalDpIFUserAttorney {
-private:
-
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
-		return interface->getAccessorHandle();
-	}
-
-	friend class LocalPoolObjectBase;
-	friend class LocalPoolDataSetBase;
-
-};
+class LocalPoolDataSetBase;
 
 class HasLocalDpIFManagerAttorney {
 
@@ -33,6 +23,4 @@ class HasLocalDpIFManagerAttorney {
 	friend class LocalDataPoolManager;
 };
 
-
-
-#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIFATTORNEY_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
new file mode 100644
index 00000000..ebac9374
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+
+class AccessPoolManagerIF;
+class HasLocalDataPoolIF;
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
+		return interface->getAccessorHandle();
+	}
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b48f9b13..b54b0601 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,7 +1,7 @@
+#include <fsfw/datapoollocal/HasLocalDpIFManagerAttorney.h>
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
 #include "LocalPoolDataSetAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 70bf42c0..cd0f8931 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,5 +1,6 @@
 #include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
+#include "HasLocalDataPoolIF.h"
+#include "HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
@@ -50,9 +51,6 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
     	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
 
-    //if(hkManager != nullptr) {
-    //    mutexIfSingleDataCreator = hkManager->getMutexHandle();
-    //}
     this->sid = sid;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index f815ac44..ba4c1b6d 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,15 +1,16 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
 
+#include "../datapoollocal/locPoolDefinitions.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 
 #include <vector>
 
 class LocalDataPoolManager;
+class HasLocalDataPoolIF;
 class PeriodicHousekeepingHelper;
 
 /**
@@ -42,7 +43,6 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	//friend class LocalDataPoolManager;
 	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 5140df00..2ba9ef79 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,5 +1,6 @@
+#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
-#include "HasLocalDataPoolIFAttorney.h"
+#include "HasLocalDpIFUserAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -19,7 +20,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkO
 	}
 	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 	hkManager = poolManAccessor->getHkManagerHandle();
-	//HasLohkOwner->getHkManagerHandle();
+
 	if (dataSet != nullptr) {
 		dataSet->registerVariable(this);
 	}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index e7414131..5e6d215c 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -2,9 +2,14 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
 #include "MarkChangedIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../datapoollocal/locPoolDefinitions.h"
+#include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
+class LocalDataPoolManager;
+class DataSetIF;
+class HasLocalDataPoolIF;
 
 class LocalPoolObjectBase: public PoolVariableIF,
         public HasReturnvaluesIF,

From 40ae81c4ff264e01911392f650297a32975ecec5 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:58:29 +0100
Subject: [PATCH 1261/1292] unfortunate api change

should improve include robustness
---
 controller/ExtendedControllerBase.cpp         |  2 +-
 controller/ExtendedControllerBase.h           |  2 +-
 datapoollocal/HasLocalDataPoolIF.h            | 18 +++++-------------
 datapoollocal/HasLocalDpIFUserAttorney.h      |  3 ++-
 datapoollocal/LocalDataPoolManager.cpp        | 11 ++++++-----
 datapoollocal/LocalDataPoolManager.h          | 14 ++++++++------
 datapoollocal/LocalPoolDataSetBase.h          |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp         | 10 ++++++----
 datapoollocal/LocalPoolObjectBase.h           |  2 +-
 .../ProvidesDataPoolSubscriptionIF.h          |  2 +-
 ...olDefinitions.h => localPoolDefinitions.h} | 19 +++++++++++++++----
 devicehandlers/DeviceHandlerBase.cpp          |  2 +-
 devicehandlers/DeviceHandlerBase.h            |  2 +-
 devicehandlers/DeviceHandlerIF.h              |  2 +-
 housekeeping/HousekeepingMessage.h            |  2 +-
 internalError/InternalErrorReporter.cpp       |  2 +-
 internalError/InternalErrorReporter.h         |  2 +-
 monitoring/MonitorReporter.h                  |  2 +-
 monitoring/MonitoringMessageContent.h         |  2 +-
 19 files changed, 55 insertions(+), 46 deletions(-)
 rename datapoollocal/{locPoolDefinitions.h => localPoolDefinitions.h} (78%)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 379f189c..74453b25 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -17,7 +17,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     // needs to be overriden and implemented by child class.
     return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index ed1d7193..6076b2fe 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -63,7 +63,7 @@ protected:
     /** HasLocalDatapoolIF overrides */
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+            localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 822a8590..3132277d 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,10 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include "AccessLocalPoolF.h"
-#include "ProvidesDataPoolSubscriptionIF.h"
-#include "locPoolDefinitions.h"
-
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
@@ -12,11 +9,11 @@
 
 #include <map>
 
+class AccessPoolManagerIF;
+class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
+class LocalDataPoolManager;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local data pool (not the
@@ -42,11 +39,6 @@ class HasLocalDataPoolIF {
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
-
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
@@ -59,7 +51,7 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
 	/**
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index ebac9374..51260dbf 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 
+#include "HasLocalDataPoolIF.h"
+
 class AccessPoolManagerIF;
-class HasLocalDataPoolIF;
 
 class HasLocalDpIFUserAttorney {
 private:
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index b54b0601..3902a0fe 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,8 +1,9 @@
-#include <fsfw/datapoollocal/HasLocalDpIFManagerAttorney.h>
+#include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
 #include "LocalPoolDataSetAttorney.h"
+#include "HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
@@ -601,8 +602,8 @@ ReturnValue_t LocalDataPoolManager::printPoolEntry(
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
-				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+				localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 	poolIter->second->print();
 	return HasReturnvaluesIF::RETURN_OK;
@@ -870,10 +871,10 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 		else if(error == QUEUE_OR_DESTINATION_INVALID) {
 			errorPrint = "Queue or destination not set";
 		}
-		else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+		else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
 			errorPrint = "Pool entry type conflict";
 		}
-		else if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+		else if(error == localpool::POOL_ENTRY_NOT_FOUND) {
 			errorPrint = "Pool entry not found";
 		}
 		else {
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index cba79776..580ac8b9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -2,7 +2,7 @@
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
 #include "ProvidesDataPoolSubscriptionIF.h"
-#include "HasLocalDataPoolIF.h"
+#include "AccessLocalPoolF.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
@@ -25,6 +25,8 @@ void setStaticFrameworkObjectIds();
 
 class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
+class HasLocalDataPoolIF;
+class LocalDataPool;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -267,7 +269,7 @@ public:
 
     virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
-    LocalDataPool localPoolMap;
+    localpool::DataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
@@ -400,15 +402,15 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
     	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-				HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND);
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+    			localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
     	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT);
-		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+    			localpool::POOL_ENTRY_TYPE_CONFLICT);
+		return localpool::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index ba4c1b6d..2d170c3f 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,9 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 2ba9ef79..6dc6e356 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,6 +1,9 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
+
+#include "../objectmanager/ObjectManagerIF.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
 		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
@@ -35,8 +38,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
 	}
-	HasLocalDataPoolIF* hkOwner =
-			objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
 	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "LocalPoolVariable: The supplied pool owner did not "
@@ -98,10 +100,10 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
 	}
 
 	const char* errMsg = nullptr;
-	if(error == HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND) {
+	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
 		errMsg = "Pool entry not found";
 	}
-	else if(error == HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT) {
+	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
 		errMsg = "Pool entry type conflict";
 	}
 	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 5e6d215c..2dddc246 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 7f0cc754..e6d6257e 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 
-#include <fsfw/datapoollocal/locPoolDefinitions.h>
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include <fsfw/ipc/messageQueueDefinitions.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
similarity index 78%
rename from datapoollocal/locPoolDefinitions.h
rename to datapoollocal/localPoolDefinitions.h
index 6e74d349..5f558895 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -1,10 +1,13 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
-#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
 
-#include <cstdint>
+#include "../datapool/PoolEntryIF.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../objectmanager/frameworkObjects.h"
 
+#include <cstdint>
+#include <map>
+
 /**
  * @brief   Type definition for local pool entries.
  */
@@ -12,6 +15,14 @@ using lp_id_t = uint32_t;
 
 namespace localpool {
 static constexpr uint32_t INVALID_LPID = -1;
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using DataPoolMapIter = DataPool::iterator;
 }
 
 /**
@@ -90,4 +101,4 @@ union gp_id_t {
     }
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index abe0f701..acfdd81e 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1421,7 +1421,7 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
-		LocalDataPool &localDataPoolMap,
+		localpool::DataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
 	if(thermalSet != nullptr) {
 		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index c062603f..6042d249 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -514,7 +514,7 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
 
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 865b38b3..bae68516 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,10 +1,10 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 90bbe594..a64ce18b 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 3a05b350..5656f208 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -153,7 +153,7 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
 }
 
 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     localDataPoolMap.emplace(errorPoolIds::TM_HITS,
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 0cb6be59..ec9134d4 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -41,7 +41,7 @@ public:
     virtual object_id_t getObjectId() const override;
     virtual MessageQueueId_t getCommandQueue() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+    		localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9028e7e4..6b3204b3 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_MONITORING_MONITORREPORTER_H_
 #define FSFW_MONITORING_MONITORREPORTER_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 2822743a..e44e8480 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,9 @@
 #ifndef MONITORINGMESSAGECONTENT_H_
 #define MONITORINGMESSAGECONTENT_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"

From 0643faf0e509f3cc968305afffb6b6bef8064841 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 19:59:43 +0100
Subject: [PATCH 1262/1292] forward declaration correctness

---
 datapoollocal/HasLocalDpIFManagerAttorney.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index bb47639c..5a62bba0 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -4,6 +4,7 @@
 #include "HasLocalDataPoolIF.h"
 
 class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 

From fa636fded5f0bd1e631e276b2a75940f47994d68 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:15:15 +0100
Subject: [PATCH 1263/1292] source files for attorney

---
 datapoollocal/HasLocalDpIFManagerAttorney.cpp | 18 ++++++++++++++++++
 datapoollocal/HasLocalDpIFManagerAttorney.h   | 15 +++++----------
 datapoollocal/HasLocalDpIFUserAttorney.cpp    |  6 ++++++
 datapoollocal/HasLocalDpIFUserAttorney.h      |  7 ++-----
 4 files changed, 31 insertions(+), 15 deletions(-)
 create mode 100644 datapoollocal/HasLocalDpIFManagerAttorney.cpp
 create mode 100644 datapoollocal/HasLocalDpIFUserAttorney.cpp

diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
new file mode 100644
index 00000000..997f4dfa
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
@@ -0,0 +1,18 @@
+#include "HasLocalDpIFManagerAttorney.h"
+#include "LocalPoolObjectBase.h"
+#include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIF.h"
+
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* interface,
+		sid_t sid) {
+	return interface->getDataSetHandle(sid);
+}
+
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* interface,
+		lp_id_t localPoolId) {
+	return interface->getPoolObjectHandle(localPoolId);
+}
+
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* interface) {
+	return interface->getObjectId();
+}
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index 5a62bba0..ca596599 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -1,25 +1,20 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include "HasLocalDataPoolIF.h"
+#include "localPoolDefinitions.h"
 
+class HasLocalDataPoolIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid) {
-		return interface->getDataSetHandle(sid);
-	}
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid);
 
 	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
-			lp_id_t localPoolId) {
-		return interface->getPoolObjectHandle(localPoolId);
-	}
+			lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* interface) {
-		return interface->getObjectId();
-	}
+	static object_id_t getObjectId(HasLocalDataPoolIF* interface);
 
 	friend class LocalDataPoolManager;
 };
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/HasLocalDpIFUserAttorney.cpp
new file mode 100644
index 00000000..002230fe
--- /dev/null
+++ b/datapoollocal/HasLocalDpIFUserAttorney.cpp
@@ -0,0 +1,6 @@
+#include "HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
+
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *interface) {
+	return interface->getAccessorHandle();
+}
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index 51260dbf..67b51a4a 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -1,16 +1,13 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 
-#include "HasLocalDataPoolIF.h"
-
+class HasLocalDataPoolIF;
 class AccessPoolManagerIF;
 
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface) {
-		return interface->getAccessorHandle();
-	}
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface);
 
 	friend class LocalPoolObjectBase;
 	friend class LocalPoolDataSetBase;

From 20bf7b6fc4653b74431f00e4b2cc31ecf4189289 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:33:53 +0100
Subject: [PATCH 1264/1292] fixed annoying bug

---
 datapoollocal/CMakeLists.txt                        |  2 ++
 datapoollocal/HasLocalDataPoolIF.h                  |  3 ++-
 datapoollocal/HasLocalDpIFManagerAttorney.cpp       | 12 ++++++------
 datapoollocal/HasLocalDpIFManagerAttorney.h         |  6 +++---
 datapoollocal/HasLocalDpIFUserAttorney.cpp          |  5 +++--
 datapoollocal/HasLocalDpIFUserAttorney.h            |  2 +-
 datapoollocal/LocalPoolDataSetBase.h                |  2 +-
 datapoollocal/localPoolDefinitions.h                |  3 +++
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h   | 13 +++++++++++--
 .../tests/datapoollocal/LocalPoolVariableTest.cpp   |  6 +++---
 .../tests/datapoollocal/LocalPoolVectorTest.cpp     |  8 ++++----
 11 files changed, 39 insertions(+), 23 deletions(-)

diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index c6b187cd..925be505 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,4 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
 )
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3132277d..c1afb4a0 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include "localPoolDefinitions.h"
+
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
index 997f4dfa..a683cf7b 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.cpp
@@ -3,16 +3,16 @@
 #include "LocalPoolDataSetBase.h"
 #include "HasLocalDataPoolIF.h"
 
-LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* interface,
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
 		sid_t sid) {
-	return interface->getDataSetHandle(sid);
+	return clientIF->getDataSetHandle(sid);
 }
 
-LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* interface,
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
 		lp_id_t localPoolId) {
-	return interface->getPoolObjectHandle(localPoolId);
+	return clientIF->getPoolObjectHandle(localPoolId);
 }
 
-object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* interface) {
-	return interface->getObjectId();
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
+	return clientIF->getObjectId();
 }
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/HasLocalDpIFManagerAttorney.h
index ca596599..44b06592 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/HasLocalDpIFManagerAttorney.h
@@ -9,12 +9,12 @@ class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* interface, sid_t sid);
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
 
-	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* interface,
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
 			lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* interface);
+	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
 
 	friend class LocalDataPoolManager;
 };
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/HasLocalDpIFUserAttorney.cpp
index 002230fe..bb4d83d1 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.cpp
+++ b/datapoollocal/HasLocalDpIFUserAttorney.cpp
@@ -1,6 +1,7 @@
 #include "HasLocalDpIFUserAttorney.h"
+#include "AccessLocalPoolF.h"
 #include "HasLocalDataPoolIF.h"
 
-AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *interface) {
-	return interface->getAccessorHandle();
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
+	return clientIF->getAccessorHandle();
 }
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/HasLocalDpIFUserAttorney.h
index 67b51a4a..a07c2d59 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/HasLocalDpIFUserAttorney.h
@@ -7,7 +7,7 @@ class AccessPoolManagerIF;
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* interface);
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
 
 	friend class LocalPoolObjectBase;
 	friend class LocalPoolDataSetBase;
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 2d170c3f..5f17eeb6 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 5f558895..86073e6f 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -21,8 +21,11 @@ static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
 static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
 static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
+//! This is the core data structure of the local data pools. Users should insert all desired
+//! pool variables, using the std::map interface.
 using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
 using DataPoolMapIter = DataPool::iterator;
+
 }
 
 /**
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index a5389812..aaccc90e 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -92,7 +92,7 @@ public:
 
 	// This is called by initializeAfterTaskCreation of the HK manager.
 	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	        localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) {
 		// Default initialization empty for now.
 		localDataPoolMap.emplace(lpool::uint8VarId,
@@ -109,7 +109,16 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalDataPoolManager* getHkManagerHandle() override {
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
+		return &hkManager;
+	}
+
+	virtual AccessPoolManagerIF* getAccessorHandle() override {
 		return &hkManager;
 	}
 
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
index 5f7118ff..2e4cb7ec 100644
--- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -81,15 +81,15 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
 		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVariable.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
 		REQUIRE(invalidVariable.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 		// now try to access with wrong type
 		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
 		REQUIRE(invalidVariable2.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
 		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
index cfc2ec2e..7c309bbb 100644
--- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -91,17 +91,17 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
 		REQUIRE(invalidVector.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 		REQUIRE(invalidVector.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND));
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
 
 		// now try to access with wrong type
 		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
 		REQUIRE(invalidVector2.read() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 		REQUIRE(invalidVector2.commit() ==
-				static_cast<int>(HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT));
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
 
 		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
 				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,

From b3e2e93f52fe2ee5743f8f3beb6467067235d556 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:46:34 +0100
Subject: [PATCH 1265/1292] cleaned up a bit

---
 datapoollocal/CMakeLists.txt                  |  6 ++---
 datapoollocal/HasLocalDataPoolIF.h            | 23 +++++++++++--------
 datapoollocal/LocalDataPoolManager.cpp        |  4 ++--
 datapoollocal/LocalPoolDataSetBase.cpp        |  2 +-
 datapoollocal/LocalPoolObjectBase.cpp         |  2 +-
 datapoollocal/LocalPoolVariable.h             |  3 ++-
 datapoollocal/LocalPoolVector.h               |  3 ++-
 datapoollocal/PoolReadHelper.h                |  5 +++-
 datapoollocal/SharedLocalDataSet.h            |  7 ++++++
 datapoollocal/internal/CMakeLists.txt         |  5 ++++
 .../HasLocalDpIFManagerAttorney.cpp           |  6 ++---
 .../HasLocalDpIFManagerAttorney.h             |  2 +-
 .../HasLocalDpIFUserAttorney.cpp              |  4 ++--
 .../{ => internal}/HasLocalDpIFUserAttorney.h |  0
 .../{ => internal}/LocalDpManagerAttorney.h   |  0
 .../{ => internal}/LocalPoolDataSetAttorney.h |  3 +--
 datapoollocal/localPoolDefinitions.h          |  5 ++--
 17 files changed, 50 insertions(+), 30 deletions(-)
 create mode 100644 datapoollocal/internal/CMakeLists.txt
 rename datapoollocal/{ => internal}/HasLocalDpIFManagerAttorney.cpp (82%)
 rename datapoollocal/{ => internal}/HasLocalDpIFManagerAttorney.h (94%)
 rename datapoollocal/{ => internal}/HasLocalDpIFUserAttorney.cpp (72%)
 rename datapoollocal/{ => internal}/HasLocalDpIFUserAttorney.h (100%)
 rename datapoollocal/{ => internal}/LocalDpManagerAttorney.h (100%)
 rename datapoollocal/{ => internal}/LocalPoolDataSetAttorney.h (95%)

diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index 925be505..e2db39eb 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,6 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
-		HasLocalDpIFUserAttorney.cpp
-		HasLocalDpIFManagerAttorney.cpp
-)
\ No newline at end of file
+)
+
+add_subdirectory(internal)
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index c1afb4a0..569f2b09 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -23,16 +23,11 @@ class LocalDataPoolManager;
  * @details
  * Any class implementing this interface shall also have a LocalDataPoolManager member class which
  * contains the actual pool data structure and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes specifying an interface
- * rather difficult. The local data pool can be accessed by using the LocalPoolVariable,
- * LocalPoolVector or LocalDataSet classes.
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or implementing the templated
- * function in this interface.. The first solution sounds better than the second but the
- * LocalPoolVariable classes are templates as well, so this just shifts the problem somewhere else.
- * Interfaces are nice, but the most pragmatic solution I found was to offer the client the full
- * interface of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
 	friend class HasLocalDpIFManagerAttorney;
@@ -106,13 +101,21 @@ public:
 
 	/**
 	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates.
+	 * which allows subscriptions to dataset and variable updates in form of messages.
+	 * The consumers can then read the most recent variable value by calling read with
+	 * an own pool variable or set instance or using the deserialized snapshot data.
 	 * @return
 	 */
 	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
 protected:
 
+	/**
+	 * Accessor handle required for internal handling. Not intended for users and therefore
+	 * declared protected. Users should instead use pool variables, sets or the subscription
+	 * interface to access pool entries.
+	 * @return
+	 */
 	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
 	/**
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 3902a0fe..462ef17f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -2,8 +2,8 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
-#include "LocalPoolDataSetAttorney.h"
-#include "HasLocalDpIFManagerAttorney.h"
+#include "internal/LocalPoolDataSetAttorney.h"
+#include "internal/HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index cd0f8931..5343a9c9 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,6 +1,6 @@
 #include "LocalPoolDataSetBase.h"
 #include "HasLocalDataPoolIF.h"
-#include "HasLocalDpIFUserAttorney.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 6dc6e356..bd1bfa0f 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,6 +1,6 @@
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
-#include "HasLocalDpIFUserAttorney.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index e66c565c..859c8f08 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -1,11 +1,12 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
 
-#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "AccessLocalPoolF.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
 #include "../serviceinterface/ServiceInterface.h"
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 3f26b9f5..74255605 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
-#include <fsfw/datapoollocal/LocalDpManagerAttorney.h>
 #include "LocalPoolObjectBase.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index c89fff98..61e5feaf 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 #define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "LocalPoolDataSetBase.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
 /**
@@ -19,6 +20,8 @@ public:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
+#else
+			sif::printError("PoolReadHelper: Read failed!\n");
 #endif
 		}
 	}
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 2e5a76fa..713d435b 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,6 +6,13 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
+/**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * TODO: override and protect read, commit and some other calls used by pool manager.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
diff --git a/datapoollocal/internal/CMakeLists.txt b/datapoollocal/internal/CMakeLists.txt
new file mode 100644
index 00000000..554f3b88
--- /dev/null
+++ b/datapoollocal/internal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
+)
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
similarity index 82%
rename from datapoollocal/HasLocalDpIFManagerAttorney.cpp
rename to datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
index a683cf7b..bc07170f 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -1,7 +1,7 @@
 #include "HasLocalDpIFManagerAttorney.h"
-#include "LocalPoolObjectBase.h"
-#include "LocalPoolDataSetBase.h"
-#include "HasLocalDataPoolIF.h"
+#include "../LocalPoolObjectBase.h"
+#include "../LocalPoolDataSetBase.h"
+#include "../HasLocalDataPoolIF.h"
 
 LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
 		sid_t sid) {
diff --git a/datapoollocal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
similarity index 94%
rename from datapoollocal/HasLocalDpIFManagerAttorney.h
rename to datapoollocal/internal/HasLocalDpIFManagerAttorney.h
index 44b06592..ef180b37 100644
--- a/datapoollocal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
 
-#include "localPoolDefinitions.h"
+#include "../localPoolDefinitions.h"
 
 class HasLocalDataPoolIF;
 class LocalPoolDataSetBase;
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
similarity index 72%
rename from datapoollocal/HasLocalDpIFUserAttorney.cpp
rename to datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
index bb4d83d1..838204a7 100644
--- a/datapoollocal/HasLocalDpIFUserAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
@@ -1,6 +1,6 @@
 #include "HasLocalDpIFUserAttorney.h"
-#include "AccessLocalPoolF.h"
-#include "HasLocalDataPoolIF.h"
+#include "../AccessLocalPoolF.h"
+#include "../HasLocalDataPoolIF.h"
 
 AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
 	return clientIF->getAccessorHandle();
diff --git a/datapoollocal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
similarity index 100%
rename from datapoollocal/HasLocalDpIFUserAttorney.h
rename to datapoollocal/internal/HasLocalDpIFUserAttorney.h
diff --git a/datapoollocal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
similarity index 100%
rename from datapoollocal/LocalDpManagerAttorney.h
rename to datapoollocal/internal/LocalDpManagerAttorney.h
diff --git a/datapoollocal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
similarity index 95%
rename from datapoollocal/LocalPoolDataSetAttorney.h
rename to datapoollocal/internal/LocalPoolDataSetAttorney.h
index 36358db4..9804444a 100644
--- a/datapoollocal/LocalPoolDataSetAttorney.h
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "../LocalPoolDataSetBase.h"
 
 class LocalPoolDataSetAttorney {
 private:
@@ -36,5 +36,4 @@ private:
 };
 
 
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 86073e6f..3ff1feed 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -29,7 +29,7 @@ using DataPoolMapIter = DataPool::iterator;
 }
 
 /**
- * Used as a unique identifier for data sets.
+ * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
  */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
@@ -71,7 +71,8 @@ union sid_t {
 };
 
 /**
- * Used as a global unique identifier for local pool variables.
+ * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
+ * and 4 byte local pool ID.
  */
 union gp_id_t {
 	static constexpr uint64_t INVALID_GPID = -1;

From f9a8c3d35a625c5bfde4edb1705f5a477a19444e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:46:54 +0100
Subject: [PATCH 1266/1292] updated .mk support

---
 fsfw.mk | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fsfw.mk b/fsfw.mk
index 3df63060..0d72fae1 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -10,6 +10,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/internal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)

From 59b4f50c1ca40a7485598aef2bd9b4a8313998e2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:53:30 +0100
Subject: [PATCH 1267/1292] added FSFW verbose level

---
 datapoollocal/AccessLocalPoolF.h        | 7 ++++---
 defaultcfg/fsfwconfig/FSFWConfig.h      | 4 ++--
 internalError/InternalErrorReporter.cpp | 7 ++++++-
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index 88ccec93..da08644f 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -1,11 +1,12 @@
 #ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 #define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
 
-//#include "LocalDataPoolManager.h"
-#include <fsfw/ipc/MutexIF.h>
-
 class LocalDataPoolManager;
+class MutexIF;
 
+/**
+ * @brief 	Accessor class which can be used by classes which like to use the pool manager.
+ */
 class AccessPoolManagerIF {
 public:
 	virtual ~AccessPoolManagerIF() {};
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index e251729c..49678d35 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,8 +9,8 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts. Useful for development.
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
 #if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 5656f208..bc72ada2 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -29,7 +29,7 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#if FSFW_ENHANCED_PRINTOUT == 1
+#if FSFW_VERBOSE_LEVEL == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -38,6 +38,11 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+	        sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+	        sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+	        sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+	        sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
 	    }
 	}

From b637f033899f3b68d5d8e339811059696721504e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:54:52 +0100
Subject: [PATCH 1268/1292] updated defaultconfig

---
 defaultcfg/fsfwconfig/FSFWConfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 49678d35..0740c9c7 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -13,7 +13,7 @@
 #define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 

From 0b08ac10041cd6803cf3058ddd0ef030422157ca Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:56:53 +0100
Subject: [PATCH 1269/1292] updated template config files

---
 datapoollocal/PoolReadHelper.h     |  2 +-
 defaultcfg/fsfwconfig/FSFWConfig.h |  3 ---
 unittest/user/testcfg/FSFWConfig.h | 10 +++-------
 3 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 61e5feaf..62db1598 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -16,7 +16,7 @@ public:
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
 			readResult = readObject->read(timeoutType, mutexTimeout);
-#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+#if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #endif
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 0740c9c7..ed86e6e1 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -17,9 +17,6 @@
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 
diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 261e3d6d..ed86e6e1 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -9,18 +9,14 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 

From 634a8f3469154c009698ccea120520b4d6d2c3a1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 20:59:15 +0100
Subject: [PATCH 1270/1292] renamed to pool manager for consistency

---
 devicehandlers/DeviceHandlerBase.cpp               | 14 +++++++-------
 devicehandlers/DeviceHandlerBase.h                 | 12 +++++++-----
 .../tests/datapoollocal/LocalPoolManagerTest.cpp   | 12 ++++++------
 3 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index acfdd81e..c4098525 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -24,7 +24,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this, nullptr),
+		actionHelper(this, nullptr), poolManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), childTransitionDelay(5000),
@@ -107,7 +107,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-		hkManager.performHkOperation();
+		poolManager.performHkOperation();
 		break;
 	default:
 		break;
@@ -210,7 +210,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initialize(commandQueue);
+	result = poolManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -280,7 +280,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = hkManager.handleHousekeepingMessage(&command);
+	result = poolManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -1438,7 +1438,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }
-    this->hkManager.initializeAfterTaskCreation();
+    this->poolManager.initializeAfterTaskCreation();
 
     if(setStartupImmediately) {
         startTransition(MODE_ON, SUBMODE_NONE);
@@ -1484,7 +1484,7 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 }
 
 AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
-	return &hkManager;
+	return &poolManager;
 }
 
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
@@ -1533,5 +1533,5 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 }
 
 ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
-	return &hkManager;
+	return &poolManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 6042d249..43f61897 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -517,12 +517,14 @@ protected:
 	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
-
-	/** Get the HK manager object handle */
-	//LocalDataPoolManager* getHkManagerHandle() override;
-
+	/**
+	 * Provides the subscription handle which can be used by classes like controllers
+	 * to get messages on data updates.
+	 * @return
+	 */
 	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
+	//! Accessor handle required for internal handling.
 	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
@@ -653,7 +655,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 
 	/**
 	 *  @brief Information about commands
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
index f497e610..f550582e 100644
--- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -27,7 +27,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// Subscribe for an update message.
 		poolOwner->dataset.setChanged(true);
 		// Now the update message should be generated.
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent() == true);
 
 		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
@@ -38,7 +38,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		CHECK(poolOwner->dataset.hasChanged() == false);
 		// Set changed again, result should be the same.
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 1);
@@ -49,7 +49,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		// now subscribe for set update HK as well.
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 2);
 		// first message sent should be the update notification, considering
@@ -77,7 +77,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
 		REQUIRE(poolVar != nullptr);
 		poolVar->setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 
 		// Check update notification was sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
@@ -93,7 +93,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
 
 		poolOwner->dataset.setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		// now two messages should be sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 2);
@@ -101,7 +101,7 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
 
 		poolOwner->dataset.setChanged(true);
 		poolVar->setChanged(true);
-		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
 		// now three messages should be sent.
 		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
 		CHECK(messagesSent == 3);

From af7e9194e5f2acdd5be08f3959511d93befa1477 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 21:01:55 +0100
Subject: [PATCH 1271/1292] more consistency renamings

---
 controller/ExtendedControllerBase.cpp | 16 ++++++++--------
 controller/ExtendedControllerBase.h   | 13 ++++++++++---
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 74453b25..e0aec63a 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -4,7 +4,7 @@
 ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
         object_id_t parentId, size_t commandQueueDepth):
         ControllerBase(objectId, parentId, commandQueueDepth),
-        localPoolManager(this, commandQueue),
+        poolManager(this, commandQueue),
         actionHelper(this, commandQueue) {
 }
 
@@ -27,7 +27,7 @@ object_id_t ExtendedControllerBase::getObjectId() const {
 }
 
 AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
-    return &localPoolManager;
+    return &poolManager;
 }
 
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
@@ -40,7 +40,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(
     if(result == HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
-    return localPoolManager.handleHousekeepingMessage(message);
+    return poolManager.handleHousekeepingMessage(message);
 }
 
 void ExtendedControllerBase::handleQueue() {
@@ -64,7 +64,7 @@ void ExtendedControllerBase::handleQueue() {
             continue;
         }
 
-        result = localPoolManager.handleHousekeepingMessage(&command);
+        result = poolManager.handleHousekeepingMessage(&command);
         if (result == RETURN_OK) {
             continue;
         }
@@ -88,16 +88,16 @@ ReturnValue_t ExtendedControllerBase::initialize() {
         return result;
     }
 
-    return localPoolManager.initialize(commandQueue);
+    return poolManager.initialize(commandQueue);
 }
 
 ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
-    return localPoolManager.initializeAfterTaskCreation();
+    return poolManager.initializeAfterTaskCreation();
 }
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    localPoolManager.performHkOperation();
+    poolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;
 }
@@ -115,5 +115,5 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 }
 
 ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
-	return &localPoolManager;
+	return &poolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 6076b2fe..b2760514 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,13 +32,20 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-   ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-   AccessPoolManagerIF* getAccessorHandle() override;
+    /**
+     * Provides a subscription interface for objects which required updates on changed
+     * controller variables or datasets
+     * @return
+     */
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
 
 protected:
-    LocalDataPoolManager localPoolManager;
+    LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
+    //! Accessor handle required for internal handling
+    AccessPoolManagerIF* getAccessorHandle() override;
+
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.

From eb5c56664fd3bc41fb6ea006987096150b95dec1 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Tue, 12 Jan 2021 21:03:09 +0100
Subject: [PATCH 1272/1292] relative include

---
 housekeeping/HousekeepingMessage.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index a64ce18b..0c7680dc 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"

From 482f240995f9d72bd1c3cf1f08de890cd3e4e3f2 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:39:19 +0100
Subject: [PATCH 1273/1292] doc update

---
 README.md                    | 133 +++++++----------------------------
 doc/README-controllers.md    |   1 +
 doc/README-core.md           |   5 +-
 doc/README-devicehandlers.md |   2 +-
 doc/README-highlevel.md      |  99 ++++++++++++++++++++++++++
 doc/README-localpools.md     |   3 +
 doc/README-osal.md           |  32 +++++++++
 doc/README-pus.md            |   1 +
 8 files changed, 165 insertions(+), 111 deletions(-)
 create mode 100644 doc/README-controllers.md
 create mode 100644 doc/README-highlevel.md
 create mode 100644 doc/README-localpools.md
 create mode 100644 doc/README-osal.md
 create mode 100644 doc/README-pus.md

diff --git a/README.md b/README.md
index 8552e0c8..fb3be429 100644
--- a/README.md
+++ b/README.md
@@ -9,121 +9,40 @@ 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.
 
-## Intended Use
+## 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 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 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 tested on the STM32H743ZI-Nucleo board.
+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.
 
-## How to Use
+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.
 
-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. 
 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. 
+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.
+a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
 
-## Structure
+## Index
 
-The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
-This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses run-time type information but exceptions are not allowed.
+[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>
 
-### Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
-Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
-The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
 
-### OSAL
-
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-A independent Host OSAL is in development which will provide abstraction for common type of 
-host OSes (tested for Linux and Windows, not for MacOS yet).
-The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-
-### Core Components 
-
-The FSFW has following core components. More detailed informations can be found in the
-[core component section](doc/README-core.md#top):
-
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
-   using dynamic memory allocation. These pools are allocated up front.
-3. Clock: This module provided common time related functions
-4. EventManager: This module allows routing of events generated by `SystemObjects`
-5. HealthTable: A component which stores the health states of objects
-
-### Static Ids in the framework
-
-Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
-
-### Events
-
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
-Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
-Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
-
-### Internal Communication
-
-Components communicate mostly over Message through Queues. 
-Those queues are created by calling the singleton QueueFactory::instance()->create(). 
-
-### External Communication
-
-The external communication with the mission control system is mostly up to the user implementation.
-The FSFW provides PUS Services which can be used to but don't need to be used. 
-The services can be seen as a conversion from a TC to a message based communication and back.
-
-#### CCSDS Frames, CCSDS Space Packets and PUS
-
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
-If Space Packets are used, a timestamper must be created. 
-An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
-
-#### Device Handlers
-
-DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
-More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
-
-#### Modes, Health
-
-The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
-On-board Mode Management is implement in hierarchy system. 
-DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
-Assemblies share a common core with the next level which are the Subsystems. 
-
-Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
-The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
-The target table is used to describe the state that is checked continuously by the subsystem. 
-All of this allows System Modes to be generated as Subsystem object as well from the same database. 
-This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
-
-The health state represents if the component is able to perform its tasks. 
-This can be used to signal the system to avoid using this component instead of a redundant one.
-The on-board FDIR uses the health state for isolation and recovery. 
-
-## Unit Tests
-
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. 
-See README.md in the unittest Folder.
\ No newline at end of file
diff --git a/doc/README-controllers.md b/doc/README-controllers.md
new file mode 100644
index 00000000..7af0652d
--- /dev/null
+++ b/doc/README-controllers.md
@@ -0,0 +1 @@
+## Controllers
diff --git a/doc/README-core.md b/doc/README-core.md
index c47ae0f2..6431b831 100644
--- a/doc/README-core.md
+++ b/doc/README-core.md
@@ -16,9 +16,8 @@ Flight Software Framework
 * A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
 A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
 
-``` c++
-	template <typename T> T* ObjectManagerIF::get( object_id_t id )
-
+```cpp
+template <typename T> T* ObjectManagerIF::get( object_id_t id )
 ```
 * A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
 By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
diff --git a/doc/README-devicehandlers.md b/doc/README-devicehandlers.md
index 6e737cc5..8b6551aa 100644
--- a/doc/README-devicehandlers.md
+++ b/doc/README-devicehandlers.md
@@ -1 +1 @@
-## FSFW DeviceHandlers
\ No newline at end of file
+## Device Handlers
diff --git a/doc/README-highlevel.md b/doc/README-highlevel.md
new file mode 100644
index 00000000..fac89c53
--- /dev/null
+++ b/doc/README-highlevel.md
@@ -0,0 +1,99 @@
+# High-level overview
+
+## Structure
+
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
+This simplifies the instantiation of objects and allows the usage of some standard containers. 
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
+The fsfw uses run-time type information but exceptions are not allowed.
+
+### Failure Handling
+
+Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
+Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
+The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+
+### OSAL
+
+The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
+The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
+The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components and how to use them.
+
+### Core Components 
+
+The FSFW has following core components. More detailed informations can be found in the
+[core component section](doc/README-core.md#top):
+
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
+   using dynamic memory allocation. These pools are allocated up front.
+3. Clock: This module provided common time related functions
+4. EventManager: This module allows routing of events generated by `SystemObjects`
+5. HealthTable: A component which stores the health states of objects
+
+### Static IDs in the framework
+
+Some parts of the framework use a static routing address for communication. 
+An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+
+### Events
+
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
+Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
+Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+
+### Internal Communication
+
+Components communicate mostly over Message through Queues. 
+Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+
+### External Communication
+
+The external communication with the mission control system is mostly up to the user implementation.
+The FSFW provides PUS Services which can be used to but don't need to be used. 
+The services can be seen as a conversion from a TC to a message based communication and back.
+
+#### CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
+If Space Packets are used, a timestamper must be created. 
+An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+
+#### Device Handlers
+
+DeviceHandlers are another important component of the FSFW. 
+The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
+By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
+Device Handlers can be created by overriding `DeviceHandlerBase`. 
+A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
+More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
+
+#### Modes, Health
+
+The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
+On-board Mode Management is implement in hierarchy system. 
+DeviceHandlers and Controllers are the lowest part of the hierarchy. 
+The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
+Assemblies share a common core with the next level which are the Subsystems. 
+
+Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
+The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+The target table is used to describe the state that is checked continuously by the subsystem. 
+All of this allows System Modes to be generated as Subsystem object as well from the same database. 
+This System contains list of subsystem modes in the transition and target tables. 
+Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+
+The health state represents if the component is able to perform its tasks. 
+This can be used to signal the system to avoid using this component instead of a redundant one.
+The on-board FDIR uses the health state for isolation and recovery. 
+
+## Unit Tests
+
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. More information on how to run these tests can be found in the separate
+[`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
new file mode 100644
index 00000000..8dd83385
--- /dev/null
+++ b/doc/README-localpools.md
@@ -0,0 +1,3 @@
+## Local Data Pools
+
+
diff --git a/doc/README-osal.md b/doc/README-osal.md
new file mode 100644
index 00000000..6f8ce60f
--- /dev/null
+++ b/doc/README-osal.md
@@ -0,0 +1,32 @@
+# Operating System Abstraction Layer (OSAL)
+
+Some specific information on the provided OSALs are provided.
+
+## Linux OSAL
+
+This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
+embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
+and real-time functionalities. For most UNIX systems, this is done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
+
+More information on how to set up a Linux system accordingly can be found in the 
+[Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)
+
+## Hosted OSAL
+
+This is the newest OSAL. Support for Semaphores has not been implemented yet and will propably be implemented as soon as C++20 with Semaphore support has matured. This OSAL can be used to run the FSFW on any host system, but currently has only been tested on Windows 10 and Ubuntu 20.04. Unlike the other OSALs, it uses dynamic memory allocation (e.g. for the message queue implementation). Cross-platform serial port (USB) support might be added soon.
+
+## FreeRTOS OSAL
+
+FreeRTOS is not included and the developer needs to take care of compiling the FreeRTOS sources and adding the `FreeRTOSConfig.h` file location to the include path. This OSAL has only been tested extensively with the pre-emptive scheduler configuration so far but it should in principle also be possible to use a cooperative scheduler. It is recommended to use the `heap_4` allocation scheme. When using newlib (nano), it is also recommended to add `#define configUSE_NEWLIB_REENTRANT` to the FreeRTOS configuration file to ensure thread-safety.
+
+When using this OSAL, developers also need to provide an implementation for the `vRequestContextSwitchFromISR` function. This has been done because the call to request a context switch from an ISR is generally located in the `portmacro.h` header and is different depending on the target architecture or device.
+
+## RTEMS OSAL
+
+The RTEMS OSAL was the first implemented OSAL which is also used on the active satellite Flying Laptop.
+
+## TCP/IP socket abstraction
+
+The Linux and Host OSAL provide abstraction layers for the socket API. Currently, only UDP sockets have been imlemented. This is very useful to test TMTC handling either on the host computer directly (targeting localhost with a TMTC application) or on embedded Linux devices, sending TMTC packets via Ethernet.
+
+
diff --git a/doc/README-pus.md b/doc/README-pus.md
new file mode 100644
index 00000000..928d2eda
--- /dev/null
+++ b/doc/README-pus.md
@@ -0,0 +1 @@
+## PUS Services

From 27e5254ecdb34ee197353230e88da718c5e9049e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:45:47 +0100
Subject: [PATCH 1274/1292] include fixes

---
 monitoring/MonitorReporter.h          | 2 +-
 monitoring/MonitoringMessageContent.h | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 6b3204b3..7ce110e5 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_MONITORING_MONITORREPORTER_H_
 #define FSFW_MONITORING_MONITORREPORTER_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index e44e8480..d830e313 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,10 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
+#ifndef FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
+#define FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -85,4 +86,4 @@ private:
 template<typename T>
 object_id_t MonitoringReportContent<T>::timeStamperId = 0;
 
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#endif /* FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_ */

From c9913ea53adf8b07e65d2e7a0ad8fd735002af7a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:47:04 +0100
Subject: [PATCH 1275/1292] updated cmakelists

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cc5ffd5..587e6701 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,7 +106,7 @@ else()
 	)
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(WARNING_FLAGS
 		-Wall
 		-Wextra

From e8cadd069ee1fde7f820af222764d379c76664bd Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 11:53:34 +0100
Subject: [PATCH 1276/1292] Squashed commit of the following:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

commit 27e5254ecdb34ee197353230e88da718c5e9049e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 13 11:45:47 2021 +0100

    include fixes

commit eb5c56664fd3bc41fb6ea006987096150b95dec1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 21:03:09 2021 +0100

    relative include

commit af7e9194e5f2acdd5be08f3959511d93befa1477
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 21:01:55 2021 +0100

    more consistency renamings

commit 634a8f3469154c009698ccea120520b4d6d2c3a1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:59:15 2021 +0100

    renamed to pool manager for consistency

commit 0b08ac10041cd6803cf3058ddd0ef030422157ca
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:56:53 2021 +0100

    updated template config files

commit b637f033899f3b68d5d8e339811059696721504e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:54:52 2021 +0100

    updated defaultconfig

commit 59b4f50c1ca40a7485598aef2bd9b4a8313998e2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:53:30 2021 +0100

    added FSFW verbose level

commit f9a8c3d35a625c5bfde4edb1705f5a477a19444e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:46:54 2021 +0100

    updated .mk support

commit b3e2e93f52fe2ee5743f8f3beb6467067235d556
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:46:34 2021 +0100

    cleaned up a bit

commit 20bf7b6fc4653b74431f00e4b2cc31ecf4189289
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:33:53 2021 +0100

    fixed annoying bug

commit fa636fded5f0bd1e631e276b2a75940f47994d68
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 20:15:15 2021 +0100

    source files for attorney

commit 0643faf0e509f3cc968305afffb6b6bef8064841
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:59:43 2021 +0100

    forward declaration correctness

commit 40ae81c4ff264e01911392f650297a32975ecec5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:58:29 2021 +0100

    unfortunate api change

    should improve include robustness

commit 71a12792a94ac3008876eade5c9c8515713483e3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 19:41:47 2021 +0100

    hopefully this fixes circular includes

commit 3242264a7714ae50ab52d6fe030de3884377edac
Merge: cafc8e4c 25a86e91
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 15:04:00 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit cafc8e4ccbdd8ee5df48b7b7a247898b16d1cc20
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 14:08:51 2021 +0100

    updated attorneys

commit 25a86e91de099405992b9666fecf0605216907c0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:23:24 2021 +0100

    fixed warning of static var

commit 7e394ea15fd199d9adcef11b779e12bb747cdcaa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:18:18 2021 +0100

    replaced all fsfw:: by sif:: for printouts

commit 071ce21f09a0afd7abf10e34e003d76a6e24e02a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 13:12:44 2021 +0100

    renamed namepsace for printers

commit bb10c259096d9837c1dfe35b4d6a55c846eca0f6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 12 00:13:49 2021 +0100

    introduced new accessor IF

commit 0109428d470193820d5cd66bdee83db216ea9f73
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:46:40 2021 +0100

    indentation

commit fa5580cb7fb12cccaff1feac60f2eb21544e2bfa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:45:04 2021 +0100

    indentation

commit 58d813c249842e3c627123d0584607e5f3f338a6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:33:58 2021 +0100

    minor formatting stuff

commit 0be4c35b737d08d4ba6b78d664be8bba915b5e2d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:32:36 2021 +0100

    using 100 line width now

commit 44955db341c4b732437e75bd00e134fa0c5da333
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:27:24 2021 +0100

    tab replacement

commit a8873e608c7f86ca544221b02b583e664584c803
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:25:39 2021 +0100

    cleaning up

commit 065f79615ad97b96bad42e1e588f172179c70281
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:21:21 2021 +0100

    compiling again

commit 5bc46bae02eb34a352df97ebafe9b594d799c604
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 22:18:42 2021 +0100

    reverted some stuff

commit 037bd83af9cd7f05680323e1ae856b73b31eb007
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 21:31:03 2021 +0100

    trying new interface

commit 0bf0d8e743de5978910726d3e73358ebe42b81f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 20:20:39 2021 +0100

    stuff

commit 54e97f7bdc120b1aaa1c0dfc27894ebaa0c0b73e
Merge: ef9ad60b 217866c0
Author: NguSa1 <sa.nguyen@gmx.de>
Date:   Mon Jan 11 20:18:11 2021 +0100

    Merge branch 'sa/new-if' into mueller/master

commit 217866c042d92bdfe7ea8bccab4338fd22b2bfda
Author: NguSa1 <sa.nguyen@gmx.de>
Date:   Mon Jan 11 19:44:07 2021 +0100

    SubscriptIF implementation started

commit ef9ad60ba8a79be6e32f24aee9f6d2c3cb0c1d0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:38:25 2021 +0100

    doc update

commit 5e251705f682642b683b1b91bae7c7a5cce9bce8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:33:02 2021 +0100

    getter function for object iD

commit af7def3368a7e1ed7cec29242bc265c5c17bffd3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:26:46 2021 +0100

    some bugfixes

commit 60102465927399d7c66d4bd1e8a379770325212b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 16:21:41 2021 +0100

    rearchitectured a little bit

commit 2d28f71eca6e57e2db9129b64f14a5df9e4fc54f
Merge: f083e83f e497c4ab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 11 00:49:33 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit e497c4ab1505f7438c96283a391f3b71de81fd8e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:34:21 2021 +0100

    added new reamde file stubs

commit c956feafd6fc5932570181cde9e51b525f20980c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:30:31 2021 +0100

    added new readme which will be filled later

commit 1f901a14ffcb8af674dfc7703b79eefb78bb5cf9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:28:13 2021 +0100

    updated osal readme

commit 368b42c7b031cbc9c4689ed41576249b51c396f2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:26:48 2021 +0100

    formatting improvements

commit 6dde0ab8f66dc144b0323437f93e3e8d689eb41f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:25:51 2021 +0100

    readme update

commit 952438f2528aa792638348fb5cce90a36e116837
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:25:19 2021 +0100

    README

commit 7a053b6f72b50a3868019bcbc9af4f80c5f03d55
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 17:24:19 2021 +0100

    updated README

commit 4bfbeead0024898b1e2139ec6ed4a877e60980c3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 15:04:47 2021 +0100

    additional doc

commit 63ce87acab188be447f820c421661487fda7b5a9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:59:03 2021 +0100

    more indentation corrections

commit 15b65b78e730d73a840d9708658a7d0d2817a19e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:57:56 2021 +0100

    ndentiation

commit 6993415873b88b68e987ef7796e5f371a21fbef4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:54:05 2021 +0100

    more tests

commit 4fa9a1fe1934694999a031fc802119721f05bd93
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:33:02 2021 +0100

    added more tests

commit 69e931c07b8a6dbb7c3c0f665b33d8722cce8223
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 14:27:57 2021 +0100

    important logic fix

commit 1af28dd45737440a43cf4f8560e9d28ed3b9cd69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 13:59:40 2021 +0100

    updated user folder for unittests

commit b570da6467fb11497e14d3d05abd20d386f68e4b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 13:58:33 2021 +0100

    more tests added

commit 918200e88c542a985e9751c1a053dfa37bc4c66e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 12:53:01 2021 +0100

    added first unit tests for hk manager

commit f8abf3527dead67938a7c03f39cf63f46ca73ff5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 10 11:51:33 2021 +0100

    fixed indentation

commit 13ffcfe801c61a5d4cca3ccb55d2d9300e100ffd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 16:20:35 2021 +0100

    prints added

commit 7129ea67bdf4c85d496a22c692a84f0f7a6ede97
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 16:06:54 2021 +0100

    linux fixes

commit 36bc7609c5ff94c6ab8c6cba7a30a263bed9530d
Merge: dbe326e7 57829faa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 13:52:57 2021 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/master

commit dbe326e78743ca64888cea4506acefdbb1bf566b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 9 13:52:47 2021 +0100

    minor tweak

commit f083e83f63c89ff505262144d45a1e29edaa6635
Merge: ffb7b41f 57829faa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 21:09:29 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit 57829faa64f004a48510e057742c4a9fb03a3726
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 21:03:47 2021 +0100

    added cast

commit ffb7b41f0aa48a627dd5594d344841a03107dc14
Merge: b59d6d32 12091ca6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:56:23 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit 12091ca6ab48df043708b2a63e0b695679f5315d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:55:36 2021 +0100

    enum members renamed, global vars static now

commit b59d6d3244fb584c5796dd09a4a0e164a5950be0
Merge: f64e356d 7c47b1ce
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:46:49 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit 7c47b1ce345182c6a69ff2fcaf6e89d81ef8c867
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 20:44:05 2021 +0100

    100 percent test coverage for pool vector

commit 9f15cd697d154d0d464560ce2c26cedee9c87388
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:23:57 2021 +0100

    improved includes

commit a1c394143a1b6ba4c80abcb54302ca1020053f69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:18:08 2021 +0100

    small formatting stuff

commit a9dba82661f6a88eeaa3fd1aab0948bf1919158c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:16:17 2021 +0100

    bugfix

commit c0fd981360dbb7d16018e9803a2a9a0f97de32f9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 16:14:11 2021 +0100

    improved DHB error handling

commit 541478e4d5f4ad029dd4fd968e10ccc6cc72068d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 15:15:02 2021 +0100

    another small improvement

commit f2ecd6d740763e55e682c5892b8ad3b0df74e627
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 15:10:33 2021 +0100

    revamed and imroved error handling

commit 5a8647d36701b9eda4d6b6a29f2d83dd9b5eeeab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 13:40:13 2021 +0100

    better returnvalues etc.

commit 3b39c6b6e26fd523b732b14bf00c4c5933cf0ea3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 02:07:37 2021 +0100

    defaultcfg update

commit 2ef3e0aa7b502b5ac1d40057a4fdc9b324af9fcb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 02:06:27 2021 +0100

    added option to add CR for printf support

commit 4255176b5c499d3be11947f8b77d9bbcc21bb12c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 01:49:00 2021 +0100

    more tests, minor bugfix

commit 41d8cbda5597c61aac6c965cc14f4fe571fe3263
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:22:04 2021 +0100

    small form changes

commit 8e3f4c81a5d0db9709052012e71824ca019938b9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:20:39 2021 +0100

    pool entry doc correction

commit c1c331e29ef4501d923830cc38a3179d7d7b6332
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 8 00:10:10 2021 +0100

    fixed vector test

commit d3405ee34063eca17a529dcf521ff860d91e5b50
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:30:52 2021 +0100

    whitespace

commit d3fbe4a3b96184b1f1620041fd7f433cf902b56e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:29:38 2021 +0100

    local pool variable error handling improved

commit 44a5430555766db0d6bae8a1dca7221c122c80a9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:28:03 2021 +0100

    pool vector improvements

commit 3be51762cccb8964ab3d19e379f1d427a99710b7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 20:23:23 2021 +0100

    improved error handling significantly

commit 007526c0502d7db92d37dcdc080bf4c08c5f9030
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 7 19:10:07 2021 +0100

    new f unctions for read error reporting, bugfix

commit 8aaf45049faa4677208d3486ce4e6c2946416ee2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:49:40 2021 +0100

    major bugfix in rtems osal

commit fcb33201a4c40ae868d82fcff1060fc6fdf2c342
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:45:35 2021 +0100

    fixed linux osal

commit 2b287dfc3ac227af78f68a003948b92656cd4005
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:33:54 2021 +0100

    freertos and pool read helper fix

commit dacdfc62d3841a89be5aa4988e35784737027dd1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 21:14:23 2021 +0100

    a lot of bugfixes and important api change

commit 91cf5f176400a12c18e66ef53bf7efe1fab9265f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:49:58 2021 +0100

    added way to completely disable printouts

commit db7d28f8526c7a6998f712b5ed4f904f757f011a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:32:33 2021 +0100

    test update

commit 8807772d134c04dc495627ebeef7d4f45cb31057
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:16:41 2021 +0100

    100 % line coverage reached

commit dc8dd770e7e9500da1ce5813a954ea5c8111ca8f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 19:07:35 2021 +0100

    added more tests

commit 16458f6a1e42fa75c4ca0155f22117bd0acf2b0b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 18:20:38 2021 +0100

    continued tests

commit bd93392b59b3904ef450a61d0005196d896af948
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 6 16:26:08 2021 +0100

    local pool variabel tweaks and fixes

commit b241ef6aad5861dc570548fd17bdf856e3332984
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 22:51:49 2021 +0100

    continued tests

commit a05cf8d4ab54066f6cc9f6450f80f98577fad1af
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 22:46:17 2021 +0100

    updated tests

commit 85764ba94c3f4edf1cbabc260cb94dd916b2d72f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 17:30:15 2021 +0100

    added include

commit fbb063cedad666c48947f014b70e6a9ffb393a63
Merge: 8e3aef5d 3c041388
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 5 16:44:52 2021 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/master

commit 3c041388d6705bccda5790ceeb5545ed9e48613d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 15:31:06 2021 +0100

    bugfix

commit cca5689a18425627559308e87dfde34f22cc28d0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 15:17:11 2021 +0100

    clock improvements for rtems

commit 8e3aef5df05669d686d1ec0a6a899e3c6a369d7a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 4 00:21:44 2021 +0100

    adding new tests for local pool variable

commit 49c6cd947300bef7db1622a547af7ce5fdf7980b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 23:27:49 2021 +0100

    added local pool owner base

commit e9a8313df7e5f4ae8f5afb732ef461bd348fcbb5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 23:18:10 2021 +0100

    repaired unit tests

commit e9da8e79f32fc2dfc34b779aa069c0c1faae339a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 22:00:40 2021 +0100

    updated testcfg

commit f64e356de398cf20d467110f9d1078efcaefbec5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 16:42:29 2021 +0100

    small include fix

commit fd44fb4781a291c284f82cb879d1b35aac1ad4cb
Merge: 3486a047 c94a396f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 3 16:00:09 2021 +0100

    Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

commit 3486a04741a1705d67f450c312e099935973552d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 25 00:37:24 2020 +0100

    renaming for name shadowing

commit ccbbef777808757c8f74d1070b663adfbbd0b21b
Merge: 208ad7d4 52d9a55d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 17:54:10 2020 +0100

    Merge branch 'development' into mueller/master

commit 208ad7d479d983f77629ee6b86ca19c24d2ed95b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:24:52 2020 +0100

    fixed timeslot task doc

commit e55df691ff1d121e5b72dbefd0493aee737ef55e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:24:15 2020 +0100

    upstream subsystem taken over

commit 27d03dc17f6bb14a03f85f5c69f21eed485b52ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:21:17 2020 +0100

    upstream cmakelists f iles taken over

commit f905a753e2b7517bdeff19fc9bbaf9435df9f807
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:20:24 2020 +0100

    upstream unittest folder adapted

commit 41dc9ce6c6942ef92722d9a6c82dde8efa954a88
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:19:30 2020 +0100

    cmake lists form upstream taken over

commit 707bb9dd5d3fe500d511c30f95f7bed596dd9e66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:18:50 2020 +0100

    serviceinterface taken over

commit 2e1ad41da76ea50847a9fa9756e1751d503ae85c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:18:12 2020 +0100

    power and pus upstream taken over

commit f6e7e232f58ce9119265ac9be8c6cf596b3af76d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:17:15 2020 +0100

    parameter upstream taken over

commit c174c9ecb82fd18a796cdaf41706b44982e3ba79
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:15:18 2020 +0100

    osal taken over

commit e052a9694ffa14cda100ce39a3c106b23dbc79f3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:10:13 2020 +0100

    upstream stuff

commit c603bcc91c528f1d2c76c2af8132e26873c9f7c1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:08:24 2020 +0100

    some upstream stuff taken over

commit f21f43754bd02535d4f3e31fd70779617e701178
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:06:46 2020 +0100

    taken over upstream defaultcfg

commit 7b98b0d5dd01806048753f6f6992402d84632654
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:04:39 2020 +0100

    txt is md now

commit df7a2322bfa34504049238a0c299cc1aa2eccac4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:03:56 2020 +0100

    timemanager update

commit 8f88032110f8be06e7eb653fa39e95335f7a7104
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 16:00:30 2020 +0100

    taken over upstream .mk file

commit a73cd37e52119057da75030643b41389c16c4ce2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 15:59:46 2020 +0100

    taken over changelog

commit 75a0df4cd97fd14bd5bb99475dcbaf14fbc4dda8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 15:59:28 2020 +0100

    tm storage update

commit 7ba660a222a3c0cdb1276942557ba27891783138
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:18:48 2020 +0100

    removed comment

commit 947dfd69e97f894287d758eb929cdf9caa1b1f23
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:16:33 2020 +0100

    service types.h delted

commit 362578e982e5754911ae93e3edc90420f207d813
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 14:12:35 2020 +0100

    transition delay abstract

commit 88967529277732fca91a74696a06d63dd43cd3fa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:22:10 2020 +0100

    updated readme

commit 632f319a2f181207ad3309c109ff790e919e4abd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:19:00 2020 +0100

    updated readme

commit 95a8dd418c487c3b0ab2a76d1e85ff3221a23a22
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:29:58 2020 +0100

    added cmake lists

commit ee05a34c9ead0bd79b0209afcf8ba9f070db758a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:27:47 2020 +0100

    added gitmodules

commit 5e8aff0603c6507b6f417ecb882446b25b9b54f7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:25:00 2020 +0100

    unittest update

commit e41aba719c93fe25cf97d8cccee5cb2a01a3530f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:20:17 2020 +0100

    updated testcfg

commit b97b67d56e362ef1a329cb0f118653b9f5cc5ea0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:19:07 2020 +0100

    updating unittest folder

commit 770336fff3de55194b4b0e6fc3f9f582f2ed3ef9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 13:06:35 2020 +0100

    added ipc cmakelists

commit 81201d6fb73393ce83b725b6a86c09bdc3586c2a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:39:51 2020 +0100

    typo

commit 38983407fd8973c48f4c23c02f3e8d7c34eb20da
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:22:35 2020 +0100

    added default implementation for setNormalDatapool

    entries invalid

commit 6abc56009405b64e7536f919f025f4f443df8b6a
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 22 00:55:47 2020 +0100

    feed back include improvements

commit 8dd9d6ad9195b7adbf54cb69a78bbee15fd3ed78
Merge: c2619bf0 17a12b78
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 23:39:34 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit c2619bf07052faa2d36ec9e09468b2843aa1dac4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 23:39:24 2020 +0100

    transition delay not 0 anymore

commit 17a12b78073c98eb0abdce9f7c46df9c18e46fac
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:05:44 2020 +0100

    clock update

commit a6e38afb98317abb7d0c592fe7be9edee1cbb356
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:04:04 2020 +0100

    buffer more explicit eof()

commit 30c9209c7488ac4bc69c1ee0bcd6424009d39c07
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:03:19 2020 +0100

    better win udp polling task error handling

commit e511dc61b48b12d944302a781326ad79811dfd8b
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:02:41 2020 +0100

    upstream osal endiness adapted

commit de61d0c3ac331e179d0839284f1b537acf56f825
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:02:13 2020 +0100

    upstream timeval op

commit ca2571464680d6fbef9e011c61fbcabe9b178e84
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Mon Dec 21 14:01:48 2020 +0100

    upstream coordinates taken over

commit 60d69c95c497945fbb7650dca21655fbfd9649f5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 17 17:10:27 2020 +0100

    address in use handling for socket

commit f8b34bcb5305b946380d2e401c8c57976ad07aae
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 16 13:53:36 2020 +0100

    some readme improvements

commit 8706d663d5121b56277a1f17ca40384087e20189
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:57:14 2020 +0100

    upstream changes taken over

commit f99bf6d75c51d84d49f8bbc3ca6d2c736cac06fd
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:51:30 2020 +0100

    taken over cmake list for storagemanager

commit 1f7938f610ca08e35add7264036104d2ecc0280f
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 22:46:55 2020 +0100

    deleted archive folder

commit 910e6817ef94b6692cde80be3bb3c759a22ff93c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:48:06 2020 +0100

    default cfg update

commit 48aef068379cfd9cbb43f2a23481c7853b219b0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:24:46 2020 +0100

    fsfwconfig update

commit ca52255d300047093bf1939dfafec621b47eec7b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 15:20:32 2020 +0100

    update

commit 3e41b202a105603c7f4eb2a9bf3dc7fbb96b72ac
Merge: 052e2ed1 0c3e87f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 14:41:07 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 052e2ed1e82128356c3cf8260d4d874d47ea53b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 15 14:40:49 2020 +0100

    type update, assert that type is not boolean

commit 0c3e87f1deee38f1ee30acf8090c86377ebcb840
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:55:54 2020 +0100

    using new xTaskDelayUntil

commit b8f4d8690bec206be73a4e819ae71685177ae3e9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:38:06 2020 +0100

    determination of freeRTOS features from version

commit 9170f466e8ccaf74da9bd97d260fd846fcb6551a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 23:21:07 2020 +0100

    freeRTOS version checks

commit 95b2191824f8ca051021801cf84aa9b440a45d37
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 22:55:12 2020 +0100

    long name

commit 3ee25785a2cefa7eca6d33bba49e046df75a18e1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:54:03 2020 +0100

    linux changes adapted

commit f2ba653833924f073a44974fd6e902ce6f5d1815
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:47:42 2020 +0100

    ipc changes taken over

commit db42e79fd4eb299c960a3da50ef629098f9bb409
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:38:45 2020 +0100

    taken over cmakelists file

commit 1c79da0e75309662bdfe5b94c4a71c93c1825492
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:34:29 2020 +0100

    tc distrib changed  taken over

commit 796f0e2e17152a40d6f58c9c592b9c74fc573148
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:33:19 2020 +0100

    important changes adapted

commit 8c88255873283ea51cbe02f6bf9c3c36900e567c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:31:50 2020 +0100

    taken over some tweaks

commit d2f631a955bfd439ac04fcf3d75327e5171a3ca0
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:20:21 2020 +0100

    cast added

commit f604d621e8958ebe906f0cc0bf3c77fad775cd41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:19:12 2020 +0100

    removed interrupt class

commit 6911f91744ff1b1022adca763bf8b42c208cff97
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:15:41 2020 +0100

    rtems fixes taken over

commit c1a156dde3956be55c96469c98e204d27bb3a0c9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:08:35 2020 +0100

    catch factory in objects folder again

commit 050770c184a8a965a856df53aea37ad75f0962ff
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 21:07:58 2020 +0100

    catch factory fixes

commit 14a0573f3d99025347a40bea9df2633b188d80ea
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:58:20 2020 +0100

    one define now

commit b14c1c43ccbd97fe774a2a2b9f812487b14afcd3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:50:56 2020 +0100

    small fix

commit 2100ae34f2c69d9a982e1d52d2f8068558daff9b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:49:17 2020 +0100

    event folder taken over

commit a0e7584e841f3d9a2469ef091fae79fc55560c7c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 20:19:23 2020 +0100

    tiny tweak

commit a547fafa33576ce33423536f28d1fa1333a6423a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:49:01 2020 +0100

    minor tweaks

commit 3dd86039bb01448c57425f1b9d6f9c4135de3622
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:43:32 2020 +0100

    changes taken over

commit d3239b90644126af99b12dd029d2c19690d2e775
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:41:40 2020 +0100

    tiny format stuff

commit 89de4cc321e32ce94d458d72d76c14999cfd6437
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:40:26 2020 +0100

    changes and tweaks taken over

commit 5c6916a07848a8aed3c7ec2fbc8fded1f37f2a08
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:23:23 2020 +0100

    small tweaks

commit 620c9c6ae15008631d506aa57181a11ff5130e52
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:19:05 2020 +0100

    taken over freeRTOS changes

commit 073cd4f5e1ebbf1bcc09a3c71ae8da16b6e4ddad
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:09:53 2020 +0100

    small tweaks

commit 7ace117c42832ad65d657b2d203f5371fb3ad2a7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 11:06:09 2020 +0100

    added cmakelistst

commit 0ccd266f51f8238f3489b192ec36496c90fc24fe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 10:49:00 2020 +0100

    internal unittests fixed

commit f161a94113c6c95ce7014a2cf9597817d8f4c0b1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 14 10:44:48 2020 +0100

    taken over upstream fixes

commit 692aa087d8d4dfb3c02cb7bf61b93ea47e1ba8df
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 22:13:22 2020 +0100

    taken over cleaned up branch

commit 3f77fab2d9ada5b029cf823674adaa5e5ea7d403
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 22:01:38 2020 +0100

    taken over cmake lists

commit 7c390c07eed79ee02fa23266ece8d0218672923e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:58:54 2020 +0100

    taken over unnittest folder from upstream

commit 0b056720bae878adf65bcb1fa6cf01f98ccdd6a4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:57:06 2020 +0100

    taken over master

commit d944e25d4a3b037f82981fad278de5fb9e367086
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:54:46 2020 +0100

    taken over upstream changes

commit f69113b4d516b12a2a9fc7624f17ab311e6f91fb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:53:37 2020 +0100

    taken over upstream change in ipc

commit 0e42ba062dd9b217e1f89eb62f30295d4e31beb4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:51:46 2020 +0100

    notice taken over

commit 62e16b13d343ad134fb308f56b185243515fa215
Merge: b7dbdb07 b2d01a31
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:51:09 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit b7dbdb072d46d72e8b8730c9edad97c710f4d3ad
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 13 21:50:33 2020 +0100

    taken over upstream changes

commit b2d01a31c224cf609ed2cc83e5e482604881a64d
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:58:18 2020 +0100

    removed some commented stuff

commit 5bad1142059af8a946fe57c0cad31284fd8496ea
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:39:31 2020 +0100

    thermal module set heating repaired

commit 9a540e97c557e58a8b7b933c6f41fde21e8fa315
Author: Spacefish <robin.mueller.m@gmail.com>
Date:   Thu Dec 10 16:36:44 2020 +0100

    taken over thermal module from thermal-update

commit df333e0cc828afaacc7b591527ea724b342025b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 16:01:23 2020 +0100

    tab replacement

commit e9a740f110c61cff3c836afecfdb1f635ba533f5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 16:00:02 2020 +0100

    small tweak

commit beab942f07458c709cb39d8b4976fd1462438fd6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 15:57:30 2020 +0100

    fixes taken over from master

commit 322dd1253e222ecfc81f40c671864d75d2e0334a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 15:15:22 2020 +0100

    map packet extract update

commit d9cccdedf30b8ad95b87799dba5b426b66494f56
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 8 14:34:56 2020 +0100

    event update

commit 89e80beb62f8f52625a92b397cb2d4b16429c12b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Dec 5 17:10:36 2020 +0100

    task if set now

commit 248ceebf81e824f337edbb15fa774fb3596289b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Dec 5 17:09:49 2020 +0100

    taken over host osal from upstream branch

commit c5c776e676a6b7c39e9bc8d4535ab9cba836d977
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 3 18:57:50 2020 +0100

    rtems changes taken over from upstream

commit b7a29235f876fa60d783654ebfb449799451948d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 3 13:28:56 2020 +0100

    deleted memory proxy file

commit 6d915b7dcf76c76672b07483936b9c9fcbbbb047
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:26:40 2020 +0100

    doc formatting

commit 21c3db4ffc7c95b31f323bbdd825a869389dafde
Merge: 586e8b03 4d76bf24
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:22:40 2020 +0100

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 586e8b034780fcd107cdd8ae06cd0fbffe5947b3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:22:28 2020 +0100

    function more robust now

commit f4ed0ce502b696cc6acf9eac3d20f0d9db6975d3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:18:48 2020 +0100

    doc format improvements

commit 5e77058add5f51504b4bfab4afe18debf8d8a9df
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 2 23:15:30 2020 +0100

    added getter function for pending command

commit 4d76bf24b581aaeba5c2e276f4d09c90c806215e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 19:16:19 2020 +0100

    fsfw compiles without datapoolglob folder

commit e3de5ce7774b8571865ff6755056527912f0e7c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 19:12:40 2020 +0100

    device handler changes complete

commit 74b2830d9b2c612bff9467f063617028cbf309a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:55:53 2020 +0100

    using new device handler thermal set

commit fff928a191eced806e6f8aa9fa2e58d2c26b3565
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:29:00 2020 +0100

    bugfixes and improvements

commit 3fb3039be530acdc21f41ca09dc7fc9d276827dc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:16:26 2020 +0100

    minus 1 replacement

commit 0116bb86635d9480f74b87e83a267d66e6f904e0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 18:15:09 2020 +0100

    replacing global pool with local pool DHB

commit 84ab5f83189481909f23dc7016082f51010fdfa0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:19:26 2020 +0100

    readme and logo update

commit 314dc577b547f734ef32b0552d109a9b5f88e7b4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:19:00 2020 +0100

    added changelog from upstream

commit e0f063f232f92931f17d874de122d9c30c795d73
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 17:14:44 2020 +0100

    comment added

commit e323c69f20da5b2321fbecd5ef2ab84dc1b2060d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 13:36:30 2020 +0100

    better name for preproc define

commit f357de21c9b37a5ca384590be0d511c0c503aa16
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 1 13:23:51 2020 +0100

    updated testcfg

commit ef2e07b3891a3c2a2429d973d5db68208db7e526
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 17:03:14 2020 +0100

    added explicit type conversion operator

commit d1beb96c6030c82bf20d65eea0196cb4d904c8a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:30:20 2020 +0100

    some more replacements

commit f108ae883c1a19eaa74f1c67cd4278815c98538a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:28:16 2020 +0100

    local pool replacement

commit f581b37fcf51415fe9f24ff22bb61aaf367739f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:25:09 2020 +0100

    thermal module replacements

commit 4bb9dd816ec910870cd8183951efbdae9cb74d0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 16:06:59 2020 +0100

    compiling again

commit f70ee7696a82f96268d5cc06b6182a6c30780515
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 15:30:56 2020 +0100

    it compiles again

commit e7a96d5ad8dd7169818e624943bcf15b651c0af1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 14:13:52 2020 +0100

    it doesnt work? comment it !

commit 25f08b8c1f8143bbcabfab7f40541351eb2adc50
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:59:54 2020 +0100

    started replacing local pool vars

commit b7945dfe606e2b2edd1a618aa089f893876ed75c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:45:08 2020 +0100

    added gp_id_t

commit fa4597782ec20090f45d390c9cee6542561de7f6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:09:56 2020 +0100

    some improvements taken over from master

commit f0ca4be71eec5e3883d270e98b5b53ceab4fe1e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 30 13:09:03 2020 +0100

    fsfw version include removed

commit 952978f999936c515de731e796f95076373c5528
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 13:04:38 2020 +0100

    moved perform hk op call

commit 279df93cdf84eb99b3d1609b97c422be6e07d512
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 13:01:37 2020 +0100

    form and doc comments

commit b7fb1b42e660795325c66f7fcf5e1a9d2388bb12
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 29 12:43:19 2020 +0100

    added new cfg option

commit 03fad1cfcd91fad4456188ff18b2bee0d1e0de03
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 19 00:10:59 2020 +0100

    better naming.. hopefully..

commit 0d79d4ab030c3b40cf53203a74ff7d7425b24ade
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Nov 18 21:15:48 2020 +0100

    replaced spaces with tab

commit cb5fa4a2175bc684e21fb885c94a420b97e680a8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Nov 18 21:15:14 2020 +0100

    monitoring changes

commit 434709ca9693a68a27b1595d9a86c9472f52a610
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 10 11:16:56 2020 +0100

    parameter small stuff

commit 72f7a1b1b786d97624632d8291a7fb2eaeb26882
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 9 21:24:23 2020 +0100

    translation files removed

commit 225e65628db70873cc6267cef55e915f65088ad8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 9 00:12:39 2020 +0100

    include corrections

commit 319ae724785807329a8bf9304e3228604a64fbe9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 8 15:29:06 2020 +0100

    folder config renamed to fsfwconfig

commit aa45d34b4a682c1240f5c4ad8d86bff99f858bae
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 8 15:20:51 2020 +0100

    include improvements /factory improvement

commit 1b2af5285d6269b482f8717902fc811d5781f99e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 5 13:12:42 2020 +0100

    message queue depth configurable

commit 8d109b7cd0a4955a1289a54cd7d6e9e148ae6650
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Nov 5 11:57:05 2020 +0100

    preproc define correction

commit 5efbc7496a57ff5549ca381dad521b277c0798ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:39:56 2020 +0100

    doc improved, some functions virtual now

commit cf7385d64ec3f541d69b7fe23ad38ec8b6b0e9bf
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:32:34 2020 +0100

    include fixes

commit e99cf32bddf33f7c44c14a355ae2c167f2a8a78e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:29:03 2020 +0100

    amazing size checks

commit f72ee0b7acb70dc0e91f7a50884a491ece57a334
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:26:28 2020 +0100

    small bugfix

commit 65aecc356590778da5f66939d8bfe0c10226f8bb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 23:23:05 2020 +0100

    IT IS DONE

commit e9aecdac26b83e8548ca03b04ff4d1660e33de78
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:58:09 2020 +0100

    sth with eclipse indentiation

commit d87f78f5c3576d4d3f27f206690047c1783da1b5
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:25:14 2020 +0100

    timer stamper in fsfw now

commit c69681b402ea3523cc16cb45799715045d14b13a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 22:22:26 2020 +0100

    time stamper

commit 5908f99f0b352ef41db992708888c6c2e64bcde8
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:09:33 2020 +0100

    size t changes

commit 30947d3901ef412f860b4758e66e9c77cd79afdb
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:08:40 2020 +0100

    size_t changes

commit d424d85f6d0699a7f9da63f28e973a2855873243
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 17:07:48 2020 +0100

    sizet changes and indentation

commit 695b161934052c7d18f1db7dbb04c71e66e6f3de
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:54:56 2020 +0100

    some bugfixes

commit 9e97357b8caa13883e59ed16d5fd60362697a55b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:46:43 2020 +0100

    taken over changes from master

commit f69f9bb31e505537a1093ed2c5af26d672e03b19
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:31:25 2020 +0100

    comments removed

commit 81f5783d371bdf3b3521d8c37a59592bf7d45b79
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 16:06:30 2020 +0100

    clock update, definitions file

commit dcf36d4ceebc8c70f4d17f14fd1cdf78fa4969ea
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:54:27 2020 +0100

    cstdint include added

commit 83f0b4bffc25dd4f8619220401a0f5ed2f1c1e15
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:51:56 2020 +0100

    defaultcfg changes taken over

commit 633203eb5406adbf3d4f48e1cbcc6397352fe19d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:50:55 2020 +0100

    upstream time stamper taken over

commit 38b5695a1008af28ecd783b437770b08775bd2ab
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:45:04 2020 +0100

    size check + include guard

commit b71ccf8dd8274b6dc00dcec74e412bad25c812cd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 3 15:28:55 2020 +0100

    some refactoring

commit cd71a9cc12fc799905f781a0e2453e28590bffe7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:53:08 2020 +0100

    fsfw container taken over

commit 41bf5622f313c205a931d5bc439b4302ccdc0af9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:50:14 2020 +0100

    master taken over

commit aed7f31f24cfd2a0b83117de8925a250c16e2917
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 2 15:47:09 2020 +0100

    health changes taken over

commit e0a11f3a6edb5a3493e9bc5214a655caf2eea208
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:46:44 2020 +0100

    include guard update

commit 6edc2ef1d67f074b57d252ca67650646ae50b202
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:42:05 2020 +0100

    class IDs moved

commit 641da2aa2184edeab2b3f282615c8ac27b6eae4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:33:22 2020 +0100

    config make update

commit 777457482b8ea3bb5c78e9b86c5c4e06ed1d08ee
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:21:51 2020 +0100

    fixes for internal unittest

commit 3fc206801153370773adbabd7b9260b8b13d1c23
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 17:09:16 2020 +0100

    fsfwconfig update

commit 0919d2c53231934748bcb581915993ed670f2e87
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:52:06 2020 +0100

    updates taken over

commit 3d2778fdf79eeb315ace8944fd8b555b35d550d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:45:47 2020 +0100

    doc update

commit 42e611899befd5992d639ab3a46b08f7c5785069
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 16:43:03 2020 +0100

    added timestamp size

commit fb12045f23151e60c30359ee00c09bcef2b0b700
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:25:03 2020 +0100

    changes from master taken over

commit 4b2af9eaa6ce2c418cfb280d633772d870f0dc86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:15:08 2020 +0100

    static keyword removed

commit 172fbd7e4840bcc2001fcf425684a552f2488ad1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:13:03 2020 +0100

    some changes taken over

commit 7970043cb5a138afe4259b9442034c501b327380
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:12:36 2020 +0100

    deleted some sutff

commit 176ca56e355405d4e9d81e503187e2f87d87f84f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 15:12:05 2020 +0100

    core changes taken over

commit 565fd63d0855e10fc29e46a7ab0f31a45e253ba8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 12:07:48 2020 +0100

    makefile moved

commit 29187fbc4badd33e7533c53b2aaa8032b73353e0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 11:59:50 2020 +0100

    some config adaptions

commit a38c3e5005eb96ea7dd3be1e50896f9e1fd5329f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 29 11:47:03 2020 +0100

    config folder renamed

commit a9b48749048c128e128ee77c4fc59e0deb68d871
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:49:19 2020 +0100

    new defines added

commit b860d8bce788c3f530282721d63fea3995e7a376
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:34:41 2020 +0100

    include fixes

commit 6325eb764717af8470715cb34934c2e7e0953f0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 22:11:13 2020 +0100

    include fixes

commit 24cb83498ae4c8a50db33ce6f235913fbe2695bc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:28:59 2020 +0100

    include fix

commit 82ccd146927f80e154e430ab5ce13b966a596263
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:25:11 2020 +0100

    added new tests

commit ea04e7d4d644c7c50faf862902fceafb8490d994
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 21:13:00 2020 +0100

    removed catch2

commit 3244487eaec76a8cf014d35df062daacc24edf41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 20:18:58 2020 +0100

    slight improvements

commit dcb24360d85b94a8124e697c3b5640c8dc220dd1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 20:17:50 2020 +0100

    form improvements taken over

commit d1a399a1a8c55a83a932cd326fea87141ddf9d44
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 19:46:27 2020 +0100

    tm packet store update

commit 90bdb844e703951ef783f0a025799efefcf6fc98
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 28 19:27:00 2020 +0100

    taken over some changes

commit e7210a34f95cfa2ef4a980c18e37629f54aa0bd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 22 14:34:52 2020 +0200

    output tweaked

commit 742cc6eb7660adbff54e498b29afe73bfca4bbdd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 21 18:19:51 2020 +0200

    no command added

commit b9f3c1ee84e331e0c5d52f88c313643d43dbf3c4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:53:47 2020 +0200

    takne over defaultcfg

commit 057f3b859e9857d7139be783c9fb89987fc8fa15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:39:48 2020 +0200

    added readme and efaultcfg

commit 9309562716da79a49e9d04a4f9081eb730216581
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:24:53 2020 +0200

    defaultcfg folder added

commit bb53c71f70132beae2dcf7f39201df769be697d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:21:20 2020 +0200

    fsfs config update

commit 7033328962e8997e1757b5ca0999a89a9d04c7fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 20 17:12:56 2020 +0200

    unittest folder added

commit 95924dd55bf9d6f1f8231fd16b8b3a54871caf32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 15:38:22 2020 +0200

    some more bugfixes

commit 22e4e464c79fe2924c3a2a88948b0b17c31dab9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:43:10 2020 +0200

    doc improved, new returnvalue

commit 75e67ce5f8e1383796de2c0c9f7754456d011625
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:37:26 2020 +0200

    small form improvements

commit ad9ac7537e150150679a4104b915836f8cc0f248
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 19 00:25:03 2020 +0200

    bool is mapped to uint8 now for pod type conversion

commit 8b8324f21c1b0d30ba1c5ef7919846bfeb283e62
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 23:50:02 2020 +0200

    some stuff renamed

commit 1bddfeb86bf42a9dfd5fdf9ecdddc7522058469a
Merge: 88a89d67 6baa8596
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 22:41:37 2020 +0200

    Merge branch 'mueller/LocalPoolTests' into mueller/master

commit 88a89d6797a22c108d2841a1f7c835edf55afcec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:32:10 2020 +0200

    added basic documentation

commit 8e498060571c89c06574f1a9aec381fb3290f886
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:23:47 2020 +0200

    some adaptions

commit 3b0b474ab6e5586cd81c4950d9af1b61f7c07518
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 17:01:49 2020 +0200

    better naming

commit 02b7c51318f096447703d6845365aa568d280e03
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 18 16:54:55 2020 +0200

    HasParametersIF less confusing

commit 9a70f75a4bf043292f213b4791364a8183267fef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 01:45:07 2020 +0200

    returnvalues added

commit 6f955ed8bad01074039de13e54b7534b248706c0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 00:42:49 2020 +0200

    another bugfix

commit 91cf33127a1a869a7a0b959f609dea09ec735e57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 16 00:41:50 2020 +0200

    bugfix

commit 6baa859628857c5ac0acbb115095eeac667c652f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:42:35 2020 +0200

    fsfw config removed for now

commit ba02becfc9fa228ab156efeb1c39e7a15cae73ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:38:41 2020 +0200

    deleted old files

commit b6ae82ec2ceb33936f25a2f4c5b5a9ec483fe810
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 13:21:46 2020 +0200

    bugfixes

commit 6e5f029a641ba7c77f85ea9e1d1f1a58d1a58b9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 12:47:21 2020 +0200

    type usage improved, getFillCoutn implemented

commit 48ff5dea0831610897c9aec52bea2734c68f0720
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:57:30 2020 +0200

    line break added

commit 56dc06e0ed1a0c0956793409aec24e5821385c42
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:51:12 2020 +0200

    some little formatting stuff

commit e5000abbb786f01a8664012fe52059ade71c0e61
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:31:11 2020 +0200

    custom cmp operator

commit 364bce90ddc44aa7e71852c458c6eff5c7aefc93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 01:07:20 2020 +0200

    small fixes

commit 1ee01ffcdb3a8e65a6f6e227aada9a109ec8680b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:54:00 2020 +0200

    important bugfixes

commit 64bed475fe8976c7d84a82540b2b7e0dfa915561
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:43:23 2020 +0200

    important bugfix

commit d1498366122e861703ee808fdf10eae4560d802b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 15 00:34:20 2020 +0200

    better  form

commit bdfea9ea38331a5c36f72100834d0fb524100b4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:53:50 2020 +0200

    includes reordered

commit b3e5946291a7c6a5365c79b68e3ea52aa3aca497
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:42:49 2020 +0200

    implementation added

commit 57c9775d7d9863072aa9d06e782c10184185bce3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:41:16 2020 +0200

    add fill count func added

commit 7bd536e76395a38a3a0cdecba436b7efccdc596e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 23:20:53 2020 +0200

    new templateless pool prototype

commit ab603abada422d906a6cedb9d204ca2fe5e200ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 20:05:39 2020 +0200

    subscription mechanism almost complete

commit a9a31308ae40618e49db5c6e98f131bfdebddcb7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 19:52:06 2020 +0200

    update notifications working

commit 5b96161331519c43d9ea8903d0ad7d7029d8f410
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 16:46:00 2020 +0200

    optimization and printout improvements

commit 088bc35301dc87ebb7b4d30e789deda7264b973e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 12:42:30 2020 +0200

    update handler continued

commit 45c0acec5f4744862a411c3b1852d6a7785f6b3c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 01:38:27 2020 +0200

    its all falling into places

commit 9ca086e0269c5a09bea5dc992c9050fcd24e0dad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 01:25:15 2020 +0200

    base class extraction complete

commit 72ca2bfa43e56a98a7462f9a372fe290c7e67e5e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 14 00:50:24 2020 +0200

    added new messages

commit 9917f7126d53f6e6387c1c46a779560b34735699
Merge: 3af79e57 d22c6a5f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:19:28 2020 +0200

    Merge branch 'mueller/DHB_separating_steps' into mueller/master

commit 3af79e572ef34c8508b9d6f6315893952cfacda5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:19:11 2020 +0200

    default msg size for health device

commit afe5a627895f40bb05d314aaa98eb9ee898424ca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 18:12:26 2020 +0200

    imrpoved form, removed comm msg for now

commit d22c6a5fe929d9c0c7dcfb584bcb7cf1879b3ec2
Merge: dbb394f7 736ce2d5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:44:58 2020 +0200

    Merge branch 'mueller/master' into mueller/DHB_separating_steps

commit 736ce2d5fd199ed5c18eb2d59718ce4faa3b5cff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:42:30 2020 +0200

    some more form improvements

commit 06c7919daa1f30e93452d2fe284d7ff0ccae4a41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 17:39:13 2020 +0200

    monitoring form improvements

commit e4c74ec060df2beb86eb34f1b2a9a8b1193adbd8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:57:37 2020 +0200

    added todos

commit 8c689751b4238589902b796a36e4aa484c46feee
Merge: b9ebd153 18671a0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:55:57 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit b9ebd153a2d6e897b76c41d09f2f2f8d40c1d517
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 16:55:40 2020 +0200

    added action helper function

commit 18671a0db7357a0e209cc547d64271f84f8893af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 12 13:40:24 2020 +0200

    doc wrong

commit ed71a3700435aa8532abd2764ddfa9d5be882235
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 20:11:20 2020 +0200

    get command queue override

commit 3e79d2e73ad239b5f1c4838178f35348ac5ca6b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 20:04:01 2020 +0200

    added extended controller base

commit 670e9bfa0f4fa55fddfd3cbcd7669987e65aa3f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 18:12:22 2020 +0200

    CMD/REPLY prefixes added

commit b9c7d1bd3f77f8d2da1e7376ef55df99ea26ec92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 18:09:04 2020 +0200

    added health subservices

commit 01e7a98425f8fd09b08d8f0e8edbbe9bed695de6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:55:38 2020 +0200

    added announce all subservice

commit bc0402faf7c819d5b63630bc209444b3c2df89bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:49:50 2020 +0200

    health update

commit 837a18135e2d643f52213ff1c1995af3d1cd9f2d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:41:51 2020 +0200

    subsystem folder update

commit 3aa666633e4d561847e2cf12972c2fb916d41ee8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:14:52 2020 +0200

    include guard replacements

commit 94884c2402e3c5077bfe5b88c3255cd554a4ad5b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 10 17:11:11 2020 +0200

    service 1 small improvements

commit e338b4662d8682f391cdf950ed4a47e80eaf37da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 9 02:49:18 2020 +0200

    fix for c++11 comformity

commit 2364c4f9a4d1aa551557e0d2a4b616652da8d2db
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 7 20:47:46 2020 +0200

    form improvements

commit 6e9db0d67533b8b3fa25def2b185691749c2b6f6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 7 18:43:56 2020 +0200

    retval added

commit 9fb38e9b7c168e514706b3b757e70b2d1b163c3f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 19:58:29 2020 +0200

    better error output

commit df1a730cdff36835424057e64f89f3817fda24bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 16:01:35 2020 +0200

    some form stuff

commit 6a077c583dd2063ad9b71d9298967c78e59d967b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 6 14:00:18 2020 +0200

    action helper some formatting stuff

commit 8c43c6993eca053fdf8dc633ea049ceed6564a43
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 22:47:32 2020 +0200

    CSB fifo depth configurable

commit c17d50bd1e16031be3861723d68b9269c4623cbf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 19:46:25 2020 +0200

    file syste mmessage moved to mission code for now

commit 1431116417672389bfef1ea1a77bf832cbbe309e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 12:11:11 2020 +0200

    NULL exception somewhere

commit a7fe23c3004d8c933b36d3c5a23f0b8322eaa022
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 5 00:12:52 2020 +0200

    small stuff

commit f955cd9eee41ad52eb854f8fb8cca4b040dba181
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 23:37:22 2020 +0200

    made interface more generic

commit a8a6d448ecc601fc74cefbc7b80736985b8ca06b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 23:24:36 2020 +0200

    added subservices

commit 2b1029916bab936cd7553d8c93f5300abeefe495
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 15:55:39 2020 +0200

    using deletei nstead

commit 20c261514b672d3919c036c85702d71fe107723e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 4 14:31:06 2020 +0200

    made message interface more readable (dec instead hex)

commit 0c1c61558ba2d2c831260d4a6be51cc9b90a1ee4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Oct 3 03:45:29 2020 +0200

    very important bugfix

commit 55a4c0423db264b8a1d16bd7bc8abb527d9a9597
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:45:28 2020 +0200

    typo

commit af038d0a2f04c30cd4bfbe6ff3811afdc2740ddc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:44:27 2020 +0200

    master taken over

commit f9e6b9facac4e9f8c4c7a261f4bccf04337c1f07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:42:28 2020 +0200

    taken over master

commit 0b1b159582b7b3234fdb926f4a1cb4fb875ad69d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:40:45 2020 +0200

    taken over master

commit bf3276cbb2545c1773b1478569703dda9bb402d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:40:02 2020 +0200

    taken over master

commit 148bbb4be4ef309ac023631782064140fa8d5966
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:36:43 2020 +0200

    master taken over

commit f2c07ee9c6268f255eca9f8cbb374f393cf1ef72
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:35:56 2020 +0200

    removed tests

commit 5fbb8f8ef02747e8c95c74f4301b369982a7b2f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:35:13 2020 +0200

    taken over fixed array list from master

commit 1ecca4b3d882fcbc704f21a0ed9f32c0e2d2524e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:33:50 2020 +0200

    taken over array list

commit 0714dc6e06d7bbd30b12775d1f7f39bac189b216
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 20:31:30 2020 +0200

    taken over container

commit 26454356f8958bf077e8756471869dc0bb8e0af8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 13:57:34 2020 +0200

    tpp extraction

commit 315777d265a57b50aff944bc795a15a24e64ac72
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 13:21:23 2020 +0200

    tc distribution equalization

commit 32ebca48b864039cd5ee334b6f69ff6010d1d700
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 11:07:46 2020 +0200

    FIFO updates

commit 43b44c57b6754c82e3813444568b8fc275469f92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 1 11:07:20 2020 +0200

    placement fact update

commit aed2d7fc9369e006cc7aa672a1cfeb7fb46e9f25
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 23:42:18 2020 +0200

    slight formatting

commit d44428f49c8d99de93632b20307d9ddbe4b77584
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 23:38:54 2020 +0200

    DH IF and DH message improved

commit d8392de058b1ecde643dabb5903f3534b68acefb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 30 20:28:33 2020 +0200

    made define more generic

commit b59a4c5de62863afd9fa3a45912a4f4e7f862b4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 18:02:41 2020 +0200

    equalization complete

commit 3c814a5e6105390bbbee8ae7df825af45fa53df1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 18:01:55 2020 +0200

    include fixes

commit 4f3cfdcaaf57a790ae7b8cf874c76252f20ceb6d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:41:14 2020 +0200

    fixed map and array list implemented as non - members

commit 9013ac240ff9a9ef2f488c1e6bee22ec314b6a37
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:12:01 2020 +0200

    array list taken over

commit d85096d98b951890bf93d373c4a928bea822676f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 16:03:01 2020 +0200

    service 200 take over

commit e1eb1a3be17fa8b417859ff5d3231dc32cf1535f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:48:42 2020 +0200

    small tweaks

commit 1ea1c8c02fca9cc46536831280e3160b0c73b3f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:16:20 2020 +0200

    srv9 fix

commit 207d2cab9c6345c02b93f754344e0e34fc446a5f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:15:29 2020 +0200

    service 1 changes taken over

commit bc23fd65a678fef98a3a7e701d6e40fdac8cf387
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 15:13:51 2020 +0200

    master taken over

commit fd87a16661290a771e18287bd88ef9df42d60cb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:51:25 2020 +0200

    changes taken over

commit 485e96f12f74dc6dd891aed548b8915872dd540c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:49:57 2020 +0200

    merged changes

commit 224248dfa1e3ca25eaa4cd94910b8e1293679406
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 14:27:31 2020 +0200

    removed debug outpuzt for missed deadline

commit 1691d63169c7bec77954873c476f1fa530f981ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:54:08 2020 +0200

    include fix

commit 3663d7269ca37b8ac2a5af62e1f86557d9766462
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:37:21 2020 +0200

    changes taken over

commit 7b1f72254f866666d251f097b6587fc1c92f67e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 13:30:30 2020 +0200

    object id names improved

commit 53a62257906df8ca44d3a447dd4434e3d7b889ea
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 29 12:50:36 2020 +0200

    doc & tweaks

commit 260fac43f73d638823c4dd1d887e2e8409c9a480
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 23:38:37 2020 +0200

    bugfix

commit 1f70b1159d39527d58cbcd2a0e85ca46c2d66695
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 23:21:21 2020 +0200

    another small bugfix

commit 7ff9c29b62cbd3738377bcb6883ac42362db4731
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:51:02 2020 +0200

    added another command

commit 62ee1391bf195337af99bddb151cd65fcc95504e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:48:10 2020 +0200

    added two new commands

commit 1d972fcbef9e935121ad5a168ec1f5f6f2c8619d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:46:18 2020 +0200

    hk messages are cleared properly now

commit 7e9d095ed16264786480e648465efa7d44abe8d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:38:36 2020 +0200

    important bugfixes

commit e48dbb87973ccbce0fb5679b7bd0ad726c34161b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:17:18 2020 +0200

    small improvements

commit 786dcdf88d915c701a0266768b06e6158cdd59e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 22:13:17 2020 +0200

    removed clock include

commit ad2ca814b2e100c7da2b3371244f28c70baa1e32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 21:28:03 2020 +0200

    improved doc

commit bf574c12e4ea8397062d17a3e047e7de7d223437
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 21:09:56 2020 +0200

    bugfixes, owner ptr not const anymore

commit 88c4b2a5390a927d1eda33e9ac410ddc757cfc45
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 28 16:56:42 2020 +0200

    bugfixes for srv3

commit c12110cbf16c71394aa939e67629fc3c11370472
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 22:23:17 2020 +0200

    has file system IF retvals

commit 6eaade239579ca814bb3aaded0f858b8f7bf47d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:28:03 2020 +0200

    added new mode for local datapool manager

commit c3830da3d0a1f871bfca904b240f7cedfbb2a366
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:24:06 2020 +0200

    bugfixes

commit 4a97596030f2dbebcdebdd00c2c524e74df00d36
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 17:21:32 2020 +0200

    internal error reporter uses new local datapool now

commit e67b1fce9a1f23d30a73d41142472adb7fb42b57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 16:38:07 2020 +0200

    added additional include

commit 52d8c4f3a84c870e67f251be025ec27f657d2e17
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:35:10 2020 +0200

    include guard fix

commit de08bd6c8a9b8ec3f0627a028c319446d0a09bc7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:33:24 2020 +0200

    small include fix

commit 50621704073764a4673288442e54346af7bf4af2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:32:16 2020 +0200

    correct function used now

commit 55bdd2c2f5e8d656375912dc24a4d40515bca925
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:28:28 2020 +0200

    include fix

commit 6fd39dfac38da3c825f14b8171e05ef961dcb96c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:27:06 2020 +0200

    set struct reporting continued

commit 08d0e0949342c3620fb119c9d2e6dabde243e2aa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:16:13 2020 +0200

    power equalization

commit fab7eb8a5d40386237ee243cc98af78e22f5fffe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 15:03:04 2020 +0200

    controller base update

commit 9aca5cb6f246d3db825bb447fa18d28468a59ec4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 26 14:59:40 2020 +0200

    taken over convergence changes

commit cf28c9ff9d861b7ecd30a45b172635ed1766b882
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 25 19:01:59 2020 +0200

    make event func changed

commit a65745d037a2ef26e51302d5c585620681a0f56a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 25 18:40:04 2020 +0200

    added explicit function to refresh task handle

commit 5ca1c7bca2d7a5c431488afde034dbe6625807cb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:58:51 2020 +0200

    coutndown update

commit 43ab0ba2702f482f1f5e7d39493a90e66bb91336
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:55:48 2020 +0200

    updated subsystemId ranged

commit 2f0b36de46938bf6dd58539f75f91f183e567d25
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 19:54:22 2020 +0200

    updated framework object list

commit 9ff3a8537cb711b11be97321d02d45bb50264df8
Merge: 320a5ac3 c7a6711e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 17:44:41 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit 320a5ac355728fd8b357d8bb3e0bca889e2e280e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 23 17:44:22 2020 +0200

    has health IF improvements

commit c7a6711eecddf89a5bad9ab193f166dfd8e93452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 16:25:10 2020 +0200

    include fix

commit 4074ca1b8970e3c3c115f77df15dc87e60f64f59
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 14:22:14 2020 +0200

    error code improved

commit 5072c09bc030e381df054b5b28ff979804030cff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 13:59:25 2020 +0200

    csb hotfix

commit e3cbc4dfd5a854204130df4e0dd3434438b8d795
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 22 02:12:02 2020 +0200

    shared ring buffer extended

commit f5d793a1cf63b9ebe87bef2e0d49e55947c11cf1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 20 13:38:53 2020 +0200

    file system message getter func

commit 763c52cfca0c173cf54924cb736ebb4262171489
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 21:57:23 2020 +0200

    CSB FIFO first steps to make configurable

commit 40db85e73f54d77cd813afe7f57667ca7e3f56cc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 21:36:12 2020 +0200

    separate messages for success/failure

commit cad08e1ea9d722801b1e6675b88a8513bdc6078a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 20:54:27 2020 +0200

    error output for failed deletion

commit e140d39944ba02407aa281cc6397bc75e69017ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 20:08:25 2020 +0200

    some  fixes for sd card handler

commit 9e9bde03951b143fec0e16078bcb0a02f0cd442e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 19:50:02 2020 +0200

    srv23 taken over

commit 44989ada64c2fa5919e2ae6245d964eed009976f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 19:41:41 2020 +0200

    file system message taken over

commit 718502c04b35f2677c39d68da4c00f5052e01d33
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:15:33 2020 +0200

    added additional flag which casn be used to disable

    periodic handling

commit 02f778ea1d4bbe07df38a7e58ca50ebf6ea81232
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:14:09 2020 +0200

    new error code added

commit 4ab7a0838702698e23590c636b93f375103688f8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 17:08:08 2020 +0200

    srv3 continued

commit 32c0140cc24c2aee082abf777f9bcda65b6ba43c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 15:58:34 2020 +0200

    hk stuff continued

commit 9ecbc8199e458e6c56a91c4de91b6217d30d9ea3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 02:46:29 2020 +0200

    added periodic helper

commit ba56f48e8e87f0087b9c5e29846723505abe71cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 19 01:17:43 2020 +0200

    huge progress on hk + testing

commit 757d2275ea9f1f19e134e896459fa8a02c9bedcb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 15:06:14 2020 +0200

    internal bugfix

commit 33e7cca23c3175b7349654e790fadb9a2938546c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 15:01:35 2020 +0200

    several bugfixes amd improvements

commit 5e3f40a2c1c163eaa36705de597db37b36ec8635
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:40:48 2020 +0200

    changes taken over from pull request

commit 3a043b5773de78516ac6efd0c3b483e79ebd729e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:31:51 2020 +0200

    object manager tweaks complete

commit f50a80fc3c61066d69117d033b59a85722212c09
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:29:42 2020 +0200

    minor tweaks

commit 4d4166071ca864ce4e60d0aa92ddcc6b74fa1644
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:28:20 2020 +0200

    added pus services to framework objects

commit 1b5c3786b61ceecdb4e7cf1b7b664e81399dbcf6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:24:06 2020 +0200

    taken over serviceinterface folder

commit b429359864f3a25eb33af17f52958fa102ffb8b9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:14:01 2020 +0200

    renormalize files

commit 57c88059e5be68191b25dac2f179df237b125df2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:12:07 2020 +0200

    DHB small improvements

commit 7b0ddb3941729647276cdfe0218d0727d2f6e343
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 13:09:23 2020 +0200

    quick fix DHB

commit e70e9e3f1f67e007245ab457c1e2f685d5450697
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:57:30 2020 +0200

    added uptime seconds functions

commit 19632b8fb1cf4cdedf13795ee5ecaa6158f91f10
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:36:36 2020 +0200

    linux fixes

commit e0b2e0b00a578f59ac692c57d1d3b2bc1ea4528c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:31:11 2020 +0200

    fxed linux message queues

commit 37f4cc46447906295f11e9e368e32e010eedecad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 18 12:28:29 2020 +0200

    taken over stopwatch changes

commit 0c6514a682a03e4dc74e5b7878960b0af8bf34f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 17 22:31:28 2020 +0200

    clock uses getUptime again

commit 6ef5e3e5501e5d925160306f25e39c3e1cfbb312
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 16 21:22:53 2020 +0200

    queue factory host OS fix

commit e5dac30e98f694ad92ea82cc8c15ff7bfc7bd8b2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:37:43 2020 +0200

    new include used now

commit 0d5724e3d416f837348b764cde3f7f732c2c5af6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:34:07 2020 +0200

    include improvements taken over

commit 347d591deff649540ff9dbeee1115c2803c060c3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:33:21 2020 +0200

    uses new define and config file now

commit 7643af8607ad9b1ccb27f9bd120a324869807134
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:15:22 2020 +0200

    include guard fix

commit b8ad17639ceb8b773175749608477d8ff970521c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 17:02:31 2020 +0200

    include guard fix

commit 850a4a3e3deddf8a13a9ee52e53262a8e0c7fe41
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:44:48 2020 +0200

    header file renamed

commit 15891b3cf08b585a9e177447d0d15a5ba7490705
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:42:17 2020 +0200

    fixed some message queue includes

commit ad98a63e87602790de874b7fa336a2d04d012a1a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 16:02:58 2020 +0200

    changes taken over from upstream master

commit e707c5e05117b9734f50f4a144987ec51b4dfb65
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 15 15:58:12 2020 +0200

    fixes taken over

commit e8de2fc47a1f1c6451ec5a7a6ec3767377289de7
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 14 18:29:19 2020 +0200

    added srv3

commit 2d2316a0c7824defdd1f079f7fd5d23c29f5d27c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 14 18:01:48 2020 +0200

    hk message continued

commit f9612afe06248d38db5b8b4bb875bd7c66a12598
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 11 14:06:08 2020 +0200

    added report status toggler

commit 71125c075a267e5f0b8cc6229095827b1e9285da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 21:05:50 2020 +0200

    added new setter function

commit 2d2d0de35cefdc627e556d33e9537cee4dca36a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 20:24:49 2020 +0200

    local data pool manager bugfixes

commit d7bbd4b652ff2e2e4fe63485fe57e5622ec3d82a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 19:51:17 2020 +0200

    severla bugfixes, new periodic op divider added

commit e4d95a4e0991e766725ddcb4158f26341c7d213e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 16:07:09 2020 +0200

    subsystem changes taken over

commit e57d4a11ae1db3b965a24e3de5efcae1ffc29781
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 16:01:05 2020 +0200

    fixed ordered multi map changes integrated

commit d9dcee3692aa548a94fc614529c954ffcd36b9fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:55:56 2020 +0200

    array list changes taken over

commit f35efa3cbe3926b1e47e8a62faeb81a6dae9a1ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:52:00 2020 +0200

    taken over CSB changes

commit 96e471add600b1829d08958e87b505d37e45a8e3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:51:11 2020 +0200

    merged fixed map changes

commit bbc73a6aaf5d607aca25c04b2bc59a1f7d4b031c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:25:29 2020 +0200

    taken over serialize adapter changes

commit fd09774fc3577eb3993759d2473112796c87a0cb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:18:45 2020 +0200

    serialize if update

commit f663de2418ae1be1064ab4acbf132651c0e5b509
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:17:38 2020 +0200

    taken over changes from master

commit 224ea3914a08710227f057703b64c8a0aaf4d240
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:15:13 2020 +0200

    deleted file not needed anymore

commit db3e32655d70fc4b56c69325faee75449190bf01
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:05:26 2020 +0200

    changes taken over from master

commit 18e6de7d6ba75326262918d4bd0dde93e5c6fa0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:04:43 2020 +0200

    added compile time check

commit cefac2db0b9f2672039e83bce27d38a92cdb7933
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:03:28 2020 +0200

    assignment operator added

commit d43ef479b6191923a60b308fa9a3efa7fd1bd249
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:02:58 2020 +0200

    assignment operator added

commit 26bb2de0504114bff116277fbd264fa2f39b3ff2
Merge: d99b100a e085deb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 10 15:01:49 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit e085deb2355e68e4456143988964a152ff96134b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Sep 7 15:23:27 2020 +0200

    fifo fix

commit d99b100ace281a6a371e42ba15c8d260a27159ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 18:46:56 2020 +0200

    debug output removed

commit 26cbcdbff058a542a30055ba4104b18cb16353a7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 15:21:02 2020 +0200

    removed comment

commit 673af264724261873f78079e72e5fc109fbf2f63
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 14:57:05 2020 +0200

    rework/restructuring

commit 50ae50d28679e620d0a60392f5b557ae4875995d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 14:01:41 2020 +0200

    removed pool raw access helper

commit ac2f6c5ed4dff00bf3ce3228896e393813998bf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:59:59 2020 +0200

    minor improvements

commit efa41b29aa2fb45180d7bd6c2805a8ced32378fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:16:43 2020 +0200

    added informative comment

commit 8db9a4a1911862a359d6c9a27569fb4e640670a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 12:00:57 2020 +0200

    some minor tweaks

commit 7774434d7a211f212ec376bb8296d6aa9f63aab7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 11:58:12 2020 +0200

    windows sockets working

commit 3e0819f954d3eb6b6fb090f7b0d157d867f4ed6c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 11:48:32 2020 +0200

    some bugfixes

commit b7c4f5ce05ec1c235cbea3b825d21ce4497dd095
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 10:36:39 2020 +0200

    continued win sockets

commit 0c85b05aca4d7a1adc8f5bf1a85133c845ecc63f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 09:54:22 2020 +0200

    continued win bridge

commit 08ffbfefae6ea75186a6b405afacc1b9e73e0f55
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Sep 6 09:33:02 2020 +0200

    added windows udp bridge

commit f698275a0bafc6494780f9b65858ca7d920e8e5a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:59:17 2020 +0200

    removed seconds typedef, confusing

commit c7606b7b1e870b510488da7d72c0dbe9b47e6ddb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:51:17 2020 +0200

    updating and cleaning pool files

commit cb970b1883b35412b64145ddff4f1c5eb1604529
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:24:59 2020 +0200

    task IF is set now

commit 7a24f899158ad8b6a3a74ff2da8a0ba530dc8539
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:19:15 2020 +0200

    removed comment

commit c43ae66205f6fc4c594075660d34b0f6317569fa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:18:30 2020 +0200

    some tweaks

commit 883103af2b4de3e099180e1fb999af974675e7ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:13:07 2020 +0200

    queue map manager update

commit 80e60566d82c5a6ed35c91af6f3d6cc21866dd7f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 21:11:27 2020 +0200

    compiling and working again

commit 39b675cf9984a1b22c215979821073a81202b273
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 20:39:10 2020 +0200

    repairing host osal

commit 05814dc805e3901aecdfd353c6e63712e9ed2c27
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Sep 5 15:58:53 2020 +0200

    added way to start DH immediately, bugfix in event manager

commit faeeca8707857dc75451f06fb78e1c5bffd22b63
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:07:54 2020 +0200

    seiralize folder converged

commit 1803030640f2201a006a3e3e30e8029cf001464b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:04:11 2020 +0200

    taken over serialize element changes

commit 721b981df2df5ea852d0ad8a0381b488099f2d32
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 16:01:18 2020 +0200

    changes taken over

commit 305d8ef84079a9e0e0861b4708147e3b562d2e10
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:56:52 2020 +0200

    taken over changes

commit f2f7a5de87b728868e13d96765846e50349a789f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:47:33 2020 +0200

    taken over convergence changes

commit 0d69e9beca4b0f35b2c0aea86d5c6df983e9ccaa
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:42:15 2020 +0200

    taken over serial uffer adapter from upstream

commit 37764f7ca710f3ae0ab3b41b7e6b72ea6ba3a14b
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:39:17 2020 +0200

    include guard fixed

commit be89e7ebb73f273077c4211eb01078e01d8f537a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:36:53 2020 +0200

    taken over from upstream with little tweak

commit cfa952d9829b4b686ab615b5383c5fa59de285d1
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:33:36 2020 +0200

    hybrid iterator same to FSFW

commit fff0131c9b27b25d8705ce42837f432035b51741
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:20:07 2020 +0200

    taken over changes

commit 147ab94149e2dff309ea628b5d77e74ed9a58208
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 15:13:32 2020 +0200

    include guard improvements

commit f4a50677751b01417a476dc1f309b5074e337601
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:53:27 2020 +0200

    update fw class Ids

commit 94b45d7407bd6413926184e8ec8f746fda648cfe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:49:27 2020 +0200

    changed taken over

commit 9d1f292af0f2973f595b0db09957a45a94782662
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:32:32 2020 +0200

    changed taken over

commit 6980245c984c69f052c8d1ba2ad1c5c240f50c56
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:30:04 2020 +0200

    added line break

commit 31c16382fc5d40cccc9ca3a58a8a60cef5d7a04f
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Sep 4 14:28:43 2020 +0200

    took over changed for fixed slot sequence

commit 403d83f32cedcd6c655e95e25e4f421df9e94971
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 13:01:14 2020 +0200

    removed commented out code

commit dbb394f761a147aae4a2fb722cb7ffc264452079
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 00:22:16 2020 +0200

    new member to store last step

commit 822a908353608f053590fecd9e0a3115c37cb6f9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Sep 3 00:17:01 2020 +0200

    separated steps, everything seems to work

commit e8fa9816ceea383d1e15e55b6bbf84d1e6327702
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 23:45:14 2020 +0200

    doc improved

commit 6069c64048b2850f7cb080cac2d0f836c4543be0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 23:36:54 2020 +0200

    doc improved

commit 631b2ca70536b0f05465dfbc790a01cbf509aac5
Merge: ae9bc39b 33039f8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 17:59:45 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit ae9bc39bdaadb7323dfe009b5e93276e620e6d76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Sep 2 17:59:26 2020 +0200

    some bugfixes and improvements

commit 33039f8c6055b45cb75b39a4e86a8a38430222a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:57:56 2020 +0200

    include  guard correction

commit bec562ece0ae8cc5f7c81d7e998f47ebfaaa083b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:54:33 2020 +0200

    FIFO updates

commit a634875b4b08cde12d2c2ea14d50303ab13d573d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:50:17 2020 +0200

    dynamic fifo update

commit 7cf79c17a9e54de41fd9a10e630ad07fd967829f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:48:51 2020 +0200

    fifo update

commit f7f134ac20ca6bb76fedd14804290fc06455c44a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:48:11 2020 +0200

    corrections

commit edde2ee58b54270aa832193312ecd289940fe0d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Sep 1 12:43:50 2020 +0200

    offsetr update

commit 15bb0aee985cc5b558cea21e635b1600db5905f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 29 19:08:10 2020 +0200

    handler ID cached, debug output improved

commit 6c02776975fbebb9a49302825943c0244c3ebc55
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 29 00:16:40 2020 +0200

    added srv9

commit b0673c7fa6e7f66d9c76a5f66c3d209579a759f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:47:11 2020 +0200

    typo fixes

commit b6a19f911d177e4129dfc0a5a10e0e499aa1ba88
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:45:19 2020 +0200

    include guards improved

commit 1b9c8446b7bb7fa005eaf7ce390c12800a3a2177
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 18:33:29 2020 +0200

    renormalized line endings

commit 9abd796e6fd1ad0d8fa91e78bf7b68e8d61ca61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:58:36 2020 +0200

    updated map packet extraction

commit 8596810fe24836ab9be154aaa47f584447ddef37
Merge: 9f522466 b71cab39
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:58:31 2020 +0200

    Merge branch 'event/git-update' into mueller/master

commit b71cab399330f3ae631bb51fd2cfdbb43dd32cf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:55:13 2020 +0200

    integrated all changes

commit 9f522466f0529e4fc56abc0ebf2d952e82d39e89
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:52:13 2020 +0200

    wrapped info output in additonal ifdef

commit e800aad97993d36f6800a35cc6ccd805a6e269d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:44:10 2020 +0200

    event git update

commit d2ef2b2be46e6ac29a6b75a5b44e32f56a7f16b3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:40:53 2020 +0200

    taken over datalinklayer form upstream

commit 5ce954672b023ea804d7915ac3031b284ad10091
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:40:21 2020 +0200

    taken over coordinates  from upstream

commit 2e23fc1201dbd6177527563ed74652961e53018b
Merge: 468ebfb8 8862f35a
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:37:29 2020 +0200

    Merge pull request 'git is weird' (#15) from mueller/action-git-update into mueller/master

    Reviewed-on: https://egit.irs.uni-stuttgart.de/KSat/fsfw/pulls/15

commit 8862f35ad136991e4f4a04d5551a507aba3ed31b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:35:27 2020 +0200

    git is weird

commit 468ebfb809f4ec6140492e3146f134f54b4f1d7d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:18:11 2020 +0200

    include improvement

commit 5ca26a72ea2101786cdfbd6a812a2d9913809224
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 28 17:00:16 2020 +0200

    fixed some shadowing issues

commit 42dd665e2649b8e37a27862640f1f73c1147c627
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:06:19 2020 +0200

    include improvement

commit ed70f3861272b064fae00a6fab155ccfe67b1e93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:04:17 2020 +0200

    some renaming

commit a6e99e443aaa483b705d8b5570d30ef2a524ec9e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 20:00:36 2020 +0200

    took over dHB failure isolation base fixes

commit 4d1b1ba50662984bd90af489dfa811d8165be6fb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:24:40 2020 +0200

    additonal doc for freeRTOS semaphores

commit b9314cffb955b95234a7c82e1a847c9533fee57a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:13:52 2020 +0200

    small improvements

commit 5aa664648e8e0d102e29a68c42fac9b16c5ecbb9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 17:03:54 2020 +0200

    linux semaph update

commit fd42d8cd46bdefece3002e15e585fa18578f1372
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 16:14:42 2020 +0200

    periodic task taken over from master

commit 6d3fdab9446d0129823b16aba8cc9e71e2067006
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 15:52:55 2020 +0200

    adapted semaphore IF to mutex IF

commit 1dfdd65662583271a202ee759c2fb48cc0ad6386
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:42:10 2020 +0200

    new initializeSequence func

commit 790e0399b7ce5cbb431cf8736cda0ca23b9a216f
Merge: 67ab1f62 3aa6858c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:23:14 2020 +0200

    Merge branch 'mueller/project/distribDatapool' into mueller/master

commit 67ab1f6240772ba1c85c6c826f8e9ee097418127
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 27 14:17:13 2020 +0200

    initialize after task crteation moved

commit 0f9930524b4b7ff8e3e4d5b13ea926ce4b3676f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 15:54:13 2020 +0200

    some minor improvements

commit 83c9d4fc1cb22228f1d58a0f6ba5a1f0f36b6fb0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 14:55:27 2020 +0200

    improved tmtc bridge

commit 51b62fd9b189ea149b64a2015c0497240041129c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 03:21:26 2020 +0200

    debug output fix

commit c314792e86042a2d60a7ce3a6af265fea4da61a7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 26 02:52:59 2020 +0200

    linebreak changed

commit da3b2b2500592047335c689d8f7d9b9b15f60a86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 18:09:05 2020 +0200

    form improvements

commit 6afbeb8423cdb3d5a0cf2d2c41623d1310ed2e73
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:42:11 2020 +0200

    removed linker forward decl

commit 92e18b91a3a9d4dac069281971009b4dba5a1dd7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:38:53 2020 +0200

    seriasl buffer update

commit b97128c12eed9d6b3e5d74f861ab99c6c7cea7ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:29:10 2020 +0200

    deserialize improved

commit c8ba486538fe6086ab8835a70c5656dd5a4ce1af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:17:57 2020 +0200

    serial buffer adapter

commit 3aa6858c93594a08a670479fda9354bd9940816e
Merge: 11ce3d02 6afbeb84
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 25 13:04:20 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 11ce3d025fc58fd4205ddc3ef4302ab5262f8c2b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 24 22:08:27 2020 +0200

    srv3 received reply now

commit 8e7f167a6628c0b219b0cbe18e991a2b203a2170
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 24 14:48:22 2020 +0200

    small fix taken over

commit a5227115e5b0361ec33242453ae3435589033200
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 23:24:48 2020 +0200

    first subscriptio nfunction written

commit a95bc6b293683e63c3070b5f2ce33a5e2b3f942f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 22:33:22 2020 +0200

    sid cached now

commit 687e124929f367f8009b517450e8f61322bb0613
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 21:52:44 2020 +0200

    doc added

commit 2b63f1b3f3557ae05bdb55791d90e2febf8a17c8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 21:00:25 2020 +0200

    New reporting mode

commit 2f53a3fb1b283cdb26fa4323af2c071107397b57
Merge: f39b8bdb cdaed452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 23 20:27:00 2020 +0200

    Merge branch 'mueller/master' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller/master

commit cdaed4523bdbe6f27820de605344340fec6698b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 21 16:15:40 2020 +0200

    tmtc bridge todo added

commit 0d476062299a1c5f305146327be3920480fd940a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 21 15:49:06 2020 +0200

    tm/tc packet stored improvements

commit 15fd30b23f313a2f8678fb0946a7ec9c84c52266
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 22:31:58 2020 +0200

    assigned read len for decoding error

commit 9385f9024132a5f5edb23284ee70911e7a302110
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 20:36:49 2020 +0200

    some bugfixes and improvements

commit adbf39166f1cd7d9b86033148f02b9c18c21f438
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Aug 20 18:13:17 2020 +0200

    removed pus parser

commit f90bd012825b29ef0d4ec1d7b58f1b48da424103
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 19 17:00:50 2020 +0200

    added srv17 and srv201

commit 7b998268cb782f90e8daab6d3bbe94c08cb37047
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Aug 19 13:17:40 2020 +0200

    error message improvement

commit a1d94ec556b6fbb35b6dbcc76499ba9620d663ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 20:51:13 2020 +0200

    added aditional comment

commit 5af50cfbf74fdf025b30030f0f2edfa29ed080b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 20:50:24 2020 +0200

    renamed .mk file

commit fbecda75492905c8c8301b774d66ee777e791037
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 18 13:09:15 2020 +0200

    include replacements

commit f39b8bdb419bd2832d8b1e6b44b13ece12ceb0b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Aug 10 18:33:28 2020 +0200

    several simplifications

commit 87eb31b65aa7c68c4b3ad40cfac7353349b7b968
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 20:06:29 2020 +0200

    local data pool manager uses new packet now

commit 9e7d92b387249a6156a889e277cefc80fd53d667
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 19:46:37 2020 +0200

    some renaming , hk packets finished

commit a181f19c02a0abe25966be3b9c18026f7e1d824f
Merge: b092850d 5d09ae32
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Aug 9 17:13:58 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 5d09ae322176247536667994806ca8aa6bb3b1e5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:47:44 2020 +0200

    additional comment

commit f9ce1d9eb9f5fcf85a339fc28b3b5806cb1c644c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:46:21 2020 +0200

    more simplifications for shared ring buffer

commit 6484c1a27697f1b3a8326dbae0d3fa5eb4be7b4f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 23:45:18 2020 +0200

    shared ring buffer simplified

commit b092850dfcb0a37f3d9fd8b67933b8201d8d622b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 21:32:15 2020 +0200

    internal housekeeping packet finished

commit b828d7c6d7b8267e9867369a557d6e0b9c4d8452
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 19:56:42 2020 +0200

    continued with local datapool manager

commit e7d28d630cfe41ed859f516084b661df3b37a565
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 19:43:28 2020 +0200

    continued with implementation

commit 03cd5780f9b6f915566c07b07482a1b86b103eed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:29:38 2020 +0200

    null initializations in header

commit 121e94a3854049c4a4075327034f8d492b1b3bb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:20:02 2020 +0200

    local pool var update

commit 5c85d03c39af4e9ec31a03e238dd1994b02ea68a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 13:04:31 2020 +0200

    additional check for freeRTOS

commit fba8775f49347da75646b0c70e4adbea94cbd1b3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:51:31 2020 +0200

    some renaming

commit f766398b20a1c148f63d10eaea70aad46bf2f3a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:49:20 2020 +0200

    some bugfixes

commit af11c8fcf96c242447baeffbbb9731c9807a6f8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:38:39 2020 +0200

    freeRTOS corrections

commit a6a1e656071342e70d2408a51289ccfe42de78e4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:17:27 2020 +0200

    local data set fix

commit 4afb19be51b4fee35d8140f08072df043ec7fd21
Merge: b7411591 03cd5780
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 8 12:04:52 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit 979fea3400668661d817621766c64af1a62ed379
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:15:03 2020 +0200

    mutex helper api change

commit 458e849f7d86ca95b0a3ae675d4d00895e26ede8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:11:13 2020 +0200

    adapting mutex helper to new interface

commit 44b70b45e216600bf5cfdca4899166f6bad0fd41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:06:20 2020 +0200

    little doc correction

commit e3d094b2dec8ddc838a0f70218b0200b8c1b1ce4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 22:02:23 2020 +0200

    linux: removed old static timeout values

commit 37f2539d894b8f1e9b85fd29005032c9bd4ba12a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 20:44:40 2020 +0200

    empty line removed

commit bfecbfbd80a9f64f84b55246b742c07bf1beccf9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 20:36:37 2020 +0200

    implemented new mutex interface

commit 1a118fe215350eb321184bae30777278095cb1c7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Aug 7 19:21:47 2020 +0200

    added documentation to assembly base

commit 66039bd3feb553e913fe8440a48e09c1b8843166
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 18:14:39 2020 +0200

    move group def down

commit c4ffb1acd5bff2a8214ddb9f4336d081b3f84636
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 18:12:15 2020 +0200

    subservice number correction

commit 3f87537c6106feb54ab0151247be0ad300a88580
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:25:24 2020 +0200

    minor corrections

commit 4d3f0875c18a69147c18f99d401175e5b64c361f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:23:37 2020 +0200

    periodic task if adapted

commit 2177877625aa1543c585504505b55b49fd1c2904
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 15:16:09 2020 +0200

    updated framework subsystem ID ranges

commit 4dcfa5125edf80f2bc6bde7861e1da394b4d7a4e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 11:47:47 2020 +0200

    added additional calls

commit 6b475792a4a7c57a5006a010c554dda8b31d41b7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 02:25:10 2020 +0200

    shared ring buffer continued

commit 4e9e465360b2b4757699e79b265c12358ac5e8db
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 02:00:00 2020 +0200

    shared ring buffer continued

commit 0ead44bea976bba70676fc40ed9716f2ae6b84d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 01:07:59 2020 +0200

    getFreeElement implemented

commit f240827bbdd9ad7542e21ca5810235e6acb20c96
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Aug 4 00:59:19 2020 +0200

    added getFreeElement

commit ebf5d41a7880f4c866fa1eb29113ecc960bd0efc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 19:03:03 2020 +0200

    parameters IF doc and improvement

commit 7475e6a9b85278512a1f4c922e564519cbe63a8f
Merge: 76cc3e96 66eac57e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 17:06:12 2020 +0200

    Merge branch 'mueller/master' into source/master

commit 66eac57e3bb77c73a4030d1320a64b42e5841641
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 16:54:54 2020 +0200

    csb update

commit 58a4f4f8a1d9608b671cd6fab087afea5d086dc1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 16:39:17 2020 +0200

    command message bugfix, CSB improvement

    parameter helper diagnostic message

commit 76cc3e96e8680127fd16c30d83bb4b4c32f6f31f
Merge: ffba6641 18899a4c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Aug 1 12:34:46 2020 +0200

    Merge branch 'mueller/master' into source/master

commit 18899a4c828262258699d9c80beab12cd251b506
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 29 20:07:24 2020 +0200

    hotfix for deadline checking

commit 276c3b172e18df8b7f457e23fb43c22e9c332553
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 29 15:32:36 2020 +0200

    better diagnostic warning for DHB

commit c64aa9f7f55e4afbc5f21cf149bfc71a889a06e5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 21:00:11 2020 +0200

    another important bugfix

commit 9fa9421ba58d4c6793aa19886ce6ee17e7f85d71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 20:57:05 2020 +0200

    important bugfix

commit 9acf82cf510be6dfd0f7e94601cdf4795213e5f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 18:12:10 2020 +0200

    doc improved

commit 69f9ff02f047917c2c6a622bcb6fc6244d60564f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 17:00:51 2020 +0200

    better returnvalue for failed  comIF init

commit afc16ef2d72dd6662ecb19c4a08a9aedc2119aab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 28 12:49:18 2020 +0200

    new servicei nterface buffer /stream

commit 6425c0dd4c43ba0fa0711d5d894ae76a1858782f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 26 03:12:04 2020 +0200

    better init error output

commit e179288c00ffedf8e160b399db15a0ec26395ea2
Author: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date:   Thu Jun 25 18:09:32 2020 +0200

    Fixed spelling mistake in HealthHelper

commit b7411591a151419687d1c55054543ec065e7345f
Merge: a0b8f885 b4d6d970
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:42:02 2020 +0200

    Merge branch 'mueller/master' into mueller/project/distribDatapool

commit b4d6d970bc9890c24b4abb3c671dad2104aac383
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:41:05 2020 +0200

    removed HK manager virtual functions

commit aaafed7b28bc7110321f0a092a81beb8002990bb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:38:21 2020 +0200

    health table init now mandatory, better

    diagnostic output for uninit health table or invalid health helper owner

commit 47b3a428c68ff74a6019eb2c36c9fb253cc427fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 12:33:03 2020 +0200

    removed device switch, not necessary anymore

commit a0b8f8855ced699701290f643c1fab8658bd323b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 16 11:45:23 2020 +0200

    cotinued distir datapool

commit e5ab7ada682fb80db4daa3ba7b4f5f20b364fedd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 14 15:45:03 2020 +0200

    added new interfaces for datasets

commit e204bd77c6cf4ac9a4229ed434674a43d72a94c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 14 02:21:11 2020 +0200

    created tpp file for fixed ordered multimap

commit e7b6999c5ea11e776848cb63a11f1e9673af0efa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 22:13:19 2020 +0200

    added back inttypes.h for cleaner code

commit 15052cb33304f18d3e5ce95a4b547a2ff0826c99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 19:54:38 2020 +0200

    singly linked list update

commit 6d99ab3df3e105901cf6af955a034968b7f8364d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 13 19:37:33 2020 +0200

    ncreased readability of DHB function

commit b4f292f3d7fc4f606bf1b6d48618bd0cf1878e26
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 12 18:01:09 2020 +0200

    new generic freertos task interface

commit 99aef0cf287fcdf23f9336927c171762e8bf4f7c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 12 01:16:32 2020 +0200

    C++ linkage for yield from ISR function

commit 7d794c76235c8247602b6327034f604d962b71c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 18:24:09 2020 +0200

    task management functions have freertos syntax now

commit 799846d89fecc4c17dc6305d17b903217b0687ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 14:29:30 2020 +0200

    little formatting changes

commit e4f795d209f36bbfaa39a1d03e46c759d4a86acd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 13:38:14 2020 +0200

    stack high watermark in bytes now

commit ffba6641448c921f74ec7e4ff48e774d8d037b2a
Merge: 69946d52 35d4267b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 11:57:46 2020 +0200

    Merge branch 'mueller_framework' into front_branch

    changes for new freertos task monitor

commit 69946d5276549dce7624540df1de75c94ffc5004
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 11:52:01 2020 +0200

    FIFO hotfix

commit 35d4267b400a950847447d2adc24e53096e4ef86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 02:36:04 2020 +0200

    dynamic fifo bug fixed

commit 6a6395313f8dce6ec9693acddb6b93d3cda9549a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 11 01:06:01 2020 +0200

    added copy ctor and assignment for FIFObase

commit 444ee80f356a8e6b8e639c1cb847da320a21713b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 20:31:10 2020 +0200

    removed unnecessary case and added more size checks

commit 31450362106ebec643d99dd60d963e822516b0a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 19:34:18 2020 +0200

    getter functions for task handle

commit 36a7f2f9ee86b00370bee48721f470d9392bf93c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 14:32:25 2020 +0200

    removed file header comment

commit e29226c9bba6587460d5db87e3ad3b3d7eab2357
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 14:28:36 2020 +0200

    srv8 improved

commit 9716bcdd749cca8ea2e569448a7a1b8ab7cd2298
Merge: c8821ae7 a7d68f8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 13:55:14 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit a7d68f8c52886f39d116a9ad0553f26463c753b8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 13:31:45 2020 +0200

    deleted copy ctor

commit be8913efeaada850906e19f2d40b6e503b7ec270
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:30:52 2020 +0200

    srv8 improvements

commit 9cbc1a18b8c305c095f1c70ada691541e1df6bd1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:16:08 2020 +0200

    csrv200 improvements

commit bdc6e881986e9048eac100561ac0e0159b1b0eca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:09:32 2020 +0200

    reordered includes

commit 3551a767a71635c47af18df4b5afbc393416838e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 03:06:18 2020 +0200

    removed old code

commit f3739fd213acd0849399fa4b755ffa7a126da6ab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 02:44:58 2020 +0200

    bugfix failure isolation base

commit 7a4cc1a6b692b39c596bb88e67051af69b97f928
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 01:22:23 2020 +0200

    hk manager initialized now

commit 1fde3c2c992f3fd96cd0098bfb23c5ab6fa51589
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jul 10 00:19:25 2020 +0200

    added srv200, CSB doc

commit cdd877032fe211cd6e9e56940352f608b7e90efb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 23:20:48 2020 +0200

    doc for system object IF improved

commit 57418eb877888bed655eb8f3fee2d58b6f4cbe82
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 20:04:49 2020 +0200

    distrinction between default settings

    and individual settings for service

commit ad049cc634b1c0aa9b0505bc4de42cb6a89a6679
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 19:41:52 2020 +0200

    tmtc bridge formatting improvements

commit ceb61979048feb501a31530ac363aaf53c6b5e43
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 17:01:12 2020 +0200

    some minor improvements

commit da30680d04bffca3ebd17a446fc7cad765a6770f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:54:18 2020 +0200

    readability improvement

commit 0cdce6e3272b72044a6d2acf1248d821b62d7002
Merge: a5d3d9ea ac9e6e13
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:47:39 2020 +0200

    Merge branch 'mueller_devel_distribDatapool' into mueller_framework

commit a5d3d9ea8030d5f14a7c584641b68a5bf4f21d58
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:46:57 2020 +0200

    improved init function

commit 5a351474d2de7e2b38c2ccf232f1a9ba6241bf10
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 16:31:33 2020 +0200

    DHB ctor simplified

commit 32ef807341f2b868af94a11507db532990a4c771
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 15:49:52 2020 +0200

    newline

commit ecd740a1015f47d60ec73b48d54f632dc6aa38bd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 15:47:50 2020 +0200

    ring buffer base calls made protected

commit 6f50356964da86b311b9e96b08d33de6c2b76233
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 14:26:15 2020 +0200

    new shared ring buffer

commit ac9e6e1337acc8a5f68811be1f5da30c69a3e52e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 9 00:59:10 2020 +0200

    continued with local data pool manager

commit c8821ae74f90cbbbcf4d2d89d29b981b74219ad0
Merge: e48de981 64c290ff
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:49:09 2020 +0200

    Merge pull request 'A lot of new features and tweaks' (#12) from mueller_framework into front_branch

commit 64c290ffe44ce6a4352152bcb1a04ff643bfd395
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:38:58 2020 +0200

    include guard fix

commit dc27cc9aff73e6c17eb36281d056bd7c217ba6b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:37:26 2020 +0200

    srv8 added to framework

commit 8046d005a46e734aa2112cbd6f617920da2ec753
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 18:18:54 2020 +0200

    CSB static framework id setting

commit 236ad1b85b600acecc741127faa19c72925542fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 15:06:46 2020 +0200

    a lot of debug output added

commit 5ec78b065c4ca0ba486b9837c0e4c0eba40d5b15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 13:29:57 2020 +0200

    error handling for invalid dest queues improved

commit b56aa94f99730cee982eebc09dd8fa88a3fbc077
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:54:40 2020 +0200

    additional doc

commit 01b10803766e61833eaa9762327a48e0fff76c29
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:53:46 2020 +0200

    readability increase

commit 94f9b1e1ef0ecdbd0f92751284f74dc02310b7c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 12:41:15 2020 +0200

    dle encoder doc finished and hopefully correct

commit 264914e86a1b9a2854dbc8d83ed96445a1255482
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 03:18:09 2020 +0200

    tmtcbridge tweaks.

    UDP bridge now working :-D

commit 2efcda735f84166665c2c1b42dc604048a7bbb34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 8 02:20:38 2020 +0200

    message arriving.

    big clean up in tcdistribution folder

commit 399fc0e287048b1fb8e1343185d637c78a791a80
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:42:37 2020 +0200

    fifo replacements

commit dd48f7ccadc824b275ea3bf2af0da1c9820ad61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:28:00 2020 +0200

    some form improvements

commit 06d389ed1e6157f1fe736c5dacf121eec247ea14
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:25:52 2020 +0200

    increased srv2 readability

commit 684b56ac883b0ee0528edc55b492977518611430
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:21:47 2020 +0200

    srv2 tweak: CSB params now configurable

commit 7698f3f13e4ff5886c6c56145e56111a49a6ff4f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:18:33 2020 +0200

    moved srv2 to framework

commit 359163886ba2d926cefe8f57b6691818a1e70b8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 17:06:30 2020 +0200

    pus srv5 and 1 moved to framework

commit 4f1f610ae03bd4f0fecc9e19ecafa5803ee8a231
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jul 7 16:36:41 2020 +0200

    doc and improvements for DLE encoder

commit e48de981f54e611d67bba1b2b7907ba2425051a8
Merge: 062ebabb cb691db8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 23:31:38 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit cb691db807d562c8f84178d48650464c4cb58ecc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 23:07:38 2020 +0200

    fifo tweaks, pus parser fixes

commit fd1e612ea5d931d20177405a827c34bf52ee7c54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 20:17:05 2020 +0200

    pus parser fixes

commit 8ba75fc3c2fad46fc0e37fe17a627a99cfa3f09a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 19:36:21 2020 +0200

    pus parser implemented

commit f442a5889ec4bb213f35668a9320dd4cfedeee94
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 16:34:11 2020 +0200

    pus parser continued

commit 78283ddbeecefb733fe68408befb3337ad869173
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 14:09:33 2020 +0200

    queue map manager: not using std::atomic anymore

commit b61e1df8bcd2177f06cbdb28e7c4352cee75422c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 13:43:41 2020 +0200

    fifo in namespace now

commit bb5de8f11041014ad9f6c33c98fc6d6e0822afc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 13:41:07 2020 +0200

    merged new changes

commit 2158208a2fbbd98c1fa5ced154866803f80d04f1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jul 6 00:33:55 2020 +0200

    new pus parser

commit ebec074655d40dd60c4553c8b94ce3018d6f7358
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 23:53:13 2020 +0200

    Split up FIFO into StaticFIFO and normale FIFO

commit 2395e487aee6c5cc6701a4e0a50de2ea676e4f0c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 20:42:05 2020 +0200

    udp polling taks init

commit 327b1e9d2f242c49c331533a6d8c34407bf0060f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 19:11:21 2020 +0200

    file renamed

commit 724fee09ff30d8c1e435870a93cd4800e6ac0c86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 18:58:16 2020 +0200

    new task for tc unix polling

commit 26ab1983dcad5ae88addd3aa9b947db9ee6edfc6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 18:22:39 2020 +0200

    new ports

commit 9e2fa165506192b18ca2ea4fa2540c7918c9e480
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 15:31:02 2020 +0200

    mq stack error improved

commit fcf3f04377910154f4a8302481b5f0cbec5273fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 01:25:49 2020 +0200

    diag output for inits improved

commit 9dcf0c711854aff22789f0bdcb5375bde51e74bd
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 15:50:29 2020 +0200

    size_t for DataPoolAdmin

commit b86e5664c470bf1b1c9615abb8557d51d3f86eb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:33:03 2020 +0200

    include which was missing, pool raw access size_t replacements

commit 1a177d2efa05f62c86fe33352cf3608d1b96340b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:28:06 2020 +0200

    integrated pool raw access serialize changes

commit 24240b6c7d73d124af1caae18ead919ccde203c8
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 15:46:00 2020 +0200

    Documented EndianConverter and changed length to size_t

commit c160000027bbe6311fd9c0d318c62a51179129ac
Author: Ulrich Mohr <mohr@irs.uni-stuttgart.de>
Date:   Fri Jul 3 12:44:08 2020 +0200

    Corrected filename of EndianConverter.h

commit 5cee12684142153d01f31627b0bd9b17bcee31d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jul 5 00:06:30 2020 +0200

    formatting

commit 571da391087a8c03220989ed61b1333543aef4ee
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 23:52:44 2020 +0200

    continued new bridge

commit e0a3257f8b945da09aba28e784ebc2756e72f984
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 23:20:29 2020 +0200

    even better output for unset max msg size

commit 72768a68152b3fb6778e7c90aead2b6f46d596ab
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jul 4 00:51:49 2020 +0200

    started unix udp bridge

commit 18173772affc0a39866e74465f443328625a4ead
Merge: 47b8ed23 099e6281
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:56:27 2020 +0200

    Merge branch 'mueller_framework' into mueller_merge_mohr_serialize

commit 099e6281ecdaccf39127da33e7b86b6eaa3f2335
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:54:53 2020 +0200

    DataSetBase not bound to max size anymore

commit 3e069c34aa6a076f0394ab6bdf3c66f14294ba53
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:29:29 2020 +0200

    datasetbase stays same f or now

commit 8011d49ebc3c935cb2aba3ccc267f33ed342a60e
Merge: 837fecf8 68c41e23
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jul 2 16:07:16 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_framework

commit 47b8ed2321c1a71743cb50fa555cbb3f6b2a3a62
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 14:34:16 2020 +0200

    split up long debug message

commit d7bff31a4cfd5e720847a0c9525a4099b97560ac
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 14:17:55 2020 +0200

    compiling again

commit 6802ff7d710ddab109d513c2091d683d566b68bc
Merge: 837fecf8 6553450b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jul 1 13:15:58 2020 +0200

    Merge remote-tracking branch 'upstream/mohr_serialize' into mueller_merge_mohr_serialize

commit 837fecf8599a54102c59ea549ac56a876ff5c32b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 21:22:26 2020 +0200

    added hk receiver obj id to dhb ctor

commit 062ebabb9a4d6ff625d3fab05cd385978bf201db
Merge: 2de972bb 1820b5f9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 16:41:38 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 1820b5f95c4e3d03c06cd7c0ee9b2fa6639adac9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 16:02:07 2020 +0200

    hotfix for copy ctor

commit 2de972bb8a9a35b81824f5c6bc5d00802c32dadd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 15:51:19 2020 +0200

    const store accessor copy ctor fixx

commit 3a850018550b319476a4ec8b68bd75b035909df2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 30 00:48:48 2020 +0200

    bit setter correction

commit 85cc936d5da669f8f74ea02c87a8204f4a6235c4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:50:45 2020 +0200

    added back clear CommandMessage function

commit e2a36efce3d210c85c1ba924cd627a43b1cac922
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:47:58 2020 +0200

    csb changes taken over

commit 48df3cbe8382423b671d7b5d651e3b623f4e2d90
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:43:02 2020 +0200

    csb comment improved

commit 691be0dcd4f6c8586b4a29b866bc7d9808d345c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:39:55 2020 +0200

    dhb doc improvements

commit 044aa259e6298bf8accff8c8ab53cd373ed186bc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:37:55 2020 +0200

    dhb cached pst interval now

commit ae6314d8cd43a0ad8f0c1a7b9bd567be378203d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 16:06:53 2020 +0200

    added task handle member

commit 003e70bf4785a8b9e57a8f8ab5f67ae0b0dfade3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:55:20 2020 +0200

    new initializeAfterTaskCreation()

commit d5d968a39365b2b0c285d8f283a054050e94be3b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:46:16 2020 +0200

    some more correctioons

commit b81b458ba6cc5c6819b9dae6045e25469a1d43cc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 29 15:44:18 2020 +0200

    exec task if new init function, some corrections

commit 71f997888b71a0c3b5fc77cec93537a849f5984b
Merge: 61370d43 ba5b8bd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 26 13:33:19 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit ba5b8bd682e1e3e36612a9c8974a4b27c8bf1151
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 26 13:28:58 2020 +0200

    hybrid iter update

commit 08f25370f3505ebf39f26166b2bf5a4000c28461
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 12:03:52 2020 +0200

    moved typedefs into namespace

commit 0c32a964529105b611b600938c84df647f8fa0cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 11:54:41 2020 +0200

    some more singly linked list improvements

commit 8d633bf1278e473a23ab67ee86458771a5c45bc2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 11:40:48 2020 +0200

    took over changed for singly linked list

commit 6f2bb4125d7e4cd9baaf812c3dcd118883f65e71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 02:02:57 2020 +0200

    bugfix

commit 7f3607c3d998fb4473fd7b35b3ddf9ebff7b1dbb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 02:00:26 2020 +0200

    hk service fixed

commit 61370d43da713b54379251bca1c6a07f1456318e
Merge: 65c775b8 bb9f606f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:29:11 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit bb9f606ffde07095531ee2d3fac85812ce5f59cf
Merge: 16cbbb26 b2c352b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:26:23 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_framework

commit 16cbbb2693a18cc588661270c482325d4257e95f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 01:11:48 2020 +0200

    linux fixes

commit af24cc7d047cccf09ff5a002a86aa222b18b19ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:49:13 2020 +0200

    some bugfixes

commit c7c49b4239fe42f4c4da47eba686c41ff687cf17
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:30:32 2020 +0200

    deleted command messge base

commit 3bf29a7315d926dc1447e954494f393061ee2c8a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 24 00:24:15 2020 +0200

    removed CommandMessageBase, changed interfaces

commit 905c1a92e38865558e25bebb10a8c7ca380d2ab6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 21:03:22 2020 +0200

    reverted some changes

commit 56455a5fa290d69f62ad6a17a2ad66b311401c5e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 14:11:53 2020 +0200

    added static function as alternative to macro

commit 67366c25a0bd0b4e532cb8ee48d3d795215c773b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 13:49:25 2020 +0200

    typo fix

commit 5f16d30d822a26fd42ddd2cdc4bc5211db695f41
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 13:47:38 2020 +0200

    all ones value for return failed now

commit 6f4682e1c8848e8fb578af9329c6f274e84a6f60
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 12:53:30 2020 +0200

    hasactionsIF include guard and doc

commit 2ecd7c44937180ab0aad13a1185ed9cc54c9eaa4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 11:05:40 2020 +0200

    some minor improvements

commit 446e7d2f82d46ce9690d3f2c4c84b166407a8c2d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 11:00:40 2020 +0200

    const storage accessor improvement

commit 45ffb7549aa0654f1423ef5cd8dd0f012ab0537a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:58:48 2020 +0200

    storage accessor const in own file now

commit e27310da40a420e78cc894746301d318da632bc9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:47:31 2020 +0200

    updates for tmtcbridge

commit c0beef44630f991e7307727bbcca6adc81bb48a0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 10:27:44 2020 +0200

    some include guards, todo comments

commit 64a02c55ba9c0f067e64b460b66750b613a31526
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:37:25 2020 +0200

    linux fixed, size checks added

commit f7d55a8a37559bf9717b49e414c19db99c5113e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:15:35 2020 +0200

    equal to pull request now

commit 847292ea30e3c71678b0cf994e6436caad71a463
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 23 01:10:19 2020 +0200

    added overflow checking for periodic task

commit a82dbcbd501a6c035430f8394d5eaebe06480918
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 23:47:18 2020 +0200

    minor doc correction

commit 6a7f47e06d95c91f8f9885c38f0716894735a10a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 23:46:44 2020 +0200

    doc fix

commit dadc867d9ed44d82782d2f3f66cc0f54b50bfe00
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 20:18:13 2020 +0200

    adapted MessageQueueSenderIF function calls

commit 5734a0a0e948df50c57f9d589a2eddac479bb70b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 19:22:52 2020 +0200

    some fixes necessary to perform size check

commit 3b2fa978e1b86ccf1b9c113ab958dcaf81e63b4a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 19:06:10 2020 +0200

    replaced break with continue

commit 109fdad8b36ca1fe99f0ebad89fb28b04fa7d197
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 22 15:34:35 2020 +0200

    size check for message queue

commit 65c775b83c4ef3c40e3666a10a90c06847349c8b
Merge: 555b7cc9 45a55044
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:48:35 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 45a55044ddd3ded4cac2522313f1db53ac62c1d4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:47:36 2020 +0200

    using debug stream now

commit 95b646046b162d2c47e0a231ae8fad35cc733f21
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:43:29 2020 +0200

    debug output working again

commit 3936fe93609875c7f49332a8a5f24b09d67b7c1c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:34:19 2020 +0200

    linux fix

commit 2c04b87418f2552f836775e4c3eaa1b14bcd033c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:18:00 2020 +0200

    corrected includes

commit 1b0e7c84c7ac2fff9e8b7129110271681c147620
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:15:58 2020 +0200

    linux periodic task improvements

commit 2de811e0afd0ae6a1dc9e4d700bedc693a888691
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 20:14:56 2020 +0200

    moved timeslot files to task folder

    implmented setting task IF for regular periodic tasks

commit eb4ce980fe93feaba64f01cf13d43d96aaa7d20a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 14:32:04 2020 +0200

    small fixed

commit 60ae2d45655330a3d81dd897b8dfb0ff6456dcd4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 14:25:03 2020 +0200

    continued with hk data pool

    added deadline missed check for fixed timeslot task,
    improved doc for both periodic task and fixed timeslot task

commit 84b8d733c0065280fbb1e39d81bcb8f20fc1ddb7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 19 03:03:17 2020 +0200

    hk continued

commit 583efec3f8d93efab38c792a9f264f29b0bc01c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:45:44 2020 +0200

    nullptr

commit ed26992d7f1decf404e04d39477836381ec5635b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:40:40 2020 +0200

    shoulddo added

commit bb16fd80b8d60813f0605737e2cdd47d729effbf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:37:45 2020 +0200

    singly linked list improvements

commit 259517ac9ba0cc51e61980883467374b3ed849f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:22:09 2020 +0200

    single linked list improvement

commit d5ae74f86073c2f9847f4abbd9ed921cdb5ae094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 20:21:49 2020 +0200

    bugfix hk message size

commit b68ad9e4f9182f8e216e69b34d58138e4044494f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:50:26 2020 +0200

    new ctor for simple ring buffer which does not

    allocate

commit f8f10a173033b71d0bb4916cf89243327c0c2921
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:41:10 2020 +0200

    slight hybrid iter improvements

commit 38676308e332ead072d35238c95953b7e64abaec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 17 19:37:55 2020 +0200

    improved array list a bit

commit 813e82415affa80420751065d83454ae88d47262
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 16 11:03:24 2020 +0200

    additional doc info

commit 555b7cc9823123443724d3d61281576cca288fc0
Merge: cd424d79 7871ee7c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 17:59:59 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 7871ee7ca810bc49380b3362b3d0c9e1c0e49e0d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 17:39:52 2020 +0200

    mutex helper little formatting correction

commit e39d5689e537be8ae3595383005d62e656ad554d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 16:56:22 2020 +0200

    device com IF formattign

commit c9d8bd59f0120dca352352dab737d39c43896131
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 15 11:11:42 2020 +0200

    ctor improved

commit 6ecf1cf534b1eaf45be731263a241b629fa3d937
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 19:03:28 2020 +0200

    hk message continued

commit 9f69191f234d84e8d73b6ceeeabac3699466aaea
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 17:59:14 2020 +0200

    optimized command messages a bit

commit cd424d79e7fe68e3fb14249399bc2beb96eaad10
Merge: 60aed39b 8c03f6a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 14 17:13:52 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 8c03f6a823afca715f51d01cbecdbaa5e6ca185e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 13 21:01:01 2020 +0200

    command message only passed IF now

commit 6b67f46c802aa1b421689097d3faf96668073c71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 13 17:37:48 2020 +0200

    evil hidden bug found.

    CSB uses CommandMessageIF now

commit 7b538e9750001a7b91a89fbde5a47f9b619674eb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 12 20:23:39 2020 +0200

    introduced command message base and

    command message IF

commit f578c3ea29731f29153741b1ee99ae95c02782c6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:46:18 2020 +0200

    set buffer: const buffer is set too

commit 60aed39bc5bd5bcc3bf6abe04ebfed73f1b95eee
Merge: b6427d01 6838a9e7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:22:50 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 6838a9e7687a7232f903b5b39c11fe026bf476ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:19:22 2020 +0200

    serial buffer adapter bugfix

commit 206235ed47e0b086acc06015aeb36484bfeeab76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 16:03:09 2020 +0200

    dataset base bugfixes

commit a9c7ad84c8b93c39021194e99306e023432b4ee0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 11 02:03:18 2020 +0200

    added new interface to host and linux osal

commit c1fe326f67f7e734b2f2a8b8d2f9bd569fc537b2
Merge: b2ed0edc 3268806f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 23:42:09 2020 +0200

    Merge branch 'mueller_framework' into mueller_newCommandMessageTest

commit 3268806f75a3ea8ceaf7ce933276133d26b05719
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:51:54 2020 +0200

    split up huge function to be more readable

commit b2ed0edce0fd0499fab41e900d877ea42d10b6ae
Merge: 47aa9ddc 454524d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:45:04 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_newCommandMessageTest

commit bb9a299e33ce7429314acb58606f964613a31589
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:19:40 2020 +0200

    added back removed comments

commit 5007041bc87e39a44284de14f465fa0478cbc2a0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 22:12:29 2020 +0200

    cleaned up includes and improved doc a bit

commit 659594bac71505492c01feff182a2577f79fb1fe
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 21:35:47 2020 +0200

    better include guard and doc form improvement

commit 606957dc243f31d18d80f51885f4684fc134186b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 21:26:45 2020 +0200

    PSB update

commit 8fbd414a86c82e66f21c1a2fa89f2af005fed1e9
Merge: 52c88792 454524d2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 20:57:04 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_framework

commit 52c887925fe68f0729db72925c24e3b703ca600b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 20:53:28 2020 +0200

    iomanip include

commit b6427d017be03a19bd847e8ffe800c1e7b9fb892
Merge: b20ba1f9 20e3b3c0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:19:00 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 20e3b3c0e2eeec791f2f7c25e1893808af28c0eb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:10:16 2020 +0200

    0 replaced by MQIF::NO_QUEUE

commit 3277d199ac166db242ff1fb7b5edfab6fa2964ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 10 01:07:50 2020 +0200

    linux mq update

commit 47aa9ddcc382393279c0a769e51e7d732cf25a35
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 9 02:46:19 2020 +0200

    doc for mqm improved

commit 8ff6506ad90965f6a42d2b03a1fa2b2638f436c9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 9 02:18:39 2020 +0200

    MessageQueue refactoring complete

commit b1f91439c6325593c59099cbf93d214c27820fc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 17:50:09 2020 +0200

    deleted copy ctor taskes const ref now

commit 07302e0d2aa55dc7a0ed77c595e94f3c4ae9899f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 17:44:54 2020 +0200

    removed include

commit b20ba1f938a213c6408d326eb6a591d119b81e61
Merge: 3b4413a6 514ff4f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 14:06:01 2020 +0200

    Merge remote-tracking branch 'upstream/master' into front_branch

commit 3cb79ebc864d17556c4b0743ec3c57f71001fea7
Merge: 0ea249aa 514ff4f4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 14:05:40 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_framework

commit 0ea249aac46c7416aa5b908b9c5f844ac8e09388
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 12:25:20 2020 +0200

    messagetype namespace im small letters now

commit 4c41456ddffb6800119c0e6a0d90f4ff03bd4618
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jun 8 01:22:21 2020 +0200

    thoughts on message queuee message

    new interface. What if there are MQ messages with different sizes?
    -> generic interface

    furthermore, maybe command message should be refactored to operate
    on a mq message instead of implementing it

commit 2649fa150706bc93d88137dc1de595d2d17272b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 23:38:15 2020 +0200

    small small command message tweaks

commit e8bc2cec9f267079f29e78c94d90d4e107e7eba0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 23:26:52 2020 +0200

    small comment in semaph factory

commit 4a90f41122339e106b7ec52f45fcd982dccc5c39
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 18:53:55 2020 +0200

    generate HK packet function continued

commit 3b4413a6ee268d2759a5ef94c1ce8348c7f4d425
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 16:12:23 2020 +0200

    added queue lock for  receiveMessage

commit 98e6ca5f78b19e679f5f527db1c3612f8e1f214a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 15:22:32 2020 +0200

    removed locks in lockless functions

commit 73932f0349a958aa15b932f23e56dfa4277a02a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 13:58:51 2020 +0200

    object maanager tweaks

commit fe5b50d8857bb07d7c84d2a89e8cf79d65f6d7a6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 02:22:18 2020 +0200

    improved documentation signigicantly

commit d0b218c18e2cdd65405903626566f5c996064876
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:40:48 2020 +0200

    renaming for host os

commit 3c80bdfefa8149823ed9fb6273cabaac3d02ccc0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:18:19 2020 +0200

    some linebreaks

commit 33cc8591dc2f2ca920dbe86d05e35f8aa40c736c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jun 7 01:17:24 2020 +0200

    yaaay, hardcoded values

commit c81613690be10ae70c6e18f373a303d77b80052c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:41:54 2020 +0200

    no_queue value is 0xffffffff now

commit 65999ac6d6c2d8d1cc1b7b30f38366bf67f96054
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:30:16 2020 +0200

    pool var no param is one now

commit 3d8993b0c599636fb7549ade76ca08cb47f0b4f2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:23:20 2020 +0200

    new typedef names

commit 9ed92e5e6f24721446613138f81939c763ae4783
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:21:51 2020 +0200

    clock typedefs renamed

commit 70212d9f4e979b1092e151cc7cb666b085acddad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:15:42 2020 +0200

    slight formatting

commit 8216b26fdee2f5e7dc552b0d037219149abc7edb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 23:15:05 2020 +0200

    datapoollocal updates

commit ea548dea5bbd969ca17cf9cb48a6b5cfad5e8fda
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 21:16:47 2020 +0200

    map lock init

commit d99be255292e7682bac12dea38258c9cc4eed707
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 20:52:28 2020 +0200

    cookie info iter was uninitialized

    leads to crash

commit 262d34174ea9a7bd46b7ffd12b70e9e1258fe063
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 18:56:54 2020 +0200

    using strncat now

commit b79efa6d6c87cbb9d122b654b706a0279df093a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 16:25:06 2020 +0200

    variable for name len

commit 096fbec156dc27d269154bebd70b61e9d7ed1c70
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:40:10 2020 +0200

    cleaned includesu p a bit

commit dc9ef41bec99951a0012cfa1a6ae17edfbff5bd5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:31:45 2020 +0200

    added doc for linux

commit b0634ab0a2f53fc7e1e194391f7ef4da80077931
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:26:22 2020 +0200

    fixed bug (critical!)

commit ef01b7814064e6847ce8e90ea00e8ea09bb36111
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 15:01:57 2020 +0200

    some issue with stack size ..

commit 212cd58f9a7a8c7b1ed86b5a4b4f46c09f645022
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 14:45:45 2020 +0200

    issues with fixed timeslo ttask on linux

commit 788f7a37459dbd445253c4876da62d0a2298c2d6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:59:00 2020 +0200

    better name for mq

commit 95bc5a871b6a3e823cc6ed1c7564e3540456fda0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:56:35 2020 +0200

    improved diagnostic messages for linux

commit 04236859daecfcde5ed24829623d0a5dbf5da070
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 13:03:37 2020 +0200

    slight improvements to diagnostic ouput

commit 5289497ab5769fc61ba1816322c4f86377cfd36f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 12:59:43 2020 +0200

    health helper optional, diagnostic output improved

commit d35524ecbcbcd49d8f95e37180c787f606fad493
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 12:41:17 2020 +0200

    decoupling from raw reciever, linux mq improvements

commit 8e7593d68a8bf7f909cf87f2daea6625c6ef4010
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 02:10:21 2020 +0200

    removed error handling in separate fnctn

commit b4561465ba273718f03b8f32e73eb4d5ffcb7610
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 01:36:07 2020 +0200

    some little form improvements

commit d600d488167c891407e27b3d3f545d02e319fb2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jun 6 01:31:08 2020 +0200

    added the decoupling of DHB from powerSwitcher

    + some first hk maanger changes, might comment them out

commit 87f64d99cd1b7eae59b601140d13a5b92565f384
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 23:18:00 2020 +0200

    implemented fixed timeslot task

commit d74f2c7560452a9b82ddfa4020335b73d971b8a5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 21:40:06 2020 +0200

    housekeeping folder added to .mk file

commit 579115f904e5287ad0bd8d15038b6d707a72523f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 21:36:50 2020 +0200

    adapting host osal

commit 2b646551e96882aac5c62232b9c88a0271209440
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:40:22 2020 +0200

    mutex helper new output error

commit e9a9a543ce3fbf8a9ff57e337513e050e6004c8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:38:59 2020 +0200

    fw message count one line further

commit 0d4d4123ab28a10376c8ba6c6cc7bd3be5c54e74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:37:46 2020 +0200

    added new message  type (hk)

commit 7247a1af7efde551f6e7d619e66917d9d4717562
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:36:25 2020 +0200

    new class ids

commit 9ec2283d1397b5699796517cc47e3f82e327757a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:35:08 2020 +0200

    hk folder update

commit 319fa9ddb6237c58d9fe8b0e5763b0b463ec82a4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:34:34 2020 +0200

    datapoollocal update

commit e04e6a6f1506ca90498803bbce49e854e5ed5d4b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:33:57 2020 +0200

    datapoolglob update

commit 9fd5ef0194ebad3e2fe1bfc90b705fe7438ac29b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:28:06 2020 +0200

    updated datapool files

commit 8d3ac33b0ef0b22e35dc102f9d715878780d50df
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 20:18:38 2020 +0200

    reordering init list for compiler

commit 872c350a9296999af94ad2c275fd2bf34abec1b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 18:36:22 2020 +0200

    another small bugfix (this-> was missing)

commit ef3e5c4582df70896758e775bed5383b7c415689
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 18:20:21 2020 +0200

    very important bugfix for serial buffer adapter

commit dbeb04895b2d86731be07c4f6af7b1f7f09316fc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 17:55:03 2020 +0200

    added hosted OSAL

commit 4ebd937fe036e5a9427f2bda8683bfca58d5207b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:47:46 2020 +0200

    deleted old printer file

commit abcd818f2f48f6805ca1bfadf9d9694078e6a963
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:44:31 2020 +0200

    printer renamed to arrayprinter

commit 2a632ae711565b8dbcfd149e5b82f44b647681b0
Merge: 405e1149 d7036edb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 16:03:58 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit d7036edb94e7d64626e3cacf3d205c2b9db143a9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 15:53:20 2020 +0200

    hotfix

commit dd210e99af8ece3866bc898ec3daa631d90b8d9d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 13:45:18 2020 +0200

    additional include which was missing

commit 904721cc3638ffac5a1c4758e84395726d2a415b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jun 5 13:44:11 2020 +0200

    improved pool entry iF

commit dd193fd64d302e5592dfddc8a4395101d921b61b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:27:37 2020 +0200

    obj manager.cpp improvements

commit e4944a067c3624a669c4703bfa0d5dce5f1b4119
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:24:44 2020 +0200

    change made was wrong (pointers in map are not deleted!)

commit d423c001156916fe62b3113c539dee9931f359fb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:14:35 2020 +0200

    additional nullptr check

commit 569724843e7196d5c7ca0b324cd575b6aa9aa9ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:11:49 2020 +0200

    object manager improvements

commit 849053b830d92ccd463779569cb6c450033b47c1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:04:24 2020 +0200

    small fix for object manager.cpp

commit 71487d60ca524042c95dffdf1582252f028f35e2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 21:01:09 2020 +0200

    onj managerIF update

commit 3eca16ff785b928f7015444d987a5dbed0ce99dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 20:59:52 2020 +0200

    removed exit clause

commit 405e1149e56e2a802587b98ff4451ea16268d5c9
Merge: f0be1b1f 4d59ddc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 20:41:30 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 4d59ddc3db6d9382e61bc4492e51c63283174489
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 19:50:26 2020 +0200

    some fixes, check for preamble size

commit 6ff1cf46c5cda5e6c9ecb85926acc68c8825b1ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 19:40:43 2020 +0200

    new service interface stream

commit f2a9d2969617f8f3ca9ae8b5fce1e156e8dfb36a
Merge: a115bf11 d75e4716
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 14:45:06 2020 +0200

    Merge remote-tracking branch 'upstream/master' into mueller_framework

commit a115bf1186d075ea8c6b98c03ba847f22d41251b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 14:43:33 2020 +0200

    store access improvements

commit 925a54dec965b0c52d312616f9f42902fd5fac2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jun 4 01:06:03 2020 +0200

    more improvements for servicei nterface

commit 17ed9b77967f6a8ba2deb281a730df3b33fdadb3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:38:02 2020 +0200

    OS renamed to OS_FSFW (nameclash with system variable)

commit 5eb3d77bdbb1f4537c95d5c6919a0792b8f274e6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:29:00 2020 +0200

    clarfiying comment

commit 0a512abc3364855116a4756e42aeac33c0aa2fe2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:26:27 2020 +0200

    additional clarification comment

commit 5b93799ea659b0b93bd769657c0d00c390786e26
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:10:04 2020 +0200

    added forward declarations for service interface streams

commit 1c0ca4c329c99caa75f438745b53a53f2978cd30
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 23:02:23 2020 +0200

    some changes to take care of activity

commit 3483dff2abf171f85f61e498c6ce3c10131783ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jun 3 22:56:03 2020 +0200

    some more interface improvements

commit 5036cdbef3f23cc878c2ce09f66fc648fd34bbe5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 23:54:24 2020 +0200

    queue factory first param uint32_t again

commit 6972e72fbf2a1a5f9dd1adae9c8274ecb1119581
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 23:52:31 2020 +0200

    fixed order

commit f0be1b1fff0c43e0562c577bcc5166e54f5212d6
Merge: c34c6238 54edeacb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:27:57 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 54edeacb2d20dcd5a01c0a11e3337b18fb3cf364
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:25:28 2020 +0200

    changed names for linux

commit 986dc2047e7ef0f52ebe8bd54fdf7f0fd565a518
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:19:48 2020 +0200

    replaced mutexIF and semaphoreIF name for timeouts

commit f0a25b5e2b0e26e549145ff429fc707a5f7c6bb3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 22:10:34 2020 +0200

    new timeout values for MUtexIF and SemaphIF

commit de6ed5c0859e528b798fdb214cf62b7a3143762e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jun 2 15:57:04 2020 +0200

    improved include guard and removed old comment

commit 42f0687a6bcf0f1c947ef00dfeea95fa3e060af8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 31 23:28:51 2020 +0200

    self deletion nullptr

commit c8a36a79de45c228e7071cc827423e0b4a383998
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 31 00:23:38 2020 +0200

    corrected doc for task factory interface

commit c34c6238c63b70df5167c0c0856dabbdb65a0890
Merge: 66b75802 7a22d12d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:56:06 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 7a22d12d0f1328ff55e3e2826e58000e191ef643
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:48:24 2020 +0200

    removed extern "C", not needed

commit 914bf8b9fc1afff3cf98675b4a98707099cb4021
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:45:53 2020 +0200

    seconds_t is double now

commit 4d4ca2f3bd87efaca572378e107f92dda2c57eb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 17:43:37 2020 +0200

    doc fix for stopwatch

commit f13eff79c90a174011c6d3b6c617ce25b575cc76
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:51:09 2020 +0200

    another little include guard fix

commit 6b0558d6c71a5b23b2f678d5b18e170cde60e706
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:49:11 2020 +0200

    added author tag back

commit 3ef939aca8cff90c0ad51418e859eb69a76a655f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:46:26 2020 +0200

    fixed inclue protection

commit 5cf9e938cccf450c5a4ad5b7fb74f7cc4b3705ff
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:45:03 2020 +0200

    added include protection

commit b90492562ac44f576ab7c7519826ae272d5be68e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 16:40:57 2020 +0200

    added author tag back at class definition

commit f14bacba32e97c7d74e55405d59b9230ec4e362c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 14:15:45 2020 +0200

    using nullptr now

    added new distinction between blocking (MAX_TIMEOUT) and polling
    (NO_TIMEOUT)

commit 6a3dc94108304d9cf0cdde1cc82ecc6dc62390d8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:18:27 2020 +0200

    removed extern "C" for freertos includes

commit d5352a9b87a604cd8535963d2a7fcc8176b2182b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:15:37 2020 +0200

    actually extern "C" is not needed

    it is included by freeRTOS

commit e7ae35c6592fb101ebe2fd44517a8cfc62b1096d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:09:47 2020 +0200

    improved structure a bit

commit 5169c09fd8d56eb041011da9062bb325578a313e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:07:35 2020 +0200

    improved includes

commit 78ae109a08ec58c17b1b966944992da0b74da011
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 13:02:13 2020 +0200

    removed context switch request

    (shall be done at end of ISR, so must be performed by caller)

commit da403c01d0178d814896d4c26561e092c1ac2a6e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 03:03:48 2020 +0200

    retval fix, unittest running again

commit 3d2935ac6917b6d8f20c68011cd77cf9d5890686
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 02:23:14 2020 +0200

    linux time lib improvements

    stop watch other function used (more precise for linux)

commit ccf79ab5b63d5870dfd8aabde90895746f9cdc08
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 01:55:20 2020 +0200

    output correction for linux

commit 671f298935a640e33274e1a5fd52339e790068b6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 01:41:16 2020 +0200

    implemented counting semaph for linux

commit 56498e5bc12076330e8f1b74ce7955b16005d0aa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 00:50:44 2020 +0200

    linux bin semaph unlocked

commit 8676fcd9a929b619b65c1598434c75261fdb74b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 29 00:47:54 2020 +0200

    yay, linux bin semaph finished

commit 60872f936ce2c2566b388e1e40bdb24194178453
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:43:40 2020 +0200

    some output improvements

commit 08ffe89682e72c70876d3dbfd0555161e16608e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:41:59 2020 +0200

    doc and api improvements

commit 7ce505fdf9234630298dc6560b625cc44f41770a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 23:29:06 2020 +0200

    some safety updates and fixes

commit 63dbf995925f181f406173ba380d36b8faadb393
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 22:12:52 2020 +0200

    counting semaph implementation finished

commit 95bf5c1071a84696cc0e15abf9a01102764caaca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:33:34 2020 +0200

    improved const correctness

commit c4e60946d3282c497714cb9345918069afb11047
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:30:20 2020 +0200

    improved bin semaph implementation

commit 88e3dc15b2604de0c337f2bf4911ee5e4780588f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 21:27:31 2020 +0200

    replaced old semaph api

commit 7145982b4ade5f3da12e8dd05161b11e45512998
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:59:59 2020 +0200

    improved documentation

commit eabee85ba9f1dd014abc66d13e212427dc328242
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:56:02 2020 +0200

    tweaked factory to have configurability

commit b4065c776437b39613542d9beff87ba06e6242ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:46:56 2020 +0200

    seperation of semaph implementations finished

commit 8a1e0dab0370c5b454fcb9e95de0f1349000b380
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 19:03:46 2020 +0200

    continued with task notifications

commit 2d33274c2306fd51b4ea512d5d399502755f20fa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 17:42:18 2020 +0200

    implementing new task notifications

commit 968d7fad815877213c154845bc058140e47ee91b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 17:07:35 2020 +0200

    replaced some timeout values

commit 66b75802b24f1498f8baf189d2475ae6c3e7797c
Merge: 9b5095e5 5b521e03
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:58:17 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 5b521e039b9cb3973561cc3483ed15794c1d41a3
Merge: badcacad 18d19fbb
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:40:01 2020 +0200

    Merge branch 'mueller_fw_loc_globpool_distinction' into mueller_framework

commit 9b5095e5b8009a0b4fa11a6824f8b536ad018f2c
Merge: a926312b badcacad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 12:28:43 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit badcacad49e3790df3cda101dc9da973287238de
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 11:48:11 2020 +0200

    added new timeout values

commit f6ae0348cb50dddefa867dc3a0344dac99efef2e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 11:41:36 2020 +0200

    some linux mutex tweaks

commit be4ac0bc8fa03faee1330a9899cb9051485eebba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 27 00:28:13 2020 +0200

    added semaph factory to linux

commit f7dd91891a644c660ff8ae7d6c183e84faf75d9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 16:05:03 2020 +0200

    removed comments

commit 1a623a6a527599efc6ee8d4e28e85c405c58cb9a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 11:05:49 2020 +0200

    added override

commit a19fa231f51c6b83c0417afe08e208e2bc8c2563
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 01:21:48 2020 +0200

    comment improvements

commit 9f2d5b64e009349a03be6990f43b8a3fddc5a02b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 01:03:26 2020 +0200

    comment improvements

commit a926312b2506c2c3b324d2856767d1252d76ab16
Merge: 8ddccfe3 242ca355
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 00:08:00 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 242ca355f51008eb9ada619295cf397dbc49ae35
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 26 00:01:07 2020 +0200

    removed swappers for arraylist for now

commit 8ddccfe3bd017d69b576945f06814f9fd1fd4723
Merge: 219d85d7 3fd30635
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:54:39 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 3fd306356a4b2eefeb78bf6f4cf6d197b7c5c7ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:43:44 2020 +0200

    fix for dh returnvalues

commit 243ea9cd8782a4edd74259351b8fb536fdf95bca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:38:51 2020 +0200

    improved dhb IF returnvalues

commit eacda67f027dc24a65f60f08b837b2358aa094f5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:36:03 2020 +0200

    added some comments for returnvalues

commit 18d19fbb2c7575cf7b880e0caebf5cbcbc447358
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:12:25 2020 +0200

    < removed

commit a37f01cd0ee31c57f8f76f3b299c2f51718e9d85
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 23:11:56 2020 +0200

    improved readability of mode explanations

commit 96462ba8dc4cc7c6389428dca2e35f1e584fe260
Merge: f6ec65d3 7a0cbfb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 22:29:33 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 7a0cbfb2f5cb9b17fe05a1db1978837796dea0ad
Merge: d6af9da5 cb14ec15
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 22:21:13 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_framework

commit 219d85d700d3791efb3158544f281b2a97b4e1f5
Merge: 723e7150 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 15:59:17 2020 +0200

    Merge remote-tracking branch 'upstram/master' into front_branch

commit d6af9da5661f7ccc4e423ff0422a687a5cfbfc8e
Merge: 723e7150 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 15:58:57 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_framework

commit f6ec65d35dac92c7de50eb848fc0a7d3ac11a02e
Merge: 8eb13ec6 5e91363d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:49:22 2020 +0200

    Merge remote-tracking branch 'upstram/master' into mueller_fw_loc_globpool_distinction

commit 8eb13ec6279624aaecd5e3b9e95744461a7b79b6
Merge: 2f16b1e7 723e7150
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:02:43 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 723e715022e6d5ada2dfdee9da5a6f3d7450faa9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 14:01:35 2020 +0200

    consistency fix

commit 2f16b1e7336a1b174bfc0da4ae5437c925c6ac21
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 25 13:48:43 2020 +0200

    moved some files

commit d4abfacd27b09c17f898e80c62f969610a5d6367
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 22 01:15:02 2020 +0200

    found solution for circ dependency

    had to put store_address_t in own file though

commit d2d1ef9a854727a0381ccab719d2a8cba8a4acf0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 22 00:58:30 2020 +0200

    better include guards

commit aea18c423e030a65309495152332f32592bcd06a
Merge: 7c48274c f6b17d6e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 21 17:01:29 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit f6b17d6e2ea6156d06214937c70bee305707a836
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 20 12:50:56 2020 +0200

    deleted copyctor and copy assignment

commit 338651af2f7a67422cda787b56b513f020325df4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 23:07:28 2020 +0200

    binary printer added

commit 9b53e2b64fe9327f55eb12b393a91c666b836dde
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 22:45:48 2020 +0200

    added informative comment for counting semaphore

commit 7afaa752f37422254f962982a41038afb0fbe8da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 20:25:54 2020 +0200

    form improvement

commit 1aef000eff336b97917ac4c178d95749ec9cd5dc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 20:24:58 2020 +0200

    printer improvements and fixes

    tc packet stored getter function

commit e2418d61a6263f67f2db96ac265f0e271766a28c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 19:53:10 2020 +0200

    improved printer

commit f612b095c1c508466098576866827dc065dc9809
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 19:39:19 2020 +0200

    updated tmtc packet base

commit 2790a40d6c35d27bb8e86121e02c6ca9f0ddf4ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 19 18:55:13 2020 +0200

    some renamings

commit 3c7e2c7cfff53bffd4e84de778dcf5d71fc13939
Merge: b12bace3 066930b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:46:50 2020 +0200

    Merge branch 'mueller_BinSempahInterface' into mueller_framework

commit 066930b110730c8c781f0b680e1f7b99f1dbe920
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:39:48 2020 +0200

    improvements

commit 7227c3a8667a1ead8c4160b8372d350e79617de4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 20:35:13 2020 +0200

    implemented semaph factory

commit 067cd9573100952c1398b956a8b7d2cbeab93a3a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:42:45 2020 +0200

    removed file header

commit b1d9d55f50a0e242ec57604934659c7fff50eb01
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:42:05 2020 +0200

    improved documentation

commit 4dd6594845deb381b80fcb2ba8e0ec27acec27e1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:38:02 2020 +0200

    integrated interface into bin semaphore

commit 9ba21b1e288ba9f8e20fae9c4cc7ea6923b2651f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:30:50 2020 +0200

    semaphore if continued

commit 87bf843beffe92f7f535609cb83fcb4378f952be
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 19:19:50 2020 +0200

    binary semaphore IF init

commit 45b0193ef38b70a4f1d5be76564258bc6ab5c928
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 18:06:40 2020 +0200

    bin semaph todo

commit b23728731548d900b97a70e3d32565ebcfcc50e7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:48:16 2020 +0200

    bin semaph sif replacements

commit ec8538b442eef934a6cc1dfb8033c069cbed06a6
Merge: 41c0ca6c fc4199c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:46:04 2020 +0200

    Merge branch 'mueller_binSemaph' into mueller_FreeRTOS_improvements

commit 41c0ca6c52a728ffaf359805efb0df0319b9dcc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:39:10 2020 +0200

    added doc for switchSystemContext

commit f8614e23a867d21d64922329164920c41ab55c38
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:38:19 2020 +0200

    deleted copy ans assignment ctor

commit d1500a78685d18e05b94419be69f9cb09056c127
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:31:05 2020 +0200

    mq doc improvements

commit 1d4d01d1906d1300eb7fe4e65d259afe64210a81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 17:22:10 2020 +0200

    Added ISR calls for MQ and task mgmt

    The task management defines an external function which
    implements a context switch call from an ISR

commit b12bace3857588cfca51e0b0c8df37fec0d6c31a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 16:40:11 2020 +0200

    changed order of input arguments (relevance)

    default argument for ACK

commit 7e04c055b353b1cfe6817a2cc2e0fbbca4db631e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 16:13:46 2020 +0200

    tc packet stored formatting

commit 355bc2b9057da4f79ead6aa0e7882b9220edffd7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 18 15:42:47 2020 +0200

    improvements

commit 767850e12546ddb7b17d344ee32a1c5bb389a593
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:58:57 2020 +0200

    deleted poolvector

commit d1b315c7df5882427c41c77bf732f606c73ab50b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:54:56 2020 +0200

    pool raw access adaptions

commit 1d28e1398ea927a74a0fc492e4db468122d41afa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 23:41:28 2020 +0200

    DataSetBase class finished

commit 71f1722b886d002a0b8fe550771ee1ed4cde1cc3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 22:20:54 2020 +0200

    removed old poolVar file

commit 9da0b0b2b299b7abeb9b73dd8fdb624942de996c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 22:16:25 2020 +0200

    glob pool vec implementation in tpp file

commit 8b1fef730dcb4cd4f21c3f90121b1c6a74758f63
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 18:02:58 2020 +0200

    resolved conflict

commit 234fd8e300d37bd5293508542ec0b6e5b16c259b
Merge: e9a4056d 0467b6a1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 18:00:51 2020 +0200

    Merge branch 'mueller_framework' into mueller_fw_loc_globpool_distinction

commit 0467b6a1bf60481b74850096c60fc09304bb7ee6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 17:53:18 2020 +0200

    slight DHB improvements

commit 7c48274c9b5a2ae904accae6cd5f01e9e85a8164
Merge: ebcc4742 9597a012
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 17:27:04 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 9597a0121ba7177b7b18beca9319c37be0f230d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:49:46 2020 +0200

    DHB update

commit da972e1b5823cde5cfdf4611e42736d6e8bf7b11
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:41:42 2020 +0200

    DHB improvements

commit e9a4056deb17756f70973d6f383182fbabdf90b2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 15:19:24 2020 +0200

    added DHB cookie init

    (why was that never a problem beofre????) ¯\_(ツ)_/¯

commit 9056ad36ed69575e499376558839d0bc044ca4d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 14:13:31 2020 +0200

    object manager better output

commit 5b8a6e35dcc3e36715e2eaa39345744e3b2ebaef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 13:37:50 2020 +0200

    renaming complete, pool in namespace

commit cbfa21d45a51bbe97d6d35a6b54ab8f409a8f2d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 17 01:17:11 2020 +0200

    merging renaming into main branch

commit b673e13892cf7aac425569709a140dc4b589ec70
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 16 20:58:48 2020 +0200

    some refactoring

commit 7d579889792144e9cf45fdcc332bb3636c69f488
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 16 13:09:50 2020 +0200

    added deadline check

commit 20900227f8bc119befa7dcc2bd5ca3fea3d74e1b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 22:53:01 2020 +0200

    periodic posix task ctor format

commit ebcc4742a92c6aa2152aa7cc8953a587f05fec5b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 21:14:21 2020 +0200

    removed conflict markers

commit abdf04ce79b58a34c8576f18b466327c398694d2
Merge: d44a06fa 0e243841
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 21:10:56 2020 +0200

    Merge branch 'mueller_framework' into front_branch

commit 0e2438416d0af245d086175868a5496c679b94ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 20:00:43 2020 +0200

    added comment

commit 5b41f2a6bd4e91956874fff43774865d9887dab5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:58:58 2020 +0200

    optimization

commit c77ec9e7fcbe038a4622b3faf3cf311d6d3cc901
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:56:54 2020 +0200

    uint16_t correction

commit 3f71babfa995965ef39299f5285ad5990efe6921
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 19:50:51 2020 +0200

    app data len uint16_t, full length size_t

commit 24bfbfbd33e93d35dabd716d72d67eefc9512b11
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:56:06 2020 +0200

    removed StorageAccessoremoved StorageAccessorr

commit 80cee2742964485910faa168cb9a1c96e2c0dec3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:53:54 2020 +0200

    printer fixes

commit d48fe8fb0997c996d6f30ab1b017b7e5f1da9529
Merge: 6e1bb16d 1b093d96
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:51:58 2020 +0200

    Merge branch 'mueller_globalPrinter' into mueller_framework

commit 6e1bb16d4e22f5e4b0b3d9010a5662ffe7f1b16e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:46:58 2020 +0200

    printers continued,

    possible  bugfix in tc packet base

commit 237dd4a256598ed805442a71bef58a4ddc9aabb4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:23:57 2020 +0200

    added additonal functions for tc packet base

commit 5ac32b14f070c926429969a459106559e8cdf08d
Merge: 684da2b8 effac0e9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 18:23:45 2020 +0200

    Merge branch 'mueller_globalPrinter' into mueller_framework

commit 684da2b8d5400ad68a59a59579bbb9244a1be5c3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 15 15:30:29 2020 +0200

    set application data function added

commit 69237bc2e87fba9d5b3c8dfc91d11e328e2bdfc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 14 21:26:04 2020 +0200

    freertos includes adapted

commit 49fa2fe32c6bfc4fba6fc91e8cbf564eb7532658
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 14 16:12:01 2020 +0200

    changed void* cast to QueueHandle_t cast

commit 50a1b5170aa472c143c8a1a349e04316fb399225
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 13 18:03:09 2020 +0200

    formatting

commit 19e51575cf67c8c1eee1ec402e55cc4dfec74611
Merge: 3122f62b 0e56a094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 13 12:53:25 2020 +0200

    Merge remote-tracking branch 'origin/meier_framework' into mueller_framework

commit 3122f62b0a1e81268ad5f7ac8fa249a5458dc906
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 19:02:59 2020 +0200

    bugfixes for write() call

commit 291710f257745e60e8417b2fa3648dcbfa09ed5d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 17:57:37 2020 +0200

    new ctor and bugfixes

commit d873fcbf8ece518e1da89500ef8195da4384c1a3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 16:47:47 2020 +0200

    added documentation for storage manager IF

commit 6c70abfe1621a83074f21476d680bc808a52576f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 16:32:01 2020 +0200

    moved pool accessor fuctions to local pool

commit 5af0c15dfc6906eb16675e53416c0fe2f95b34b0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 14:12:39 2020 +0200

    simplified storage accessor

commit 1946af64af5afb479bda4604b33d712eef99e43a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 12 14:11:00 2020 +0200

    storage accessor mutex lock removed

commit e5c46c5ec1be4ed2c6e890b26a33361b9c3cdbdf
Merge: 43d3ca7e 77565c74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 11 19:25:45 2020 +0200

    Merge branch 'mueller_FixedSequenceImprovements' into mueller_framework

commit 43d3ca7e379cf1dd20cd0372cf4883eb468d030a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 21:56:21 2020 +0200

    memory message: no retval

    CSB: retval

commit d44a06fafc1a63ec38354438910b556e0f1c6b81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 12:48:22 2020 +0200

    removed cfg include

commit 2f58c3a3052506e922ba1758e9a7fa4f1c642c9f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 10 00:14:00 2020 +0200

    commented out storage accessor

commit 0f286461d065f25ddda7b63f4f3ae45d2e6b5db3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat May 9 18:10:26 2020 +0200

    added new storage raw accessor

commit d35a6e6c147e381dce6029db1fd857625fff9ec9
Merge: c05b9cbd 6dc05e49
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 8 18:41:07 2020 +0200

    Merge remote-tracking branch 'upstream/master' into front_branch

commit 9489b7abc1bee2a2b164e81f178222706a8c2b8e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 7 19:23:56 2020 +0200

    modifyData override deleted

    is not really thread-safe anyway

commit fe9aa46cf8d33ccb93b570fe77631abb08555829
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu May 7 12:22:17 2020 +0200

    removed system object list include.

    makes it difficult for multiple configurations, because the wrong header
    might be included

commit b016f2995a00a3a5183794bb576820d17b6f078b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 16:34:43 2020 +0200

    added default vlaue for init function

commit e950051b4ab7edcc6919af226f3c7a1eae63602e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 14:35:30 2020 +0200

    some object managerIF security measures

    objectmanager get function checks whether global object manager was
    initialized now.
    New returnvalues, which are also used for local pool init

commit 6b205e166ba6eab2addc3289bde1734e9ff3830f
Merge: cc0469fe 77c21fc2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed May 6 13:54:18 2020 +0200

    Merge branch 'master' into mueller_framework

commit cc0469fef6031ebde23583f958fcf1c0b1e5ef3e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 20:09:42 2020 +0200

    return failed insteead of exiting

commit f09836a9eb4aeb561ae1e6fa13e20c0aa0fc01cf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 19:30:03 2020 +0200

    removed exit for empty psremoved exit for empty pstt

commit 4695e87cdca7d9a87e9021d715dced763e079ae8
Merge: 160a0979 df9e6683
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 19:08:46 2020 +0200

    Merge branch 'mueller_fifo_enhancement' into mueller_framework

commit 160a09790e112fdd6cc40cbb75b502c9ca057fd8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:53:25 2020 +0200

    removed c omment for now

commit bc17b5a907ca3fe2ead9829a1a582bedc84389b1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:43:28 2020 +0200

    resolved conflict

commit ad31a1b97db9cb78a9e6ddd8c8c95537fa4005a4
Merge: 399e6b3a f1a0bb9d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 18:41:40 2020 +0200

    Merge branch 'luz_FixedTimeslotTask_ExistenceCheck' into mueller_framework

commit 399e6b3a09126fc8f63072428acf99de73e36658
Merge: 6817aa4d c05b9cbd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 15:07:47 2020 +0200

    Merge branch 'front_branch' into mueller_framework

commit c05b9cbd01b490046f6d7881bf4ff62f7e2a63c2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 14:07:27 2020 +0200

    reverted ResultIF. for now, keep using HasReturnvaluesIF

commit 1825924b7bf46d65fc163ac89921d9d70ddbe33b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue May 5 10:16:16 2020 +0200

    abbreviation for resultIF

commit 6817aa4d03f542939742ef9ccdadd578faaf428a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 16:57:08 2020 +0200

    pool manager refactoring

commit b947253ac3107e05ccb85760bb0413d28c46b5c5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 16:49:15 2020 +0200

    local pool neat

commit 4b65d6e84739ea13e82441768917c530154d656f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon May 4 12:33:57 2020 +0200

    local pool bugfix

commit 3e4263f068aa476a608102acccad93f47b0a6d99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 3 12:27:18 2020 +0200

    freeRTOS task factory fix

commit 35594d4b717e5296581f0227e6d952aebf506cf4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun May 3 00:48:18 2020 +0200

    goofed up, delay function back in task factory

commit 281da25bf97f344fd7b7727530208879c9c7a153
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 1 16:47:53 2020 +0200

    extended task management for freeRTOS

commit 15c03863c008fb6d8b455bed15985ed725df3bc9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri May 1 14:49:52 2020 +0200

    additional docmentation for freeRTOS task factory

commit 03333c2af0cc698646f617812fc183a2627ce974
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 30 21:37:02 2020 +0200

    pool raw acces printout

commit 431709a3ecefb0a358726e7f94e2f45131a7d914
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 30 15:42:33 2020 +0200

    pool raw acces helper bugfix

commit e1aa285b6db9733c3b302a0c3c1c0231a2a5e561
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 29 13:46:30 2020 +0200

    linux osal output in namespace

commit 7ec6d2ceaa74f3823db8fe49cef0ff811cbabdd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 28 18:58:55 2020 +0200

    remove dspecial character messing with decoding

commit ecf3b4b535f7becb1adbd8f0ca1619545b04f4ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 22:05:12 2020 +0200

    stopwatch warning fix

commit a5d2cbd7db6d6f47e7a3f75cc429ac36070f806e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 21:59:24 2020 +0200

    some more sif replacements

commit 0ea692a5ea8e5230ccb14ae42156ac74f05ac851
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 20:04:48 2020 +0200

    some more sif changes

commit 01195093e3309c6bc9722c3b98c4886883e6d384
Merge: 1415cd23 2c6b4465
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 19:21:12 2020 +0200

    Merge branch 'mueller_sifRenaming_soooMany' into mueller_framework

commit fc4199c3b12dfc6f7996d75c035fb0767c21a004
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 18:13:14 2020 +0200

    architecture dependant call delcared external

commit 328737d0ad5d6efb098963fdf0e5088776f50f64
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 18:12:02 2020 +0200

    newer non-deprecated semaphore call used

commit 1415cd2339931cec2dda229782af069459a02f3d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 17:54:41 2020 +0200

    using newer bin semaph create call.

    architecture dependant function call is external now and shall
    be implemented by developer

commit 44d467808939a803f837d188b006cedd332f3d0a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 14:06:48 2020 +0200

    fifo features and stopwatch enhancement

commit ee2ee745c7329445a408137dd95b7e243a4b5adf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 12:47:59 2020 +0200

    fifo renamed

commit d546317e6aa5070873062a12c04b98cf5504a019
Merge: 40d952a3 3a3960ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:33:19 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 40d952a3491f549989f5bfb15da6000b8f77b3d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:24:34 2020 +0200

    minor form changes

commit e40c9f42c676ef5fabe55e1392f88e3a8ba11884
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:22:25 2020 +0200

    info output commented out

commit c075e1bf2334e6984da63997589c3652d5d39b74
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:20:19 2020 +0200

    adapting tmtc bridge

commit db535e25f2e3d978c4eab4a83d4f8751816a9b91
Merge: 2c2ccf8a d0ce075e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 23 10:03:15 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 2c2ccf8a8d0b4828b7d63dd34d4dbf0449fc38d9
Merge: 9f7f8073 50265170
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 23:49:10 2020 +0200

    Merge branch 'mueller_TmTcBridge_cherryPicked' into mueller_framework

commit 0e6f8d3f821d3fa6907de2310e9102a33d30afb2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:53:06 2020 +0200

    comment adapted

commit 1b5127dc85f236d7e02cdb22c722bea4976d531b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:50:07 2020 +0200

    added task management implementation

commit 6eda5a08381891907d67e3b23a93e80808585b07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:46:49 2020 +0200

    task management header added

commit e26f0d54b2828e786c4d91ef38345a7e68d1fbcf
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:44:03 2020 +0200

    binary semaphore init

commit 9f7f8073f17df0081406804bf2fc84034420da54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 19:42:42 2020 +0200

    freertos includes in extern "C"

commit fb9a5678fc463aba32a4bbcf01a8cf8994638a30
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 10:24:00 2020 +0200

    removed comment belonging in egit

commit 4e76b8133e905446c90b3447abfaad3744da5d87
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 01:08:36 2020 +0200

    uninitialized variable

commit 326e5cf5febda0dd3ad55cd6c5b181969ebdf9ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 22 01:01:32 2020 +0200

    initialized uninitialized variables

commit 6553450b4b85ea7ec53e88850195af35d76d85b2
Author: Uli <uli@vnks.de>
Date:   Tue Apr 21 22:28:43 2020 +0200

    Actually, not that horrible, thanks to sed

commit a42832ca01d9b5554b3e6b7c274bf16ce5d13f58
Author: Uli <uli@vnks.de>
Date:   Tue Apr 21 21:34:03 2020 +0200

    working on updating SerializeIF, to quote Basti: This is going to be horrible

commit 7e3af7cf839ee07cca12093812f323b7b396be04
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 19 21:36:10 2020 +0200

    replaced slotLengthMs with lengthMs

commit 36715e3f4cf98cb21049eaf2001129fe3acbe625
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 19 12:06:28 2020 +0200

    test folder moved to separate test folder

    for fsfw for now

commit e77ca55b1d383afd0079152a4d6809d3e79a6a93
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 17:12:26 2020 +0200

    serial fixed array list adapter doc fix

commit a7d3b4c4a03a0ec2afee9ab0ec5021750fc80dca
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 15:05:51 2020 +0200

    added std:: before uint32_t typedef

commit 9580f51c30590617084b2ef21b8c4fa4a23e0d92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 14:16:46 2020 +0200

    removed self-inclusion

commit e34a438e774aee4dfe39ab881519e01e8735cb52
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:38:05 2020 +0200

    using size_t

commit 4d8aca8417f722ab6fcf15f3defd73652cc0a18a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:32:40 2020 +0200

    message queue adaptation for ISRs

commit a405357578cb683f91bad536b9e0b100670a2c1b
Merge: ea1d55b0 05c1330b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:30:22 2020 +0200

    Merge remote-tracking branch 'upstream/master'
    into mueller_framework

commit ea1d55b0336dd860c7c5ab7a2a6b62d408d3244c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Apr 18 13:16:00 2020 +0200

    null replaced by nullptr.

    storeID initialization added, all nullptr/0 initializations in header

commit 5595b0f3ce76e9d4c169e09b11960c46b7d2531f
Merge: eb362dca f45a8cc1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 17:02:10 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit eb362dcad2adb126156d19c558794892526a8791
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 17:02:04 2020 +0200

    some comment line break

commit f45a8cc17193fb3176a8410bd8b00e4ca351bad9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 13:17:26 2020 +0200

    fixed slot sequence safety check added

commit 21650b064dbd901aaaae72345ad326aada79137b
Merge: 5582ca27 33b834ad
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 13:01:17 2020 +0200

    Merge branch 'mueller_framework'

commit 33b834ad910ca269c4131d8b796c2deba94a2eed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 10:43:50 2020 +0200

    null replaced by nullptr

commit 7c360be1e0fe9eeb6d28f8ac6bd473c6d66ae43b
Merge: bd0b9cb8 9284fe81
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 09:30:26 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit bd0b9cb877ec6138d6d83727480748d4a676975e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 16 09:30:02 2020 +0200

    catch example informative comment

commit fc08754b98698708dfd36b0f2d1f121e1755922f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 23:28:45 2020 +0200

    some doc unclarities comment added

commit 9284fe81da14628f26001536e22a66c1873517f3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 20:53:03 2020 +0200

    added override specifiers, some doc fixes

commit 906f941f32bc949edf899e5e8b9ededf45797793
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 15 15:53:46 2020 +0200

    ssize_t in deSerialize replaced by size_t

commit af27a2441affb1923a4a2ff33c044ce825549094
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 16:19:13 2020 +0200

    added catch framework for basic testing

commit c5e5de1530acb3f3212514c254dea65635ece647
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 12:24:26 2020 +0200

    deleted example values

commit 2cc4386b4c98f92f83c79c0fdfd07dba091d3544
Merge: b48a0a4a 03b0ae7b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 11:18:24 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 03b0ae7b68541f8d6268c0dcc8b763e04870d185
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 14 11:16:51 2020 +0200

    unit test fixes

commit b48a0a4a4ce5ea9b4e85b76223e357fe49ce6907
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 22:45:23 2020 +0200

    unit test class continued. serialize adapter

    functions which are internal, extracted to separate class

commit fe45c7eb8b7f66d01d1ca4f3e06dd91b79987f9f
Merge: 0d016e5a a0ee0109
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:38:29 2020 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 0d016e5a2b2e5b566c7c7f2a11e64c1c93dcc4d3
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:37:25 2020 +0200

    slight formatting

commit a0ee010926eb3870c61c8eaa8cd39f9601b1fa86
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 13 16:27:05 2020 +0200

    Added test folder.

commit eb2df3d88cc3bc2c70bda89208bf4e392bbef860
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 12 23:06:57 2020 +0200

    Using C++ to implement preamble. adding optional flag for carriage return

commit 69e9710bf17013f974188ee420279107b472e822
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Apr 10 17:06:06 2020 +0200

    added intial carriage return im preamble

commit 841b28b65d3c46a175d283d01e92729495f218d9
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 9 18:02:10 2020 +0200

    stopwatch ms now working

commit 8a8761ea88e361ff610dd18ba22e59f3f5a9140b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Apr 9 17:56:48 2020 +0200

    stopwatch bugfix

commit 5582ca278b7b050550af3948b6b37331e3575841
Merge: 94137896 640cc1dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:44:21 2020 +0200

    Merge branch 'mueller_framework'

commit 94137896cc171cd5b9e1c461c53dca464c885885
Merge: 35eff6df 2a72e94d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:44:10 2020 +0200

    Merge branch 'mueller_stopwatch'

commit 35eff6dfbaf15f722975ca339f88716f988b8b2f
Merge: 826e2bdb c88c6c2a
Author: Robin Müller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:35:26 2020 +0200

    Merge branch 'ksat_master' of KSat/fsfw into master

commit 640cc1ddec6fa6e53c8dca212b06b61604e5a6da
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:30:39 2020 +0200

    some more bugfixes

commit 5b0f80509f7f8dec258d333c26766dfdf8336ccc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:24:24 2020 +0200

    usec replaced by seconds

commit da9bb97b23f2519137674a8b352e7b93592f4ef4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 19:05:21 2020 +0200

    added precision for double output

commit 3dbf35338561897c356a1f949ed2a74ec7e9f311
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:33:38 2020 +0200

    some more refactoring for stopwatch

commit 3af241b9c48f1c0f5685435f198d27e4333caa99
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:27:18 2020 +0200

    stopwatch more lightweight now

commit e0e1e64a092b9a06570149c2c694102230af182c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 8 18:08:14 2020 +0200

    various changes, stopwatch

    Semaphore: Some bugfixes, some constructors added
    Stopwatch: First implementation, can measure in ms(double) and
    ms(normal)

commit 30ed08005fd07cd894a49dee5123e028d1fbeed6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Apr 7 22:16:43 2020 +0200

    reverted some naming changes

commit c88c6c2a45482d19f51ec0548ffe50e5b1203a82
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 19:51:45 2020 +0200

    binary semaphore info printout added

commit aaabbe8aef2a759d1928b22c6b3acfca2fd9980d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 13:59:57 2020 +0200

    DHB fix

commit 78aad91aab99ff6123d8575300613dd14a79b81e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 12:38:39 2020 +0200

    PSB subservice passed to handleRequest

commit 3654c7bf8162cd176509db6d83241f077bdfb929
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Apr 6 11:15:44 2020 +0200

    some form stuff

commit e791f44c41525bc742c9027bbeb08a530cd5a424
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 23:03:32 2020 +0200

    copy ctor and assgnment op forbidden

    for serial linked lists

commit 42838272a522b76c9e055f93bdf7af6d00b84b01
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 22:42:48 2020 +0200

    replaced int32_t size by ssize_t (type trait trick)

commit 87852e5f2a3983e21c99a18f8503a511a158cecd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 21:54:11 2020 +0200

    replaced getSerializedSize returnvalue with size_t

commit 7079c9c56dc03bc1eb89311b831ff9f622257f81
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 17:58:39 2020 +0200

    replaced serializeIF serialize sizes with size_t

commit 06ae64d59c7de1bfaa63c63249cc56c53c47d829
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:46:10 2020 +0200

    CSB: replaced some uint32 with size_t

commit a65a19f583b4f71b4c13e3d553fc6e990fd49ba9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:33:24 2020 +0200

    deletd serial buffer adapter2

commit 4a35035b2890f3491d096afb22ad3421bc4d1e60
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 15:30:31 2020 +0200

    serial buffer adapted improvements

commit 80b1d28bc84ed4d9e86791b6e1c3e74abae3a4d4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Apr 5 00:23:29 2020 +0200

    new dvice com IF return value

commit bd468a1b7498d217ca681e25c1932a39639f155f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:19:03 2020 +0200

    timeslot time 0 definitely leads to error

commit 335df7787ab118078b1a22a26cdd1259d46240ed
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:15:27 2020 +0200

    testing timeslot task 0

commit 8f39820ace6ecd146b5ac8e0ce10797c79159801
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 17:05:55 2020 +0200

    doc formatting

commit 996dbc9e4b952fa208b1e4b12d1ee291701ddf57
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Apr 1 12:41:54 2020 +0200

    DHB/Cookie refactoring

commit 5218a0d84f987272ac2281c6a09ac4ef431dceb6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Mar 28 19:42:24 2020 +0100

    doc fix

commit 93678adc5a8570f444e82259c991f8b5e378cae8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Mar 28 00:09:15 2020 +0100

    replace std::set by std::multiset

    so there can be multiple entries with same pollignTime

commit 5d071a1cf1e4160386566cd1bcd1eeb70e65e5f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 26 19:53:05 2020 +0100

    new device comIF return value in DHB

    request receive message

commit 0e56a094d305a35b80bdb20cc0c3cdcd533bd888
Author: jakob.meier <jakob.meier@outlook.de>
Date:   Thu Mar 26 19:43:38 2020 +0100

    merged FwMessageTypes

commit e252a5b795147d11371514b9defad39d91a596ed
Author: jakob.meier <jakob.meier@outlook.de>
Date:   Thu Mar 26 19:20:16 2020 +0100

    file system support

commit 093fef5d6f2aea6589abe45077037057bfb879ba
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 26 15:20:17 2020 +0100

    moved address_t typedef to cookieImoved address_t typedef to cookieIFF

commit 163779622fd9b7d367a0fe05d236928e2727d06e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 25 02:08:35 2020 +0100

    DHB: replyLen in replyMap now

commit b2b6b8ee23bc1ed05a4b1e1fc583a9c3f1f71cef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 15:33:18 2020 +0100

    added initializeInterface for comIF/cookie

commit ea49d88c4be5929208192fd86d9f2ccf99889cb8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 14:21:57 2020 +0100

    moved all return values to DH IF

commit 7e8d92f956220734c4d65dc026550595cfbf577f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 24 00:22:17 2020 +0100

    replaced std::list by std::set for fixedSlotSequen

commit f7b7e10d05224dcd6ab5e2c0c4e778ce5585c544
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 19:14:36 2020 +0100

    date format changed

commit b6bf9d71477b3695b1a3dfe7253137c5936c7ebc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 19:09:42 2020 +0100

    to avoid dynamic casting, introuced CookieIF

commit f7bd661e6923713740c77e91c2602caa74e6abe5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 18:08:24 2020 +0100

    small fixes

commit fa058ee6025cfe03e0a60f62ebb744d80b676637
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 18:05:39 2020 +0100

    renamed rmap to com (more generic)

commit d3e2652078913332c407845920b14cd0c5e459a6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 17:58:23 2020 +0100

    replaced DHB sizes by size_t, rework

    Cookie now passed to DHB, rework in progress

commit c50d9d90d61a727ddc90e64d75ee98a4d3679bd0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 23 13:14:23 2020 +0100

    replaced std::variant by two uint32 parameters

commit af6d18d60b323ea2759e1ca5af5980bd25673015
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 20 22:47:07 2020 +0100

    added additional parameter form open/reopen call

commit 52c05e2f3da8043336f77deba36e1fefa53e61fd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 12:44:24 2020 +0100

    minor formatting for pull request

commit b7e3449b04c48ff65e6e21767667c328938701dd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 12:38:11 2020 +0100

    some more doc for containers

commit a3903f80fb915a046eb69e1492254ef4e69b5987
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Mar 19 00:49:47 2020 +0100

    typedef address_t moved to deviceComIF

commit b5fe1fa530ed9fd91b5936b0cb617a9774861a6a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 9 22:15:52 2020 +0100

    dhb virtual function moved to top

commit 6579200f5551f93349ce018127b249ab7cdb3739
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 19:01:31 2020 +0100

    removed counter, will be implemented in childclass

commit 68cda479d699ef0f5c73b9ee95c352e178171896
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 18:48:48 2020 +0100

    DHB: performOperation Hook + polling counter

    polling counter to specify how often communication opertions are
    performed, however this still needs to be changed..

commit 22e4dabd1bf778c1a4c32aa76d8bf72b99936576
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Mar 6 15:39:42 2020 +0100

    BinSemaphore reset function added

commit 43ac0ec04bbaffc1f7a23b478fd747396a3a4ad4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 4 23:07:54 2020 +0100

    Communication Message continued

commit fb6172fdc51a6e76513437ec74ed733da3847e1f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Mar 4 00:37:58 2020 +0100

    communication message continued.

    Some fixed timeslot task improvements

commit dd4a5a45e3a25ce5bbbedfdd37a407273b62ac54
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 3 21:20:08 2020 +0100

    communication message extended

commit 72963f5855bc8a12dd21d4405cfec3a5a603fbc4
Merge: d0e8eb38 238892bd
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Mar 3 00:07:48 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit d0e8eb386ce45b3aa99f8d1413b2c05b1db079d7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Mar 2 01:00:17 2020 +0100

    renamed system context to call context

    to avoid conflicts with ISIS library, I don't want to fiddle with
    it if we don't have source code

commit 238892bd6648f090c8356a6eac9e5dfaddae1de9
Merge: 6d6c78b2 fa38a376
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 29 01:22:41 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 6d6c78b255407dc08979dbfbf927b9e4dd54db44
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 29 01:21:36 2020 +0100

    task management doc

commit fa38a3760448e28109b6a73bb46e3ee50bb583a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Feb 28 22:55:25 2020 +0100

    all context switches calls to TaskManagement.h now

commit c93ee5c6cdc0098dbcf41ff3fe4c5511534e6c69
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Feb 27 19:00:51 2020 +0100

    message queue IF return values

commit abccd81fdfddb1fc065af32bf6c603c4c3722430
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Feb 26 16:55:35 2020 +0100

    new file for freeRTOS task management functions

commit 083cc7c50ac017a12061e66d6d937a82b2908c92
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 17:04:21 2020 +0100

    sempahore wrapper extended

commit 685c18dc4ee3f96af909b90904160048fd39489d
Merge: 7a426ace bfc7a768
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 12:55:20 2020 +0100

    Merge branch 'ksat_master' into mueller_framework

commit bfc7a768ce73b1db2a535d7919f24cc1b3244736
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Feb 25 12:54:28 2020 +0100

    message queue adaptions for calls from ISR

    functions moved to top
    binary sempahore file init
    mutex return values

commit 7a426acece7e6fb6135f48b62f1431c894c8e711
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Feb 21 16:08:43 2020 +0100

    therm sensor doc correction

commit 54eeb71f02d1c4c4e49f25e25ed0821a7325b093
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Feb 17 21:20:51 2020 +0100

    bugfix: added implementation

commit 6ab07aeb1978d7a630944a698abebca1097b1d71
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 21:04:17 2020 +0100

    valid mask bugfixes

commit 1001c1d48bc7aff5a88bcd58028e6f6d58777265
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 17:21:06 2020 +0100

    added new IF for thermal messages

commit 99b90e625d916dafe30cda283c7d75ec772376a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 16:14:29 2020 +0100

    refactored: limit type specified separately

commit ddae9ee80f2c74383fa4efa91082c3871b60f6d3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Feb 16 14:59:45 2020 +0100

    adapted temp sensor to use °C limits, doc added

commit d8ed5bb1c15587ef853432a84a3c0334350f9ebd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 18:55:22 2020 +0100

    some comments for missing doc

commit e15839b3a6cdccf3f437991262c0c2eddb6b4ba6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 18:26:25 2020 +0100

    Thermal: Some formatting stuff, doc to do

    Need to find out how to use the thermal components

commit a7964c7200bee823cdf20063673f9cd905ef720c
Merge: b3faf1e4 413d6593
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sat Feb 15 15:34:53 2020 +0100

    Merge branch 'luz_FixedTimeslotTask_ExistenceCheck' into mueller_framework

commit b3faf1e4adee4097b9bcc15ad61c299adacc33a2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 31 23:42:11 2020 +0100

    old timestring used

commit 5190e4c16e0f6618cd1c6b3a3b8f8ad7683172f7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 31 00:54:34 2020 +0100

    Serial Buffer dapter changes reverted

    CCSDS time bugfixes in separate section (for C98)
    Serial buffer adapter 2 bugfixes

commit 09144b18c4fad1c9c92510f3c99ad377ddbbac58
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 29 01:03:20 2020 +0100

    ccsds time changes changed

commit 7dd4694d9d9e25114c6b52f7539ced43b8bdca3f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 28 23:19:19 2020 +0100

    CCSDS time extra defined for avr lib

commit 8f17d5147e7b13179c32fa47f2c2bdc7408e4ef5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 27 00:43:01 2020 +0100

    SerialFixedArrayList constructor bugfix

commit 85048cc9ee180ce6ba14485d18d85bf694e1e51f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 26 22:13:56 2020 +0100

    Pool Raw Access change bugfix

commit d9fa13b6ebd597b6c23f5768405dc757b467028e
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 26 18:31:17 2020 +0100

    ADDED old pool entry constructor

commit 6eedb3f09748ed698ece38cb9fc5be6ebe1d3c66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 23 15:45:21 2020 +0100

    New Pool List Initializer.

    Needs testing !!!

commit d330958abb5813261936198700a2fac535aa1884
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 22 14:27:11 2020 +0100

    Array List endian swapper protected now

commit 1977942c4b2a785e503c21f5cd5cc235ee69e9ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 22 14:24:48 2020 +0100

    Array List Entry swapper function

    And respective SerialAdapter functions to use it

commit 3d2bdae14df5427251b59bd81dc44a82f7667a34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 20 23:29:36 2020 +0100

    CSB abstract functions moved to top

    So documentation of functions to implement is closer to the top

commit dba26baee6b4df5c0379f6886c7eaf12a387683d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 20 23:00:23 2020 +0100

    Restructured header file

    Abstract functions are closer to the top
    because they must be implemented and documentation
    should be near the top.
    Important virtual functions moved up too.
    Additional documentation added

commit 424c82ce165e1da122729ce058be19a32ade7dfa
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 23:07:43 2020 +0100

    Extracted one logic block

    To increase readability

commit 5cb591a063cb9df22954a26e490806b5648d4061
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 18:01:37 2020 +0100

    Array List swapper for SerialFixedArrayList

commit 6fe0f45c278e51b4a54a7f3a105edcafaad9f89a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 16:48:33 2020 +0100

    SerialBufferAdapter new setBuffer function

    Serial Fixed Array List Adapter documentation adapted
    SinglyLinkedList setEnd() function added

commit c9e4c73bd251b15c05c7d3140413ca39a2617919
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 18 15:03:22 2020 +0100

    Local pool public members/functions moved to top

commit 1f4391f56e5f95a44529bf89661c69c821fbb5c4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 17 21:11:39 2020 +0100

    Endian Swapper buffer swapper changes reverted

commit 1d1bb88a6f173ba3426a176fb6609e27740928cd
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 16 19:07:53 2020 +0100

    Merge request check

commit 9bdbc2c380780ae7f523c4367560a13f1c64ca66
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 16 18:46:29 2020 +0100

    Endian swapper changes, Serial buffer adapter

    New Serial Buffer Adapter with complete template class for buffer type.
    Endian Swapper input now standard uint8_t * pointers instead of template
    type. Fixed Array List new ctor, but commented out for now

commit 1437f33027cf60c8561eb3517418df2b16194016
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 17:30:23 2020 +0100

    Serial Fixed Array List template type clarifications

commit 9aa57f29b81d066429f77cd163043f661062d7ed
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:52:18 2020 +0100

    basic documentation thermal

commit 9ec0b80497d7c605f40f2764b3699c424b4987ad
Merge: f16cce8b b0d88129
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:32:41 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit f16cce8be11be06f704fd0f141cb28dea233d802
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 15 13:32:21 2020 +0100

    Basic doc for thermal modules started

commit b0d88129db48db94d4d8ed4526408c62c962e2f0
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 14 01:39:47 2020 +0100

    Pool Raw Access Helper bugfix

    debug output commented

commit c7479523363c83db5e1c3c9a207a5eeee5cf5a65
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Jan 14 00:49:09 2020 +0100

    fixed map full() function added.

    Pool raw access debugging

commit 01551b8fa5bf642bac0ec124eef94f192087188a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 13 01:21:53 2020 +0100

    Getter function in SerialBufferAdapter

    For const uint8_t *

commit 1369e792b4c1f3327923c1e7418641c687bb512e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Jan 13 00:14:14 2020 +0100

    CommandingServiceBase documentation

commit d2325e60b69650b5dde10f28dc88a929decf6527
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 12 15:51:59 2020 +0100

    Import bugfix in MessageQueue.cpp

    lastPartner is only assigned if receiveMessage is successful

commit a8247eb2f0406ea78259f9a5c3f70f7b02cef15a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 12 14:18:12 2020 +0100

    Some more debugging output switched on

commit 0ce67de8c8eb8f4eb532e4445e3a1e3765ff07f2
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 10 00:57:09 2020 +0100

    Changes to pool access classes

    1. PoolRawAccessHelper is more robust now and has better error handling
    2. PoolRawAccess: Removed an unneeded constructor value, moved serialize
    further to the top. Added new returnvalues and more precise error
    handling for read() call
    3. DataSet: Made MAX Number of data pool entries public so it can be
    used by pool raw access error handling

commit 59b25bee863987dd8a38517f95ac3dc2b780be1a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 9 19:04:33 2020 +0100

    pool raw helper input buffer type changed to uint32_t

commit 0ddc44062ddc1d29c077f4e04d64e2fb7bc3e313
Merge: a7450144 2ec486a8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 9 12:50:00 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 2ec486a8806f9c0bdf287ef81b04c6b494c592ef
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Jan 5 18:20:57 2020 +0100

    max number of stored packets lowered

commit 827f185e20788b0b72eaf4cd5d322e78fb7cadd6
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Jan 4 16:37:08 2020 +0100

    Some bugfixes(?) for PusServiceBase.
    Getter Function for Serial Buffer Adapter.

commit a7450144de20cb086ba5a9602bd5a7ad44fb83af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Jan 3 15:39:32 2020 +0100

    doxygen group definitions moved to framework

commit 0a57103339a45c3a7cb18463c891c04644757c5c
Merge: f6e88e83 e2f07cbc
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 21:12:42 2020 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit f6e88e83db014f529151126d7ba5fe681604981c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 21:12:21 2020 +0100

    debug output change

commit e2f07cbcd1436176c45ad8c846657436b0aed832
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Jan 2 14:01:21 2020 +0100

    connect and disconnect functions public

commit 831a01e79ef7d5c5fd6885486f9a9fc7333d504e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 1 17:31:17 2020 +0100

    recvBuffer and recvSize initialized

commit c73cb90c3645f50794cd2919ef73fc755cc93948
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Jan 1 16:54:05 2020 +0100

    receiveTc function adapted

commit a762c159fe334f1e1be6f448dd9ed6ea2519246b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 30 01:13:33 2019 +0100

    pool raw access helper info output commented out

commit 2425685e446ec9a0dae320ea6f0cf0ca95e0cd33
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 29 01:59:02 2019 +0100

    Pool Raw Access Helper serialization of vectors implemented

commit 666341d03ddbe1394e452b0f15af2a4457a0f148
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 27 22:43:09 2019 +0100

    new bool datatype for possible pool entries

commit 79e7fee8072abbf40d65d2114157f35d856bbb5d
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 22:15:19 2019 +0100

    comment deleted

commit a38a2f4b3a4e07b77e4989300871c91705496718
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 22:07:17 2019 +0100

    tmtc bridge bugfix: tm data deleted when overwriting old data

commit 33a7c033a27dd741ebbec31f5d517b6acabd342a
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:38:15 2019 +0100

    doc extended, instructions for sendTm and receiveTc

commit 19e257a90aa57622732177166a9b1ff547da9456
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:35:11 2019 +0100

    tmtc bridge debug output corrected

commit 8397f5b2b1961bc875282829fa687adb6cdb6d97
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 20:17:21 2019 +0100

    tmtc bridge bugfix

commit 0066a6b78819777a62f8f1b0ec8512f56b4a49d4
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 19:47:46 2019 +0100

    Generic TMTC Bridge added

commit 29b4480fc4f6d752e1236e6b9172dc622ea640ba
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 18:55:31 2019 +0100

    include adapted

commit e24f9b89e4c1965387de84520c80d2439337a9e3
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 26 16:44:50 2019 +0100

    Pool Raw Access Helper tested, appesrs to work. SerializeAdapter doc
    changes, tm packet stored debug output if not enough
    storage available

commit 1f1831c4a14ddf806a6a360e1f60b1c46e90d968
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 24 22:15:39 2019 +0100

    pool raw access init

commit f6b9b232877d29d6a68640967f131d6091c7f2de
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 24 01:41:04 2019 +0100

    pool raw access init

commit 89f490ac36dd3178616cbdfa712adea389ab15ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Dec 20 23:09:35 2019 +0100

    assembly constructor formatting

commit d17146d847610b403118c7992908a94deb361e1c
Author: Maximilian Luz <luzmaximilian@gmail.com>
Date:   Thu Dec 19 16:09:50 2019 +0100

    Check object existence before adding it to the PST

    Currently, adding new objects/components to the FixedSlotSequence PST is
    not being checked, meaning that it is possible to add NULL objects here
    without any warning. This causes NULL-pointer errors when non-existent
    components are added, which can be hard to debug.

    To solve this, add a check for the object existence before adding it to
    PST and emit an error message.

    Signed-off-by: Maximilian Luz <luzmaximilian@gmail.com>

commit fa6cbe7e0c8862f903e7c78bdf938c8caff93863
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 23:18:28 2019 +0100

    pool raw access changed reverted

commit 625f3dc79c33794c041bf91af87bd0a2d271e67b
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 23:15:34 2019 +0100

    local pool modify data doc modifided

commit 9382eb03e6cfb0985d78587df3f4696e52ead038
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 22:50:08 2019 +0100

    function to serialize pool ID buffers into dataset created

commit 29a15e8154d5de81d5dff878f6e54f413f5fe12d
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 13:03:51 2019 +0100

    commented out functions which will propably not
    be needed and removed

commit 138cac98d100affabc0916e27f8189c42af3f3b9
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Wed Dec 11 01:57:36 2019 +0100

    experimenting with recursive constructor and dataset call

commit f7d8f0c1617295aae5ed652ee99566f98d84111c
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 23:26:48 2019 +0100

    Reverted changed  pool raw access commit

commit 6abb3cc525fece4f32f905200e7fa00fba4818c7
Merge: f33949ba 356d1d35
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 14:54:32 2019 +0100

    Merge remote-tracking branch 'origin/feature_EndianSwapper_UINT32_BUFFER_PoolRawAccess_Modification_For_Vectors' into mueller_framework

commit f33949ba4b2e7ef3784d712af06e94a04c45ebac
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 14:54:17 2019 +0100

    doc adapted, merging

commit 356d1d35dc97232e92778a4d0602947db812dc59
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 10 13:29:16 2019 +0100

    experimenting with recursive constructor to enable
    automatic vector registering

commit e765f8c99bbe6827b44a8ea21a9808ca51471cf1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Dec 9 12:27:14 2019 +0100

    pool raw access modified so vectors are properly serialized now
    Endian swapper can swap the entries of a uint16,uint32 buffers now.
    Some documentation for functions added. setter function for serial buffer
    adapter written but does not appear to compile, commented out

commit 8168885dd905992920029c38444b9abf27541d52
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 22:57:03 2019 +0100

    Serialization documentation update

commit 3159ccbc4017f7a9662b82054ac3adbce3aa6261
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 22:26:42 2019 +0100

    fixed map and local pool doc

commit d99ed4715017fddab2c1f80610c9c72d3b428315
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 8 19:04:53 2019 +0100

    fixed map bugfix (fist instead of first), new access functions for fixed maP
    (first(), second()), some documentation, raw pool access read() call public
    because call is necessary before using public serialize function.
    maybe integrate read() call into serialize function?

commit 950a48078c6464decada0262f5590c75c5d35a6f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Dec 5 12:21:06 2019 +0100

    some documentation, question about HasParametersIF,
    variable in ParameterHelper intialized (compiler warning)

commit 9c3a9323b7ee50685fd23b57c9d1b39445c43a18
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Dec 3 19:30:37 2019 +0100

    some doc change proposals while
    writing hk service.
    Added Type.h in PoolRawAccess.h, compiler error
    when not doing that

commit 37a70df24496dd0924969c4f52c960ed80d5a1d1
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Dec 1 17:48:05 2019 +0100

    SerialBufferAdapter can process uint32_t * buffers now

commit 10c24e39a31293ba54ee8bfdbb2f3835b91dad9e
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Nov 29 19:56:05 2019 +0100

    new returnvalue for scanForReply to ignore full packet

commit 2039aa56658923cb4127fddb409c251fdb8d55af
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 25 00:14:39 2019 +0100

    Service Interface Stream buffer size higher to print long buffers (like nav data)

commit 2f14fd5d4d67d2b8223b115d2c5d421cccecffb5
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 11 22:45:53 2019 +0100

    Cant reach mode reason getter function added

commit 2b44e1c9c4aa5e516114a6adb922e860c5044417
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Nov 10 13:08:02 2019 +0100

    CCSDS sscanf function adapted for atmel stdio.c (see comments)

commit b8af3b5e3df66e67c8fa7e0e99b6d5b2554deef4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 18:15:45 2019 +0100

    debugInterface extended

commit 537e2ceb18ddd360176fddec37331bb952f8c674
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:29:12 2019 +0100

    Getter method for logicalAddress

commit ee765eafc766d9a4a1053d3d685d7d63e6f9f95f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:17:54 2019 +0100

    ioBoardAddress renamed to logicalAddress

commit 801bd4d7ebce3ce32eab46e561dec5bc95401c4a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 9 13:07:26 2019 +0100

    debug interface for dhb created.
    This is useful to track states or values
    in child handler. some documentation added.
    New doxygen group for interfaced added.

commit bf7bc342ff2bb816d910bd2c142661fecd25c867
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:30:02 2019 +0100

    Revert "documentation for DHB init function, ioBoard addres has default value 0 now, order in ctor changed (not used in source)"

    This reverts commit c6e34cada64f59757e420347dec8373401d73c7a.

commit af4e9db9e3be75265cfcb0e48e6c7122fb02591a
Merge: b594bc2a 8a93a873
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:25:27 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit b594bc2a9719b6ffb99cb3fdaf4813c688576158
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Nov 5 19:25:00 2019 +0100

    removed obsolete comment

commit 8a93a873a8d28afa8b43635a2611b2930cd7e764
Merge: e7f7625a cb919ada
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 11:07:02 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit e7f7625adf27263aec16580fa70ca137e412aef6
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 11:06:59 2019 +0100

    removed wrong include

commit cb919ada2a99b818624d05a4e4fdfeb85e9b8174
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 01:55:40 2019 +0100

    assuming that a default value of 0 for expectedReplies is needed, I introduced a new variable into DeviceCommandInfo, which stores another number of replies expected. this value is assigned in enableReplyInReplyMap. That way, the initial value of 0 remains the same (if it was needed), and is only set to another desired value if a write was sent

commit 12f51575eb42bffc9e2cf5a72a5678975f87db34
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 00:53:05 2019 +0100

    removed a flag by accident, fixed now

commit 8eb1a5b13e2fccf21176aed9a6a27287196fd236
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Nov 4 00:47:46 2019 +0100

    proposal 1: expectedReplies parameter is set in insertInCommandAndReplyMap, default value stays one. overriding enableReplyInReplyMap is not necessary anymore.second proposal: the commander id is supplied in the interpretDeviceReply function, so we don't have to look for it in the DeviceCommandMap. was it removed at some point because it is listed in the documentation?

commit 46986f69e4a17923717464c120f4d227df561618
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sat Nov 2 23:30:12 2019 +0100

    serialize tools more documentation

commit d47496db40de8ef8a9be221b9bd023b229a59cc6
Merge: 16af33a7 3887cb8c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 19:31:20 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit 16af33a7bb52e3d9363e1e6f61e16a67783f74df
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 19:31:18 2019 +0100

    doc for fifo, device com if..

commit 3887cb8ca14f4a12a2fd446e1779b66c76096962
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:22:34 2019 +0100

    removed wrong include in dhb

commit 3f1d68542e1787e098f37a98005d984a8d83abaa
Merge: e8a16ac5 1ee445ce
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:21:03 2019 +0100

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit e8a16ac59cf87d27d1e79a6571a6ee11f0edc3c2
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 18:21:01 2019 +0100

    dummy com if sendMessage data const

commit 1ee445ce245b0383a3d770b44f971693ff37542f
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 29 11:17:07 2019 +0100

    fifo typo

commit b51536c772c9d058b7c7a4449f8cf8ca107773ec
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 28 12:48:41 2019 +0100

    CSB doc correction

commit d79f072851264ec3f9e369f2b2ccbfa7fddd3145
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 27 13:38:08 2019 +0100

    Additional documentation for DHB and CSB

commit 64f84d9d9ffbf2d4b357ac72ad24956b8540db07
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Sun Oct 27 03:21:38 2019 +0100

    doc for dhb, serializeIF and SerializeAdapter

commit 8f1517d276aac56dc260b8ea4609204ab8e1036a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 25 21:12:11 2019 +0200

    additional comments on endianness (I hope this is correct)

commit 1631e739b8c0b3b7ab0af314309da898df7e2eae
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 23 12:03:32 2019 +0200

    at91sam9g20 uses custom stdio.c, unsigned long cast in sprintf does not seem to work, casting (unsigned int) does, timestamp now visible in debug output

commit 07950b0c2bb9c3822729a225302cb685cb62ea7a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Wed Oct 23 00:31:45 2019 +0200

    documentation for object manager IF get function

commit cd1b26b04cff83ba4d238bf74c5d9bace467ea3b
Merge: c6e34cad 4db655e4
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 17:15:54 2019 +0200

    Merge branch 'mueller_framework' of https://egit.irs.uni-stuttgart.de/KSat/fsfw into mueller_framework

commit c6e34cada64f59757e420347dec8373401d73c7a
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 17:15:29 2019 +0200

    documentation for DHB init function, ioBoard addres has default value 0 now, order in ctor changed (not used in source)

commit 4db655e4898de934f6388365ec036d9d6e6b1bbe
Author: Robin Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 14:01:17 2019 +0200

    task priority order comment

commit cbc8012198da6e94870f2b5fe63b799587092bc8
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Tue Oct 22 00:06:11 2019 +0200

    ioBoardAddress protected instead of private to allow custom initialize

commit 907664cea9958f1259ed19560839c26533481cf7
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Mon Oct 21 11:38:13 2019 +0200

    added do performOperation where the comIF functions are called, some comments added in DeviceHandlerIF

commit 5e3b7c36257314bab40b36c78c13c0525b08eb86
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Fri Oct 18 13:37:09 2019 +0200

    explanation of cookie purpose added, device handler base indentation

commit 743d8abeaffe55cefbddbd2b264be4adcac4d19c
Author: Robin.Mueller <robin.mueller.m@gmail.com>
Date:   Thu Oct 17 00:23:46 2019 +0200

    first attempt to document and explain serialization tools for application developers
---
 container/FixedOrderedMultimap.h              |    1 +
 controller/ExtendedControllerBase.cpp         |   22 +-
 controller/ExtendedControllerBase.h           |   15 +-
 datapool/PoolDataSetBase.cpp                  |   51 +-
 datapool/PoolDataSetBase.h                    |   29 +-
 datapool/PoolDataSetIF.h                      |    5 +-
 datapool/PoolEntry.cpp                        |   42 +-
 datapool/PoolEntry.h                          |   61 +-
 datapool/PoolVariableIF.h                     |    1 +
 datapool/ReadCommitIF.h                       |   11 +-
 datapoollocal/AccessLocalPoolF.h              |   27 +
 datapoollocal/CMakeLists.txt                  |    4 +-
 datapoollocal/HasLocalDataPoolIF.h            |  135 +-
 datapoollocal/LocalDataPoolManager.cpp        | 1407 +++++++++--------
 datapoollocal/LocalDataPoolManager.h          |   70 +-
 datapoollocal/LocalPoolDataSetBase.cpp        |   80 +-
 datapoollocal/LocalPoolDataSetBase.h          |   55 +-
 datapoollocal/LocalPoolObjectBase.cpp         |  133 +-
 datapoollocal/LocalPoolObjectBase.h           |   11 +-
 datapoollocal/LocalPoolVariable.h             |   24 +-
 datapoollocal/LocalPoolVariable.tpp           |  103 +-
 datapoollocal/LocalPoolVector.h               |   29 +-
 datapoollocal/LocalPoolVector.tpp             |   90 +-
 datapoollocal/PoolReadHelper.h                |   16 +-
 .../ProvidesDataPoolSubscriptionIF.h          |   84 +
 datapoollocal/SharedLocalDataSet.h            |    7 +
 datapoollocal/internal/CMakeLists.txt         |    5 +
 .../internal/HasLocalDpIFManagerAttorney.cpp  |   18 +
 .../internal/HasLocalDpIFManagerAttorney.h    |   22 +
 .../internal/HasLocalDpIFUserAttorney.cpp     |    7 +
 .../internal/HasLocalDpIFUserAttorney.h       |   18 +
 .../internal/LocalDpManagerAttorney.h         |   32 +
 .../internal/LocalPoolDataSetAttorney.h       |   39 +
 ...olDefinitions.h => localPoolDefinitions.h} |   27 +-
 defaultcfg/fsfwconfig/FSFWConfig.h            |   10 +-
 devicehandlers/DeviceHandlerBase.cpp          |  187 ++-
 devicehandlers/DeviceHandlerBase.h            |   35 +-
 devicehandlers/DeviceHandlerIF.h              |    2 +-
 events/EventManager.cpp                       |    8 +-
 events/EventManager.h                         |    4 +
 fsfw.mk                                       |    1 +
 globalfunctions/arrayprinter.cpp              |   10 +-
 housekeeping/HousekeepingMessage.h            |    2 +-
 internalError/InternalErrorDataset.h          |    6 +-
 internalError/InternalErrorReporter.cpp       |   52 +-
 internalError/InternalErrorReporter.h         |   13 +-
 ipc/MutexIF.h                                 |    2 +-
 monitoring/MonitorReporter.h                  |    2 +-
 monitoring/MonitoringMessageContent.h         |    9 +-
 osal/FreeRTOS/Clock.cpp                       |    4 +-
 osal/host/Clock.cpp                           |    4 +-
 osal/host/Mutex.cpp                           |    6 +-
 osal/host/Mutex.h                             |    1 -
 osal/linux/BinarySemaphore.cpp                |   20 +-
 osal/linux/Clock.cpp                          |   10 +-
 osal/linux/CountingSemaphore.cpp              |    4 +-
 osal/linux/MessageQueue.cpp                   |   14 +-
 osal/linux/PosixThread.cpp                    |   10 +-
 osal/linux/TcUnixUdpPollingTask.cpp           |    2 +
 osal/linux/TmTcUnixUdpBridge.cpp              |    8 +-
 osal/rtems/Mutex.cpp                          |    4 +-
 power/Fuse.cpp                                |    7 +-
 power/PowerSensor.cpp                         |    3 +-
 unittest/internal/UnittDefinitions.cpp        |    6 +-
 unittest/internal/UnittDefinitions.h          |    3 +-
 unittest/internal/osal/IntTestMutex.cpp       |    2 +-
 unittest/tests/CMakeLists.txt                 |    1 +
 unittest/tests/action/TestActionHelper.cpp    |    3 +
 unittest/tests/action/TestActionHelper.h      |   81 -
 .../tests/container/TestPlacementFactory.cpp  |   93 +-
 unittest/tests/datapoollocal/CMakeLists.txt   |    6 +
 unittest/tests/datapoollocal/DataSetTest.cpp  |   23 +
 .../datapoollocal/LocalPoolManagerTest.cpp    |  122 ++
 .../tests/datapoollocal/LocalPoolOwnerBase.h  |  206 +++
 .../datapoollocal/LocalPoolVariableTest.cpp   |  123 ++
 .../datapoollocal/LocalPoolVectorTest.cpp     |  120 ++
 unittest/tests/mocks/HkReceiverMock.h         |   20 +
 unittest/tests/mocks/MessageQueueMockBase.h   |  121 ++
 .../tests/storagemanager/TestNewAccessor.cpp  |  322 ++--
 unittest/tests/storagemanager/TestPool.cpp    |    2 -
 unittest/user/CMakeLists.txt                  |  108 +-
 unittest/user/testcfg/FSFWConfig.h            |   23 +-
 .../user/testcfg/objects/systemObjectList.h   |   15 +-
 unittest/user/unittest/CMakeLists.txt         |    1 +
 unittest/user/unittest/core/CMakeLists.txt    |    6 +
 .../user/unittest/core/CatchDefinitions.cpp   |    5 +-
 unittest/user/unittest/core/CatchFactory.cpp  |   27 +-
 unittest/user/unittest/core/CatchRunner.cpp   |   13 +-
 unittest/user/unittest/core/CatchSetup.cpp    |   14 +-
 unittest/user/unittest/core/printChar.cpp     |    2 +-
 90 files changed, 3080 insertions(+), 1509 deletions(-)
 create mode 100644 datapoollocal/AccessLocalPoolF.h
 create mode 100644 datapoollocal/ProvidesDataPoolSubscriptionIF.h
 create mode 100644 datapoollocal/internal/CMakeLists.txt
 create mode 100644 datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
 create mode 100644 datapoollocal/internal/HasLocalDpIFManagerAttorney.h
 create mode 100644 datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
 create mode 100644 datapoollocal/internal/HasLocalDpIFUserAttorney.h
 create mode 100644 datapoollocal/internal/LocalDpManagerAttorney.h
 create mode 100644 datapoollocal/internal/LocalPoolDataSetAttorney.h
 rename datapoollocal/{locPoolDefinitions.h => localPoolDefinitions.h} (68%)
 create mode 100644 unittest/tests/datapoollocal/CMakeLists.txt
 create mode 100644 unittest/tests/datapoollocal/DataSetTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolOwnerBase.h
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
 create mode 100644 unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
 create mode 100644 unittest/tests/mocks/HkReceiverMock.h
 create mode 100644 unittest/tests/mocks/MessageQueueMockBase.h
 create mode 100644 unittest/user/unittest/CMakeLists.txt

diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index 96bc0073..acf2368a 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -3,6 +3,7 @@
 
 #include "ArrayList.h"
 #include <cstring>
+#include <functional>
 
 /**
  * @brief  An associative container which allows multiple entries of the same key.
diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index 017acafe..e0aec63a 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -4,7 +4,7 @@
 ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId,
         object_id_t parentId, size_t commandQueueDepth):
         ControllerBase(objectId, parentId, commandQueueDepth),
-        localPoolManager(this, commandQueue),
+        poolManager(this, commandQueue),
         actionHelper(this, commandQueue) {
 }
 
@@ -17,7 +17,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     // needs to be overriden and implemented by child class.
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -26,8 +26,8 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
-    return &localPoolManager;
+AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
+    return &poolManager;
 }
 
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
@@ -40,7 +40,7 @@ ReturnValue_t ExtendedControllerBase::handleCommandMessage(
     if(result == HasReturnvaluesIF::RETURN_OK) {
         return result;
     }
-    return localPoolManager.handleHousekeepingMessage(message);
+    return poolManager.handleHousekeepingMessage(message);
 }
 
 void ExtendedControllerBase::handleQueue() {
@@ -64,7 +64,7 @@ void ExtendedControllerBase::handleQueue() {
             continue;
         }
 
-        result = localPoolManager.handleHousekeepingMessage(&command);
+        result = poolManager.handleHousekeepingMessage(&command);
         if (result == RETURN_OK) {
             continue;
         }
@@ -88,16 +88,16 @@ ReturnValue_t ExtendedControllerBase::initialize() {
         return result;
     }
 
-    return localPoolManager.initialize(commandQueue);
+    return poolManager.initialize(commandQueue);
 }
 
 ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
-    return localPoolManager.initializeAfterTaskCreation();
+    return poolManager.initializeAfterTaskCreation();
 }
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    localPoolManager.performHkOperation();
+    poolManager.performHkOperation();
     performControlOperation();
     return RETURN_OK;
 }
@@ -113,3 +113,7 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
 #endif
     return nullptr;
 }
+
+ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index 02c5728e..b2760514 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,10 +32,20 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
+    /**
+     * Provides a subscription interface for objects which required updates on changed
+     * controller variables or datasets
+     * @return
+     */
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+
 protected:
-    LocalDataPoolManager localPoolManager;
+    LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
+    //! Accessor handle required for internal handling
+    AccessPoolManagerIF* getAccessorHandle() override;
+
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.
@@ -60,9 +70,8 @@ protected:
     /** HasLocalDatapoolIF overrides */
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+            localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual uint32_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 };
diff --git a/datapool/PoolDataSetBase.cpp b/datapool/PoolDataSetBase.cpp
index 5fb1c3c7..01069785 100644
--- a/datapool/PoolDataSetBase.cpp
+++ b/datapool/PoolDataSetBase.cpp
@@ -38,11 +38,12 @@ ReturnValue_t PoolDataSetBase::registerVariable(
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PoolDataSetBase::read(uint32_t lockTimeout) {
+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(lockTimeout);
+		lockDataPool(timeoutType, lockTimeout);
 		for (uint16_t count = 0; count < fillCount; count++) {
 			result = readVariable(count);
 			if(result != RETURN_OK) {
@@ -86,7 +87,9 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 				!= PoolVariableIF::NO_PARAMETER)
 	{
 		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(mutexTimeout);
+			result = registeredVariables[count]->read(
+					timeoutTypeForSingleVars,
+					mutexTimeoutForSingleVars);
 		}
 		else {
 			result = registeredVariables[count]->readWithoutLock();
@@ -99,25 +102,29 @@ ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
 	return result;
 }
 
-ReturnValue_t PoolDataSetBase::commit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(lockTimeout);
+		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 	else {
-		return handleUnreadDatasetCommit(lockTimeout);
+		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
 	}
 }
 
-void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
-	lockDataPool(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
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(mutexTimeout);
+				registeredVariables[count]->commit(
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				registeredVariables[count]->commitWithoutLock();
@@ -128,16 +135,19 @@ void PoolDataSetBase::handleAlreadyReadDatasetCommit(uint32_t lockTimeout) {
 	unlockDataPool();
 }
 
-ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
+ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
+		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(lockTimeout);
+	lockDataPool(timeoutType, lockTimeout);
 	for (uint16_t count = 0; count < fillCount; count++) {
 		if (registeredVariables[count]->getReadWriteMode()
 				== PoolVariableIF::VAR_WRITE
 				&& registeredVariables[count]->getDataPoolId()
 				!= PoolVariableIF::NO_PARAMETER) {
 			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(mutexTimeout);
+				result = registeredVariables[count]->commit(
+						timeoutTypeForSingleVars,
+						mutexTimeoutForSingleVars);
 			}
 			else {
 				result = registeredVariables[count]->commitWithoutLock();
@@ -160,7 +170,8 @@ ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(uint32_t lockTimeout) {
 }
 
 
-ReturnValue_t PoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
+ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
+		uint32_t lockTimeout) {
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -206,8 +217,14 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
 
-void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->mutexTimeout = mutexTimeout;
+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;
 }
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 7c1d84a4..d741dabc 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -3,6 +3,7 @@
 
 #include "PoolDataSetIF.h"
 #include "PoolVariableIF.h"
+#include "../serialize/SerializeIF.h"
 #include "../ipc/MutexIF.h"
 
 /**
@@ -62,8 +63,9 @@ public:
 	 * - @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;
+	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
@@ -82,8 +84,9 @@ public:
 	 * 			- @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;
+	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.
@@ -97,8 +100,9 @@ public:
 	 * thread-safety. Default implementation is empty
 	 * @return Always returns -@c RETURN_OK
 	 */
-	virtual ReturnValue_t lockDataPool(uint32_t timeoutMs =
-			MutexIF::BLOCKING) override;
+	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
@@ -124,6 +128,7 @@ protected:
 	 * @param mutexTimeout
 	 */
 	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
 			uint32_t mutexTimeout = 20);
 
 	/**
@@ -154,14 +159,20 @@ protected:
 	const size_t maxFillCount = 0;
 
 	void setContainer(PoolVariableIF** variablesContainer);
+	PoolVariableIF** getContainer() const;
 
 private:
 	bool protectEveryReadCommitCall = false;
-	uint32_t mutexTimeout = 20;
+	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(uint32_t lockTimeout);
-	ReturnValue_t handleUnreadDatasetCommit(uint32_t lockTimeout);
+	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_ */
diff --git a/datapool/PoolDataSetIF.h b/datapool/PoolDataSetIF.h
index 99c06cfd..1f52871d 100644
--- a/datapool/PoolDataSetIF.h
+++ b/datapool/PoolDataSetIF.h
@@ -18,7 +18,10 @@ public:
      *          thread-safety
      * @return Lock operation result
      */
-    virtual ReturnValue_t lockDataPool(dur_millis_t timeoutMs) = 0;
+    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
diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp
index 58375162..a5867222 100644
--- a/datapool/PoolEntry.cpp
+++ b/datapool/PoolEntry.cpp
@@ -1,32 +1,24 @@
 #include "PoolEntry.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.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(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){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		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) {
@@ -70,14 +62,26 @@ bool PoolEntry<T>::getValid() {
 
 template <typename T>
 void PoolEntry<T>::print() {
+	const char* validString = nullptr;
+	if(valid) {
+		validString = "Valid";
+	}
+	else {
+		validString = "Invalid";
+	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	 sif::debug << "Pool Entry Validity: " <<
-			 (this->valid? " (valid) " : " (invalid) ") << std::endl;
-#endif
-	arrayprinter::print(reinterpret_cast<uint8_t*>(address), length);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug << std::dec << std::endl;
+	 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>
@@ -88,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>;
diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h
index 033db40d..30940320 100644
--- a/datapool/PoolEntry.h
+++ b/datapool/PoolEntry.h
@@ -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 /* FSFW_DATAPOOL_POOLENTRY_H_ */
diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index 9740fc12..444e19d0 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -25,6 +25,7 @@ class PoolVariableIF : public SerializeIF,
 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 ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
 
 	static constexpr bool VALID = 1;
 	static constexpr bool INVALID = 0;
diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index 0cdce371..efe51594 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/ipc/MutexIF.h>
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit
@@ -10,8 +11,10 @@
 class ReadCommitIF {
 public:
 	virtual ~ReadCommitIF() {}
-	virtual ReturnValue_t read(uint32_t mutexTimeout) = 0;
-	virtual ReturnValue_t commit(uint32_t mutexTimeout) = 0;
+	virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
+	virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) = 0;
 
 protected:
 
@@ -19,11 +22,11 @@ protected:
 	//! members with commit and read semantics where the lock is only necessary
 	//! once.
 	virtual ReturnValue_t readWithoutLock()  {
-		return read(20);
+		return read(MutexIF::TimeoutType::WAITING, 20);
 	}
 
 	virtual ReturnValue_t commitWithoutLock() {
-		return commit(20);
+		return commit(MutexIF::TimeoutType::WAITING, 20);
 	}
 };
 
diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
new file mode 100644
index 00000000..da08644f
--- /dev/null
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -0,0 +1,27 @@
+#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
+
+class LocalDataPoolManager;
+class MutexIF;
+
+/**
+ * @brief 	Accessor class which can be used by classes which like to use the pool manager.
+ */
+class AccessPoolManagerIF {
+public:
+	virtual ~AccessPoolManagerIF() {};
+
+	virtual MutexIF* getLocalPoolMutex() = 0;
+
+	/**
+	 * Can be used to get a handle to the local data pool manager.
+	 * This function is protected because it should only be used by the
+	 * class imlementing the interface.
+	 */
+	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+protected:
+
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/datapoollocal/CMakeLists.txt b/datapoollocal/CMakeLists.txt
index c6b187cd..e2db39eb 100644
--- a/datapoollocal/CMakeLists.txt
+++ b/datapoollocal/CMakeLists.txt
@@ -5,4 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		LocalPoolDataSetBase.cpp
 		LocalPoolObjectBase.cpp
 		SharedLocalDataSet.cpp
-)
\ No newline at end of file
+)
+
+add_subdirectory(internal)
\ No newline at end of file
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 7707fab8..569f2b09 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -1,52 +1,40 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
-#include "locPoolDefinitions.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/PoolEntryIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 
 #include <map>
 
-class LocalDataPoolManager;
+class AccessPoolManagerIF;
+class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-
-using LocalDataPool =  std::map<lp_id_t, PoolEntryIF*>;
-using LocalDataPoolMapIter = LocalDataPool::iterator;
+class LocalDataPoolManager;
 
 /**
- * @brief 		This interface is implemented by classes which posses a local
- * 				data pool (not the managing class). It defines the relationship
- * 				between the local data pool owner and the LocalDataPoolManager.
+ * @brief 		This interface is implemented by classes which posses a local data pool (not the
+ * 				managing class). It defines the relationship between the local data pool owner
+ * 				and the LocalDataPoolManager.
  * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager
- * member class which contains the actual pool data structure
- * and exposes the public interface for it.
- * This is required because the pool entries are templates, which makes
- * specifying an interface rather difficult. The local data pool can be
- * accessed by using the LocalPoolVariable, LocalPoolVector or LocalDataSet
- * classes.
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
  *
- * Architectural Note:
- * This could be circumvented by using a wrapper/accessor function or
- * implementing the templated function in this interface..
- * The first solution sounds better than the second but
- * the LocalPoolVariable classes are templates as well, so this just shifts
- * the problem somewhere else. Interfaces are nice, but the most
- * pragmatic solution I found was to offer the client the full interface
- * of the LocalDataPoolManager.
  */
 class HasLocalDataPoolIF {
+	friend class HasLocalDpIFManagerAttorney;
+	friend class HasLocalDpIFUserAttorney;
 public:
 	virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
-
-    static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
-    static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
-
 	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
 	virtual object_id_t getObjectId() const = 0;
@@ -59,13 +47,9 @@ public:
 	 * The manager instance shall also be passed to this function.
 	 * It can be used to subscribe for periodic packets for for updates.
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(
-	        LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 	        LocalDataPoolManager& poolManager) = 0;
 
-	/** Can be used to get a handle to the local data pool manager. */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
 	/**
 	 * Returns the minimum sampling frequency in milliseconds, which will
 	 * usually be the period the pool owner performs its periodic operation.
@@ -73,40 +57,17 @@ public:
 	 */
 	virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
-     * from a SID
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
-
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
-#endif
-	    return nullptr;
-	}
-
     /**
      * @brief   This function will be called by the manager if an update
      *          notification is received.
-     * @details
+     * @details  HasLocalDataPoolIF
      * Can be overriden by the child class to handle changed datasets.
      * @param sid
      * @param storeId If a snapshot was requested, data will be located inside
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -124,18 +85,68 @@ public:
         return;
     }
 
-	/* These function can be implemented by pool owner, as they are required
-	 * by the housekeeping message interface */
+	/**
+	 * These function can be implemented by pool owner, if they are required
+	 * and used by the housekeeping message interface.
+	 * */
 	virtual ReturnValue_t addDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
 	virtual ReturnValue_t removeDataSet(sid_t sid) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid,
-	        float newIntervalSeconds) {
+	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};
+
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates in form of messages.
+	 * The consumers can then read the most recent variable value by calling read with
+	 * an own pool variable or set instance or using the deserialized snapshot data.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+
+protected:
+
+	/**
+	 * Accessor handle required for internal handling. Not intended for users and therefore
+	 * declared protected. Users should instead use pool variables, sets or the subscription
+	 * interface to access pool entries.
+	 * @return
+	 */
+	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID. This function is protected to prevent users from
+     * using raw data set pointers which could not be thread-safe. Users
+     * should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+
+	/**
+	 * Similar to the function above, but used to get a local pool variable
+	 * handle. This is only needed for update notifications, so it is not
+	 * defined as abstract. This function is protected to prevent users from
+     * using raw pool variable pointers which could not be thread-safe.
+     * Users should use the #ProvidesDataPoolSubscriptionIF.
+	 * @param localPoolId
+	 * @return
+	 */
+	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+	            << ". Returning nullptr!" << std::endl;
+#else
+	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+	    		"Not overriden. Returning nullptr!\n");
+#endif
+	    return nullptr;
+	}
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index 24516aad..462ef17f 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -1,11 +1,13 @@
+#include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
 #include "LocalPoolDataSetBase.h"
+#include "internal/LocalPoolDataSetAttorney.h"
+#include "internal/HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingPacketUpdate.h"
 #include "../housekeeping/HousekeepingSetPacket.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
-
 #include "../timemanager/CCSDSTime.h"
 #include "../ipc/MutexFactory.h"
 #include "../ipc/MutexHelper.h"
@@ -14,797 +16,896 @@
 #include <array>
 #include <cmath>
 
-object_id_t LocalDataPoolManager::defaultHkDestination =
-        objects::PUS_SERVICE_3_HOUSEKEEPING;
+object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
 
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner,
-        MessageQueueIF* queueToUse, bool appendValidityBuffer):
-                        appendValidityBuffer(appendValidityBuffer) {
-    if(owner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Invalid supplied owner!" << std::endl;
-#endif
-        return;
-    }
-    this->owner = owner;
-    mutex = MutexFactory::instance()->createMutex();
-    if(mutex == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                << "Could not create mutex." << std::endl;
-#endif
-    }
+LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
+		bool appendValidityBuffer):
+		appendValidityBuffer(appendValidityBuffer) {
+	if(owner == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Invalid supplied owner");
+		return;
+	}
+	this->owner = owner;
+	mutex = MutexFactory::instance()->createMutex();
+	if(mutex == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not create mutex");
+	}
 
-    hkQueue = queueToUse;
+	hkQueue = queueToUse;
 }
 
 LocalDataPoolManager::~LocalDataPoolManager() {}
 
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-    if(queueToUse == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ". Supplied "
-                << "queue invalid!" << std::dec << std::endl;
-#endif
-    }
-    hkQueue = queueToUse;
+	if(queueToUse == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"initialize", QUEUE_OR_DESTINATION_INVALID);
+	}
+	hkQueue = queueToUse;
 
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-    if(ipcStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::initialize: "
-                << std::hex << "0x" << owner->getObjectId() << ": Could not "
-                << "set IPC store." <<std::dec << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	if(ipcStore == nullptr) {
+		// error, all destinations invalid
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"initialize", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not set IPC store.");
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
 
 
-    if(defaultHkDestination != objects::NO_OBJECT) {
-        AcceptsHkPacketsIF* hkPacketReceiver =
-                objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-        if(hkPacketReceiver != nullptr) {
-            hkDestinationId = hkPacketReceiver->getHkQueue();
-        }
-        else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
-                    << "Default HK destination object is invalid!" << std::endl;
-#endif
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
+	if(defaultHkDestination != objects::NO_OBJECT) {
+		AcceptsHkPacketsIF* hkPacketReceiver =
+				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+		if(hkPacketReceiver != nullptr) {
+			hkDestinationId = hkPacketReceiver->getHkQueue();
+		}
+		else {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", QUEUE_OR_DESTINATION_INVALID);
+			return QUEUE_OR_DESTINATION_INVALID;
+		}
+	}
 
-    return HasReturnvaluesIF::RETURN_OK;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
-        uint8_t nonDiagInvlFactor) {
-    setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-    return initializeHousekeepingPoolEntriesOnce();
+		uint8_t nonDiagInvlFactor) {
+	setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
+	return initializeHousekeepingPoolEntriesOnce();
 }
 
 ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-    if(not mapInitialized) {
-        ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-                *this);
-        if(result == HasReturnvaluesIF::RETURN_OK) {
-            mapInitialized = true;
-        }
-        return result;
-    }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HousekeepingManager: The map should only be initialized "
-            << "once!" << std::endl;
-#endif
-    return HasReturnvaluesIF::RETURN_OK;
+	if(not mapInitialized) {
+		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
+				*this);
+		if(result == HasReturnvaluesIF::RETURN_OK) {
+			mapInitialized = true;
+		}
+		return result;
+	}
+
+	printWarningOrError(sif::OutputTypes::OUT_WARNING,
+			"initialize", HasReturnvaluesIF::RETURN_FAILED,
+			"The map should only be initialized once");
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::performHkOperation() {
-    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-    for(auto& receiver: hkReceiversMap) {
-        switch(receiver.reportingType) {
-        case(ReportingType::PERIODIC): {
-            if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-                // Periodic packets shall only be generated from datasets.
-                continue;
-            }
-            performPeriodicHkGeneration(receiver);
-            break;
-        }
-        case(ReportingType::UPDATE_HK): {
-            handleHkUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_NOTIFICATION): {
-            handleNotificationUpdate(receiver, status);
-            break;
-        }
-        case(ReportingType::UPDATE_SNAPSHOT): {
-            handleNotificationSnapshot(receiver, status);
-            break;
-        }
-        default:
-            // This should never happen.
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-    }
-    resetHkUpdateResetHelper();
-    return status;
+	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+	for(auto& receiver: hkReceiversMap) {
+		switch(receiver.reportingType) {
+		case(ReportingType::PERIODIC): {
+			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+				// Periodic packets shall only be generated from datasets.
+				continue;
+			}
+			performPeriodicHkGeneration(receiver);
+			break;
+		}
+		case(ReportingType::UPDATE_HK): {
+			handleHkUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_NOTIFICATION): {
+			handleNotificationUpdate(receiver, status);
+			break;
+		}
+		case(ReportingType::UPDATE_SNAPSHOT): {
+			handleNotificationSnapshot(receiver, status);
+			break;
+		}
+		default:
+			// This should never happen.
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+	}
+	resetHkUpdateResetHelper();
+	return status;
 }
 
 ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-        ReturnValue_t& status) {
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        // Update packets shall only be generated from datasets.
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-            receiver.dataId.sid);
-    if(dataSet->hasChanged()) {
-        // prepare and send update notification
-        ReturnValue_t result = generateHousekeepingPacket(
-                receiver.dataId.sid, dataSet, true);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-    }
-    handleChangeResetLogic(receiver.dataType, receiver.dataId,
-            dataSet);
-    return HasReturnvaluesIF::RETURN_OK;
+		ReturnValue_t& status) {
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		// Update packets shall only be generated from datasets.
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+			receiver.dataId.sid);
+	if(dataSet->hasChanged()) {
+		// prepare and send update notification
+		ReturnValue_t result = generateHousekeepingPacket(
+				receiver.dataId.sid, dataSet, true);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+	}
+	handleChangeResetLogic(receiver.dataType, receiver.dataId,
+			dataSet);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        if(poolObj->hasChanged()) {
-            // prepare and send update notification.
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationVariableCommand(
-                    &notification, receiver.dataId.localPoolId);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = poolObj;
-        }
+ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
+		ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
+		if(poolObj->hasChanged()) {
+			// prepare and send update notification.
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
+					receiver.dataId.localPoolId);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = poolObj;
+		}
 
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        if(dataSet->hasChanged()) {
-            // prepare and send update notification
-            CommandMessage notification;
-            HousekeepingMessage::setUpdateNotificationSetCommand(
-                    &notification, receiver.dataId.sid);
-            ReturnValue_t result = hkQueue->sendMessage(
-                    receiver.destinationQueue, &notification);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                status = result;
-            }
-            toReset = dataSet;
-        }
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationUpdate", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
+		if(dataSet->hasChanged()) {
+			// prepare and send update notification
+			CommandMessage notification;
+			HousekeepingMessage::setUpdateNotificationSetCommand(
+					&notification, receiver.dataId.sid);
+			ReturnValue_t result = hkQueue->sendMessage(
+					receiver.destinationQueue, &notification);
+			if(result != HasReturnvaluesIF::RETURN_OK) {
+				status = result;
+			}
+			toReset = dataSet;
+		}
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
-        HkReceiver& receiver, ReturnValue_t& status) {
-    MarkChangedIF* toReset = nullptr;
-    // check whether data has changed and send messages in case it has.
-    if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-        LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId);
-        if(poolObj == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
+		HkReceiver& receiver, ReturnValue_t& status) {
+	MarkChangedIF* toReset = nullptr;
+	// check whether data has changed and send messages in case it has.
+	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
+		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+				receiver.dataId.localPoolId);
+		if(poolObj == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
+			return POOLOBJECT_NOT_FOUND;
+		}
 
-        if (not poolObj->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if (not poolObj->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getPoolObjectHandle(
-                receiver.dataId.localPoolId));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
+						receiver.dataId.localPoolId));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-                receiver.dataId.localPoolId, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue,
-                &notification);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = poolObj;
-    }
-    else {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(
-                receiver.dataId.sid);
-        if(dataSet == nullptr) {
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
+				receiver.dataId.localPoolId, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue,
+				&notification);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = poolObj;
+	}
+	else {
+		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+				receiver.dataId.sid);
+		if(dataSet == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"handleNotificationSnapshot", DATASET_NOT_FOUND);
+			return DATASET_NOT_FOUND;
+		}
 
-        if(not dataSet->hasChanged()) {
-            return HasReturnvaluesIF::RETURN_OK;
-        }
+		if(not dataSet->hasChanged()) {
+			return HasReturnvaluesIF::RETURN_OK;
+		}
 
-        // prepare and send update snapshot.
-        timeval now;
-        Clock::getClock_timeval(&now);
-        CCSDSTime::CDS_short cds;
-        CCSDSTime::convertToCcsds(&cds, &now);
-        HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-                sizeof(cds), owner->getDataSetHandle(receiver.dataId.sid));
+		// prepare and send update snapshot.
+		timeval now;
+		Clock::getClock_timeval(&now);
+		CCSDSTime::CDS_short cds;
+		CCSDSTime::convertToCcsds(&cds, &now);
+		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
+				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
+						receiver.dataId.sid));
 
-        store_address_t storeId;
-        ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
+		store_address_t storeId;
+		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 
-        CommandMessage notification;
-        HousekeepingMessage::setUpdateSnapshotSetCommand(
-                &notification, receiver.dataId.sid, storeId);
-        result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            status = result;
-        }
-        toReset = dataSet;
+		CommandMessage notification;
+		HousekeepingMessage::setUpdateSnapshotSetCommand(
+				&notification, receiver.dataId.sid, storeId);
+		result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			status = result;
+		}
+		toReset = dataSet;
 
-    }
-    if(toReset != nullptr) {
-        handleChangeResetLogic(receiver.dataType,
-                receiver.dataId, toReset);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+	}
+	if(toReset != nullptr) {
+		handleChangeResetLogic(receiver.dataType,
+				receiver.dataId, toReset);
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-        HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
-    size_t updatePacketSize = updatePacket.getSerializedSize();
-    uint8_t *storePtr = nullptr;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            updatePacket.getSerializedSize(), &storePtr);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-    size_t serializedSize = 0;
-    result = updatePacket.serialize(&storePtr, &serializedSize,
-            updatePacketSize, SerializeIF::Endianness::MACHINE);
-    return result;;
+		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
+	size_t updatePacketSize = updatePacket.getSerializedSize();
+	uint8_t *storePtr = nullptr;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			updatePacket.getSerializedSize(), &storePtr);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	size_t serializedSize = 0;
+	result = updatePacket.serialize(&storePtr, &serializedSize,
+			updatePacketSize, SerializeIF::Endianness::MACHINE);
+	return result;;
 }
 
 void LocalDataPoolManager::handleChangeResetLogic(
-        DataType type, DataId dataId, MarkChangedIF* toReset) {
-    if(hkUpdateResetList == nullptr) {
-        // config error!
-        return;
-    }
+		DataType type, DataId dataId, MarkChangedIF* toReset) {
+	if(hkUpdateResetList == nullptr) {
+		// config error!
+		return;
+	}
+	HkUpdateResetList& listRef = *hkUpdateResetList;
+	for(auto& changeInfo: listRef) {
+		if(changeInfo.dataType != type) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::DATA_SET) and
+				(changeInfo.dataId.sid != dataId.sid)) {
+			continue;
+		}
+		if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
+				(changeInfo.dataId.localPoolId != dataId.localPoolId)) {
+			continue;
+		}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        if(changeInfo.dataType != type) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::DATA_SET) and
-                (changeInfo.dataId.sid != dataId.sid)) {
-            continue;
-        }
-        if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-                (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-            continue;
-        }
-
-        if(changeInfo.updateCounter <= 1) {
-            toReset->setChanged(false);
-        }
-        if(changeInfo.currentUpdateCounter == 0) {
-            toReset->setChanged(false);
-        }
-        else {
-            changeInfo.currentUpdateCounter--;
-        }
-        return;
-    }
+		// only one update recipient, we can reset changes status immediately.
+		if(changeInfo.updateCounter <= 1) {
+			toReset->setChanged(false);
+		}
+		// All recipients have been notified, reset the changed flag.
+		if(changeInfo.currentUpdateCounter <= 1) {
+			toReset->setChanged(false);
+			changeInfo.currentUpdateCounter = 0;
+		}
+		// Not all recipiens have been notified yet, decrement.
+		else {
+			changeInfo.currentUpdateCounter--;
+		}
+		return;
+	}
 }
 
 void LocalDataPoolManager::resetHkUpdateResetHelper() {
-    if(hkUpdateResetList == nullptr) {
-        return;
-    }
+	if(hkUpdateResetList == nullptr) {
+		return;
+	}
 
-    for(auto& changeInfo: *hkUpdateResetList) {
-        changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-    }
+	for(auto& changeInfo: *hkUpdateResetList) {
+		changeInfo.currentUpdateCounter = changeInfo.updateCounter;
+	}
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-        bool enableReporting, float collectionInterval, bool isDiagnostics,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+		bool enableReporting, float collectionInterval, bool isDiagnostics,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::PERIODIC;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::PERIODIC;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(enableReporting);
-        dataSet->setDiagnostic(isDiagnostics);
-        dataSet->initializePeriodicHelper(collectionInterval,
-                owner->getPeriodicOperationFrequency(), isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
+				owner->getPeriodicOperationFrequency(), isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
-    return HasReturnvaluesIF::RETURN_OK;
+	hkReceiversMap.push_back(hkReceiver);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
-        bool isDiagnostics, bool reportingEnabled,
-        object_id_t packetDestination) {
-    AcceptsHkPacketsIF* hkReceiverObject =
-            objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-    if(hkReceiverObject == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalDataPoolManager::subscribeForPeriodicPacket:"
-                << " Invalid receiver!"<< std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+		bool isDiagnostics, bool reportingEnabled,
+		object_id_t packetDestination) {
+	AcceptsHkPacketsIF* hkReceiverObject =
+			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	if(hkReceiverObject == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
 
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataId.sid = sid;
-    hkReceiver.reportingType = ReportingType::UPDATE_HK;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataId.sid = sid;
+	hkReceiver.reportingType = ReportingType::UPDATE_HK;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
 
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet != nullptr) {
-        dataSet->setReportingEnabled(true);
-        dataSet->setDiagnostic(isDiagnostics);
-    }
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	if(dataSet != nullptr) {
+		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
+		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
-        const uint32_t setId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::DATA_SET;
-    hkReceiver.dataId.sid = sid_t(this->getOwner()->getObjectId(), setId);
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const uint32_t setId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::DATA_SET;
+	hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
-        const lp_id_t localPoolId, object_id_t destinationObject,
-        MessageQueueId_t targetQueueId, bool generateSnapshot) {
-    struct HkReceiver hkReceiver;
-    hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-    hkReceiver.dataId.localPoolId = localPoolId;
-    hkReceiver.destinationQueue = targetQueueId;
-    hkReceiver.objectId = destinationObject;
-    if(generateSnapshot) {
-        hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-    }
-    else {
-        hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-    }
+		const lp_id_t localPoolId, object_id_t destinationObject,
+		MessageQueueId_t targetQueueId, bool generateSnapshot) {
+	struct HkReceiver hkReceiver;
+	hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
+	hkReceiver.dataId.localPoolId = localPoolId;
+	hkReceiver.destinationQueue = targetQueueId;
+	hkReceiver.objectId = destinationObject;
+	if(generateSnapshot) {
+		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
+	}
+	else {
+		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
+	}
 
-    hkReceiversMap.push_back(hkReceiver);
+	hkReceiversMap.push_back(hkReceiver);
 
-    handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-    return HasReturnvaluesIF::RETURN_OK;
+	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
-        DataId dataId) {
-    if(hkUpdateResetList == nullptr) {
-        hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-    }
+		DataId dataId) {
+	if(hkUpdateResetList == nullptr) {
+		hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
+	}
 
-    for(auto& updateResetStruct: *hkUpdateResetList) {
-        if(dataType == DataType::DATA_SET) {
-            if(updateResetStruct.dataId.sid == dataId.sid) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
-        else {
-            if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-                updateResetStruct.updateCounter++;
-                updateResetStruct.currentUpdateCounter++;
-                return;
-            }
-        }
+	for(auto& updateResetStruct: *hkUpdateResetList) {
+		if(dataType == DataType::DATA_SET) {
+			if(updateResetStruct.dataId.sid == dataId.sid) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
+		else {
+			if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
+				updateResetStruct.updateCounter++;
+				updateResetStruct.currentUpdateCounter++;
+				return;
+			}
+		}
 
-    }
-    HkUpdateResetHelper hkUpdateResetHelper;
-    hkUpdateResetHelper.currentUpdateCounter = 1;
-    hkUpdateResetHelper.updateCounter = 1;
-    hkUpdateResetHelper.dataType = dataType;
-    if(dataType == DataType::DATA_SET) {
-        hkUpdateResetHelper.dataId.sid = dataId.sid;
-    }
-    else {
-        hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-    }
-    hkUpdateResetList->push_back(hkUpdateResetHelper);
+	}
+	HkUpdateResetHelper hkUpdateResetHelper;
+	hkUpdateResetHelper.currentUpdateCounter = 1;
+	hkUpdateResetHelper.updateCounter = 1;
+	hkUpdateResetHelper.dataType = dataType;
+	if(dataType == DataType::DATA_SET) {
+		hkUpdateResetHelper.dataId.sid = dataId.sid;
+	}
+	else {
+		hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
+	}
+	hkUpdateResetList->push_back(hkUpdateResetHelper);
 }
 
 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-        CommandMessage* message) {
-    Command_t command = message->getCommand();
-    sid_t sid = HousekeepingMessage::getSid(message);
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(command) {
-    // Houskeeping interface handling.
-    case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, true);
-        break;
-    }
+		CommandMessage* message) {
+	Command_t command = message->getCommand();
+	sid_t sid = HousekeepingMessage::getSid(message);
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+	switch(command) {
+	// Houskeeping interface handling.
+	case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, true);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, true);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, true);
+		break;
+	}
 
-    case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, true, false);
-        break;
-    }
+	case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, true, false);
+		break;
+	}
 
-    case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-        result = togglePeriodicGeneration(sid, false, false);
-        break;
-    }
+	case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+		result = togglePeriodicGeneration(sid, false, false);
+		break;
+	}
 
-    case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, true);
-    case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES):
-                        return generateSetStructurePacket(sid, false);
-    case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
-    case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-        float newCollIntvl = 0;
-        HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-                &newCollIntvl);
-        if(command == HousekeepingMessage::
-                MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-            result = changeCollectionInterval(sid, newCollIntvl, true);
-        }
-        else {
-            result = changeCollectionInterval(sid, newCollIntvl, false);
-        }
-        break;
-    }
+	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, true);
+	}
 
-    case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-    case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-        LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-        if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-                and dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-                and not dataSet->isDiagnostics()) {
-            return WRONG_HK_PACKET_TYPE;
-        }
-        return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-                dataSet, true);
-    }
+	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+		return generateSetStructurePacket(sid, false);
+	}
+	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
+	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+		float newCollIntvl = 0;
+		HousekeepingMessage::getCollectionIntervalModificationCommand(message,
+				&newCollIntvl);
+		if(command == HousekeepingMessage::
+				MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
+			result = changeCollectionInterval(sid, newCollIntvl, true);
+		}
+		else {
+			result = changeCollectionInterval(sid, newCollIntvl, false);
+		}
+		break;
+	}
 
-    // Notification handling.
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-        owner->handleChangedDataset(sid);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-        lp_id_t locPoolId = HousekeepingMessage::
-                getUpdateNotificationVariableCommand(message);
-        owner->handleChangedPoolVariable(locPoolId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-        store_address_t storeId;
-        HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-        owner->handleChangedDataset(sid, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-        store_address_t storeId;
-        lp_id_t localPoolId = HousekeepingMessage::
-                getUpdateSnapshotVariableCommand(message, &storeId);
-        owner->handleChangedPoolVariable(localPoolId, storeId);
-        return HasReturnvaluesIF::RETURN_OK;
-    }
+	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
+	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
+		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
+				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
+				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+			return WRONG_HK_PACKET_TYPE;
+		}
+		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
+				dataSet, true);
+	}
 
-    default:
-        return CommandMessageIF::UNKNOWN_COMMAND;
-    }
+	// Notification handling.
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
+		owner->handleChangedDataset(sid);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
+		lp_id_t locPoolId = HousekeepingMessage::
+				getUpdateNotificationVariableCommand(message);
+		owner->handleChangedPoolVariable(locPoolId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
+		store_address_t storeId;
+		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
+		owner->handleChangedDataset(sid, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
+		store_address_t storeId;
+		lp_id_t localPoolId = HousekeepingMessage::
+				getUpdateSnapshotVariableCommand(message, &storeId);
+		owner->handleChangedPoolVariable(localPoolId, storeId);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
 
-    CommandMessage reply;
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-    }
-    else {
-        HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-    }
-    hkQueue->sendMessage(hkDestinationId, &reply);
-    return result;
+	default:
+		return CommandMessageIF::UNKNOWN_COMMAND;
+	}
+
+	CommandMessage reply;
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+	}
+	else {
+		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+	}
+	hkQueue->sendMessage(hkDestinationId, &reply);
+	return result;
 }
 
 ReturnValue_t LocalDataPoolManager::printPoolEntry(
-        lp_id_t localPoolId) {
-    auto poolIter = localPoolMap.find(localPoolId);
-    if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "HousekeepingManager::fechPoolEntry:"
-                << " Pool entry not found." << std::endl;
-#endif
-        return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
-    }
-    poolIter->second->print();
-    return HasReturnvaluesIF::RETURN_OK;
+		lp_id_t localPoolId) {
+	auto poolIter = localPoolMap.find(localPoolId);
+	if (poolIter == localPoolMap.end()) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
+				localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
+	}
+	poolIter->second->print();
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 MutexIF* LocalDataPoolManager::getMutexHandle() {
-    return mutex;
+	return mutex;
 }
 
 HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
-    return owner;
+	return owner;
 }
 
 ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-        LocalPoolDataSetBase* dataSet, bool forDownlink,
-        MessageQueueId_t destination) {
-    if(dataSet == nullptr) {
-        // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found or dataset not assigned!" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		LocalPoolDataSetBase* dataSet, bool forDownlink,
+		MessageQueueId_t destination) {
+	if(dataSet == nullptr) {
+		// Configuration error.
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
-    store_address_t storeId;
-    HousekeepingPacketDownlink hkPacket(sid, dataSet);
-    size_t serializedSize = 0;
-    ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-            forDownlink, &serializedSize);
-    if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-        return result;
-    }
+	store_address_t storeId;
+	HousekeepingPacketDownlink hkPacket(sid, dataSet);
+	size_t serializedSize = 0;
+	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
+			forDownlink, &serializedSize);
+	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
+		return result;
+	}
 
-    // and now we set a HK message and send it the HK packet destination.
-    CommandMessage hkMessage;
-    if(dataSet->isDiagnostics()) {
-        HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-    }
+	// and now we set a HK message and send it the HK packet destination.
+	CommandMessage hkMessage;
+	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
+		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+	}
 
-    if(hkQueue == nullptr) {
-        return QUEUE_OR_DESTINATION_NOT_SET;
-    }
-    if(destination == MessageQueueIF::NO_QUEUE) {
-        if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-            // error, all destinations invalid
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        destination = hkDestinationId;
-    }
+	if(hkQueue == nullptr) {
+		// error, no queue available to send packet with.
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateHousekeepingPacket",
+				QUEUE_OR_DESTINATION_INVALID);
+		return QUEUE_OR_DESTINATION_INVALID;
+	}
+	if(destination == MessageQueueIF::NO_QUEUE) {
+		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
+			// error, all destinations invalid
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"generateHousekeepingPacket",
+					QUEUE_OR_DESTINATION_INVALID);
+		}
+		destination = hkDestinationId;
+	}
 
-    return hkQueue->sendMessage(destination, &hkMessage);
+	return hkQueue->sendMessage(destination, &hkMessage);
 }
 
 ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-        HousekeepingPacketDownlink& hkPacket,
-        store_address_t& storeId, bool forDownlink,
-        size_t* serializedSize) {
-    uint8_t* dataPtr = nullptr;
-    const size_t maxSize = hkPacket.getSerializedSize();
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            maxSize, &dataPtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
+		HousekeepingPacketDownlink& hkPacket,
+		store_address_t& storeId, bool forDownlink,
+		size_t* serializedSize) {
+	uint8_t* dataPtr = nullptr;
+	const size_t maxSize = hkPacket.getSerializedSize();
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			maxSize, &dataPtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
 
-    if(forDownlink) {
-        return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-                SerializeIF::Endianness::BIG);
-    }
-    return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-            SerializeIF::Endianness::MACHINE);
+	if(forDownlink) {
+		return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+				SerializeIF::Endianness::BIG);
+	}
+	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
+			SerializeIF::Endianness::MACHINE);
 }
 
 void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
-        uint8_t nonDiagInvlFactor) {
-    this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
+		uint8_t nonDiagInvlFactor) {
+	this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
 }
 
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-    sid_t sid = receiver.dataId.sid;
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(not dataSet->getReportingEnabled()) {
-        return;
-    }
+	sid_t sid = receiver.dataId.sid;
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // Configuration error.
-        return;
-    }
+	if(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
+		return;
+	}
 
-    if(not dataSet->periodicHelper->checkOpNecessary()) {
-        return;
-    }
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
-    ReturnValue_t result = generateHousekeepingPacket(
-            sid, dataSet, true);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        // configuration error
+	if(periodicHelper == nullptr) {
+		// Configuration error.
+		return;
+	}
+
+	if(periodicHelper->checkOpNecessary()) {
+		return;
+	}
+
+	ReturnValue_t result = generateHousekeepingPacket(
+			sid, dataSet, true);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		// configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "LocalDataPoolManager::performHkOperation:"
-                << "0x" << std::hex << std::setfill('0') << std::setw(8)
-                << owner->getObjectId() << " Error generating "
-                << "HK packet" << std::setfill(' ') << std::dec << std::endl;
+		sif::warning << "LocalDataPoolManager::performHkOperation: "
+				<< "HK generation failed." << std::endl;
+#else
+		sif::printWarning("LocalDataPoolManager::performHkOperation: "
+				"HK generation failed.\n");
 #endif
-    }
+	}
 }
 
 
 ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-        bool enable, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if((dataSet->isDiagnostics() and not isDiagnostics) or
-            (not dataSet->isDiagnostics() and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		bool enable, bool isDiagnostics) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
+			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if((dataSet->getReportingEnabled() and enable) or
-            (not dataSet->getReportingEnabled() and not enable)) {
-        return REPORTING_STATUS_UNCHANGED;
-    }
+	if((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
+			(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
+		return REPORTING_STATUS_UNCHANGED;
+	}
 
-    dataSet->setReportingEnabled(enable);
-    return HasReturnvaluesIF::RETURN_OK;
+	LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-        float newCollectionInterval, bool isDiagnostics) {
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+		float newCollectionInterval, bool isDiagnostics) {
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    if(dataSet->periodicHelper == nullptr) {
-        // config error
-        return PERIODIC_HELPER_INVALID;
-    }
+	PeriodicHousekeepingHelper* periodicHelper =
+			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
 
-    dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval);
-    return HasReturnvaluesIF::RETURN_OK;
+	if(periodicHelper == nullptr) {
+		// config error
+		return PERIODIC_HELPER_INVALID;
+	}
+
+	periodicHelper->changeCollectionInterval(newCollectionInterval);
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-        bool isDiagnostics) {
-    // Get and check dataset first.
-    LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-    if(dataSet == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HousekeepingManager::generateHousekeepingPacket:"
-                << " Set ID not found" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+		bool isDiagnostics) {
+	// Get and check dataset first.
+	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
+	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+	if(dataSet == nullptr) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"performPeriodicHkGeneration",
+				DATASET_NOT_FOUND);
+		return DATASET_NOT_FOUND;
+	}
 
 
-    bool targetIsDiagnostics = dataSet->isDiagnostics();
-    if((targetIsDiagnostics and not isDiagnostics) or
-            (not targetIsDiagnostics and isDiagnostics)) {
-        return WRONG_HK_PACKET_TYPE;
-    }
+	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
+	if((targetIsDiagnostics and not isDiagnostics) or
+			(not targetIsDiagnostics and isDiagnostics)) {
+		return WRONG_HK_PACKET_TYPE;
+	}
 
-    bool valid = dataSet->isValid();
-    bool reportingEnabled = dataSet->getReportingEnabled();
-    float collectionInterval =
-            dataSet->periodicHelper->getCollectionIntervalInSeconds();
+	bool valid = dataSet->isValid();
+	bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
+	float collectionInterval = LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->
+			getCollectionIntervalInSeconds();
 
-    // Generate set packet which can be serialized.
-    HousekeepingSetPacket setPacket(sid,
-            reportingEnabled, valid, collectionInterval, dataSet);
-    size_t expectedSize = setPacket.getSerializedSize();
-    uint8_t* storePtr = nullptr;
-    store_address_t storeId;
-    ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-            expectedSize,&storePtr);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateHousekeepingPacket: "
-                << "Could not get free element from IPC store." << std::endl;
-#endif
-        return result;
-    }
+	// Generate set packet which can be serialized.
+	HousekeepingSetPacket setPacket(sid,
+			reportingEnabled, valid, collectionInterval, dataSet);
+	size_t expectedSize = setPacket.getSerializedSize();
+	uint8_t* storePtr = nullptr;
+	store_address_t storeId;
+	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
+			expectedSize,&storePtr);
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		printWarningOrError(sif::OutputTypes::OUT_ERROR,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Could not get free element from IPC store.");
+		return result;
+	}
 
-    // Serialize set packet into store.
-    size_t size = 0;
-    result = setPacket.serialize(&storePtr, &size, expectedSize,
-            SerializeIF::Endianness::BIG);
-    if(expectedSize != size) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "HousekeepingManager::generateSetStructurePacket: "
-                << "Expected size is not equal to serialized size" << std::endl;
-#endif
-    }
+	// Serialize set packet into store.
+	size_t size = 0;
+	result = setPacket.serialize(&storePtr, &size, expectedSize,
+			SerializeIF::Endianness::BIG);
+	if(expectedSize != size) {
+		printWarningOrError(sif::OutputTypes::OUT_WARNING,
+				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
+				"Expected size is not equal to serialized size");
+	}
 
-    // Send structure reporting reply.
-    CommandMessage reply;
-    if(isDiagnostics) {
-        HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-                sid, storeId);
-    }
-    else {
-        HousekeepingMessage::setHkStuctureReportReply(&reply,
-                sid, storeId);
-    }
+	// Send structure reporting reply.
+	CommandMessage reply;
+	if(isDiagnostics) {
+		HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
+				sid, storeId);
+	}
+	else {
+		HousekeepingMessage::setHkStuctureReportReply(&reply,
+				sid, storeId);
+	}
 
-    hkQueue->reply(&reply);
-    return result;
+	hkQueue->reply(&reply);
+	return result;
+}
+
+void LocalDataPoolManager::clearReceiversList() {
+	// clear the vector completely and releases allocated memory.
+	HkReceivers().swap(hkReceiversMap);
+}
+
+MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
+	return this->mutex;
+}
+
+object_id_t LocalDataPoolManager::getCreatorObjectId() const {
+	return owner->getObjectId();
+	//return owner->getObjectId();
+}
+
+void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
+		const char* functionName, ReturnValue_t error, const char* errorPrint) {
+	if(errorPrint == nullptr) {
+		if(error == DATASET_NOT_FOUND) {
+			errorPrint = "Dataset not found";
+		}
+		else if(error == POOLOBJECT_NOT_FOUND) {
+			errorPrint = "Pool Object not found";
+		}
+		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
+			if(outputType == sif::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic error";
+			}
+		}
+		else if(error == QUEUE_OR_DESTINATION_INVALID) {
+			errorPrint = "Queue or destination not set";
+		}
+		else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+			errorPrint = "Pool entry type conflict";
+		}
+		else if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+			errorPrint = "Pool entry not found";
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(outputType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+	else if(outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "LocalDataPoolManager::" << functionName
+				<< ": Object ID " << std::setw(8) << std::setfill('0')
+				<< std::hex << owner->getObjectId() << " | " << errorPrint
+				<< std::dec << std::setfill(' ') << std::endl;
+#else
+		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
+				owner->getObjectId(), errorPrint);
+#endif
+	}
+}
+
+LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
+	return this;
 }
diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 0e98b90c..580ac8b9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -1,8 +1,10 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
 
-#include "HasLocalDataPoolIF.h"
+#include "ProvidesDataPoolSubscriptionIF.h"
+#include "AccessLocalPoolF.h"
 
+#include "../serviceinterface/ServiceInterface.h"
 #include "../housekeeping/HousekeepingPacketDownlink.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
@@ -15,6 +17,7 @@
 #include "../ipc/MutexHelper.h"
 
 #include <map>
+#include <vector>
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -22,6 +25,8 @@ void setStaticFrameworkObjectIds();
 
 class LocalPoolDataSetBase;
 class HousekeepingPacketUpdate;
+class HasLocalDataPoolIF;
+class LocalDataPool;
 
 /**
  * @brief 		This class is the managing instance for the local data pool.
@@ -47,19 +52,23 @@ class HousekeepingPacketUpdate;
  * Each pool entry has a valid state too.
  * @author 		R. Mueller
  */
-class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
-	friend class LocalPoolDataSetBase;
+class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
+		public AccessPoolManagerIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
+	//! Some classes using the pool manager directly need to access class internals of the
+	//! manager. The attorney provides granular control of access to these internals.
+	friend class LocalDpManagerAttorney;
 public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
 
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x0);
+    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
+
+    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
+    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
+    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
+    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
+    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
 
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(0x01);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(0x02);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(0x03);
 
     /**
      * This constructor is used by a class which wants to implement
@@ -116,7 +125,7 @@ public:
 	 */
 	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
 			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination);
+			object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for the  generation of packets if the dataset
@@ -130,7 +139,7 @@ public:
 	 */
     ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
             bool isDiagnostics,
-            object_id_t packetDestination = defaultHkDestination);
+            object_id_t packetDestination = defaultHkDestination) override;
 
 	/**
 	 * @brief   Subscribe for a notification message which will be sent
@@ -149,7 +158,7 @@ public:
 	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
 	        object_id_t destinationObject,
 	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot);
+	        bool generateSnapshot) override;
 
     /**
      * @brief   Subscribe for an notification message which will be sent if a
@@ -168,7 +177,9 @@ public:
     ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
             object_id_t destinationObject,
             MessageQueueId_t targetQueueId,
-            bool generateSnapshot);
+            bool generateSnapshot) override;
+
+    MutexIF* getLocalPoolMutex() override;
 
 	/**
 	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
@@ -247,8 +258,18 @@ public:
     LocalDataPoolManager(const LocalDataPoolManager &) = delete;
     LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
 
+    /**
+     * This function can be used to clear the receivers list. This is
+     * intended for test functions and not for regular operations, because
+     * the insertion operations allocate dynamically.
+     */
+    void clearReceiversList();
+
+    object_id_t getCreatorObjectId() const;
+
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
 private:
-    LocalDataPool localPoolMap;
+    localpool::DataPool localPoolMap;
     //! Every housekeeping data manager has a mutex to protect access
     //! to it's data pool.
     MutexIF* mutex = nullptr;
@@ -367,6 +388,11 @@ private:
             ReturnValue_t& status);
 	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
 	        store_address_t& storeId);
+
+	void printWarningOrError(sif::OutputTypes outputType,
+			const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 
@@ -375,20 +401,16 @@ ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 		PoolEntry<T> **poolEntry) {
 	auto poolIter = localPoolMap.find(localPoolId);
 	if (poolIter == localPoolMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
-		        "not found." << std::endl;
-#endif
-		return HasLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    			localpool::POOL_ENTRY_NOT_FOUND);
+		return localpool::POOL_ENTRY_NOT_FOUND;
 	}
 
 	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
 	if(*poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "HousekeepingManager::fetchPoolEntry:"
-				" Pool entry not found." << std::endl;
-#endif
-		return HasLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
+    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
+    			localpool::POOL_ENTRY_TYPE_CONFLICT);
+		return localpool::POOL_ENTRY_TYPE_CONFLICT;
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index dbe34dfd..5343a9c9 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -1,4 +1,8 @@
 #include "LocalPoolDataSetBase.h"
+#include "HasLocalDataPoolIF.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
+
+#include "../serviceinterface/ServiceInterface.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -15,15 +19,22 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
                 << "invalid!" << std::endl;
-#endif
+#else
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
         return;
     }
-    hkManager = hkOwner->getHkManagerHandle();
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+
+    if(poolManager != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+    }
+
     this->sid.objectId = hkOwner->getObjectId();
     this->sid.ownerSetId = setId;
 
-    mutex = MutexFactory::instance()->createMutex();
-
     // Data creators get a periodic helper for periodic HK data generation.
     if(periodicHandling) {
         periodicHelper = new PeriodicHousekeepingHelper(this);
@@ -34,23 +45,34 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
         PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
-    	hkManager = hkOwner->getHkManagerHandle();
+    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
     }
-    this->sid = sid;
 
-    mutex = MutexFactory::instance()->createMutex();
+    this->sid = sid;
 }
 
+LocalPoolDataSetBase::LocalPoolDataSetBase(
+		PoolVariableIF **registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
+}
+
+
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
+	if(periodicHelper != nullptr) {
+		delete periodicHelper;
+	}
 }
 
-ReturnValue_t LocalPoolDataSetBase::lockDataPool(uint32_t timeoutMs) {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->lockMutex(MutexIF::TimeoutType::WAITING, timeoutMs);
+ReturnValue_t LocalPoolDataSetBase::lockDataPool(
+		MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -128,9 +150,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(hkManager != nullptr) {
-	    MutexIF* mutex = hkManager->getMutexHandle();
-	    return mutex->unlockMutex();
+	if(mutexIfSingleDataCreator != nullptr) {
+	    return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -150,9 +171,12 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
                 size, maxSize, streamEndianness);
         if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
-                    " error!" << std::endl;
-#endif
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		<< "Serialization error!" << std::endl;
+#else
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+            		"Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
             return result;
         }
     }
@@ -211,8 +235,11 @@ ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
     if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
                 << std::endl;
+#else
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+        		"Invalid position!\n\r");
 #endif
         return;
     }
@@ -244,14 +271,10 @@ void LocalPoolDataSetBase::initializePeriodicHelper(
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
     this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    // TODO: Make this configurable?
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 20);
     return changed;
 }
 
@@ -273,12 +296,10 @@ bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    MutexHelper(mutex, MutexIF::TimeoutType::WAITING, 5);
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
             registeredVariables[idx] -> setValid(valid);
@@ -287,8 +308,9 @@ void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     this->valid = valid;
 }
 
-void LocalPoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, uint32_t mutexTimeout) {
-	PoolDataSetBase::setReadCommitProtectionBehaviour(protectEveryReadCommit,
-			mutexTimeout);
+object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
+	if(poolManager != nullptr) {
+		return poolManager->getCreatorObjectId();
+	}
+	return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index d9b6a221..5f17eeb6 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -1,16 +1,16 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
 
-#include "HasLocalDataPoolIF.h"
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
 
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolDataSetBase.h"
-#include "../serialize/SerializeIF.h"
 
 #include <vector>
 
 class LocalDataPoolManager;
+class HasLocalDataPoolIF;
 class PeriodicHousekeepingHelper;
 
 /**
@@ -43,7 +43,7 @@ class PeriodicHousekeepingHelper;
  */
 class LocalPoolDataSetBase: public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalDataPoolManager;
+	friend class LocalPoolDataSetAttorney;
 	friend class PeriodicHousekeepingHelper;
 public:
 	/**
@@ -57,8 +57,11 @@ public:
 	        const size_t maxNumberOfVariables, bool periodicHandling = true);
 
 	/**
-	 * @brief	Constructor for users of local pool data.
+	 * @brief	Constructor for users of the local pool data, which need
+	 *          to access data created by one (!) HK manager.
 	 * @details
+	 * Unlike the first constructor, no component for periodic handling
+	 * will be initiated.
 	 * @param sid Unique identifier of dataset consisting of object ID and
 	 * set ID.
 	 * @param registeredVariablesArray
@@ -67,6 +70,28 @@ public:
 	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
 	        const size_t maxNumberOfVariables);
 
+	/**
+	 * @brief	Simple constructor, if the dataset is not the owner by
+	 * 			a class with a HK manager.
+	 * @details
+	 * This constructor won't create components required for periodic handling
+	 * and it also won't try to deduce the HK manager because no SID is
+	 * supplied. This function should therefore be called by classes which need
+	 * to access pool variables from different creators.
+	 *
+	 * If the class is intended to access pool variables from different
+	 * creators, the third argument should be set to true. The mutex
+	 * properties can be set with #setReadCommitProtectionBehaviour .
+	 * @param registeredVariablesArray
+	 * @param maxNumberOfVariables
+	 * @param protectEveryReadCommitCall If the pool variables are created by
+	 * multiple creators, this flag can be set to protect all read and
+	 * commit calls separately.
+	 */
+	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+	        const size_t maxNumberOfVariables,
+			bool protectEveryReadCommitCall = true);
+
 	/**
 	 * @brief	The destructor automatically manages writing the valid
 	 * 			information of variables.
@@ -77,16 +102,6 @@ public:
 	 */
 	~LocalPoolDataSetBase();
 
-	/**
-	 * If the data is pulled from different local data pools, every read and
-	 * commit call should be mutex protected for thread safety.
-	 * This can be specified with the second parameter.
-	 * @param dataCreator
-	 * @param protectEveryReadCommit
-	 */
-	void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-			uint32_t mutexTimeout = 20);
-
 	void setValidityBufferGeneration(bool withValidityBuffer);
 
 	sid_t getSid() const;
@@ -136,10 +151,11 @@ public:
 	void setChanged(bool changed) override;
 	bool hasChanged() const override;
 
+	object_id_t getCreatorObjectId();
 protected:
 	sid_t sid;
-	uint32_t mutexTimeout = 20;
-	MutexIF* mutex = nullptr;
+	//! This mutex is used if the data is created by one object only.
+	MutexIF* mutexIfSingleDataCreator = nullptr;
 
 	bool diagnostic = false;
 	void setDiagnostic(bool diagnostics);
@@ -183,7 +199,9 @@ protected:
 	 * @details
 	 * It makes use of the lockDataPool method offered by the DataPool class.
 	 */
-	ReturnValue_t lockDataPool(uint32_t timeoutMs) override;
+	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs) override;
+
 	/**
 	 * @brief	This is a small helper function to facilitate
 	 * 			unlocking the global data pool
@@ -192,8 +210,6 @@ protected:
 	 */
 	ReturnValue_t unlockDataPool() override;
 
-	LocalDataPoolManager* hkManager = nullptr;
-
 	/**
 	 * Set n-th bit of a byte, with n being the position from 0
 	 * (most significant bit) to 7 (least significant bit)
@@ -202,6 +218,7 @@ protected:
 	bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
 	PeriodicHousekeepingHelper* periodicHelper = nullptr;
+	LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index 4b57dede..bd1bfa0f 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,81 +1,128 @@
+#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
+#include "internal/HasLocalDpIFUserAttorney.h"
+#include "HasLocalDataPoolIF.h"
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+#include "../objectmanager/ObjectManagerIF.h"
+
+LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
+		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+		localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    if(hkOwner == nullptr) {
+	}
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-                << "owner is a invalid!" << std::endl;
+		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+				<< "owner is a invalid!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if (dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+
+	if (dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode): localPoolId(poolId),
-        readWriteMode(setReadWriteMode) {
-    if(poolId == PoolVariableIF::NO_PARAMETER) {
+LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
+		pool_rwm_t setReadWriteMode):
+				localPoolId(poolId), readWriteMode(setReadWriteMode) {
+	if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+				<< "which is the NO_PARAMETER value!" << std::endl;
 #endif
-    }
-    HasLocalDataPoolIF* hkOwner =
-            objectManager->get<HasLocalDataPoolIF>(poolOwner);
-    if(hkOwner == nullptr) {
+	}
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
+	if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+		sif::error << "LocalPoolVariable: The supplied pool owner did not "
+				<< "implement the correct interface"
+				<< " HasLocalDataPoolIF!" << std::endl;
 #endif
-        return;
-    }
-    hkManager = hkOwner->getHkManagerHandle();
-    if(dataSet != nullptr) {
-        dataSet->registerVariable(this);
-    }
+		return;
+	}
+	//hkManager = hkOwner->getHkManagerHandle();
+	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
+	hkManager = poolManAccessor->getHkManagerHandle();
+	if(dataSet != nullptr) {
+		dataSet->registerVariable(this);
+	}
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-    return readWriteMode;
+	return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-    return valid;
+	return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-    this->valid = valid;
+	this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-    return localPoolId;
+	return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-    this->localPoolId = poolId;
+	this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 	this->readWriteMode = newReadWriteMode;
 }
+
+void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
+		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+#if FSFW_DISABLE_PRINTOUT == 0
+	const char* type = nullptr;
+	if(read) {
+		type = "read";
+	}
+	else {
+		type = "commit";
+	}
+
+	const char* errMsg = nullptr;
+	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+		errMsg = "Pool entry not found";
+	}
+	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+		errMsg = "Pool entry type conflict";
+	}
+	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+		errMsg = "Pool variable wrong read-write mode";
+	}
+	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+		errMsg = "Pool entry invalid";
+	}
+	else {
+		errMsg = "Unknown error code";
+	}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+			<< " LPID: " << lpId << std::endl;
+#else
+	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+			variableType, type, errMsg, objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+}
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 7165fc24..2dddc246 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,10 +1,15 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
+#include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
+class LocalDataPoolManager;
+class DataSetIF;
+class HasLocalDataPoolIF;
 
 class LocalPoolObjectBase: public PoolVariableIF,
         public HasReturnvaluesIF,
@@ -54,8 +59,10 @@ protected:
     ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
 
     //! @brief  Pointer to the class which manages the HK pool.
-    LocalDataPoolManager* hkManager;
+    LocalDataPoolManager* hkManager = nullptr;
 
+	void reportReadCommitError(const char* variableType,
+			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
 
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 84be54b1..859c8f08 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -4,9 +4,12 @@
 #include "LocalPoolObjectBase.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
+#include "AccessLocalPoolF.h"
+#include "internal/LocalDpManagerAttorney.h"
 
 #include "../datapool/PoolVariableIF.h"
 #include "../datapool/DataSetIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
 
@@ -105,7 +108,9 @@ public:
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 *
 	 */
-	ReturnValue_t read(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -115,8 +120,21 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit function can be used to set the pool variable valid
+	 * 			as well.
+	 * @param setValid
+	 * @param timeoutType
+	 * @param timeoutMs
+	 * @return
+	 */
+	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 	LocalPoolVariable<T> &operator=(const T& newValue);
 	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
@@ -163,8 +181,6 @@ protected:
 	friend std::ostream& operator<< (std::ostream &out,
 			const LocalPoolVariable<U> &var);
 #endif
-
-private:
 };
 
 #include "LocalPoolVariable.tpp"
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index cd5117c8..6fd34171 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -24,73 +24,91 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK or poolEntry == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				<< std::hex << std::setw(8) << std::setfill('0')
-				<< hkManager->getOwner() << " and lp ID " << localPoolId
-				<< std::dec << " failed." << std::setfill(' ') <<  std::endl;
-#endif
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	if(result != RETURN_OK) {
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
+
+	// Actually this should never happen..
+//	if(poolEntry->address == nullptr) {
+//		result = PoolVariableIF::INVALID_POOL_ENTRY;
+//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+//		reportReadCommitError("LocalPoolVariable", result,
+//				false, ownerObjectId, localPoolId);
+//		return result;
+//	}
+
+	this->value = *(poolEntry->getDataPtr());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(setValid);
+	return commit(timeoutType, timeoutMs);
+}
+
+template<typename T>
+inline ReturnValue_t LocalPoolVariable<T>::commit(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVariable: Invalid read write "
-				 "mode for commit() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
+
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
-#endif
+		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVariable", result,
+				false, ownerObjectId, localPoolId);
 		return result;
 	}
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
+
+	*(poolEntry->getDataPtr()) = this->value;
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size,
+		SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
@@ -121,7 +139,8 @@ inline LocalPoolVariable<T>::operator T() const {
 }
 
 template<typename T>
-inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
+		const T& newValue) {
     value = newValue;
     return *this;
 }
@@ -134,7 +153,8 @@ inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
 }
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(
+		const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
@@ -145,7 +165,8 @@ inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
@@ -156,7 +177,8 @@ inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(
+		const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
@@ -167,7 +189,8 @@ inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 
 
 template<typename T>
-inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(
+		const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 58face3c..74255605 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -2,12 +2,14 @@
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
 
 #include "LocalPoolObjectBase.h"
+#include "internal/LocalDpManagerAttorney.h"
+
 #include "../datapool/DataSetIF.h"
 #include "../datapool/PoolEntry.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 
 /**
@@ -100,8 +102,8 @@ public:
 		return vectorSize;
 	}
 
-	T& operator [](int i);
-	const T &operator [](int i) const;
+	T& operator [](size_t i);
+	const T &operator [](size_t i) const;
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t maxSize,
@@ -123,7 +125,10 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t read(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
+
 	/**
 	 * @brief	The commit call copies the array values back to the data pool.
 	 * @details
@@ -133,7 +138,17 @@ public:
 	 * It is recommended to use DataSets to read and commit multiple variables
 	 * at once to avoid the overhead of unnecessary lock und unlock operations.
 	 */
-	ReturnValue_t commit(uint32_t lockTimeout = MutexIF::BLOCKING) override;
+	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20) override;
+
+	/**
+	 * @brief	This commit call also sets the validity of the pool entry.
+	 * @details
+	 */
+	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
 
 protected:
 	/**
@@ -157,12 +172,12 @@ protected:
 
 private:
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 	// std::ostream is the type for object std::cout
 	template <typename U, uint16_t otherSize>
 	friend std::ostream& operator<< (std::ostream &out,
 	        const LocalPoolVector<U, otherSize> &var);
-
+#endif
 
 };
 
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index 5c3b0ce0..acffebee 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -24,98 +24,106 @@ inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
 				dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for read() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	memset(this->value, 0, vectorSize * sizeof(T));
 
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << "and lp ID 0x" << localPoolId <<
-				std::dec << " failed." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+				localPoolId);
 		return result;
 	}
-	std::memcpy(this->value, poolEntry->address, poolEntry->getByteSize());
-	this->valid = poolEntry->valid;
+	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+	this->valid = poolEntry->getValid();
 	return RETURN_OK;
 }
 
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(valid);
+	return commit(timeoutType, timeoutMs);
+}
+
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		uint32_t lockTimeout) {
-	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
-			lockTimeout);
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
 	return commitWithoutLock();
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "LocalPoolVar: Invalid read write "
-				"mode for commit() call." << std::endl;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector",
+				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+				localPoolId);
 		return PoolVariableIF::INVALID_READ_WRITE_MODE;
 	}
 	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+			&poolEntry);
 	if(result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PoolVector: Read of local pool variable of object "
-				"0x" << std::hex << std::setw(8) << std::setfill('0') <<
-				hkManager->getOwner() << " and lp ID 0x" << localPoolId <<
-				std::dec << " failed.\n" << std::flush;
-#endif
+		object_id_t targetObjectId = hkManager->getCreatorObjectId();
+		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+				localPoolId);
 		return result;
 	}
-	std::memcpy(poolEntry->address, this->value, poolEntry->getByteSize());
-	poolEntry->valid = this->valid;
+	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+	poolEntry->setValid(this->valid);
 	return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](int i) {
-	if(i <= vectorSize) {
+inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
-	return value[i];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
-	if(i <= vectorSize) {
+inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
+	if(i < vectorSize) {
 		return value[i];
 	}
 	// If this happens, I have to set some value. I consider this
 	// a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "LocalPoolVector: Invalid index. Setting or returning"
+	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
 			" last value!" << std::endl;
+#else
+	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+			" last value!\n");
 #endif
-	return value[i];
+	return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
@@ -153,6 +161,7 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
 	return result;
 }
 
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T, uint16_t vectorSize>
 inline std::ostream& operator<< (std::ostream &out,
         const LocalPoolVector<T, vectorSize> &var) {
@@ -166,5 +175,6 @@ inline std::ostream& operator<< (std::ostream &out,
     out << "]";
     return out;
 }
+#endif
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 0510dbb5..6a816c1f 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -1,7 +1,8 @@
 #ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 #define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
 
-#include <fsfw/datapoollocal/LocalPoolDataSetBase.h>
+#include "LocalPoolDataSetBase.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
 /**
@@ -9,13 +10,17 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject, uint32_t mutexTimeout = 20):
+	PoolReadHelper(ReadCommitIF* readObject,
+			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+			uint32_t mutexTimeout = 20):
 			readObject(readObject), mutexTimeout(mutexTimeout) {
 		if(readObject != nullptr) {
-			readResult = readObject->read(mutexTimeout);
-#if FSFW_PRINT_VERBOSITY_LEVEL == 1
+			readResult = readObject->read(timeoutType, mutexTimeout);
+#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 */
 		}
@@ -27,7 +32,7 @@ public:
 
 	~PoolReadHelper() {
 		if(readObject != nullptr) {
-			readObject->commit(mutexTimeout);
+			readObject->commit(timeoutType, mutexTimeout);
 		}
 
 	}
@@ -35,6 +40,7 @@ public:
 private:
 	ReadCommitIF* readObject = nullptr;
 	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeout = 20;
 };
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
new file mode 100644
index 00000000..e6d6257e
--- /dev/null
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -0,0 +1,84 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+
+
+class ProvidesDataPoolSubscriptionIF {
+public:
+	virtual ~ProvidesDataPoolSubscriptionIF(){};
+
+	/**
+	 * @brief   Subscribe for the generation of periodic packets.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator
+	 * to generate housekeeping packets which are downlinked directly.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+			bool enableReporting,
+			float collectionInterval, bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for the  generation of packets if the dataset
+	 *          is marked as changed.
+	 * @details
+	 * This subscription mechanism will generally be used by the data creator.
+	 * @param sid
+	 * @param isDiagnostics
+	 * @param packetDestination
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+			bool reportingEnabled,
+			bool isDiagnostics,
+			object_id_t packetDestination) = 0;
+
+
+	/**
+	 * @brief   Subscribe for a notification message which will be sent
+	 *          if a dataset has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param setId     Set ID of the set to receive update messages from.
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+	/**
+	 * @brief   Subscribe for an notification message which will be sent if a
+	 *          pool variable has changed.
+	 * @details
+	 * This subscription mechanism will generally be used internally by
+	 * other software components.
+	 * @param localPoolId Pool ID of the pool variable
+	 * @param destinationObject
+	 * @param targetQueueId
+	 * @param generateSnapshot If this is set to true, a copy of the current
+	 * data with a timestamp will be generated and sent via message.
+	 * Otherwise, only an notification message is sent.
+	 * @return
+	 */
+	virtual ReturnValue_t subscribeForVariableUpdateMessages(
+			const lp_id_t localPoolId,
+			object_id_t destinationObject,
+			MessageQueueId_t targetQueueId,
+			bool generateSnapshot) = 0;
+
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 2e5a76fa..713d435b 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -6,6 +6,13 @@
 #include "../objectmanager/SystemObject.h"
 #include <vector>
 
+/**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * TODO: override and protect read, commit and some other calls used by pool manager.
+ */
 class SharedLocalDataSet: public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
diff --git a/datapoollocal/internal/CMakeLists.txt b/datapoollocal/internal/CMakeLists.txt
new file mode 100644
index 00000000..554f3b88
--- /dev/null
+++ b/datapoollocal/internal/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		HasLocalDpIFUserAttorney.cpp
+		HasLocalDpIFManagerAttorney.cpp
+)
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
new file mode 100644
index 00000000..bc07170f
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -0,0 +1,18 @@
+#include "HasLocalDpIFManagerAttorney.h"
+#include "../LocalPoolObjectBase.h"
+#include "../LocalPoolDataSetBase.h"
+#include "../HasLocalDataPoolIF.h"
+
+LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
+		sid_t sid) {
+	return clientIF->getDataSetHandle(sid);
+}
+
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+		lp_id_t localPoolId) {
+	return clientIF->getPoolObjectHandle(localPoolId);
+}
+
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
+	return clientIF->getObjectId();
+}
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
new file mode 100644
index 00000000..ef180b37
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -0,0 +1,22 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
+
+#include "../localPoolDefinitions.h"
+
+class HasLocalDataPoolIF;
+class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
+
+class HasLocalDpIFManagerAttorney {
+
+	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
+
+	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+			lp_id_t localPoolId);
+
+	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
+
+	friend class LocalDataPoolManager;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
new file mode 100644
index 00000000..838204a7
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
@@ -0,0 +1,7 @@
+#include "HasLocalDpIFUserAttorney.h"
+#include "../AccessLocalPoolF.h"
+#include "../HasLocalDataPoolIF.h"
+
+AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF *clientIF) {
+	return clientIF->getAccessorHandle();
+}
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
new file mode 100644
index 00000000..a07c2d59
--- /dev/null
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
@@ -0,0 +1,18 @@
+#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
+
+class HasLocalDataPoolIF;
+class AccessPoolManagerIF;
+
+class HasLocalDpIFUserAttorney {
+private:
+
+	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
+
+	friend class LocalPoolObjectBase;
+	friend class LocalPoolDataSetBase;
+
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
new file mode 100644
index 00000000..1d72f607
--- /dev/null
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -0,0 +1,32 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+
+/**
+ * @brief	This is a helper class implements the Attorney-Client idiom for access to
+ * 			LocalDataPoolManager internals
+ * @details
+ * This helper class provides better control over which classes are allowed to access
+ * LocalDataPoolManager internals in a granular and encapsulated way when compared to
+ * other methods like direct friend declarations. It allows these classes to use
+ * an explicit subset of the pool manager private/protected functions.
+ * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
+ */
+class LocalDpManagerAttorney {
+private:
+	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+		return manager.fetchPoolEntry(localPoolId, poolEntry);
+	}
+
+	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+		return manager.getMutexHandle();
+	}
+
+
+	template<typename T> friend class LocalPoolVariable;
+	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+};
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
new file mode 100644
index 00000000..9804444a
--- /dev/null
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -0,0 +1,39 @@
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
+
+#include "../LocalPoolDataSetBase.h"
+
+class LocalPoolDataSetAttorney {
+private:
+	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+		set.setDiagnostic(diagnostics);
+	}
+
+	static bool isDiagnostics(LocalPoolDataSetBase& set) {
+		return set.isDiagnostics();
+	}
+
+	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+			uint32_t minimumPeriodicIntervalMs,
+			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+				nonDiagIntervalFactor);
+	}
+
+	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+		set.setReportingEnabled(enabled);
+	}
+
+	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+		return set.getReportingEnabled();
+	}
+
+	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+		return set.periodicHelper;
+	}
+
+	friend class LocalDataPoolManager;
+};
+
+
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/datapoollocal/locPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
similarity index 68%
rename from datapoollocal/locPoolDefinitions.h
rename to datapoollocal/localPoolDefinitions.h
index 6e74d349..3ff1feed 100644
--- a/datapoollocal/locPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -1,10 +1,13 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
-#define FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_
+#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
 
-#include <cstdint>
+#include "../datapool/PoolEntryIF.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../objectmanager/frameworkObjects.h"
 
+#include <cstdint>
+#include <map>
+
 /**
  * @brief   Type definition for local pool entries.
  */
@@ -12,10 +15,21 @@ using lp_id_t = uint32_t;
 
 namespace localpool {
 static constexpr uint32_t INVALID_LPID = -1;
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+
+static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
+static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
+
+//! This is the core data structure of the local data pools. Users should insert all desired
+//! pool variables, using the std::map interface.
+using DataPool =  std::map<lp_id_t, PoolEntryIF*>;
+using DataPoolMapIter = DataPool::iterator;
+
 }
 
 /**
- * Used as a unique identifier for data sets.
+ * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
  */
 union sid_t {
     static constexpr uint64_t INVALID_SID = -1;
@@ -57,7 +71,8 @@ union sid_t {
 };
 
 /**
- * Used as a global unique identifier for local pool variables.
+ * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
+ * and 4 byte local pool ID.
  */
 union gp_id_t {
 	static constexpr uint64_t INVALID_GPID = -1;
@@ -90,4 +105,4 @@ union gp_id_t {
     }
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCPOOLDEFINITIONS_H_ */
+#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */
diff --git a/defaultcfg/fsfwconfig/FSFWConfig.h b/defaultcfg/fsfwconfig/FSFWConfig.h
index 261e3d6d..ed86e6e1 100644
--- a/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/defaultcfg/fsfwconfig/FSFWConfig.h
@@ -9,18 +9,14 @@
 //! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! More FSFW related printouts.
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
 //! Can be used to completely disable printouts, even the C stdio ones.
-#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_ENHANCED_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
 	#define FSFW_DISABLE_PRINTOUT 	0
 #endif
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
-
 //! Can be used to disable the ANSI color sequences for C stdio.
 #define FSFW_COLORED_OUTPUT 		1
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 1af6932a..c4098525 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -2,7 +2,7 @@
 #include "AcceptsDeviceResponsesIF.h"
 #include "DeviceTmReportingWrapper.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../thermal/ThermalComponentIF.h"
@@ -13,9 +13,6 @@
 #include "../subsystem/SubsystemBase.h"
 #include "../datapoollocal/LocalPoolVariable.h"
 
-#include <iomanip>
-
-
 object_id_t DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 object_id_t DeviceHandlerBase::defaultFdirParentId = objects::NO_OBJECT;
@@ -27,7 +24,7 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 		wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
 		deviceCommunicationId(deviceCommunication), comCookie(comCookie),
 		healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
-		actionHelper(this, nullptr), hkManager(this, nullptr),
+		actionHelper(this, nullptr), poolManager(this, nullptr),
 		childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
 		hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
 		switchOffWasReported(false), childTransitionDelay(5000),
@@ -39,13 +36,8 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
 	cookieInfo.state = COOKIE_UNUSED;
 	cookieInfo.pendingCommand = deviceCommandMap.end();
 	if (comCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase: ObjectID 0x" << std::hex
-				<< std::setw(8) << std::setfill('0') << this->getObjectId()
-				<< std::dec << ": Do not pass nullptr as a cookie, consider "
-				<< std::setfill(' ') << "passing a dummy cookie instead!"
-				<< std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
+				HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
 	}
 	if (this->fdirInstance == nullptr) {
 		this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId,
@@ -115,7 +107,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
 		doGetRead();
 		// This will be performed after datasets have been updated by the
 		// custom device implementation.
-		hkManager.performHkOperation();
+		poolManager.performHkOperation();
 		break;
 	default:
 		break;
@@ -132,30 +124,24 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	communicationInterface = objectManager->get<DeviceCommunicationIF>(
 			deviceCommunicationId);
 	if (communicationInterface == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: Communication interface "
-				"invalid." << std::endl;
-		sif::error << "Make sure it is set up properly and implements"
-				" DeviceCommunicationIF" << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"Passed communication IF invalid");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
 	result = communicationInterface->initializeInterface(comCookie);
 	if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::error << "DeviceHandlerBase::initialize: Initializing "
-	            "communication interface failed!" << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED,
+				"ComIF initialization failed");
 	    return result;
 	}
 
 	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DeviceHandlerBase::initialize: IPC store not set up in "
-				"factory." << std::endl;
-#endif
+		printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+				ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 
@@ -164,11 +150,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 				AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
 		if (rawReceiver == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Raw receiver object ID set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
-					"ID set but no valid object found." << std::endl;
 			sif::error << "Make sure the raw receiver object is set up properly"
 					" and implements AcceptsDeviceResponsesIF" << std::endl;
+#else
+			sif::printError("Make sure the raw receiver object is set up "
+					"properly and implements AcceptsDeviceResponsesIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -178,11 +168,15 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	if(powerSwitcherId != objects::NO_OBJECT) {
 		powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
 		if (powerSwitcher == nullptr) {
+			printWarningOrError(sif::OutputTypes::OUT_ERROR,
+					"initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+					"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "DeviceHandlerBase::initialize: Power switcher "
-					<< "object ID set but no valid object found." << std::endl;
-			sif::error << "Make sure the raw receiver object is set up properly"
-					<< " and implements PowerSwitchIF" << std::endl;
+			sif::error << "Make sure the power switcher object is set up "
+					<< "properly and implements PowerSwitchIF" << std::endl;
+#else
+			sif::printError("Make sure the power switcher object is set up "
+					"properly and implements PowerSwitchIF\n");
 #endif
 			return ObjectManagerIF::CHILD_INIT_FAILED;
 		}
@@ -216,7 +210,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		return result;
 	}
 
-	result = hkManager.initialize(commandQueue);
+	result = poolManager.initialize(commandQueue);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -229,7 +223,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 		if(result == HasReturnvaluesIF::RETURN_OK) {
 			thermalSet->heaterRequest.value =
 					ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-			thermalSet->commit(PoolVariableIF::VALID);
+			thermalSet->heaterRequest.setValid(true);
+			thermalSet->commit();
 		}
 
 	}
@@ -285,7 +280,7 @@ void DeviceHandlerBase::readCommandQueue() {
 		return;
 	}
 
-	result = hkManager.handleHousekeepingMessage(&command);
+	result = poolManager.handleHousekeepingMessage(&command);
 	if (result == RETURN_OK) {
 		return;
 	}
@@ -555,17 +550,17 @@ void DeviceHandlerBase::replyReturnvalueToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 		uint32_t parameter) {
-//Check if we reply to a raw command.
+	// Check if we reply to a raw command.
 	if (cookieInfo.pendingCommand->first == RAW_COMMAND_ID) {
 		if (status == NO_REPLY_EXPECTED) {
 			status = RETURN_OK;
 		}
 		replyReturnvalueToCommand(status, parameter);
-		//Always delete data from a raw command.
+		// Always delete data from a raw command.
 		IPCStore->deleteData(storedRawData);
 		return;
 	}
-//Check if we were externally commanded.
+	// Check if we were externally commanded.
 	if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
 		MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
 		if (status == NO_REPLY_EXPECTED) {
@@ -580,15 +575,17 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
 
 void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
 		ReturnValue_t status) {
-//No need to check if iter exists, as this is checked by callers. If someone else uses the method, add check.
+	// No need to check if iter exists, as this is checked by callers.
+	// If someone else uses the method, add check.
 	if (iter->second.command == deviceCommandMap.end()) {
 		//Is most likely periodic reply. Silent return.
 		return;
 	}
-//Check if more replies are expected. If so, do nothing.
+	// Check if more replies are expected. If so, do nothing.
 	DeviceCommandInfo* info = &(iter->second.command->second);
 	if (--info->expectedReplies == 0) {
-		//Check if it was transition or internal command. Don't send any replies in that case.
+		// Check if it was transition or internal command.
+		// Don't send any replies in that case.
 		if (info->sendReplyTo != NO_COMMANDER) {
 			actionHelper.finish(info->sendReplyTo, iter->first, status);
 		}
@@ -605,7 +602,7 @@ void DeviceHandlerBase::doSendWrite() {
 		if (result == RETURN_OK) {
 			cookieInfo.state = COOKIE_WRITE_SENT;
 		} else {
-			//always generate a failure event, so that FDIR knows what's up
+			// always generate a failure event, so that FDIR knows what's up
 			triggerEvent(DEVICE_SENDING_COMMAND_FAILED, result,
 					cookieInfo.pendingCommand->first);
 			replyToCommand(result);
@@ -720,10 +717,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case RETURN_OK:
 			handleReply(receivedData, foundId, foundLen);
 			if(foundLen == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-			            " Packet parsing will be stuck." << std::endl;
-#endif
+				printWarningOrError(sif::OutputTypes::OUT_WARNING,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Found length is one, parsing might be stuck");
 			}
 			break;
 		case APERIODIC_REPLY: {
@@ -734,6 +730,9 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 			            foundId);
 			}
 			if(foundLen == 0) {
+				printWarningOrError(sif::OutputTypes::OUT_ERROR,
+						"parseReply", ObjectManagerIF::CHILD_INIT_FAILED,
+						"Power switcher set but no valid object found.");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			    sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
 			            " Packet parsing will be stuck." << std::endl;
@@ -746,7 +745,8 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData,
 		case IGNORE_FULL_PACKET:
 			return;
 		default:
-			//We need to wait for timeout.. don't know what command failed and who sent it.
+			// We need to wait for timeout.. don't know what command failed
+			// and who sent it.
 			replyRawReplyIfnotWiretapped(receivedData, foundLen);
 			triggerEvent(DEVICE_READING_REPLY_FAILED, result, foundLen);
 			break;
@@ -967,7 +967,8 @@ ReturnValue_t DeviceHandlerBase::getStateOfSwitches(void) {
 }
 
 Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
-//only child action special modes are handled, as a child should never see any base action modes
+	// only child action special modes are handled, as a child should
+	// never see any base action modes
 	if (transitionMode == _MODE_START_UP) {
 		return _MODE_TO_ON;
 	}
@@ -1290,12 +1291,11 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 	if (mode == MODE_NORMAL) {
 		result = buildNormalDeviceCommand(&deviceCommandId);
 		if (result == BUSY) {
-		    //so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Busy" << std::dec
-					<< std::endl;
-#endif
+		    // so we can track misconfigurations
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					"Busy.");
 			result = NOTHING_TO_SEND; //no need to report this
 		}
 	}
@@ -1319,12 +1319,15 @@ void DeviceHandlerBase::buildInternalCommand(void) {
 		if (iter == deviceCommandMap.end()) {
 			result = COMMAND_NOT_SUPPORTED;
 		} else if (iter->second.isExecuting) {
-			//so we can track misconfigurations
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::debug << std::hex << getObjectId()
-					<< ": DHB::buildInternalCommand: Command "
-					<< deviceCommandId << " isExecuting" << std::dec
-					<< std::endl;
+#if FSFW_DISABLE_PRINTOUT == 0
+			char output[36];
+			sprintf(output, "Command 0x%08x is executing",
+					static_cast<unsigned int>(deviceCommandId));
+			// so we can track misconfigurations
+			printWarningOrError(sif::OutputTypes::OUT_WARNING,
+					"buildInternalCommand",
+					HasReturnvaluesIF::RETURN_FAILED,
+					output);
 #endif
 			// this is an internal command, no need to report a failure here,
 			// missed reply will track if a reply is too late, otherwise, it's ok
@@ -1418,7 +1421,7 @@ void DeviceHandlerBase::performOperationHook() {
 }
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
-		LocalDataPool &localDataPoolMap,
+		localpool::DataPool &localDataPoolMap,
         LocalDataPoolManager& poolManager) {
 	if(thermalSet != nullptr) {
 		localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
@@ -1429,18 +1432,13 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(
 	return RETURN_OK;
 }
 
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
-	return &hkManager;
-}
-
-
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
     // In this function, the task handle should be valid if the task
     // was implemented correctly. We still check to be 1000 % sure :-)
     if(executingTask != nullptr) {
         pstIntervalMs = executingTask->getPeriodMs();
     }
-    this->hkManager.initializeAfterTaskCreation();
+    this->poolManager.initializeAfterTaskCreation();
 
     if(setStartupImmediately) {
         startTransition(MODE_ON, SUBMODE_NONE);
@@ -1484,3 +1482,56 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 		}
 	}
 }
+
+AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
+	return &poolManager;
+}
+
+void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
+		const char *functionName, ReturnValue_t errorCode,
+		const char *errorPrint) {
+	if(errorPrint == nullptr) {
+		if(errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
+			errorPrint = "Initialization error";
+		}
+		if(errorCode == HasReturnvaluesIF::RETURN_FAILED) {
+			if(errorType == sif::OutputTypes::OUT_WARNING) {
+				errorPrint = "Generic Warning";
+			}
+			else {
+				errorPrint = "Generic Error";
+			}
+		}
+		else {
+			errorPrint = "Unknown error";
+		}
+	}
+
+	if(errorType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+	else if(errorType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "DeviceHandlerBase::" << functionName << ": Object ID "
+				<< std::hex << std::setw(8) << std::setfill('0')
+				<< this->getObjectId() << " | " << errorPrint << std::dec
+				<< std::setfill(' ') << std::endl;
+#else
+		sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n",
+				this->getObjectId(), errorPrint);
+#endif
+	}
+
+}
+
+ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 24ba0372..43f61897 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -6,6 +6,8 @@
 #include "DeviceHandlerFailureIsolation.h"
 #include "DeviceHandlerThermalSet.h"
 
+#include "../serviceinterface/ServiceInterface.h"
+#include "../serviceinterface/serviceInterfaceDefintions.h"
 #include "../objectmanager/SystemObject.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -512,11 +514,18 @@ protected:
 	 * @param localDataPoolMap
 	 * @return
 	 */
-	virtual ReturnValue_t initializeLocalDataPool(LocalDataPool& localDataPoolMap,
+	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
 				LocalDataPoolManager& poolManager) override;
 
-	/** Get the HK manager object handle */
-	virtual LocalDataPoolManager* getHkManagerHandle() override;
+	/**
+	 * Provides the subscription handle which can be used by classes like controllers
+	 * to get messages on data updates.
+	 * @return
+	 */
+	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+
+	//! Accessor handle required for internal handling.
+	AccessPoolManagerIF* getAccessorHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
@@ -646,7 +655,7 @@ protected:
 	/** Action helper for HasActionsIF */
 	ActionHelper actionHelper;
 	/** Housekeeping Manager */
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 
 	/**
 	 *  @brief Information about commands
@@ -1111,7 +1120,7 @@ private:
 	/**
 	 * @brief   The mode the current transition originated from
 	 *
-	 * This is private so the child can not change it and fuck up the timeouts
+	 * This is private so the child can not change it and mess up the timeouts
 	 *
 	 * IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
 	 * (it is _MODE_POWER_DOWN during this modes)
@@ -1190,7 +1199,8 @@ private:
 	 * Check if the RMAP sendWrite action was successful.
 	 *
 	 * Depending on the result, the following is done
-	 * - if the device command was external commanded, a reply is sent indicating the result
+	 * - if the device command was external commanded, a reply is sent
+	 *   indicating the result
 	 * - if the action was successful, the reply timout counter is initialized
 	 */
 	void doGetWrite(void);
@@ -1206,9 +1216,9 @@ private:
 	/**
 	 * Check the getRead reply and the contained data.
 	 *
-	 * If data was received scanForReply() and, if successful, handleReply() are called.
-	 * If the current mode is @c MODE_RAW, the received packet is sent to the commanding object
-	 * via commandQueue.
+	 * If data was received scanForReply() and, if successful, handleReply()
+	 * are called. If the current mode is @c MODE_RAW, the received packet
+	 * is sent to the commanding object via commandQueue.
 	 */
 	void doGetRead(void);
 
@@ -1227,7 +1237,7 @@ private:
 			uint32_t *len);
 
 	/**
-	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW NOTHING ELSE!!!
+	 * @param modeTo either @c MODE_ON, MODE_NORMAL or MODE_RAW, nothing else!
 	 */
 	void setTransition(Mode_t modeTo, Submode_t submodeTo);
 
@@ -1247,6 +1257,11 @@ private:
 
     void handleTransitionToOnMode(Mode_t commandedMode,
     		Submode_t commandedSubmode);
+
+    void printWarningOrError(sif::OutputTypes errorType,
+    		const char* functionName,
+			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
+			const char* errorPrint = nullptr);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index 865b38b3..bae68516 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,10 +1,10 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
 #include "../action/HasActionsIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index 65e19d10..e25e574f 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -162,9 +162,15 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::BLOCKING);
+	mutex->lockMutex(timeoutType, timeoutMs);
 }
 
 void EventManager::unlockMutex() {
 	mutex->unlockMutex();
 }
+
+void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
diff --git a/events/EventManager.h b/events/EventManager.h
index c6bd07be..abce9b8b 100644
--- a/events/EventManager.h
+++ b/events/EventManager.h
@@ -29,6 +29,8 @@ public:
 	EventManager(object_id_t setObjectId);
 	virtual ~EventManager();
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
+
 	MessageQueueId_t getEventReportQueue();
 
 	ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
@@ -51,6 +53,8 @@ protected:
 	std::map<MessageQueueId_t, EventMatchTree> listenerList;
 
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
 
 	static const uint8_t N_POOLS = 3;
 	LocalPool factoryBackend;
diff --git a/fsfw.mk b/fsfw.mk
index 3df63060..0d72fae1 100644
--- a/fsfw.mk
+++ b/fsfw.mk
@@ -10,6 +10,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/internal/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp
index c273b250..25d6fcf4 100644
--- a/globalfunctions/arrayprinter.cpp
+++ b/globalfunctions/arrayprinter.cpp
@@ -1,5 +1,5 @@
 #include "arrayprinter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include <bitset>
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
@@ -9,6 +9,8 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
 		sif::info << "Printing data with size " << size << ": ";
 	}
 	sif::info << "[";
+#else
+	sif::printInfo("Printing data with size %zu: [", size);
 #endif
 	if(type == OutputType::HEX) {
 		arrayprinter::printHex(data, size, maxCharPerLine);
@@ -37,6 +39,8 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
 	}
 	sif::info << std::dec;
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -54,6 +58,8 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 		}
 	}
 	sif::info << "]" << std::endl;
+#else
+	// how much memory to reserve for printout?
 #endif
 }
 
@@ -65,5 +71,7 @@ void arrayprinter::printBin(const uint8_t *data, size_t size) {
                 std::bitset<8>(data[i]) << ",\n" << std::flush;
     }
     sif::info << "]" << std::endl;
+#else
+    // how much memory to reserve for printout?
 #endif
 }
diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h
index 90bbe594..0c7680dc 100644
--- a/housekeeping/HousekeepingMessage.h
+++ b/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../ipc/CommandMessage.h"
 #include "../ipc/FwMessageTypes.h"
 #include "../objectmanager/frameworkObjects.h"
diff --git a/internalError/InternalErrorDataset.h b/internalError/InternalErrorDataset.h
index fa91116d..bd9062ed 100644
--- a/internalError/InternalErrorDataset.h
+++ b/internalError/InternalErrorDataset.h
@@ -21,11 +21,11 @@ public:
     InternalErrorDataset(object_id_t objectId):
            StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
 
-    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId,
     		TM_HITS, this);
-    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId,
     		QUEUE_HITS, this);
-    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(hkManager->getOwner(),
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId,
     		STORE_HITS, this);
 };
 
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index 48b6f851..bc72ada2 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -2,7 +2,7 @@
 
 #include "../ipc/QueueFactory.h"
 #include "../ipc/MutexFactory.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
         uint32_t messageQueueDepth): SystemObject(setObjectId),
@@ -23,13 +23,13 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
 }
 
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
-    internalErrorDataset.read(INTERNAL_ERROR_MUTEX_TIMEOUT);
+    internalErrorDataset.read(timeoutType, timeoutMs);
 
 	uint32_t newQueueHits = getAndResetQueueHits();
 	uint32_t newTmHits = getAndResetTmHits();
 	uint32_t newStoreHits = getAndResetStoreHits();
 
-#if FSFW_ENHANCED_PRINTOUT == 1
+#if FSFW_VERBOSE_LEVEL == 1
 	if(diagnosticPrintout) {
 	    if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -38,6 +38,11 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	        sif::debug << "Queue errors: " << newQueueHits << std::endl;
 	        sif::debug << "TM errors: " << newTmHits << std::endl;
 	        sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+	        sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+	        sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+	        sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+	        sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
 	    }
 	}
@@ -46,8 +51,8 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 	internalErrorDataset.queueHits.value += newQueueHits;
 	internalErrorDataset.storeHits.value += newStoreHits;
 	internalErrorDataset.tmHits.value += newTmHits;
-
-	internalErrorDataset.commit(INTERNAL_ERROR_MUTEX_TIMEOUT);
+	internalErrorDataset.setValidity(true, true);
+	internalErrorDataset.commit(timeoutType, timeoutMs);
 
 	poolManager.performHkOperation();
 
@@ -69,7 +74,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -78,21 +83,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -101,14 +106,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -119,7 +124,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -128,14 +133,18 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
+AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
+	return &poolManager;
+}
+
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::WAITING, INTERNAL_ERROR_MUTEX_TIMEOUT);
+	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
 	mutex->unlockMutex();
 }
@@ -149,7 +158,7 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
 }
 
 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
-        LocalDataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
     localDataPoolMap.emplace(errorPoolIds::TM_HITS,
             new PoolEntry<uint32_t>());
     localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS,
@@ -162,10 +171,6 @@ ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
-    return &poolManager;
-}
-
 dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
@@ -190,3 +195,12 @@ ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
     return poolManager.initializeAfterTaskCreation();
 }
 
+void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+		uint32_t timeoutMs) {
+	this->timeoutType = timeoutType;
+	this->timeoutMs = timeoutMs;
+}
+
+ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
+	return &poolManager;
+}
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index 8d33c06e..ec9134d4 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -22,7 +22,6 @@ class InternalErrorReporter: public SystemObject,
 		public InternalErrorReporterIF,
 		public HasLocalDataPoolIF {
 public:
-    static constexpr uint8_t INTERNAL_ERROR_MUTEX_TIMEOUT = 20;
 
 	InternalErrorReporter(object_id_t setObjectId,
 	        uint32_t messageQueueDepth = 5);
@@ -34,16 +33,20 @@ public:
 	 */
 	void setDiagnosticPrintout(bool enable);
 
+	void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+			uint32_t timeoutMs);
+
 	virtual ~InternalErrorReporter();
 
     virtual object_id_t getObjectId() const override;
     virtual MessageQueueId_t getCommandQueue() const override;
     virtual ReturnValue_t initializeLocalDataPool(
-            LocalDataPool& localDataPoolMap,
+    		localpool::DataPool& localDataPoolMap,
             LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
+	AccessPoolManagerIF* getAccessorHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
@@ -61,7 +64,11 @@ protected:
 	LocalDataPoolManager poolManager;
 
 	PeriodicTaskIF* executingTask = nullptr;
+
 	MutexIF* mutex = nullptr;
+	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+	uint32_t timeoutMs = 20;
+
 	sid_t internalErrorSid;
 	InternalErrorDataset internalErrorDataset;
 
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 5673e4d7..084b702b 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -14,7 +14,7 @@ public:
     /**
      * Different types of timeout for the mutex lock.
      */
-    enum TimeoutType {
+    enum class TimeoutType {
         POLLING, //!< If mutex is not available, return immediately
         WAITING, //!< Wait a specified time for the mutex to become available
         BLOCKING //!< Block indefinitely until the mutex becomes available.
diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h
index 9028e7e4..7ce110e5 100644
--- a/monitoring/MonitorReporter.h
+++ b/monitoring/MonitorReporter.h
@@ -5,7 +5,7 @@
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
 
-#include "../datapoollocal/locPoolDefinitions.h"
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 
diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h
index 2822743a..d830e313 100644
--- a/monitoring/MonitoringMessageContent.h
+++ b/monitoring/MonitoringMessageContent.h
@@ -1,9 +1,10 @@
-#ifndef MONITORINGMESSAGECONTENT_H_
-#define MONITORINGMESSAGECONTENT_H_
+#ifndef FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
+#define FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
 
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
-#include "../datapoollocal/locPoolDefinitions.h"
+
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -85,4 +86,4 @@ private:
 template<typename T>
 object_id_t MonitoringReportContent<T>::timeStamperId = 0;
 
-#endif /* MONITORINGMESSAGECONTENT_H_ */
+#endif /* FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_ */
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index d3f4e68e..9c0a0267 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -163,7 +163,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -178,7 +178,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Clock.cpp b/osal/host/Clock.cpp
index 2bc78785..88bf51d2 100644
--- a/osal/host/Clock.cpp
+++ b/osal/host/Clock.cpp
@@ -202,7 +202,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -217,7 +217,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex == nullptr){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex();
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/host/Mutex.cpp b/osal/host/Mutex.cpp
index ad8873df..892028b2 100644
--- a/osal/host/Mutex.cpp
+++ b/osal/host/Mutex.cpp
@@ -4,16 +4,16 @@
 Mutex::Mutex() {}
 
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
-	if(timeoutType == MutexIF::BLOCKING) {
+	if(timeoutType == TimeoutType::BLOCKING) {
 		mutex.lock();
 		return HasReturnvaluesIF::RETURN_OK;
 	}
-	else if(timeoutType == MutexIF::POLLING) {
+	else if(timeoutType == TimeoutType::POLLING) {
 		if(mutex.try_lock()) {
 			return HasReturnvaluesIF::RETURN_OK;
 		}
 	}
-	else if(timeoutMs > MutexIF::POLLING){
+	else if(timeoutType == TimeoutType::WAITING){
 		auto chronoMs = std::chrono::milliseconds(timeoutMs);
 		if(mutex.try_lock_for(chronoMs)) {
 			return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/host/Mutex.h b/osal/host/Mutex.h
index c0fa19b7..0bd93c8a 100644
--- a/osal/host/Mutex.h
+++ b/osal/host/Mutex.h
@@ -22,7 +22,6 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	//bool locked = false;
 	std::timed_mutex mutex;
 };
 
diff --git a/osal/linux/BinarySemaphore.cpp b/osal/linux/BinarySemaphore.cpp
index 0a6bb29f..5716e560 100644
--- a/osal/linux/BinarySemaphore.cpp
+++ b/osal/linux/BinarySemaphore.cpp
@@ -1,10 +1,11 @@
 #include "BinarySemaphore.h"
+#include "../../serviceinterface/ServiceInterfacePrinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-extern "C" {
+#include <time.h>
 #include <errno.h>
 #include <string.h>
-}
+
 
 BinarySemaphore::BinarySemaphore() {
 	// Using unnamed semaphores for now
@@ -113,7 +114,8 @@ uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
 	}
 	else if(result != 0 and errno == EINVAL) {
 		// Could be called from interrupt, use lightweight printf
-		printf("BinarySemaphore::getSemaphoreCounter: Invalid semaphore\n");
+		sif::printError("BinarySemaphore::getSemaphoreCounter: "
+				"Invalid semaphore\n");
 		return 0;
 	}
 	else {
@@ -128,13 +130,17 @@ void BinarySemaphore::initSemaphore(uint8_t initCount) {
 		switch(errno) {
 		case(EINVAL):
 			// Value exceeds SEM_VALUE_MAX
-		case(ENOSYS):
-		// System does not support process-shared semaphores
+		case(ENOSYS): {
+			// System does not support process-shared semaphores
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "BinarySemaphore: Init failed with" << strerror(errno)
-				<< std::endl;
+				sif::error << "BinarySemaphore: Init failed with "
+						<< strerror(errno) << std::endl;
+#else
+				sif::printError("BinarySemaphore: Init failed with %s\n",
+						strerror(errno));
 #endif
 		}
+		}
 	}
 }
 
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 54dad839..35cbfae0 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -182,7 +182,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -197,7 +197,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -209,13 +209,13 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex(){
-	if(timeMutex==NULL){
+	if(timeMutex == nullptr){
 		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
+		if (mutexFactory == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
+		if (timeMutex == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
diff --git a/osal/linux/CountingSemaphore.cpp b/osal/linux/CountingSemaphore.cpp
index 0bb71831..07c52212 100644
--- a/osal/linux/CountingSemaphore.cpp
+++ b/osal/linux/CountingSemaphore.cpp
@@ -1,5 +1,7 @@
 #include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <errno.h>
 
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
 		maxCount(maxCount), initCount(initCount) {
diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp
index e7b09b4f..60d15dee 100644
--- a/osal/linux/MessageQueue.cpp
+++ b/osal/linux/MessageQueue.cpp
@@ -1,5 +1,5 @@
 #include "MessageQueue.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../objectmanager/ObjectManagerIF.h"
 
 #include <fstream>
@@ -121,14 +121,16 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
 		break;
 	}
 
-	default:
+	default: {
 		// Failed either the first time or the second time
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MessageQueue::MessageQueue: Creating Queue " << std::hex
-		<< name << std::dec << " failed with status: "
-		<< strerror(errno) << std::endl;
+		sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
+				<< " failed with status: " << strerror(errno) << std::endl;
+#else
+		sif::printError("MessageQueue::MessageQueue: Creating Queue %s"
+				" failed with status: %s\n", name, strerror(errno));
 #endif
-
+	}
 	}
 	return HasReturnvaluesIF::RETURN_FAILED;
 
diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp
index a0e540cf..2499b442 100644
--- a/osal/linux/PosixThread.cpp
+++ b/osal/linux/PosixThread.cpp
@@ -1,6 +1,6 @@
 #include "PosixThread.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 #include <errno.h>
@@ -146,16 +146,22 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 				strerror(status) << std::endl;
 #endif
 		if(errno == ENOMEM) {
-			uint64_t stackMb = stackSize/10e6;
+			size_t stackMb = stackSize/10e6;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Insufficient memory for"
 					" the requested " << stackMb << " MB" << std::endl;
+#else
+			sif::printError("PosixThread::createTask: Insufficient memory for "
+					"the requested %zu MB\n", stackMb);
 #endif
 		}
 		else if(errno == EINVAL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "PosixThread::createTask: Wrong alignment argument!"
 					<< std::endl;
+#else
+			sif::printError("PosixThread::createTask: "
+					"Wrong alignment argument!\n");
 #endif
 		}
 		return;
diff --git a/osal/linux/TcUnixUdpPollingTask.cpp b/osal/linux/TcUnixUdpPollingTask.cpp
index a8387e87..11ed7fee 100644
--- a/osal/linux/TcUnixUdpPollingTask.cpp
+++ b/osal/linux/TcUnixUdpPollingTask.cpp
@@ -1,6 +1,8 @@
 #include "TcUnixUdpPollingTask.h"
 #include "../../globalfunctions/arrayprinter.h"
 
+#include <errno.h>
+
 TcUnixUdpPollingTask::TcUnixUdpPollingTask(object_id_t objectId,
 		object_id_t tmtcUnixUdpBridge, size_t frameSize,
 		double timeoutSeconds): SystemObject(objectId),
diff --git a/osal/linux/TmTcUnixUdpBridge.cpp b/osal/linux/TmTcUnixUdpBridge.cpp
index 1d318d3b..0af1fc68 100644
--- a/osal/linux/TmTcUnixUdpBridge.cpp
+++ b/osal/linux/TmTcUnixUdpBridge.cpp
@@ -1,5 +1,5 @@
 #include "TmTcUnixUdpBridge.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexHelper.h"
 
 #include <errno.h>
@@ -188,12 +188,16 @@ void TmTcUnixUdpBridge::handleBindError() {
 
 void TmTcUnixUdpBridge::handleSendError() {
 	switch(errno) {
-	default:
+	default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcUnixBridge::handleSendError: "
 		        << strerror(errno) << std::endl;
+#else
+		sif::printError("TmTcUnixBridge::handleSendError: %s\n",
+				strerror(errno));
 #endif
 	}
+	}
 }
 
 void TmTcUnixUdpBridge::setClientAddressToAny(bool ipAddrAnySet){
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index 71c5782f..7dd512fa 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -30,11 +30,11 @@ Mutex::~Mutex() {
 ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
         TimeoutType::BLOCKING, uint32_t timeoutMs) {
 	rtems_status_code status = RTEMS_INVALID_ID;
-	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+	if(timeoutType == MutexIF::TimeoutType::BLOCKING) {
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 	}
-	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+	else if(timeoutType == MutexIF::TimeoutType::POLLING) {
 		timeoutMs = RTEMS_NO_TIMEOUT;
 		status = rtems_semaphore_obtain(mutexId,
 				RTEMS_NO_WAIT, 0);
diff --git a/power/Fuse.cpp b/power/Fuse.cpp
index 1c30d83f..b6e0a7f1 100644
--- a/power/Fuse.cpp
+++ b/power/Fuse.cpp
@@ -65,8 +65,8 @@ ReturnValue_t Fuse::check() {
 	set.read();
 	if (!healthHelper.healthTable->isHealthy(getObjectId())) {
 		setAllMonitorsToUnchecked();
-		set.commit(PoolVariableIF::INVALID);
-		return RETURN_OK;
+		set.setValidity(false, true);
+		return set.commit();
 	}
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 	checkFuseState();
@@ -206,7 +206,8 @@ float Fuse::getPower() {
 
 void Fuse::setDataPoolEntriesInvalid() {
 	set.read();
-	set.commit(PoolVariableIF::INVALID);
+	set.setValidity(false, true);
+	set.commit();
 }
 
 ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp
index 1ef041e3..fb181d9f 100644
--- a/power/PowerSensor.cpp
+++ b/power/PowerSensor.cpp
@@ -97,7 +97,8 @@ void PowerSensor::checkCommandQueue() {
 
 void PowerSensor::setDataPoolEntriesInvalid() {
 	powerSensorSet.read();
-	powerSensorSet.commit(PoolVariableIF::INVALID);
+	powerSensorSet.setValidity(false, true);
+	powerSensorSet.commit();
 }
 
 float PowerSensor::getPower() {
diff --git a/unittest/internal/UnittDefinitions.cpp b/unittest/internal/UnittDefinitions.cpp
index 7138e6c6..517f561a 100644
--- a/unittest/internal/UnittDefinitions.cpp
+++ b/unittest/internal/UnittDefinitions.cpp
@@ -3,7 +3,9 @@
  ReturnValue_t unitt::put_error(std::string errorId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 	sif::error << "Unit Tester error: Failed at test ID "
-			<< errorId << "\n" << std::flush;
-#endif
+			<< errorId << std::endl;
+#else
+	sif::printError("Unit Tester error: Failed at test ID 0x%08x", errorId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
diff --git a/unittest/internal/UnittDefinitions.h b/unittest/internal/UnittDefinitions.h
index ea36fea4..3e14fec5 100644
--- a/unittest/internal/UnittDefinitions.h
+++ b/unittest/internal/UnittDefinitions.h
@@ -2,9 +2,10 @@
 #define UNITTEST_INTERNAL_UNITTDEFINITIONS_H_
 
 #include "../../returnvalues/HasReturnvaluesIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include <cstdint>
 #include <cstddef>
+#include <string>
 
 namespace tv {
 // POD test values
diff --git a/unittest/internal/osal/IntTestMutex.cpp b/unittest/internal/osal/IntTestMutex.cpp
index 3316de74..2a1584b8 100644
--- a/unittest/internal/osal/IntTestMutex.cpp
+++ b/unittest/internal/osal/IntTestMutex.cpp
@@ -13,7 +13,7 @@
 void testmutex::testMutex() {
 	std::string id = "[testMutex]";
 	MutexIF* mutex = MutexFactory::instance()->createMutex();
-	auto result = mutex->lockMutex(MutexIF::POLLING);
+	auto result = mutex->lockMutex(MutexIF::TimeoutType::POLLING);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 		unitt::put_error(id);
 	}
diff --git a/unittest/tests/CMakeLists.txt b/unittest/tests/CMakeLists.txt
index 97074417..180e1a51 100644
--- a/unittest/tests/CMakeLists.txt
+++ b/unittest/tests/CMakeLists.txt
@@ -2,5 +2,6 @@ add_subdirectory(action)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)
+add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 3109eba1..2493a6b8 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -4,9 +4,12 @@
 
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <array>
+
 
 TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	ActionHelperOwnerMockBase testDhMock;
diff --git a/unittest/tests/action/TestActionHelper.h b/unittest/tests/action/TestActionHelper.h
index 610fb09e..641ea2c6 100644
--- a/unittest/tests/action/TestActionHelper.h
+++ b/unittest/tests/action/TestActionHelper.h
@@ -48,85 +48,4 @@ public:
 };
 
 
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		memcpy(message->getBuffer(), lastMessage.getBuffer(),
-				message->getMessageSize());
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
 #endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */
diff --git a/unittest/tests/container/TestPlacementFactory.cpp b/unittest/tests/container/TestPlacementFactory.cpp
index 5edbb9d2..14cf8eb4 100644
--- a/unittest/tests/container/TestPlacementFactory.cpp
+++ b/unittest/tests/container/TestPlacementFactory.cpp
@@ -1,45 +1,48 @@
-//#include <fsfw/container/PlacementFactory.h>
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-//#include <fsfw/container/ArrayList.h>
-//
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//
-//TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
-//	INFO("PlacementFactory Tests");
-//
-//	const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
-//	const uint16_t n_elements[3] = {1, 1, 1};
-//	LocalPool<3> storagePool(0x1, element_sizes, n_elements, false, true);
-//	PlacementFactory factory(&storagePool);
-//
-//	SECTION("Pool overload"){
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
-//				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
-//		REQUIRE(list2 == nullptr);
-//	}
-//
-//	SECTION("Test generate and destroy"){
-//		uint64_t* number = factory.generate<uint64_t>(32000);
-//		REQUIRE(number != nullptr);
-//		REQUIRE(*number == 32000);
-//		store_address_t address;
-//		uint8_t* ptr = nullptr;
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
-//		uint64_t* number2 = factory.generate<uint64_t>(12345);
-//		REQUIRE(number2 == nullptr);
-//		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
-//						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
-//
-//		//Check that PlacementFactory checks for nullptr
-//		ptr = nullptr;
-//		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
-//	}
-//}
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/storagemanager/LocalPool.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/container/ArrayList.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE( "PlacementFactory Tests", "[TestPlacementFactory]") {
+	INFO("PlacementFactory Tests");
+
+	LocalPool::LocalPoolConfig poolCfg= {{1, sizeof(uint16_t)},
+			{1, sizeof(uint32_t)}, {1, sizeof(uint64_t)}
+	};
+	//const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+	//const uint16_t n_elements[3] = {1, 1, 1};
+	LocalPool storagePool(0x1, poolCfg, false, true);
+	PlacementFactory factory(&storagePool);
+
+	SECTION("Pool overload"){
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr)
+				== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+		REQUIRE(list2 == nullptr);
+	}
+
+	SECTION("Test generate and destroy"){
+		uint64_t* number = factory.generate<uint64_t>(32000);
+		REQUIRE(number != nullptr);
+		REQUIRE(*number == 32000);
+		store_address_t address;
+		uint8_t* ptr = nullptr;
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+		uint64_t* number2 = factory.generate<uint64_t>(12345);
+		REQUIRE(number2 == nullptr);
+		REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr)
+						== static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+		REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+		//Check that PlacementFactory checks for nullptr
+		ptr = nullptr;
+		REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+	}
+}
diff --git a/unittest/tests/datapoollocal/CMakeLists.txt b/unittest/tests/datapoollocal/CMakeLists.txt
new file mode 100644
index 00000000..f196a080
--- /dev/null
+++ b/unittest/tests/datapoollocal/CMakeLists.txt
@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE
+	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
+	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
+)
diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp
new file mode 100644
index 00000000..968a0b3d
--- /dev/null
+++ b/unittest/tests/datapoollocal/DataSetTest.cpp
@@ -0,0 +1,23 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	const uint32_t setId = 0;
+	SECTION("BasicTest") {
+		StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>(
+				sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId));
+	}
+}
+
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
new file mode 100644
index 00000000..f550582e
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp
@@ -0,0 +1,122 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+	REQUIRE(mqMock != nullptr);
+	CommandMessage messageSent;
+	uint8_t messagesSent = 0;
+
+
+	SECTION("BasicTest") {
+		// Subscribe for message generation on update.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		// Subscribe for an update message.
+		poolOwner->dataset.setChanged(true);
+		// Now the update message should be generated.
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent() == true);
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// Should have been reset.
+		CHECK(poolOwner->dataset.hasChanged() == false);
+		// Set changed again, result should be the same.
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		// now subscribe for set update HK as well.
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		// first message sent should be the update notification, considering
+		// the internal list is a vector checked in insertion order.
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		// clear message to avoid memory leak, our mock won't do it for us (yet)
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+	}
+
+	SECTION("AdvancedTests") {
+		// we need to reset the subscription list because the pool owner
+		// is a global object.
+		poolOwner->resetSubscriptionList();
+		// Subscribe for variable update as well
+		REQUIRE(not poolOwner->dataset.hasChanged());
+		REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) ==
+				retval::CATCH_OK);
+		lp_var_t<uint8_t>* poolVar = dynamic_cast<lp_var_t<uint8_t>*>(
+				poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+		REQUIRE(poolVar != nullptr);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+		// Check update notification was sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 1);
+		// Should have been reset.
+		CHECK(poolVar->hasChanged() == false);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+
+		// now subscribe for the dataset update (HK and update) again
+		REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+		REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		// now two messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 2);
+		mqMock->clearMessages(true);
+
+		poolOwner->dataset.setChanged(true);
+		poolVar->setChanged(true);
+		REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+		// now three messages should be sent.
+		REQUIRE(mqMock->wasMessageSent(&messagesSent) == true);
+		CHECK(messagesSent == 3);
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+		REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+		CHECK(messageSent.getCommand() == static_cast<int>(
+				HousekeepingMessage::HK_REPORT));
+		CommandMessageCleaner::clearCommandMessage(&messageSent);
+		REQUIRE(mqMock->receiveMessage(&messageSent) ==
+				static_cast<int>(MessageQueueIF::EMPTY));
+	}
+}
+
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
new file mode 100644
index 00000000..aaccc90e
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -0,0 +1,206 @@
+#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/LocalDataSet.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/LocalPoolVector.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <testcfg/objects/systemObjectList.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
+
+namespace lpool {
+static constexpr lp_id_t uint8VarId = 0;
+static constexpr lp_id_t floatVarId = 1;
+static constexpr lp_id_t uint32VarId = 2;
+static constexpr lp_id_t uint16Vec3Id = 3;
+static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
+static constexpr uint8_t dataSetMaxVariables = 10;
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE,
+		testSetId);
+}
+
+
+class LocalPoolTestDataSet: public LocalDataSet {
+public:
+	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+		LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {
+	}
+
+	ReturnValue_t assignPointers() {
+		PoolVariableIF** rawVarArray = getContainer();
+		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+				rawVarArray[2]);
+		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+				localPoolUint16Vec == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+	lp_var_t<float>* localPoolVarFloat = nullptr;
+	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+
+private:
+};
+
+
+class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
+public:
+	LocalPoolOwnerBase(
+			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
+		SystemObject(objectId), hkManager(this, messageQueue),
+		dataset(this, lpool::testSetId) {
+		messageQueue = new MessageQueueMockBase();
+	}
+
+	~LocalPoolOwnerBase() {
+		QueueFactory::instance()->deleteMessageQueue(messageQueue);
+	}
+
+	object_id_t getObjectId() const override {
+		return SystemObject::getObjectId();
+	}
+
+	ReturnValue_t initializeHkManager() {
+		if(not initialized) {
+			initialized = true;
+			return hkManager.initialize(messageQueue);
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	ReturnValue_t initializeHkManagerAfterTaskCreation() {
+		if(not initializedAfterTaskCreation) {
+			initializedAfterTaskCreation = true;
+			return hkManager.initializeAfterTaskCreation();
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/** Command queue for housekeeping messages. */
+	MessageQueueId_t getCommandQueue() const override {
+		return messageQueue->getId();
+	}
+
+	// This is called by initializeAfterTaskCreation of the HK manager.
+	virtual ReturnValue_t initializeLocalDataPool(
+	        localpool::DataPool& localDataPoolMap,
+	        LocalDataPoolManager& poolManager) {
+		// Default initialization empty for now.
+		localDataPoolMap.emplace(lpool::uint8VarId,
+				new PoolEntry<uint8_t>({0}));
+		localDataPoolMap.emplace(lpool::floatVarId,
+				new PoolEntry<float>({0}));
+		localDataPoolMap.emplace(lpool::uint32VarId,
+				new PoolEntry<uint32_t>({0}));
+
+		localDataPoolMap.emplace(lpool::uint16Vec3Id,
+				new PoolEntry<uint16_t>({0, 0, 0}));
+		localDataPoolMap.emplace(lpool::int64Vec2Id,
+				new PoolEntry<int64_t>({0, 0}));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	/**
+	 * This function can be used by data pool consumers to retrieve a handle
+	 * which allows subscriptions to dataset and variable updates.
+	 * @return
+	 */
+	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
+		return &hkManager;
+	}
+
+	virtual AccessPoolManagerIF* getAccessorHandle() override {
+		return &hkManager;
+	}
+
+	uint32_t getPeriodicOperationFrequency() const override {
+		return 0;
+	}
+
+	/**
+	 * This function is used by the pool manager to get a valid dataset
+     * from a SID
+	 * @param sid Corresponding structure ID
+	 * @return
+	 */
+	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
+		return &dataset;
+	}
+
+	virtual LocalPoolObjectBase* getPoolObjectHandle(
+			lp_id_t localPoolId) override {
+		if(localPoolId == lpool::uint8VarId) {
+			return &testUint8;
+		}
+		else if(localPoolId == lpool::uint16Vec3Id) {
+			return &testUint16Vec;
+		}
+		else if(localPoolId == lpool::floatVarId) {
+			return &testFloat;
+		}
+		else if(localPoolId == lpool::int64Vec2Id) {
+			return &testInt64Vec;
+		}
+		else if(localPoolId == lpool::uint32VarId) {
+			return &testUint32;
+		}
+		else {
+			return &testUint8;
+		}
+	}
+
+	MessageQueueMockBase* getMockQueueHandle() const {
+		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdate() {
+		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+				false, objects::HK_RECEIVER_MOCK);
+	}
+
+	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
+	}
+
+	void resetSubscriptionList() {
+		hkManager.clearReceiversList();
+	}
+
+	LocalDataPoolManager hkManager;
+	LocalPoolTestDataSet dataset;
+private:
+
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
+			&dataset);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+			&dataset);
+	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
+
+	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
+			lpool::uint16Vec3Id, &dataset);
+	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
+			lpool::int64Vec2Id);
+
+	MessageQueueIF* messageQueue = nullptr;
+
+	bool initialized = false;
+	bool initializedAfterTaskCreation = false;
+
+};
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
new file mode 100644
index 00000000..2e4cb7ec
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp
@@ -0,0 +1,123 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("Basic Tests") {
+		// very basic test.
+		lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		CHECK(testVariable.value == 0);
+		testVariable.value = 5;
+		REQUIRE(testVariable.commit() == retval::CATCH_OK);
+		REQUIRE(testVariable.read() == retval::CATCH_OK);
+		REQUIRE(testVariable.value == 5);
+		CHECK(not testVariable.isValid());
+		testVariable.setValid(true);
+		CHECK(testVariable.isValid());
+		CHECK(testVariable.commit(true) == retval::CATCH_OK);
+
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+		CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+		testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+
+		testVariable.setDataPoolId(22);
+		CHECK(testVariable.getDataPoolId() == 22);
+		testVariable.setDataPoolId(lpool::uint8VarId);
+
+		testVariable.setChanged(true);
+		CHECK(testVariable.hasChanged());
+		testVariable.setChanged(false);
+
+		gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+		REQUIRE(testVariable2.read() == retval::CATCH_OK);
+		CHECK(testVariable2 == 5);
+		CHECK(testVariable == testVariable2);
+		testVariable = 10;
+		CHECK(testVariable != 5);
+		//CHECK(not testVariable != testVariable2);
+		uint8_t variableRaw = 0;
+		uint8_t* varPtr = &variableRaw;
+		size_t maxSize = testVariable.getSerializedSize();
+		CHECK(maxSize == 1);
+		size_t serSize = 0;
+		CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(variableRaw == 10);
+		const uint8_t* varConstPtr = &variableRaw;
+		testVariable = 5;
+		CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVariable == 10);
+		CHECK(testVariable != testVariable2);
+		CHECK(testVariable2 < testVariable);
+		CHECK(testVariable2 < 10);
+		CHECK(testVariable > 5);
+		CHECK(testVariable > testVariable2);
+		variableRaw = static_cast<uint8_t>(testVariable2);
+		CHECK(variableRaw == 5);
+
+		CHECK(testVariable == 10);
+		testVariable = testVariable2;
+		CHECK(testVariable == 5);
+	}
+
+	SECTION("ErrorHandling") {
+
+		// not try to use a local pool variable which does not exist
+		lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVariable.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+		REQUIRE(invalidVariable.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+		// now try to access with wrong type
+		lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+		REQUIRE(invalidVariable2.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVar.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+		lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVar.read() == static_cast<int>(
+				PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
+#endif
+
+		// for code coverage. If program does not crash -> OK
+		lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
+				0xffffffff, lpool::uint8VarId);
+		gp_id_t globPoolId(0xffffffff,
+				lpool::uint8VarId);
+		lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+		lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
+				lpool::uint8VarId);
+	}
+
+}
+
+
diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
new file mode 100644
index 00000000..7c309bbb
--- /dev/null
+++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp
@@ -0,0 +1,120 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <unittest/core/CatchDefinitions.h>
+
+TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
+	LocalPoolOwnerBase* poolOwner = objectManager->
+			get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+	REQUIRE(poolOwner != nullptr);
+	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
+			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		// very basic test.
+		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(testVector.read() == retval::CATCH_OK);
+		testVector.value[0] = 5;
+		testVector.value[1] = 232;
+		testVector.value[2] = 32023;
+
+		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+		CHECK(testVector.isValid());
+
+		testVector.value[0] = 0;
+		testVector.value[1] = 0;
+		testVector.value[2] = 0;
+
+		CHECK(testVector.read() == retval::CATCH_OK);
+		CHECK(testVector.value[0] == 5);
+		CHECK(testVector.value[1] == 232);
+		CHECK(testVector.value[2] == 32023);
+
+		CHECK(testVector[0] == 5);
+
+		// This is invalid access, so the last value will be set instead.
+		// (we can't throw exceptions)
+		testVector[4] = 12;
+		CHECK(testVector[2] == 12);
+		CHECK(testVector.commit() == retval::CATCH_OK);
+
+		// Use read-only reference.
+		const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+		uint16_t valueOne = roTestVec[0];
+		CHECK(valueOne == 5);
+
+		uint16_t lastVal = roTestVec[25];
+		CHECK(lastVal == 12);
+
+		size_t maxSize = testVector.getSerializedSize();
+		CHECK(maxSize == 6);
+
+		uint16_t serializedVector[3];
+		uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+		size_t serSize = 0;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+
+		CHECK(serSize == 6);
+		CHECK(serializedVector[0] == 5);
+		CHECK(serializedVector[1] == 232);
+		CHECK(serializedVector[2] == 12);
+
+		maxSize = 1;
+		REQUIRE(testVector.serialize(&vecPtr, &serSize,
+				maxSize, SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+
+		serializedVector[0] = 16;
+		serializedVector[1] = 7832;
+		serializedVector[2] = 39232;
+
+		const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(
+				serializedVector);
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+		CHECK(testVector[0] == 16);
+		CHECK(testVector[1] == 7832);
+		CHECK(testVector[2] == 39232);
+
+		serSize = 1;
+		REQUIRE(testVector.deSerialize(&constVecPtr, &serSize,
+				SerializeIF::Endianness::MACHINE) ==
+				static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
+	}
+
+	SECTION("ErrorHandling") {
+		// not try to use a local pool variable which does not exist
+		lp_vec_t<uint16_t, 3> invalidVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+		REQUIRE(invalidVector.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+		REQUIRE(invalidVector.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+		// now try to access with wrong type
+		lp_vec_t<uint32_t, 3> invalidVector2 = lp_vec_t<uint32_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		REQUIRE(invalidVector2.read() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+		REQUIRE(invalidVector2.commit() ==
+				static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+		lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_WRITE);
+		REQUIRE(writeOnlyVec.read() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+		lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+				nullptr, pool_rwm_t::VAR_READ);
+		REQUIRE(readOnlyVec.commit() ==
+				static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+	}
+}
+
+
diff --git a/unittest/tests/mocks/HkReceiverMock.h b/unittest/tests/mocks/HkReceiverMock.h
new file mode 100644
index 00000000..e7509c59
--- /dev/null
+++ b/unittest/tests/mocks/HkReceiverMock.h
@@ -0,0 +1,20 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class HkReceiverMock: public SystemObject, public AcceptsHkPacketsIF {
+public:
+	HkReceiverMock(object_id_t objectId): SystemObject(objectId) {
+
+	}
+
+	MessageQueueId_t getHkQueue() const {
+		return MessageQueueIF::NO_QUEUE;
+	}
+};
+
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */
diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h
new file mode 100644
index 00000000..7b810b41
--- /dev/null
+++ b/unittest/tests/mocks/MessageQueueMockBase.h
@@ -0,0 +1,121 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
+#include <unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+#include <queue>
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = tconst::testQueueId;
+	uint8_t messageSentCounter = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+	bool wasMessageSent(uint8_t* messageSentCounter = nullptr,
+			bool resetCounter = true) {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		if(messageSentCounter != nullptr) {
+			*messageSentCounter = this->messageSentCounter;
+		}
+		if(resetCounter) {
+			this->messageSentCounter = 0;
+		}
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		return receiveMessage(message);
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		if(messagesSentQueue.empty()) {
+			return MessageQueueIF::EMPTY;
+		}
+
+		std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
+				message->getMessageSize());
+		messagesSentQueue.pop();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return myQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return myQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(sendTo, message);
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		//return HasReturnvaluesIF::RETURN_OK;
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		//messageSent = true;
+		//lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return sendMessage(myQueueId, message);
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		messageSentCounter++;
+		MessageQueueMessage& messageRef = *(
+				dynamic_cast<MessageQueueMessage*>(message));
+		messagesSentQueue.push(messageRef);
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+
+	void clearMessages(bool clearCommandMessages = true) {
+		while(not messagesSentQueue.empty()) {
+			if(clearCommandMessages) {
+				CommandMessage message;
+				std::memcpy(message.getBuffer(),
+						messagesSentQueue.front().getBuffer(),
+						message.getMessageSize());
+				message.clear();
+			}
+			messagesSentQueue.pop();
+		}
+	}
+
+private:
+	std::queue<MessageQueueMessage> messagesSentQueue;
+	//MessageQueueMessage lastMessage;
+};
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */
diff --git a/unittest/tests/storagemanager/TestNewAccessor.cpp b/unittest/tests/storagemanager/TestNewAccessor.cpp
index 7bd0dee2..10d05c6b 100644
--- a/unittest/tests/storagemanager/TestNewAccessor.cpp
+++ b/unittest/tests/storagemanager/TestNewAccessor.cpp
@@ -1,161 +1,161 @@
-//#include <fsfw/storagemanager/LocalPool.h>
-//#include <catch2/catch.hpp>
-//#include "../../core/CatchDefinitions.h"
-//#include <array>
-//
-//TEST_CASE( "New Accessor" , "[NewAccessor]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
-//	LocalPool<1> SimplePool = LocalPool<1>(0, sizeofElements, numberOfElements);
-//	std::array<uint8_t, 20> testDataArray;
-//	std::array<uint8_t, 20> receptionArray;
-//	store_address_t testStoreId;
-//	ReturnValue_t result = retval::CATCH_FAILED;
-//
-//	for(size_t i = 0; i < testDataArray.size(); i++) {
-//		testDataArray[i] = i;
-//	}
-//	size_t size = 10;
-//
-//	SECTION ("Simple tests getter functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		CHECK(resultPair.second.getId() == testStoreId);
-//		CHECK(resultPair.second.size() == 10);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		std::copy(resultPair.second.data(), resultPair.second.data() +
-//				resultPair.second.size(), receptionArray.data());
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//
-//		{
-//			auto resultPairLoc = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			// data should be deleted when accessor goes out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			ConstStorageAccessor constAccessor(testStoreId);
-//			result = SimplePool.getData(testStoreId, constAccessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			constAccessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// likewise, data should be deleted when accessor gets out of scope.
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		{
-//			resultPair = SimplePool.getData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			resultPair.second.release();
-//			// now data should not be deleted anymore
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 0; i < size; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//	}
-//
-//
-//	SECTION("Simple tests modify functions") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			StorageAccessor accessor(testStoreId);
-//			result = SimplePool.modifyData(testStoreId, accessor);
-//			REQUIRE(result == retval::CATCH_OK);
-//			CHECK(accessor.getId() == testStoreId);
-//			CHECK(accessor.size() == 10);
-//			accessor.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(accessor.data(), accessor.data() +
-//					accessor.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			// data should be deleted when accessor goes out of scope
-//		}
-//		auto resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
-//
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPairLoc = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
-//			CHECK(resultPairLoc.second.getId() == testStoreId);
-//			CHECK(resultPairLoc.second.size() == 10);
-//			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
-//					resultPairLoc.second.size(), receptionArray.data());
-//			for(size_t i = 0; i < size; i++) {
-//				CHECK(receptionArray[i] == i );
-//			}
-//			resultPairLoc.second.release();
-//			// data should not be deleted when accessor goes out of scope
-//		}
-//		resultPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//	}
-//
-//
-//	SECTION("Write tests") {
-//		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
-//		REQUIRE(result == retval::CATCH_OK);
-//		{
-//			auto resultPair = SimplePool.modifyData(testStoreId);
-//			REQUIRE(resultPair.first == retval::CATCH_OK);
-//			testDataArray[9] = 42;
-//			resultPair.second.write(testDataArray.data(), 10, 0);
-//			// now data should not be deleted
-//			resultPair.second.release();
-//		}
-//		auto resultConstPair = SimplePool.getData(testStoreId);
-//		REQUIRE(resultConstPair.first == retval::CATCH_OK);
-//
-//		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
-//		for(size_t i = 0; i < size-1; i++) {
-//			CHECK(receptionArray[i] == i );
-//		}
-//		CHECK(receptionArray[9] == 42 );
-//
-//		auto resultPair = SimplePool.modifyData(testStoreId);
-//		REQUIRE(resultPair.first == retval::CATCH_OK);
-//		result = resultPair.second.write(testDataArray.data(), 20, 0);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//		result = resultPair.second.write(testDataArray.data(), 10, 5);
-//		REQUIRE(result == retval::CATCH_FAILED);
-//
-//		memset(testDataArray.data(), 42, 5);
-//		result = resultPair.second.write(testDataArray.data(), 5, 5);
-//		REQUIRE(result == retval::CATCH_OK);
-//		resultConstPair = SimplePool.getData(testStoreId);
-//		resultPair.second.getDataCopy(receptionArray.data(), 20);
-//		for(size_t i = 5; i < 10; i++) {
-//			CHECK(receptionArray[i] == 42 );
-//		}
-//
-//	}
-//}
+#include <fsfw/storagemanager/LocalPool.h>
+#include <catch2/catch_test_macros.hpp>
+#include <unittest/core/CatchDefinitions.h>
+#include <array>
+#include <cstring>
+
+TEST_CASE( "New Accessor" , "[NewAccessor]") {
+	LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
+	LocalPool SimplePool = LocalPool(0, poolCfg);
+	std::array<uint8_t, 20> testDataArray;
+	std::array<uint8_t, 20> receptionArray;
+	store_address_t testStoreId;
+	ReturnValue_t result = retval::CATCH_FAILED;
+
+	for(size_t i = 0; i < testDataArray.size(); i++) {
+		testDataArray[i] = i;
+	}
+	size_t size = 10;
+
+	SECTION ("Simple tests getter functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		CHECK(resultPair.second.getId() == testStoreId);
+		CHECK(resultPair.second.size() == 10);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		std::copy(resultPair.second.data(), resultPair.second.data() +
+				resultPair.second.size(), receptionArray.data());
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+
+		{
+			auto resultPairLoc = SimplePool.getData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			// data should be deleted when accessor goes out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			ConstStorageAccessor constAccessor(testStoreId);
+			result = SimplePool.getData(testStoreId, constAccessor);
+			REQUIRE(result == retval::CATCH_OK);
+			constAccessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// likewise, data should be deleted when accessor gets out of scope.
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		{
+			resultPair = SimplePool.getData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			resultPair.second.release();
+			// now data should not be deleted anymore
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 0; i < size; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+	}
+
+
+	SECTION("Simple tests modify functions") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			StorageAccessor accessor(testStoreId);
+			result = SimplePool.modifyData(testStoreId, accessor);
+			REQUIRE(result == retval::CATCH_OK);
+			CHECK(accessor.getId() == testStoreId);
+			CHECK(accessor.size() == 10);
+			accessor.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(accessor.data(), accessor.data() +
+					accessor.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			// data should be deleted when accessor goes out of scope
+		}
+		auto resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == (int) StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPairLoc = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+			CHECK(resultPairLoc.second.getId() == testStoreId);
+			CHECK(resultPairLoc.second.size() == 10);
+			resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			std::copy(resultPairLoc.second.data(), resultPairLoc.second.data() +
+					resultPairLoc.second.size(), receptionArray.data());
+			for(size_t i = 0; i < size; i++) {
+				CHECK(receptionArray[i] == i );
+			}
+			resultPairLoc.second.release();
+			// data should not be deleted when accessor goes out of scope
+		}
+		resultPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+	}
+
+
+	SECTION("Write tests") {
+		result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+		REQUIRE(result == retval::CATCH_OK);
+		{
+			auto resultPair = SimplePool.modifyData(testStoreId);
+			REQUIRE(resultPair.first == retval::CATCH_OK);
+			testDataArray[9] = 42;
+			resultPair.second.write(testDataArray.data(), 10, 0);
+			// now data should not be deleted
+			resultPair.second.release();
+		}
+		auto resultConstPair = SimplePool.getData(testStoreId);
+		REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+		resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+		for(size_t i = 0; i < size-1; i++) {
+			CHECK(receptionArray[i] == i );
+		}
+		CHECK(receptionArray[9] == 42 );
+
+		auto resultPair = SimplePool.modifyData(testStoreId);
+		REQUIRE(resultPair.first == retval::CATCH_OK);
+		result = resultPair.second.write(testDataArray.data(), 20, 0);
+		REQUIRE(result == retval::CATCH_FAILED);
+		result = resultPair.second.write(testDataArray.data(), 10, 5);
+		REQUIRE(result == retval::CATCH_FAILED);
+
+		std::memset(testDataArray.data(), 42, 5);
+		result = resultPair.second.write(testDataArray.data(), 5, 5);
+		REQUIRE(result == retval::CATCH_OK);
+		resultConstPair = SimplePool.getData(testStoreId);
+		resultPair.second.getDataCopy(receptionArray.data(), 20);
+		for(size_t i = 5; i < 10; i++) {
+			CHECK(receptionArray[i] == 42 );
+		}
+
+	}
+}
diff --git a/unittest/tests/storagemanager/TestPool.cpp b/unittest/tests/storagemanager/TestPool.cpp
index dcfb6c03..50bde01a 100644
--- a/unittest/tests/storagemanager/TestPool.cpp
+++ b/unittest/tests/storagemanager/TestPool.cpp
@@ -8,8 +8,6 @@
 
 
 TEST_CASE( "Local Pool Simple Tests [1 Pool]" , "[TestPool]") {
-//	uint16_t numberOfElements[1] = {1};
-//	uint16_t sizeofElements[1] = {10};
 	LocalPool::LocalPoolConfig config = {{1, 10}};
 	LocalPool simplePool(0, config);
 	std::array<uint8_t, 20> testDataArray;
diff --git a/unittest/user/CMakeLists.txt b/unittest/user/CMakeLists.txt
index 6ec314c3..722cc424 100644
--- a/unittest/user/CMakeLists.txt
+++ b/unittest/user/CMakeLists.txt
@@ -13,7 +13,19 @@ cmake_minimum_required(VERSION 3.13)
 
 # set(CMAKE_VERBOSE TRUE)
 
-set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake")
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+option(TMTC_TEST "Build binary for manual or automatic TMTC tests" FALSE)
+option(GENERATE_COVERAGE 
+	"Specify whether coverage data is generated with GCOV" 
+	TRUE
+)
+
+if(TMTC_TEST)
+	set(LINK_CATCH2 FALSE)
+else()
+	set(LINK_CATCH2 TRUE)
+endif()
 
 # Tests can be built with the Host OSAL or with the Linux OSAL.
 if(NOT OS_FSFW)
@@ -53,6 +65,7 @@ set(FSFW_PATH fsfw)
 set(CATCH2_PATH Catch2)
 set(FSFW_TESTS_PATH fsfw/unittest)
 set(TEST_SETUP_PATH unittest)
+set(TMTC_TEST_PATH tests)
 
 # Analyse different OS and architecture/target options and
 # determine BSP_PATH
@@ -71,6 +84,15 @@ else()
 	endif()
 endif()
 
+if(GENERATE_COVERAGE)
+	list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/cmake-modules)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+    	include(CodeCoverage)
+    	# Add compile options on target base, we don't want coverage for Catch2
+    	# append_coverage_compiler_flags()
+   	endif()
+endif()
+
 set(FSFW_CONFIG_PATH testcfg)
 
 ################################################################################
@@ -82,10 +104,16 @@ add_executable(${TARGET_NAME})
 
 # Add subdirectories
 add_subdirectory(${FSFW_PATH})
-add_subdirectory(${CATCH2_PATH})
 add_subdirectory(${FSFW_CONFIG_PATH})
-add_subdirectory(${FSFW_TESTS_PATH})
-add_subdirectory(${TEST_SETUP_PATH})
+
+if(LINK_CATCH2)
+	add_subdirectory(${CATCH2_PATH})
+	add_subdirectory(${FSFW_TESTS_PATH})
+	add_subdirectory(${TEST_SETUP_PATH})
+else()
+	add_subdirectory(${TMTC_TEST_PATH})
+endif()
+
 
 ################################################################################
 # Post-Sources preparation
@@ -94,9 +122,74 @@ add_subdirectory(${TEST_SETUP_PATH})
 # Add libraries for all sources.
 target_link_libraries(${TARGET_NAME} PRIVATE
 	${LIB_FSFW_NAME} 
-	${CATCH2_TARGET}
 )
 
+if(LINK_CATCH2)
+	target_link_libraries(${TARGET_NAME} PRIVATE
+		${CATCH2_TARGET}
+	)
+endif()
+
+if(GENERATE_COVERAGE)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(CODE_COVERAGE_VERBOSE TRUE)
+    	include(CodeCoverage)
+    	
+    	# Remove quotes.
+    	separate_arguments(COVERAGE_COMPILER_FLAGS 
+    		NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+    	# Add compile options manually, we don't want coverage for Catch2
+    	target_compile_options(${TARGET_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	target_compile_options(${LIB_FSFW_NAME} PRIVATE
+    		"${COVERAGE_COMPILER_FLAGS}"
+    	)
+    	
+		# Exclude internal unittest from coverage for now.
+    	if(WIN32)
+			set(GCOVR_ADDITIONAL_ARGS 
+				"--exclude-throw-branches"
+				"--exclude-unreachable-branches"
+			)
+			set(COVERAGE_EXCLUDES
+				"/c/msys64/mingw64/*" "Catch2"
+				"${CMAKE_CURRENT_SOURCE_DIR}/fsfw/unittest/internal"
+			)
+		elseif(UNIX)
+			set(COVERAGE_EXCLUDES
+				"/usr/include/*" "/usr/bin/*" "Catch2/*"
+				"fsfw/unittest/internal/*"
+			)
+		endif()
+    	
+		target_link_options(${TARGET_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	target_link_options(${LIB_FSFW_NAME} PRIVATE
+			-fprofile-arcs
+			-ftest-coverage
+    	)
+    	
+		if(WIN32)
+			setup_target_for_coverage_gcovr_html(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+    	else()
+			setup_target_for_coverage_lcov(
+				NAME ${TARGET_NAME}_coverage
+				EXECUTABLE ${TARGET_NAME}
+				DEPENDENCIES ${TARGET_NAME}
+			)
+		endif()
+	endif()
+endif()
+
 # Add include paths for all sources.
 target_include_directories(${TARGET_NAME} PRIVATE
 	${CMAKE_CURRENT_SOURCE_DIR}
@@ -147,8 +240,7 @@ if(NOT CMAKE_SIZE)
 	endif()
 endif()
 
-add_custom_command(
-   TARGET ${TARGET_NAME}
+add_custom_command(TARGET ${TARGET_NAME}
    POST_BUILD
    COMMAND echo "Build directory: ${CMAKE_BINARY_DIR}"
    COMMAND echo "Target OSAL: ${OS_FSFW}"
@@ -156,7 +248,7 @@ add_custom_command(
    COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
 )
 
-include (${CMAKE_CURRENT_SOURCE_DIR}/buildsystem/cmake/BuildType.cmake)
+include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()
 
 
diff --git a/unittest/user/testcfg/FSFWConfig.h b/unittest/user/testcfg/FSFWConfig.h
index 6b0def90..ed86e6e1 100644
--- a/unittest/user/testcfg/FSFWConfig.h
+++ b/unittest/user/testcfg/FSFWConfig.h
@@ -4,16 +4,21 @@
 #include <cstddef>
 #include <cstdint>
 
-//! Used to determine whether C++ ostreams are used
-//! Those can lead to code bloat.
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
 #define FSFW_CPP_OSTREAM_ENABLED 	1
 
-//! Reduced printout to further decrease code size
-//! Be careful, this also turns off most diagnostic prinouts!
-#define FSFW_ENHANCED_PRINTOUT		0
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
 
-//! Can be used to enable additional debugging printouts for developing the FSFW
-#define FSFW_PRINT_VERBOSITY_LEVEL   0
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
 
 //! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
 //! additional output which requires the translation files translateObjects
@@ -49,7 +54,9 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 //! also determines how many commands a CSB service can handle in one cycle
 //! simulataneously. This will increase the required RAM for
 //! each CSB service !
-static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 3;
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
 }
 
 #endif /* CONFIG_FSFWCONFIG_H_ */
diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h
index 0e034aff..88b92131 100644
--- a/unittest/user/testcfg/objects/systemObjectList.h
+++ b/unittest/user/testcfg/objects/systemObjectList.h
@@ -9,7 +9,20 @@ namespace objects {
 	enum sourceObjects: uint32_t {
 		/* All addresses between start and end are reserved for the FSFW */
 		FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
-		FSFW_CONFIG_RESERVED_END = TM_STORE
+		FSFW_CONFIG_RESERVED_END = TM_STORE,
+
+		CCSDS_DISTRIBUTOR = 10,
+		PUS_DISTRIBUTOR = 11,
+		TM_FUNNEL = 12,
+
+		UDP_BRIDGE = 15,
+		UDP_POLLING_TASK = 16,
+
+		TEST_ECHO_COM_IF = 20,
+		TEST_DEVICE = 21,
+
+		HK_RECEIVER_MOCK = 22,
+		TEST_LOCAL_POOL_OWNER_BASE = 25
 	};
 }
 
diff --git a/unittest/user/unittest/CMakeLists.txt b/unittest/user/unittest/CMakeLists.txt
new file mode 100644
index 00000000..ad6d4787
--- /dev/null
+++ b/unittest/user/unittest/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(core)
diff --git a/unittest/user/unittest/core/CMakeLists.txt b/unittest/user/unittest/core/CMakeLists.txt
index d78f45f1..0989926c 100644
--- a/unittest/user/unittest/core/CMakeLists.txt
+++ b/unittest/user/unittest/core/CMakeLists.txt
@@ -5,3 +5,9 @@ target_sources(${TARGET_NAME} PRIVATE
 	CatchSetup.cpp
 	printChar.cpp
 )
+
+if(CUSTOM_UNITTEST_RUNNER)
+	target_sources(${TARGET_NAME} PRIVATE
+		CatchRunner.cpp
+	)
+endif()
\ No newline at end of file
diff --git a/unittest/user/unittest/core/CatchDefinitions.cpp b/unittest/user/unittest/core/CatchDefinitions.cpp
index 00daf015..bae02875 100644
--- a/unittest/user/unittest/core/CatchDefinitions.cpp
+++ b/unittest/user/unittest/core/CatchDefinitions.cpp
@@ -1,4 +1,5 @@
 #include "CatchDefinitions.h"
+#include <fsfw/serviceinterface/ServiceInterface.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
@@ -7,7 +8,9 @@ StorageManagerIF* tglob::getIpcStoreHandle() {
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;
-#endif
+#else
+		sif::printError("Global object manager uninitialized\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 		return nullptr;
 	}
 }
diff --git a/unittest/user/unittest/core/CatchFactory.cpp b/unittest/user/unittest/core/CatchFactory.cpp
index 3177212f..eabaa21d 100644
--- a/unittest/user/unittest/core/CatchFactory.cpp
+++ b/unittest/user/unittest/core/CatchFactory.cpp
@@ -1,11 +1,17 @@
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include "CatchFactory.h"
 
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-
 #include <fsfw/internalError/InternalErrorReporter.h>
 #include <fsfw/objectmanager/frameworkObjects.h>
 #include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/unittest/tests/datapoollocal/LocalPoolOwnerBase.h>
+#include <fsfw/unittest/tests/mocks/HkReceiverMock.h>
 
 /**
  * @brief Produces system objects.
@@ -26,6 +32,9 @@ void Factory::produce(void) {
 	new HealthTable(objects::HEALTH_TABLE);
 	new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
 
+	new LocalPoolOwnerBase (objects::TEST_LOCAL_POOL_OWNER_BASE);
+	new HkReceiverMock(objects::HK_RECEIVER_MOCK);
+
 	{
 		PoolManager::LocalPoolConfig poolCfg = {
 		        {100, 16}, {50, 32}, {25, 64} , {15, 128}, {5, 1024}
@@ -50,7 +59,23 @@ void Factory::produce(void) {
 }
 
 void Factory::setStaticFrameworkObjectIds() {
+	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::packetDestination = objects::NO_OBJECT;
 
+	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;
+
+	LocalDataPoolManager::defaultHkDestination = objects::HK_RECEIVER_MOCK;
+
+	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+	TmPacketStored::timeStamperId = objects::NO_OBJECT;
 }
 
 
+
diff --git a/unittest/user/unittest/core/CatchRunner.cpp b/unittest/user/unittest/core/CatchRunner.cpp
index 35c53cd4..886d641f 100644
--- a/unittest/user/unittest/core/CatchRunner.cpp
+++ b/unittest/user/unittest/core/CatchRunner.cpp
@@ -1,17 +1,16 @@
 /**
- * @file 	CatchSource.cpp
+ * @file 	CatchRunner.cpp
  * @brief 	Source file to compile catch framework.
  * @details	All tests should be written in other files.
  * For eclipse console output, install ANSI Escape in Console
  * from the eclipse market place to get colored characters.
  */
 
-#ifndef NO_UNIT_TEST_FRAMEWORK
+#include <TestsConfig.h>
 
-#define CATCH_CONFIG_RUNNER
-#include <catch2/catch.hpp>
+#define CATCH_CONFIG_COLOUR_WINDOWS
 
-#if CUSTOM_UNITTEST_RUNNER == 0
+#include <catch2/catch_session.hpp>
 
 extern int customSetup();
 
@@ -25,7 +24,3 @@ int main( int argc, char* argv[] ) {
     return result;
 }
 
-#endif
-
-
-#endif
diff --git a/unittest/user/unittest/core/CatchSetup.cpp b/unittest/user/unittest/core/CatchSetup.cpp
index c93cf032..bda31400 100644
--- a/unittest/user/unittest/core/CatchSetup.cpp
+++ b/unittest/user/unittest/core/CatchSetup.cpp
@@ -1,21 +1,20 @@
-#include <fsfw/unittest/core/CatchFactory.h>
+#include "CatchFactory.h"
 #include "CatchDefinitions.h"
-#include <testcfg/cdatapool/dataPoolInit.h>
 
 #ifdef GCOV
 #include <gcov.h>
 #endif
 
-#include "../../objectmanager/ObjectManager.h"
-#include "../../objectmanager/ObjectManagerIF.h"
-#include "../../storagemanager/StorageManagerIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 
 
 /* Global instantiations normally done in main.cpp */
 /* Initialize Data Pool */
 
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
 namespace sif {
 /* Set up output streams */
 ServiceInterfaceStream debug("DEBUG");
@@ -23,6 +22,7 @@ ServiceInterfaceStream info("INFO");
 ServiceInterfaceStream error("ERROR");
 ServiceInterfaceStream warning("WARNING");
 }
+#endif
 
 /* Global object manager */
 ObjectManagerIF *objectManager;
diff --git a/unittest/user/unittest/core/printChar.cpp b/unittest/user/unittest/core/printChar.cpp
index 755a13b2..5d4f1b17 100644
--- a/unittest/user/unittest/core/printChar.cpp
+++ b/unittest/user/unittest/core/printChar.cpp
@@ -1,4 +1,4 @@
-#include <fsfw/unittest/core/printChar.h>
+#include "printChar.h"
 #include <cstdio>
 
 void printChar(const char* character, bool errStream) {

From c3bca518e707f8dd563f39b9e873b949d58f6961 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:12:08 +0100
Subject: [PATCH 1277/1292] bugfixes and auto indentation

---
 datapoollocal/LocalPoolDataSetBase.cpp | 369 +++++++++++++------------
 1 file changed, 186 insertions(+), 183 deletions(-)

diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 5343a9c9..f3cd7106 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -11,47 +11,50 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-        uint32_t setId, PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables, bool periodicHandling):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-    if(hkOwner == nullptr) {
-        // Configuration error.
+		uint32_t setId, PoolVariableIF** registeredVariablesArray,
+		const size_t maxNumberOfVariables, bool periodicHandling):
+		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+	if(hkOwner == nullptr) {
+		// Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                << "invalid!" << std::endl;
+		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				<< "invalid!" << std::endl;
 #else
-        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-                "invalid!\n\r");
+		sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+				"invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        return;
-    }
-    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+		return;
+	}
+	AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-    if(poolManager != nullptr) {
-        poolManager = accessor->getHkManagerHandle();
-    	mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-    }
+	if(accessor != nullptr) {
+		poolManager = accessor->getHkManagerHandle();
+		mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+	}
 
-    this->sid.objectId = hkOwner->getObjectId();
-    this->sid.ownerSetId = setId;
+	this->sid.objectId = hkOwner->getObjectId();
+	this->sid.ownerSetId = setId;
 
-    // Data creators get a periodic helper for periodic HK data generation.
-    if(periodicHandling) {
-        periodicHelper = new PeriodicHousekeepingHelper(this);
-    }
+	// Data creators get a periodic helper for periodic HK data generation.
+	if(periodicHandling) {
+		periodicHelper = new PeriodicHousekeepingHelper(this);
+	}
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-        PoolVariableIF** registeredVariablesArray,
-        const size_t maxNumberOfVariables):
+		PoolVariableIF** registeredVariablesArray,
+		const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	AccessPoolManagerIF* hkOwner = objectManager->get<AccessPoolManagerIF>(
-            sid.objectId);
-    if(hkOwner != nullptr) {
-    	mutexIfSingleDataCreator = hkOwner->getLocalPoolMutex();
-    }
+	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+			sid.objectId);
+	if(hkOwner != nullptr) {
+		AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+		if(accessor != nullptr) {
+			mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+		}
+	}
 
-    this->sid = sid;
+	this->sid = sid;
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
@@ -72,240 +75,240 @@ ReturnValue_t LocalPoolDataSetBase::lockDataPool(
 		MutexIF::TimeoutType timeoutType,
 		uint32_t timeoutMs) {
 	if(mutexIfSingleDataCreator != nullptr) {
-	    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
+		return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
-        size_t *size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-    uint8_t validityMask[validityMaskSize];
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        if(registeredVariables[count]->isValid()) {
-            // set validity buffer here.
-            this->bitSetter(validityMask + validBufferIndex,
-                    validBufferIndexBit);
-            if(validBufferIndexBit == 7) {
-                validBufferIndex ++;
-                validBufferIndexBit = 0;
-            }
-            else {
-                validBufferIndexBit ++;
-            }
-        }
-        result = registeredVariables[count]->serialize(buffer, size, maxSize,
-                streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
+		size_t *size, size_t maxSize,
+		SerializeIF::Endianness streamEndianness) const {
+	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+	uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+	uint8_t validityMask[validityMaskSize];
+	uint8_t validBufferIndex = 0;
+	uint8_t validBufferIndexBit = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		if(registeredVariables[count]->isValid()) {
+			// set validity buffer here.
+			this->bitSetter(validityMask + validBufferIndex,
+					validBufferIndexBit);
+			if(validBufferIndexBit == 7) {
+				validBufferIndex ++;
+				validBufferIndexBit = 0;
+			}
+			else {
+				validBufferIndexBit ++;
+			}
+		}
+		result = registeredVariables[count]->serialize(buffer, size, maxSize,
+				streamEndianness);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	}
 
-    if(*size + validityMaskSize > maxSize) {
-        return SerializeIF::BUFFER_TOO_SHORT;
-    }
-    // copy validity buffer to end
-    std::memcpy(*buffer, validityMask, validityMaskSize);
-    *size += validityMaskSize;
-    return result;
+	if(*size + validityMaskSize > maxSize) {
+		return SerializeIF::BUFFER_TOO_SHORT;
+	}
+	// copy validity buffer to end
+	std::memcpy(*buffer, validityMask, validityMaskSize);
+	*size += validityMaskSize;
+	return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
-        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;
-        }
-    }
+		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;
+		}
+	}
 
-    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
-        return SerializeIF::STREAM_TOO_SHORT;
-    }
+	if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+		return SerializeIF::STREAM_TOO_SHORT;
+	}
 
-    uint8_t validBufferIndex = 0;
-    uint8_t validBufferIndexBit = 0;
-    for (uint16_t count = 0; count < fillCount; count++) {
-        // set validity buffer here.
-        bool nextVarValid = this->bitGetter(*buffer +
-                validBufferIndex, validBufferIndexBit);
-        registeredVariables[count]->setValid(nextVarValid);
+	uint8_t validBufferIndex = 0;
+	uint8_t validBufferIndexBit = 0;
+	for (uint16_t count = 0; count < fillCount; count++) {
+		// set validity buffer here.
+		bool nextVarValid = this->bitGetter(*buffer +
+				validBufferIndex, validBufferIndexBit);
+		registeredVariables[count]->setValid(nextVarValid);
 
-        if(validBufferIndexBit == 7) {
-            validBufferIndex ++;
-            validBufferIndexBit = 0;
-        }
-        else {
-            validBufferIndexBit ++;
-        }
-    }
-    return result;
+		if(validBufferIndexBit == 7) {
+			validBufferIndex ++;
+			validBufferIndexBit = 0;
+		}
+		else {
+			validBufferIndexBit ++;
+		}
+	}
+	return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
 	if(mutexIfSingleDataCreator != nullptr) {
-	    return mutexIfSingleDataCreator->unlockMutex();
+		return mutexIfSingleDataCreator->unlockMutex();
 	}
 	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
-        bool serializeFillCount) const {
-    // Serialize as uint8_t
-    uint8_t fillCount = this->fillCount;
-    if(serializeFillCount) {
-        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
-                streamEndianness);
-    }
-    for (uint16_t count = 0; count < fillCount; count++) {
-        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-                size, maxSize, streamEndianness);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
+		size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+		bool serializeFillCount) const {
+	// Serialize as uint8_t
+	uint8_t fillCount = this->fillCount;
+	if(serializeFillCount) {
+		SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+				streamEndianness);
+	}
+	for (uint16_t count = 0; count < fillCount; count++) {
+		lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+		auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+				size, maxSize, streamEndianness);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
-            		<< "Serialization error!" << std::endl;
+		sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+				<< "Serialization error!" << std::endl;
 #else
-            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
-            		"Serialization error!\n\r");
+		sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+				"Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-            return result;
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+		return result;
+		}
+	}
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
-        bool serializeFillCount) const {
-    if(serializeFillCount) {
-        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
-    }
-    else {
-        return fillCount * sizeof(lp_id_t);
-    }
+		bool serializeFillCount) const {
+	if(serializeFillCount) {
+		return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+	}
+	else {
+		return fillCount * sizeof(lp_id_t);
+	}
 }
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
-    if(withValidityBuffer) {
-        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-        return validityMaskSize + PoolDataSetBase::getSerializedSize();
-    }
-    else {
-        return PoolDataSetBase::getSerializedSize();
-    }
+	if(withValidityBuffer) {
+		uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+		return validityMaskSize + PoolDataSetBase::getSerializedSize();
+	}
+	else {
+		return PoolDataSetBase::getSerializedSize();
+	}
 }
 
 void LocalPoolDataSetBase::setValidityBufferGeneration(
-        bool withValidityBuffer) {
-    this->withValidityBuffer = withValidityBuffer;
+		bool withValidityBuffer) {
+	this->withValidityBuffer = withValidityBuffer;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
-        size_t *size, SerializeIF::Endianness streamEndianness) {
-    if(withValidityBuffer) {
-        return this->deSerializeWithValidityBuffer(buffer, size,
-                streamEndianness);
-    }
-    else {
-        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
-    }
+		size_t *size, SerializeIF::Endianness streamEndianness) {
+	if(withValidityBuffer) {
+		return this->deSerializeWithValidityBuffer(buffer, size,
+				streamEndianness);
+	}
+	else {
+		return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+	}
 }
 
 ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
-        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-    if(withValidityBuffer) {
-        return this->serializeWithValidityBuffer(buffer, size,
-                maxSize, streamEndianness);
-    }
-    else {
-        return PoolDataSetBase::serialize(buffer, size, maxSize,
-                streamEndianness);
-    }
+		size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+	if(withValidityBuffer) {
+		return this->serializeWithValidityBuffer(buffer, size,
+				maxSize, streamEndianness);
+	}
+	else {
+		return PoolDataSetBase::serialize(buffer, size, maxSize,
+				streamEndianness);
+	}
 }
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-    if(position > 7) {
+	if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-                << std::endl;
+		sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
+		<< std::endl;
 #else
-        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-        		"Invalid position!\n\r");
+		sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+				"Invalid position!\n\r");
 #endif
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
+		return;
+	}
+	uint8_t shiftNumber = position + (7 - 2 * position);
+	*byte |= 1 << shiftNumber;
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-    this->diagnostic = isDiagnostics;
+	this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-    return diagnostic;
+	return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-    this->reportingEnabled = reportingEnabled;
+	this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-    return reportingEnabled;
+	return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-        float collectionInterval, dur_millis_t minimumPeriodicInterval,
-        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-            isDiagnostics, nonDiagIntervalFactor);
+		float collectionInterval, dur_millis_t minimumPeriodicInterval,
+		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+			isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-    this->changed = changed;
+	this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-    return changed;
+	return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-    return sid;
+	return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-        uint8_t position) const {
-    if(position > 7) {
+		uint8_t position) const {
+	if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
-                << std::endl;
+		sif::debug << "Pool Raw Access: Bit setting invalid position"
+				<< std::endl;
 #endif
-        return false;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
+		return false;
+	}
+	uint8_t shiftNumber = position + (7 - 2 * position);
+	return *byte & (1 << shiftNumber);
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-    return this->valid;
+	return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-    if(setEntriesRecursively) {
-        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-            registeredVariables[idx] -> setValid(valid);
-        }
-    }
-    this->valid = valid;
+	if(setEntriesRecursively) {
+		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+			registeredVariables[idx] -> setValid(valid);
+		}
+	}
+	this->valid = valid;
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {

From fdef8bc22b3f85652ce76b060d68c1142eacd3e4 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:18:05 +0100
Subject: [PATCH 1278/1292] read commit if

---
 datapool/ReadCommitIF.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapool/ReadCommitIF.h b/datapool/ReadCommitIF.h
index efe51594..e6355e82 100644
--- a/datapool/ReadCommitIF.h
+++ b/datapool/ReadCommitIF.h
@@ -1,8 +1,8 @@
 #ifndef FSFW_DATAPOOL_READCOMMITIF_H_
 #define FSFW_DATAPOOL_READCOMMITIF_H_
 
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/ipc/MutexIF.h>
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../ipc/MutexIF.h"
 
 /**
  * @brief 	Common interface for all software objects which employ read-commit

From a4e0f15dac6109aec504805a774cd8689c1eaa93 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:41:24 +0100
Subject: [PATCH 1279/1292] consistency changes

---
 datapoollocal/AccessLocalPoolF.h              |  16 +-
 datapoollocal/HasLocalDataPoolIF.h            | 138 +++---
 datapoollocal/LocalDataSet.cpp                |   6 +-
 datapoollocal/LocalDataSet.h                  |   2 +-
 datapoollocal/LocalPoolDataSetBase.cpp        | 412 +++++++++---------
 datapoollocal/LocalPoolDataSetBase.h          | 311 ++++++-------
 datapoollocal/LocalPoolObjectBase.cpp         | 150 +++----
 datapoollocal/LocalPoolObjectBase.h           |  17 +-
 datapoollocal/LocalPoolVariable.h             | 272 ++++++------
 datapoollocal/LocalPoolVariable.tpp           | 176 ++++----
 datapoollocal/LocalPoolVector.h               | 258 +++++------
 datapoollocal/LocalPoolVector.tpp             | 198 ++++-----
 datapoollocal/PoolReadHelper.h                |  44 +-
 .../ProvidesDataPoolSubscriptionIF.h          | 126 +++---
 datapoollocal/SharedLocalDataSet.h            |   3 +-
 datapoollocal/StaticLocalDataSet.h            |  32 +-
 datapoollocal/localPoolDefinitions.h          |  32 +-
 17 files changed, 1099 insertions(+), 1094 deletions(-)

diff --git a/datapoollocal/AccessLocalPoolF.h b/datapoollocal/AccessLocalPoolF.h
index da08644f..f68189f6 100644
--- a/datapoollocal/AccessLocalPoolF.h
+++ b/datapoollocal/AccessLocalPoolF.h
@@ -9,16 +9,16 @@ class MutexIF;
  */
 class AccessPoolManagerIF {
 public:
-	virtual ~AccessPoolManagerIF() {};
+    virtual ~AccessPoolManagerIF() {};
 
-	virtual MutexIF* getLocalPoolMutex() = 0;
+    virtual MutexIF* getLocalPoolMutex() = 0;
 
-	/**
-	 * Can be used to get a handle to the local data pool manager.
-	 * This function is protected because it should only be used by the
-	 * class imlementing the interface.
-	 */
-	virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+    /**
+     * Can be used to get a handle to the local data pool manager.
+     * This function is protected because it should only be used by the
+     * class imlementing the interface.
+     */
+    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
 
 protected:
 
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 569f2b09..3d822650 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -30,32 +30,32 @@ class LocalDataPoolManager;
  *
  */
 class HasLocalDataPoolIF {
-	friend class HasLocalDpIFManagerAttorney;
-	friend class HasLocalDpIFUserAttorney;
+    friend class HasLocalDpIFManagerAttorney;
+    friend class HasLocalDpIFUserAttorney;
 public:
-	virtual~ HasLocalDataPoolIF() {};
+    virtual~ HasLocalDataPoolIF() {};
 
-	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	virtual object_id_t getObjectId() const = 0;
+    virtual object_id_t getObjectId() const = 0;
 
-	/** Command queue for housekeeping messages. */
-	virtual MessageQueueId_t getCommandQueue() const = 0;
+    /** Command queue for housekeeping messages. */
+    virtual MessageQueueId_t getCommandQueue() const = 0;
 
-	/**
-	 * Is used by pool owner to initialize the pool map once
-	 * The manager instance shall also be passed to this function.
-	 * It can be used to subscribe for periodic packets for for updates.
-	 */
-	virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-	        LocalDataPoolManager& poolManager) = 0;
+    /**
+     * Is used by pool owner to initialize the pool map once
+     * The manager instance shall also be passed to this function.
+     * It can be used to subscribe for periodic packets for for updates.
+     */
+    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) = 0;
 
-	/**
-	 * Returns the minimum sampling frequency in milliseconds, which will
-	 * usually be the period the pool owner performs its periodic operation.
-	 * @return
-	 */
-	virtual uint32_t getPeriodicOperationFrequency() const = 0;
+    /**
+     * Returns the minimum sampling frequency in milliseconds, which will
+     * usually be the period the pool owner performs its periodic operation.
+     * @return
+     */
+    virtual uint32_t getPeriodicOperationFrequency() const = 0;
 
     /**
      * @brief   This function will be called by the manager if an update
@@ -67,7 +67,7 @@ public:
      * the IPC store with this store ID.
      */
     virtual void handleChangedDataset(sid_t sid,
-    		store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
+            store_address_t storeId = storeId::INVALID_STORE_ADDRESS) {
         return;
     }
 
@@ -85,68 +85,68 @@ public:
         return;
     }
 
-	/**
-	 * These function can be implemented by pool owner, if they are required
-	 * and used by the housekeeping message interface.
-	 * */
-	virtual ReturnValue_t addDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t removeDataSet(sid_t sid) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
-	virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	};
+    /**
+     * These function can be implemented by pool owner, if they are required
+     * and used by the housekeeping message interface.
+     * */
+    virtual ReturnValue_t addDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t removeDataSet(sid_t sid) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
+    virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    };
 
-	/**
-	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates in form of messages.
-	 * The consumers can then read the most recent variable value by calling read with
-	 * an own pool variable or set instance or using the deserialized snapshot data.
-	 * @return
-	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+    /**
+     * This function can be used by data pool consumers to retrieve a handle
+     * which allows subscriptions to dataset and variable updates in form of messages.
+     * The consumers can then read the most recent variable value by calling read with
+     * an own pool variable or set instance or using the deserialized snapshot data.
+     * @return
+     */
+    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
 
 protected:
 
-	/**
-	 * Accessor handle required for internal handling. Not intended for users and therefore
-	 * declared protected. Users should instead use pool variables, sets or the subscription
-	 * interface to access pool entries.
-	 * @return
-	 */
-	virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+    /**
+     * Accessor handle required for internal handling. Not intended for users and therefore
+     * declared protected. Users should instead use pool variables, sets or the subscription
+     * interface to access pool entries.
+     * @return
+     */
+    virtual AccessPoolManagerIF* getAccessorHandle() = 0;
 
-	/**
-	 * This function is used by the pool manager to get a valid dataset
+    /**
+     * This function is used by the pool manager to get a valid dataset
      * from a SID. This function is protected to prevent users from
      * using raw data set pointers which could not be thread-safe. Users
      * should use the #ProvidesDataPoolSubscriptionIF.
-	 * @param sid Corresponding structure ID
-	 * @return
-	 */
-	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
+     * @param sid Corresponding structure ID
+     * @return
+     */
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
 
-	/**
-	 * Similar to the function above, but used to get a local pool variable
-	 * handle. This is only needed for update notifications, so it is not
-	 * defined as abstract. This function is protected to prevent users from
+    /**
+     * Similar to the function above, but used to get a local pool variable
+     * handle. This is only needed for update notifications, so it is not
+     * defined as abstract. This function is protected to prevent users from
      * using raw pool variable pointers which could not be thread-safe.
      * Users should use the #ProvidesDataPoolSubscriptionIF.
-	 * @param localPoolId
-	 * @return
-	 */
-	virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
+     * @param localPoolId
+     * @return
+     */
+    virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-	            << ". Returning nullptr!" << std::endl;
+        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
+                << ". Returning nullptr!" << std::endl;
 #else
-	    sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
-	    		"Not overriden. Returning nullptr!\n");
+        sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
+                "Not overriden. Returning nullptr!\n");
 #endif
-	    return nullptr;
-	}
+        return nullptr;
+    }
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/datapoollocal/LocalDataSet.cpp b/datapoollocal/LocalDataSet.cpp
index 394a9abe..aeb5c6b3 100644
--- a/datapoollocal/LocalDataSet.cpp
+++ b/datapoollocal/LocalDataSet.cpp
@@ -9,13 +9,13 @@ LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
         const size_t maxNumberOfVariables):
         LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
         poolVarList(maxNumberOfVariables) {
-	this->setContainer(poolVarList.data());
+    this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables):
         LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables),
-		poolVarList(maxNumberOfVariables) {
-	this->setContainer(poolVarList.data());
+        poolVarList(maxNumberOfVariables) {
+    this->setContainer(poolVarList.data());
 }
 
 LocalDataSet::~LocalDataSet() {}
diff --git a/datapoollocal/LocalDataSet.h b/datapoollocal/LocalDataSet.h
index 0368f26d..b7f8f90f 100644
--- a/datapoollocal/LocalDataSet.h
+++ b/datapoollocal/LocalDataSet.h
@@ -7,7 +7,7 @@
 class LocalDataSet: public LocalPoolDataSetBase {
 public:
     LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId,
-    		const size_t maxSize);
+            const size_t maxSize);
     LocalDataSet(sid_t sid, const size_t maxSize);
     virtual~ LocalDataSet();
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index f3cd7106..4dae757e 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -11,309 +11,309 @@
 #include <cstring>
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-		uint32_t setId, PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool periodicHandling):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	if(hkOwner == nullptr) {
-		// Configuration error.
+        uint32_t setId, PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool periodicHandling):
+        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    if(hkOwner == nullptr) {
+        // Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				<< "invalid!" << std::endl;
+        sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                << "invalid!" << std::endl;
 #else
-		sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-				"invalid!\n\r");
+        sif::printError("LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+                "invalid!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		return;
-	}
-	AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+        return;
+    }
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
 
-	if(accessor != nullptr) {
-		poolManager = accessor->getHkManagerHandle();
-		mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-	}
+    if(accessor != nullptr) {
+        poolManager = accessor->getHkManagerHandle();
+        mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+    }
 
-	this->sid.objectId = hkOwner->getObjectId();
-	this->sid.ownerSetId = setId;
+    this->sid.objectId = hkOwner->getObjectId();
+    this->sid.ownerSetId = setId;
 
-	// Data creators get a periodic helper for periodic HK data generation.
-	if(periodicHandling) {
-		periodicHelper = new PeriodicHousekeepingHelper(this);
-	}
+    // Data creators get a periodic helper for periodic HK data generation.
+    if(periodicHandling) {
+        periodicHelper = new PeriodicHousekeepingHelper(this);
+    }
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-		PoolVariableIF** registeredVariablesArray,
-		const size_t maxNumberOfVariables):
-        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
-			sid.objectId);
-	if(hkOwner != nullptr) {
-		AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-		if(accessor != nullptr) {
-			mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-		}
-	}
+        PoolVariableIF** registeredVariablesArray,
+        const size_t maxNumberOfVariables):
+                PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+            sid.objectId);
+    if(hkOwner != nullptr) {
+        AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+        if(accessor != nullptr) {
+            mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
+        }
+    }
 
-	this->sid = sid;
+    this->sid = sid;
 }
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(
-		PoolVariableIF **registeredVariablesArray,
-		const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
-		PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-	this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
+        PoolVariableIF **registeredVariablesArray,
+        const size_t maxNumberOfVariables, bool protectEveryReadCommitCall):
+		        PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
+    this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
 }
 
 
 LocalPoolDataSetBase::~LocalPoolDataSetBase() {
-	if(periodicHelper != nullptr) {
-		delete periodicHelper;
-	}
+    if(periodicHelper != nullptr) {
+        delete periodicHelper;
+    }
 }
 
 ReturnValue_t LocalPoolDataSetBase::lockDataPool(
-		MutexIF::TimeoutType timeoutType,
-		uint32_t timeoutMs) {
-	if(mutexIfSingleDataCreator != nullptr) {
-		return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+        MutexIF::TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    if(mutexIfSingleDataCreator != nullptr) {
+        return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer,
-		size_t *size, size_t maxSize,
-		SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-	uint8_t validityMask[validityMaskSize];
-	uint8_t validBufferIndex = 0;
-	uint8_t validBufferIndexBit = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if(registeredVariables[count]->isValid()) {
-			// set validity buffer here.
-			this->bitSetter(validityMask + validBufferIndex,
-					validBufferIndexBit);
-			if(validBufferIndexBit == 7) {
-				validBufferIndex ++;
-				validBufferIndexBit = 0;
-			}
-			else {
-				validBufferIndexBit ++;
-			}
-		}
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
+        size_t *size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+    uint8_t validityMask[validityMaskSize];
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        if(registeredVariables[count]->isValid()) {
+            // set validity buffer here.
+            this->bitSetter(validityMask + validBufferIndex,
+                    validBufferIndexBit);
+            if(validBufferIndexBit == 7) {
+                validBufferIndex ++;
+                validBufferIndexBit = 0;
+            }
+            else {
+                validBufferIndexBit ++;
+            }
+        }
+        result = registeredVariables[count]->serialize(buffer, size, maxSize,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+    }
 
-	if(*size + validityMaskSize > maxSize) {
-		return SerializeIF::BUFFER_TOO_SHORT;
-	}
-	// copy validity buffer to end
-	std::memcpy(*buffer, validityMask, validityMaskSize);
-	*size += validityMaskSize;
-	return result;
+    if(*size + validityMaskSize > maxSize) {
+        return SerializeIF::BUFFER_TOO_SHORT;
+    }
+    // copy validity buffer to end
+    std::memcpy(*buffer, validityMask, validityMaskSize);
+    *size += validityMaskSize;
+    return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
-		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;
-		}
-	}
+        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;
+        }
+    }
 
-	if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
-		return SerializeIF::STREAM_TOO_SHORT;
-	}
+    if(*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
+        return SerializeIF::STREAM_TOO_SHORT;
+    }
 
-	uint8_t validBufferIndex = 0;
-	uint8_t validBufferIndexBit = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		// set validity buffer here.
-		bool nextVarValid = this->bitGetter(*buffer +
-				validBufferIndex, validBufferIndexBit);
-		registeredVariables[count]->setValid(nextVarValid);
+    uint8_t validBufferIndex = 0;
+    uint8_t validBufferIndexBit = 0;
+    for (uint16_t count = 0; count < fillCount; count++) {
+        // set validity buffer here.
+        bool nextVarValid = this->bitGetter(*buffer +
+                validBufferIndex, validBufferIndexBit);
+        registeredVariables[count]->setValid(nextVarValid);
 
-		if(validBufferIndexBit == 7) {
-			validBufferIndex ++;
-			validBufferIndexBit = 0;
-		}
-		else {
-			validBufferIndexBit ++;
-		}
-	}
-	return result;
+        if(validBufferIndexBit == 7) {
+            validBufferIndex ++;
+            validBufferIndexBit = 0;
+        }
+        else {
+            validBufferIndexBit ++;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-	if(mutexIfSingleDataCreator != nullptr) {
-		return mutexIfSingleDataCreator->unlockMutex();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(mutexIfSingleDataCreator != nullptr) {
+        return mutexIfSingleDataCreator->unlockMutex();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t** buffer,
-		size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
-		bool serializeFillCount) const {
-	// Serialize as uint8_t
-	uint8_t fillCount = this->fillCount;
-	if(serializeFillCount) {
-		SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
-				streamEndianness);
-	}
-	for (uint16_t count = 0; count < fillCount; count++) {
-		lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-		auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
-				size, maxSize, streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
+        size_t* size, size_t maxSize,SerializeIF::Endianness streamEndianness,
+        bool serializeFillCount) const {
+    // Serialize as uint8_t
+    uint8_t fillCount = this->fillCount;
+    if(serializeFillCount) {
+        SerializeAdapter::serialize(&fillCount, buffer, size, maxSize,
+                streamEndianness);
+    }
+    for (uint16_t count = 0; count < fillCount; count++) {
+        lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
+        auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
+                size, maxSize, streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
-				<< "Serialization error!" << std::endl;
+            sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+                    << "Serialization error!" << std::endl;
 #else
-		sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
-				"Serialization error!\n\r");
+            sif::printWarning("LocalPoolDataSetBase::serializeLocalPoolIds: "
+                    "Serialization error!\n\r");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		return result;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+            return result;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
 uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(
-		bool serializeFillCount) const {
-	if(serializeFillCount) {
-		return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
-	}
-	else {
-		return fillCount * sizeof(lp_id_t);
-	}
+        bool serializeFillCount) const {
+    if(serializeFillCount) {
+        return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
+    }
+    else {
+        return fillCount * sizeof(lp_id_t);
+    }
 }
 
 size_t LocalPoolDataSetBase::getSerializedSize() const {
-	if(withValidityBuffer) {
-		uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
-		return validityMaskSize + PoolDataSetBase::getSerializedSize();
-	}
-	else {
-		return PoolDataSetBase::getSerializedSize();
-	}
+    if(withValidityBuffer) {
+        uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
+        return validityMaskSize + PoolDataSetBase::getSerializedSize();
+    }
+    else {
+        return PoolDataSetBase::getSerializedSize();
+    }
 }
 
 void LocalPoolDataSetBase::setValidityBufferGeneration(
-		bool withValidityBuffer) {
-	this->withValidityBuffer = withValidityBuffer;
+        bool withValidityBuffer) {
+    this->withValidityBuffer = withValidityBuffer;
 }
 
 ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer,
-		size_t *size, SerializeIF::Endianness streamEndianness) {
-	if(withValidityBuffer) {
-		return this->deSerializeWithValidityBuffer(buffer, size,
-				streamEndianness);
-	}
-	else {
-		return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
-	}
+        size_t *size, SerializeIF::Endianness streamEndianness) {
+    if(withValidityBuffer) {
+        return this->deSerializeWithValidityBuffer(buffer, size,
+                streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
+    }
 }
 
 ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size,
-		size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	if(withValidityBuffer) {
-		return this->serializeWithValidityBuffer(buffer, size,
-				maxSize, streamEndianness);
-	}
-	else {
-		return PoolDataSetBase::serialize(buffer, size, maxSize,
-				streamEndianness);
-	}
+        size_t maxSize, SerializeIF::Endianness streamEndianness) const {
+    if(withValidityBuffer) {
+        return this->serializeWithValidityBuffer(buffer, size,
+                maxSize, streamEndianness);
+    }
+    else {
+        return PoolDataSetBase::serialize(buffer, size, maxSize,
+                streamEndianness);
+    }
 }
 
 void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) const {
-	if(position > 7) {
+    if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-		<< std::endl;
+        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
+                << std::endl;
 #else
-		sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-				"Invalid position!\n\r");
+        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
+                "Invalid position!\n\r");
 #endif
-		return;
-	}
-	uint8_t shiftNumber = position + (7 - 2 * position);
-	*byte |= 1 << shiftNumber;
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
 }
 
 void LocalPoolDataSetBase::setDiagnostic(bool isDiagnostics) {
-	this->diagnostic = isDiagnostics;
+    this->diagnostic = isDiagnostics;
 }
 
 bool LocalPoolDataSetBase::isDiagnostics() const {
-	return diagnostic;
+    return diagnostic;
 }
 
 void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-	this->reportingEnabled = reportingEnabled;
+    this->reportingEnabled = reportingEnabled;
 }
 
 bool LocalPoolDataSetBase::getReportingEnabled() const {
-	return reportingEnabled;
+    return reportingEnabled;
 }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(
-		float collectionInterval, dur_millis_t minimumPeriodicInterval,
-		bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
-	periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
-			isDiagnostics, nonDiagIntervalFactor);
+        float collectionInterval, dur_millis_t minimumPeriodicInterval,
+        bool isDiagnostics, uint8_t nonDiagIntervalFactor) {
+    periodicHelper->initialize(collectionInterval, minimumPeriodicInterval,
+            isDiagnostics, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) {
-	this->changed = changed;
+    this->changed = changed;
 }
 
 bool LocalPoolDataSetBase::hasChanged() const {
-	return changed;
+    return changed;
 }
 
 sid_t LocalPoolDataSetBase::getSid() const {
-	return sid;
+    return sid;
 }
 
 bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte,
-		uint8_t position) const {
-	if(position > 7) {
+        uint8_t position) const {
+    if(position > 7) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "Pool Raw Access: Bit setting invalid position"
-				<< std::endl;
+        sif::debug << "Pool Raw Access: Bit setting invalid position"
+                << std::endl;
 #endif
-		return false;
-	}
-	uint8_t shiftNumber = position + (7 - 2 * position);
-	return *byte & (1 << shiftNumber);
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
 }
 
 bool LocalPoolDataSetBase::isValid() const {
-	return this->valid;
+    return this->valid;
 }
 
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-	if(setEntriesRecursively) {
-		for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-			registeredVariables[idx] -> setValid(valid);
-		}
-	}
-	this->valid = valid;
+    if(setEntriesRecursively) {
+        for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+            registeredVariables[idx] -> setValid(valid);
+        }
+    }
+    this->valid = valid;
 }
 
 object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
-	if(poolManager != nullptr) {
-		return poolManager->getCreatorObjectId();
-	}
-	return objects::NO_OBJECT;
+    if(poolManager != nullptr) {
+        return poolManager->getCreatorObjectId();
+    }
+    return objects::NO_OBJECT;
 }
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 5f17eeb6..cc41b0eb 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -41,184 +41,185 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase: public PoolDataSetBase,
+class LocalPoolDataSetBase:
+        public PoolDataSetBase,
         public MarkChangedIF {
-	friend class LocalPoolDataSetAttorney;
-	friend class PeriodicHousekeepingHelper;
+    friend class LocalPoolDataSetAttorney;
+    friend class PeriodicHousekeepingHelper;
 public:
-	/**
-	 * @brief	Constructor for the creator of local pool data.
-	 * @details
-	 * This constructor also initializes the components required for
-	 * periodic handling.
-	 */
-	LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
-			uint32_t setId, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables, bool periodicHandling = true);
+    /**
+     * @brief	Constructor for the creator of local pool data.
+     * @details
+     * This constructor also initializes the components required for
+     * periodic handling.
+     */
+    LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
+            uint32_t setId, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables, bool periodicHandling = true);
 
-	/**
-	 * @brief	Constructor for users of the local pool data, which need
-	 *          to access data created by one (!) HK manager.
-	 * @details
-	 * Unlike the first constructor, no component for periodic handling
-	 * will be initiated.
-	 * @param sid Unique identifier of dataset consisting of object ID and
-	 * set ID.
-	 * @param registeredVariablesArray
-	 * @param maxNumberOfVariables
-	 */
-	LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables);
+    /**
+     * @brief	Constructor for users of the local pool data, which need
+     *          to access data created by one (!) HK manager.
+     * @details
+     * Unlike the first constructor, no component for periodic handling
+     * will be initiated.
+     * @param sid Unique identifier of dataset consisting of object ID and
+     * set ID.
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     */
+    LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables);
 
-	/**
-	 * @brief	Simple constructor, if the dataset is not the owner by
-	 * 			a class with a HK manager.
-	 * @details
-	 * This constructor won't create components required for periodic handling
-	 * and it also won't try to deduce the HK manager because no SID is
-	 * supplied. This function should therefore be called by classes which need
-	 * to access pool variables from different creators.
-	 *
-	 * If the class is intended to access pool variables from different
-	 * creators, the third argument should be set to true. The mutex
-	 * properties can be set with #setReadCommitProtectionBehaviour .
-	 * @param registeredVariablesArray
-	 * @param maxNumberOfVariables
-	 * @param protectEveryReadCommitCall If the pool variables are created by
-	 * multiple creators, this flag can be set to protect all read and
-	 * commit calls separately.
-	 */
-	LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxNumberOfVariables,
-			bool protectEveryReadCommitCall = true);
+    /**
+     * @brief	Simple constructor, if the dataset is not the owner by
+     * 			a class with a HK manager.
+     * @details
+     * This constructor won't create components required for periodic handling
+     * and it also won't try to deduce the HK manager because no SID is
+     * supplied. This function should therefore be called by classes which need
+     * to access pool variables from different creators.
+     *
+     * If the class is intended to access pool variables from different
+     * creators, the third argument should be set to true. The mutex
+     * properties can be set with #setReadCommitProtectionBehaviour .
+     * @param registeredVariablesArray
+     * @param maxNumberOfVariables
+     * @param protectEveryReadCommitCall If the pool variables are created by
+     * multiple creators, this flag can be set to protect all read and
+     * commit calls separately.
+     */
+    LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray,
+            const size_t maxNumberOfVariables,
+            bool protectEveryReadCommitCall = true);
 
-	/**
-	 * @brief	The destructor automatically manages writing the valid
-	 * 			information of variables.
-	 * @details
-	 * In case the data set was read out, but not committed(indicated by state),
-	 * the destructor parses all variables that are still registered to the set.
-	 * For each, the valid flag in the data pool is set to "invalid".
-	 */
-	~LocalPoolDataSetBase();
+    /**
+     * @brief	The destructor automatically manages writing the valid
+     * 			information of variables.
+     * @details
+     * In case the data set was read out, but not committed(indicated by state),
+     * the destructor parses all variables that are still registered to the set.
+     * For each, the valid flag in the data pool is set to "invalid".
+     */
+    ~LocalPoolDataSetBase();
 
-	void setValidityBufferGeneration(bool withValidityBuffer);
+    void setValidityBufferGeneration(bool withValidityBuffer);
 
-	sid_t getSid() const;
+    sid_t getSid() const;
 
-	/** SerializeIF overrides */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-	            SerializeIF::Endianness streamEndianness) const override;
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
-	        SerializeIF::Endianness streamEndianness) override;
-	size_t getSerializedSize() const override;
+    /** SerializeIF overrides */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const override;
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t *size,
+            SerializeIF::Endianness streamEndianness) override;
+    size_t getSerializedSize() const override;
 
-	/**
-	 * Special version of the serilization function which appends a
-	 * validity buffer at the end. Each bit of this validity buffer
-	 * denotes whether the container data set entries are valid from left
-	 * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param bigEndian
-	 * @param withValidityBuffer
-	 * @return
-	 */
-	ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness) const;
-	ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
-	        size_t *size, SerializeIF::Endianness streamEndianness);
-	ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
-	        size_t* size, size_t maxSize,
-	        SerializeIF::Endianness streamEndianness,
-	        bool serializeFillCount = true) const;
-	uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
+    /**
+     * Special version of the serilization function which appends a
+     * validity buffer at the end. Each bit of this validity buffer
+     * denotes whether the container data set entries are valid from left
+     * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param bigEndian
+     * @param withValidityBuffer
+     * @return
+     */
+    ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness) const;
+    ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer,
+            size_t *size, SerializeIF::Endianness streamEndianness);
+    ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
+            size_t* size, size_t maxSize,
+            SerializeIF::Endianness streamEndianness,
+            bool serializeFillCount = true) const;
+    uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
 
-	/**
-	 * Set the dataset valid or invalid. These calls are mutex protected.
-	 * @param setEntriesRecursively
-	 * If this is true, all contained datasets will also be set recursively.
-	 */
-	void setValidity(bool valid, bool setEntriesRecursively);
-	bool isValid() const override;
+    /**
+     * Set the dataset valid or invalid. These calls are mutex protected.
+     * @param setEntriesRecursively
+     * If this is true, all contained datasets will also be set recursively.
+     */
+    void setValidity(bool valid, bool setEntriesRecursively);
+    bool isValid() const override;
 
-	/**
-	 * These calls are mutex protected.
-	 * @param changed
-	 */
-	void setChanged(bool changed) override;
-	bool hasChanged() const override;
+    /**
+     * These calls are mutex protected.
+     * @param changed
+     */
+    void setChanged(bool changed) override;
+    bool hasChanged() const override;
 
-	object_id_t getCreatorObjectId();
+    object_id_t getCreatorObjectId();
 protected:
-	sid_t sid;
-	//! This mutex is used if the data is created by one object only.
-	MutexIF* mutexIfSingleDataCreator = nullptr;
+    sid_t sid;
+    //! This mutex is used if the data is created by one object only.
+    MutexIF* mutexIfSingleDataCreator = nullptr;
 
-	bool diagnostic = false;
-	void setDiagnostic(bool diagnostics);
-	bool isDiagnostics() const;
+    bool diagnostic = false;
+    void setDiagnostic(bool diagnostics);
+    bool isDiagnostics() const;
 
-	/**
-	 * Used for periodic generation.
-	 */
-	bool reportingEnabled = false;
-	void setReportingEnabled(bool enabled);
-	bool getReportingEnabled() const;
+    /**
+     * Used for periodic generation.
+     */
+    bool reportingEnabled = false;
+    void setReportingEnabled(bool enabled);
+    bool getReportingEnabled() const;
 
-	void initializePeriodicHelper(float collectionInterval,
-			dur_millis_t minimumPeriodicInterval,
-			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
+    void initializePeriodicHelper(float collectionInterval,
+            dur_millis_t minimumPeriodicInterval,
+            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5);
 
-	/**
-	 * If the valid state of a dataset is always relevant to the whole
-	 * data set we can use this flag.
-	 */
-	bool valid = false;
+    /**
+     * If the valid state of a dataset is always relevant to the whole
+     * data set we can use this flag.
+     */
+    bool valid = false;
 
-	/**
-	 * Can be used to mark the dataset as changed, which is used
-	 * by the LocalDataPoolManager to send out update messages.
-	 */
-	bool changed = false;
+    /**
+     * Can be used to mark the dataset as changed, which is used
+     * by the LocalDataPoolManager to send out update messages.
+     */
+    bool changed = false;
 
-	/**
-	 * Specify whether the validity buffer is serialized too when serializing
-	 * or deserializing the packet. Each bit of the validity buffer will
-	 * contain the validity state of the pool variables from left to right.
-	 * The size of validity buffer thus will be ceil(N / 8) with N = number of
-	 * pool variables.
-	 */
-	bool withValidityBuffer = true;
+    /**
+     * Specify whether the validity buffer is serialized too when serializing
+     * or deserializing the packet. Each bit of the validity buffer will
+     * contain the validity state of the pool variables from left to right.
+     * The size of validity buffer thus will be ceil(N / 8) with N = number of
+     * pool variables.
+     */
+    bool withValidityBuffer = true;
 
-	/**
-	 * @brief	This is a small helper function to facilitate locking
-	 * 			the global data pool.
-	 * @details
-	 * It makes use of the lockDataPool method offered by the DataPool class.
-	 */
-	ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
-			uint32_t timeoutMs) override;
+    /**
+     * @brief	This is a small helper function to facilitate locking
+     * 			the global data pool.
+     * @details
+     * It makes use of the lockDataPool method offered by the DataPool class.
+     */
+    ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType,
+            uint32_t timeoutMs) override;
 
-	/**
-	 * @brief	This is a small helper function to facilitate
-	 * 			unlocking the global data pool
-	 * @details
-	 * It makes use of the freeDataPoolLock method offered by the DataPool class.
-	 */
-	ReturnValue_t unlockDataPool() override;
+    /**
+     * @brief	This is a small helper function to facilitate
+     * 			unlocking the global data pool
+     * @details
+     * It makes use of the freeDataPoolLock method offered by the DataPool class.
+     */
+    ReturnValue_t unlockDataPool() override;
 
-	/**
-	 * Set n-th bit of a byte, with n being the position from 0
-	 * (most significant bit) to 7 (least significant bit)
-	 */
-	void bitSetter(uint8_t* byte, uint8_t position) const;
-	bool bitGetter(const uint8_t* byte, uint8_t position) const;
+    /**
+     * Set n-th bit of a byte, with n being the position from 0
+     * (most significant bit) to 7 (least significant bit)
+     */
+    void bitSetter(uint8_t* byte, uint8_t position) const;
+    bool bitGetter(const uint8_t* byte, uint8_t position) const;
 
-	PeriodicHousekeepingHelper* periodicHelper = nullptr;
-	LocalDataPoolManager* poolManager = nullptr;
+    PeriodicHousekeepingHelper* periodicHelper = nullptr;
+    LocalDataPoolManager* poolManager = nullptr;
 
 };
 
diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index bd1bfa0f..a0bf5708 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -1,128 +1,130 @@
-#include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
+#include "LocalDataPoolManager.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 #include "HasLocalDataPoolIF.h"
 
 #include "../objectmanager/ObjectManagerIF.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-		DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-		localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
+        DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-				<< "which is the NO_PARAMETER value!" << std::endl;
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
 #endif
-	}
-	if(hkOwner == nullptr) {
+    }
+    if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
-				<< "owner is a invalid!" << std::endl;
+        sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+                << "owner is a invalid!" << std::endl;
 #endif
-		return;
-	}
-	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-	hkManager = poolManAccessor->getHkManagerHandle();
+        return;
+    }
+    AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+    hkManager = poolManAccessor->getHkManagerHandle();
 
-	if (dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
+    if (dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
 }
 
 LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF *dataSet,
-		pool_rwm_t setReadWriteMode):
-				localPoolId(poolId), readWriteMode(setReadWriteMode) {
-	if(poolId == PoolVariableIF::NO_PARAMETER) {
+        pool_rwm_t setReadWriteMode):
+		                localPoolId(poolId), readWriteMode(setReadWriteMode) {
+    if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-				<< "which is the NO_PARAMETER value!" << std::endl;
+        sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                << "which is the NO_PARAMETER value!" << std::endl;
 #endif
-	}
-	HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
-	if(hkOwner == nullptr) {
+    }
+    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalPoolVariable: The supplied pool owner did not "
-				<< "implement the correct interface"
-				<< " HasLocalDataPoolIF!" << std::endl;
+        sif::error << "LocalPoolVariable: The supplied pool owner did not "
+                << "implement the correct interface"
+                << " HasLocalDataPoolIF!" << std::endl;
 #endif
-		return;
-	}
-	//hkManager = hkOwner->getHkManagerHandle();
-	AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-	//hkManager = HasLocalDpIFUserAttorney::getHkManagerHandle(hkOwner);
-	hkManager = poolManAccessor->getHkManagerHandle();
-	if(dataSet != nullptr) {
-		dataSet->registerVariable(this);
-	}
+        return;
+    }
+
+    AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
+    if(accessor != nullptr) {
+        hkManager = accessor->getHkManagerHandle();
+    }
+
+    if(dataSet != nullptr) {
+        dataSet->registerVariable(this);
+    }
 }
 
 pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const {
-	return readWriteMode;
+    return readWriteMode;
 }
 
 bool LocalPoolObjectBase::isValid() const {
-	return valid;
+    return valid;
 }
 
 void LocalPoolObjectBase::setValid(bool valid) {
-	this->valid = valid;
+    this->valid = valid;
 }
 
 lp_id_t LocalPoolObjectBase::getDataPoolId() const {
-	return localPoolId;
+    return localPoolId;
 }
 
 void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) {
-	this->localPoolId = poolId;
+    this->localPoolId = poolId;
 }
 
 void LocalPoolObjectBase::setChanged(bool changed) {
-	this->changed = changed;
+    this->changed = changed;
 }
 
 bool LocalPoolObjectBase::hasChanged() const {
-	return changed;
+    return changed;
 }
 
 void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
-	this->readWriteMode = newReadWriteMode;
+    this->readWriteMode = newReadWriteMode;
 }
 
 void LocalPoolObjectBase::reportReadCommitError(const char* variableType,
-		ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
+        ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId) {
 #if FSFW_DISABLE_PRINTOUT == 0
-	const char* type = nullptr;
-	if(read) {
-		type = "read";
-	}
-	else {
-		type = "commit";
-	}
+    const char* type = nullptr;
+    if(read) {
+        type = "read";
+    }
+    else {
+        type = "commit";
+    }
 
-	const char* errMsg = nullptr;
-	if(error == localpool::POOL_ENTRY_NOT_FOUND) {
-		errMsg = "Pool entry not found";
-	}
-	else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
-		errMsg = "Pool entry type conflict";
-	}
-	else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
-		errMsg = "Pool variable wrong read-write mode";
-	}
-	else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
-		errMsg = "Pool entry invalid";
-	}
-	else {
-		errMsg = "Unknown error code";
-	}
+    const char* errMsg = nullptr;
+    if(error == localpool::POOL_ENTRY_NOT_FOUND) {
+        errMsg = "Pool entry not found";
+    }
+    else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+        errMsg = "Pool entry type conflict";
+    }
+    else if(error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
+        errMsg = "Pool variable wrong read-write mode";
+    }
+    else if(error == PoolVariableIF::INVALID_POOL_ENTRY) {
+        errMsg = "Pool entry invalid";
+    }
+    else {
+        errMsg = "Unknown error code";
+    }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
-			<< std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
-			<< " LPID: " << lpId << std::endl;
+    sif::warning << variableType << ": " << type << " call | " << errMsg << " | Owner: 0x"
+            << std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+            << " LPID: " << lpId << std::endl;
 #else
-	sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
-			variableType, type, errMsg, objectId, lpId);
+    sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n",
+            variableType, type, errMsg, objectId, lpId);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }
diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 2dddc246..44a0c82b 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -1,8 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 #define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "MarkChangedIF.h"
+#include "localPoolDefinitions.h"
+
 #include "../objectmanager/SystemObjectIF.h"
 #include "../datapool/PoolVariableIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -11,9 +12,13 @@ class LocalDataPoolManager;
 class DataSetIF;
 class HasLocalDataPoolIF;
 
+/**
+ * @brief 	This class serves as a non-template base for pool objects like pool variables
+ * 			or pool vectors.
+ */
 class LocalPoolObjectBase: public PoolVariableIF,
-        public HasReturnvaluesIF,
-        public MarkChangedIF {
+public HasReturnvaluesIF,
+public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
@@ -61,10 +66,8 @@ protected:
     //! @brief  Pointer to the class which manages the HK pool.
     LocalDataPoolManager* hkManager = nullptr;
 
-	void reportReadCommitError(const char* variableType,
-			ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
+    void reportReadCommitError(const char* variableType,
+            ReturnValue_t error, bool read, object_id_t objectId, lp_id_t lpId);
 };
 
-
-
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index 859c8f08..76629489 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -27,159 +27,159 @@
 template<typename T>
 class LocalPoolVariable: public LocalPoolObjectBase {
 public:
-	//! Default ctor is forbidden.
-	LocalPoolVariable() = delete;
+    //! Default ctor is forbidden.
+    LocalPoolVariable() = delete;
 
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 */
-	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     */
+    LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 *
-	 * It does not fetch the current value from the data pool, which
-	 * has to be done by calling the read() operation.
-	 * Datasets can be used to access multiple local pool entries in an
-	 * efficient way. A pointer to a dataset can be passed to register
-	 * the pool variable in that dataset directly.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner object ID of the pool owner.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 *
-	 */
-	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-	/**
-	 * Variation which takes the global unique identifier of a pool variable.
-	 * @param globalPoolId
-	 * @param dataSet
-	 * @param setReadWriteMode
-	 */
-	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     *
+     * It does not fetch the current value from the data pool, which
+     * has to be done by calling the read() operation.
+     * Datasets can be used to access multiple local pool entries in an
+     * efficient way. A pointer to a dataset can be passed to register
+     * the pool variable in that dataset directly.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner object ID of the pool owner.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     *
+     */
+    LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the global unique identifier of a pool variable.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVariable() {};
+    virtual~ LocalPoolVariable() {};
 
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details	The user can work on this attribute
-	 * 			just like he would on a simple local variable.
-	 */
-	T value = 0;
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details	The user can work on this attribute
+     * 			just like he would on a simple local variable.
+     */
+    T value = 0;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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;
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, 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;
 
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 *
-	 */
-	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     *
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	This commit function can be used to set the pool variable valid
-	 * 			as well.
-	 * @param setValid
-	 * @param timeoutType
-	 * @param timeoutMs
-	 * @return
-	 */
-	ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
+    /**
+     * @brief	This commit function can be used to set the pool variable valid
+     * 			as well.
+     * @param setValid
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    ReturnValue_t commit(bool setValid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
 
-	LocalPoolVariable<T> &operator=(const T& newValue);
-	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
+    LocalPoolVariable<T> &operator=(const T& newValue);
+    LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
-	//! Explicit type conversion operator. Allows casting the class to
-	//! its template type to perform operations on value.
-	explicit operator T() const;
+    //! Explicit type conversion operator. Allows casting the class to
+    //! its template type to perform operations on value.
+    explicit operator T() const;
 
-	bool operator==(const LocalPoolVariable<T>& other) const;
-	bool operator==(const T& other) const;
+    bool operator==(const LocalPoolVariable<T>& other) const;
+    bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVariable<T>& other) const;
-	bool operator!=(const T& other) const;
+    bool operator!=(const LocalPoolVariable<T>& other) const;
+    bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVariable<T>& other) const;
-	bool operator<(const T& other) const;
+    bool operator<(const LocalPoolVariable<T>& other) const;
+    bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVariable<T>& other) const;
-	bool operator>(const T& other) const;
+    bool operator>(const LocalPoolVariable<T>& other) const;
+    bool operator>(const T& other) const;
 
 protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	// std::ostream is the type for object std::cout
-	template <typename U>
-	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVariable<U> &var);
+    // std::ostream is the type for object std::cout
+    template <typename U>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVariable<U> &var);
 #endif
 };
 
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 6fd34171..35de4ebd 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -7,127 +7,127 @@
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
-		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner,
-		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
 inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-				dataSet, setReadWriteMode){}
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode){}
 
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return readWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
 
-	// Actually this should never happen..
-//	if(poolEntry->address == nullptr) {
-//		result = PoolVariableIF::INVALID_POOL_ENTRY;
-//		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-//		reportReadCommitError("LocalPoolVariable", result,
-//				false, ownerObjectId, localPoolId);
-//		return result;
-//	}
+    // Actually this should never happen..
+    //	if(poolEntry->address == nullptr) {
+    //		result = PoolVariableIF::INVALID_POOL_ENTRY;
+    //		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
+    //		reportReadCommitError("LocalPoolVariable", result,
+    //				false, ownerObjectId, localPoolId);
+    //		return result;
+    //	}
 
-	this->value = *(poolEntry->getDataPtr());
-	this->valid = poolEntry->getValid();
-	return RETURN_OK;
+    this->value = *(poolEntry->getDataPtr());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	this->setValid(setValid);
-	return commit(timeoutType, timeoutMs);
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(setValid);
+    return commit(timeoutType, timeoutMs);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return commitWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	//ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
+    PoolEntry<T>* poolEntry = nullptr;
+    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t ownerObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVariable", result,
+                false, ownerObjectId, localPoolId);
+        return result;
+    }
 
-	*(poolEntry->getDataPtr()) = this->value;
-	poolEntry->setValid(this->valid);
-	return RETURN_OK;
+    *(poolEntry->getDataPtr()) = this->value;
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer,
-		size_t* size, const size_t max_size,
-		SerializeIF::Endianness streamEndianness) const {
-	return SerializeAdapter::serialize(&value,
-			buffer, size ,max_size, streamEndianness);
+        size_t* size, const size_t max_size,
+        SerializeIF::Endianness streamEndianness) const {
+    return SerializeAdapter::serialize(&value,
+            buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
 inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-	return SerializeAdapter::getSerializedSize(&value);
+    return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
-		size_t* size, SerializeIF::Endianness streamEndianness) {
-	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+        size_t* size, SerializeIF::Endianness streamEndianness) {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVariable<T> &var) {
+        const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
@@ -135,68 +135,68 @@ inline std::ostream& operator<< (std::ostream &out,
 
 template<typename T>
 inline LocalPoolVariable<T>::operator T() const {
-	return value;
+    return value;
 }
 
 template<typename T>
 inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(
-		const T& newValue) {
+        const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
 inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
-		const LocalPoolVariable<T>& newPoolVariable) {
-	value = newPoolVariable.value;
-	return *this;
+        const LocalPoolVariable<T>& newPoolVariable) {
+    value = newPoolVariable.value;
+    return *this;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator ==(
-		const LocalPoolVariable<T> &other) const {
-	return this->value == other.value;
+        const LocalPoolVariable<T> &other) const {
+    return this->value == other.value;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
-	return this->value == other;
+    return this->value == other;
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator !=(
-		const LocalPoolVariable<T> &other) const {
-	return not (*this == other);
+        const LocalPoolVariable<T> &other) const {
+    return not (*this == other);
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
-	return not (*this == other);
+    return not (*this == other);
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator <(
-		const LocalPoolVariable<T> &other) const {
-	return this->value < other.value;
+        const LocalPoolVariable<T> &other) const {
+    return this->value < other.value;
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator <(const T &other) const {
-	return this->value < other;
+    return this->value < other;
 }
 
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator >(
-		const LocalPoolVariable<T> &other) const {
-	return not (*this < other);
+        const LocalPoolVariable<T> &other) const {
+    return not (*this < other);
 }
 
 template<typename T>
 inline bool LocalPoolVariable<T>::operator >(const T &other) const {
-	return not (*this < other);
+    return not (*this < other);
 }
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/datapoollocal/LocalPoolVector.h b/datapoollocal/LocalPoolVector.h
index 74255605..593d26ab 100644
--- a/datapoollocal/LocalPoolVector.h
+++ b/datapoollocal/LocalPoolVector.h
@@ -35,148 +35,148 @@
 template<typename T, uint16_t vectorSize>
 class LocalPoolVector: public LocalPoolObjectBase {
 public:
-	LocalPoolVector() = delete;
-	/**
-	 * This constructor is used by the data creators to have pool variable
-	 * instances which can also be stored in datasets.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    LocalPoolVector() = delete;
+    /**
+     * This constructor is used by the data creators to have pool variable
+     * instances which can also be stored in datasets.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * This constructor is used by data users like controllers to have
-	 * access to the local pool variables of data creators by supplying
-	 * the respective creator object ID.
-	 * It does not fetch the current value from the data pool. This is performed
-	 * by the read() operation (which is not thread-safe).
-	 * Datasets can be used to access local pool entires in a thread-safe way.
-	 * @param poolId ID of the local pool entry.
-	 * @param hkOwner Pointer of the owner. This will generally be the calling
-	 * class itself which passes "this".
-	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
-	 * @param dataSet The data set in which the variable shall register itself.
-	 * If nullptr, the variable is not registered.
-	 */
-	LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-	/**
-	 * Variation which takes the unique global identifier of a local pool
-	 * vector.
-	 * @param globalPoolId
-	 * @param dataSet
-	 * @param setReadWriteMode
-	 */
-	LocalPoolVector(gp_id_t globalPoolId,
-			DataSetIF* dataSet = nullptr,
-			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * This constructor is used by data users like controllers to have
+     * access to the local pool variables of data creators by supplying
+     * the respective creator object ID.
+     * It does not fetch the current value from the data pool. This is performed
+     * by the read() operation (which is not thread-safe).
+     * Datasets can be used to access local pool entires in a thread-safe way.
+     * @param poolId ID of the local pool entry.
+     * @param hkOwner Pointer of the owner. This will generally be the calling
+     * class itself which passes "this".
+     * @param setReadWriteMode Specify the read-write mode of the pool variable.
+     * @param dataSet The data set in which the variable shall register itself.
+     * If nullptr, the variable is not registered.
+     */
+    LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+    /**
+     * Variation which takes the unique global identifier of a local pool
+     * vector.
+     * @param globalPoolId
+     * @param dataSet
+     * @param setReadWriteMode
+     */
+    LocalPoolVector(gp_id_t globalPoolId,
+            DataSetIF* dataSet = nullptr,
+            pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	/**
-	 * @brief	This is the local copy of the data pool entry.
-	 * @details
-	 * The user can work on this attribute just like he would on a local
-	 * array of this type.
-	 */
-	T value[vectorSize];
-	/**
-	 * @brief	The classes destructor is empty.
-	 * @details	If commit() was not called, the local value is
-	 * 			discarded and not written back to the data pool.
-	 */
-	~LocalPoolVector() {};
-	/**
-	 * @brief	The operation returns the number of array entries
-	 * 			in this variable.
-	 */
-	uint8_t getSize() {
-		return vectorSize;
-	}
+    /**
+     * @brief	This is the local copy of the data pool entry.
+     * @details
+     * The user can work on this attribute just like he would on a local
+     * array of this type.
+     */
+    T value[vectorSize];
+    /**
+     * @brief	The classes destructor is empty.
+     * @details	If commit() was not called, the local value is
+     * 			discarded and not written back to the data pool.
+     */
+    ~LocalPoolVector() {};
+    /**
+     * @brief	The operation returns the number of array entries
+     * 			in this variable.
+     */
+    uint8_t getSize() {
+        return vectorSize;
+    }
 
-	T& operator [](size_t i);
-	const T &operator [](size_t i) const;
+    T& operator [](size_t i);
+    const T &operator [](size_t i) const;
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t maxSize,
-			SerializeIF::Endianness streamEndiannes) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            const size_t maxSize,
+            SerializeIF::Endianness streamEndiannes) const override;
+    virtual size_t getSerializedSize() const override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            SerializeIF::Endianness streamEndianness) override;
 
-	/**
-	 * @brief	This is a call to read the array's values
-	 * 			from the global data pool.
-	 * @details
-	 * When executed, this operation tries to fetch the pool entry with matching
-	 * data pool id from the data pool and copies all array values and the valid
-	 * information to its local attributes.
-	 * In case of a failure (wrong type, size or pool id not found), the
-	 * variable is set to zero and invalid.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t read(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	This is a call to read the array's values
+     * 			from the global data pool.
+     * @details
+     * When executed, this operation tries to fetch the pool entry with matching
+     * data pool id from the data pool and copies all array values and the valid
+     * information to its local attributes.
+     * In case of a failure (wrong type, size or pool id not found), the
+     * variable is set to zero and invalid.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t read(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	The commit call copies the array values back to the data pool.
-	 * @details
-	 * It checks type and size, as well as if the variable is writable. If so,
-	 * the value is copied and the local valid flag is written back as well.
-	 * The read call is protected with a lock.
-	 * It is recommended to use DataSets to read and commit multiple variables
-	 * at once to avoid the overhead of unnecessary lock und unlock operations.
-	 */
-	ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
+    /**
+     * @brief	The commit call copies the array values back to the data pool.
+     * @details
+     * It checks type and size, as well as if the variable is writable. If so,
+     * the value is copied and the local valid flag is written back as well.
+     * The read call is protected with a lock.
+     * It is recommended to use DataSets to read and commit multiple variables
+     * at once to avoid the overhead of unnecessary lock und unlock operations.
+     */
+    ReturnValue_t commit(MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20) override;
 
-	/**
-	 * @brief	This commit call also sets the validity of the pool entry.
-	 * @details
-	 */
-	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
-			MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
+    /**
+     * @brief	This commit call also sets the validity of the pool entry.
+     * @details
+     */
+    ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+            MutexIF::TimeoutType::WAITING,
+            uint32_t timeoutMs = 20);
 
 protected:
-	/**
-	 * @brief	Like #read, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t readWithoutLock() override;
-	/**
-	 * @brief	Like #commit, but without a lock protection of the global pool.
-	 * @details
-	 * The operation does NOT provide any mutual exclusive protection by itself.
-	 * This can be used if the lock is handled externally to avoid the overhead
-	 * of consecutive lock und unlock operations.
-	 * Declared protected to discourage free public usage.
-	 */
-	ReturnValue_t commitWithoutLock() override;
+    /**
+     * @brief	Like #read, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t readWithoutLock() override;
+    /**
+     * @brief	Like #commit, but without a lock protection of the global pool.
+     * @details
+     * The operation does NOT provide any mutual exclusive protection by itself.
+     * This can be used if the lock is handled externally to avoid the overhead
+     * of consecutive lock und unlock operations.
+     * Declared protected to discourage free public usage.
+     */
+    ReturnValue_t commitWithoutLock() override;
 
 private:
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	// std::ostream is the type for object std::cout
-	template <typename U, uint16_t otherSize>
-	friend std::ostream& operator<< (std::ostream &out,
-	        const LocalPoolVector<U, otherSize> &var);
+    // std::ostream is the type for object std::cout
+    template <typename U, uint16_t otherSize>
+    friend std::ostream& operator<< (std::ostream &out,
+            const LocalPoolVector<U, otherSize> &var);
 #endif
 
 };
diff --git a/datapoollocal/LocalPoolVector.tpp b/datapoollocal/LocalPoolVector.tpp
index acffebee..98eb27f9 100644
--- a/datapoollocal/LocalPoolVector.tpp
+++ b/datapoollocal/LocalPoolVector.tpp
@@ -7,158 +7,158 @@
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
-		HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
-		pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+        pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
-		lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T, uint16_t vectorSize>
 inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
-		DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
-		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
-				dataSet, setReadWriteMode) {}
+        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+                dataSet, setReadWriteMode) {}
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return readWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return readWithoutLock();
 }
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
+    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
 
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	memset(this->value, 0, vectorSize * sizeof(T));
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    memset(this->value, 0, vectorSize * sizeof(T));
 
-	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
-				localPoolId);
-		return result;
-	}
-	std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-	this->valid = poolEntry->getValid();
-	return RETURN_OK;
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+    this->valid = poolEntry->getValid();
+    return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	this->setValid(valid);
-	return commit(timeoutType, timeoutMs);
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    this->setValid(valid);
+    return commit(timeoutType, timeoutMs);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
-		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-	MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-	return commitWithoutLock();
+        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+    return commitWithoutLock();
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
-			&poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t targetObjectId = hkManager->getCreatorObjectId();
-		reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-				localPoolId);
-		return result;
-	}
-	std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-	poolEntry->setValid(this->valid);
-	return RETURN_OK;
+    if(readWriteMode == pool_rwm_t::VAR_READ) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector",
+                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                localPoolId);
+        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+            &poolEntry);
+    if(result != RETURN_OK) {
+        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
+                localPoolId);
+        return result;
+    }
+    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+    poolEntry->setValid(this->valid);
+    return RETURN_OK;
 }
 
 template<typename T, uint16_t vectorSize>
 inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
-	if(i < vectorSize) {
-		return value[i];
-	}
-	// If this happens, I have to set some value. I consider this
-	// a configuration error, but I wont exit here.
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-			" last value!" << std::endl;
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
 #else
-	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n");
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
 #endif
-	return value[vectorSize - 1];
+    return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
 inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
-	if(i < vectorSize) {
-		return value[i];
-	}
-	// If this happens, I have to set some value. I consider this
-	// a configuration error, but I wont exit here.
+    if(i < vectorSize) {
+        return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-			" last value!" << std::endl;
+    sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+            " last value!" << std::endl;
 #else
-	sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
-			" last value!\n");
+    sif::printWarning("LocalPoolVector: Invalid index. Setting or returning"
+            " last value!\n");
 #endif
-	return value[vectorSize - 1];
+    return value[vectorSize - 1];
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-		size_t* size, size_t maxSize,
-		SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-	}
-	return result;
+        size_t* size, size_t maxSize,
+        SerializeIF::Endianness streamEndianness) const {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
+                maxSize, streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
 }
 
 template<typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-	return vectorSize * SerializeAdapter::getSerializedSize(value);
+    return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-		const uint8_t** buffer, size_t* size,
-		SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t i = 0; i < vectorSize; i++) {
-		result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			break;
-		}
-	}
-	return result;
+        const uint8_t** buffer, size_t* size,
+        SerializeIF::Endianness streamEndianness) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+    for (uint16_t i = 0; i < vectorSize; i++) {
+        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+                streamEndianness);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            break;
+        }
+    }
+    return result;
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 6a816c1f..509aaae9 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -10,38 +10,38 @@
  */
 class PoolReadHelper {
 public:
-	PoolReadHelper(ReadCommitIF* readObject,
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t mutexTimeout = 20):
-			readObject(readObject), mutexTimeout(mutexTimeout) {
-		if(readObject != nullptr) {
-			readResult = readObject->read(timeoutType, mutexTimeout);
+    PoolReadHelper(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 FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "PoolReadHelper: Read failed!" << std::endl;
+            sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #else
-			sif::printError("PoolReadHelper: Read failed!\n");
+            sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-		}
-	}
+        }
+    }
 
-	ReturnValue_t getReadResult() const {
-		return readResult;
-	}
+    ReturnValue_t getReadResult() const {
+        return readResult;
+    }
 
-	~PoolReadHelper() {
-		if(readObject != nullptr) {
-			readObject->commit(timeoutType, mutexTimeout);
-		}
+    ~PoolReadHelper() {
+        if(readObject != nullptr) {
+            readObject->commit(timeoutType, mutexTimeout);
+        }
 
-	}
+    }
 
 private:
-	ReadCommitIF* readObject = nullptr;
-	ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
-	MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeout = 20;
+    ReadCommitIF* readObject = nullptr;
+    ReturnValue_t readResult = HasReturnvaluesIF::RETURN_OK;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t mutexTimeout = 20;
 };
 
 
diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index e6d6257e..6c70046d 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -9,75 +9,75 @@
 
 class ProvidesDataPoolSubscriptionIF {
 public:
-	virtual ~ProvidesDataPoolSubscriptionIF(){};
+    virtual ~ProvidesDataPoolSubscriptionIF(){};
 
-	/**
-	 * @brief   Subscribe for the generation of periodic packets.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator
-	 * to generate housekeeping packets which are downlinked directly.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
-			bool enableReporting,
-			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for the generation of periodic packets.
+     * @details
+     * This subscription mechanism will generally be used by the data creator
+     * to generate housekeeping packets which are downlinked directly.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid,
+            bool enableReporting,
+            float collectionInterval, bool isDiagnostics,
+            object_id_t packetDestination) = 0;
 
 
-	/**
-	 * @brief   Subscribe for the  generation of packets if the dataset
-	 *          is marked as changed.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator.
-	 * @param sid
-	 * @param isDiagnostics
-	 * @param packetDestination
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
-			bool reportingEnabled,
-			bool isDiagnostics,
-			object_id_t packetDestination) = 0;
+    /**
+     * @brief   Subscribe for the  generation of packets if the dataset
+     *          is marked as changed.
+     * @details
+     * This subscription mechanism will generally be used by the data creator.
+     * @param sid
+     * @param isDiagnostics
+     * @param packetDestination
+     * @return
+     */
+    virtual ReturnValue_t subscribeForUpdatePackets(sid_t sid,
+            bool reportingEnabled,
+            bool isDiagnostics,
+            object_id_t packetDestination) = 0;
 
 
-	/**
-	 * @brief   Subscribe for a notification message which will be sent
-	 *          if a dataset has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param setId     Set ID of the set to receive update messages from.
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
-			object_id_t destinationObject,
-			MessageQueueId_t targetQueueId,
-			bool generateSnapshot) = 0;
+    /**
+     * @brief   Subscribe for a notification message which will be sent
+     *          if a dataset has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param setId     Set ID of the set to receive update messages from.
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
 
-	/**
-	 * @brief   Subscribe for an notification message which will be sent if a
-	 *          pool variable has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param localPoolId Pool ID of the pool variable
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	virtual ReturnValue_t subscribeForVariableUpdateMessages(
-			const lp_id_t localPoolId,
-			object_id_t destinationObject,
-			MessageQueueId_t targetQueueId,
-			bool generateSnapshot) = 0;
+    /**
+     * @brief   Subscribe for an notification message which will be sent if a
+     *          pool variable has changed.
+     * @details
+     * This subscription mechanism will generally be used internally by
+     * other software components.
+     * @param localPoolId Pool ID of the pool variable
+     * @param destinationObject
+     * @param targetQueueId
+     * @param generateSnapshot If this is set to true, a copy of the current
+     * data with a timestamp will be generated and sent via message.
+     * Otherwise, only an notification message is sent.
+     * @return
+     */
+    virtual ReturnValue_t subscribeForVariableUpdateMessages(
+            const lp_id_t localPoolId,
+            object_id_t destinationObject,
+            MessageQueueId_t targetQueueId,
+            bool generateSnapshot) = 0;
 
 };
 
diff --git a/datapoollocal/SharedLocalDataSet.h b/datapoollocal/SharedLocalDataSet.h
index 713d435b..83f2a72f 100644
--- a/datapoollocal/SharedLocalDataSet.h
+++ b/datapoollocal/SharedLocalDataSet.h
@@ -13,7 +13,8 @@
  *
  * TODO: override and protect read, commit and some other calls used by pool manager.
  */
-class SharedLocalDataSet: public SystemObject,
+class SharedLocalDataSet:
+        public SystemObject,
         public LocalPoolDataSetBase,
         public SharedDataSetIF {
 public:
diff --git a/datapoollocal/StaticLocalDataSet.h b/datapoollocal/StaticLocalDataSet.h
index a637e360..0e51fb5b 100644
--- a/datapoollocal/StaticLocalDataSet.h
+++ b/datapoollocal/StaticLocalDataSet.h
@@ -20,26 +20,24 @@
 template <uint8_t NUM_VARIABLES>
 class StaticLocalDataSet: public LocalPoolDataSetBase {
 public:
-	/**
-	 * Constructor used by data owner and creator like device handlers.
-	 * This constructor also initialized the components required for
-	 * periodic handling.
-	 * @param hkOwner
-	 * @param setId
-	 */
-    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner,
-    		uint32_t setId): LocalPoolDataSetBase(hkOwner, setId, nullptr,
-            NUM_VARIABLES) {
+    /**
+     * Constructor used by data owner and creator like device handlers.
+     * This constructor also initialized the components required for
+     * periodic handling.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId):
+            LocalPoolDataSetBase(hkOwner, setId, nullptr, NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
     }
 
-	/**
-	 * Constructor used by data users like controllers.
-	 * @param hkOwner
-	 * @param setId
-	 */
-    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr,
-            NUM_VARIABLES) {
+    /**
+     * Constructor used by data users like controllers.
+     * @param hkOwner
+     * @param setId
+     */
+    StaticLocalDataSet(sid_t sid): LocalPoolDataSetBase(sid, nullptr, NUM_VARIABLES) {
         this->setContainer(poolVarList.data());
     }
 
diff --git a/datapoollocal/localPoolDefinitions.h b/datapoollocal/localPoolDefinitions.h
index 3ff1feed..ff44fb8e 100644
--- a/datapoollocal/localPoolDefinitions.h
+++ b/datapoollocal/localPoolDefinitions.h
@@ -40,8 +40,8 @@ union sid_t {
     sid_t(): raw(INVALID_SID) {}
 
     sid_t(object_id_t objectId, uint32_t setId):
-            objectId(objectId),
-            ownerSetId(setId) {}
+        objectId(objectId),
+        ownerSetId(setId) {}
 
     struct {
         object_id_t objectId ;
@@ -75,26 +75,26 @@ union sid_t {
  * and 4 byte local pool ID.
  */
 union gp_id_t {
-	static constexpr uint64_t INVALID_GPID = -1;
+    static constexpr uint64_t INVALID_GPID = -1;
     static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-	static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
+    static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-	gp_id_t(): raw(INVALID_GPID) {}
+    gp_id_t(): raw(INVALID_GPID) {}
 
-	gp_id_t(object_id_t objectId, lp_id_t localPoolId):
-			objectId(objectId),
-			localPoolId(localPoolId) {}
+    gp_id_t(object_id_t objectId, lp_id_t localPoolId):
+        objectId(objectId),
+        localPoolId(localPoolId) {}
 
-	struct {
-		object_id_t objectId;
-		lp_id_t localPoolId;
-	};
+    struct {
+        object_id_t objectId;
+        lp_id_t localPoolId;
+    };
 
-	uint64_t raw;
+    uint64_t raw;
 
-	bool notSet() const {
-		return raw == INVALID_GPID;
-	}
+    bool notSet() const {
+        return raw == INVALID_GPID;
+    }
 
     bool operator==(const sid_t& other) const {
         return raw == other.raw;

From 3a4b89cc280e6c27759ae58ffa83ecccb28536bc Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:43:53 +0100
Subject: [PATCH 1280/1292] more changes

---
 datapoollocal/ProvidesDataPoolSubscriptionIF.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
index 6c70046d..a0d73b93 100644
--- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@@ -1,10 +1,9 @@
 #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
-#include <fsfw/ipc/messageQueueDefinitions.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-
+#include "localPoolDefinitions.h"
+#include "../ipc/messageQueueDefinitions.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 
 
 class ProvidesDataPoolSubscriptionIF {

From fa49def1cfe54a53e22d1de8136c27dc03aaede3 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 12:53:05 +0100
Subject: [PATCH 1281/1292] indentation

---
 datapoollocal/LocalPoolObjectBase.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.h b/datapoollocal/LocalPoolObjectBase.h
index 44a0c82b..797cf8b5 100644
--- a/datapoollocal/LocalPoolObjectBase.h
+++ b/datapoollocal/LocalPoolObjectBase.h
@@ -17,8 +17,8 @@ class HasLocalDataPoolIF;
  * 			or pool vectors.
  */
 class LocalPoolObjectBase: public PoolVariableIF,
-public HasReturnvaluesIF,
-public MarkChangedIF {
+        public HasReturnvaluesIF,
+        public MarkChangedIF {
 public:
     LocalPoolObjectBase(lp_id_t poolId,
             HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,

From 7ac59c6d188e4773a72a5ee1a8afecbbae487309 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:01:41 +0100
Subject: [PATCH 1282/1292] include fix

---
 devicehandlers/DeviceHandlerIF.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h
index bae68516..fc31cce0 100644
--- a/devicehandlers/DeviceHandlerIF.h
+++ b/devicehandlers/DeviceHandlerIF.h
@@ -1,9 +1,9 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
-#include <fsfw/datapoollocal/localPoolDefinitions.h>
 #include "DeviceHandlerMessage.h"
 
+#include "../datapoollocal/localPoolDefinitions.h"
 #include "../action/HasActionsIF.h"
 #include "../events/Event.h"
 #include "../modes/HasModesIF.h"

From 2e456cebb7278539b6e70c7ff8bf4ad9debb7d6e Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:06:30 +0100
Subject: [PATCH 1283/1292] include fix

---
 datapoollocal/internal/LocalDpManagerAttorney.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
index 1d72f607..9047d158 100644
--- a/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
 
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include "../LocalDataPoolManager.h"
 
 /**
  * @brief	This is a helper class implements the Attorney-Client idiom for access to

From 5710f3824aef3db29ecb72d60b5a6fa101c8b5d8 Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 13:06:57 +0100
Subject: [PATCH 1284/1292] indentation consistent now

---
 .../internal/HasLocalDpIFManagerAttorney.cpp  | 10 ++---
 .../internal/HasLocalDpIFManagerAttorney.h    | 10 ++---
 .../internal/HasLocalDpIFUserAttorney.h       |  6 +--
 .../internal/LocalDpManagerAttorney.h         | 18 ++++----
 .../internal/LocalPoolDataSetAttorney.h       | 44 +++++++++----------
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
index bc07170f..65feda75 100644
--- a/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
@@ -4,15 +4,15 @@
 #include "../HasLocalDataPoolIF.h"
 
 LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
-		sid_t sid) {
-	return clientIF->getDataSetHandle(sid);
+        sid_t sid) {
+    return clientIF->getDataSetHandle(sid);
 }
 
 LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-		lp_id_t localPoolId) {
-	return clientIF->getPoolObjectHandle(localPoolId);
+        lp_id_t localPoolId) {
+    return clientIF->getPoolObjectHandle(localPoolId);
 }
 
 object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
-	return clientIF->getObjectId();
+    return clientIF->getObjectId();
 }
diff --git a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
index ef180b37..dfe333a6 100644
--- a/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
@@ -9,14 +9,14 @@ class LocalPoolObjectBase;
 
 class HasLocalDpIFManagerAttorney {
 
-	static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
+    static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
 
-	static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-			lp_id_t localPoolId);
+    static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
+            lp_id_t localPoolId);
 
-	static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
+    static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
 
-	friend class LocalDataPoolManager;
+    friend class LocalDataPoolManager;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/HasLocalDpIFUserAttorney.h b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
index a07c2d59..77eaa8bd 100644
--- a/datapoollocal/internal/HasLocalDpIFUserAttorney.h
+++ b/datapoollocal/internal/HasLocalDpIFUserAttorney.h
@@ -7,10 +7,10 @@ class AccessPoolManagerIF;
 class HasLocalDpIFUserAttorney {
 private:
 
-	static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
+    static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
 
-	friend class LocalPoolObjectBase;
-	friend class LocalPoolDataSetBase;
+    friend class LocalPoolObjectBase;
+    friend class LocalPoolDataSetBase;
 
 };
 
diff --git a/datapoollocal/internal/LocalDpManagerAttorney.h b/datapoollocal/internal/LocalDpManagerAttorney.h
index 9047d158..bb64fb42 100644
--- a/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/datapoollocal/internal/LocalDpManagerAttorney.h
@@ -15,18 +15,18 @@
  */
 class LocalDpManagerAttorney {
 private:
-	template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
-			lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
-		return manager.fetchPoolEntry(localPoolId, poolEntry);
-	}
+    template<typename T> static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager,
+            lp_id_t localPoolId, PoolEntry<T> **poolEntry) {
+        return manager.fetchPoolEntry(localPoolId, poolEntry);
+    }
 
-	static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
-		return manager.getMutexHandle();
-	}
+    static MutexIF* getMutexHandle(LocalDataPoolManager& manager) {
+        return manager.getMutexHandle();
+    }
 
 
-	template<typename T> friend class LocalPoolVariable;
-	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
+    template<typename T> friend class LocalPoolVariable;
+    template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
diff --git a/datapoollocal/internal/LocalPoolDataSetAttorney.h b/datapoollocal/internal/LocalPoolDataSetAttorney.h
index 9804444a..7a34e9c8 100644
--- a/datapoollocal/internal/LocalPoolDataSetAttorney.h
+++ b/datapoollocal/internal/LocalPoolDataSetAttorney.h
@@ -5,34 +5,34 @@
 
 class LocalPoolDataSetAttorney {
 private:
-	static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
-		set.setDiagnostic(diagnostics);
-	}
+    static void setDiagnostic(LocalPoolDataSetBase& set, bool diagnostics) {
+        set.setDiagnostic(diagnostics);
+    }
 
-	static bool isDiagnostics(LocalPoolDataSetBase& set) {
-		return set.isDiagnostics();
-	}
+    static bool isDiagnostics(LocalPoolDataSetBase& set) {
+        return set.isDiagnostics();
+    }
 
-	static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-			uint32_t minimumPeriodicIntervalMs,
-			bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
-		set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
-				nonDiagIntervalFactor);
-	}
+    static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
+            uint32_t minimumPeriodicIntervalMs,
+            bool isDiagnostics, uint8_t nonDiagIntervalFactor = 5) {
+        set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs, isDiagnostics,
+                nonDiagIntervalFactor);
+    }
 
-	static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
-		set.setReportingEnabled(enabled);
-	}
+    static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
+        set.setReportingEnabled(enabled);
+    }
 
-	static bool getReportingEnabled(LocalPoolDataSetBase& set) {
-		return set.getReportingEnabled();
-	}
+    static bool getReportingEnabled(LocalPoolDataSetBase& set) {
+        return set.getReportingEnabled();
+    }
 
-	static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
-		return set.periodicHelper;
-	}
+    static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
+        return set.periodicHelper;
+    }
 
-	friend class LocalDataPoolManager;
+    friend class LocalDataPoolManager;
 };
 
 

From 0cd457725e8edae8b3c8bc580262f77fd09ab82d Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 13 Jan 2021 21:35:17 +0100
Subject: [PATCH 1285/1292] trying to suppress certain warnings

---
 CMakeLists.txt             | 21 +++++++++++----------
 datapool/PoolDataSetBase.h | 17 ++++++++---------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 587e6701..76542842 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -107,14 +107,16 @@ else()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-	set(WARNING_FLAGS
-		-Wall
-		-Wextra
-		-Wshadow=local
-		-Wimplicit-fallthrough=1
-		-Wno-unused-parameter
-		-Wno-psabi
-	)
+    if(NOT DEFINED FSFW_WARNING_FLAGS)
+	   set(FSFW_WARNING_FLAGS
+		  -Wall
+		  -Wextra
+		  -Wshadow=local
+		  -Wimplicit-fallthrough=1
+		  -Wno-unused-parameter
+		  -Wno-psabi
+        )
+	endif()
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
@@ -135,8 +137,7 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 	${FSFW_CONFIG_PATH_ABSOLUTE}
 )
 
-# Machine specific options can be set with the ABI_FLAGS variable.
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
-	${WARNING_FLAGS}
+	${FSFW_WARNING_FLAGS}
 	${COMPILER_FLAGS}
 )
diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index d741dabc..65a6651e 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -120,17 +120,16 @@ public:
 	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:
 
-	/**
-	 * 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);
-
 	/**
 	 * @brief	The fill_count attribute ensures that the variables
 	 * 			register in the correct array position and that the maximum

From 7bb570540baea7f769c5f4b995d4709ce975b1ff Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:27:35 +0100
Subject: [PATCH 1286/1292] added hk service

---
 pus/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index 758c2629..c0e00448 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,6 +5,7 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
+		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From a5e20657c6eb22043c4313a00fd4c4f4bcf2e98a Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:31:26 +0100
Subject: [PATCH 1287/1292] resolved merge conflicts

---
 datapoollocal/LocalPoolVariable.tpp | 55 -----------------------------
 pus/CMakeLists.txt                  |  1 -
 2 files changed, 56 deletions(-)

diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 7eea2a46..35de4ebd 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -32,37 +32,6 @@ inline ReturnValue_t LocalPoolVariable<T>::read(
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-<<<<<<< HEAD
-	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	// Actually this should never happen..
-	if(poolEntry->address == nullptr) {
-		result = PoolVariableIF::INVALID_POOL_ENTRY;
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	this->value = *(poolEntry->address);
-	this->valid = poolEntry->valid;
-	return RETURN_OK;
-=======
     if(readWriteMode == pool_rwm_t::VAR_WRITE) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVector",
@@ -94,7 +63,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
     this->value = *(poolEntry->getDataPtr());
     this->valid = poolEntry->getValid();
     return RETURN_OK;
->>>>>>> upstream/mueller/master
 }
 
 template<typename T>
@@ -113,28 +81,6 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(
 
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-<<<<<<< HEAD
-	if(readWriteMode == pool_rwm_t::VAR_READ) {
-		object_id_t targetObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVector",
-				PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
-				localPoolId);
-		return PoolVariableIF::INVALID_READ_WRITE_MODE;
-	}
-
-	PoolEntry<T>* poolEntry = nullptr;
-	ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
-	if(result != RETURN_OK) {
-		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-		reportReadCommitError("LocalPoolVariable", result,
-				false, ownerObjectId, localPoolId);
-		return result;
-	}
-
-	*(poolEntry->address) = this->value;
-	poolEntry->valid = this->valid;
-	return RETURN_OK;
-=======
     if(readWriteMode == pool_rwm_t::VAR_READ) {
         object_id_t targetObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVector",
@@ -157,7 +103,6 @@ inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
     *(poolEntry->getDataPtr()) = this->value;
     poolEntry->setValid(this->valid);
     return RETURN_OK;
->>>>>>> upstream/mueller/master
 }
 
 template<typename T>
diff --git a/pus/CMakeLists.txt b/pus/CMakeLists.txt
index c0e00448..758c2629 100644
--- a/pus/CMakeLists.txt
+++ b/pus/CMakeLists.txt
@@ -5,7 +5,6 @@ target_sources(${LIB_FSFW_NAME}
 		Service17Test.cpp
 		Service1TelecommandVerification.cpp
 		Service2DeviceAccess.cpp
-		Service3Housekeeping.cpp
 		Service5EventReporting.cpp
 		Service8FunctionManagement.cpp
 		Service9TimeManagement.cpp

From 67ce8d2e24dcb8636f2dd4b04e3d275bb18a7fe4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:50:33 +0100
Subject: [PATCH 1288/1292] improved internal interface

---
 controller/ExtendedControllerBase.cpp   |  8 ++------
 controller/ExtendedControllerBase.h     | 11 +----------
 datapoollocal/HasLocalDataPoolIF.h      | 25 +++++++++++++++++++------
 devicehandlers/DeviceHandlerBase.cpp    |  8 ++------
 devicehandlers/DeviceHandlerBase.h      |  8 ++------
 internalError/InternalErrorReporter.cpp |  8 ++------
 internalError/InternalErrorReporter.h   |  3 +--
 7 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index e0aec63a..397c8c10 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -26,10 +26,6 @@ object_id_t ExtendedControllerBase::getObjectId() const {
     return SystemObject::getObjectId();
 }
 
-AccessPoolManagerIF* ExtendedControllerBase::getAccessorHandle() {
-    return &poolManager;
-}
-
 uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
     return this->executingTask->getPeriodMs();
 }
@@ -114,6 +110,6 @@ LocalPoolDataSetBase* ExtendedControllerBase::getDataSetHandle(sid_t sid) {
     return nullptr;
 }
 
-ProvidesDataPoolSubscriptionIF* ExtendedControllerBase::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* ExtendedControllerBase::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h
index b2760514..bcb414dd 100644
--- a/controller/ExtendedControllerBase.h
+++ b/controller/ExtendedControllerBase.h
@@ -32,20 +32,10 @@ public:
     virtual ReturnValue_t performOperation(uint8_t opCode) override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;
 
-    /**
-     * Provides a subscription interface for objects which required updates on changed
-     * controller variables or datasets
-     * @return
-     */
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-
 protected:
     LocalDataPoolManager poolManager;
     ActionHelper actionHelper;
 
-    //! Accessor handle required for internal handling
-    AccessPoolManagerIF* getAccessorHandle() override;
-
     /**
      * Implemented by child class. Handle all command messages which are
      * not health, mode, action or housekeeping messages.
@@ -68,6 +58,7 @@ protected:
             size_t size) override;
 
     /** HasLocalDatapoolIF overrides */
+    virtual LocalDataPoolManager* getHkManagerHandle() override;
     virtual object_id_t getObjectId() const override;
     virtual ReturnValue_t initializeLocalDataPool(
             localpool::DataPool& localDataPoolMap,
diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 3d822650..1d87d47c 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -2,6 +2,7 @@
 #define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
 
 #include "localPoolDefinitions.h"
+#include "LocalDataPoolManager.h"
 
 #include "../datapool/PoolEntryIF.h"
 #include "../serviceinterface/ServiceInterface.h"
@@ -14,7 +15,6 @@ class AccessPoolManagerIF;
 class ProvidesDataPoolSubscriptionIF;
 class LocalPoolDataSetBase;
 class LocalPoolObjectBase;
-class LocalDataPoolManager;
 
 /**
  * @brief 		This interface is implemented by classes which posses a local data pool (not the
@@ -104,19 +104,32 @@ public:
      * which allows subscriptions to dataset and variable updates in form of messages.
      * The consumers can then read the most recent variable value by calling read with
      * an own pool variable or set instance or using the deserialized snapshot data.
+     * Returns the HK manager casted to the required interface by default.
      * @return
      */
-    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() = 0;
+    virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() {
+        return getHkManagerHandle();
+    }
 
 protected:
 
     /**
-     * Accessor handle required for internal handling. Not intended for users and therefore
-     * declared protected. Users should instead use pool variables, sets or the subscription
-     * interface to access pool entries.
+     * Every class implementing this interface should have a local data pool manager. This
+     * function will return a reference to the manager.
      * @return
      */
-    virtual AccessPoolManagerIF* getAccessorHandle() = 0;
+    virtual LocalDataPoolManager* getHkManagerHandle() = 0;
+
+    /**
+     * Accessor handle required for internal handling. Not intended for users and therefore
+     * declared protected. Users should instead use pool variables, sets or the subscription
+     * interface to access pool entries. Returns the HK manager casted to a different interface
+     * by default.
+     * @return
+     */
+    virtual AccessPoolManagerIF* getAccessorHandle() {
+        return getHkManagerHandle();
+    }
 
     /**
      * This function is used by the pool manager to get a valid dataset
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index c4098525..6092a89f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1483,10 +1483,6 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
 	}
 }
 
-AccessPoolManagerIF* DeviceHandlerBase::getAccessorHandle() {
-	return &poolManager;
-}
-
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 		const char *functionName, ReturnValue_t errorCode,
 		const char *errorPrint) {
@@ -1532,6 +1528,6 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType,
 
 }
 
-ProvidesDataPoolSubscriptionIF* DeviceHandlerBase::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h
index 43f61897..3a993aff 100644
--- a/devicehandlers/DeviceHandlerBase.h
+++ b/devicehandlers/DeviceHandlerBase.h
@@ -518,14 +518,10 @@ protected:
 				LocalDataPoolManager& poolManager) override;
 
 	/**
-	 * Provides the subscription handle which can be used by classes like controllers
-	 * to get messages on data updates.
+	 * Required for HasLocalDataPoolIF, return a handle to the local pool manager.
 	 * @return
 	 */
-	ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-
-	//! Accessor handle required for internal handling.
-	AccessPoolManagerIF* getAccessorHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
 
 	/**
 	 * @brief 	Hook function for child handlers which is called once per
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index bc72ada2..7e5a316c 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -139,10 +139,6 @@ uint32_t InternalErrorReporter::getStoreHits() {
 	return value;
 }
 
-AccessPoolManagerIF* InternalErrorReporter::getAccessorHandle() {
-	return &poolManager;
-}
-
 void InternalErrorReporter::incrementStoreHits() {
 	mutex->lockMutex(timeoutType, timeoutMs);
 	storeHits++;
@@ -201,6 +197,6 @@ void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
 	this->timeoutMs = timeoutMs;
 }
 
-ProvidesDataPoolSubscriptionIF* InternalErrorReporter::getSubscriptionInterface() {
-	return &poolManager;
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
 }
diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h
index ec9134d4..a237418e 100644
--- a/internalError/InternalErrorReporter.h
+++ b/internalError/InternalErrorReporter.h
@@ -45,8 +45,7 @@ public:
             LocalDataPoolManager& poolManager) override;
     virtual dur_millis_t getPeriodicOperationFrequency() const override;
     virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override;
-	AccessPoolManagerIF* getAccessorHandle() override;
+	LocalDataPoolManager* getHkManagerHandle() override;
 
     virtual ReturnValue_t initialize() override;
     virtual ReturnValue_t initializeAfterTaskCreation() override;

From 2c4cd756c6d868a9a1d6e08cb6bfb503012a9cae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 11:58:50 +0100
Subject: [PATCH 1289/1292] updated to new internal interface

---
 .../tests/datapoollocal/LocalPoolOwnerBase.h  | 29 +++++++------------
 1 file changed, 10 insertions(+), 19 deletions(-)

diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index aaccc90e..916b3e45 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -56,7 +56,7 @@ class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
 			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), hkManager(this, messageQueue),
+		SystemObject(objectId), poolManager(this, messageQueue),
 		dataset(this, lpool::testSetId) {
 		messageQueue = new MessageQueueMockBase();
 	}
@@ -72,7 +72,7 @@ public:
 	ReturnValue_t initializeHkManager() {
 		if(not initialized) {
 			initialized = true;
-			return hkManager.initialize(messageQueue);
+			return poolManager.initialize(messageQueue);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -80,7 +80,7 @@ public:
 	ReturnValue_t initializeHkManagerAfterTaskCreation() {
 		if(not initializedAfterTaskCreation) {
 			initializedAfterTaskCreation = true;
-			return hkManager.initializeAfterTaskCreation();
+			return poolManager.initializeAfterTaskCreation();
 		}
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -109,17 +109,8 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	/**
-	 * This function can be used by data pool consumers to retrieve a handle
-	 * which allows subscriptions to dataset and variable updates.
-	 * @return
-	 */
-	virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() override {
-		return &hkManager;
-	}
-
-	virtual AccessPoolManagerIF* getAccessorHandle() override {
-		return &hkManager;
+	LocalDataPoolManager* getHkManagerHandle() override {
+	    return &poolManager;
 	}
 
 	uint32_t getPeriodicOperationFrequency() const override {
@@ -163,25 +154,25 @@ public:
 	}
 
 	ReturnValue_t subscribeWrapperSetUpdate() {
-		return hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+		return poolManager.subscribeForSetUpdateMessages(lpool::testSetId,
 				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
 	}
 
 	ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
-		return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
+		return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics,
 				false, objects::HK_RECEIVER_MOCK);
 	}
 
 	ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
-		return hkManager.subscribeForVariableUpdateMessages(localPoolId,
+		return poolManager.subscribeForVariableUpdateMessages(localPoolId,
 				MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false);
 	}
 
 	void resetSubscriptionList() {
-		hkManager.clearReceiversList();
+		poolManager.clearReceiversList();
 	}
 
-	LocalDataPoolManager hkManager;
+	LocalDataPoolManager poolManager;
 	LocalPoolTestDataSet dataset;
 private:
 

From 549afaee1d5713de7700445d771a8ada95e96a2d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:02:20 +0100
Subject: [PATCH 1290/1292] initialized member

---
 datapool/PoolDataSetBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datapool/PoolDataSetBase.h b/datapool/PoolDataSetBase.h
index 65a6651e..75654146 100644
--- a/datapool/PoolDataSetBase.h
+++ b/datapool/PoolDataSetBase.h
@@ -162,7 +162,7 @@ protected:
 
 private:
 	bool protectEveryReadCommitCall = false;
-	MutexIF::TimeoutType timeoutTypeForSingleVars;
+	MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
 	uint32_t mutexTimeoutForSingleVars = 20;
 
 	ReturnValue_t readVariable(uint16_t count);

From 1996215bc7c4e82480f5ef64a3aab8a22d4d9539 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:15:43 +0100
Subject: [PATCH 1291/1292] small bugfix

---
 datapoollocal/PoolReadHelper.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/datapoollocal/PoolReadHelper.h b/datapoollocal/PoolReadHelper.h
index 509aaae9..b863a0f1 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapoollocal/PoolReadHelper.h
@@ -16,13 +16,15 @@ public:
                 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;
+                sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #else
-            sif::printError("PoolReadHelper: Read failed!\n");
+                sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+            }
         }
     }
 

From d6b0af3be7a61ca2f00a1158b770d8a0a9c99878 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 14 Jan 2021 12:21:40 +0100
Subject: [PATCH 1292/1292] moved read helper into correct folder

---
 {datapoollocal => datapool}/PoolReadHelper.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename {datapoollocal => datapool}/PoolReadHelper.h (88%)

diff --git a/datapoollocal/PoolReadHelper.h b/datapool/PoolReadHelper.h
similarity index 88%
rename from datapoollocal/PoolReadHelper.h
rename to datapool/PoolReadHelper.h
index b863a0f1..5c3153bb 100644
--- a/datapoollocal/PoolReadHelper.h
+++ b/datapool/PoolReadHelper.h
@@ -1,7 +1,7 @@
-#ifndef FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
-#define FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_
+#ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
+#define FSFW_DATAPOOL_POOLREADHELPER_H_
 
-#include "LocalPoolDataSetBase.h"
+#include "ReadCommitIF.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include <FSFWConfig.h>
 
@@ -48,4 +48,4 @@ private:
 
 
 
-#endif /* FSFW_DATAPOOLLOCAL_POOLREADHELPER_H_ */
+#endif /* FSFW_DATAPOOL_POOLREADHELPER_H_ */